| /* |
| * Copyright (C) 2020 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 "PowerStatsService" |
| |
| #include <android/hardware/power/stats/1.0/IPowerStats.h> |
| #include <jni.h> |
| #include <nativehelper/JNIHelp.h> |
| |
| #include <log/log.h> |
| |
| using android::hardware::hidl_vec; |
| using android::hardware::Return; |
| using android::hardware::power::stats::V1_0::EnergyData; |
| using android::hardware::power::stats::V1_0::RailInfo; |
| using android::hardware::power::stats::V1_0::Status; |
| |
| // Channel |
| static jclass class_C; |
| static jmethodID method_C_init; |
| static jfieldID field_C_id; |
| static jfieldID field_C_name; |
| static jfieldID field_C_subsystem; |
| |
| // EnergyMeasurement |
| static jclass class_EM; |
| static jmethodID method_EM_init; |
| static jfieldID field_EM_id; |
| static jfieldID field_EM_timestampMs; |
| static jfieldID field_EM_durationMs; |
| static jfieldID field_EM_energyUWs; |
| |
| // State |
| static jclass class_S; |
| static jmethodID method_S_init; |
| static jfieldID field_S_id; |
| static jfieldID field_S_name; |
| |
| // PowerEntity |
| static jclass class_PE; |
| static jmethodID method_PE_init; |
| static jfieldID field_PE_id; |
| static jfieldID field_PE_name; |
| static jfieldID field_PE_states; |
| |
| // StateResidency |
| static jclass class_SR; |
| static jmethodID method_SR_init; |
| static jfieldID field_SR_id; |
| static jfieldID field_SR_totalTimeInStateMs; |
| static jfieldID field_SR_totalStateEntryCount; |
| static jfieldID field_SR_lastEntryTimestampMs; |
| |
| // StateResidencyResult |
| static jclass class_SRR; |
| static jmethodID method_SRR_init; |
| static jfieldID field_SRR_id; |
| static jfieldID field_SRR_stateResidencyData; |
| |
| namespace android { |
| |
| static std::mutex gPowerStatsHalMutex; |
| static sp<android::hardware::power::stats::V1_0::IPowerStats> gPowerStatsHalV1_0_ptr = nullptr; |
| |
| static void deinitPowerStats() { |
| gPowerStatsHalV1_0_ptr = nullptr; |
| } |
| |
| struct PowerStatsHalDeathRecipient : virtual public hardware::hidl_death_recipient { |
| virtual void serviceDied(uint64_t cookie, |
| const wp<android::hidl::base::V1_0::IBase> &who) override { |
| // The HAL just died. Reset all handles to HAL services. |
| std::lock_guard<std::mutex> lock(gPowerStatsHalMutex); |
| deinitPowerStats(); |
| } |
| }; |
| |
| sp<PowerStatsHalDeathRecipient> gPowerStatsHalDeathRecipient = new PowerStatsHalDeathRecipient(); |
| |
| static bool connectToPowerStatsHal() { |
| if (gPowerStatsHalV1_0_ptr == nullptr) { |
| gPowerStatsHalV1_0_ptr = android::hardware::power::stats::V1_0::IPowerStats::getService(); |
| |
| if (gPowerStatsHalV1_0_ptr == nullptr) { |
| ALOGE("Unable to get power.stats HAL service."); |
| return false; |
| } |
| |
| // Link death recipient to power.stats service handle |
| hardware::Return<bool> linked = |
| gPowerStatsHalV1_0_ptr->linkToDeath(gPowerStatsHalDeathRecipient, 0); |
| if (!linked.isOk()) { |
| ALOGE("Transaction error in linking to power.stats HAL death: %s", |
| linked.description().c_str()); |
| deinitPowerStats(); |
| return false; |
| } else if (!linked) { |
| ALOGW("Unable to link to power.stats HAL death notifications"); |
| return false; |
| } |
| } |
| return true; |
| } |
| |
| static bool checkResult(const Return<void> &ret, const char *function) { |
| if (!ret.isOk()) { |
| ALOGE("%s failed: requested HAL service not available. Description: %s", function, |
| ret.description().c_str()); |
| if (ret.isDeadObject()) { |
| deinitPowerStats(); |
| } |
| return false; |
| } |
| return true; |
| } |
| |
| static jobjectArray nativeGetPowerEntityInfo(JNIEnv *env, jclass clazz) { |
| std::lock_guard<std::mutex> lock(gPowerStatsHalMutex); |
| |
| if (!connectToPowerStatsHal()) { |
| ALOGE("nativeGetPowerEntityInfo failed to connect to power.stats HAL"); |
| return nullptr; |
| } |
| |
| jobjectArray powerEntityArray = nullptr; |
| Return<void> ret = gPowerStatsHalV1_0_ptr->getPowerEntityInfo( |
| [&env, &powerEntityArray](auto infos, auto status) { |
| if (status != Status::SUCCESS) { |
| ALOGE("Error getting power entity info"); |
| } else { |
| powerEntityArray = env->NewObjectArray(infos.size(), class_PE, nullptr); |
| for (int i = 0; i < infos.size(); i++) { |
| jstring name = env->NewStringUTF(infos[i].powerEntityName.c_str()); |
| jobject powerEntity = env->NewObject(class_PE, method_PE_init); |
| env->SetIntField(powerEntity, field_PE_id, infos[i].powerEntityId); |
| env->SetObjectField(powerEntity, field_PE_name, name); |
| env->SetObjectArrayElement(powerEntityArray, i, powerEntity); |
| env->DeleteLocalRef(name); |
| env->DeleteLocalRef(powerEntity); |
| } |
| } |
| }); |
| if (!checkResult(ret, __func__)) { |
| return nullptr; |
| } |
| |
| ret = gPowerStatsHalV1_0_ptr |
| ->getPowerEntityStateInfo({}, [&env, &powerEntityArray](auto infos, auto status) { |
| if (status != Status::SUCCESS) { |
| ALOGE("Error getting power entity state info"); |
| } else { |
| for (int i = 0; i < infos.size(); i++) { |
| jobjectArray stateArray = |
| env->NewObjectArray(infos[i].states.size(), class_S, nullptr); |
| for (int j = 0; j < infos[i].states.size(); j++) { |
| jstring name = env->NewStringUTF( |
| infos[i].states[j].powerEntityStateName.c_str()); |
| jobject state = env->NewObject(class_S, method_S_init); |
| env->SetIntField(state, field_S_id, |
| infos[i].states[j].powerEntityStateId); |
| env->SetObjectField(state, field_S_name, name); |
| env->SetObjectArrayElement(stateArray, j, state); |
| env->DeleteLocalRef(name); |
| env->DeleteLocalRef(state); |
| } |
| |
| for (int j = 0; j < env->GetArrayLength(powerEntityArray); j++) { |
| jobject powerEntity = |
| env->GetObjectArrayElement(powerEntityArray, j); |
| if (env->GetIntField(powerEntity, field_PE_id) == |
| infos[i].powerEntityId) { |
| env->SetObjectField(powerEntity, field_PE_states, stateArray); |
| env->SetObjectArrayElement(powerEntityArray, j, powerEntity); |
| break; |
| } |
| } |
| } |
| } |
| }); |
| if (!checkResult(ret, __func__)) { |
| return nullptr; |
| } |
| |
| return powerEntityArray; |
| } |
| |
| static jobjectArray nativeGetStateResidency(JNIEnv *env, jclass clazz, jintArray powerEntityIds) { |
| std::lock_guard<std::mutex> lock(gPowerStatsHalMutex); |
| |
| if (!connectToPowerStatsHal()) { |
| ALOGE("nativeGetStateResidency failed to connect to power.stats HAL"); |
| return nullptr; |
| } |
| |
| size_t powerEntityIdCount = env->GetArrayLength(powerEntityIds); |
| hidl_vec<uint32_t> powerEntityIdVector(powerEntityIdCount); |
| |
| jint *powerEntityIdElements = env->GetIntArrayElements(powerEntityIds, 0); |
| for (int i = 0; i < powerEntityIdCount; i++) { |
| powerEntityIdVector[i] = powerEntityIdElements[i]; |
| } |
| env->ReleaseIntArrayElements(powerEntityIds, powerEntityIdElements, 0); |
| |
| jobjectArray stateResidencyResultArray = nullptr; |
| Return<void> ret = gPowerStatsHalV1_0_ptr->getPowerEntityStateResidencyData( |
| powerEntityIdVector, [&env, &stateResidencyResultArray](auto results, auto status) { |
| stateResidencyResultArray = env->NewObjectArray(results.size(), class_SRR, nullptr); |
| for (int i = 0; i < results.size(); i++) { |
| jobjectArray stateResidencyArray = |
| env->NewObjectArray(results[i].stateResidencyData.size(), class_SR, |
| nullptr); |
| for (int j = 0; j < results[i].stateResidencyData.size(); j++) { |
| jobject stateResidency = env->NewObject(class_SR, method_SR_init); |
| env->SetIntField(stateResidency, field_SR_id, |
| results[i].stateResidencyData[j].powerEntityStateId); |
| env->SetLongField(stateResidency, field_SR_totalTimeInStateMs, |
| results[i].stateResidencyData[j].totalTimeInStateMs); |
| env->SetLongField(stateResidency, field_SR_totalStateEntryCount, |
| results[i].stateResidencyData[j].totalStateEntryCount); |
| env->SetLongField(stateResidency, field_SR_lastEntryTimestampMs, |
| results[i].stateResidencyData[j].lastEntryTimestampMs); |
| env->SetObjectArrayElement(stateResidencyArray, j, stateResidency); |
| env->DeleteLocalRef(stateResidency); |
| } |
| jobject stateResidencyResult = env->NewObject(class_SRR, method_SRR_init); |
| env->SetIntField(stateResidencyResult, field_SRR_id, results[i].powerEntityId); |
| env->SetObjectField(stateResidencyResult, field_SRR_stateResidencyData, |
| stateResidencyArray); |
| env->SetObjectArrayElement(stateResidencyResultArray, i, stateResidencyResult); |
| env->DeleteLocalRef(stateResidencyResult); |
| } |
| }); |
| if (!checkResult(ret, __func__)) { |
| return nullptr; |
| } |
| |
| return stateResidencyResultArray; |
| } |
| |
| static jobjectArray nativeGetEnergyMeterInfo(JNIEnv *env, jclass clazz) { |
| std::lock_guard<std::mutex> lock(gPowerStatsHalMutex); |
| |
| if (!connectToPowerStatsHal()) { |
| ALOGE("nativeGetEnergyMeterInfo failed to connect to power.stats HAL"); |
| return nullptr; |
| } |
| |
| jobjectArray channelArray = nullptr; |
| Return<void> ret = |
| gPowerStatsHalV1_0_ptr->getRailInfo([&env, &channelArray](auto railInfo, auto status) { |
| if (status != Status::SUCCESS) { |
| ALOGW("Error getting rail info"); |
| } else { |
| channelArray = env->NewObjectArray(railInfo.size(), class_C, nullptr); |
| for (int i = 0; i < railInfo.size(); i++) { |
| jstring name = env->NewStringUTF(railInfo[i].railName.c_str()); |
| jstring subsystem = env->NewStringUTF(railInfo[i].subsysName.c_str()); |
| jobject channel = env->NewObject(class_C, method_C_init); |
| env->SetIntField(channel, field_C_id, railInfo[i].index); |
| env->SetObjectField(channel, field_C_name, name); |
| env->SetObjectField(channel, field_C_subsystem, subsystem); |
| env->SetObjectArrayElement(channelArray, i, channel); |
| env->DeleteLocalRef(name); |
| env->DeleteLocalRef(subsystem); |
| env->DeleteLocalRef(channel); |
| } |
| } |
| }); |
| |
| if (!checkResult(ret, __func__)) { |
| ALOGE("getRailInfo failed"); |
| return nullptr; |
| } |
| |
| return channelArray; |
| } |
| |
| static jobjectArray nativeReadEnergyMeters(JNIEnv *env, jclass clazz, jintArray channelIds) { |
| std::lock_guard<std::mutex> lock(gPowerStatsHalMutex); |
| |
| if (!connectToPowerStatsHal()) { |
| ALOGE("nativeGetEnergy failed to connect to power.stats HAL"); |
| } |
| |
| size_t channelIdCount = env->GetArrayLength(channelIds); |
| hidl_vec<uint32_t> channelIdVector(channelIdCount); |
| |
| jint *channelIdElements = env->GetIntArrayElements(channelIds, 0); |
| for (int i = 0; i < channelIdCount; i++) { |
| channelIdVector[i] = channelIdElements[i]; |
| } |
| env->ReleaseIntArrayElements(channelIds, channelIdElements, 0); |
| |
| jobjectArray energyMeasurementArray = nullptr; |
| Return<void> ret = |
| gPowerStatsHalV1_0_ptr |
| ->getEnergyData(channelIdVector, |
| [&env, &energyMeasurementArray](auto energyData, auto status) { |
| energyMeasurementArray = |
| env->NewObjectArray(energyData.size(), class_EM, |
| nullptr); |
| for (int i = 0; i < energyData.size(); i++) { |
| jobject energyMeasurement = |
| env->NewObject(class_EM, method_EM_init); |
| env->SetIntField(energyMeasurement, field_EM_id, |
| energyData[i].index); |
| env->SetLongField(energyMeasurement, |
| field_EM_timestampMs, |
| energyData[i].timestamp); |
| env->SetLongField(energyMeasurement, |
| field_EM_durationMs, |
| energyData[i].timestamp); |
| env->SetLongField(energyMeasurement, field_EM_energyUWs, |
| energyData[i].energy); |
| env->SetObjectArrayElement(energyMeasurementArray, i, |
| energyMeasurement); |
| env->DeleteLocalRef(energyMeasurement); |
| } |
| }); |
| |
| if (!checkResult(ret, __func__)) { |
| ALOGE("getEnergyData failed"); |
| return nullptr; |
| } |
| |
| return energyMeasurementArray; |
| } |
| |
| static jboolean nativeInit(JNIEnv *env, jclass clazz) { |
| std::lock_guard<std::mutex> lock(gPowerStatsHalMutex); |
| |
| // Channel |
| jclass temp = env->FindClass("android/hardware/power/stats/Channel"); |
| class_C = (jclass)env->NewGlobalRef(temp); |
| method_C_init = env->GetMethodID(class_C, "<init>", "()V"); |
| field_C_id = env->GetFieldID(class_C, "id", "I"); |
| field_C_name = env->GetFieldID(class_C, "name", "Ljava/lang/String;"); |
| field_C_subsystem = env->GetFieldID(class_C, "subsystem", "Ljava/lang/String;"); |
| |
| // EnergyMeasurement |
| temp = env->FindClass("android/hardware/power/stats/EnergyMeasurement"); |
| class_EM = (jclass)env->NewGlobalRef(temp); |
| method_EM_init = env->GetMethodID(class_EM, "<init>", "()V"); |
| field_EM_id = env->GetFieldID(class_EM, "id", "I"); |
| field_EM_timestampMs = env->GetFieldID(class_EM, "timestampMs", "J"); |
| field_EM_durationMs = env->GetFieldID(class_EM, "durationMs", "J"); |
| field_EM_energyUWs = env->GetFieldID(class_EM, "energyUWs", "J"); |
| |
| // State |
| temp = env->FindClass("android/hardware/power/stats/State"); |
| class_S = (jclass)env->NewGlobalRef(temp); |
| method_S_init = env->GetMethodID(class_S, "<init>", "()V"); |
| field_S_id = env->GetFieldID(class_S, "id", "I"); |
| field_S_name = env->GetFieldID(class_S, "name", "Ljava/lang/String;"); |
| |
| // PowerEntity |
| temp = env->FindClass("android/hardware/power/stats/PowerEntity"); |
| class_PE = (jclass)env->NewGlobalRef(temp); |
| method_PE_init = env->GetMethodID(class_PE, "<init>", "()V"); |
| field_PE_id = env->GetFieldID(class_PE, "id", "I"); |
| field_PE_name = env->GetFieldID(class_PE, "name", "Ljava/lang/String;"); |
| field_PE_states = env->GetFieldID(class_PE, "states", "[Landroid/hardware/power/stats/State;"); |
| |
| // StateResidency |
| temp = env->FindClass("android/hardware/power/stats/StateResidency"); |
| class_SR = (jclass)env->NewGlobalRef(temp); |
| method_SR_init = env->GetMethodID(class_SR, "<init>", "()V"); |
| field_SR_id = env->GetFieldID(class_SR, "id", "I"); |
| field_SR_totalTimeInStateMs = env->GetFieldID(class_SR, "totalTimeInStateMs", "J"); |
| field_SR_totalStateEntryCount = env->GetFieldID(class_SR, "totalStateEntryCount", "J"); |
| field_SR_lastEntryTimestampMs = env->GetFieldID(class_SR, "lastEntryTimestampMs", "J"); |
| |
| // StateResidencyResult |
| temp = env->FindClass("android/hardware/power/stats/StateResidencyResult"); |
| class_SRR = (jclass)env->NewGlobalRef(temp); |
| method_SRR_init = env->GetMethodID(class_SRR, "<init>", "()V"); |
| field_SRR_id = env->GetFieldID(class_SRR, "id", "I"); |
| field_SRR_stateResidencyData = |
| env->GetFieldID(class_SRR, "stateResidencyData", |
| "[Landroid/hardware/power/stats/StateResidency;"); |
| |
| if (!connectToPowerStatsHal()) { |
| ALOGE("nativeInit failed to connect to power.stats HAL"); |
| return false; |
| } |
| |
| return true; |
| } |
| |
| static const JNINativeMethod method_table[] = { |
| {"nativeInit", "()Z", (void *)nativeInit}, |
| {"nativeGetPowerEntityInfo", "()[Landroid/hardware/power/stats/PowerEntity;", |
| (void *)nativeGetPowerEntityInfo}, |
| {"nativeGetStateResidency", "([I)[Landroid/hardware/power/stats/StateResidencyResult;", |
| (void *)nativeGetStateResidency}, |
| {"nativeGetEnergyMeterInfo", "()[Landroid/hardware/power/stats/Channel;", |
| (void *)nativeGetEnergyMeterInfo}, |
| {"nativeReadEnergyMeters", "([I)[Landroid/hardware/power/stats/EnergyMeasurement;", |
| (void *)nativeReadEnergyMeters}, |
| }; |
| |
| int register_android_server_PowerStatsService(JNIEnv *env) { |
| return jniRegisterNativeMethods(env, |
| "com/android/server/powerstats/" |
| "PowerStatsHALWrapper$PowerStatsHAL10WrapperImpl", |
| method_table, NELEM(method_table)); |
| } |
| |
| }; // namespace android |
