services/core/jni/com_android_server_HardwarePropertiesManagerService.cpp - platform/frameworks/base - Git at Google

 /*
  * Copyright (C) 2015 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 "HardwarePropertiesManagerService-JNI"

 #include <aidl/android/hardware/thermal/IThermal.h>
 #include <android/binder_manager.h>
 #include <android/hardware/thermal/1.0/IThermal.h>
 #include <math.h>
 #include <nativehelper/JNIHelp.h>
 #include <utils/Log.h>
 #include <utils/String8.h>

 #include "core_jni_helpers.h"
 #include "jni.h"

 namespace android {

 using ::aidl::android::hardware::thermal::CoolingDevice;
 using ::aidl::android::hardware::thermal::IThermal;
 using ::aidl::android::hardware::thermal::Temperature;
 using ::aidl::android::hardware::thermal::TemperatureThreshold;
 using ::aidl::android::hardware::thermal::TemperatureType;
 using ::aidl::android::hardware::thermal::ThrottlingSeverity;
 using android::hidl::base::V1_0::IBase;
 using hardware::hidl_death_recipient;
 using hardware::hidl_vec;
 using hardware::thermal::V1_0::ThermalStatus;
 using hardware::thermal::V1_0::ThermalStatusCode;
 template<typename T>
 using Return = hardware::Return<T>;

 // ---------------------------------------------------------------------------

 // These values must be kept in sync with the temperature source constants in
 // HardwarePropertiesManager.java
 enum {
     TEMPERATURE_CURRENT = 0,
     TEMPERATURE_THROTTLING = 1,
     TEMPERATURE_SHUTDOWN = 2,
     TEMPERATURE_THROTTLING_BELOW_VR_MIN = 3
 };

 static struct {
     jclass clazz;
     jmethodID initMethod;
 } gCpuUsageInfoClassInfo;

 jfloat gUndefinedTemperature;

 static void getThermalHalLocked();
 static std::mutex gThermalHalMutex;
 static sp<hardware::thermal::V1_0::IThermal> gThermalHidlHal = nullptr;
 static std::shared_ptr<IThermal> gThermalAidlHal = nullptr;

 struct ThermalHidlHalDeathRecipient : virtual public hidl_death_recipient {
     // hidl_death_recipient interface
     virtual void serviceDied(uint64_t cookie, const wp<IBase> &who) override {
         std::lock_guard<std::mutex> lock(gThermalHalMutex);
         ALOGE("Thermal HAL just died");
         gThermalHidlHal = nullptr;
         getThermalHalLocked();
     }
 };

 static void onThermalAidlBinderDied(void *cookie) {
     std::lock_guard<std::mutex> lock(gThermalHalMutex);
     ALOGE("Thermal AIDL HAL just died");
     gThermalAidlHal = nullptr;
     getThermalHalLocked();
 }

 sp<ThermalHidlHalDeathRecipient> gThermalHidlHalDeathRecipient = nullptr;
 ndk::ScopedAIBinder_DeathRecipient gThermalAidlDeathRecipient;

 // ----------------------------------------------------------------------------

 float finalizeTemperature(float temperature) {
     return isnan(temperature) ? gUndefinedTemperature : temperature;
 }

 // The caller must be holding gThermalHalMutex.
 static void getThermalHalLocked() {
     if (gThermalAidlHal || gThermalHidlHal) {
         return;
     }
     const std::string thermalInstanceName = std::string(IThermal::descriptor) + "/default";
     if (AServiceManager_isDeclared(thermalInstanceName.c_str())) {
         auto binder = AServiceManager_waitForService(thermalInstanceName.c_str());
         auto thermalAidlService = IThermal::fromBinder(ndk::SpAIBinder(binder));
         if (thermalAidlService) {
             gThermalAidlHal = thermalAidlService;
             if (gThermalAidlDeathRecipient.get() == nullptr) {
                 gThermalAidlDeathRecipient = ndk::ScopedAIBinder_DeathRecipient(
                         AIBinder_DeathRecipient_new(onThermalAidlBinderDied));
             }
             auto linked = AIBinder_linkToDeath(thermalAidlService->asBinder().get(),
                                                gThermalAidlDeathRecipient.get(), nullptr);
             if (linked != STATUS_OK) {
                 ALOGW("Failed to link to death (AIDL): %d", linked);
                 gThermalAidlHal = nullptr;
             }
         } else {
             ALOGE("Unable to get Thermal AIDL service");
         }
         return;
     }

     ALOGI("Thermal AIDL service is not declared, trying HIDL");
     gThermalHidlHal = hardware::thermal::V1_0::IThermal::getService();

     if (gThermalHidlHal == nullptr) {
         ALOGE("Unable to get Thermal service.");
     } else {
         if (gThermalHidlHalDeathRecipient == nullptr) {
             gThermalHidlHalDeathRecipient = new ThermalHidlHalDeathRecipient();
         }
         hardware::Return<bool> linked =
                 gThermalHidlHal->linkToDeath(gThermalHidlHalDeathRecipient, 0x451F /* cookie */);
         if (!linked.isOk()) {
             ALOGE("Transaction error in linking to ThermalHAL death: %s",
                   linked.description().c_str());
             gThermalHidlHal = nullptr;
         } else if (!linked) {
             ALOGW("Unable to link to ThermalHal death notifications");
             gThermalHidlHal = nullptr;
         } else {
             ALOGD("Link to death notification successful");
         }
     }
 }

 static void nativeInit(JNIEnv* env, jobject obj) {
     std::lock_guard<std::mutex> lock(gThermalHalMutex);
     getThermalHalLocked();
 }

 static jfloatArray getFanSpeedsAidl(JNIEnv *env) {
     std::vector<CoolingDevice> list;
     auto status = gThermalAidlHal->getCoolingDevices(&list);
     if (!status.isOk()) {
         ALOGE("getFanSpeeds failed status: %s", status.getMessage());
         return env->NewFloatArray(0);
     }
     float values[list.size()];
     for (size_t i = 0; i < list.size(); ++i) {
         values[i] = list[i].value;
     }
     jfloatArray fanSpeeds = env->NewFloatArray(list.size());
     env->SetFloatArrayRegion(fanSpeeds, 0, list.size(), values);
     return fanSpeeds;
 }

 static jfloatArray getFanSpeedsHidl(JNIEnv *env) {
     hidl_vec<hardware::thermal::V1_0::CoolingDevice> list;
     Return<void> ret = gThermalHidlHal->getCoolingDevices(
             [&list](ThermalStatus status,
                     hidl_vec<hardware::thermal::V1_0::CoolingDevice> devices) {
                 if (status.code == ThermalStatusCode::SUCCESS) {
                     list = std::move(devices);
                 } else {
                     ALOGE("Couldn't get fan speeds because of HAL error: %s",
                           status.debugMessage.c_str());
                 }
             });

     if (!ret.isOk()) {
         ALOGE("getFanSpeeds failed status: %s", ret.description().c_str());
         return env->NewFloatArray(0);
     }
     float values[list.size()];
     for (size_t i = 0; i < list.size(); ++i) {
         values[i] = list[i].currentValue;
     }
     jfloatArray fanSpeeds = env->NewFloatArray(list.size());
     env->SetFloatArrayRegion(fanSpeeds, 0, list.size(), values);
     return fanSpeeds;
 }

 static jfloatArray nativeGetFanSpeeds(JNIEnv *env, jclass /* clazz */) {
     std::lock_guard<std::mutex> lock(gThermalHalMutex);
     getThermalHalLocked();
     if (!gThermalHidlHal && !gThermalAidlHal) {
         ALOGE("Couldn't get fan speeds because of HAL error.");
         return env->NewFloatArray(0);
     }
     if (gThermalAidlHal) {
         return getFanSpeedsAidl(env);
     }
     return getFanSpeedsHidl(env);
 }

 static jfloatArray getDeviceTemperaturesAidl(JNIEnv *env, int type, int source) {
     jfloat *values;
     size_t length = 0;
     if (source == TEMPERATURE_CURRENT) {
         std::vector<Temperature> list;
         auto status =
                 gThermalAidlHal->getTemperaturesWithType(static_cast<TemperatureType>(type), &list);

         if (!status.isOk()) {
             ALOGE("getDeviceTemperatures failed status: %s", status.getMessage());
             return env->NewFloatArray(0);
         }
         values = new jfloat[list.size()];
         for (const auto &temp : list) {
             if (static_cast<int>(temp.type) == type) {
                 values[length++] = finalizeTemperature(temp.value);
             }
         }
     } else if (source == TEMPERATURE_THROTTLING_BELOW_VR_MIN) {
         values = new jfloat[1];
         values[length++] = gUndefinedTemperature;
     } else {
         std::vector<TemperatureThreshold> list;
         auto status =
                 gThermalAidlHal->getTemperatureThresholdsWithType(static_cast<TemperatureType>(
                                                                           type),
                                                                   &list);

         if (!status.isOk()) {
             ALOGE("getDeviceTemperatures failed status: %s", status.getMessage());
             return env->NewFloatArray(0);
         }
         values = new jfloat[list.size()];
         for (auto &t : list) {
             if (static_cast<int>(t.type) == type) {
                 switch (source) {
                     case TEMPERATURE_THROTTLING:
                         values[length++] =
                                 finalizeTemperature(t.hotThrottlingThresholds[static_cast<int>(
                                         ThrottlingSeverity::SEVERE)]);
                         break;
                     case TEMPERATURE_SHUTDOWN:
                         values[length++] =
                                 finalizeTemperature(t.hotThrottlingThresholds[static_cast<int>(
                                         ThrottlingSeverity::SHUTDOWN)]);
                         break;
                 }
             }
         }
     }
     jfloatArray deviceTemps = env->NewFloatArray(length);
     env->SetFloatArrayRegion(deviceTemps, 0, length, values);
     return deviceTemps;
 }

 static jfloatArray getDeviceTemperaturesHidl(JNIEnv *env, int type, int source) {
     hidl_vec<hardware::thermal::V1_0::Temperature> list;
     Return<void> ret = gThermalHidlHal->getTemperatures(
             [&list](ThermalStatus status,
                     hidl_vec<hardware::thermal::V1_0::Temperature> temperatures) {
                 if (status.code == ThermalStatusCode::SUCCESS) {
                     list = std::move(temperatures);
                 } else {
                     ALOGE("Couldn't get temperatures because of HAL error: %s",
                           status.debugMessage.c_str());
                 }
             });

     if (!ret.isOk()) {
         ALOGE("getDeviceTemperatures failed status: %s", ret.description().c_str());
         return env->NewFloatArray(0);
     }
     float values[list.size()];
     size_t length = 0;
     for (size_t i = 0; i < list.size(); ++i) {
         if (static_cast<int>(list[i].type) == type) {
             switch (source) {
                 case TEMPERATURE_CURRENT:
                     values[length++] = finalizeTemperature(list[i].currentValue);
                     break;
                 case TEMPERATURE_THROTTLING:
                     values[length++] = finalizeTemperature(list[i].throttlingThreshold);
                     break;
                 case TEMPERATURE_SHUTDOWN:
                     values[length++] = finalizeTemperature(list[i].shutdownThreshold);
                     break;
                 case TEMPERATURE_THROTTLING_BELOW_VR_MIN:
                     values[length++] = finalizeTemperature(list[i].vrThrottlingThreshold);
                     break;
             }
         }
     }
     jfloatArray deviceTemps = env->NewFloatArray(length);
     env->SetFloatArrayRegion(deviceTemps, 0, length, values);
     return deviceTemps;
 }

 static jfloatArray nativeGetDeviceTemperatures(JNIEnv *env, jclass /* clazz */, int type,
                                                int source) {
     std::lock_guard<std::mutex> lock(gThermalHalMutex);
     getThermalHalLocked();
     if (!gThermalHidlHal && !gThermalAidlHal) {
         ALOGE("Couldn't get device temperatures because of HAL error.");
         return env->NewFloatArray(0);
     }
     if (gThermalAidlHal) {
         return getDeviceTemperaturesAidl(env, type, source);
     }
     return getDeviceTemperaturesHidl(env, type, source);
 }

 static jobjectArray nativeGetCpuUsages(JNIEnv *env, jclass /* clazz */) {
     std::lock_guard<std::mutex> lock(gThermalHalMutex);
     getThermalHalLocked();
     if (gThermalAidlHal) {
         ALOGW("getCpuUsages is not supported");
         return env->NewObjectArray(0, gCpuUsageInfoClassInfo.clazz, nullptr);
     }
     if (gThermalHidlHal == nullptr || !gCpuUsageInfoClassInfo.initMethod) {
         ALOGE("Couldn't get CPU usages because of HAL error.");
         return env->NewObjectArray(0, gCpuUsageInfoClassInfo.clazz, nullptr);
     }
     hidl_vec<hardware::thermal::V1_0::CpuUsage> list;
     Return<void> ret = gThermalHidlHal->getCpuUsages(
             [&list](ThermalStatus status, hidl_vec<hardware::thermal::V1_0::CpuUsage> cpuUsages) {
                 if (status.code == ThermalStatusCode::SUCCESS) {
                     list = std::move(cpuUsages);
                 } else {
                     ALOGE("Couldn't get CPU usages because of HAL error: %s",
                           status.debugMessage.c_str());
                 }
             });

     if (!ret.isOk()) {
         ALOGE("getCpuUsages failed status: %s", ret.description().c_str());
         return env->NewObjectArray(0, gCpuUsageInfoClassInfo.clazz, nullptr);
     }

     jobjectArray cpuUsages = env->NewObjectArray(list.size(), gCpuUsageInfoClassInfo.clazz,
                                                  nullptr);
     for (size_t i = 0; i < list.size(); ++i) {
         if (list[i].isOnline) {
             jobject cpuUsage = env->NewObject(gCpuUsageInfoClassInfo.clazz,
                                               gCpuUsageInfoClassInfo.initMethod,
                                               list[i].active,
                                               list[i].total);
             env->SetObjectArrayElement(cpuUsages, i, cpuUsage);
         }
     }
     return cpuUsages;
 }

 // ----------------------------------------------------------------------------

 static const JNINativeMethod gHardwarePropertiesManagerServiceMethods[] = {
     /* name, signature, funcPtr */
     { "nativeInit", "()V",
             (void*) nativeInit },
     { "nativeGetFanSpeeds", "()[F",
             (void*) nativeGetFanSpeeds },
     { "nativeGetDeviceTemperatures", "(II)[F",
             (void*) nativeGetDeviceTemperatures },
     { "nativeGetCpuUsages", "()[Landroid/os/CpuUsageInfo;",
             (void*) nativeGetCpuUsages }
 };

 int register_android_server_HardwarePropertiesManagerService(JNIEnv* env) {
     int res = jniRegisterNativeMethods(env, "com/android/server/HardwarePropertiesManagerService",
                                        gHardwarePropertiesManagerServiceMethods,
                                        NELEM(gHardwarePropertiesManagerServiceMethods));
     jclass clazz = env->FindClass("android/os/CpuUsageInfo");
     gCpuUsageInfoClassInfo.clazz = MakeGlobalRefOrDie(env, clazz);
     gCpuUsageInfoClassInfo.initMethod = GetMethodIDOrDie(env, gCpuUsageInfoClassInfo.clazz,
                                                          "<init>", "(JJ)V");

     clazz = env->FindClass("android/os/HardwarePropertiesManager");
     jfieldID undefined_temperature_field = GetStaticFieldIDOrDie(env, clazz,
                                                                  "UNDEFINED_TEMPERATURE", "F");
     gUndefinedTemperature = env->GetStaticFloatField(clazz, undefined_temperature_field);

     return res;
 }

 } /* namespace android */
	/*
	* Copyright (C) 2015 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 "HardwarePropertiesManagerService-JNI"

	#include <aidl/android/hardware/thermal/IThermal.h>
	#include <android/binder_manager.h>
	#include <android/hardware/thermal/1.0/IThermal.h>
	#include <math.h>
	#include <nativehelper/JNIHelp.h>
	#include <utils/Log.h>
	#include <utils/String8.h>

	#include "core_jni_helpers.h"
	#include "jni.h"

	namespace android {

	using ::aidl::android::hardware::thermal::CoolingDevice;
	using ::aidl::android::hardware::thermal::IThermal;
	using ::aidl::android::hardware::thermal::Temperature;
	using ::aidl::android::hardware::thermal::TemperatureThreshold;
	using ::aidl::android::hardware::thermal::TemperatureType;
	using ::aidl::android::hardware::thermal::ThrottlingSeverity;
	using android::hidl::base::V1_0::IBase;
	using hardware::hidl_death_recipient;
	using hardware::hidl_vec;
	using hardware::thermal::V1_0::ThermalStatus;
	using hardware::thermal::V1_0::ThermalStatusCode;
	template<typename T>
	using Return = hardware::Return<T>;

	// ---------------------------------------------------------------------------

	// These values must be kept in sync with the temperature source constants in
	// HardwarePropertiesManager.java
	enum {
	TEMPERATURE_CURRENT = 0,
	TEMPERATURE_THROTTLING = 1,
	TEMPERATURE_SHUTDOWN = 2,
	TEMPERATURE_THROTTLING_BELOW_VR_MIN = 3
	};

	static struct {
	jclass clazz;
	jmethodID initMethod;
	} gCpuUsageInfoClassInfo;

	jfloat gUndefinedTemperature;

	static void getThermalHalLocked();
	static std::mutex gThermalHalMutex;
	static sp<hardware::thermal::V1_0::IThermal> gThermalHidlHal = nullptr;
	static std::shared_ptr<IThermal> gThermalAidlHal = nullptr;

	struct ThermalHidlHalDeathRecipient : virtual public hidl_death_recipient {
	// hidl_death_recipient interface
	virtual void serviceDied(uint64_t cookie, const wp<IBase> &who) override {
	std::lock_guard<std::mutex> lock(gThermalHalMutex);
	ALOGE("Thermal HAL just died");
	gThermalHidlHal = nullptr;
	getThermalHalLocked();
	}
	};

	static void onThermalAidlBinderDied(void *cookie) {
	std::lock_guard<std::mutex> lock(gThermalHalMutex);
	ALOGE("Thermal AIDL HAL just died");
	gThermalAidlHal = nullptr;
	getThermalHalLocked();
	}

	sp<ThermalHidlHalDeathRecipient> gThermalHidlHalDeathRecipient = nullptr;
	ndk::ScopedAIBinder_DeathRecipient gThermalAidlDeathRecipient;

	// ----------------------------------------------------------------------------

	float finalizeTemperature(float temperature) {
	return isnan(temperature) ? gUndefinedTemperature : temperature;
	}

	// The caller must be holding gThermalHalMutex.
	static void getThermalHalLocked() {
	if (gThermalAidlHal \|\| gThermalHidlHal) {
	return;
	}
	const std::string thermalInstanceName = std::string(IThermal::descriptor) + "/default";
	if (AServiceManager_isDeclared(thermalInstanceName.c_str())) {
	auto binder = AServiceManager_waitForService(thermalInstanceName.c_str());
	auto thermalAidlService = IThermal::fromBinder(ndk::SpAIBinder(binder));
	if (thermalAidlService) {
	gThermalAidlHal = thermalAidlService;
	if (gThermalAidlDeathRecipient.get() == nullptr) {
	gThermalAidlDeathRecipient = ndk::ScopedAIBinder_DeathRecipient(
	AIBinder_DeathRecipient_new(onThermalAidlBinderDied));
	}
	auto linked = AIBinder_linkToDeath(thermalAidlService->asBinder().get(),
	gThermalAidlDeathRecipient.get(), nullptr);
	if (linked != STATUS_OK) {
	ALOGW("Failed to link to death (AIDL): %d", linked);
	gThermalAidlHal = nullptr;
	}
	} else {
	ALOGE("Unable to get Thermal AIDL service");
	}
	return;
	}

	ALOGI("Thermal AIDL service is not declared, trying HIDL");
	gThermalHidlHal = hardware::thermal::V1_0::IThermal::getService();

	if (gThermalHidlHal == nullptr) {
	ALOGE("Unable to get Thermal service.");
	} else {
	if (gThermalHidlHalDeathRecipient == nullptr) {
	gThermalHidlHalDeathRecipient = new ThermalHidlHalDeathRecipient();
	}
	hardware::Return<bool> linked =
	gThermalHidlHal->linkToDeath(gThermalHidlHalDeathRecipient, 0x451F /* cookie */);
	if (!linked.isOk()) {
	ALOGE("Transaction error in linking to ThermalHAL death: %s",
	linked.description().c_str());
	gThermalHidlHal = nullptr;
	} else if (!linked) {
	ALOGW("Unable to link to ThermalHal death notifications");
	gThermalHidlHal = nullptr;
	} else {
	ALOGD("Link to death notification successful");
	}
	}
	}

	static void nativeInit(JNIEnv* env, jobject obj) {
	std::lock_guard<std::mutex> lock(gThermalHalMutex);
	getThermalHalLocked();
	}

	static jfloatArray getFanSpeedsAidl(JNIEnv *env) {
	std::vector<CoolingDevice> list;
	auto status = gThermalAidlHal->getCoolingDevices(&list);
	if (!status.isOk()) {
	ALOGE("getFanSpeeds failed status: %s", status.getMessage());
	return env->NewFloatArray(0);
	}
	float values[list.size()];
	for (size_t i = 0; i < list.size(); ++i) {
	values[i] = list[i].value;
	}
	jfloatArray fanSpeeds = env->NewFloatArray(list.size());
	env->SetFloatArrayRegion(fanSpeeds, 0, list.size(), values);
	return fanSpeeds;
	}

	static jfloatArray getFanSpeedsHidl(JNIEnv *env) {
	hidl_vec<hardware::thermal::V1_0::CoolingDevice> list;
	Return<void> ret = gThermalHidlHal->getCoolingDevices(
	[&list](ThermalStatus status,
	hidl_vec<hardware::thermal::V1_0::CoolingDevice> devices) {
	if (status.code == ThermalStatusCode::SUCCESS) {
	list = std::move(devices);
	} else {
	ALOGE("Couldn't get fan speeds because of HAL error: %s",
	status.debugMessage.c_str());
	}
	});

	if (!ret.isOk()) {
	ALOGE("getFanSpeeds failed status: %s", ret.description().c_str());
	return env->NewFloatArray(0);
	}
	float values[list.size()];
	for (size_t i = 0; i < list.size(); ++i) {
	values[i] = list[i].currentValue;
	}
	jfloatArray fanSpeeds = env->NewFloatArray(list.size());
	env->SetFloatArrayRegion(fanSpeeds, 0, list.size(), values);
	return fanSpeeds;
	}

	static jfloatArray nativeGetFanSpeeds(JNIEnv env, jclass / clazz */) {
	std::lock_guard<std::mutex> lock(gThermalHalMutex);
	getThermalHalLocked();
	if (!gThermalHidlHal && !gThermalAidlHal) {
	ALOGE("Couldn't get fan speeds because of HAL error.");
	return env->NewFloatArray(0);
	}
	if (gThermalAidlHal) {
	return getFanSpeedsAidl(env);
	}
	return getFanSpeedsHidl(env);
	}

	static jfloatArray getDeviceTemperaturesAidl(JNIEnv *env, int type, int source) {
	jfloat *values;
	size_t length = 0;
	if (source == TEMPERATURE_CURRENT) {
	std::vector<Temperature> list;
	auto status =
	gThermalAidlHal->getTemperaturesWithType(static_cast<TemperatureType>(type), &list);

	if (!status.isOk()) {
	ALOGE("getDeviceTemperatures failed status: %s", status.getMessage());
	return env->NewFloatArray(0);
	}
	values = new jfloat[list.size()];
	for (const auto &temp : list) {
	if (static_cast<int>(temp.type) == type) {
	values[length++] = finalizeTemperature(temp.value);
	}
	}
	} else if (source == TEMPERATURE_THROTTLING_BELOW_VR_MIN) {
	values = new jfloat[1];
	values[length++] = gUndefinedTemperature;
	} else {
	std::vector<TemperatureThreshold> list;
	auto status =
	gThermalAidlHal->getTemperatureThresholdsWithType(static_cast<TemperatureType>(
	type),
	&list);

	if (!status.isOk()) {
	ALOGE("getDeviceTemperatures failed status: %s", status.getMessage());
	return env->NewFloatArray(0);
	}
	values = new jfloat[list.size()];
	for (auto &t : list) {
	if (static_cast<int>(t.type) == type) {
	switch (source) {
	case TEMPERATURE_THROTTLING:
	values[length++] =
	finalizeTemperature(t.hotThrottlingThresholds[static_cast<int>(
	ThrottlingSeverity::SEVERE)]);
	break;
	case TEMPERATURE_SHUTDOWN:
	values[length++] =
	finalizeTemperature(t.hotThrottlingThresholds[static_cast<int>(
	ThrottlingSeverity::SHUTDOWN)]);
	break;
	}
	}
	}
	}
	jfloatArray deviceTemps = env->NewFloatArray(length);
	env->SetFloatArrayRegion(deviceTemps, 0, length, values);
	return deviceTemps;
	}

	static jfloatArray getDeviceTemperaturesHidl(JNIEnv *env, int type, int source) {
	hidl_vec<hardware::thermal::V1_0::Temperature> list;
	Return<void> ret = gThermalHidlHal->getTemperatures(
	[&list](ThermalStatus status,
	hidl_vec<hardware::thermal::V1_0::Temperature> temperatures) {
	if (status.code == ThermalStatusCode::SUCCESS) {
	list = std::move(temperatures);
	} else {
	ALOGE("Couldn't get temperatures because of HAL error: %s",
	status.debugMessage.c_str());
	}
	});

	if (!ret.isOk()) {
	ALOGE("getDeviceTemperatures failed status: %s", ret.description().c_str());
	return env->NewFloatArray(0);
	}
	float values[list.size()];
	size_t length = 0;
	for (size_t i = 0; i < list.size(); ++i) {
	if (static_cast<int>(list[i].type) == type) {
	switch (source) {
	case TEMPERATURE_CURRENT:
	values[length++] = finalizeTemperature(list[i].currentValue);
	break;
	case TEMPERATURE_THROTTLING:
	values[length++] = finalizeTemperature(list[i].throttlingThreshold);
	break;
	case TEMPERATURE_SHUTDOWN:
	values[length++] = finalizeTemperature(list[i].shutdownThreshold);
	break;
	case TEMPERATURE_THROTTLING_BELOW_VR_MIN:
	values[length++] = finalizeTemperature(list[i].vrThrottlingThreshold);
	break;
	}
	}
	}
	jfloatArray deviceTemps = env->NewFloatArray(length);
	env->SetFloatArrayRegion(deviceTemps, 0, length, values);
	return deviceTemps;
	}

	static jfloatArray nativeGetDeviceTemperatures(JNIEnv env, jclass / clazz */, int type,
	int source) {
	std::lock_guard<std::mutex> lock(gThermalHalMutex);
	getThermalHalLocked();
	if (!gThermalHidlHal && !gThermalAidlHal) {
	ALOGE("Couldn't get device temperatures because of HAL error.");
	return env->NewFloatArray(0);
	}
	if (gThermalAidlHal) {
	return getDeviceTemperaturesAidl(env, type, source);
	}
	return getDeviceTemperaturesHidl(env, type, source);
	}

	static jobjectArray nativeGetCpuUsages(JNIEnv env, jclass / clazz */) {
	std::lock_guard<std::mutex> lock(gThermalHalMutex);
	getThermalHalLocked();
	if (gThermalAidlHal) {
	ALOGW("getCpuUsages is not supported");
	return env->NewObjectArray(0, gCpuUsageInfoClassInfo.clazz, nullptr);
	}
	if (gThermalHidlHal == nullptr \|\| !gCpuUsageInfoClassInfo.initMethod) {
	ALOGE("Couldn't get CPU usages because of HAL error.");
	return env->NewObjectArray(0, gCpuUsageInfoClassInfo.clazz, nullptr);
	}
	hidl_vec<hardware::thermal::V1_0::CpuUsage> list;
	Return<void> ret = gThermalHidlHal->getCpuUsages(
	[&list](ThermalStatus status, hidl_vec<hardware::thermal::V1_0::CpuUsage> cpuUsages) {
	if (status.code == ThermalStatusCode::SUCCESS) {
	list = std::move(cpuUsages);
	} else {
	ALOGE("Couldn't get CPU usages because of HAL error: %s",
	status.debugMessage.c_str());
	}
	});

	if (!ret.isOk()) {
	ALOGE("getCpuUsages failed status: %s", ret.description().c_str());
	return env->NewObjectArray(0, gCpuUsageInfoClassInfo.clazz, nullptr);
	}

	jobjectArray cpuUsages = env->NewObjectArray(list.size(), gCpuUsageInfoClassInfo.clazz,
	nullptr);
	for (size_t i = 0; i < list.size(); ++i) {
	if (list[i].isOnline) {
	jobject cpuUsage = env->NewObject(gCpuUsageInfoClassInfo.clazz,
	gCpuUsageInfoClassInfo.initMethod,
	list[i].active,
	list[i].total);
	env->SetObjectArrayElement(cpuUsages, i, cpuUsage);
	}
	}
	return cpuUsages;
	}

	// ----------------------------------------------------------------------------

	static const JNINativeMethod gHardwarePropertiesManagerServiceMethods[] = {
	/* name, signature, funcPtr */
	{ "nativeInit", "()V",
	(void*) nativeInit },
	{ "nativeGetFanSpeeds", "()[F",
	(void*) nativeGetFanSpeeds },
	{ "nativeGetDeviceTemperatures", "(II)[F",
	(void*) nativeGetDeviceTemperatures },
	{ "nativeGetCpuUsages", "()[Landroid/os/CpuUsageInfo;",
	(void*) nativeGetCpuUsages }
	};

	int register_android_server_HardwarePropertiesManagerService(JNIEnv* env) {
	int res = jniRegisterNativeMethods(env, "com/android/server/HardwarePropertiesManagerService",
	gHardwarePropertiesManagerServiceMethods,
	NELEM(gHardwarePropertiesManagerServiceMethods));
	jclass clazz = env->FindClass("android/os/CpuUsageInfo");
	gCpuUsageInfoClassInfo.clazz = MakeGlobalRefOrDie(env, clazz);
	gCpuUsageInfoClassInfo.initMethod = GetMethodIDOrDie(env, gCpuUsageInfoClassInfo.clazz,
	"<init>", "(JJ)V");

	clazz = env->FindClass("android/os/HardwarePropertiesManager");
	jfieldID undefined_temperature_field = GetStaticFieldIDOrDie(env, clazz,
	"UNDEFINED_TEMPERATURE", "F");
	gUndefinedTemperature = env->GetStaticFloatField(clazz, undefined_temperature_field);

	return res;
	}

	} /* namespace android */