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 <nativehelper/JNIHelp.h>
 #include "jni.h"

 #include <math.h>
 #include <stdlib.h>

 #include <android/hardware/thermal/1.0/IThermal.h>
 #include <utils/Log.h>
 #include <utils/String8.h>

 #include "core_jni_helpers.h"

 namespace android {

 using android::hidl::base::V1_0::IBase;
 using hardware::hidl_death_recipient;
 using hardware::hidl_vec;
 using hardware::thermal::V1_0::CoolingDevice;
 using hardware::thermal::V1_0::CpuUsage;
 using hardware::thermal::V1_0::IThermal;
 using hardware::thermal::V1_0::Temperature;
 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<IThermal> gThermalHal = nullptr;

 // struct ThermalHalDeathRecipient;
 struct ThermalHalDeathRecipient : 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("ThermalHAL just died");
           gThermalHal = nullptr;
           getThermalHalLocked();
       }
 };

 sp<ThermalHalDeathRecipient> gThermalHalDeathRecipient = nullptr;

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

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

 // The caller must be holding gThermalHalMutex.
 static void getThermalHalLocked() {
     if (gThermalHal != nullptr) {
         return;
     }

     gThermalHal = IThermal::getService();

     if (gThermalHal == nullptr) {
         ALOGE("Unable to get Thermal service.");
     } else {
         if (gThermalHalDeathRecipient == nullptr) {
             gThermalHalDeathRecipient = new ThermalHalDeathRecipient();
         }
         hardware::Return<bool> linked = gThermalHal->linkToDeath(
             gThermalHalDeathRecipient, 0x451F /* cookie */);
         if (!linked.isOk()) {
             ALOGE("Transaction error in linking to ThermalHAL death: %s",
             linked.description().c_str());
             gThermalHal = nullptr;
         } else if (!linked) {
             ALOGW("Unable to link to ThermalHal death notifications");
             gThermalHal = 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 nativeGetFanSpeeds(JNIEnv *env, jclass /* clazz */) {
     std::lock_guard<std::mutex> lock(gThermalHalMutex);
     getThermalHalLocked();
     if (gThermalHal == nullptr) {
         ALOGE("Couldn't get fan speeds because of HAL error.");
         return env->NewFloatArray(0);
     }

     hidl_vec<CoolingDevice> list;
     Return<void> ret = gThermalHal->getCoolingDevices(
             [&list](ThermalStatus status, hidl_vec<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("getCoolingDevices failed status: %s", ret.description().c_str());
     }

     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 nativeGetDeviceTemperatures(JNIEnv *env, jclass /* clazz */, int type,
                                                int source) {
     std::lock_guard<std::mutex> lock(gThermalHalMutex);
     getThermalHalLocked();
     if (gThermalHal == nullptr) {
         ALOGE("Couldn't get device temperatures because of HAL error.");
         return env->NewFloatArray(0);
     }
     hidl_vec<Temperature> list;
     Return<void> ret = gThermalHal->getTemperatures(
             [&list](ThermalStatus status, hidl_vec<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());
     }

     jfloat 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 jobjectArray nativeGetCpuUsages(JNIEnv *env, jclass /* clazz */) {
     std::lock_guard<std::mutex> lock(gThermalHalMutex);
     getThermalHalLocked();
     if (gThermalHal == nullptr || !gCpuUsageInfoClassInfo.initMethod) {
         ALOGE("Couldn't get CPU usages because of HAL error.");
         return env->NewObjectArray(0, gCpuUsageInfoClassInfo.clazz, nullptr);
     }
     hidl_vec<CpuUsage> list;
     Return<void> ret = gThermalHal->getCpuUsages(
             [&list](ThermalStatus status, hidl_vec<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());
     }

     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 <nativehelper/JNIHelp.h>
	#include "jni.h"

	#include <math.h>
	#include <stdlib.h>

	#include <android/hardware/thermal/1.0/IThermal.h>
	#include <utils/Log.h>
	#include <utils/String8.h>

	#include "core_jni_helpers.h"

	namespace android {

	using android::hidl::base::V1_0::IBase;
	using hardware::hidl_death_recipient;
	using hardware::hidl_vec;
	using hardware::thermal::V1_0::CoolingDevice;
	using hardware::thermal::V1_0::CpuUsage;
	using hardware::thermal::V1_0::IThermal;
	using hardware::thermal::V1_0::Temperature;
	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<IThermal> gThermalHal = nullptr;

	// struct ThermalHalDeathRecipient;
	struct ThermalHalDeathRecipient : 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("ThermalHAL just died");
	gThermalHal = nullptr;
	getThermalHalLocked();
	}
	};

	sp<ThermalHalDeathRecipient> gThermalHalDeathRecipient = nullptr;

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

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

	// The caller must be holding gThermalHalMutex.
	static void getThermalHalLocked() {
	if (gThermalHal != nullptr) {
	return;
	}

	gThermalHal = IThermal::getService();

	if (gThermalHal == nullptr) {
	ALOGE("Unable to get Thermal service.");
	} else {
	if (gThermalHalDeathRecipient == nullptr) {
	gThermalHalDeathRecipient = new ThermalHalDeathRecipient();
	}
	hardware::Return<bool> linked = gThermalHal->linkToDeath(
	gThermalHalDeathRecipient, 0x451F /* cookie */);
	if (!linked.isOk()) {
	ALOGE("Transaction error in linking to ThermalHAL death: %s",
	linked.description().c_str());
	gThermalHal = nullptr;
	} else if (!linked) {
	ALOGW("Unable to link to ThermalHal death notifications");
	gThermalHal = 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 nativeGetFanSpeeds(JNIEnv env, jclass / clazz */) {
	std::lock_guard<std::mutex> lock(gThermalHalMutex);
	getThermalHalLocked();
	if (gThermalHal == nullptr) {
	ALOGE("Couldn't get fan speeds because of HAL error.");
	return env->NewFloatArray(0);
	}

	hidl_vec<CoolingDevice> list;
	Return<void> ret = gThermalHal->getCoolingDevices(
	[&list](ThermalStatus status, hidl_vec<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("getCoolingDevices failed status: %s", ret.description().c_str());
	}

	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 nativeGetDeviceTemperatures(JNIEnv env, jclass / clazz */, int type,
	int source) {
	std::lock_guard<std::mutex> lock(gThermalHalMutex);
	getThermalHalLocked();
	if (gThermalHal == nullptr) {
	ALOGE("Couldn't get device temperatures because of HAL error.");
	return env->NewFloatArray(0);
	}
	hidl_vec<Temperature> list;
	Return<void> ret = gThermalHal->getTemperatures(
	[&list](ThermalStatus status, hidl_vec<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());
	}

	jfloat 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 jobjectArray nativeGetCpuUsages(JNIEnv env, jclass / clazz */) {
	std::lock_guard<std::mutex> lock(gThermalHalMutex);
	getThermalHalLocked();
	if (gThermalHal == nullptr \|\| !gCpuUsageInfoClassInfo.initMethod) {
	ALOGE("Couldn't get CPU usages because of HAL error.");
	return env->NewObjectArray(0, gCpuUsageInfoClassInfo.clazz, nullptr);
	}
	hidl_vec<CpuUsage> list;
	Return<void> ret = gThermalHal->getCpuUsages(
	[&list](ThermalStatus status, hidl_vec<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());
	}

	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 */