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