tequilaOS/platform_hardware_interfaces
2
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

Add thermal HAL 2.0

Browse source 
Bug: 116540200
Test: add default ThermalHAL 2.0 and VtsHalThermalV2_0TargetTest pass
Change-Id: Ib12634459d9ed5071230adf353b9737f5c90e771
This commit is contained in:
Wei Wang 2018-10-18 13:56:03 -07:00
parent 6a7e67cc92
commit 84ce54ebaf
13 changed files with 1031 additions and 0 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
compatibility_matrices/compatibility_matrix.current.xml
View file

@ -398,6 +398,7 @@
<hal format="hidl" optional="true"> <hal format="hidl" optional="true">
<name>android.hardware.thermal</name> <name>android.hardware.thermal</name>
<version>1.0-1</version> <version>1.0-1</version>
<version>2.0</version>
<interface> <interface>
<name>IThermal</name> <name>IThermal</name>
<instance>default</instance> <instance>default</instance>

29
thermal/2.0/Android.bp Normal file
View file

@ -0,0 +1,29 @@
// This file is autogenerated by hidl-gen -Landroidbp.
hidl_interface {
name: "android.hardware.thermal@2.0",
root: "android.hardware",
vndk: {
enabled: true,
},
srcs: [
"types.hal",
"IThermal.hal",
"IThermalChangedCallback.hal",
],
interfaces: [
"android.hardware.thermal@1.0",
"android.hidl.base@1.0",
],
types: [
"CoolingDevice",
"CoolingType",
"Temperature",
"TemperatureThreshold",
"TemperatureType",
"ThrottlingSeverity",
"ThrottlingSeverityCount",
],
gen_java: true,
}

113
thermal/2.0/IThermal.hal Normal file
View file

@ -0,0 +1,113 @@
/*
* Copyright (C) 2018 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package android.hardware.thermal@2.0;
import android.hardware.thermal@1.0::IThermal;
import android.hardware.thermal@1.0::ThermalStatus;
import IThermalChangedCallback;
interface IThermal extends @1.0::IThermal {
/**
* Retrieves temperatures in Celsius.
*
* @param filterType whether to filter the result for a given type.
* @param type the TemperatureType such as battery or skin.
*
* @return status Status of the operation. If status code is FAILURE,
* the status.debugMessage must be populated with a human-readable
* error message.
*
* @return temperatures If status code is SUCCESS, it's filled with the
* current temperatures. The order of temperatures of built-in
* devices (such as CPUs, GPUs and etc.) in the list must be kept
* the same regardless of the number of calls to this method even if
* they go offline, if these devices exist on boot. The method
* always returns and never removes such temperatures.
*/
getCurrentTemperatures(bool filterType, TemperatureType type)
generates (ThermalStatus status, vec<Temperature> temperatures);
/**
* Retrieves temperature thresholds in Celsius.
*
* @param filterType whether to filter the result for a given type.
* @param type the TemperatureType such as battery or skin.
*
* @return status Status of the operation. If status code is FAILURE,
* the status.debugMessage must be populated with a human-readable error message.
* @return temperatureThresholds If status code is SUCCESS, it's filled with the
* temperatures thresholds. The order of temperatures of built-in
* devices (such as CPUs, GPUs and etc.) in the list must be kept
* the same regardless of the number of calls to this method even if
* they go offline, if these devices exist on boot. The method
* always returns and never removes such temperatures.
*/
getTemperatureThresholds(bool filterType, TemperatureType type)
generates (ThermalStatus status, vec<TemperatureThreshold> temperatureThresholds);
/**
* Register an IThermalChangedCallback, used by the Thermal HAL
* to send thermal events when thermal mitigation status changed.
* Multiple registrations with different IThermalChangedCallback must be allowed.
* Multiple registrations with same IThermalChangedCallback is not allowed, client
* should unregister the given IThermalChangedCallback first.
*
* @param callback the IThermalChangedCallback to use for sending
* thermal events (cannot be nullptr).
* @param filterType if filter for given sensor type.
* @param type the type to be filtered.
*
* @return status Status of the operation. If status code is FAILURE,
* the status.debugMessage must be populated with a human-readable error message.
*/
registerThermalChangedCallback(IThermalChangedCallback callback,
bool filterType,
TemperatureType type)
generates (ThermalStatus status);
/**
* Register an IThermalChangedCallback, used by the Thermal HAL
* to send thermal events when thermal mitigation status changed.
*
* @param callback the IThermalChangedCallback to use for sending
* thermal events, or nullptr to set no callback.
*
* @return status Status of the operation. If status code is FAILURE,
* the status.debugMessage must be populated with a human-readable error message.
*/
unregisterThermalChangedCallback(IThermalChangedCallback callback)
generates (ThermalStatus status);
/**
* Retrieves the cooling devices information.
*
* @param filterType whether to filter the result for a given type.
* @param type the CoolingDevice such as CPU/GPU.
*
* @return status Status of the operation. If status code is FAILURE,
* the status.debugMessage must be populated with the human-readable
* error message.
* @return devices If status code is SUCCESS, it's filled with the current
* cooling device information. The order of built-in cooling
* devices in the list must be kept the same regardless of the number
* of calls to this method even if they go offline, if these devices
* exist on boot. The method always returns and never removes from
* the list such cooling devices.
*/
getCurrentCoolingDevices(bool filterType, CoolingType type)
generates (ThermalStatus status, vec<CoolingDevice> devices);
};

33
thermal/2.0/IThermalChangedCallback.hal Normal file
View file

@ -0,0 +1,33 @@
/*
* Copyright (C) 2018 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package android.hardware.thermal@2.0;
import android.hardware.thermal@2.0::Temperature;
/**
* IThermalChangedCallback send throttling notification to clients.
*/
interface IThermalChangedCallback {
/**
* Send a thermal throttling event to all ThermalHAL
* thermal event listeners.
*
* @param temperature The temperature associated with the
* throttling event.
*/
oneway notifyThrottling (Temperature temperature);
};

35
thermal/2.0/default/Android.bp Normal file
View file

@ -0,0 +1,35 @@
//
// Copyright (C) 2018 The Android Open Source Project
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
cc_binary {
name: "android.hardware.thermal@2.0-service",
defaults: ["hidl_defaults"],
relative_install_path: "hw",
vendor: true,
init_rc: ["android.hardware.thermal@2.0-service.rc"],
vintf_fragments: ["android.hardware.thermal@2.0-service.xml"],
srcs: [
"Thermal.cpp",
"service.cpp"
],
shared_libs: [
"libbase",
"libhidlbase",
"libhidltransport",
"libutils",
"android.hardware.thermal@2.0",
"android.hardware.thermal@1.0",
],
}

208
thermal/2.0/default/Thermal.cpp Normal file
View file

@ -0,0 +1,208 @@
/*
* Copyright (C) 2018 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#define LOG_TAG "android.hardware.thermal@2.0-service-mock"
#include <cmath>
#include <set>
#include <android-base/logging.h>
#include <hidl/HidlTransportSupport.h>
#include "Thermal.h"
namespace android {
namespace hardware {
namespace thermal {
namespace V2_0 {
namespace implementation {
using ::android::sp;
using ::android::hardware::interfacesEqual;
using ::android::hardware::thermal::V1_0::ThermalStatus;
using ::android::hardware::thermal::V1_0::ThermalStatusCode;
std::set<sp<IThermalChangedCallback>> gCallbacks;
static const Temperature_1_0 kTemp_1_0 = {
.type = static_cast<::android::hardware::thermal::V1_0::TemperatureType>(TemperatureType::CPU),
.name = "test temperature sensor",
.currentValue = 98.6,
.throttlingThreshold = 58,
.shutdownThreshold = 60.0,
.vrThrottlingThreshold = 59.0,
};
static const Temperature_2_0 kTemp_2_0 = {
.type = TemperatureType::SKIN,
.name = "test temperature sensor",
.value = 98.6,
.throttlingStatus = ThrottlingSeverity::CRITICAL,
};
static const TemperatureThreshold kTempThreshold = {
.type = TemperatureType::SKIN,
.name = "test temperature sensor",
.hotThrottlingThresholds = {{NAN, NAN, NAN, NAN, NAN, NAN, NAN}},
.coldThrottlingThresholds = {{NAN, NAN, NAN, NAN, NAN, NAN, NAN}},
.vrThrottlingThreshold = NAN,
};
static const CoolingDevice_1_0 kCooling_1_0 = {
.type = ::android::hardware::thermal::V1_0::CoolingType::FAN_RPM,
.name = "test cooling device",
.currentValue = 100.0,
};
static const CoolingDevice_2_0 kCooling_2_0 = {
.type = CoolingType::CPU,
.name = "test cooling device",
.value = 1,
};
static const CpuUsage kCpuUsage = {
.name = "cpu_name",
.active = 0,
.total = 0,
.isOnline = true,
};
// Methods from ::android::hardware::thermal::V1_0::IThermal follow.
Return<void> Thermal::getTemperatures(getTemperatures_cb _hidl_cb) {
ThermalStatus status;
status.code = ThermalStatusCode::SUCCESS;
std::vector<Temperature_1_0> temperatures = {kTemp_1_0};
_hidl_cb(status, temperatures);
return Void();
}
Return<void> Thermal::getCpuUsages(getCpuUsages_cb _hidl_cb) {
ThermalStatus status;
status.code = ThermalStatusCode::SUCCESS;
std::vector<CpuUsage> cpu_usages = {kCpuUsage};
_hidl_cb(status, cpu_usages);
return Void();
}
Return<void> Thermal::getCoolingDevices(getCoolingDevices_cb _hidl_cb) {
ThermalStatus status;
status.code = ThermalStatusCode::SUCCESS;
std::vector<CoolingDevice_1_0> cooling_devices = {kCooling_1_0};
_hidl_cb(status, cooling_devices);
return Void();
}
// Methods from ::android::hardware::thermal::V2_0::IThermal follow.
Return<void> Thermal::getCurrentTemperatures(bool filterType, TemperatureType type,
getCurrentTemperatures_cb _hidl_cb) {
ThermalStatus status;
status.code = ThermalStatusCode::SUCCESS;
std::vector<Temperature_2_0> temperatures;
if (filterType && type != kTemp_2_0.type) {
status.code = ThermalStatusCode::FAILURE;
status.debugMessage = "Failed to read data";
} else {
temperatures = {kTemp_2_0};
}
_hidl_cb(status, temperatures);
return Void();
}
Return<void> Thermal::getTemperatureThresholds(bool filterType, TemperatureType type,
getTemperatureThresholds_cb _hidl_cb) {
ThermalStatus status;
status.code = ThermalStatusCode::SUCCESS;
std::vector<TemperatureThreshold> temperature_thresholds;
if (filterType && type != kTempThreshold.type) {
status.code = ThermalStatusCode::FAILURE;
status.debugMessage = "Failed to read data";
} else {
temperature_thresholds = {kTempThreshold};
}
_hidl_cb(status, temperature_thresholds);
return Void();
}
Return<void> Thermal::getCurrentCoolingDevices(bool filterType, CoolingType type,
getCurrentCoolingDevices_cb _hidl_cb) {
ThermalStatus status;
status.code = ThermalStatusCode::SUCCESS;
std::vector<CoolingDevice_2_0> cooling_devices;
if (filterType && type != kCooling_2_0.type) {
status.code = ThermalStatusCode::FAILURE;
status.debugMessage = "Failed to read data";
} else {
cooling_devices = {kCooling_2_0};
}
_hidl_cb(status, cooling_devices);
return Void();
}
Return<void> Thermal::registerThermalChangedCallback(const sp<IThermalChangedCallback>& callback,
bool filterType, TemperatureType type,
registerThermalChangedCallback_cb _hidl_cb) {
ThermalStatus status;
status.code = ThermalStatusCode::SUCCESS;
std::lock_guard<std::mutex> _lock(thermal_callback_mutex_);
if (std::any_of(callbacks_.begin(), callbacks_.end(), [&](const CallbackSetting& c) {
return interfacesEqual(c.callback, callback);
})) {
status.code = ThermalStatusCode::FAILURE;
status.debugMessage = "Same callback interface registered already";
LOG(ERROR) << status.debugMessage;
} else {
callbacks_.emplace_back(callback, filterType, type);
LOG(INFO) << "A callback has been registered to ThermalHAL, isFilter: " << filterType
<< " Type: " << android::hardware::thermal::V2_0::toString(type);
}
_hidl_cb(status);
return Void();
}
Return<void> Thermal::unregisterThermalChangedCallback(
const sp<IThermalChangedCallback>& callback, unregisterThermalChangedCallback_cb _hidl_cb) {
ThermalStatus status;
status.code = ThermalStatusCode::SUCCESS;
bool removed = false;
std::lock_guard<std::mutex> _lock(thermal_callback_mutex_);
callbacks_.erase(
std::remove_if(callbacks_.begin(), callbacks_.end(),
[&](const CallbackSetting& c) {
if (interfacesEqual(c.callback, callback)) {
LOG(INFO)
<< "A callback has been unregistered from ThermalHAL, isFilter: "
<< c.is_filter_type << " Type: "
<< android::hardware::thermal::V2_0::toString(c.type);
removed = true;
return true;
}
return false;
}),
callbacks_.end());
if (!removed) {
status.code = ThermalStatusCode::FAILURE;
status.debugMessage = "The callback was not registered before";
LOG(ERROR) << status.debugMessage;
}
_hidl_cb(status);
return Void();
}
} // namespace implementation
} // namespace V2_0
} // namespace thermal
} // namespace hardware
} // namespace android

88
thermal/2.0/default/Thermal.h Normal file
View file

@ -0,0 +1,88 @@
/*
* Copyright (C) 2018 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ANDROID_HARDWARE_THERMAL_V2_0_THERMAL_H
#define ANDROID_HARDWARE_THERMAL_V2_0_THERMAL_H
#include <android/hardware/thermal/2.0/IThermal.h>
#include <hidl/MQDescriptor.h>
#include <hidl/Status.h>
namespace android {
namespace hardware {
namespace thermal {
namespace V2_0 {
namespace implementation {
using ::android::sp;
using ::android::hardware::hidl_array;
using ::android::hardware::hidl_memory;
using ::android::hardware::hidl_string;
using ::android::hardware::hidl_vec;
using ::android::hardware::Return;
using ::android::hardware::Void;
using ::android::hardware::thermal::V1_0::CpuUsage;
using ::android::hardware::thermal::V2_0::CoolingType;
using ::android::hardware::thermal::V2_0::IThermal;
using CoolingDevice_1_0 = ::android::hardware::thermal::V1_0::CoolingDevice;
using CoolingDevice_2_0 = ::android::hardware::thermal::V2_0::CoolingDevice;
using Temperature_1_0 = ::android::hardware::thermal::V1_0::Temperature;
using Temperature_2_0 = ::android::hardware::thermal::V2_0::Temperature;
using ::android::hardware::thermal::V2_0::IThermalChangedCallback;
using ::android::hardware::thermal::V2_0::TemperatureThreshold;
using ::android::hardware::thermal::V2_0::TemperatureType;
struct CallbackSetting {
CallbackSetting(sp<IThermalChangedCallback> callback, bool is_filter_type, TemperatureType type)
: callback(callback), is_filter_type(is_filter_type), type(type) {}
sp<IThermalChangedCallback> callback;
bool is_filter_type;
TemperatureType type;
};
class Thermal : public IThermal {
public:
// Methods from ::android::hardware::thermal::V1_0::IThermal follow.
Return<void> getTemperatures(getTemperatures_cb _hidl_cb) override;
Return<void> getCpuUsages(getCpuUsages_cb _hidl_cb) override;
Return<void> getCoolingDevices(getCoolingDevices_cb _hidl_cb) override;
// Methods from ::android::hardware::thermal::V2_0::IThermal follow.
Return<void> getCurrentTemperatures(bool filterType, TemperatureType type,
getCurrentTemperatures_cb _hidl_cb) override;
Return<void> getTemperatureThresholds(bool filterType, TemperatureType type,
getTemperatureThresholds_cb _hidl_cb) override;
Return<void> registerThermalChangedCallback(
const sp<IThermalChangedCallback>& callback, bool filterType, TemperatureType type,
registerThermalChangedCallback_cb _hidl_cb) override;
Return<void> unregisterThermalChangedCallback(
const sp<IThermalChangedCallback>& callback,
unregisterThermalChangedCallback_cb _hidl_cb) override;
Return<void> getCurrentCoolingDevices(bool filterType, CoolingType type,
getCurrentCoolingDevices_cb _hidl_cb) override;
private:
std::mutex thermal_callback_mutex_;
std::vector<CallbackSetting> callbacks_;
};
} // namespace implementation
} // namespace V2_0
} // namespace thermal
} // namespace hardware
} // namespace android
#endif // ANDROID_HARDWARE_THERMAL_V2_0_THERMAL_H

5
thermal/2.0/default/android.hardware.thermal@2.0-service.rc Normal file
View file

@ -0,0 +1,5 @@
service vendor.thermal-hal-2-0-mock /vendor/bin/hw/android.hardware.thermal@2.0-service
interface android.hardware.thermal@2.0::IThermal default
class hal
user system
group system

11
thermal/2.0/default/android.hardware.thermal@2.0-service.xml Normal file
View file

@ -0,0 +1,11 @@
<manifest version="1.0" type="device">
<hal format="hidl">
<name>android.hardware.thermal</name>
<transport>hwbinder</transport>
<version>2.0</version>
<interface>
<name>IThermal</name>
<instance>default</instance>
</interface>
</hal>
</manifest>

63
thermal/2.0/default/service.cpp Normal file
View file

@ -0,0 +1,63 @@
/*
* Copyright (C) 2018 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#define LOG_TAG "android.hardware.thermal@2.0-service-mock"
#include <android-base/logging.h>
#include <hidl/HidlTransportSupport.h>
#include "Thermal.h"
using ::android::OK;
using ::android::status_t;
// libhwbinder:
using ::android::hardware::configureRpcThreadpool;
using ::android::hardware::joinRpcThreadpool;
// Generated HIDL files:
using ::android::hardware::thermal::V2_0::IThermal;
using ::android::hardware::thermal::V2_0::implementation::Thermal;
static int shutdown() {
LOG(ERROR) << "Thermal Service is shutting down.";
return 1;
}
int main(int /* argc */, char** /* argv */) {
status_t status;
android::sp<IThermal> service = nullptr;
LOG(INFO) << "Thermal HAL Service Mock 2.0 starting...";
service = new Thermal();
if (service == nullptr) {
LOG(ERROR) << "Error creating an instance of ThermalHAL. Exiting...";
return shutdown();
}
configureRpcThreadpool(1, true /* callerWillJoin */);
status = service->registerAsService();
if (status != OK) {
LOG(ERROR) << "Could not register service for ThermalHAL (" << status << ")";
return shutdown();
}
LOG(INFO) << "Thermal Service started successfully.";
joinRpcThreadpool();
// We should not get past the joinRpcThreadpool().
return shutdown();
}

155
thermal/2.0/types.hal Normal file
View file

@ -0,0 +1,155 @@
/*
* Copyright (C) 2018 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package android.hardware.thermal@2.0;
import android.hardware.thermal@1.0::types;
/** Device temperature types */
enum TemperatureType : @1.0::TemperatureType {
USB_PORT = 4,
POWER_AMPLIFIER = 5,
};
/** Device cooling device types */
enum CoolingType : uint32_t {
FAN,
BATTERY,
CPU,
GPU,
MODEM,
NPU,
COMPONENT, // for the rest of components
};
/** Device throttling severity */
enum ThrottlingSeverity : uint32_t {
/**
* Not under throttling.
*/
NONE = 0,
/**
* Light throttling where UX is not impacted.
*/
LIGHT,
/**
* Moderate throttling where UX is not largily impacted.
*/
MODERATE,
/**
* Severe throttling where UX is largely impacted.
* Similar to 1.0 throttlingThreshold.
*/
SEVERE,
/**
* Platform has done everything to reduce power.
*/
CRITICAL,
/**
* User should be warned before shutdown.
*/
WARNING,
/**
* Need shutdown immediately.
*/
SHUTDOWN,
};
enum ThrottlingSeverityCount : uint32_t {NUM_THROTTLING_LEVELS = 7};
struct TemperatureThreshold {
/**
* This temperature's type.
*/
TemperatureType type;
/**
* Name of this temperature matching the Temperature struct.
* All temperatures of the same "type" must have a different "name",
* e.g., cpu0, battery. Clients use it to match Temperature struct.
*/
string name;
/**
* Hot throttling temperature constant for this temperature sensor in
* level defined in ThrottlingSeverity including shutdown. Throttling
* happens when temperature >= threshold. If not available, set to NAN.
*/
float[ThrottlingSeverityCount:NUM_THROTTLING_LEVELS] hotThrottlingThresholds;
/**
* Cold throttling temperature constant for this temperature sensor in
* level defined in ThrottlingSeverity including shutdown. Throttling
* happens when temperature <= threshold. If not available, set to NAN.
*/
float[ThrottlingSeverityCount:NUM_THROTTLING_LEVELS] coldThrottlingThresholds;
/**
* Threshold temperature above which the VR mode clockrate minimums cannot
* be maintained for this device.
* If not available, set by HAL to NAN.
*/
float vrThrottlingThreshold;
};
struct Temperature {
/**
* This temperature's type.
*/
TemperatureType type;
/**
* Name of this temperature matching the TemperatureThreshold.
* All temperatures of the same "type" must have a different "name",
* e.g., cpu0, battery. Clients use it to match with TemperatureThreshold
* struct.
*/
string name;
/**
* Current temperature in Celsius. If not available set by HAL to NAN.
*/
float value;
/**
* The current throttling level of the sensor.
*/
ThrottlingSeverity throttlingStatus;
};
struct CoolingDevice {
/**
* This cooling device type, CPU, GPU, BATTERY, and etc.
*/
CoolingType type;
/**
* Name of this cooling device.
* All cooling devices of the same "type" must have a different "name".
* The name is usually defined in kernel device tree, and this is for client
* logging purpose.
*/
string name;
/**
* Current throttle state of the cooling device. The value can any unsigned integer
* numbers between 0 and max_state defined in its driver, usually representing the
* associated device's power state. 0 means device is not in throttling, higher value
* means deeper throttling.
*/
uint64_t value;
};

26
thermal/2.0/vts/functional/Android.bp Normal file
View file

@ -0,0 +1,26 @@
//
// Copyright (C) 2018 The Android Open Source Project
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
cc_test {
name: "VtsHalThermalV2_0TargetTest",
defaults: ["VtsHalTargetTestDefaults"],
srcs: ["VtsHalThermalV2_0TargetTest.cpp"],
static_libs: [
"android.hardware.thermal@1.0",
"android.hardware.thermal@2.0",
],
}

264
thermal/2.0/vts/functional/VtsHalThermalV2_0TargetTest.cpp Normal file
View file

@ -0,0 +1,264 @@
/*
* Copyright (C) 2018 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <android/hardware/thermal/2.0/IThermal.h>
#include <android/hardware/thermal/2.0/IThermalChangedCallback.h>
#include <android/hardware/thermal/2.0/types.h>
#include <VtsHalHidlTargetCallbackBase.h>
#include <VtsHalHidlTargetTestBase.h>
#include <VtsHalHidlTargetTestEnvBase.h>
using ::android::sp;
using ::android::hardware::hidl_vec;
using ::android::hardware::Return;
using ::android::hardware::Void;
using ::android::hardware::thermal::V1_0::ThermalStatus;
using ::android::hardware::thermal::V1_0::ThermalStatusCode;
using ::android::hardware::thermal::V2_0::CoolingDevice;
using ::android::hardware::thermal::V2_0::CoolingType;
using ::android::hardware::thermal::V2_0::IThermal;
using ::android::hardware::thermal::V2_0::IThermalChangedCallback;
using ::android::hardware::thermal::V2_0::Temperature;
using ::android::hardware::thermal::V2_0::TemperatureThreshold;
using ::android::hardware::thermal::V2_0::TemperatureType;
using ::android::hardware::thermal::V2_0::ThrottlingSeverity;
using ::android::hardware::thermal::V2_0::ThrottlingSeverityCount;
constexpr char kCallbackNameNotifyThrottling[] = "notifyThrottling";
static const Temperature kThrottleTemp = {
.type = TemperatureType::SKIN,
.name = "test temperature sensor",
.value = 98.6,
.throttlingStatus = ThrottlingSeverity::CRITICAL,
};
class ThermalCallbackArgs {
public:
Temperature temperature;
};
// Callback class for receiving thermal event notifications from main class
class ThermalCallback : public ::testing::VtsHalHidlTargetCallbackBase<ThermalCallbackArgs>,
public IThermalChangedCallback {
public:
Return<void> notifyThrottling(const Temperature& temperature) override {
ThermalCallbackArgs args;
args.temperature = temperature;
NotifyFromCallback(kCallbackNameNotifyThrottling, args);
return Void();
}
};
// Test environment for Thermal HIDL HAL.
class ThermalHidlEnvironment : public ::testing::VtsHalHidlTargetTestEnvBase {
public:
// get the test environment singleton
static ThermalHidlEnvironment* Instance() {
static ThermalHidlEnvironment* instance = new ThermalHidlEnvironment;
return instance;
}
void registerTestServices() override { registerTestService<IThermal>(); }
private:
ThermalHidlEnvironment() {}
};
// The main test class for THERMAL HIDL HAL 2.0.
class ThermalHidlTest : public ::testing::VtsHalHidlTargetTestBase {
public:
virtual void SetUp() override {
mThermal = ::testing::VtsHalHidlTargetTestBase::getService<IThermal>(
ThermalHidlEnvironment::Instance()->getServiceName<IThermal>());
ASSERT_NE(mThermal, nullptr);
mThermalCallback = new (std::nothrow) ThermalCallback();
ASSERT_NE(mThermalCallback, nullptr);
auto ret = mThermal->registerThermalChangedCallback(
mThermalCallback, false, TemperatureType::SKIN,
[](ThermalStatus status) { EXPECT_EQ(ThermalStatusCode::SUCCESS, status.code); });
ASSERT_TRUE(ret.isOk());
// Expect to fail if register again
ret = mThermal->registerThermalChangedCallback(
mThermalCallback, false, TemperatureType::SKIN,
[](ThermalStatus status) { EXPECT_NE(ThermalStatusCode::SUCCESS, status.code); });
ASSERT_TRUE(ret.isOk());
}
virtual void TearDown() override {
auto ret = mThermal->unregisterThermalChangedCallback(
mThermalCallback,
[](ThermalStatus status) { EXPECT_EQ(ThermalStatusCode::SUCCESS, status.code); });
ASSERT_TRUE(ret.isOk());
// Expect to fail if unregister again
ret = mThermal->unregisterThermalChangedCallback(
mThermalCallback,
[](ThermalStatus status) { EXPECT_NE(ThermalStatusCode::SUCCESS, status.code); });
ASSERT_TRUE(ret.isOk());
}
protected:
sp<IThermal> mThermal;
sp<ThermalCallback> mThermalCallback;
}; // class ThermalHidlTest
// Test ThermalChangedCallback::notifyThrottling().
// This just calls into and back from our local ThermalChangedCallback impl.
// Note: a real thermal throttling event from the Thermal HAL could be
// inadvertently received here.
TEST_F(ThermalHidlTest, NotifyThrottlingTest) {
auto ret = mThermalCallback->notifyThrottling(kThrottleTemp);
ASSERT_TRUE(ret.isOk());
auto res = mThermalCallback->WaitForCallback(kCallbackNameNotifyThrottling);
EXPECT_TRUE(res.no_timeout);
ASSERT_TRUE(res.args);
EXPECT_EQ(kThrottleTemp, res.args->temperature);
}
// Test Thermal->registerThermalChangedCallback.
TEST_F(ThermalHidlTest, RegisterThermalChangedCallbackTest) {
// Expect to fail with same callback
auto ret = mThermal->registerThermalChangedCallback(
mThermalCallback, false, TemperatureType::SKIN,
[](ThermalStatus status) { EXPECT_NE(ThermalStatusCode::SUCCESS, status.code); });
ASSERT_TRUE(ret.isOk());
sp<ThermalCallback> localThermalCallback = new (std::nothrow) ThermalCallback();
// Expect to succeed with different callback
ret = mThermal->registerThermalChangedCallback(
localThermalCallback, false, TemperatureType::SKIN,
[](ThermalStatus status) { EXPECT_EQ(ThermalStatusCode::SUCCESS, status.code); });
ASSERT_TRUE(ret.isOk());
// Remove the local callback.
ret = mThermal->unregisterThermalChangedCallback(
localThermalCallback,
[](ThermalStatus status) { EXPECT_EQ(ThermalStatusCode::SUCCESS, status.code); });
ASSERT_TRUE(ret.isOk());
}
// Test Thermal->unregisterThermalChangedCallback.
TEST_F(ThermalHidlTest, UnregisterThermalChangedCallbackTest) {
sp<ThermalCallback> localThermalCallback = new (std::nothrow) ThermalCallback();
// Expect to fail as the callback was not registered before
auto ret = mThermal->unregisterThermalChangedCallback(
localThermalCallback,
[](ThermalStatus status) { EXPECT_NE(ThermalStatusCode::SUCCESS, status.code); });
ASSERT_TRUE(ret.isOk());
// Register a local callback
ret = mThermal->registerThermalChangedCallback(
localThermalCallback, false, TemperatureType::SKIN,
[](ThermalStatus status) { EXPECT_EQ(ThermalStatusCode::SUCCESS, status.code); });
ASSERT_TRUE(ret.isOk());
// Expect to succeed with callback removed
ret = mThermal->unregisterThermalChangedCallback(
localThermalCallback,
[](ThermalStatus status) { EXPECT_EQ(ThermalStatusCode::SUCCESS, status.code); });
ASSERT_TRUE(ret.isOk());
// Expect to fail as the callback has been unregistered already
ret = mThermal->unregisterThermalChangedCallback(
localThermalCallback,
[](ThermalStatus status) { EXPECT_NE(ThermalStatusCode::SUCCESS, status.code); });
ASSERT_TRUE(ret.isOk());
}
// Sanity test for Thermal::getCurrentTemperatures().
TEST_F(ThermalHidlTest, TemperatureTest) {
mThermal->getCurrentTemperatures(false, TemperatureType::SKIN,
[](ThermalStatus status, hidl_vec<Temperature> temperatures) {
if (temperatures.size()) {
EXPECT_EQ(ThermalStatusCode::SUCCESS, status.code);
} else {
EXPECT_NE(ThermalStatusCode::SUCCESS, status.code);
}
});
for (int i = static_cast<int>(TemperatureType::UNKNOWN);
i <= static_cast<int>(TemperatureType::POWER_AMPLIFIER); ++i) {
auto type = static_cast<TemperatureType>(i);
mThermal->getCurrentTemperatures(
true, type, [&type](ThermalStatus status, hidl_vec<Temperature> temperatures) {
if (temperatures.size()) {
EXPECT_EQ(ThermalStatusCode::SUCCESS, status.code);
} else {
EXPECT_NE(ThermalStatusCode::SUCCESS, status.code);
}
for (int i = 0; i < temperatures.size(); ++i) {
EXPECT_EQ(type, temperatures[i].type);
}
});
}
}
// Sanity test for Thermal::getTemperatureThresholds().
TEST_F(ThermalHidlTest, TemperatureThresholdTest) {
mThermal->getTemperatureThresholds(
false, TemperatureType::SKIN,
[](ThermalStatus status, hidl_vec<TemperatureThreshold> temperatures) {
if (temperatures.size()) {
EXPECT_EQ(ThermalStatusCode::SUCCESS, status.code);
} else {
EXPECT_NE(ThermalStatusCode::SUCCESS, status.code);
}
});
for (int i = static_cast<int>(TemperatureType::UNKNOWN);
i <= static_cast<int>(TemperatureType::POWER_AMPLIFIER); ++i) {
auto type = static_cast<TemperatureType>(i);
mThermal->getTemperatureThresholds(
true, type, [&type](ThermalStatus status, hidl_vec<TemperatureThreshold> temperatures) {
if (temperatures.size()) {
EXPECT_EQ(ThermalStatusCode::SUCCESS, status.code);
} else {
EXPECT_NE(ThermalStatusCode::SUCCESS, status.code);
}
for (int i = 0; i < temperatures.size(); ++i) {
EXPECT_EQ(type, temperatures[i].type);
}
});
}
}
// Sanity test for Thermal::getCurrentCoolingDevices().
TEST_F(ThermalHidlTest, CoolingDeviceTest) {
mThermal->getCurrentCoolingDevices(
false, CoolingType::CPU, [](ThermalStatus status, hidl_vec<CoolingDevice> cooling_devices) {
if (cooling_devices.size()) {
EXPECT_EQ(ThermalStatusCode::SUCCESS, status.code);
} else {
EXPECT_NE(ThermalStatusCode::SUCCESS, status.code);
}
});
for (int i = 0; i <= static_cast<int>(CoolingType::COMPONENT); ++i) {
auto type = static_cast<CoolingType>(i);
mThermal->getCurrentCoolingDevices(
true, type, [&type](ThermalStatus status, hidl_vec<CoolingDevice> cooling_devices) {
if (cooling_devices.size()) {
EXPECT_EQ(ThermalStatusCode::SUCCESS, status.code);
} else {
EXPECT_NE(ThermalStatusCode::SUCCESS, status.code);
}
for (int i = 0; i < cooling_devices.size(); ++i) {
EXPECT_EQ(type, cooling_devices[i].type);
}
});
}
}
int main(int argc, char** argv) {
::testing::AddGlobalTestEnvironment(ThermalHidlEnvironment::Instance());
::testing::InitGoogleTest(&argc, argv);
ThermalHidlEnvironment::Instance()->init(&argc, argv);
int status = RUN_ALL_TESTS();
cout << "Test result = " << status << std::endl;
return status;
}