1 /*
2 * Copyright (c) 2021-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 <hdf_base.h>
17 #include <hdf_log.h>
18 #include <iproxy_broker.h>
19 #include <iremote_stub.h>
20 #include <iservice_registry.h>
21 #include <object_collector.h>
22
23 #include "iservmgr_hdi.h"
24
25 #define HDF_LOG_TAG hdi_servmgr_client
26
27 namespace OHOS {
28 namespace HDI {
29 namespace ServiceManager {
30 namespace V1_0 {
31 constexpr int DEVICE_SERVICE_MANAGER_SA_ID = 5100;
32 constexpr int DEVSVC_MANAGER_GET_SERVICE = 3;
33 constexpr int DEVSVC_MANAGER_REGISTER_SVCLISTENER = 4;
34 constexpr int DEVSVC_MANAGER_UNREGISTER_SVCLISTENER = 5;
35 constexpr int DEVSVC_MANAGER_LIST_ALL_SERVICE = 6;
36
37 class ServiceManagerProxy : public IProxyBroker<IServiceManager> {
38 public:
ServiceManagerProxy(const sptr<IRemoteObject> & impl)39 explicit ServiceManagerProxy(const sptr<IRemoteObject> &impl) : IProxyBroker<IServiceManager>(impl) {}
~ServiceManagerProxy()40 ~ServiceManagerProxy() {}
41
42 sptr<IRemoteObject> GetService(const char *serviceName) override;
43 int32_t ListAllService(std::vector<HdiServiceInfo> &serviceInfos) override;
44 int32_t RegisterServiceStatusListener(sptr<IServStatListener> listener, uint16_t deviceClass) override;
45 int32_t UnregisterServiceStatusListener(sptr<IServStatListener> listener) override;
46
47 private:
48 static inline BrokerDelegator<ServiceManagerProxy> delegator_;
49 };
50
Get()51 sptr<IServiceManager> IServiceManager::Get()
52 {
53 auto saManager = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
54 if (saManager == nullptr) {
55 HDF_LOGE("failed to get sa manager");
56 return nullptr;
57 }
58 sptr<IRemoteObject> remote = saManager->GetSystemAbility(DEVICE_SERVICE_MANAGER_SA_ID);
59 if (remote != nullptr) {
60 return new ServiceManagerProxy(remote);
61 }
62
63 HDF_LOGE("failed to get sa hdf service manager");
64 return nullptr;
65 }
66
RegisterServiceStatusListener(::OHOS::sptr<IServStatListener> listener,uint16_t deviceClass)67 int32_t ServiceManagerProxy::RegisterServiceStatusListener(
68 ::OHOS::sptr<IServStatListener> listener, uint16_t deviceClass)
69 {
70 MessageParcel data;
71 MessageParcel reply;
72 MessageOption option;
73
74 if (!data.WriteInterfaceToken(GetDescriptor()) || !data.WriteUint16(deviceClass) ||
75 !data.WriteRemoteObject(listener->AsObject())) {
76 return HDF_FAILURE;
77 }
78
79 int status = Remote()->SendRequest(DEVSVC_MANAGER_REGISTER_SVCLISTENER, data, reply, option);
80 if (status) {
81 HDF_LOGE("failed to register servstat listener, %{public}d", status);
82 }
83 return status;
84 }
85
UnregisterServiceStatusListener(::OHOS::sptr<IServStatListener> listener)86 int32_t ServiceManagerProxy::UnregisterServiceStatusListener(::OHOS::sptr<IServStatListener> listener)
87 {
88 MessageParcel data;
89 MessageParcel reply;
90 MessageOption option;
91
92 if (!data.WriteInterfaceToken(GetDescriptor()) || !data.WriteRemoteObject(listener->AsObject())) {
93 return HDF_FAILURE;
94 }
95
96 int status = Remote()->SendRequest(DEVSVC_MANAGER_UNREGISTER_SVCLISTENER, data, reply, option);
97 if (status) {
98 HDF_LOGE("failed to unregister servstat listener, %{public}d", status);
99 }
100 return status;
101 }
102
GetService(const char * serviceName)103 sptr<IRemoteObject> ServiceManagerProxy::GetService(const char *serviceName)
104 {
105 MessageParcel data;
106 MessageParcel reply;
107 if (!data.WriteInterfaceToken(GetDescriptor()) || !data.WriteCString(serviceName)) {
108 return nullptr;
109 }
110
111 MessageOption option;
112 int status = Remote()->SendRequest(DEVSVC_MANAGER_GET_SERVICE, data, reply, option);
113 if (status) {
114 HDF_LOGE("get hdi service %{public}s failed, %{public}d", serviceName, status);
115 return nullptr;
116 }
117 HDF_LOGD("get hdi service %{public}s success ", serviceName);
118 return reply.ReadRemoteObject();
119 }
120
HdfDevMgrDbgFillServiceInfo(std::vector<HdiServiceInfo> & serviceInfos,MessageParcel & reply)121 static void HdfDevMgrDbgFillServiceInfo(std::vector<HdiServiceInfo> &serviceInfos, MessageParcel &reply)
122 {
123 while (true) {
124 HdiServiceInfo info;
125 const char *servName = reply.ReadCString();
126 if (servName == nullptr) {
127 break;
128 }
129 info.serviceName = servName;
130 info.devClass = reply.ReadUint16();
131 info.devId = reply.ReadUint32();
132 serviceInfos.push_back(info);
133 }
134 return;
135 }
136
ListAllService(std::vector<HdiServiceInfo> & serviceInfos)137 int32_t ServiceManagerProxy::ListAllService(std::vector<HdiServiceInfo> &serviceInfos)
138 {
139 MessageParcel data;
140 MessageParcel reply;
141 if (!data.WriteInterfaceToken(GetDescriptor())) {
142 return HDF_FAILURE;
143 }
144
145 MessageOption option;
146 int status = Remote()->SendRequest(DEVSVC_MANAGER_LIST_ALL_SERVICE, data, reply, option);
147 if (status != HDF_SUCCESS) {
148 HDF_LOGE("list all service info failed, %{public}d", status);
149 return status;
150 } else {
151 HdfDevMgrDbgFillServiceInfo(serviceInfos, reply);
152 }
153 HDF_LOGD("get all service info success");
154 return status;
155 }
156 } // namespace V1_0
157 } // namespace ServiceManager
158 } // namespace HDI
159 } // namespace OHOS