1 /*
2 * Copyright (c) 2022 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 "ipc_client_manager.h"
17
18 #include "device_manager_notify.h"
19 #include "device_manager_impl.h"
20 #include "dm_constants.h"
21 #include "dm_log.h"
22 #include "ipc_client_server_proxy.h"
23 #include "ipc_client_stub.h"
24 #include "ipc_register_listener_req.h"
25 #include "ipc_remote_broker.h"
26 #include "iremote_object.h"
27 #include "iservice_registry.h"
28 #include "system_ability_definition.h"
29
30 namespace OHOS {
31 namespace DistributedHardware {
OnRemoteDied(const wptr<IRemoteObject> & remote)32 void DmDeathRecipient::OnRemoteDied(const wptr<IRemoteObject> &remote)
33 {
34 LOGW("DmDeathRecipient : OnRemoteDied");
35 (void)remote;
36 DeviceManagerImpl::GetInstance().OnDmServiceDied();
37 DeviceManagerNotify::GetInstance().OnRemoteDied();
38 }
39
ClientInit()40 int32_t IpcClientManager::ClientInit()
41 {
42 LOGI("InitDeviceManagerService start");
43 if (dmInterface_ != nullptr) {
44 LOGI("DeviceManagerService Already Init");
45 return DM_OK;
46 }
47
48 auto samgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
49 if (samgr == nullptr) {
50 LOGE("Get SystemAbilityManager Failed");
51 return ERR_DM_INIT_FAILED;
52 }
53
54 auto object = samgr->CheckSystemAbility(DISTRIBUTED_HARDWARE_DEVICEMANAGER_SA_ID);
55 if (object == nullptr) {
56 LOGE("Get DeviceManager SystemAbility Failed");
57 return ERR_DM_INIT_FAILED;
58 }
59
60 if (dmRecipient_ == nullptr) {
61 dmRecipient_ = sptr<DmDeathRecipient>(new DmDeathRecipient());
62 }
63 if (!object->AddDeathRecipient(dmRecipient_)) {
64 LOGE("InitDeviceManagerService: AddDeathRecipient Failed");
65 }
66 dmInterface_ = iface_cast<IpcRemoteBroker>(object);
67 LOGI("DeviceManager::InitDeviceManagerService completed");
68 return DM_OK;
69 }
70
Init(const std::string & pkgName)71 int32_t IpcClientManager::Init(const std::string &pkgName)
72 {
73 if (pkgName.empty()) {
74 LOGE("Invalid parameter, pkgName is empty.");
75 return ERR_DM_INPUT_PARA_INVALID;
76 }
77 std::lock_guard<std::mutex> autoLock(lock_);
78 int32_t ret = ClientInit();
79 if (ret != DM_OK) {
80 LOGE("InitDeviceManager Failed with ret %d", ret);
81 return ret;
82 }
83
84 sptr<IpcClientStub> listener = sptr<IpcClientStub>(new IpcClientStub());
85 std::shared_ptr<IpcRegisterListenerReq> req = std::make_shared<IpcRegisterListenerReq>();
86 std::shared_ptr<IpcRsp> rsp = std::make_shared<IpcRsp>();
87 req->SetPkgName(pkgName);
88 req->SetListener(listener);
89 ret = dmInterface_->SendCmd(REGISTER_DEVICE_MANAGER_LISTENER, req, rsp);
90 if (ret != DM_OK) {
91 LOGE("InitDeviceManager: RegisterDeviceManagerListener Failed with ret %d", ret);
92 return ret;
93 }
94 ret = rsp->GetErrCode();
95 if (ret != DM_OK) {
96 return ret;
97 }
98 dmListener_[pkgName] = listener;
99 LOGI("completed, pkgName: %s", pkgName.c_str());
100 return DM_OK;
101 }
102
UnInit(const std::string & pkgName)103 int32_t IpcClientManager::UnInit(const std::string &pkgName)
104 {
105 if (pkgName.empty()) {
106 LOGE("Invalid parameter, pkgName is empty.");
107 return ERR_DM_INPUT_PARA_INVALID;
108 }
109 LOGI("UnInit in, pkgName %s", pkgName.c_str());
110 if (dmInterface_ == nullptr) {
111 LOGE("DeviceManager not Init");
112 return ERR_DM_INIT_FAILED;
113 }
114
115 std::lock_guard<std::mutex> autoLock(lock_);
116 if (dmListener_.count(pkgName) > 0) {
117 std::shared_ptr<IpcReq> req = std::make_shared<IpcReq>();
118 std::shared_ptr<IpcRsp> rsp = std::make_shared<IpcRsp>();
119 req->SetPkgName(pkgName);
120 int32_t ret = dmInterface_->SendCmd(UNREGISTER_DEVICE_MANAGER_LISTENER, req, rsp);
121 if (ret != DM_OK) {
122 LOGE("UnRegisterDeviceManagerListener Failed with ret %d", ret);
123 return ret;
124 }
125 dmListener_.erase(pkgName);
126 }
127 if (dmListener_.empty()) {
128 if (dmRecipient_ != nullptr) {
129 dmInterface_->AsObject()->RemoveDeathRecipient(dmRecipient_);
130 dmRecipient_ = nullptr;
131 }
132 dmInterface_ = nullptr;
133 }
134 LOGI("completed, pkgName: %s", pkgName.c_str());
135 return DM_OK;
136 }
137
SendRequest(int32_t cmdCode,std::shared_ptr<IpcReq> req,std::shared_ptr<IpcRsp> rsp)138 int32_t IpcClientManager::SendRequest(int32_t cmdCode, std::shared_ptr<IpcReq> req, std::shared_ptr<IpcRsp> rsp)
139 {
140 if (cmdCode < 0 || cmdCode >= IPC_MSG_BUTT || req == nullptr || rsp == nullptr) {
141 LOGE("IpcClientManager::SendRequest cmdCode param invalid!");
142 return ERR_DM_INPUT_PARA_INVALID;
143 }
144 LOGI("IpcClientManager::SendRequest in");
145 std::string pkgName = req->GetPkgName();
146 if (!IsInit(pkgName)) {
147 LOGE("IpcClientManager::SendRequest ERR_DM_INIT_FAILED");
148 return ERR_DM_INIT_FAILED;
149 }
150
151 LOGI("IpcClientManager::SendRequest cmdCode: %d", cmdCode);
152 return dmInterface_->SendCmd(cmdCode, req, rsp);
153 }
154
IsInit(const std::string & pkgName)155 bool IpcClientManager::IsInit(const std::string &pkgName)
156 {
157 if (dmInterface_ == nullptr) {
158 LOGE("DeviceManager not Init");
159 return false;
160 }
161
162 return true;
163 }
164
OnDmServiceDied()165 int32_t IpcClientManager::OnDmServiceDied()
166 {
167 LOGI("IpcClientManager::OnDmServiceDied begin");
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 LOGI("IpcClientManager::OnDmServiceDied complete");
178 return DM_OK;
179 }
180 } // namespace DistributedHardware
181 } // namespace OHOS
182