1 /*
2 * Copyright (C) 2018 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 #define LOG_TAG "android.hardware.thermal@2.0-service-mock"
18
19 #include <cmath>
20 #include <set>
21
22 #include <android-base/logging.h>
23 #include <hidl/HidlTransportSupport.h>
24
25 #include "Thermal.h"
26
27 namespace android {
28 namespace hardware {
29 namespace thermal {
30 namespace V2_0 {
31 namespace implementation {
32
33 using ::android::sp;
34 using ::android::hardware::interfacesEqual;
35 using ::android::hardware::thermal::V1_0::ThermalStatus;
36 using ::android::hardware::thermal::V1_0::ThermalStatusCode;
37
38 std::set<sp<IThermalChangedCallback>> gCallbacks;
39
40 static const Temperature_1_0 kTemp_1_0 = {
41 .type = static_cast<::android::hardware::thermal::V1_0::TemperatureType>(
42 TemperatureType::SKIN),
43 .name = "test temperature sensor",
44 .currentValue = 30.8,
45 .throttlingThreshold = 48.0,
46 .shutdownThreshold = 60.0,
47 .vrThrottlingThreshold = 49.0,
48 };
49
50 static const Temperature_2_0 kTemp_2_0 = {
51 .type = TemperatureType::SKIN,
52 .name = "test temperature sensor",
53 .value = 30.8,
54 .throttlingStatus = ThrottlingSeverity::NONE,
55 };
56
57 static const TemperatureThreshold kTempThreshold = {
58 .type = TemperatureType::SKIN,
59 .name = "test temperature sensor",
60 .hotThrottlingThresholds = {{NAN, NAN, NAN, 48.0, NAN, NAN, 60.0}},
61 .coldThrottlingThresholds = {{NAN, NAN, NAN, NAN, NAN, NAN, NAN}},
62 .vrThrottlingThreshold = 49.0,
63 };
64
65 static const CoolingDevice_1_0 kCooling_1_0 = {
66 .type = ::android::hardware::thermal::V1_0::CoolingType::FAN_RPM,
67 .name = "test cooling device",
68 .currentValue = 100.0,
69 };
70
71 static const CoolingDevice_2_0 kCooling_2_0 = {
72 .type = CoolingType::FAN,
73 .name = "test cooling device",
74 .value = 100,
75 };
76
77 static const CpuUsage kCpuUsage = {
78 .name = "cpu_name",
79 .active = 0,
80 .total = 0,
81 .isOnline = true,
82 };
83
84 // Methods from ::android::hardware::thermal::V1_0::IThermal follow.
getTemperatures(getTemperatures_cb _hidl_cb)85 Return<void> Thermal::getTemperatures(getTemperatures_cb _hidl_cb) {
86 ThermalStatus status;
87 status.code = ThermalStatusCode::SUCCESS;
88 std::vector<Temperature_1_0> temperatures = {kTemp_1_0};
89 _hidl_cb(status, temperatures);
90 return Void();
91 }
92
getCpuUsages(getCpuUsages_cb _hidl_cb)93 Return<void> Thermal::getCpuUsages(getCpuUsages_cb _hidl_cb) {
94 ThermalStatus status;
95 status.code = ThermalStatusCode::SUCCESS;
96 std::vector<CpuUsage> cpu_usages = {kCpuUsage};
97 _hidl_cb(status, cpu_usages);
98 return Void();
99 }
100
getCoolingDevices(getCoolingDevices_cb _hidl_cb)101 Return<void> Thermal::getCoolingDevices(getCoolingDevices_cb _hidl_cb) {
102 ThermalStatus status;
103 status.code = ThermalStatusCode::SUCCESS;
104 std::vector<CoolingDevice_1_0> cooling_devices = {kCooling_1_0};
105 _hidl_cb(status, cooling_devices);
106 return Void();
107 }
108
109 // Methods from ::android::hardware::thermal::V2_0::IThermal follow.
getCurrentTemperatures(bool filterType,TemperatureType type,getCurrentTemperatures_cb _hidl_cb)110 Return<void> Thermal::getCurrentTemperatures(bool filterType, TemperatureType type,
111 getCurrentTemperatures_cb _hidl_cb) {
112 ThermalStatus status;
113 status.code = ThermalStatusCode::SUCCESS;
114 std::vector<Temperature_2_0> temperatures;
115 if (filterType && type != kTemp_2_0.type) {
116 status.code = ThermalStatusCode::FAILURE;
117 status.debugMessage = "Failed to read data";
118 } else {
119 temperatures = {kTemp_2_0};
120 }
121 _hidl_cb(status, temperatures);
122 return Void();
123 }
124
getTemperatureThresholds(bool filterType,TemperatureType type,getTemperatureThresholds_cb _hidl_cb)125 Return<void> Thermal::getTemperatureThresholds(bool filterType, TemperatureType type,
126 getTemperatureThresholds_cb _hidl_cb) {
127 ThermalStatus status;
128 status.code = ThermalStatusCode::SUCCESS;
129 std::vector<TemperatureThreshold> temperature_thresholds;
130 if (filterType && type != kTempThreshold.type) {
131 status.code = ThermalStatusCode::FAILURE;
132 status.debugMessage = "Failed to read data";
133 } else {
134 temperature_thresholds = {kTempThreshold};
135 }
136 _hidl_cb(status, temperature_thresholds);
137 return Void();
138 }
139
getCurrentCoolingDevices(bool filterType,CoolingType type,getCurrentCoolingDevices_cb _hidl_cb)140 Return<void> Thermal::getCurrentCoolingDevices(bool filterType, CoolingType type,
141 getCurrentCoolingDevices_cb _hidl_cb) {
142 ThermalStatus status;
143 status.code = ThermalStatusCode::SUCCESS;
144 std::vector<CoolingDevice_2_0> cooling_devices;
145 if (filterType && type != kCooling_2_0.type) {
146 status.code = ThermalStatusCode::FAILURE;
147 status.debugMessage = "Failed to read data";
148 } else {
149 cooling_devices = {kCooling_2_0};
150 }
151 _hidl_cb(status, cooling_devices);
152 return Void();
153 }
154
registerThermalChangedCallback(const sp<IThermalChangedCallback> & callback,bool filterType,TemperatureType type,registerThermalChangedCallback_cb _hidl_cb)155 Return<void> Thermal::registerThermalChangedCallback(const sp<IThermalChangedCallback>& callback,
156 bool filterType, TemperatureType type,
157 registerThermalChangedCallback_cb _hidl_cb) {
158 ThermalStatus status;
159 if (callback == nullptr) {
160 status.code = ThermalStatusCode::FAILURE;
161 status.debugMessage = "Invalid nullptr callback";
162 LOG(ERROR) << status.debugMessage;
163 _hidl_cb(status);
164 return Void();
165 } else {
166 status.code = ThermalStatusCode::SUCCESS;
167 }
168 std::lock_guard<std::mutex> _lock(thermal_callback_mutex_);
169 if (std::any_of(callbacks_.begin(), callbacks_.end(), [&](const CallbackSetting& c) {
170 return interfacesEqual(c.callback, callback);
171 })) {
172 status.code = ThermalStatusCode::FAILURE;
173 status.debugMessage = "Same callback interface registered already";
174 LOG(ERROR) << status.debugMessage;
175 } else {
176 callbacks_.emplace_back(callback, filterType, type);
177 LOG(INFO) << "A callback has been registered to ThermalHAL, isFilter: " << filterType
178 << " Type: " << android::hardware::thermal::V2_0::toString(type);
179 }
180 _hidl_cb(status);
181 return Void();
182 }
183
unregisterThermalChangedCallback(const sp<IThermalChangedCallback> & callback,unregisterThermalChangedCallback_cb _hidl_cb)184 Return<void> Thermal::unregisterThermalChangedCallback(
185 const sp<IThermalChangedCallback>& callback, unregisterThermalChangedCallback_cb _hidl_cb) {
186 ThermalStatus status;
187 if (callback == nullptr) {
188 status.code = ThermalStatusCode::FAILURE;
189 status.debugMessage = "Invalid nullptr callback";
190 LOG(ERROR) << status.debugMessage;
191 _hidl_cb(status);
192 return Void();
193 } else {
194 status.code = ThermalStatusCode::SUCCESS;
195 }
196 bool removed = false;
197 std::lock_guard<std::mutex> _lock(thermal_callback_mutex_);
198 callbacks_.erase(
199 std::remove_if(callbacks_.begin(), callbacks_.end(),
200 [&](const CallbackSetting& c) {
201 if (interfacesEqual(c.callback, callback)) {
202 LOG(INFO)
203 << "A callback has been unregistered from ThermalHAL, isFilter: "
204 << c.is_filter_type << " Type: "
205 << android::hardware::thermal::V2_0::toString(c.type);
206 removed = true;
207 return true;
208 }
209 return false;
210 }),
211 callbacks_.end());
212 if (!removed) {
213 status.code = ThermalStatusCode::FAILURE;
214 status.debugMessage = "The callback was not registered before";
215 LOG(ERROR) << status.debugMessage;
216 }
217 _hidl_cb(status);
218 return Void();
219 }
220
221 } // namespace implementation
222 } // namespace V2_0
223 } // namespace thermal
224 } // namespace hardware
225 } // namespace android
226