1 /*
2 * Copyright (c) 2021 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 "thermal_srv_stub.h"
17
18 #include "message_parcel.h"
19 #include "string_ex.h"
20
21 #include "ithermal_action_callback.h"
22 #include "ithermal_temp_callback.h"
23 #include "ithermal_level_callback.h"
24 #include "thermal_srv_sensor_info.h"
25 #include "thermal_common.h"
26 #include "xcollie.h"
27
28 namespace OHOS {
29 namespace PowerMgr {
30 namespace {
31 constexpr int PARAM_MAX_NUM = 10;
32 }
OnRemoteRequest(uint32_t code,MessageParcel & data,MessageParcel & reply,MessageOption & option)33 int ThermalSrvStub::OnRemoteRequest(uint32_t code, MessageParcel& data, MessageParcel& reply, MessageOption& option)
34 {
35 THERMAL_HILOGD(COMP_SVC,
36 "ThermalSrvStub::OnRemoteRequest, cmd = %{public}d, flags = %{public}d",
37 code, option.GetFlags());
38 std::u16string descriptor = ThermalSrvStub::GetDescriptor();
39 std::u16string remoteDescriptor = data.ReadInterfaceToken();
40 if (descriptor != remoteDescriptor) {
41 THERMAL_HILOGE(COMP_SVC, "ThermalSrvStub::OnRemoteRequest failed, descriptor is not matched!");
42 return E_GET_THERMAL_SERVICE_FAILED;
43 }
44 const int DFX_DELAY_MS = 10000;
45 int id = HiviewDFX::XCollie::GetInstance().SetTimer("ThermalSrvStub", DFX_DELAY_MS, nullptr, nullptr,
46 HiviewDFX::XCOLLIE_FLAG_NOOP);
47 int32_t ret = CheckRequestCode(code, data, reply, option);
48 HiviewDFX::XCollie::GetInstance().CancelTimer(id);
49 return ret;
50 }
51
CheckRequestCode(const uint32_t code,MessageParcel & data,MessageParcel & reply,MessageOption & option)52 int32_t ThermalSrvStub::CheckRequestCode(const uint32_t code, MessageParcel& data, MessageParcel& reply,
53 MessageOption& option)
54 {
55 switch (code) {
56 case static_cast<int>(IThermalSrv::REG_THERMAL_TEMP_CALLBACK): {
57 return SubscribeThermalTempCallbackStub(data);
58 }
59 case static_cast<int>(IThermalSrv::UNREG_THERMAL_TEMP_CALLBACK): {
60 return UnSubscribeThermalTempCallbackStub(data);
61 }
62 case static_cast<int>(IThermalSrv::REG_THERMAL_LEVEL_CALLBACK): {
63 return SubscribeThermalLevelCallbackStub(data);
64 }
65 case static_cast<int>(IThermalSrv::UNREG_THERMAL_LEVEL_CALLBACK): {
66 return UnSubscribeThermalLevelCallbackStub(data);
67 }
68 case static_cast<int>(IThermalSrv::REG_THERMAL_ACTION_CALLBACK): {
69 return SubscribeThermalActionCallbackStub(data);
70 }
71 case static_cast<int>(IThermalSrv::UNREG_THERMAL_ACTION_CALLBACK): {
72 return UnSubscribeThermalActionCallbackStub(data);
73 }
74 case static_cast<int>(IThermalSrv::GET_SENSOR_INFO): {
75 return GetThermalSrvSensorInfoStub(data, reply);
76 }
77 case static_cast<int>(IThermalSrv::GET_TEMP_LEVEL): {
78 return GetThermalevelStub(reply);
79 }
80 case static_cast<int>(IThermalSrv::GET_THERMAL_INFO): {
81 return GetThermalInfoStub(reply);
82 }
83 case static_cast<int>(IThermalSrv::SET_SCENE): {
84 return SetSceneStub(data);
85 }
86 case static_cast<int>(IThermalSrv::SHELL_DUMP): {
87 return ShellDumpStub(data, reply);
88 }
89 default: {
90 return IPCObjectStub::OnRemoteRequest(code, data, reply, option);
91 }
92 }
93 }
94
SubscribeThermalTempCallbackStub(MessageParcel & data)95 int32_t ThermalSrvStub::SubscribeThermalTempCallbackStub(MessageParcel& data)
96 {
97 THERMAL_HILOGD(COMP_SVC, "Enter");
98 sptr<IRemoteObject> obj = data.ReadRemoteObject();
99 THERMAL_RETURN_IF_WITH_RET((obj == nullptr), E_READ_PARCEL_ERROR_THERMAL);
100 sptr<IThermalTempCallback> callback = iface_cast<IThermalTempCallback>(obj);
101 THERMAL_RETURN_IF_WITH_RET((callback == nullptr), E_READ_PARCEL_ERROR_THERMAL);
102 std::vector<std::string> typeList;
103 if (!data.ReadStringVector(&typeList)) {
104 THERMAL_HILOGI(COMP_SVC, "failed to read type list");
105 return ERR_INVALID_VALUE;
106 }
107 SubscribeThermalTempCallback(typeList, callback);
108 return ERR_OK;
109 }
110
UnSubscribeThermalTempCallbackStub(MessageParcel & data)111 int32_t ThermalSrvStub::UnSubscribeThermalTempCallbackStub(MessageParcel& data)
112 {
113 THERMAL_HILOGD(COMP_SVC, "Enter");
114 sptr<IRemoteObject> obj = data.ReadRemoteObject();
115 THERMAL_RETURN_IF_WITH_RET((obj == nullptr), E_READ_PARCEL_ERROR_THERMAL);
116 sptr<IThermalTempCallback> callback = iface_cast<IThermalTempCallback>(obj);
117 THERMAL_RETURN_IF_WITH_RET((callback == nullptr), E_READ_PARCEL_ERROR_THERMAL);
118 UnSubscribeThermalTempCallback(callback);
119 return ERR_OK;
120 }
121
SubscribeThermalLevelCallbackStub(MessageParcel & data)122 int32_t ThermalSrvStub::SubscribeThermalLevelCallbackStub(MessageParcel& data)
123 {
124 THERMAL_HILOGD(COMP_SVC, "SubscribeThermalLevelCallbackStub Enter");
125 sptr<IRemoteObject> obj = data.ReadRemoteObject();
126 THERMAL_RETURN_IF_WITH_RET((obj == nullptr), E_READ_PARCEL_ERROR_THERMAL);
127 sptr<IThermalLevelCallback> callback = iface_cast<IThermalLevelCallback>(obj);
128 THERMAL_RETURN_IF_WITH_RET((callback == nullptr), E_READ_PARCEL_ERROR_THERMAL);
129 SubscribeThermalLevelCallback(callback);
130 return ERR_OK;
131 }
132
UnSubscribeThermalLevelCallbackStub(MessageParcel & data)133 int32_t ThermalSrvStub::UnSubscribeThermalLevelCallbackStub(MessageParcel& data)
134 {
135 THERMAL_HILOGD(COMP_SVC, "Enter");
136 sptr<IRemoteObject> obj = data.ReadRemoteObject();
137 THERMAL_RETURN_IF_WITH_RET((obj == nullptr), E_READ_PARCEL_ERROR_THERMAL);
138 sptr<IThermalLevelCallback> callback = iface_cast<IThermalLevelCallback>(obj);
139 THERMAL_RETURN_IF_WITH_RET((callback == nullptr), E_READ_PARCEL_ERROR_THERMAL);
140 UnSubscribeThermalLevelCallback(callback);
141 return ERR_OK;
142 }
143
SubscribeThermalActionCallbackStub(MessageParcel & data)144 int32_t ThermalSrvStub::SubscribeThermalActionCallbackStub(MessageParcel& data)
145 {
146 THERMAL_HILOGD(COMP_SVC, "Enter");
147 sptr<IRemoteObject> obj = data.ReadRemoteObject();
148 THERMAL_RETURN_IF_WITH_RET((obj == nullptr), E_READ_PARCEL_ERROR_THERMAL);
149 sptr<IThermalActionCallback> callback = iface_cast<IThermalActionCallback>(obj);
150 THERMAL_RETURN_IF_WITH_RET((callback == nullptr), E_READ_PARCEL_ERROR_THERMAL);
151
152 std::vector<std::string> actionList;
153 if (!data.ReadStringVector(&actionList)) {
154 THERMAL_HILOGI(COMP_SVC, "failed to read action list");
155 return ERR_INVALID_VALUE;
156 }
157
158 std::string desc;
159 THERMAL_READ_PARCEL_WITH_RET(data, String, desc, E_READ_PARCEL_ERROR_THERMAL);
160
161 SubscribeThermalActionCallback(actionList, desc, callback);
162 return ERR_OK;
163 }
164
UnSubscribeThermalActionCallbackStub(MessageParcel & data)165 int32_t ThermalSrvStub::UnSubscribeThermalActionCallbackStub(MessageParcel& data)
166 {
167 THERMAL_HILOGD(COMP_SVC, "Enter");
168 sptr<IRemoteObject> obj = data.ReadRemoteObject();
169 THERMAL_RETURN_IF_WITH_RET((obj == nullptr), E_READ_PARCEL_ERROR_THERMAL);
170 sptr<IThermalActionCallback> callback = iface_cast<IThermalActionCallback>(obj);
171 THERMAL_RETURN_IF_WITH_RET((callback == nullptr), E_READ_PARCEL_ERROR_THERMAL);
172 UnSubscribeThermalActionCallback(callback);
173 return ERR_OK;
174 }
175
GetThermalSrvSensorInfoStub(MessageParcel & data,MessageParcel & reply)176 int32_t ThermalSrvStub::GetThermalSrvSensorInfoStub(MessageParcel& data, MessageParcel& reply)
177 {
178 ThermalSrvSensorInfo sensorInfo;
179 uint32_t type = 0;
180 THERMAL_HILOGD(COMP_SVC, "Enter");
181
182 THERMAL_READ_PARCEL_WITH_RET(data, Uint32, type, E_READ_PARCEL_ERROR_THERMAL);
183 THERMAL_HILOGI(COMP_SVC, "type is %{public}d", type);
184 bool ret = GetThermalSrvSensorInfo(static_cast<SensorType>(type), sensorInfo);
185 if (ret) {
186 if (!reply.WriteParcelable(&sensorInfo)) {
187 THERMAL_HILOGE(COMP_SVC, "write failed");
188 return -1;
189 }
190 }
191 return ERR_OK;
192 }
193
GetThermalevelStub(MessageParcel & reply)194 int32_t ThermalSrvStub::GetThermalevelStub(MessageParcel& reply)
195 {
196 THERMAL_HILOGD(COMP_SVC, "Enter");
197 ThermalLevel level;
198 GetThermalLevel(level);
199 THERMAL_WRITE_PARCEL_WITH_RET(reply, Uint32, static_cast<uint32_t>(level), ERR_OK);
200 return ERR_OK;
201 }
202
GetThermalInfoStub(MessageParcel & reply)203 int32_t ThermalSrvStub::GetThermalInfoStub(MessageParcel& reply)
204 {
205 THERMAL_HILOGD(COMP_SVC, "Enter");
206 bool ret = false;
207 ret = GetThermalInfo();
208 if (!reply.WriteBool(ret)) {
209 THERMAL_HILOGE(COMP_FWK, "WriteBool fail");
210 return E_READ_PARCEL_ERROR_THERMAL;
211 }
212 return ERR_OK;
213 }
214
SetSceneStub(MessageParcel & data)215 int32_t ThermalSrvStub::SetSceneStub(MessageParcel& data)
216 {
217 THERMAL_HILOGD(COMP_SVC, "Enter");
218 std::string scene;
219
220 THERMAL_READ_PARCEL_WITH_RET(data, String, scene, E_READ_PARCEL_ERROR_THERMAL);
221 SetScene(scene);
222 return ERR_OK;
223 }
224
ShellDumpStub(MessageParcel & data,MessageParcel & reply)225 int32_t ThermalSrvStub::ShellDumpStub(MessageParcel& data, MessageParcel& reply)
226 {
227 uint32_t argc;
228 std::vector<std::string> args;
229
230 if (!data.ReadUint32(argc)) {
231 THERMAL_HILOGE(COMP_SVC, "Readback fail!");
232 return E_READ_PARCEL_ERROR_THERMAL;
233 }
234
235 if (argc >= PARAM_MAX_NUM) {
236 THERMAL_HILOGE(COMP_SVC, "params exceed limit");
237 return E_EXCEED_PARAM_LIMIT;
238 }
239
240 for (uint32_t i = 0; i < argc; i++) {
241 std::string arg = data.ReadString();
242 if (arg.empty()) {
243 THERMAL_HILOGE(COMP_SVC, "read value fail:%{public}d", i);
244 return E_READ_PARCEL_ERROR_THERMAL;
245 }
246 args.push_back(arg);
247 }
248
249 std::string ret = ShellDump(args, argc);
250 if (!reply.WriteString(ret)) {
251 THERMAL_HILOGE(COMP_SVC, "PowerMgrStub:: Dump Writeback Fail!");
252 return E_READ_PARCEL_ERROR_THERMAL;
253 }
254 return ERR_OK;
255 }
256 } // namespace PowerMgr
257 } // namespace OHOS
258