/*
|
* Copyright (C) 2014 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 "BatteryStatsService"
|
//#define LOG_NDEBUG 0
|
|
#include <climits>
|
#include <errno.h>
|
#include <fcntl.h>
|
#include <inttypes.h>
|
#include <semaphore.h>
|
#include <stddef.h>
|
#include <stdio.h>
|
#include <string.h>
|
#include <sys/stat.h>
|
#include <sys/types.h>
|
#include <unistd.h>
|
#include <unordered_map>
|
#include <utility>
|
|
#include <android/hardware/power/1.0/IPower.h>
|
#include <android/hardware/power/1.1/IPower.h>
|
#include <android/hardware/power/stats/1.0/IPowerStats.h>
|
#include <android/system/suspend/BnSuspendCallback.h>
|
#include <android/system/suspend/ISuspendControlService.h>
|
#include <android_runtime/AndroidRuntime.h>
|
#include <jni.h>
|
|
#include <nativehelper/ScopedLocalRef.h>
|
#include <nativehelper/ScopedPrimitiveArray.h>
|
|
#include <log/log.h>
|
#include <utils/misc.h>
|
#include <utils/Log.h>
|
|
using android::hardware::Return;
|
using android::hardware::Void;
|
using android::system::suspend::BnSuspendCallback;
|
using android::hardware::power::V1_0::PowerStatePlatformSleepState;
|
using android::hardware::power::V1_0::PowerStateVoter;
|
using android::hardware::power::V1_0::Status;
|
using android::hardware::power::V1_1::PowerStateSubsystem;
|
using android::hardware::power::V1_1::PowerStateSubsystemSleepState;
|
using android::hardware::hidl_vec;
|
using android::system::suspend::ISuspendControlService;
|
using IPowerV1_1 = android::hardware::power::V1_1::IPower;
|
using IPowerV1_0 = android::hardware::power::V1_0::IPower;
|
|
namespace android
|
{
|
|
#define LAST_RESUME_REASON "/sys/kernel/wakeup_reasons/last_resume_reason"
|
#define MAX_REASON_SIZE 512
|
|
static bool wakeup_init = false;
|
static sem_t wakeup_sem;
|
extern sp<IPowerV1_0> getPowerHalV1_0();
|
extern sp<IPowerV1_1> getPowerHalV1_1();
|
extern bool processPowerHalReturn(const Return<void> &ret, const char* functionName);
|
extern sp<ISuspendControlService> getSuspendControl();
|
|
// Java methods used in getLowPowerStats
|
static jmethodID jgetAndUpdatePlatformState = NULL;
|
static jmethodID jgetSubsystem = NULL;
|
static jmethodID jputVoter = NULL;
|
static jmethodID jputState = NULL;
|
|
std::mutex gPowerHalMutex;
|
std::unordered_map<uint32_t, std::string> gPowerStatsHalEntityNames = {};
|
std::unordered_map<uint32_t, std::unordered_map<uint32_t, std::string>>
|
gPowerStatsHalStateNames = {};
|
std::vector<uint32_t> gPowerStatsHalPlatformIds = {};
|
std::vector<uint32_t> gPowerStatsHalSubsystemIds = {};
|
sp<android::hardware::power::stats::V1_0::IPowerStats> gPowerStatsHalV1_0 = nullptr;
|
std::function<void(JNIEnv*, jobject)> gGetLowPowerStatsImpl = {};
|
std::function<jint(JNIEnv*, jobject)> gGetPlatformLowPowerStatsImpl = {};
|
std::function<jint(JNIEnv*, jobject)> gGetSubsystemLowPowerStatsImpl = {};
|
|
// Cellular/Wifi power monitor rail information
|
static jmethodID jupdateRailData = NULL;
|
static jmethodID jsetRailStatsAvailability = NULL;
|
|
std::function<void(JNIEnv*, jobject)> gGetRailEnergyPowerStatsImpl = {};
|
|
std::unordered_map<uint32_t, std::pair<std::string, std::string>> gPowerStatsHalRailNames = {};
|
static bool power_monitor_available = false;
|
|
// The caller must be holding gPowerHalMutex.
|
static void deinitPowerStatsLocked() {
|
gPowerStatsHalV1_0 = nullptr;
|
}
|
|
struct PowerHalDeathRecipient : 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(gPowerHalMutex);
|
deinitPowerStatsLocked();
|
}
|
};
|
|
sp<PowerHalDeathRecipient> gDeathRecipient = new PowerHalDeathRecipient();
|
|
class WakeupCallback : public BnSuspendCallback {
|
public:
|
binder::Status notifyWakeup(bool success) override {
|
ALOGI("In wakeup_callback: %s", success ? "resumed from suspend" : "suspend aborted");
|
int ret = sem_post(&wakeup_sem);
|
if (ret < 0) {
|
char buf[80];
|
strerror_r(errno, buf, sizeof(buf));
|
ALOGE("Error posting wakeup sem: %s\n", buf);
|
}
|
return binder::Status::ok();
|
}
|
};
|
|
static jint nativeWaitWakeup(JNIEnv *env, jobject clazz, jobject outBuf)
|
{
|
if (outBuf == NULL) {
|
jniThrowException(env, "java/lang/NullPointerException", "null argument");
|
return -1;
|
}
|
|
// Register our wakeup callback if not yet done.
|
if (!wakeup_init) {
|
wakeup_init = true;
|
ALOGV("Creating semaphore...");
|
int ret = sem_init(&wakeup_sem, 0, 0);
|
if (ret < 0) {
|
char buf[80];
|
strerror_r(errno, buf, sizeof(buf));
|
ALOGE("Error creating semaphore: %s\n", buf);
|
jniThrowException(env, "java/lang/IllegalStateException", buf);
|
return -1;
|
}
|
sp<ISuspendControlService> suspendControl = getSuspendControl();
|
bool isRegistered = false;
|
suspendControl->registerCallback(new WakeupCallback(), &isRegistered);
|
if (!isRegistered) {
|
ALOGE("Failed to register wakeup callback");
|
}
|
}
|
|
// Wait for wakeup.
|
ALOGV("Waiting for wakeup...");
|
// TODO(b/116747600): device can suspend and wakeup after sem_wait() finishes and before wakeup
|
// reason is recorded, i.e. BatteryStats might occasionally miss wakeup events.
|
int ret = sem_wait(&wakeup_sem);
|
if (ret < 0) {
|
char buf[80];
|
strerror_r(errno, buf, sizeof(buf));
|
ALOGE("Error waiting on semaphore: %s\n", buf);
|
// Return 0 here to let it continue looping but not return results.
|
return 0;
|
}
|
|
FILE *fp = fopen(LAST_RESUME_REASON, "r");
|
if (fp == NULL) {
|
ALOGE("Failed to open %s", LAST_RESUME_REASON);
|
return -1;
|
}
|
|
char* mergedreason = (char*)env->GetDirectBufferAddress(outBuf);
|
int remainreasonlen = (int)env->GetDirectBufferCapacity(outBuf);
|
|
ALOGV("Reading wakeup reasons");
|
char* mergedreasonpos = mergedreason;
|
char reasonline[128];
|
int i = 0;
|
while (fgets(reasonline, sizeof(reasonline), fp) != NULL) {
|
char* pos = reasonline;
|
char* endPos;
|
int len;
|
// First field is the index or 'Abort'.
|
int irq = (int)strtol(pos, &endPos, 10);
|
if (pos != endPos) {
|
// Write the irq number to the merged reason string.
|
len = snprintf(mergedreasonpos, remainreasonlen, i == 0 ? "%d" : ":%d", irq);
|
} else {
|
// The first field is not an irq, it may be the word Abort.
|
const size_t abortPrefixLen = strlen("Abort:");
|
if (strncmp(pos, "Abort:", abortPrefixLen) != 0) {
|
// Ooops.
|
ALOGE("Bad reason line: %s", reasonline);
|
continue;
|
}
|
|
// Write 'Abort' to the merged reason string.
|
len = snprintf(mergedreasonpos, remainreasonlen, i == 0 ? "Abort" : ":Abort");
|
endPos = pos + abortPrefixLen;
|
}
|
pos = endPos;
|
|
if (len >= 0 && len < remainreasonlen) {
|
mergedreasonpos += len;
|
remainreasonlen -= len;
|
}
|
|
// Skip whitespace; rest of the buffer is the reason string.
|
while (*pos == ' ') {
|
pos++;
|
}
|
|
// Chop newline at end.
|
char* endpos = pos;
|
while (*endpos != 0) {
|
if (*endpos == '\n') {
|
*endpos = 0;
|
break;
|
}
|
endpos++;
|
}
|
|
len = snprintf(mergedreasonpos, remainreasonlen, ":%s", pos);
|
if (len >= 0 && len < remainreasonlen) {
|
mergedreasonpos += len;
|
remainreasonlen -= len;
|
}
|
i++;
|
}
|
|
ALOGV("Got %d reasons", i);
|
if (i > 0) {
|
*mergedreasonpos = 0;
|
}
|
|
if (fclose(fp) != 0) {
|
ALOGE("Failed to close %s", LAST_RESUME_REASON);
|
return -1;
|
}
|
return mergedreasonpos - mergedreason;
|
}
|
|
// The caller must be holding gPowerHalMutex.
|
static bool checkResultLocked(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()) {
|
deinitPowerStatsLocked();
|
}
|
return false;
|
}
|
return true;
|
}
|
|
// The caller must be holding gPowerHalMutex.
|
// gPowerStatsHalV1_0 must not be null
|
static bool initializePowerStats() {
|
using android::hardware::power::stats::V1_0::Status;
|
using android::hardware::power::stats::V1_0::PowerEntityType;
|
|
// Clear out previous content if we are re-initializing
|
gPowerStatsHalEntityNames.clear();
|
gPowerStatsHalStateNames.clear();
|
gPowerStatsHalPlatformIds.clear();
|
gPowerStatsHalSubsystemIds.clear();
|
gPowerStatsHalRailNames.clear();
|
|
Return<void> ret;
|
ret = gPowerStatsHalV1_0->getPowerEntityInfo([](auto infos, auto status) {
|
if (status != Status::SUCCESS) {
|
ALOGE("Error getting power entity info");
|
return;
|
}
|
|
// construct lookup table of powerEntityId to power entity name
|
// also construct vector of platform and subsystem IDs
|
for (auto info : infos) {
|
gPowerStatsHalEntityNames.emplace(info.powerEntityId, info.powerEntityName);
|
if (info.type == PowerEntityType::POWER_DOMAIN) {
|
gPowerStatsHalPlatformIds.emplace_back(info.powerEntityId);
|
} else {
|
gPowerStatsHalSubsystemIds.emplace_back(info.powerEntityId);
|
}
|
}
|
});
|
if (!checkResultLocked(ret, __func__)) {
|
return false;
|
}
|
|
ret = gPowerStatsHalV1_0->getPowerEntityStateInfo({}, [](auto stateSpaces, auto status) {
|
if (status != Status::SUCCESS) {
|
ALOGE("Error getting state info");
|
return;
|
}
|
|
// construct lookup table of powerEntityId, powerEntityStateId to power entity state name
|
for (auto stateSpace : stateSpaces) {
|
std::unordered_map<uint32_t, std::string> stateNames = {};
|
for (auto state : stateSpace.states) {
|
stateNames.emplace(state.powerEntityStateId,
|
state.powerEntityStateName);
|
}
|
gPowerStatsHalStateNames.emplace(stateSpace.powerEntityId, stateNames);
|
}
|
});
|
if (!checkResultLocked(ret, __func__)) {
|
return false;
|
}
|
|
// Get Power monitor rails available
|
ret = gPowerStatsHalV1_0->getRailInfo([](auto rails, auto status) {
|
if (status != Status::SUCCESS) {
|
ALOGW("Rail information is not available");
|
power_monitor_available = false;
|
return;
|
}
|
|
// Fill out rail names/subsystems into gPowerStatsHalRailNames
|
for (auto rail : rails) {
|
gPowerStatsHalRailNames.emplace(rail.index,
|
std::make_pair(rail.railName, rail.subsysName));
|
}
|
if (!gPowerStatsHalRailNames.empty()) {
|
power_monitor_available = true;
|
}
|
});
|
if (!checkResultLocked(ret, __func__)) {
|
return false;
|
}
|
|
return (!gPowerStatsHalEntityNames.empty()) && (!gPowerStatsHalStateNames.empty());
|
}
|
|
// The caller must be holding gPowerHalMutex.
|
static bool getPowerStatsHalLocked() {
|
if (gPowerStatsHalV1_0 == nullptr) {
|
gPowerStatsHalV1_0 = android::hardware::power::stats::V1_0::IPowerStats::getService();
|
if (gPowerStatsHalV1_0 == 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->linkToDeath(gDeathRecipient, 0);
|
if (!linked.isOk()) {
|
ALOGE("Transaction error in linking to power.stats HAL death: %s",
|
linked.description().c_str());
|
deinitPowerStatsLocked();
|
return false;
|
} else if (!linked) {
|
ALOGW("Unable to link to power.stats HAL death notifications");
|
// We should still continue even though linking failed
|
}
|
return initializePowerStats();
|
}
|
return true;
|
}
|
|
// The caller must be holding powerHalMutex.
|
static void getPowerStatsHalLowPowerData(JNIEnv* env, jobject jrpmStats) {
|
using android::hardware::power::stats::V1_0::Status;
|
|
if (!getPowerStatsHalLocked()) {
|
ALOGE("failed to get low power stats");
|
return;
|
}
|
|
// Get power entity state residency data
|
bool success = false;
|
Return<void> ret = gPowerStatsHalV1_0->getPowerEntityStateResidencyData({},
|
[&env, &jrpmStats, &success](auto results, auto status) {
|
if (status == Status::NOT_SUPPORTED) {
|
ALOGW("getPowerEntityStateResidencyData is not supported");
|
success = false;
|
return;
|
}
|
|
for (auto result : results) {
|
jobject jsubsystem = env->CallObjectMethod(jrpmStats, jgetSubsystem,
|
env->NewStringUTF(gPowerStatsHalEntityNames.at(result.powerEntityId).c_str()));
|
if (jsubsystem == NULL) {
|
ALOGE("The rpmstats jni jobject jsubsystem is null.");
|
return;
|
}
|
for (auto stateResidency : result.stateResidencyData) {
|
|
env->CallVoidMethod(jsubsystem, jputState,
|
env->NewStringUTF(gPowerStatsHalStateNames.at(result.powerEntityId)
|
.at(stateResidency.powerEntityStateId).c_str()),
|
stateResidency.totalTimeInStateMs,
|
stateResidency.totalStateEntryCount);
|
}
|
}
|
success = true;
|
});
|
checkResultLocked(ret, __func__);
|
if (!success) {
|
ALOGE("getPowerEntityStateResidencyData failed");
|
}
|
}
|
|
static jint getPowerStatsHalPlatformData(JNIEnv* env, jobject outBuf) {
|
using android::hardware::power::stats::V1_0::Status;
|
using hardware::power::stats::V1_0::PowerEntityStateResidencyResult;
|
using hardware::power::stats::V1_0::PowerEntityStateResidencyData;
|
|
if (!getPowerStatsHalLocked()) {
|
ALOGE("failed to get low power stats");
|
return -1;
|
}
|
|
char *output = (char*)env->GetDirectBufferAddress(outBuf);
|
char *offset = output;
|
int remaining = (int)env->GetDirectBufferCapacity(outBuf);
|
int total_added = -1;
|
|
// Get power entity state residency data
|
Return<void> ret = gPowerStatsHalV1_0->getPowerEntityStateResidencyData(
|
gPowerStatsHalPlatformIds,
|
[&offset, &remaining, &total_added](auto results, auto status) {
|
if (status == Status::NOT_SUPPORTED) {
|
ALOGW("getPowerEntityStateResidencyData is not supported");
|
return;
|
}
|
|
for (size_t i = 0; i < results.size(); i++) {
|
const PowerEntityStateResidencyResult& result = results[i];
|
|
for (size_t j = 0; j < result.stateResidencyData.size(); j++) {
|
const PowerEntityStateResidencyData& stateResidency =
|
result.stateResidencyData[j];
|
int added = snprintf(offset, remaining,
|
"state_%zu name=%s time=%" PRIu64 " count=%" PRIu64 " ",
|
j + 1, gPowerStatsHalStateNames.at(result.powerEntityId)
|
.at(stateResidency.powerEntityStateId).c_str(),
|
stateResidency.totalTimeInStateMs,
|
stateResidency.totalStateEntryCount);
|
if (added < 0) {
|
break;
|
}
|
if (added > remaining) {
|
added = remaining;
|
}
|
offset += added;
|
remaining -= added;
|
total_added += added;
|
}
|
if (remaining <= 0) {
|
/* rewrite NULL character*/
|
offset--;
|
total_added--;
|
ALOGE("power.stats Hal: buffer not enough");
|
break;
|
}
|
}
|
});
|
if (!checkResultLocked(ret, __func__)) {
|
return -1;
|
}
|
|
total_added += 1;
|
return total_added;
|
}
|
|
static jint getPowerStatsHalSubsystemData(JNIEnv* env, jobject outBuf) {
|
using android::hardware::power::stats::V1_0::Status;
|
using hardware::power::stats::V1_0::PowerEntityStateResidencyResult;
|
using hardware::power::stats::V1_0::PowerEntityStateResidencyData;
|
|
if (!getPowerStatsHalLocked()) {
|
ALOGE("failed to get low power stats");
|
return -1;
|
}
|
|
char *output = (char*)env->GetDirectBufferAddress(outBuf);
|
char *offset = output;
|
int remaining = (int)env->GetDirectBufferCapacity(outBuf);
|
int total_added = -1;
|
|
// Get power entity state residency data
|
Return<void> ret = gPowerStatsHalV1_0->getPowerEntityStateResidencyData(
|
gPowerStatsHalSubsystemIds,
|
[&offset, &remaining, &total_added](auto results, auto status) {
|
if (status == Status::NOT_SUPPORTED) {
|
ALOGW("getPowerEntityStateResidencyData is not supported");
|
return;
|
}
|
|
int added = snprintf(offset, remaining, "SubsystemPowerState ");
|
offset += added;
|
remaining -= added;
|
total_added += added;
|
|
for (size_t i = 0; i < results.size(); i++) {
|
const PowerEntityStateResidencyResult& result = results[i];
|
added = snprintf(offset, remaining, "subsystem_%zu name=%s ",
|
i + 1, gPowerStatsHalEntityNames.at(result.powerEntityId).c_str());
|
if (added < 0) {
|
break;
|
}
|
|
if (added > remaining) {
|
added = remaining;
|
}
|
|
offset += added;
|
remaining -= added;
|
total_added += added;
|
|
for (size_t j = 0; j < result.stateResidencyData.size(); j++) {
|
const PowerEntityStateResidencyData& stateResidency =
|
result.stateResidencyData[j];
|
added = snprintf(offset, remaining,
|
"state_%zu name=%s time=%" PRIu64 " count=%" PRIu64 " last entry=%"
|
PRIu64 " ", j + 1, gPowerStatsHalStateNames.at(result.powerEntityId)
|
.at(stateResidency.powerEntityStateId).c_str(),
|
stateResidency.totalTimeInStateMs,
|
stateResidency.totalStateEntryCount,
|
stateResidency.lastEntryTimestampMs);
|
if (added < 0) {
|
break;
|
}
|
if (added > remaining) {
|
added = remaining;
|
}
|
offset += added;
|
remaining -= added;
|
total_added += added;
|
}
|
if (remaining <= 0) {
|
/* rewrite NULL character*/
|
offset--;
|
total_added--;
|
ALOGE("power.stats Hal: buffer not enough");
|
break;
|
}
|
}
|
});
|
if (!checkResultLocked(ret, __func__)) {
|
return -1;
|
}
|
|
total_added += 1;
|
return total_added;
|
}
|
|
static void getPowerStatsHalRailEnergyData(JNIEnv* env, jobject jrailStats) {
|
using android::hardware::power::stats::V1_0::Status;
|
using android::hardware::power::stats::V1_0::EnergyData;
|
|
if (!getPowerStatsHalLocked()) {
|
ALOGE("failed to get power stats");
|
return;
|
}
|
|
if (!power_monitor_available) {
|
env->CallVoidMethod(jrailStats, jsetRailStatsAvailability, false);
|
ALOGW("Rail energy data is not available");
|
return;
|
}
|
|
// Get power rail energySinceBoot data
|
Return<void> ret = gPowerStatsHalV1_0->getEnergyData({},
|
[&env, &jrailStats](auto energyData, auto status) {
|
if (status == Status::NOT_SUPPORTED) {
|
ALOGW("getEnergyData is not supported");
|
return;
|
}
|
|
for (auto data : energyData) {
|
if (!(data.timestamp > LLONG_MAX || data.energy > LLONG_MAX)) {
|
env->CallVoidMethod(jrailStats,
|
jupdateRailData,
|
data.index,
|
env->NewStringUTF(
|
gPowerStatsHalRailNames.at(data.index).first.c_str()),
|
env->NewStringUTF(
|
gPowerStatsHalRailNames.at(data.index).second.c_str()),
|
data.timestamp,
|
data.energy);
|
} else {
|
ALOGE("Java long overflow seen. Rail index %d not updated", data.index);
|
}
|
}
|
});
|
if (!checkResultLocked(ret, __func__)) {
|
ALOGE("getEnergyData failed");
|
}
|
}
|
|
// The caller must be holding powerHalMutex.
|
static void getPowerHalLowPowerData(JNIEnv* env, jobject jrpmStats) {
|
sp<IPowerV1_0> powerHalV1_0 = getPowerHalV1_0();
|
if (powerHalV1_0 == nullptr) {
|
ALOGE("Power Hal not loaded");
|
return;
|
}
|
|
Return<void> ret = powerHalV1_0->getPlatformLowPowerStats(
|
[&env, &jrpmStats](hidl_vec<PowerStatePlatformSleepState> states, Status status) {
|
|
if (status != Status::SUCCESS) return;
|
|
for (size_t i = 0; i < states.size(); i++) {
|
const PowerStatePlatformSleepState& state = states[i];
|
|
jobject jplatformState = env->CallObjectMethod(jrpmStats,
|
jgetAndUpdatePlatformState,
|
env->NewStringUTF(state.name.c_str()),
|
state.residencyInMsecSinceBoot,
|
state.totalTransitions);
|
if (jplatformState == NULL) {
|
ALOGE("The rpmstats jni jobject jplatformState is null.");
|
return;
|
}
|
|
for (size_t j = 0; j < state.voters.size(); j++) {
|
const PowerStateVoter& voter = state.voters[j];
|
env->CallVoidMethod(jplatformState, jputVoter,
|
env->NewStringUTF(voter.name.c_str()),
|
voter.totalTimeInMsecVotedForSinceBoot,
|
voter.totalNumberOfTimesVotedSinceBoot);
|
}
|
}
|
});
|
if (!processPowerHalReturn(ret, "getPlatformLowPowerStats")) {
|
return;
|
}
|
|
// Trying to get IPower 1.1, this will succeed only for devices supporting 1.1
|
sp<IPowerV1_1> powerHal_1_1 = getPowerHalV1_1();
|
if (powerHal_1_1 == nullptr) {
|
// This device does not support IPower@1.1, exiting gracefully
|
return;
|
}
|
ret = powerHal_1_1->getSubsystemLowPowerStats(
|
[&env, &jrpmStats](hidl_vec<PowerStateSubsystem> subsystems, Status status) {
|
|
if (status != Status::SUCCESS) return;
|
|
if (subsystems.size() > 0) {
|
for (size_t i = 0; i < subsystems.size(); i++) {
|
const PowerStateSubsystem &subsystem = subsystems[i];
|
|
jobject jsubsystem = env->CallObjectMethod(jrpmStats, jgetSubsystem,
|
env->NewStringUTF(subsystem.name.c_str()));
|
if (jsubsystem == NULL) {
|
ALOGE("The rpmstats jni jobject jsubsystem is null.");
|
return;
|
}
|
|
for (size_t j = 0; j < subsystem.states.size(); j++) {
|
const PowerStateSubsystemSleepState& state = subsystem.states[j];
|
env->CallVoidMethod(jsubsystem, jputState,
|
env->NewStringUTF(state.name.c_str()),
|
state.residencyInMsecSinceBoot,
|
state.totalTransitions);
|
}
|
}
|
}
|
});
|
processPowerHalReturn(ret, "getSubsystemLowPowerStats");
|
}
|
|
static jint getPowerHalPlatformData(JNIEnv* env, jobject outBuf) {
|
char *output = (char*)env->GetDirectBufferAddress(outBuf);
|
char *offset = output;
|
int remaining = (int)env->GetDirectBufferCapacity(outBuf);
|
int total_added = -1;
|
|
{
|
sp<IPowerV1_0> powerHalV1_0 = getPowerHalV1_0();
|
if (powerHalV1_0 == nullptr) {
|
ALOGE("Power Hal not loaded");
|
return -1;
|
}
|
|
Return<void> ret = powerHalV1_0->getPlatformLowPowerStats(
|
[&offset, &remaining, &total_added](hidl_vec<PowerStatePlatformSleepState> states,
|
Status status) {
|
if (status != Status::SUCCESS)
|
return;
|
for (size_t i = 0; i < states.size(); i++) {
|
int added;
|
const PowerStatePlatformSleepState& state = states[i];
|
|
added = snprintf(offset, remaining,
|
"state_%zu name=%s time=%" PRIu64 " count=%" PRIu64 " ",
|
i + 1, state.name.c_str(), state.residencyInMsecSinceBoot,
|
state.totalTransitions);
|
if (added < 0) {
|
break;
|
}
|
if (added > remaining) {
|
added = remaining;
|
}
|
offset += added;
|
remaining -= added;
|
total_added += added;
|
|
for (size_t j = 0; j < state.voters.size(); j++) {
|
const PowerStateVoter& voter = state.voters[j];
|
added = snprintf(offset, remaining,
|
"voter_%zu name=%s time=%" PRIu64 " count=%" PRIu64 " ",
|
j + 1, voter.name.c_str(),
|
voter.totalTimeInMsecVotedForSinceBoot,
|
voter.totalNumberOfTimesVotedSinceBoot);
|
if (added < 0) {
|
break;
|
}
|
if (added > remaining) {
|
added = remaining;
|
}
|
offset += added;
|
remaining -= added;
|
total_added += added;
|
}
|
|
if (remaining <= 0) {
|
/* rewrite NULL character*/
|
offset--;
|
total_added--;
|
ALOGE("PowerHal: buffer not enough");
|
break;
|
}
|
}
|
}
|
);
|
|
if (!processPowerHalReturn(ret, "getPlatformLowPowerStats")) {
|
return -1;
|
}
|
}
|
*offset = 0;
|
total_added += 1;
|
return total_added;
|
}
|
|
static jint getPowerHalSubsystemData(JNIEnv* env, jobject outBuf) {
|
char *output = (char*)env->GetDirectBufferAddress(outBuf);
|
char *offset = output;
|
int remaining = (int)env->GetDirectBufferCapacity(outBuf);
|
int total_added = -1;
|
|
// This is a IPower 1.1 API
|
sp<IPowerV1_1> powerHal_1_1 = nullptr;
|
|
{
|
// Trying to get 1.1, this will succeed only for devices supporting 1.1
|
powerHal_1_1 = getPowerHalV1_1();
|
if (powerHal_1_1 == nullptr) {
|
//This device does not support IPower@1.1, exiting gracefully
|
return 0;
|
}
|
|
Return<void> ret = powerHal_1_1->getSubsystemLowPowerStats(
|
[&offset, &remaining, &total_added](hidl_vec<PowerStateSubsystem> subsystems,
|
Status status) {
|
|
if (status != Status::SUCCESS)
|
return;
|
|
if (subsystems.size() > 0) {
|
int added = snprintf(offset, remaining, "SubsystemPowerState ");
|
offset += added;
|
remaining -= added;
|
total_added += added;
|
|
for (size_t i = 0; i < subsystems.size(); i++) {
|
const PowerStateSubsystem &subsystem = subsystems[i];
|
|
added = snprintf(offset, remaining,
|
"subsystem_%zu name=%s ", i + 1, subsystem.name.c_str());
|
if (added < 0) {
|
break;
|
}
|
|
if (added > remaining) {
|
added = remaining;
|
}
|
|
offset += added;
|
remaining -= added;
|
total_added += added;
|
|
for (size_t j = 0; j < subsystem.states.size(); j++) {
|
const PowerStateSubsystemSleepState& state = subsystem.states[j];
|
added = snprintf(offset, remaining,
|
"state_%zu name=%s time=%" PRIu64 " count=%" PRIu64 " last entry=%" PRIu64 " ",
|
j + 1, state.name.c_str(), state.residencyInMsecSinceBoot,
|
state.totalTransitions, state.lastEntryTimestampMs);
|
if (added < 0) {
|
break;
|
}
|
|
if (added > remaining) {
|
added = remaining;
|
}
|
|
offset += added;
|
remaining -= added;
|
total_added += added;
|
}
|
|
if (remaining <= 0) {
|
/* rewrite NULL character*/
|
offset--;
|
total_added--;
|
ALOGE("PowerHal: buffer not enough");
|
break;
|
}
|
}
|
}
|
}
|
);
|
|
if (!processPowerHalReturn(ret, "getSubsystemLowPowerStats")) {
|
return -1;
|
}
|
}
|
|
*offset = 0;
|
total_added += 1;
|
return total_added;
|
}
|
|
static void setUpPowerStatsLocked() {
|
// First see if power.stats HAL is available. Fall back to power HAL if
|
// power.stats HAL is unavailable.
|
if (android::hardware::power::stats::V1_0::IPowerStats::getService() != nullptr) {
|
ALOGI("Using power.stats HAL");
|
gGetLowPowerStatsImpl = getPowerStatsHalLowPowerData;
|
gGetPlatformLowPowerStatsImpl = getPowerStatsHalPlatformData;
|
gGetSubsystemLowPowerStatsImpl = getPowerStatsHalSubsystemData;
|
gGetRailEnergyPowerStatsImpl = getPowerStatsHalRailEnergyData;
|
} else if (android::hardware::power::V1_0::IPower::getService() != nullptr) {
|
ALOGI("Using power HAL");
|
gGetLowPowerStatsImpl = getPowerHalLowPowerData;
|
gGetPlatformLowPowerStatsImpl = getPowerHalPlatformData;
|
gGetSubsystemLowPowerStatsImpl = getPowerHalSubsystemData;
|
gGetRailEnergyPowerStatsImpl = NULL;
|
}
|
}
|
|
static void getLowPowerStats(JNIEnv* env, jobject /* clazz */, jobject jrpmStats) {
|
if (jrpmStats == NULL) {
|
jniThrowException(env, "java/lang/NullPointerException",
|
"The rpmstats jni input jobject jrpmStats is null.");
|
return;
|
}
|
if (jgetAndUpdatePlatformState == NULL || jgetSubsystem == NULL
|
|| jputVoter == NULL || jputState == NULL) {
|
ALOGE("A rpmstats jni jmethodID is null.");
|
return;
|
}
|
|
std::lock_guard<std::mutex> lock(gPowerHalMutex);
|
|
if (!gGetLowPowerStatsImpl) {
|
setUpPowerStatsLocked();
|
}
|
|
if (gGetLowPowerStatsImpl) {
|
return gGetLowPowerStatsImpl(env, jrpmStats);
|
}
|
|
ALOGE("Unable to load Power Hal or power.stats HAL");
|
return;
|
}
|
|
static jint getPlatformLowPowerStats(JNIEnv* env, jobject /* clazz */, jobject outBuf) {
|
if (outBuf == NULL) {
|
jniThrowException(env, "java/lang/NullPointerException", "null argument");
|
return -1;
|
}
|
|
std::lock_guard<std::mutex> lock(gPowerHalMutex);
|
|
if (!gGetPlatformLowPowerStatsImpl) {
|
setUpPowerStatsLocked();
|
}
|
|
if (gGetPlatformLowPowerStatsImpl) {
|
return gGetPlatformLowPowerStatsImpl(env, outBuf);
|
}
|
|
ALOGE("Unable to load Power Hal or power.stats HAL");
|
return -1;
|
}
|
|
static jint getSubsystemLowPowerStats(JNIEnv* env, jobject /* clazz */, jobject outBuf) {
|
if (outBuf == NULL) {
|
jniThrowException(env, "java/lang/NullPointerException", "null argument");
|
return -1;
|
}
|
|
std::lock_guard<std::mutex> lock(gPowerHalMutex);
|
|
if (!gGetSubsystemLowPowerStatsImpl) {
|
setUpPowerStatsLocked();
|
}
|
|
if (gGetSubsystemLowPowerStatsImpl) {
|
return gGetSubsystemLowPowerStatsImpl(env, outBuf);
|
}
|
|
ALOGE("Unable to load Power Hal or power.stats HAL");
|
return -1;
|
}
|
|
static void getRailEnergyPowerStats(JNIEnv* env, jobject /* clazz */, jobject jrailStats) {
|
if (jrailStats == NULL) {
|
jniThrowException(env, "java/lang/NullPointerException",
|
"The railstats jni input jobject jrailStats is null.");
|
return;
|
}
|
if (jupdateRailData == NULL) {
|
ALOGE("A railstats jni jmethodID is null.");
|
return;
|
}
|
|
std::lock_guard<std::mutex> lock(gPowerHalMutex);
|
|
if (!gGetRailEnergyPowerStatsImpl) {
|
setUpPowerStatsLocked();
|
}
|
|
if (gGetRailEnergyPowerStatsImpl) {
|
gGetRailEnergyPowerStatsImpl(env, jrailStats);
|
return;
|
}
|
|
if (jsetRailStatsAvailability == NULL) {
|
ALOGE("setRailStatsAvailability jni jmethodID is null.");
|
return;
|
}
|
env->CallVoidMethod(jrailStats, jsetRailStatsAvailability, false);
|
ALOGE("Unable to load Power.Stats.HAL. Setting rail availability to false");
|
return;
|
}
|
|
static const JNINativeMethod method_table[] = {
|
{ "nativeWaitWakeup", "(Ljava/nio/ByteBuffer;)I", (void*)nativeWaitWakeup },
|
{ "getLowPowerStats", "(Lcom/android/internal/os/RpmStats;)V", (void*)getLowPowerStats },
|
{ "getPlatformLowPowerStats", "(Ljava/nio/ByteBuffer;)I", (void*)getPlatformLowPowerStats },
|
{ "getSubsystemLowPowerStats", "(Ljava/nio/ByteBuffer;)I", (void*)getSubsystemLowPowerStats },
|
{ "getRailEnergyPowerStats", "(Lcom/android/internal/os/RailStats;)V",
|
(void*)getRailEnergyPowerStats },
|
};
|
|
int register_android_server_BatteryStatsService(JNIEnv *env)
|
{
|
// get java classes and methods
|
jclass clsRpmStats = env->FindClass("com/android/internal/os/RpmStats");
|
jclass clsPowerStatePlatformSleepState =
|
env->FindClass("com/android/internal/os/RpmStats$PowerStatePlatformSleepState");
|
jclass clsPowerStateSubsystem =
|
env->FindClass("com/android/internal/os/RpmStats$PowerStateSubsystem");
|
jclass clsRailStats = env->FindClass("com/android/internal/os/RailStats");
|
if (clsRpmStats == NULL || clsPowerStatePlatformSleepState == NULL
|
|| clsPowerStateSubsystem == NULL || clsRailStats == NULL) {
|
ALOGE("A rpmstats jni jclass is null.");
|
} else {
|
jgetAndUpdatePlatformState = env->GetMethodID(clsRpmStats, "getAndUpdatePlatformState",
|
"(Ljava/lang/String;JI)Lcom/android/internal/os/RpmStats$PowerStatePlatformSleepState;");
|
jgetSubsystem = env->GetMethodID(clsRpmStats, "getSubsystem",
|
"(Ljava/lang/String;)Lcom/android/internal/os/RpmStats$PowerStateSubsystem;");
|
jputVoter = env->GetMethodID(clsPowerStatePlatformSleepState, "putVoter",
|
"(Ljava/lang/String;JI)V");
|
jputState = env->GetMethodID(clsPowerStateSubsystem, "putState",
|
"(Ljava/lang/String;JI)V");
|
jupdateRailData = env->GetMethodID(clsRailStats, "updateRailData",
|
"(JLjava/lang/String;Ljava/lang/String;JJ)V");
|
jsetRailStatsAvailability = env->GetMethodID(clsRailStats, "setRailStatsAvailability",
|
"(Z)V");
|
}
|
|
return jniRegisterNativeMethods(env, "com/android/server/am/BatteryStatsService",
|
method_table, NELEM(method_table));
|
}
|
|
};
|
