/*
|
* Copyright (C) 2018 The Android Open Source Project
|
*
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
* you may not use this file except in compliance with the License.
|
* You may obtain a copy of the License at
|
*
|
* http://www.apache.org/licenses/LICENSE-2.0
|
*
|
* Unless required by applicable law or agreed to in writing, software
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
* See the License for the specific language governing permissions and
|
* limitations under the License.
|
*/
|
|
package com.android.server.power;
|
|
import android.annotation.Nullable;
|
import android.content.Context;
|
import android.hardware.thermal.V1_0.ThermalStatus;
|
import android.hardware.thermal.V1_0.ThermalStatusCode;
|
import android.hardware.thermal.V1_1.IThermalCallback;
|
import android.hardware.thermal.V2_0.IThermalChangedCallback;
|
import android.hardware.thermal.V2_0.ThrottlingSeverity;
|
import android.os.Binder;
|
import android.os.CoolingDevice;
|
import android.os.HwBinder;
|
import android.os.IThermalEventListener;
|
import android.os.IThermalService;
|
import android.os.IThermalStatusListener;
|
import android.os.PowerManager;
|
import android.os.Process;
|
import android.os.RemoteCallbackList;
|
import android.os.RemoteException;
|
import android.os.ResultReceiver;
|
import android.os.ShellCallback;
|
import android.os.ShellCommand;
|
import android.os.Temperature;
|
import android.util.ArrayMap;
|
import android.util.Slog;
|
|
import com.android.internal.annotations.GuardedBy;
|
import com.android.internal.annotations.VisibleForTesting;
|
import com.android.internal.util.DumpUtils;
|
import com.android.server.FgThread;
|
import com.android.server.SystemService;
|
|
import java.io.FileDescriptor;
|
import java.io.PrintWriter;
|
import java.util.ArrayList;
|
import java.util.Collection;
|
import java.util.Iterator;
|
import java.util.List;
|
import java.util.NoSuchElementException;
|
import java.util.concurrent.atomic.AtomicBoolean;
|
|
/**
|
* This is a system service that listens to HAL thermal events and dispatch those to listeners.
|
* <p>The service will also trigger actions based on severity of the throttling status.</p>
|
*
|
* @hide
|
*/
|
public class ThermalManagerService extends SystemService {
|
private static final String TAG = ThermalManagerService.class.getSimpleName();
|
|
/** Lock to protect listen list. */
|
private final Object mLock = new Object();
|
|
/**
|
* Registered observers of the thermal events. Cookie is used to store type as Integer, null
|
* means no filter.
|
*/
|
@GuardedBy("mLock")
|
private final RemoteCallbackList<IThermalEventListener> mThermalEventListeners =
|
new RemoteCallbackList<>();
|
|
/** Registered observers of the thermal status. */
|
@GuardedBy("mLock")
|
private final RemoteCallbackList<IThermalStatusListener> mThermalStatusListeners =
|
new RemoteCallbackList<>();
|
|
/** Current thermal status */
|
@GuardedBy("mLock")
|
private int mStatus;
|
|
/** If override status takes effect*/
|
@GuardedBy("mLock")
|
private boolean mIsStatusOverride;
|
|
/** Current thermal map, key as name */
|
@GuardedBy("mLock")
|
private ArrayMap<String, Temperature> mTemperatureMap = new ArrayMap<>();
|
|
/** HAL wrapper. */
|
private ThermalHalWrapper mHalWrapper;
|
|
/** Hal ready. */
|
private final AtomicBoolean mHalReady = new AtomicBoolean();
|
|
/** Invalid throttling status */
|
private static final int INVALID_THROTTLING = Integer.MIN_VALUE;
|
|
public ThermalManagerService(Context context) {
|
this(context, null);
|
}
|
|
@VisibleForTesting
|
ThermalManagerService(Context context, @Nullable ThermalHalWrapper halWrapper) {
|
super(context);
|
mHalWrapper = halWrapper;
|
// Initialize to invalid to send status onActivityManagerReady
|
mStatus = INVALID_THROTTLING;
|
}
|
|
@Override
|
public void onStart() {
|
publishBinderService(Context.THERMAL_SERVICE, mService);
|
}
|
|
@Override
|
public void onBootPhase(int phase) {
|
if (phase == SystemService.PHASE_ACTIVITY_MANAGER_READY) {
|
onActivityManagerReady();
|
}
|
}
|
|
private void onActivityManagerReady() {
|
synchronized (mLock) {
|
// Connect to HAL and post to listeners.
|
boolean halConnected = (mHalWrapper != null);
|
if (!halConnected) {
|
mHalWrapper = new ThermalHal20Wrapper();
|
halConnected = mHalWrapper.connectToHal();
|
}
|
if (!halConnected) {
|
mHalWrapper = new ThermalHal11Wrapper();
|
halConnected = mHalWrapper.connectToHal();
|
}
|
if (!halConnected) {
|
mHalWrapper = new ThermalHal10Wrapper();
|
halConnected = mHalWrapper.connectToHal();
|
}
|
mHalWrapper.setCallback(this::onTemperatureChangedCallback);
|
if (!halConnected) {
|
return;
|
}
|
List<Temperature> temperatures = mHalWrapper.getCurrentTemperatures(false,
|
0);
|
final int count = temperatures.size();
|
for (int i = 0; i < count; i++) {
|
onTemperatureChanged(temperatures.get(i), false);
|
}
|
onTemperatureMapChangedLocked();
|
mHalReady.set(true);
|
}
|
}
|
|
private void postStatusListener(IThermalStatusListener listener) {
|
final boolean thermalCallbackQueued = FgThread.getHandler().post(() -> {
|
try {
|
listener.onStatusChange(mStatus);
|
} catch (RemoteException | RuntimeException e) {
|
Slog.e(TAG, "Thermal callback failed to call", e);
|
}
|
});
|
if (!thermalCallbackQueued) {
|
Slog.e(TAG, "Thermal callback failed to queue");
|
}
|
}
|
|
private void notifyStatusListenersLocked() {
|
if (!Temperature.isValidStatus(mStatus)) {
|
return;
|
}
|
final int length = mThermalStatusListeners.beginBroadcast();
|
try {
|
for (int i = 0; i < length; i++) {
|
final IThermalStatusListener listener =
|
mThermalStatusListeners.getBroadcastItem(i);
|
postStatusListener(listener);
|
}
|
} finally {
|
mThermalStatusListeners.finishBroadcast();
|
}
|
}
|
|
private void onTemperatureMapChangedLocked() {
|
int newStatus = INVALID_THROTTLING;
|
final int count = mTemperatureMap.size();
|
for (int i = 0; i < count; i++) {
|
Temperature t = mTemperatureMap.valueAt(i);
|
if (t.getStatus() >= newStatus) {
|
newStatus = t.getStatus();
|
}
|
}
|
// Do not update if override from shell
|
if (!mIsStatusOverride) {
|
setStatusLocked(newStatus);
|
}
|
}
|
|
private void setStatusLocked(int newStatus) {
|
if (newStatus != mStatus) {
|
mStatus = newStatus;
|
notifyStatusListenersLocked();
|
}
|
}
|
|
private void postEventListenerCurrentTemperatures(IThermalEventListener listener,
|
@Nullable Integer type) {
|
synchronized (mLock) {
|
final int count = mTemperatureMap.size();
|
for (int i = 0; i < count; i++) {
|
postEventListener(mTemperatureMap.valueAt(i), listener,
|
type);
|
}
|
}
|
}
|
|
private void postEventListener(Temperature temperature,
|
IThermalEventListener listener,
|
@Nullable Integer type) {
|
// Skip if listener registered with a different type
|
if (type != null && type != temperature.getType()) {
|
return;
|
}
|
final boolean thermalCallbackQueued = FgThread.getHandler().post(() -> {
|
try {
|
listener.notifyThrottling(temperature);
|
} catch (RemoteException | RuntimeException e) {
|
Slog.e(TAG, "Thermal callback failed to call", e);
|
}
|
});
|
if (!thermalCallbackQueued) {
|
Slog.e(TAG, "Thermal callback failed to queue");
|
}
|
}
|
|
private void notifyEventListenersLocked(Temperature temperature) {
|
final int length = mThermalEventListeners.beginBroadcast();
|
try {
|
for (int i = 0; i < length; i++) {
|
final IThermalEventListener listener =
|
mThermalEventListeners.getBroadcastItem(i);
|
final Integer type =
|
(Integer) mThermalEventListeners.getBroadcastCookie(i);
|
postEventListener(temperature, listener, type);
|
}
|
} finally {
|
mThermalEventListeners.finishBroadcast();
|
}
|
}
|
|
private void shutdownIfNeeded(Temperature temperature) {
|
if (temperature.getStatus() != Temperature.THROTTLING_SHUTDOWN) {
|
return;
|
}
|
final PowerManager powerManager = getContext().getSystemService(PowerManager.class);
|
switch (temperature.getType()) {
|
case Temperature.TYPE_CPU:
|
// Fall through
|
case Temperature.TYPE_GPU:
|
// Fall through
|
case Temperature.TYPE_NPU:
|
// Fall through
|
case Temperature.TYPE_SKIN:
|
powerManager.shutdown(false, PowerManager.SHUTDOWN_THERMAL_STATE, false);
|
break;
|
case Temperature.TYPE_BATTERY:
|
powerManager.shutdown(false, PowerManager.SHUTDOWN_BATTERY_THERMAL_STATE, false);
|
break;
|
}
|
}
|
|
private void onTemperatureChanged(Temperature temperature, boolean sendStatus) {
|
shutdownIfNeeded(temperature);
|
synchronized (mLock) {
|
Temperature old = mTemperatureMap.put(temperature.getName(), temperature);
|
if (old != null) {
|
if (old.getStatus() != temperature.getStatus()) {
|
notifyEventListenersLocked(temperature);
|
}
|
} else {
|
notifyEventListenersLocked(temperature);
|
}
|
if (sendStatus) {
|
onTemperatureMapChangedLocked();
|
}
|
}
|
}
|
|
/* HwBinder callback **/
|
private void onTemperatureChangedCallback(Temperature temperature) {
|
final long token = Binder.clearCallingIdentity();
|
try {
|
onTemperatureChanged(temperature, true);
|
} finally {
|
Binder.restoreCallingIdentity(token);
|
}
|
}
|
|
@VisibleForTesting
|
final IThermalService.Stub mService = new IThermalService.Stub() {
|
@Override
|
public boolean registerThermalEventListener(IThermalEventListener listener) {
|
getContext().enforceCallingOrSelfPermission(
|
android.Manifest.permission.DEVICE_POWER, null);
|
synchronized (mLock) {
|
final long token = Binder.clearCallingIdentity();
|
try {
|
if (!mThermalEventListeners.register(listener, null)) {
|
return false;
|
}
|
// Notify its callback after new client registered.
|
postEventListenerCurrentTemperatures(listener, null);
|
return true;
|
} finally {
|
Binder.restoreCallingIdentity(token);
|
}
|
}
|
}
|
|
@Override
|
public boolean registerThermalEventListenerWithType(IThermalEventListener listener,
|
int type) {
|
getContext().enforceCallingOrSelfPermission(
|
android.Manifest.permission.DEVICE_POWER, null);
|
synchronized (mLock) {
|
final long token = Binder.clearCallingIdentity();
|
try {
|
if (!mThermalEventListeners.register(listener, new Integer(type))) {
|
return false;
|
}
|
// Notify its callback after new client registered.
|
postEventListenerCurrentTemperatures(listener, new Integer(type));
|
return true;
|
} finally {
|
Binder.restoreCallingIdentity(token);
|
}
|
}
|
}
|
|
@Override
|
public boolean unregisterThermalEventListener(IThermalEventListener listener) {
|
getContext().enforceCallingOrSelfPermission(
|
android.Manifest.permission.DEVICE_POWER, null);
|
synchronized (mLock) {
|
final long token = Binder.clearCallingIdentity();
|
try {
|
return mThermalEventListeners.unregister(listener);
|
} finally {
|
Binder.restoreCallingIdentity(token);
|
}
|
}
|
}
|
|
@Override
|
public List<Temperature> getCurrentTemperatures() {
|
getContext().enforceCallingOrSelfPermission(
|
android.Manifest.permission.DEVICE_POWER, null);
|
final long token = Binder.clearCallingIdentity();
|
try {
|
if (!mHalReady.get()) {
|
return new ArrayList<>();
|
}
|
return mHalWrapper.getCurrentTemperatures(false, 0 /* not used */);
|
} finally {
|
Binder.restoreCallingIdentity(token);
|
}
|
}
|
|
@Override
|
public List<Temperature> getCurrentTemperaturesWithType(int type) {
|
getContext().enforceCallingOrSelfPermission(
|
android.Manifest.permission.DEVICE_POWER, null);
|
final long token = Binder.clearCallingIdentity();
|
try {
|
if (!mHalReady.get()) {
|
return new ArrayList<>();
|
}
|
return mHalWrapper.getCurrentTemperatures(true, type);
|
} finally {
|
Binder.restoreCallingIdentity(token);
|
}
|
}
|
|
@Override
|
public boolean registerThermalStatusListener(IThermalStatusListener listener) {
|
synchronized (mLock) {
|
// Notify its callback after new client registered.
|
final long token = Binder.clearCallingIdentity();
|
try {
|
if (!mThermalStatusListeners.register(listener)) {
|
return false;
|
}
|
// Notify its callback after new client registered.
|
postStatusListener(listener);
|
return true;
|
} finally {
|
Binder.restoreCallingIdentity(token);
|
}
|
}
|
}
|
|
@Override
|
public boolean unregisterThermalStatusListener(IThermalStatusListener listener) {
|
synchronized (mLock) {
|
final long token = Binder.clearCallingIdentity();
|
try {
|
return mThermalStatusListeners.unregister(listener);
|
} finally {
|
Binder.restoreCallingIdentity(token);
|
}
|
}
|
}
|
|
@Override
|
public int getCurrentThermalStatus() {
|
synchronized (mLock) {
|
final long token = Binder.clearCallingIdentity();
|
try {
|
return Temperature.isValidStatus(mStatus) ? mStatus
|
: Temperature.THROTTLING_NONE;
|
} finally {
|
Binder.restoreCallingIdentity(token);
|
}
|
}
|
}
|
|
@Override
|
public List<CoolingDevice> getCurrentCoolingDevices() {
|
getContext().enforceCallingOrSelfPermission(
|
android.Manifest.permission.DEVICE_POWER, null);
|
final long token = Binder.clearCallingIdentity();
|
try {
|
if (!mHalReady.get()) {
|
return new ArrayList<>();
|
}
|
return mHalWrapper.getCurrentCoolingDevices(false, 0);
|
} finally {
|
Binder.restoreCallingIdentity(token);
|
}
|
}
|
|
@Override
|
public List<CoolingDevice> getCurrentCoolingDevicesWithType(int type) {
|
getContext().enforceCallingOrSelfPermission(
|
android.Manifest.permission.DEVICE_POWER, null);
|
final long token = Binder.clearCallingIdentity();
|
try {
|
if (!mHalReady.get()) {
|
return new ArrayList<>();
|
}
|
return mHalWrapper.getCurrentCoolingDevices(true, type);
|
} finally {
|
Binder.restoreCallingIdentity(token);
|
}
|
}
|
|
private void dumpItemsLocked(PrintWriter pw, String prefix,
|
Collection<?> items) {
|
for (Iterator iterator = items.iterator(); iterator.hasNext();) {
|
pw.println(prefix + iterator.next().toString());
|
}
|
}
|
|
@Override
|
public void dump(FileDescriptor fd, PrintWriter pw, String[] args) {
|
if (!DumpUtils.checkDumpPermission(getContext(), TAG, pw)) {
|
return;
|
}
|
final long token = Binder.clearCallingIdentity();
|
try {
|
synchronized (mLock) {
|
pw.println("IsStatusOverride: " + mIsStatusOverride);
|
pw.println("ThermalEventListeners:");
|
mThermalEventListeners.dump(pw, "\t");
|
pw.println("ThermalStatusListeners:");
|
mThermalStatusListeners.dump(pw, "\t");
|
pw.println("Thermal Status: " + mStatus);
|
pw.println("Cached temperatures:");
|
dumpItemsLocked(pw, "\t", mTemperatureMap.values());
|
pw.println("HAL Ready: " + mHalReady.get());
|
if (mHalReady.get()) {
|
pw.println("HAL connection:");
|
mHalWrapper.dump(pw, "\t");
|
pw.println("Current temperatures from HAL:");
|
dumpItemsLocked(pw, "\t",
|
mHalWrapper.getCurrentTemperatures(false, 0));
|
pw.println("Current cooling devices from HAL:");
|
dumpItemsLocked(pw, "\t",
|
mHalWrapper.getCurrentCoolingDevices(false, 0));
|
}
|
}
|
} finally {
|
Binder.restoreCallingIdentity(token);
|
}
|
}
|
|
private boolean isCallerShell() {
|
final int callingUid = Binder.getCallingUid();
|
return callingUid == Process.SHELL_UID || callingUid == Process.ROOT_UID;
|
}
|
|
@Override
|
public void onShellCommand(FileDescriptor in, FileDescriptor out,
|
FileDescriptor err, String[] args, ShellCallback callback,
|
ResultReceiver resultReceiver) {
|
if (!isCallerShell()) {
|
Slog.w(TAG, "Only shell is allowed to call thermalservice shell commands");
|
return;
|
}
|
(new ThermalShellCommand()).exec(
|
this, in, out, err, args, callback, resultReceiver);
|
}
|
|
};
|
|
class ThermalShellCommand extends ShellCommand {
|
@Override
|
public int onCommand(String cmd) {
|
switch(cmd != null ? cmd : "") {
|
case "override-status":
|
return runOverrideStatus();
|
case "reset":
|
return runReset();
|
default:
|
return handleDefaultCommands(cmd);
|
}
|
}
|
|
private int runReset() {
|
final long token = Binder.clearCallingIdentity();
|
try {
|
synchronized (mLock) {
|
mIsStatusOverride = false;
|
onTemperatureMapChangedLocked();
|
return 0;
|
}
|
} finally {
|
Binder.restoreCallingIdentity(token);
|
}
|
}
|
|
private int runOverrideStatus() {
|
final long token = Binder.clearCallingIdentity();
|
try {
|
final PrintWriter pw = getOutPrintWriter();
|
int status;
|
try {
|
status = Integer.parseInt(getNextArgRequired());
|
} catch (RuntimeException ex) {
|
pw.println("Error: " + ex.toString());
|
return -1;
|
}
|
if (!Temperature.isValidStatus(status)) {
|
pw.println("Invalid status: " + status);
|
return -1;
|
}
|
synchronized (mLock) {
|
mIsStatusOverride = true;
|
setStatusLocked(status);
|
}
|
return 0;
|
} finally {
|
Binder.restoreCallingIdentity(token);
|
}
|
}
|
|
@Override
|
public void onHelp() {
|
final PrintWriter pw = getOutPrintWriter();
|
pw.println("Thermal service (thermalservice) commands:");
|
pw.println(" help");
|
pw.println(" Print this help text.");
|
pw.println("");
|
pw.println(" override-status STATUS");
|
pw.println(" sets and locks the thermal status of the device to STATUS.");
|
pw.println(" status code is defined in android.os.Temperature.");
|
pw.println(" reset");
|
pw.println(" unlocks the thermal status of the device.");
|
pw.println();
|
}
|
}
|
|
abstract static class ThermalHalWrapper {
|
protected static final String TAG = ThermalHalWrapper.class.getSimpleName();
|
|
/** Lock to protect HAL handle. */
|
protected final Object mHalLock = new Object();
|
|
@FunctionalInterface
|
interface TemperatureChangedCallback {
|
void onValues(Temperature temperature);
|
}
|
|
/** Temperature callback. */
|
protected TemperatureChangedCallback mCallback;
|
|
/** Cookie for matching the right end point. */
|
protected static final int THERMAL_HAL_DEATH_COOKIE = 5612;
|
|
@VisibleForTesting
|
protected void setCallback(TemperatureChangedCallback cb) {
|
mCallback = cb;
|
}
|
|
protected abstract List<Temperature> getCurrentTemperatures(boolean shouldFilter,
|
int type);
|
|
protected abstract List<CoolingDevice> getCurrentCoolingDevices(boolean shouldFilter,
|
int type);
|
|
protected abstract boolean connectToHal();
|
|
protected abstract void dump(PrintWriter pw, String prefix);
|
|
protected void resendCurrentTemperatures() {
|
synchronized (mHalLock) {
|
List<Temperature> temperatures = getCurrentTemperatures(false, 0);
|
final int count = temperatures.size();
|
for (int i = 0; i < count; i++) {
|
mCallback.onValues(temperatures.get(i));
|
}
|
}
|
}
|
|
final class DeathRecipient implements HwBinder.DeathRecipient {
|
@Override
|
public void serviceDied(long cookie) {
|
if (cookie == THERMAL_HAL_DEATH_COOKIE) {
|
Slog.e(TAG, "Thermal HAL service died cookie: " + cookie);
|
synchronized (mHalLock) {
|
connectToHal();
|
// Post to listeners after reconnect to HAL.
|
resendCurrentTemperatures();
|
}
|
}
|
}
|
}
|
}
|
|
|
static class ThermalHal10Wrapper extends ThermalHalWrapper {
|
/** Proxy object for the Thermal HAL 1.0 service. */
|
@GuardedBy("mHalLock")
|
private android.hardware.thermal.V1_0.IThermal mThermalHal10 = null;
|
|
@Override
|
protected List<Temperature> getCurrentTemperatures(boolean shouldFilter,
|
int type) {
|
synchronized (mHalLock) {
|
List<Temperature> ret = new ArrayList<>();
|
if (mThermalHal10 == null) {
|
return ret;
|
}
|
try {
|
mThermalHal10.getTemperatures(
|
(ThermalStatus status,
|
ArrayList<android.hardware.thermal.V1_0.Temperature>
|
temperatures) -> {
|
if (ThermalStatusCode.SUCCESS == status.code) {
|
for (android.hardware.thermal.V1_0.Temperature
|
temperature : temperatures) {
|
if (shouldFilter && type != temperature.type) {
|
continue;
|
}
|
// Thermal HAL 1.0 doesn't report current throttling status
|
ret.add(new Temperature(
|
temperature.currentValue, temperature.type,
|
temperature.name,
|
Temperature.THROTTLING_NONE));
|
}
|
} else {
|
Slog.e(TAG,
|
"Couldn't get temperatures because of HAL error: "
|
+ status.debugMessage);
|
}
|
|
});
|
} catch (RemoteException e) {
|
Slog.e(TAG, "Couldn't getCurrentTemperatures, reconnecting...", e);
|
connectToHal();
|
}
|
return ret;
|
}
|
}
|
|
@Override
|
protected List<CoolingDevice> getCurrentCoolingDevices(boolean shouldFilter,
|
int type) {
|
synchronized (mHalLock) {
|
List<CoolingDevice> ret = new ArrayList<>();
|
if (mThermalHal10 == null) {
|
return ret;
|
}
|
try {
|
mThermalHal10.getCoolingDevices((status, coolingDevices) -> {
|
if (ThermalStatusCode.SUCCESS == status.code) {
|
for (android.hardware.thermal.V1_0.CoolingDevice
|
coolingDevice : coolingDevices) {
|
if (shouldFilter && type != coolingDevice.type) {
|
continue;
|
}
|
ret.add(new CoolingDevice(
|
(long) coolingDevice.currentValue,
|
coolingDevice.type,
|
coolingDevice.name));
|
}
|
} else {
|
Slog.e(TAG,
|
"Couldn't get cooling device because of HAL error: "
|
+ status.debugMessage);
|
}
|
|
});
|
} catch (RemoteException e) {
|
Slog.e(TAG, "Couldn't getCurrentCoolingDevices, reconnecting...", e);
|
connectToHal();
|
}
|
return ret;
|
}
|
}
|
|
@Override
|
protected boolean connectToHal() {
|
synchronized (mHalLock) {
|
try {
|
mThermalHal10 = android.hardware.thermal.V1_0.IThermal.getService();
|
mThermalHal10.linkToDeath(new DeathRecipient(),
|
THERMAL_HAL_DEATH_COOKIE);
|
Slog.i(TAG,
|
"Thermal HAL 1.0 service connected, no thermal call back will be "
|
+ "called due to legacy API.");
|
} catch (NoSuchElementException | RemoteException e) {
|
Slog.e(TAG,
|
"Thermal HAL 1.0 service not connected.");
|
mThermalHal10 = null;
|
}
|
return (mThermalHal10 != null);
|
}
|
}
|
|
@Override
|
protected void dump(PrintWriter pw, String prefix) {
|
synchronized (mHalLock) {
|
pw.print(prefix);
|
pw.println("ThermalHAL 1.0 connected: " + (mThermalHal10 != null ? "yes"
|
: "no"));
|
}
|
}
|
}
|
|
static class ThermalHal11Wrapper extends ThermalHalWrapper {
|
/** Proxy object for the Thermal HAL 1.1 service. */
|
@GuardedBy("mHalLock")
|
private android.hardware.thermal.V1_1.IThermal mThermalHal11 = null;
|
|
/** HWbinder callback for Thermal HAL 1.1. */
|
private final IThermalCallback.Stub mThermalCallback11 =
|
new IThermalCallback.Stub() {
|
@Override
|
public void notifyThrottling(boolean isThrottling,
|
android.hardware.thermal.V1_0.Temperature temperature) {
|
Temperature thermalSvcTemp = new Temperature(
|
temperature.currentValue, temperature.type, temperature.name,
|
isThrottling ? ThrottlingSeverity.SEVERE
|
: ThrottlingSeverity.NONE);
|
final long token = Binder.clearCallingIdentity();
|
try {
|
mCallback.onValues(thermalSvcTemp);
|
} finally {
|
Binder.restoreCallingIdentity(token);
|
}
|
}
|
};
|
|
@Override
|
protected List<Temperature> getCurrentTemperatures(boolean shouldFilter,
|
int type) {
|
synchronized (mHalLock) {
|
List<Temperature> ret = new ArrayList<>();
|
if (mThermalHal11 == null) {
|
return ret;
|
}
|
try {
|
mThermalHal11.getTemperatures(
|
(ThermalStatus status,
|
ArrayList<android.hardware.thermal.V1_0.Temperature>
|
temperatures) -> {
|
if (ThermalStatusCode.SUCCESS == status.code) {
|
for (android.hardware.thermal.V1_0.Temperature
|
temperature : temperatures) {
|
if (shouldFilter && type != temperature.type) {
|
continue;
|
}
|
// Thermal HAL 1.1 doesn't report current throttling status
|
ret.add(new Temperature(
|
temperature.currentValue, temperature.type,
|
temperature.name,
|
Temperature.THROTTLING_NONE));
|
}
|
} else {
|
Slog.e(TAG,
|
"Couldn't get temperatures because of HAL error: "
|
+ status.debugMessage);
|
}
|
|
});
|
} catch (RemoteException e) {
|
Slog.e(TAG, "Couldn't getCurrentTemperatures, reconnecting...", e);
|
connectToHal();
|
}
|
return ret;
|
}
|
}
|
|
@Override
|
protected List<CoolingDevice> getCurrentCoolingDevices(boolean shouldFilter,
|
int type) {
|
synchronized (mHalLock) {
|
List<CoolingDevice> ret = new ArrayList<>();
|
if (mThermalHal11 == null) {
|
return ret;
|
}
|
try {
|
mThermalHal11.getCoolingDevices((status, coolingDevices) -> {
|
if (ThermalStatusCode.SUCCESS == status.code) {
|
for (android.hardware.thermal.V1_0.CoolingDevice
|
coolingDevice : coolingDevices) {
|
if (shouldFilter && type != coolingDevice.type) {
|
continue;
|
}
|
ret.add(new CoolingDevice(
|
(long) coolingDevice.currentValue,
|
coolingDevice.type,
|
coolingDevice.name));
|
}
|
} else {
|
Slog.e(TAG,
|
"Couldn't get cooling device because of HAL error: "
|
+ status.debugMessage);
|
}
|
|
});
|
} catch (RemoteException e) {
|
Slog.e(TAG, "Couldn't getCurrentCoolingDevices, reconnecting...", e);
|
connectToHal();
|
}
|
return ret;
|
}
|
}
|
|
@Override
|
protected boolean connectToHal() {
|
synchronized (mHalLock) {
|
try {
|
mThermalHal11 = android.hardware.thermal.V1_1.IThermal.getService();
|
mThermalHal11.linkToDeath(new DeathRecipient(),
|
THERMAL_HAL_DEATH_COOKIE);
|
mThermalHal11.registerThermalCallback(mThermalCallback11);
|
} catch (NoSuchElementException | RemoteException e) {
|
Slog.e(TAG,
|
"Thermal HAL 1.1 service not connected, no thermal call back will be "
|
+ "called.");
|
mThermalHal11 = null;
|
}
|
return (mThermalHal11 != null);
|
}
|
}
|
|
@Override
|
protected void dump(PrintWriter pw, String prefix) {
|
synchronized (mHalLock) {
|
pw.print(prefix);
|
pw.println("ThermalHAL 1.1 connected: " + (mThermalHal11 != null ? "yes"
|
: "no"));
|
}
|
}
|
}
|
|
static class ThermalHal20Wrapper extends ThermalHalWrapper {
|
/** Proxy object for the Thermal HAL 2.0 service. */
|
@GuardedBy("mHalLock")
|
private android.hardware.thermal.V2_0.IThermal mThermalHal20 = null;
|
|
/** HWbinder callback for Thermal HAL 2.0. */
|
private final IThermalChangedCallback.Stub mThermalCallback20 =
|
new IThermalChangedCallback.Stub() {
|
@Override
|
public void notifyThrottling(
|
android.hardware.thermal.V2_0.Temperature temperature) {
|
Temperature thermalSvcTemp = new Temperature(
|
temperature.value, temperature.type, temperature.name,
|
temperature.throttlingStatus);
|
final long token = Binder.clearCallingIdentity();
|
try {
|
mCallback.onValues(thermalSvcTemp);
|
} finally {
|
Binder.restoreCallingIdentity(token);
|
}
|
}
|
};
|
|
@Override
|
protected List<Temperature> getCurrentTemperatures(boolean shouldFilter,
|
int type) {
|
synchronized (mHalLock) {
|
List<Temperature> ret = new ArrayList<>();
|
if (mThermalHal20 == null) {
|
return ret;
|
}
|
try {
|
mThermalHal20.getCurrentTemperatures(shouldFilter, type,
|
(status, temperatures) -> {
|
if (ThermalStatusCode.SUCCESS == status.code) {
|
for (android.hardware.thermal.V2_0.Temperature
|
temperature : temperatures) {
|
ret.add(new Temperature(
|
temperature.value, temperature.type,
|
temperature.name,
|
temperature.throttlingStatus));
|
}
|
} else {
|
Slog.e(TAG,
|
"Couldn't get temperatures because of HAL error: "
|
+ status.debugMessage);
|
}
|
|
});
|
} catch (RemoteException e) {
|
Slog.e(TAG, "Couldn't getCurrentTemperatures, reconnecting...", e);
|
connectToHal();
|
}
|
return ret;
|
}
|
}
|
|
@Override
|
protected List<CoolingDevice> getCurrentCoolingDevices(boolean shouldFilter,
|
int type) {
|
synchronized (mHalLock) {
|
List<CoolingDevice> ret = new ArrayList<>();
|
if (mThermalHal20 == null) {
|
return ret;
|
}
|
try {
|
mThermalHal20.getCurrentCoolingDevices(shouldFilter, type,
|
(status, coolingDevices) -> {
|
if (ThermalStatusCode.SUCCESS == status.code) {
|
for (android.hardware.thermal.V2_0.CoolingDevice
|
coolingDevice : coolingDevices) {
|
ret.add(new CoolingDevice(
|
coolingDevice.value, coolingDevice.type,
|
coolingDevice.name));
|
}
|
} else {
|
Slog.e(TAG,
|
"Couldn't get cooling device because of HAL error: "
|
+ status.debugMessage);
|
}
|
|
});
|
} catch (RemoteException e) {
|
Slog.e(TAG, "Couldn't getCurrentCoolingDevices, reconnecting...", e);
|
connectToHal();
|
}
|
return ret;
|
}
|
}
|
|
@Override
|
protected boolean connectToHal() {
|
synchronized (mHalLock) {
|
try {
|
mThermalHal20 = android.hardware.thermal.V2_0.IThermal.getService();
|
mThermalHal20.linkToDeath(new DeathRecipient(), THERMAL_HAL_DEATH_COOKIE);
|
mThermalHal20.registerThermalChangedCallback(mThermalCallback20, false,
|
0 /* not used */);
|
} catch (NoSuchElementException | RemoteException e) {
|
Slog.e(TAG, "Thermal HAL 2.0 service not connected, trying 1.1.");
|
mThermalHal20 = null;
|
}
|
return (mThermalHal20 != null);
|
}
|
}
|
|
@Override
|
protected void dump(PrintWriter pw, String prefix) {
|
synchronized (mHalLock) {
|
pw.print(prefix);
|
pw.println("ThermalHAL 2.0 connected: " + (mThermalHal20 != null ? "yes"
|
: "no"));
|
}
|
}
|
}
|
|
}
|
