diff options
62 files changed, 1581 insertions, 385 deletions
diff --git a/core/java/android/os/BatteryStats.java b/core/java/android/os/BatteryStats.java index b68b94d5bf2d..a6b2ed09a64d 100644 --- a/core/java/android/os/BatteryStats.java +++ b/core/java/android/os/BatteryStats.java @@ -31,6 +31,7 @@ import android.content.pm.ApplicationInfo; import android.content.pm.PackageManager; import android.content.res.Resources; import android.location.GnssSignalQuality; +import android.net.NetworkCapabilities; import android.os.BatteryStatsManager.WifiState; import android.os.BatteryStatsManager.WifiSupplState; import android.server.ServerProtoEnums; @@ -59,6 +60,7 @@ import com.android.internal.os.BatteryStatsHistoryIterator; import com.android.internal.os.CpuScalingPolicies; import com.android.internal.os.MonotonicClock; import com.android.internal.os.PowerStats; +import com.android.net.module.util.NetworkCapabilitiesUtils; import com.google.android.collect.Lists; @@ -2734,26 +2736,28 @@ public abstract class BatteryStats { "emngcy", "other" }; + public static final int NUM_ALL_NETWORK_TYPES = getAllNetworkTypesCount(); public static final int DATA_CONNECTION_OUT_OF_SERVICE = 0; - public static final int DATA_CONNECTION_EMERGENCY_SERVICE = getEmergencyNetworkConnectionType(); - public static final int DATA_CONNECTION_OTHER = DATA_CONNECTION_EMERGENCY_SERVICE + 1; + public static final int DATA_CONNECTION_EMERGENCY_SERVICE = NUM_ALL_NETWORK_TYPES + 1; + public static final int DATA_CONNECTION_OTHER = NUM_ALL_NETWORK_TYPES + 2; @UnsupportedAppUsage - public static final int NUM_DATA_CONNECTION_TYPES = DATA_CONNECTION_OTHER + 1; + public static final int NUM_DATA_CONNECTION_TYPES = NUM_ALL_NETWORK_TYPES + 3; + @android.ravenwood.annotation.RavenwoodReplace - private static int getEmergencyNetworkConnectionType() { + public static int getAllNetworkTypesCount() { int count = TelephonyManager.getAllNetworkTypes().length; if (DATA_CONNECTION_NAMES.length != count + 3) { // oos, emngcy, other throw new IllegalStateException( "DATA_CONNECTION_NAMES length does not match network type count. " + "Expected: " + (count + 3) + ", actual:" + DATA_CONNECTION_NAMES.length); } - return count + 1; + return count; } - private static int getEmergencyNetworkConnectionType$ravenwood() { - return DATA_CONNECTION_NAMES.length - 2; + public static int getAllNetworkTypesCount$ravenwood() { + return DATA_CONNECTION_NAMES.length - 3; // oos, emngcy, other } /** @@ -9071,4 +9075,31 @@ public abstract class BatteryStats { protected static boolean isKernelStatsAvailable$ravenwood() { return false; } + + @android.ravenwood.annotation.RavenwoodReplace + protected static int getDisplayTransport(int[] transports) { + return NetworkCapabilitiesUtils.getDisplayTransport(transports); + } + + // See NetworkCapabilitiesUtils + private static final int[] DISPLAY_TRANSPORT_PRIORITIES = new int[] { + NetworkCapabilities.TRANSPORT_VPN, + NetworkCapabilities.TRANSPORT_CELLULAR, + NetworkCapabilities.TRANSPORT_WIFI_AWARE, + NetworkCapabilities.TRANSPORT_BLUETOOTH, + NetworkCapabilities.TRANSPORT_WIFI, + NetworkCapabilities.TRANSPORT_ETHERNET, + NetworkCapabilities.TRANSPORT_USB + }; + + protected static int getDisplayTransport$ravenwood(int[] transports) { + for (int transport : DISPLAY_TRANSPORT_PRIORITIES) { + for (int t : transports) { + if (t == transport) { + return transport; + } + } + } + return transports[0]; + } } diff --git a/core/java/android/os/BluetoothBatteryStats.java b/core/java/android/os/BluetoothBatteryStats.java index 3d99a08a59c5..fa8f39d1642b 100644 --- a/core/java/android/os/BluetoothBatteryStats.java +++ b/core/java/android/os/BluetoothBatteryStats.java @@ -26,6 +26,7 @@ import java.util.List; * * @hide */ +@android.ravenwood.annotation.RavenwoodKeepWholeClass public class BluetoothBatteryStats implements Parcelable { /** @hide */ diff --git a/core/java/android/os/UserBatteryConsumer.java b/core/java/android/os/UserBatteryConsumer.java index a2ff078263ca..23ba0c635eca 100644 --- a/core/java/android/os/UserBatteryConsumer.java +++ b/core/java/android/os/UserBatteryConsumer.java @@ -34,6 +34,7 @@ import java.util.List; * * {@hide} */ +@android.ravenwood.annotation.RavenwoodKeepWholeClass public class UserBatteryConsumer extends BatteryConsumer { static final int CONSUMER_TYPE_USER = 2; diff --git a/core/java/android/os/WakeLockStats.java b/core/java/android/os/WakeLockStats.java index 05a7313d1600..69e70a0a8b07 100644 --- a/core/java/android/os/WakeLockStats.java +++ b/core/java/android/os/WakeLockStats.java @@ -25,6 +25,7 @@ import java.util.List; * Snapshot of wake lock stats. * @hide */ +@android.ravenwood.annotation.RavenwoodKeepWholeClass public final class WakeLockStats implements Parcelable { /** @hide */ diff --git a/core/java/android/view/Display.java b/core/java/android/view/Display.java index fbadef3d19ef..0006139d2cb0 100644 --- a/core/java/android/view/Display.java +++ b/core/java/android/view/Display.java @@ -86,6 +86,7 @@ import java.util.function.Consumer; * that are currently attached and whether mirroring has been enabled. * </p> */ +@android.ravenwood.annotation.RavenwoodKeepPartialClass public final class Display { private static final String TAG = "Display"; private static final boolean DEBUG = false; @@ -1998,6 +1999,7 @@ public final class Display { * display power state. In SUSPEND states, updates are absolutely forbidden. * @hide */ + @android.ravenwood.annotation.RavenwoodKeep public static boolean isSuspendedState(int state) { return state == STATE_OFF || state == STATE_DOZE_SUSPEND || state == STATE_ON_SUSPEND; } @@ -2007,6 +2009,7 @@ public final class Display { * specified display power state. * @hide */ + @android.ravenwood.annotation.RavenwoodKeep public static boolean isDozeState(int state) { return state == STATE_DOZE || state == STATE_DOZE_SUSPEND; } @@ -2016,6 +2019,7 @@ public final class Display { * or {@link #STATE_VR}. * @hide */ + @android.ravenwood.annotation.RavenwoodKeep public static boolean isActiveState(int state) { return state == STATE_ON || state == STATE_VR; } @@ -2024,6 +2028,7 @@ public final class Display { * Returns true if the display is in an off state such as {@link #STATE_OFF}. * @hide */ + @android.ravenwood.annotation.RavenwoodKeep public static boolean isOffState(int state) { return state == STATE_OFF; } @@ -2033,6 +2038,7 @@ public final class Display { * or {@link #STATE_VR} or {@link #STATE_ON_SUSPEND}. * @hide */ + @android.ravenwood.annotation.RavenwoodKeep public static boolean isOnState(int state) { return state == STATE_ON || state == STATE_VR || state == STATE_ON_SUSPEND; } diff --git a/core/java/com/android/internal/os/BackgroundThread.java b/core/java/com/android/internal/os/BackgroundThread.java index 72da819bb736..b75daeda480c 100644 --- a/core/java/com/android/internal/os/BackgroundThread.java +++ b/core/java/com/android/internal/os/BackgroundThread.java @@ -27,6 +27,7 @@ import java.util.concurrent.Executor; /** * Shared singleton background thread for each process. */ +@android.ravenwood.annotation.RavenwoodKeepWholeClass public final class BackgroundThread extends HandlerThread { private static final long SLOW_DISPATCH_THRESHOLD_MS = 10_000; private static final long SLOW_DELIVERY_THRESHOLD_MS = 30_000; diff --git a/core/java/com/android/internal/os/BatteryStatsHistory.java b/core/java/com/android/internal/os/BatteryStatsHistory.java index aa60cc9e672c..0b7593a1a5a2 100644 --- a/core/java/com/android/internal/os/BatteryStatsHistory.java +++ b/core/java/com/android/internal/os/BatteryStatsHistory.java @@ -297,9 +297,20 @@ public class BatteryStatsHistory { } } + public static class EventLogger { + /** + * Records a statsd event when the batterystats config file is written to disk. + */ + public void writeCommitSysConfigFile(long startTimeMs) { + com.android.internal.logging.EventLogTags.writeCommitSysConfigFile( + "batterystats", SystemClock.uptimeMillis() - startTimeMs); + } + } + private TraceDelegate mTracer; private int mTraceLastState = 0; private int mTraceLastState2 = 0; + private final EventLogger mEventLogger; /** * Constructor @@ -311,8 +322,16 @@ public class BatteryStatsHistory { public BatteryStatsHistory(File systemDir, int maxHistoryFiles, int maxHistoryBufferSize, HistoryStepDetailsCalculator stepDetailsCalculator, Clock clock, MonotonicClock monotonicClock) { + this(systemDir, maxHistoryFiles, maxHistoryBufferSize, + stepDetailsCalculator, clock, monotonicClock, new TraceDelegate(), + new EventLogger()); + } + + public BatteryStatsHistory(File systemDir, int maxHistoryFiles, int maxHistoryBufferSize, + HistoryStepDetailsCalculator stepDetailsCalculator, Clock clock, + MonotonicClock monotonicClock, TraceDelegate tracer, EventLogger eventLogger) { this(Parcel.obtain(), systemDir, maxHistoryFiles, maxHistoryBufferSize, - stepDetailsCalculator, clock, monotonicClock, new TraceDelegate()); + stepDetailsCalculator, clock, monotonicClock, tracer, eventLogger); initHistoryBuffer(); } @@ -320,15 +339,15 @@ public class BatteryStatsHistory { public BatteryStatsHistory(Parcel historyBuffer, File systemDir, int maxHistoryFiles, int maxHistoryBufferSize, HistoryStepDetailsCalculator stepDetailsCalculator, Clock clock, - MonotonicClock monotonicClock, TraceDelegate tracer) { + MonotonicClock monotonicClock, TraceDelegate tracer, EventLogger eventLogger) { this(historyBuffer, systemDir, maxHistoryFiles, maxHistoryBufferSize, stepDetailsCalculator, - clock, monotonicClock, tracer, null); + clock, monotonicClock, tracer, eventLogger, null); } private BatteryStatsHistory(Parcel historyBuffer, File systemDir, int maxHistoryFiles, int maxHistoryBufferSize, HistoryStepDetailsCalculator stepDetailsCalculator, Clock clock, - MonotonicClock monotonicClock, TraceDelegate tracer, + MonotonicClock monotonicClock, TraceDelegate tracer, EventLogger eventLogger, BatteryStatsHistory writableHistory) { mHistoryBuffer = historyBuffer; mSystemDir = systemDir; @@ -338,6 +357,7 @@ public class BatteryStatsHistory { mTracer = tracer; mClock = clock; mMonotonicClock = monotonicClock; + mEventLogger = eventLogger; mWritableHistory = writableHistory; if (mWritableHistory != null) { mMutable = false; @@ -394,19 +414,21 @@ public class BatteryStatsHistory { HistoryStepDetailsCalculator stepDetailsCalculator, Clock clock, MonotonicClock monotonicClock) { this(maxHistoryFiles, maxHistoryBufferSize, stepDetailsCalculator, clock, monotonicClock, - new TraceDelegate()); + new TraceDelegate(), new EventLogger()); } @VisibleForTesting public BatteryStatsHistory(int maxHistoryFiles, int maxHistoryBufferSize, HistoryStepDetailsCalculator stepDetailsCalculator, Clock clock, - MonotonicClock monotonicClock, TraceDelegate traceDelegate) { + MonotonicClock monotonicClock, TraceDelegate traceDelegate, + EventLogger eventLogger) { mMaxHistoryFiles = maxHistoryFiles; mMaxHistoryBufferSize = maxHistoryBufferSize; mStepDetailsCalculator = stepDetailsCalculator; mTracer = traceDelegate; mClock = clock; mMonotonicClock = monotonicClock; + mEventLogger = eventLogger; mHistoryBuffer = Parcel.obtain(); mSystemDir = null; @@ -425,6 +447,7 @@ public class BatteryStatsHistory { mSystemDir = null; mHistoryDir = null; mStepDetailsCalculator = null; + mEventLogger = new EventLogger(); mWritableHistory = null; mMutable = false; @@ -482,7 +505,7 @@ public class BatteryStatsHistory { historyBufferCopy.appendFrom(mHistoryBuffer, 0, mHistoryBuffer.dataSize()); return new BatteryStatsHistory(historyBufferCopy, mSystemDir, 0, 0, null, null, null, - null, this); + null, mEventLogger, this); } } @@ -2154,8 +2177,7 @@ public class BatteryStatsHistory { + " duration ms:" + (SystemClock.uptimeMillis() - startTimeMs) + " bytes:" + p.dataSize()); } - com.android.internal.logging.EventLogTags.writeCommitSysConfigFile( - "batterystats", SystemClock.uptimeMillis() - startTimeMs); + mEventLogger.writeCommitSysConfigFile(startTimeMs); } catch (IOException e) { Slog.w(TAG, "Error writing battery statistics", e); file.failWrite(fos); @@ -2164,6 +2186,7 @@ public class BatteryStatsHistory { } } + /** * Returns the total number of history tags in the tag pool. */ diff --git a/core/java/com/android/internal/os/LongMultiStateCounter.java b/core/java/com/android/internal/os/LongMultiStateCounter.java index 33a9d547be78..064609f9dfe4 100644 --- a/core/java/com/android/internal/os/LongMultiStateCounter.java +++ b/core/java/com/android/internal/os/LongMultiStateCounter.java @@ -55,11 +55,12 @@ import libcore.util.NativeAllocationRegistry; * * @hide */ +@android.ravenwood.annotation.RavenwoodKeepWholeClass +@android.ravenwood.annotation.RavenwoodNativeSubstitutionClass( + "com.android.hoststubgen.nativesubstitution.LongMultiStateCounter_host") public final class LongMultiStateCounter implements Parcelable { - private static final NativeAllocationRegistry sRegistry = - NativeAllocationRegistry.createMalloced( - LongMultiStateCounter.class.getClassLoader(), native_getReleaseFunc()); + private static NativeAllocationRegistry sRegistry; private final int mStateCount; @@ -71,16 +72,33 @@ public final class LongMultiStateCounter implements Parcelable { Preconditions.checkArgumentPositive(stateCount, "stateCount must be greater than 0"); mStateCount = stateCount; mNativeObject = native_init(stateCount); - sRegistry.registerNativeAllocation(this, mNativeObject); + registerNativeAllocation(); } private LongMultiStateCounter(Parcel in) { mNativeObject = native_initFromParcel(in); - sRegistry.registerNativeAllocation(this, mNativeObject); + registerNativeAllocation(); mStateCount = native_getStateCount(mNativeObject); } + @android.ravenwood.annotation.RavenwoodReplace + private void registerNativeAllocation() { + if (sRegistry == null) { + synchronized (LongMultiStateCounter.class) { + if (sRegistry == null) { + sRegistry = NativeAllocationRegistry.createMalloced( + LongMultiStateCounter.class.getClassLoader(), native_getReleaseFunc()); + } + } + } + sRegistry.registerNativeAllocation(this, mNativeObject); + } + + private void registerNativeAllocation$ravenwood() { + // No-op under ravenwood + } + public int getStateCount() { return mStateCount; } @@ -221,10 +239,10 @@ public final class LongMultiStateCounter implements Parcelable { private static native long native_getCount(long nativeObject, int state); @FastNative - private native String native_toString(long nativeObject); + private static native String native_toString(long nativeObject); @FastNative - private native void native_writeToParcel(long nativeObject, Parcel dest, int flags); + private static native void native_writeToParcel(long nativeObject, Parcel dest, int flags); @FastNative private static native long native_initFromParcel(Parcel parcel); diff --git a/core/java/com/android/internal/power/EnergyConsumerStats.java b/core/java/com/android/internal/power/EnergyConsumerStats.java index e2098dd11531..764908d65b17 100644 --- a/core/java/com/android/internal/power/EnergyConsumerStats.java +++ b/core/java/com/android/internal/power/EnergyConsumerStats.java @@ -44,6 +44,7 @@ import java.util.Arrays; * This class doesn't use a TimeBase, and instead requires manual decisions about when to * accumulate since it is trivial. However, in the future, a TimeBase could be used instead. */ +@android.ravenwood.annotation.RavenwoodKeepWholeClass public class EnergyConsumerStats { private static final String TAG = "MeasuredEnergyStats"; diff --git a/core/jni/com_android_internal_os_LongMultiStateCounter.cpp b/core/jni/com_android_internal_os_LongMultiStateCounter.cpp index ddf7a67e00ce..56d3fbba9458 100644 --- a/core/jni/com_android_internal_os_LongMultiStateCounter.cpp +++ b/core/jni/com_android_internal_os_LongMultiStateCounter.cpp @@ -100,7 +100,7 @@ static jlong native_getCount(jlong nativePtr, jint state) { return asLongMultiStateCounter(nativePtr)->getCount(state); } -static jobject native_toString(JNIEnv *env, jobject self, jlong nativePtr) { +static jobject native_toString(JNIEnv *env, jclass, jlong nativePtr) { return env->NewStringUTF(asLongMultiStateCounter(nativePtr)->toString().c_str()); } @@ -118,7 +118,7 @@ static void throwWriteRE(JNIEnv *env, binder_status_t status) { } \ } -static void native_writeToParcel(JNIEnv *env, jobject self, jlong nativePtr, jobject jParcel, +static void native_writeToParcel(JNIEnv *env, jclass, jlong nativePtr, jobject jParcel, jint flags) { battery::LongMultiStateCounter *counter = asLongMultiStateCounter(nativePtr); ndk::ScopedAParcel parcel(AParcel_fromJavaParcel(env, jParcel)); diff --git a/core/tests/coretests/Android.bp b/core/tests/coretests/Android.bp index ee1a4acb3839..861f71992f54 100644 --- a/core/tests/coretests/Android.bp +++ b/core/tests/coretests/Android.bp @@ -217,6 +217,7 @@ android_ravenwood_test { "src/android/os/**/*.java", "src/android/telephony/PinResultTest.java", "src/android/util/**/*.java", + "src/android/view/DisplayTest.java", "src/android/view/DisplayInfoTest.java", "src/com/android/internal/logging/**/*.java", "src/com/android/internal/os/**/*.java", diff --git a/core/tests/coretests/src/android/os/BluetoothBatteryStatsTest.java b/core/tests/coretests/src/android/os/BluetoothBatteryStatsTest.java new file mode 100644 index 000000000000..e12ca24acb85 --- /dev/null +++ b/core/tests/coretests/src/android/os/BluetoothBatteryStatsTest.java @@ -0,0 +1,64 @@ +/* + * Copyright (C) 2024 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 android.os; + +import static com.google.common.truth.Truth.assertThat; + +import androidx.test.runner.AndroidJUnit4; + +import org.junit.Test; +import org.junit.runner.RunWith; + +import java.util.List; + +@RunWith(AndroidJUnit4.class) +public class BluetoothBatteryStatsTest { + + @Test + public void parcelability() { + BluetoothBatteryStats stats = new BluetoothBatteryStats(List.of( + new BluetoothBatteryStats.UidStats(42, 100, 200, 300, 400, 500), + new BluetoothBatteryStats.UidStats(99, 600, 700, 800, 900, 999) + )); + + Parcel parcel = Parcel.obtain(); + stats.writeToParcel(parcel, 0); + byte[] bytes = parcel.marshall(); + parcel.recycle(); + + parcel = Parcel.obtain(); + parcel.unmarshall(bytes, 0, bytes.length); + parcel.setDataPosition(0); + + BluetoothBatteryStats actual = new BluetoothBatteryStats(parcel); + + assertThat(actual.getUidStats()).hasSize(2); + + BluetoothBatteryStats.UidStats uid1 = actual.getUidStats().stream() + .filter(s->s.uid == 42).findFirst().get(); + + assertThat(uid1.scanTimeMs).isEqualTo(100); + assertThat(uid1.unoptimizedScanTimeMs).isEqualTo(200); + assertThat(uid1.scanResultCount).isEqualTo(300); + assertThat(uid1.rxTimeMs).isEqualTo(400); + assertThat(uid1.txTimeMs).isEqualTo(500); + + BluetoothBatteryStats.UidStats uid2 = actual.getUidStats().stream() + .filter(s->s.uid == 99).findFirst().get(); + assertThat(uid2.scanTimeMs).isEqualTo(600); + } +} diff --git a/core/tests/coretests/src/android/os/WakeLockStatsTest.java b/core/tests/coretests/src/android/os/WakeLockStatsTest.java new file mode 100644 index 000000000000..2675ba07d2f7 --- /dev/null +++ b/core/tests/coretests/src/android/os/WakeLockStatsTest.java @@ -0,0 +1,58 @@ +/* + * Copyright (C) 2024 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 android.os; + +import static com.google.common.truth.Truth.assertThat; + +import androidx.test.runner.AndroidJUnit4; + +import org.junit.Test; +import org.junit.runner.RunWith; + +import java.util.List; + +@RunWith(AndroidJUnit4.class) +public class WakeLockStatsTest { + + @Test + public void parcelablity() { + WakeLockStats wakeLockStats = new WakeLockStats( + List.of(new WakeLockStats.WakeLock(1, "foo", 200, 3000, 40000), + new WakeLockStats.WakeLock(2, "bar", 500, 6000, 70000))); + + Parcel parcel = Parcel.obtain(); + wakeLockStats.writeToParcel(parcel, 0); + byte[] bytes = parcel.marshall(); + parcel.recycle(); + + parcel = Parcel.obtain(); + parcel.unmarshall(bytes, 0, bytes.length); + parcel.setDataPosition(0); + + WakeLockStats actual = WakeLockStats.CREATOR.createFromParcel(parcel); + assertThat(actual.getWakeLocks()).hasSize(2); + WakeLockStats.WakeLock wl1 = actual.getWakeLocks().get(0); + assertThat(wl1.uid).isEqualTo(1); + assertThat(wl1.name).isEqualTo("foo"); + assertThat(wl1.timesAcquired).isEqualTo(200); + assertThat(wl1.totalTimeHeldMs).isEqualTo(3000); + assertThat(wl1.timeHeldMs).isEqualTo(40000); + + WakeLockStats.WakeLock wl2 = actual.getWakeLocks().get(1); + assertThat(wl2.uid).isEqualTo(2); + } +} diff --git a/core/tests/coretests/src/android/view/DisplayTest.java b/core/tests/coretests/src/android/view/DisplayTest.java new file mode 100644 index 000000000000..4d2a1c45e6da --- /dev/null +++ b/core/tests/coretests/src/android/view/DisplayTest.java @@ -0,0 +1,98 @@ +/* + * Copyright (C) 2024 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 android.view; + +import static com.google.common.truth.Truth.assertWithMessage; + +import android.util.DebugUtils; + +import androidx.test.filters.SmallTest; + +import com.android.internal.util.ArrayUtils; + +import org.junit.Test; + +import java.util.function.IntFunction; + +@SmallTest +public class DisplayTest { + private static final int[] DISPLAY_STATES = { + Display.STATE_UNKNOWN, + Display.STATE_OFF, + Display.STATE_ON, + Display.STATE_DOZE, + Display.STATE_DOZE_SUSPEND, + Display.STATE_VR, + Display.STATE_ON_SUSPEND + }; + + @Test + public void isSuspendedState() { + assertOnlyTrueForStates( + Display::isSuspendedState, + Display.STATE_OFF, + Display.STATE_DOZE_SUSPEND, + Display.STATE_ON_SUSPEND + ); + } + + @Test + public void isDozeState() { + assertOnlyTrueForStates( + Display::isDozeState, + Display.STATE_DOZE, + Display.STATE_DOZE_SUSPEND + ); + } + + @Test + public void isActiveState() { + assertOnlyTrueForStates( + Display::isActiveState, + Display.STATE_ON, + Display.STATE_VR + ); + } + + @Test + public void isOffState() { + assertOnlyTrueForStates( + Display::isOffState, + Display.STATE_OFF + ); + } + + @Test + public void isOnState() { + assertOnlyTrueForStates( + Display::isOnState, + Display.STATE_ON, + Display.STATE_VR, + Display.STATE_ON_SUSPEND + ); + } + + private void assertOnlyTrueForStates(IntFunction<Boolean> function, int... trueStates) { + for (int state : DISPLAY_STATES) { + boolean actual = function.apply(state); + boolean expected = ArrayUtils.contains(trueStates, state); + assertWithMessage("Unexpected return for Display.STATE_" + + DebugUtils.constantToString(Display.class, "STATE_", state)) + .that(actual).isEqualTo(expected); + } + } +} diff --git a/core/tests/coretests/src/com/android/internal/os/BackgroundThreadTest.java b/core/tests/coretests/src/com/android/internal/os/BackgroundThreadTest.java new file mode 100644 index 000000000000..8bdf4c6192ba --- /dev/null +++ b/core/tests/coretests/src/com/android/internal/os/BackgroundThreadTest.java @@ -0,0 +1,60 @@ +/* + * Copyright (C) 2024 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.internal.os; + +import static com.google.common.truth.Truth.assertThat; + +import android.os.ConditionVariable; +import android.os.Handler; +import android.os.Looper; +import android.platform.test.ravenwood.RavenwoodRule; + +import org.junit.Rule; +import org.junit.Test; + +import java.util.concurrent.Executor; + +public class BackgroundThreadTest { + + @Rule + public final RavenwoodRule mRavenwood = + new RavenwoodRule.Builder().setProvideMainThread(true).build(); + + @Test + public void test_get() { + BackgroundThread thread = BackgroundThread.get(); + assertThat(thread.getLooper()).isNotEqualTo(Looper.getMainLooper()); + } + + @Test + public void test_getHandler() { + Handler handler = BackgroundThread.getHandler(); + ConditionVariable done = new ConditionVariable(); + handler.post(done::open); + boolean success = done.block(5000); + assertThat(success).isTrue(); + } + + @Test + public void test_getExecutor() { + Executor executor = BackgroundThread.getExecutor(); + ConditionVariable done = new ConditionVariable(); + executor.execute(done::open); + boolean success = done.block(5000); + assertThat(success).isTrue(); + } +} diff --git a/core/tests/coretests/src/com/android/internal/os/LongMultiStateCounterTest.java b/core/tests/coretests/src/com/android/internal/os/LongMultiStateCounterTest.java index e064e7483bfa..78ef92baa441 100644 --- a/core/tests/coretests/src/com/android/internal/os/LongMultiStateCounterTest.java +++ b/core/tests/coretests/src/com/android/internal/os/LongMultiStateCounterTest.java @@ -22,7 +22,6 @@ import static org.junit.Assert.assertThrows; import android.os.BadParcelableException; import android.os.Parcel; -import android.platform.test.annotations.IgnoreUnderRavenwood; import android.platform.test.ravenwood.RavenwoodRule; import androidx.test.filters.SmallTest; @@ -34,7 +33,6 @@ import org.junit.runner.RunWith; @RunWith(AndroidJUnit4.class) @SmallTest -@IgnoreUnderRavenwood(blockedBy = LongMultiStateCounterTest.class) public class LongMultiStateCounterTest { @Rule public final RavenwoodRule mRavenwood = new RavenwoodRule(); diff --git a/core/tests/coretests/src/com/android/internal/power/EnergyConsumerStatsTest.java b/core/tests/coretests/src/com/android/internal/power/EnergyConsumerStatsTest.java index ae2ef0cb4e51..9c337d788c5c 100644 --- a/core/tests/coretests/src/com/android/internal/power/EnergyConsumerStatsTest.java +++ b/core/tests/coretests/src/com/android/internal/power/EnergyConsumerStatsTest.java @@ -34,7 +34,6 @@ import static org.junit.Assert.assertNull; import static org.junit.Assert.assertTrue; import android.os.Parcel; -import android.platform.test.annotations.IgnoreUnderRavenwood; import android.platform.test.ravenwood.RavenwoodRule; import android.view.Display; @@ -49,7 +48,6 @@ import java.util.Arrays; * Test class for {@link EnergyConsumerStats}. */ @SmallTest -@IgnoreUnderRavenwood(reason = "Needs kernel support") public class EnergyConsumerStatsTest { @Rule public final RavenwoodRule mRavenwood = new RavenwoodRule(); diff --git a/ravenwood/ravenwood-annotation-allowed-classes.txt b/ravenwood/ravenwood-annotation-allowed-classes.txt index 01c0074e463f..927ddd71dd15 100644 --- a/ravenwood/ravenwood-annotation-allowed-classes.txt +++ b/ravenwood/ravenwood-annotation-allowed-classes.txt @@ -13,11 +13,13 @@ com.android.internal.os.BatteryStatsHistoryIterator com.android.internal.os.Clock com.android.internal.os.LongArrayMultiStateCounter com.android.internal.os.LongArrayMultiStateCounter$LongArrayContainer +com.android.internal.os.LongMultiStateCounter com.android.internal.os.MonotonicClock com.android.internal.os.PowerProfile com.android.internal.os.PowerStats com.android.internal.os.PowerStats$Descriptor com.android.internal.os.RuntimeInit +com.android.internal.power.EnergyConsumerStats com.android.internal.power.ModemPowerProfile android.util.AtomicFile @@ -54,6 +56,7 @@ android.os.BatteryUsageStats android.os.BatteryUsageStatsQuery android.os.Binder android.os.Binder$IdentitySupplier +android.os.BluetoothBatteryStats android.os.Broadcaster android.os.Build android.os.BundleMerger @@ -83,12 +86,15 @@ android.os.TestLooperManager android.os.ThreadLocalWorkSource android.os.TimestampedValue android.os.Trace +android.os.UserBatteryConsumer +android.os.UserBatteryConsumer$Builder android.os.UidBatteryConsumer android.os.UidBatteryConsumer$Builder android.os.UserHandle android.os.UserManager android.os.VibrationAttributes android.os.VibrationAttributes$Builder +android.os.WakeLockStats android.os.WorkSource android.content.ClipData @@ -159,6 +165,7 @@ android.app.Instrumentation android.metrics.LogMaker +android.view.Display android.view.Display$HdrCapabilities android.view.Display$Mode android.view.DisplayInfo @@ -169,7 +176,6 @@ android.telephony.ModemActivityInfo android.telephony.ServiceState com.android.server.LocalServices -com.android.server.power.stats.BatteryStatsImpl com.android.internal.util.BitUtils com.android.internal.util.BitwiseInputStream @@ -192,6 +198,7 @@ com.android.internal.util.QuickSelect com.android.internal.util.RingBuffer com.android.internal.util.StringPool +com.android.internal.os.BackgroundThread com.android.internal.os.BinderCallHeavyHitterWatcher com.android.internal.os.BinderDeathDispatcher com.android.internal.os.BinderfsStatsReader diff --git a/services/core/java/com/android/server/power/stats/BatteryStatsImpl.java b/services/core/java/com/android/server/power/stats/BatteryStatsImpl.java index 25e749f08782..00036e48891f 100644 --- a/services/core/java/com/android/server/power/stats/BatteryStatsImpl.java +++ b/services/core/java/com/android/server/power/stats/BatteryStatsImpl.java @@ -137,7 +137,6 @@ import com.android.internal.util.FrameworkStatsLog; import com.android.internal.util.XmlUtils; import com.android.modules.utils.TypedXmlPullParser; import com.android.modules.utils.TypedXmlSerializer; -import com.android.net.module.util.NetworkCapabilitiesUtils; import com.android.server.power.optimization.Flags; import com.android.server.power.stats.SystemServerCpuThreadReader.SystemServiceCpuThreadTimes; @@ -1716,14 +1715,101 @@ public class BatteryStatsImpl extends BatteryStats { return mMaxLearnedBatteryCapacityUah; } + public class FrameworkStatsLogger { + public void uidProcessStateChanged(int uid, int state) { + // TODO(b/155216561): It is possible for isolated uids to be in a higher + // state than its parent uid. We should track the highest state within the union of host + // and isolated uids rather than only the parent uid. + FrameworkStatsLog.write(FrameworkStatsLog.UID_PROCESS_STATE_CHANGED, uid, + ActivityManager.processStateAmToProto(state)); + } + + public void wakelockStateChanged(int uid, WorkChain wc, String name, int type, + int procState, boolean acquired) { + int event = acquired + ? FrameworkStatsLog.WAKELOCK_STATE_CHANGED__STATE__ACQUIRE + : FrameworkStatsLog.WAKELOCK_STATE_CHANGED__STATE__RELEASE; + if (wc != null) { + FrameworkStatsLog.write(FrameworkStatsLog.WAKELOCK_STATE_CHANGED, wc.getUids(), + wc.getTags(), getPowerManagerWakeLockLevel(type), name, + event, procState); + } else { + FrameworkStatsLog.write_non_chained(FrameworkStatsLog.WAKELOCK_STATE_CHANGED, + mapIsolatedUid(uid), null, getPowerManagerWakeLockLevel(type), name, + event, procState); + } + } + + public void kernelWakeupReported(long deltaUptimeUs) { + FrameworkStatsLog.write(FrameworkStatsLog.KERNEL_WAKEUP_REPORTED, mLastWakeupReason, + /* duration_usec */ deltaUptimeUs, mLastWakeupElapsedTimeMs); + } + + public void gpsScanStateChanged(int uid, WorkChain workChain, boolean stateOn) { + int event = stateOn + ? FrameworkStatsLog.GPS_SCAN_STATE_CHANGED__STATE__ON + : FrameworkStatsLog.GPS_SCAN_STATE_CHANGED__STATE__OFF; + if (workChain != null) { + FrameworkStatsLog.write(FrameworkStatsLog.GPS_SCAN_STATE_CHANGED, + workChain.getUids(), workChain.getTags(), event); + } else { + FrameworkStatsLog.write_non_chained(FrameworkStatsLog.GPS_SCAN_STATE_CHANGED, + uid, null, event); + } + } + + public void batterySaverModeChanged(boolean enabled) { + FrameworkStatsLog.write(FrameworkStatsLog.BATTERY_SAVER_MODE_STATE_CHANGED, + enabled + ? FrameworkStatsLog.BATTERY_SAVER_MODE_STATE_CHANGED__STATE__ON + : FrameworkStatsLog.BATTERY_SAVER_MODE_STATE_CHANGED__STATE__OFF); + } + + public void deviceIdlingModeStateChanged(int mode) { + FrameworkStatsLog.write(FrameworkStatsLog.DEVICE_IDLING_MODE_STATE_CHANGED, mode); + } + + public void deviceIdleModeStateChanged(int mode) { + FrameworkStatsLog.write(FrameworkStatsLog.DEVICE_IDLE_MODE_STATE_CHANGED, mode); + } + + public void chargingStateChanged(int status) { + FrameworkStatsLog.write(FrameworkStatsLog.CHARGING_STATE_CHANGED, status); + } + + public void pluggedStateChanged(int plugType) { + FrameworkStatsLog.write(FrameworkStatsLog.PLUGGED_STATE_CHANGED, plugType); + } + + public void batteryLevelChanged(int level) { + FrameworkStatsLog.write(FrameworkStatsLog.BATTERY_LEVEL_CHANGED, level); + } + + public void phoneServiceStateChanged(int state, int simState, int strengthBin) { + FrameworkStatsLog.write(FrameworkStatsLog.PHONE_SERVICE_STATE_CHANGED, state, + simState, strengthBin); + } + + public void phoneSignalStrengthChanged(int strengthBin) { + FrameworkStatsLog.write( + FrameworkStatsLog.PHONE_SIGNAL_STRENGTH_CHANGED, strengthBin); + } + } + + private final FrameworkStatsLogger mFrameworkStatsLogger; + @VisibleForTesting public BatteryStatsImpl(Clock clock, File historyDirectory, @NonNull Handler handler, - @NonNull PowerStatsUidResolver powerStatsUidResolver) { + @NonNull PowerStatsUidResolver powerStatsUidResolver, + @NonNull FrameworkStatsLogger frameworkStatsLogger, + @NonNull BatteryStatsHistory.TraceDelegate traceDelegate, + @NonNull BatteryStatsHistory.EventLogger eventLogger) { mClock = clock; initKernelStatsReaders(); mBatteryStatsConfig = new BatteryStatsConfig.Builder().build(); mHandler = handler; mPowerStatsUidResolver = powerStatsUidResolver; + mFrameworkStatsLogger = frameworkStatsLogger; mConstants = new Constants(mHandler); mStartClockTimeMs = clock.currentTimeMillis(); mDailyFile = null; @@ -1732,12 +1818,14 @@ public class BatteryStatsImpl extends BatteryStats { mCheckinFile = null; mStatsFile = null; mHistory = new BatteryStatsHistory(mConstants.MAX_HISTORY_FILES, - mConstants.MAX_HISTORY_BUFFER, mStepDetailsCalculator, mClock, mMonotonicClock); + mConstants.MAX_HISTORY_BUFFER, mStepDetailsCalculator, mClock, mMonotonicClock, + traceDelegate, eventLogger); } else { mCheckinFile = new AtomicFile(new File(historyDirectory, "batterystats-checkin.bin")); mStatsFile = new AtomicFile(new File(historyDirectory, "batterystats.bin")); mHistory = new BatteryStatsHistory(historyDirectory, mConstants.MAX_HISTORY_FILES, - mConstants.MAX_HISTORY_BUFFER, mStepDetailsCalculator, mClock, mMonotonicClock); + mConstants.MAX_HISTORY_BUFFER, mStepDetailsCalculator, mClock, mMonotonicClock, + traceDelegate, eventLogger); } mPlatformIdleStateCallback = null; mEnergyConsumerRetriever = null; @@ -4269,7 +4357,7 @@ public class BatteryStatsImpl extends BatteryStats { } @GuardedBy("this") - private void updateBatteryPropertiesLocked() { + protected void updateBatteryPropertiesLocked() { try { IBatteryPropertiesRegistrar registrar = IBatteryPropertiesRegistrar.Stub.asInterface( ServiceManager.getService("batteryproperties")); @@ -4403,11 +4491,7 @@ public class BatteryStatsImpl extends BatteryStats { return; } } - // TODO(b/155216561): It is possible for isolated uids to be in a higher - // state than its parent uid. We should track the highest state within the union of host - // and isolated uids rather than only the parent uid. - FrameworkStatsLog.write(FrameworkStatsLog.UID_PROCESS_STATE_CHANGED, uid, - ActivityManager.processStateAmToProto(state)); + mFrameworkStatsLogger.uidProcessStateChanged(uid, state); getUidStatsLocked(parentUid, elapsedRealtimeMs, uptimeMs) .updateUidProcessStateLocked(state, elapsedRealtimeMs, uptimeMs); } @@ -4721,17 +4805,8 @@ public class BatteryStatsImpl extends BatteryStats { Uid uidStats = getUidStatsLocked(mappedUid, elapsedRealtimeMs, uptimeMs); uidStats.noteStartWakeLocked(pid, name, type, elapsedRealtimeMs); - int procState = uidStats.mProcessState; - - if (wc != null) { - FrameworkStatsLog.write(FrameworkStatsLog.WAKELOCK_STATE_CHANGED, wc.getUids(), - wc.getTags(), getPowerManagerWakeLockLevel(type), name, - FrameworkStatsLog.WAKELOCK_STATE_CHANGED__STATE__ACQUIRE, procState); - } else { - FrameworkStatsLog.write_non_chained(FrameworkStatsLog.WAKELOCK_STATE_CHANGED, - mapIsolatedUid(uid), null, getPowerManagerWakeLockLevel(type), name, - FrameworkStatsLog.WAKELOCK_STATE_CHANGED__STATE__ACQUIRE, procState); - } + mFrameworkStatsLogger.wakelockStateChanged(mapIsolatedUid(uid), wc, name, type, + uidStats.mProcessState, true /* acquired */); } } @@ -4774,16 +4849,8 @@ public class BatteryStatsImpl extends BatteryStats { Uid uidStats = getUidStatsLocked(mappedUid, elapsedRealtimeMs, uptimeMs); uidStats.noteStopWakeLocked(pid, name, type, elapsedRealtimeMs); - int procState = uidStats.mProcessState; - if (wc != null) { - FrameworkStatsLog.write(FrameworkStatsLog.WAKELOCK_STATE_CHANGED, wc.getUids(), - wc.getTags(), getPowerManagerWakeLockLevel(type), name, - FrameworkStatsLog.WAKELOCK_STATE_CHANGED__STATE__RELEASE, procState); - } else { - FrameworkStatsLog.write_non_chained(FrameworkStatsLog.WAKELOCK_STATE_CHANGED, - mapIsolatedUid(uid), null, getPowerManagerWakeLockLevel(type), name, - FrameworkStatsLog.WAKELOCK_STATE_CHANGED__STATE__RELEASE, procState); - } + mFrameworkStatsLogger.wakelockStateChanged(mapIsolatedUid(uid), wc, name, type, + uidStats.mProcessState, false /* acquired */); if (mappedUid != uid) { // Decrement the ref count for the isolated uid and delete the mapping if uneeded. @@ -5020,8 +5087,7 @@ public class BatteryStatsImpl extends BatteryStats { long deltaUptimeMs = uptimeMs - mLastWakeupUptimeMs; SamplingTimer timer = getWakeupReasonTimerLocked(mLastWakeupReason); timer.add(deltaUptimeMs * 1000, 1, elapsedRealtimeMs); // time in in microseconds - FrameworkStatsLog.write(FrameworkStatsLog.KERNEL_WAKEUP_REPORTED, mLastWakeupReason, - /* duration_usec */ deltaUptimeMs * 1000, mLastWakeupElapsedTimeMs); + mFrameworkStatsLogger.kernelWakeupReported(deltaUptimeMs * 1000); mLastWakeupReason = null; } } @@ -5159,14 +5225,7 @@ public class BatteryStatsImpl extends BatteryStats { } mGpsNesting++; - if (workChain == null) { - FrameworkStatsLog.write_non_chained(FrameworkStatsLog.GPS_SCAN_STATE_CHANGED, - mapIsolatedUid(uid), null, FrameworkStatsLog.GPS_SCAN_STATE_CHANGED__STATE__ON); - } else { - FrameworkStatsLog.write(FrameworkStatsLog.GPS_SCAN_STATE_CHANGED, - workChain.getUids(), workChain.getTags(), - FrameworkStatsLog.GPS_SCAN_STATE_CHANGED__STATE__ON); - } + mFrameworkStatsLogger.gpsScanStateChanged(mapIsolatedUid(uid), workChain, /* on */true); getUidStatsLocked(mappedUid, elapsedRealtimeMs, uptimeMs).noteStartGps(elapsedRealtimeMs); } @@ -5188,14 +5247,7 @@ public class BatteryStatsImpl extends BatteryStats { mGpsSignalQualityBin = -1; } - if (workChain == null) { - FrameworkStatsLog.write_non_chained(FrameworkStatsLog.GPS_SCAN_STATE_CHANGED, - mapIsolatedUid(uid), null, - FrameworkStatsLog.GPS_SCAN_STATE_CHANGED__STATE__OFF); - } else { - FrameworkStatsLog.write(FrameworkStatsLog.GPS_SCAN_STATE_CHANGED, workChain.getUids(), - workChain.getTags(), FrameworkStatsLog.GPS_SCAN_STATE_CHANGED__STATE__OFF); - } + mFrameworkStatsLogger.gpsScanStateChanged(mapIsolatedUid(uid), workChain, /* on */ false); getUidStatsLocked(mappedUid, elapsedRealtimeMs, uptimeMs).noteStopGps(elapsedRealtimeMs); } @@ -5673,10 +5725,7 @@ public class BatteryStatsImpl extends BatteryStats { } else { // Log an initial value for BATTERY_SAVER_MODE_STATE_CHANGED in order to // allow the atom to read all future state changes. - FrameworkStatsLog.write(FrameworkStatsLog.BATTERY_SAVER_MODE_STATE_CHANGED, - enabled - ? FrameworkStatsLog.BATTERY_SAVER_MODE_STATE_CHANGED__STATE__ON - : FrameworkStatsLog.BATTERY_SAVER_MODE_STATE_CHANGED__STATE__OFF); + mFrameworkStatsLogger.batterySaverModeChanged(enabled); } } @@ -5696,10 +5745,7 @@ public class BatteryStatsImpl extends BatteryStats { HistoryItem.STATE2_POWER_SAVE_FLAG); mPowerSaveModeEnabledTimer.stopRunningLocked(elapsedRealtimeMs); } - FrameworkStatsLog.write(FrameworkStatsLog.BATTERY_SAVER_MODE_STATE_CHANGED, - enabled - ? FrameworkStatsLog.BATTERY_SAVER_MODE_STATE_CHANGED__STATE__ON - : FrameworkStatsLog.BATTERY_SAVER_MODE_STATE_CHANGED__STATE__OFF); + mFrameworkStatsLogger.batterySaverModeChanged(enabled); } } @@ -5727,7 +5773,7 @@ public class BatteryStatsImpl extends BatteryStats { if (nowIdling) statsmode = DEVICE_IDLE_MODE_DEEP; else if (nowLightIdling) statsmode = DEVICE_IDLE_MODE_LIGHT; else statsmode = DEVICE_IDLE_MODE_OFF; - FrameworkStatsLog.write(FrameworkStatsLog.DEVICE_IDLING_MODE_STATE_CHANGED, statsmode); + mFrameworkStatsLogger.deviceIdlingModeStateChanged(statsmode); } if (mDeviceIdling != nowIdling) { mDeviceIdling = nowIdling; @@ -5769,7 +5815,7 @@ public class BatteryStatsImpl extends BatteryStats { mDeviceIdleModeFullTimer.startRunningLocked(elapsedRealtimeMs); } mDeviceIdleMode = mode; - FrameworkStatsLog.write(FrameworkStatsLog.DEVICE_IDLE_MODE_STATE_CHANGED, mode); + mFrameworkStatsLogger.deviceIdleModeStateChanged(mode); } } @@ -5933,8 +5979,7 @@ public class BatteryStatsImpl extends BatteryStats { addStateFlag = HistoryItem.STATE_PHONE_SCANNING_FLAG; newHistory = true; mPhoneSignalScanningTimer.startRunningLocked(elapsedRealtimeMs); - FrameworkStatsLog.write(FrameworkStatsLog.PHONE_SERVICE_STATE_CHANGED, state, - simState, strengthBin); + mFrameworkStatsLogger.phoneServiceStateChanged(state, simState, strengthBin); } } @@ -5944,8 +5989,7 @@ public class BatteryStatsImpl extends BatteryStats { removeStateFlag = HistoryItem.STATE_PHONE_SCANNING_FLAG; newHistory = true; mPhoneSignalScanningTimer.stopRunningLocked(elapsedRealtimeMs); - FrameworkStatsLog.write(FrameworkStatsLog.PHONE_SERVICE_STATE_CHANGED, state, - simState, strengthBin); + mFrameworkStatsLogger.phoneServiceStateChanged(state, simState, strengthBin); } } @@ -5966,8 +6010,7 @@ public class BatteryStatsImpl extends BatteryStats { } newSignalStrength = strengthBin; newHistory = true; - FrameworkStatsLog.write( - FrameworkStatsLog.PHONE_SIGNAL_STRENGTH_CHANGED, strengthBin); + mFrameworkStatsLogger.phoneSignalStrengthChanged(strengthBin); } else { stopAllPhoneSignalStrengthTimersLocked(-1, elapsedRealtimeMs); } @@ -6076,7 +6119,7 @@ public class BatteryStatsImpl extends BatteryStats { // Unknown is included in DATA_CONNECTION_OTHER. int bin = DATA_CONNECTION_OUT_OF_SERVICE; if (hasData) { - if (dataType > 0 && dataType <= TelephonyManager.getAllNetworkTypes().length) { + if (dataType > 0 && dataType <= NUM_ALL_NETWORK_TYPES) { bin = dataType; } else { switch (serviceType) { @@ -6995,7 +7038,7 @@ public class BatteryStatsImpl extends BatteryStats { /** @hide */ public void noteNetworkInterfaceForTransports(String iface, int[] transportTypes) { if (TextUtils.isEmpty(iface)) return; - final int displayTransport = NetworkCapabilitiesUtils.getDisplayTransport(transportTypes); + final int displayTransport = getDisplayTransport(transportTypes); synchronized (mModemNetworkLock) { if (displayTransport == TRANSPORT_CELLULAR) { @@ -10507,8 +10550,7 @@ public class BatteryStatsImpl extends BatteryStats { long elapsedRealtimeMs, long uptimeMs) { int uidRunningState; // Make special note of Foreground Services - final boolean userAwareService = - (ActivityManager.isForegroundService(procState)); + final boolean userAwareService = ActivityManager.isForegroundService(procState); uidRunningState = BatteryStats.mapToInternalProcessState(procState); if (mProcessState == uidRunningState && userAwareService == mInForegroundService) { @@ -10912,6 +10954,7 @@ public class BatteryStatsImpl extends BatteryStats { mPowerProfile = powerProfile; mCpuScalingPolicies = cpuScalingPolicies; mPowerStatsUidResolver = powerStatsUidResolver; + mFrameworkStatsLogger = new FrameworkStatsLogger(); initPowerProfile(); @@ -10966,7 +11009,7 @@ public class BatteryStatsImpl extends BatteryStats { // Notify statsd that the system is initially not in doze. mDeviceIdleMode = DEVICE_IDLE_MODE_OFF; - FrameworkStatsLog.write(FrameworkStatsLog.DEVICE_IDLE_MODE_STATE_CHANGED, mDeviceIdleMode); + mFrameworkStatsLogger.deviceIdleModeStateChanged(mDeviceIdleMode); } private void recordPowerStats(PowerStats stats) { @@ -11702,7 +11745,9 @@ public class BatteryStatsImpl extends BatteryStats { mWakeupReasonStats.clear(); } - mTmpRailStats.reset(); + if (mTmpRailStats != null) { + mTmpRailStats.reset(); + } EnergyConsumerStats.resetIfNotNull(mGlobalEnergyConsumerStats); @@ -11864,6 +11909,78 @@ public class BatteryStatsImpl extends BatteryStats { return networkStatsManager.getWifiUidStats(); } + private static class NetworkStatsDelta { + int mUid; + int mSet; + long mRxBytes; + long mRxPackets; + long mTxBytes; + long mTxPackets; + + public int getUid() { + return mUid; + } + + + public int getSet() { + return mSet; + } + + public long getRxBytes() { + return mRxBytes; + } + + public long getRxPackets() { + return mRxPackets; + } + + public long getTxBytes() { + return mTxBytes; + } + + public long getTxPackets() { + return mTxPackets; + } + } + + private List<NetworkStatsDelta> computeDelta(NetworkStats currentStats, + NetworkStats lastStats) { + List<NetworkStatsDelta> deltaList = new ArrayList<>(); + for (NetworkStats.Entry entry : currentStats) { + NetworkStatsDelta delta = new NetworkStatsDelta(); + delta.mUid = entry.getUid(); + delta.mSet = entry.getSet(); + NetworkStats.Entry lastEntry = null; + if (lastStats != null) { + for (NetworkStats.Entry e : lastStats) { + if (e.getUid() == entry.getUid() && e.getSet() == entry.getSet() + && e.getTag() == entry.getTag() + && e.getMetered() == entry.getMetered() + && e.getRoaming() == entry.getRoaming() + && e.getDefaultNetwork() == entry.getDefaultNetwork() + /*&& Objects.equals(e.getIface(), entry.getIface())*/) { + lastEntry = e; + break; + } + } + } + if (lastEntry != null) { + delta.mRxBytes = entry.getRxBytes() - lastEntry.getRxBytes(); + delta.mRxPackets = entry.getRxPackets() - lastEntry.getRxPackets(); + delta.mTxBytes = entry.getTxBytes() - lastEntry.getTxBytes(); + delta.mTxPackets = entry.getTxPackets() - lastEntry.getTxPackets(); + } else { + delta.mRxBytes = entry.getRxBytes(); + delta.mRxPackets = entry.getRxPackets(); + delta.mTxBytes = entry.getTxBytes(); + delta.mTxPackets = entry.getTxPackets(); + } + deltaList.add(delta); + } + + return deltaList; + } + /** * Distribute WiFi energy info and network traffic to apps. * @param info The energy information from the WiFi controller. @@ -11879,14 +11996,14 @@ public class BatteryStatsImpl extends BatteryStats { } // Grab a separate lock to acquire the network stats, which may do I/O. - NetworkStats delta = null; + List<NetworkStatsDelta> delta; synchronized (mWifiNetworkLock) { final NetworkStats latestStats = readWifiNetworkStatsLocked(networkStatsManager); if (latestStats != null) { - delta = mLastWifiNetworkStats != null - ? latestStats.subtract(mLastWifiNetworkStats) - : latestStats.subtract(new NetworkStats(0, -1)); + delta = computeDelta(latestStats, mLastWifiNetworkStats); mLastWifiNetworkStats = latestStats; + } else { + delta = null; } } @@ -11914,7 +12031,7 @@ public class BatteryStatsImpl extends BatteryStats { long totalTxPackets = 0; long totalRxPackets = 0; if (delta != null) { - for (NetworkStats.Entry entry : delta) { + for (NetworkStatsDelta entry : delta) { if (DEBUG_ENERGY) { Slog.d(TAG, "Wifi uid " + entry.getUid() + ": delta rx=" + entry.getRxBytes() @@ -12199,13 +12316,16 @@ public class BatteryStatsImpl extends BatteryStats { } // Converting uWs to mAms. // Conversion: (uWs * (1000ms / 1s) * (1mW / 1000uW)) / mV = mAms - long monitoredRailChargeConsumedMaMs = - (long) (mTmpRailStats.getWifiTotalEnergyUseduWs() / opVolt); + long monitoredRailChargeConsumedMaMs = mTmpRailStats != null + ? (long) (mTmpRailStats.getWifiTotalEnergyUseduWs() / opVolt) + : 0L; mWifiActivity.getMonitoredRailChargeConsumedMaMs().addCountLocked( monitoredRailChargeConsumedMaMs); mHistory.recordWifiConsumedCharge(elapsedRealtimeMs, uptimeMs, (monitoredRailChargeConsumedMaMs / MILLISECONDS_IN_HOUR)); - mTmpRailStats.resetWifiTotalEnergyUsed(); + if (mTmpRailStats != null) { + mTmpRailStats.resetWifiTotalEnergyUsed(); + } if (uidEstimatedConsumptionMah != null) { totalEstimatedConsumptionMah = Math.max(controllerMaMs / MILLISECONDS_IN_HOUR, @@ -13519,14 +13639,16 @@ public class BatteryStatsImpl extends BatteryStats { } } - // Record whether we've seen a non-zero time (for debugging b/22716723). - if (wakelockStats.isEmpty()) { - Slog.wtf(TAG, "All kernel wakelocks had time of zero"); - } + if (DEBUG) { + // Record whether we've seen a non-zero time (for debugging b/22716723). + if (wakelockStats.isEmpty()) { + Slog.wtf(TAG, "All kernel wakelocks had time of zero"); + } - if (numWakelocksSetStale == mKernelWakelockStats.size()) { - Slog.wtf(TAG, "All kernel wakelocks were set stale. new version=" + - wakelockStats.kernelWakelockVersion); + if (numWakelocksSetStale == mKernelWakelockStats.size()) { + Slog.wtf(TAG, "All kernel wakelocks were set stale. new version=" + + wakelockStats.kernelWakelockVersion); + } } } @@ -14711,13 +14833,13 @@ public class BatteryStatsImpl extends BatteryStats { // Inform StatsLog of setBatteryState changes. private void reportChangesToStatsLog(final int status, final int plugType, final int level) { if (!mHaveBatteryLevel || mBatteryStatus != status) { - FrameworkStatsLog.write(FrameworkStatsLog.CHARGING_STATE_CHANGED, status); + mFrameworkStatsLogger.chargingStateChanged(status); } if (!mHaveBatteryLevel || mBatteryPlugType != plugType) { - FrameworkStatsLog.write(FrameworkStatsLog.PLUGGED_STATE_CHANGED, plugType); + mFrameworkStatsLogger.pluggedStateChanged(plugType); } if (!mHaveBatteryLevel || mBatteryLevel != level) { - FrameworkStatsLog.write(FrameworkStatsLog.BATTERY_LEVEL_CHANGED, level); + mFrameworkStatsLogger.batteryLevelChanged(level); } } diff --git a/services/core/java/com/android/server/power/stats/MobileRadioPowerCalculator.java b/services/core/java/com/android/server/power/stats/MobileRadioPowerCalculator.java index aba8e5fa9507..1050e8a371e8 100644 --- a/services/core/java/com/android/server/power/stats/MobileRadioPowerCalculator.java +++ b/services/core/java/com/android/server/power/stats/MobileRadioPowerCalculator.java @@ -32,6 +32,7 @@ import com.android.internal.power.ModemPowerProfile; import java.util.ArrayList; +@android.ravenwood.annotation.RavenwoodKeepWholeClass public class MobileRadioPowerCalculator extends PowerCalculator { private static final String TAG = "MobRadioPowerCalculator"; private static final boolean DEBUG = PowerCalculator.DEBUG; @@ -320,7 +321,7 @@ public class MobileRadioPowerCalculator extends PowerCalculator { private double calculateActiveModemPowerMah(BatteryStats bs, long elapsedRealtimeUs) { final long elapsedRealtimeMs = elapsedRealtimeUs / 1000; - final int txLvlCount = CellSignalStrength.getNumSignalStrengthLevels(); + final int txLvlCount = NUM_SIGNAL_STRENGTH_LEVELS; double consumptionMah = 0.0; if (DEBUG) { diff --git a/services/tests/powerstatstests/Android.bp b/services/tests/powerstatstests/Android.bp index 64fef68e387a..1de049eaf263 100644 --- a/services/tests/powerstatstests/Android.bp +++ b/services/tests/powerstatstests/Android.bp @@ -8,6 +8,37 @@ filegroup { srcs: [ "src/com/android/server/power/stats/AggregatedPowerStatsProcessorTest.java", "src/com/android/server/power/stats/AggregatedPowerStatsTest.java", + "src/com/android/server/power/stats/AmbientDisplayPowerCalculatorTest.java", + "src/com/android/server/power/stats/AudioPowerCalculatorTest.java", + "src/com/android/server/power/stats/BatteryChargeCalculatorTest.java", + "src/com/android/server/power/stats/BatteryStatsCounterTest.java", + "src/com/android/server/power/stats/BatteryStatsCpuTimesTest.java", + "src/com/android/server/power/stats/BatteryStatsDualTimerTest.java", + "src/com/android/server/power/stats/BatteryStatsDurationTimerTest.java", + "src/com/android/server/power/stats/BatteryStatsHistoryIteratorTest.java", + "src/com/android/server/power/stats/BatteryStatsHistoryTest.java", + "src/com/android/server/power/stats/BatteryStatsImplTest.java", + "src/com/android/server/power/stats/BatteryStatsNoteTest.java", + "src/com/android/server/power/stats/BatteryStatsSamplingTimerTest.java", + "src/com/android/server/power/stats/BatteryStatsSensorTest.java", + "src/com/android/server/power/stats/BatteryStatsServTest.java", + "src/com/android/server/power/stats/BatteryStatsStopwatchTimerTest.java", + "src/com/android/server/power/stats/BatteryStatsTimeBaseTest.java", + "src/com/android/server/power/stats/BatteryStatsTimerTest.java", + "src/com/android/server/power/stats/BatteryUsageStatsProviderTest.java", + "src/com/android/server/power/stats/BatteryUsageStatsTest.java", + "src/com/android/server/power/stats/BluetoothPowerCalculatorTest.java", + "src/com/android/server/power/stats/CameraPowerCalculatorTest.java", + "src/com/android/server/power/stats/CpuAggregatedPowerStatsProcessorTest.java", + "src/com/android/server/power/stats/CpuPowerCalculatorTest.java", + "src/com/android/server/power/stats/CustomEnergyConsumerPowerCalculatorTest.java", + "src/com/android/server/power/stats/EnergyConsumerSnapshotTest.java", + "src/com/android/server/power/stats/FlashlightPowerCalculatorTest.java", + "src/com/android/server/power/stats/GnssPowerCalculatorTest.java", + "src/com/android/server/power/stats/IdlePowerCalculatorTest.java", + "src/com/android/server/power/stats/LongSamplingCounterArrayTest.java", + "src/com/android/server/power/stats/LongSamplingCounterTest.java", + "src/com/android/server/power/stats/MemoryPowerCalculatorTest.java", "src/com/android/server/power/stats/MultiStateStatsTest.java", "src/com/android/server/power/stats/PowerStatsAggregatorTest.java", "src/com/android/server/power/stats/PowerStatsCollectorTest.java", @@ -15,6 +46,12 @@ filegroup { "src/com/android/server/power/stats/PowerStatsSchedulerTest.java", "src/com/android/server/power/stats/PowerStatsStoreTest.java", "src/com/android/server/power/stats/PowerStatsUidResolverTest.java", + "src/com/android/server/power/stats/ScreenPowerCalculatorTest.java", + "src/com/android/server/power/stats/SensorPowerCalculatorTest.java", + "src/com/android/server/power/stats/UserPowerCalculatorTest.java", + "src/com/android/server/power/stats/VideoPowerCalculatorTest.java", + "src/com/android/server/power/stats/WakelockPowerCalculatorTest.java", + "src/com/android/server/power/stats/WifiPowerCalculatorTest.java", ], } @@ -26,10 +63,6 @@ android_test { "src/**/*.java", ], - exclude_srcs: [ - ":power_stats_ravenwood_tests", - ], - static_libs: [ "services.core", "coretests-aidl", @@ -41,6 +74,7 @@ android_test { "androidx.test.ext.truth", "androidx.test.uiautomator_uiautomator", "mockito-target-minus-junit4", + "ravenwood-junit", "servicestests-utils", "platform-test-annotations", "flag-junit", diff --git a/services/tests/powerstatstests/src/com/android/server/power/stats/AmbientDisplayPowerCalculatorTest.java b/services/tests/powerstatstests/src/com/android/server/power/stats/AmbientDisplayPowerCalculatorTest.java index 319a280d10cc..f74cfae6a81b 100644 --- a/services/tests/powerstatstests/src/com/android/server/power/stats/AmbientDisplayPowerCalculatorTest.java +++ b/services/tests/powerstatstests/src/com/android/server/power/stats/AmbientDisplayPowerCalculatorTest.java @@ -21,6 +21,7 @@ import static com.android.internal.os.PowerProfile.POWER_GROUP_DISPLAY_AMBIENT; import static com.google.common.truth.Truth.assertThat; import android.os.BatteryConsumer; +import android.platform.test.ravenwood.RavenwoodRule; import android.view.Display; import androidx.test.filters.SmallTest; @@ -34,10 +35,15 @@ import org.junit.runner.RunWith; @SmallTest @SuppressWarnings("GuardedBy") public class AmbientDisplayPowerCalculatorTest { + @Rule(order = 0) + public final RavenwoodRule mRavenwood = new RavenwoodRule.Builder() + .setProvideMainThread(true) + .build(); + private static final double PRECISION = 0.00001; private static final long MINUTE_IN_MS = 60 * 1000; - @Rule + @Rule(order = 1) public final BatteryUsageStatsRule mStatsRule = new BatteryUsageStatsRule() .setAveragePowerForOrdinal(POWER_GROUP_DISPLAY_AMBIENT, 0, 10.0) .setNumDisplays(1); diff --git a/services/tests/powerstatstests/src/com/android/server/power/stats/AudioPowerCalculatorTest.java b/services/tests/powerstatstests/src/com/android/server/power/stats/AudioPowerCalculatorTest.java index fb367b24168e..ce451c2a842a 100644 --- a/services/tests/powerstatstests/src/com/android/server/power/stats/AudioPowerCalculatorTest.java +++ b/services/tests/powerstatstests/src/com/android/server/power/stats/AudioPowerCalculatorTest.java @@ -21,6 +21,7 @@ import static com.google.common.truth.Truth.assertThat; import android.os.BatteryConsumer; import android.os.Process; import android.os.UidBatteryConsumer; +import android.platform.test.ravenwood.RavenwoodRule; import androidx.test.filters.SmallTest; import androidx.test.runner.AndroidJUnit4; @@ -34,11 +35,16 @@ import org.junit.runner.RunWith; @RunWith(AndroidJUnit4.class) @SmallTest public class AudioPowerCalculatorTest { + @Rule(order = 0) + public final RavenwoodRule mRavenwood = new RavenwoodRule.Builder() + .setProvideMainThread(true) + .build(); + private static final double PRECISION = 0.00001; private static final int APP_UID = Process.FIRST_APPLICATION_UID + 42; - @Rule + @Rule(order = 1) public final BatteryUsageStatsRule mStatsRule = new BatteryUsageStatsRule() .setAveragePower(PowerProfile.POWER_AUDIO, 360.0); diff --git a/services/tests/powerstatstests/src/com/android/server/power/stats/BatteryChargeCalculatorTest.java b/services/tests/powerstatstests/src/com/android/server/power/stats/BatteryChargeCalculatorTest.java index 3f058a2348c3..3ab1c2eab6ca 100644 --- a/services/tests/powerstatstests/src/com/android/server/power/stats/BatteryChargeCalculatorTest.java +++ b/services/tests/powerstatstests/src/com/android/server/power/stats/BatteryChargeCalculatorTest.java @@ -21,6 +21,7 @@ import static com.google.common.truth.Truth.assertThat; import android.os.BatteryManager; import android.os.BatteryUsageStats; +import android.platform.test.ravenwood.RavenwoodRule; import androidx.test.filters.SmallTest; import androidx.test.runner.AndroidJUnit4; @@ -34,9 +35,14 @@ import org.junit.runner.RunWith; @RunWith(AndroidJUnit4.class) @SmallTest public class BatteryChargeCalculatorTest { + @Rule(order = 0) + public final RavenwoodRule mRavenwood = new RavenwoodRule.Builder() + .setProvideMainThread(true) + .build(); + private static final double PRECISION = 0.00001; - @Rule + @Rule(order = 1) public final BatteryUsageStatsRule mStatsRule = new BatteryUsageStatsRule() .setAveragePower(PowerProfile.POWER_BATTERY_CAPACITY, 4000.0); @@ -46,15 +52,17 @@ public class BatteryChargeCalculatorTest { final BatteryStatsImpl batteryStats = mStatsRule.getBatteryStats(); - batteryStats.setBatteryStateLocked(BatteryManager.BATTERY_STATUS_DISCHARGING, 100, - /* plugType */ 0, 90, 72, 3700, 3_600_000, 4_000_000, 0, - 1_000_000, 1_000_000, 1_000_000); - batteryStats.setBatteryStateLocked(BatteryManager.BATTERY_STATUS_DISCHARGING, 100, - /* plugType */ 0, 85, 72, 3700, 3_000_000, 4_000_000, 0, - 1_500_000, 1_500_000, 1_500_000); - batteryStats.setBatteryStateLocked(BatteryManager.BATTERY_STATUS_DISCHARGING, 100, - /* plugType */ 0, 80, 72, 3700, 2_400_000, 4_000_000, 0, - 2_000_000, 2_000_000, 2_000_000); + synchronized (batteryStats) { + batteryStats.setBatteryStateLocked(BatteryManager.BATTERY_STATUS_DISCHARGING, 100, + /* plugType */ 0, 90, 72, 3700, 3_600_000, 4_000_000, 0, + 1_000_000, 1_000_000, 1_000_000); + batteryStats.setBatteryStateLocked(BatteryManager.BATTERY_STATUS_DISCHARGING, 100, + /* plugType */ 0, 85, 72, 3700, 3_000_000, 4_000_000, 0, + 1_500_000, 1_500_000, 1_500_000); + batteryStats.setBatteryStateLocked(BatteryManager.BATTERY_STATUS_DISCHARGING, 100, + /* plugType */ 0, 80, 72, 3700, 2_400_000, 4_000_000, 0, + 2_000_000, 2_000_000, 2_000_000); + } mStatsRule.setTime(5_000_000, 5_000_000); BatteryChargeCalculator calculator = new BatteryChargeCalculator(); @@ -73,10 +81,11 @@ public class BatteryChargeCalculatorTest { assertThat(batteryUsageStats.getChargeTimeRemainingMs()).isEqualTo(-1); // Plug in - batteryStats.setBatteryStateLocked(BatteryManager.BATTERY_STATUS_CHARGING, 100, - BatteryManager.BATTERY_PLUGGED_USB, 80, 72, 3700, 2_400_000, 4_000_000, 100, - 4_000_000, 4_000_000, 4_000_000); - + synchronized (batteryStats) { + batteryStats.setBatteryStateLocked(BatteryManager.BATTERY_STATUS_CHARGING, 100, + BatteryManager.BATTERY_PLUGGED_USB, 80, 72, 3700, 2_400_000, 4_000_000, 100, + 4_000_000, 4_000_000, 4_000_000); + } batteryUsageStats = mStatsRule.apply(calculator); assertThat(batteryUsageStats.getChargeTimeRemainingMs()).isEqualTo(100_000); @@ -86,15 +95,17 @@ public class BatteryChargeCalculatorTest { public void testDischargeTotals_chargeUahUnavailable() { final BatteryStatsImpl batteryStats = mStatsRule.getBatteryStats(); - batteryStats.setBatteryStateLocked(BatteryManager.BATTERY_STATUS_DISCHARGING, 100, - /* plugType */ 0, 90, 72, 3700, 0, 0, 0, - 1_000_000, 1_000_000, 1_000_000); - batteryStats.setBatteryStateLocked(BatteryManager.BATTERY_STATUS_DISCHARGING, 100, - /* plugType */ 0, 85, 72, 3700, 0, 0, 0, - 1_500_000, 1_500_000, 1_500_000); - batteryStats.setBatteryStateLocked(BatteryManager.BATTERY_STATUS_DISCHARGING, 100, - /* plugType */ 0, 80, 72, 3700, 0, 0, 0, - 2_000_000, 2_000_000, 2_000_000); + synchronized (batteryStats) { + batteryStats.setBatteryStateLocked(BatteryManager.BATTERY_STATUS_DISCHARGING, 100, + /* plugType */ 0, 90, 72, 3700, 0, 0, 0, + 1_000_000, 1_000_000, 1_000_000); + batteryStats.setBatteryStateLocked(BatteryManager.BATTERY_STATUS_DISCHARGING, 100, + /* plugType */ 0, 85, 72, 3700, 0, 0, 0, + 1_500_000, 1_500_000, 1_500_000); + batteryStats.setBatteryStateLocked(BatteryManager.BATTERY_STATUS_DISCHARGING, 100, + /* plugType */ 0, 80, 72, 3700, 0, 0, 0, + 2_000_000, 2_000_000, 2_000_000); + } BatteryChargeCalculator calculator = new BatteryChargeCalculator(); BatteryUsageStats batteryUsageStats = mStatsRule.apply(calculator); diff --git a/services/tests/powerstatstests/src/com/android/server/power/stats/BatteryExternalStatsWorkerTest.java b/services/tests/powerstatstests/src/com/android/server/power/stats/BatteryExternalStatsWorkerTest.java index 9c2834d31609..997b7712a9dd 100644 --- a/services/tests/powerstatstests/src/com/android/server/power/stats/BatteryExternalStatsWorkerTest.java +++ b/services/tests/powerstatstests/src/com/android/server/power/stats/BatteryExternalStatsWorkerTest.java @@ -215,7 +215,7 @@ public class BatteryExternalStatsWorkerTest { public class TestBatteryStatsImpl extends BatteryStatsImpl { public TestBatteryStatsImpl(Context context) { - super(Clock.SYSTEM_CLOCK, null, null, null); + super(Clock.SYSTEM_CLOCK, null, null, null, null, null, null); mPowerProfile = new PowerProfile(context, true /* forTest */); SparseArray<int[]> cpusByPolicy = new SparseArray<>(); diff --git a/services/tests/powerstatstests/src/com/android/server/power/stats/BatteryStatsCpuTimesTest.java b/services/tests/powerstatstests/src/com/android/server/power/stats/BatteryStatsCpuTimesTest.java index f9f32b2e7091..6e62147ac6c1 100644 --- a/services/tests/powerstatstests/src/com/android/server/power/stats/BatteryStatsCpuTimesTest.java +++ b/services/tests/powerstatstests/src/com/android/server/power/stats/BatteryStatsCpuTimesTest.java @@ -40,6 +40,7 @@ import android.os.BatteryStats; import android.os.Handler; import android.os.Looper; import android.os.UserHandle; +import android.platform.test.ravenwood.RavenwoodRule; import android.util.SparseArray; import android.util.SparseLongArray; import android.view.Display; @@ -56,6 +57,7 @@ import com.android.internal.os.KernelCpuUidTimeReader.KernelCpuUidUserSysTimeRea import com.android.internal.util.ArrayUtils; import org.junit.Before; +import org.junit.Rule; import org.junit.Test; import org.junit.runner.RunWith; import org.mockito.Mock; @@ -84,7 +86,13 @@ import java.util.Arrays; */ @SmallTest @RunWith(AndroidJUnit4.class) +@SuppressWarnings("SynchronizeOnNonFinalField") public class BatteryStatsCpuTimesTest { + @Rule + public final RavenwoodRule mRavenwood = new RavenwoodRule.Builder() + .setProvideMainThread(true) + .build(); + @Mock KernelCpuUidUserSysTimeReader mCpuUidUserSysTimeReader; @Mock @@ -128,7 +136,9 @@ public class BatteryStatsCpuTimesTest { initKernelCpuSpeedReaders(numClusters); // RUN - mBatteryStatsImpl.updateCpuTimeLocked(false, false, null); + synchronized (mBatteryStatsImpl) { + mBatteryStatsImpl.updateCpuTimeLocked(false, false, null); + } // VERIFY verify(mCpuUidUserSysTimeReader).readDelta(anyBoolean(), isNull()); @@ -147,7 +157,9 @@ public class BatteryStatsCpuTimesTest { mBatteryStatsImpl.setOnBatteryInternal(true); // RUN - mBatteryStatsImpl.updateCpuTimeLocked(true, false, null); + synchronized (mBatteryStatsImpl) { + mBatteryStatsImpl.updateCpuTimeLocked(true, false, null); + } // VERIFY verify(mUserInfoProvider).refreshUserIds(); @@ -239,7 +251,7 @@ public class BatteryStatsCpuTimesTest { mBatteryStatsImpl.updateClusterSpeedTimes(updatedUids, true, null); // VERIFY - int totalClustersTimeMs = 0; + long totalClustersTimeMs = 0; for (int i = 0; i < clusterSpeedTimesMs.length; ++i) { for (int j = 0; j < clusterSpeedTimesMs[i].length; ++j) { totalClustersTimeMs += clusterSpeedTimesMs[i][j]; diff --git a/services/tests/powerstatstests/src/com/android/server/power/stats/BatteryStatsHistoryIteratorTest.java b/services/tests/powerstatstests/src/com/android/server/power/stats/BatteryStatsHistoryIteratorTest.java index bf5bf365965d..395b3aac8fd5 100644 --- a/services/tests/powerstatstests/src/com/android/server/power/stats/BatteryStatsHistoryIteratorTest.java +++ b/services/tests/powerstatstests/src/com/android/server/power/stats/BatteryStatsHistoryIteratorTest.java @@ -21,6 +21,7 @@ import static com.google.common.truth.Truth.assertThat; import android.os.BatteryManager; import android.os.BatteryStats; import android.os.Process; +import android.platform.test.ravenwood.RavenwoodRule; import androidx.test.filters.SmallTest; import androidx.test.runner.AndroidJUnit4; @@ -29,6 +30,7 @@ import com.android.internal.os.BatteryStatsHistoryIterator; import com.android.internal.os.MonotonicClock; import org.junit.Before; +import org.junit.Rule; import org.junit.Test; import org.junit.runner.RunWith; @@ -42,6 +44,11 @@ import java.util.concurrent.Future; @SmallTest @SuppressWarnings("GuardedBy") public class BatteryStatsHistoryIteratorTest { + @Rule + public final RavenwoodRule mRavenwood = new RavenwoodRule.Builder() + .setProvideMainThread(true) + .build(); + private static final int APP_UID = Process.FIRST_APPLICATION_UID + 42; private final MockClock mMockClock = new MockClock(); diff --git a/services/tests/powerstatstests/src/com/android/server/power/stats/BatteryStatsHistoryTest.java b/services/tests/powerstatstests/src/com/android/server/power/stats/BatteryStatsHistoryTest.java index 92513760fa4a..c58c92b47dd3 100644 --- a/services/tests/powerstatstests/src/com/android/server/power/stats/BatteryStatsHistoryTest.java +++ b/services/tests/powerstatstests/src/com/android/server/power/stats/BatteryStatsHistoryTest.java @@ -26,7 +26,6 @@ import static org.mockito.Mockito.doAnswer; import static org.mockito.Mockito.spy; import static org.mockito.Mockito.when; -import android.content.Context; import android.os.BatteryConsumer; import android.os.BatteryManager; import android.os.BatteryStats; @@ -39,7 +38,6 @@ import android.telephony.NetworkRegistrationInfo; import android.util.AtomicFile; import android.util.Log; -import androidx.test.InstrumentationRegistry; import androidx.test.runner.AndroidJUnit4; import com.android.internal.os.BatteryStatsHistory; @@ -59,6 +57,7 @@ import java.io.File; import java.io.IOException; import java.io.PrintWriter; import java.io.StringWriter; +import java.nio.file.Files; import java.util.ArrayList; import java.util.Arrays; import java.util.List; @@ -80,13 +79,14 @@ public class BatteryStatsHistoryTest { private BatteryStatsHistory.TraceDelegate mTracer; @Mock private BatteryStatsHistory.HistoryStepDetailsCalculator mStepDetailsCalculator; + @Mock + private BatteryStatsHistory.EventLogger mEventLogger; private List<String> mReadFiles = new ArrayList<>(); @Before - public void setUp() { + public void setUp() throws IOException { MockitoAnnotations.initMocks(this); - Context context = InstrumentationRegistry.getContext(); - mSystemDir = context.getDataDir(); + mSystemDir = Files.createTempDirectory("BatteryStatsHistoryTest").toFile(); mHistoryDir = new File(mSystemDir, "battery-history"); String[] files = mHistoryDir.list(); if (files != null) { @@ -99,7 +99,7 @@ public class BatteryStatsHistoryTest { mClock.realtime = 123; mHistory = new BatteryStatsHistory(mHistoryBuffer, mSystemDir, 32, 1024, - mStepDetailsCalculator, mClock, mMonotonicClock, mTracer); + mStepDetailsCalculator, mClock, mMonotonicClock, mTracer, mEventLogger); when(mStepDetailsCalculator.getHistoryStepDetails()) .thenReturn(new BatteryStats.HistoryStepDetails()); @@ -238,7 +238,7 @@ public class BatteryStatsHistoryTest { // create a new BatteryStatsHistory object, it will pick up existing history files. BatteryStatsHistory history2 = new BatteryStatsHistory(mHistoryBuffer, mSystemDir, 32, 1024, - null, mClock, mMonotonicClock, mTracer); + null, mClock, mMonotonicClock, mTracer, mEventLogger); // verify constructor can pick up all files from file system. verifyFileNames(history2, fileList); verifyActiveFile(history2, "33000.bh"); @@ -534,7 +534,7 @@ public class BatteryStatsHistoryTest { // Keep the preserved part of history short - we only need to capture the very tail of // history. mHistory = new BatteryStatsHistory(mHistoryBuffer, mSystemDir, 1, 6000, - mStepDetailsCalculator, mClock, mMonotonicClock, mTracer); + mStepDetailsCalculator, mClock, mMonotonicClock, mTracer, mEventLogger); mHistory.forceRecordAllHistory(); diff --git a/services/tests/powerstatstests/src/com/android/server/power/stats/BatteryStatsImplTest.java b/services/tests/powerstatstests/src/com/android/server/power/stats/BatteryStatsImplTest.java index 8d51592667c8..548fae7a0b01 100644 --- a/services/tests/powerstatstests/src/com/android/server/power/stats/BatteryStatsImplTest.java +++ b/services/tests/powerstatstests/src/com/android/server/power/stats/BatteryStatsImplTest.java @@ -31,15 +31,18 @@ import static org.junit.Assert.assertFalse; import static org.junit.Assert.assertNotNull; import static org.junit.Assert.assertTrue; import static org.mockito.ArgumentMatchers.any; +import static org.mockito.ArgumentMatchers.anyInt; import static org.mockito.ArgumentMatchers.anyLong; import static org.mockito.ArgumentMatchers.eq; import static org.mockito.Mockito.doAnswer; +import static org.mockito.Mockito.mock; import static org.mockito.Mockito.when; import android.app.ActivityManager; import android.bluetooth.BluetoothActivityEnergyInfo; import android.bluetooth.UidTraffic; import android.content.Context; +import android.hardware.SensorManager; import android.os.BatteryConsumer; import android.os.BatteryManager; import android.os.BatteryStats; @@ -51,11 +54,11 @@ import android.os.HandlerThread; import android.os.Parcel; import android.os.WakeLockStats; import android.os.WorkSource; +import android.platform.test.ravenwood.RavenwoodRule; import android.util.SparseArray; import android.view.Display; import androidx.test.InstrumentationRegistry; -import androidx.test.filters.LargeTest; import androidx.test.runner.AndroidJUnit4; import com.android.internal.os.CpuScalingPolicies; @@ -68,19 +71,26 @@ import com.google.common.collect.ImmutableList; import com.google.common.truth.LongSubject; import org.junit.Before; +import org.junit.Rule; import org.junit.Test; import org.junit.runner.RunWith; import org.mockito.Mock; import org.mockito.MockitoAnnotations; import java.io.File; +import java.io.IOException; +import java.nio.file.Files; import java.time.Instant; import java.util.List; -@LargeTest @RunWith(AndroidJUnit4.class) @SuppressWarnings("GuardedBy") public class BatteryStatsImplTest { + @Rule + public final RavenwoodRule mRavenwood = new RavenwoodRule.Builder() + .setProvideMainThread(true) + .build(); + @Mock private KernelCpuUidFreqTimeReader mKernelUidCpuFreqTimeReader; @Mock @@ -110,7 +120,7 @@ public class BatteryStatsImplTest { private PowerStatsExporter mPowerStatsExporter; @Before - public void setUp() { + public void setUp() throws IOException { MockitoAnnotations.initMocks(this); when(mKernelUidCpuFreqTimeReader.isFastCpuTimesReader()).thenReturn(true); @@ -128,8 +138,17 @@ public class BatteryStatsImplTest { .setKernelSingleUidTimeReader(mKernelSingleUidTimeReader) .setKernelWakelockReader(mKernelWakelockReader); - final Context context = InstrumentationRegistry.getContext(); - File systemDir = context.getCacheDir(); + File systemDir = Files.createTempDirectory("BatteryStatsHistoryTest").toFile(); + + Context context; + if (RavenwoodRule.isUnderRavenwood()) { + context = mock(Context.class); + SensorManager sensorManager = mock(SensorManager.class); + when(sensorManager.getSensorList(anyInt())).thenReturn(List.of()); + when(context.getSystemService(SensorManager.class)).thenReturn(sensorManager); + } else { + context = InstrumentationRegistry.getContext(); + } mPowerStatsStore = new PowerStatsStore(systemDir, mHandler, new AggregatedPowerStatsConfig()); mBatteryUsageStatsProvider = new BatteryUsageStatsProvider(context, mPowerStatsExporter, @@ -747,14 +766,22 @@ public class BatteryStatsImplTest { } private UidTraffic createUidTraffic(int appUid, long rxBytes, long txBytes) { - final Parcel parcel = Parcel.obtain(); - parcel.writeInt(appUid); // mAppUid - parcel.writeLong(rxBytes); // mRxBytes - parcel.writeLong(txBytes); // mTxBytes - parcel.setDataPosition(0); - UidTraffic uidTraffic = UidTraffic.CREATOR.createFromParcel(parcel); - parcel.recycle(); - return uidTraffic; + if (RavenwoodRule.isUnderRavenwood()) { + UidTraffic uidTraffic = mock(UidTraffic.class); + when(uidTraffic.getUid()).thenReturn(appUid); + when(uidTraffic.getRxBytes()).thenReturn(rxBytes); + when(uidTraffic.getTxBytes()).thenReturn(txBytes); + return uidTraffic; + } else { + final Parcel parcel = Parcel.obtain(); + parcel.writeInt(appUid); // mAppUid + parcel.writeLong(rxBytes); // mRxBytes + parcel.writeLong(txBytes); // mTxBytes + parcel.setDataPosition(0); + UidTraffic uidTraffic = UidTraffic.CREATOR.createFromParcel(parcel); + parcel.recycle(); + return uidTraffic; + } } private BluetoothActivityEnergyInfo createBluetoothActivityEnergyInfo( @@ -764,21 +791,31 @@ public class BatteryStatsImplTest { long controllerIdleTimeMs, long controllerEnergyUsed, UidTraffic... uidTraffic) { - Parcel parcel = Parcel.obtain(); - parcel.writeLong(timestamp); // mTimestamp - parcel.writeInt( - BluetoothActivityEnergyInfo.BT_STACK_STATE_STATE_ACTIVE); // mBluetoothStackState - parcel.writeLong(controllerTxTimeMs); // mControllerTxTimeMs; - parcel.writeLong(controllerRxTimeMs); // mControllerRxTimeMs; - parcel.writeLong(controllerIdleTimeMs); // mControllerIdleTimeMs; - parcel.writeLong(controllerEnergyUsed); // mControllerEnergyUsed; - parcel.writeTypedList(ImmutableList.copyOf(uidTraffic)); // mUidTraffic - parcel.setDataPosition(0); - - BluetoothActivityEnergyInfo info = - BluetoothActivityEnergyInfo.CREATOR.createFromParcel(parcel); - parcel.recycle(); - return info; + if (RavenwoodRule.isUnderRavenwood()) { + BluetoothActivityEnergyInfo info = mock(BluetoothActivityEnergyInfo.class); + when(info.getTimestampMillis()).thenReturn(timestamp); + when(info.getControllerTxTimeMillis()).thenReturn(controllerTxTimeMs); + when(info.getControllerRxTimeMillis()).thenReturn(controllerRxTimeMs); + when(info.getControllerIdleTimeMillis()).thenReturn(controllerIdleTimeMs); + when(info.getControllerEnergyUsed()).thenReturn(controllerEnergyUsed); + when(info.getUidTraffic()).thenReturn(ImmutableList.copyOf(uidTraffic)); + return info; + } else { + Parcel parcel = Parcel.obtain(); + parcel.writeLong(timestamp); // mTimestamp + parcel.writeInt(BluetoothActivityEnergyInfo.BT_STACK_STATE_STATE_ACTIVE); + parcel.writeLong(controllerTxTimeMs); // mControllerTxTimeMs; + parcel.writeLong(controllerRxTimeMs); // mControllerRxTimeMs; + parcel.writeLong(controllerIdleTimeMs); // mControllerIdleTimeMs; + parcel.writeLong(controllerEnergyUsed); // mControllerEnergyUsed; + parcel.writeTypedList(ImmutableList.copyOf(uidTraffic)); // mUidTraffic + parcel.setDataPosition(0); + + BluetoothActivityEnergyInfo info = + BluetoothActivityEnergyInfo.CREATOR.createFromParcel(parcel); + parcel.recycle(); + return info; + } } @Test diff --git a/services/tests/powerstatstests/src/com/android/server/power/stats/BatteryStatsNoteTest.java b/services/tests/powerstatstests/src/com/android/server/power/stats/BatteryStatsNoteTest.java index eea287568e13..07cefa9ae878 100644 --- a/services/tests/powerstatstests/src/com/android/server/power/stats/BatteryStatsNoteTest.java +++ b/services/tests/powerstatstests/src/com/android/server/power/stats/BatteryStatsNoteTest.java @@ -28,6 +28,10 @@ import static com.android.server.power.stats.BatteryStatsImpl.ExternalStatsSync. import static com.google.common.truth.Truth.assertThat; +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertNotNull; +import static org.junit.Assert.assertTrue; import static org.mockito.Mockito.mock; import android.app.ActivityManager; @@ -40,6 +44,7 @@ import android.os.Looper; import android.os.Process; import android.os.UserHandle; import android.os.WorkSource; +import android.platform.test.ravenwood.RavenwoodRule; import android.telephony.AccessNetworkConstants; import android.telephony.ActivityStatsTechSpecificInfo; import android.telephony.Annotation; @@ -50,7 +55,6 @@ import android.telephony.NetworkRegistrationInfo; import android.telephony.ServiceState; import android.telephony.TelephonyManager; import android.util.Log; -import android.util.MutableInt; import android.util.SparseIntArray; import android.util.SparseLongArray; import android.view.Display; @@ -63,8 +67,8 @@ import com.android.internal.os.PowerProfile; import com.android.internal.power.EnergyConsumerStats; import com.android.server.power.stats.BatteryStatsImpl.DualTimer; -import junit.framework.TestCase; - +import org.junit.Rule; +import org.junit.Test; import org.mockito.Mock; import java.util.ArrayList; @@ -78,7 +82,14 @@ import java.util.function.IntConsumer; * Test various BatteryStatsImpl noteStart methods. */ @SuppressWarnings("GuardedBy") -public class BatteryStatsNoteTest extends TestCase { +@SmallTest +public class BatteryStatsNoteTest { + + @Rule + public final RavenwoodRule mRavenwood = new RavenwoodRule.Builder() + .setProvideMainThread(true) + .build(); + private static final String TAG = BatteryStatsNoteTest.class.getSimpleName(); private static final int UID = 10500; @@ -96,7 +107,7 @@ public class BatteryStatsNoteTest extends TestCase { /** * Test BatteryStatsImpl.Uid.noteBluetoothScanResultLocked. */ - @SmallTest + @Test public void testNoteBluetoothScanResultLocked() throws Exception { MockBatteryStatsImpl bi = new MockBatteryStatsImpl(new MockClock()); bi.updateTimeBasesLocked(true, Display.STATE_OFF, 0, 0); @@ -125,7 +136,7 @@ public class BatteryStatsNoteTest extends TestCase { /** * Test BatteryStatsImpl.Uid.noteStartWakeLocked. */ - @SmallTest + @Test public void testNoteStartWakeLocked() throws Exception { final MockClock clocks = new MockClock(); // holds realtime and uptime in ms MockBatteryStatsImpl bi = new MockBatteryStatsImpl(clocks); @@ -155,7 +166,7 @@ public class BatteryStatsNoteTest extends TestCase { /** * Test BatteryStatsImpl.Uid.noteStartWakeLocked for an isolated uid. */ - @SmallTest + @Test public void testNoteStartWakeLocked_isolatedUid() throws Exception { final MockClock clocks = new MockClock(); // holds realtime and uptime in ms PowerStatsUidResolver uidResolver = new PowerStatsUidResolver(); @@ -197,7 +208,7 @@ public class BatteryStatsNoteTest extends TestCase { * Test BatteryStatsImpl.Uid.noteStartWakeLocked for an isolated uid, with a race where the * isolated uid is removed from batterystats before the wakelock has been stopped. */ - @SmallTest + @Test public void testNoteStartWakeLocked_isolatedUidRace() throws Exception { final MockClock clocks = new MockClock(); // holds realtime and uptime in ms PowerStatsUidResolver uidResolver = new PowerStatsUidResolver(); @@ -241,7 +252,7 @@ public class BatteryStatsNoteTest extends TestCase { /** * Test BatteryStatsImpl.Uid.noteLongPartialWakelockStart for an isolated uid. */ - @SmallTest + @Test public void testNoteLongPartialWakelockStart_isolatedUid() throws Exception { final MockClock clocks = new MockClock(); // holds realtime and uptime in ms PowerStatsUidResolver uidResolver = new PowerStatsUidResolver(); @@ -296,7 +307,7 @@ public class BatteryStatsNoteTest extends TestCase { /** * Test BatteryStatsImpl.Uid.noteLongPartialWakelockStart for an isolated uid. */ - @SmallTest + @Test public void testNoteLongPartialWakelockStart_isolatedUidRace() throws Exception { final MockClock clocks = new MockClock(); // holds realtime and uptime in ms PowerStatsUidResolver uidResolver = new PowerStatsUidResolver(); @@ -354,7 +365,7 @@ public class BatteryStatsNoteTest extends TestCase { /** * Test BatteryStatsImpl.noteUidProcessStateLocked. */ - @SmallTest + @Test public void testNoteUidProcessStateLocked() throws Exception { final MockClock clocks = new MockClock(); MockBatteryStatsImpl bi = new MockBatteryStatsImpl(clocks); @@ -441,7 +452,7 @@ public class BatteryStatsNoteTest extends TestCase { /** * Test BatteryStatsImpl.updateTimeBasesLocked. */ - @SmallTest + @Test public void testUpdateTimeBasesLocked() throws Exception { final MockClock clocks = new MockClock(); // holds realtime and uptime in ms MockBatteryStatsImpl bi = new MockBatteryStatsImpl(clocks); @@ -465,7 +476,7 @@ public class BatteryStatsNoteTest extends TestCase { /** * Test BatteryStatsImpl.noteScreenStateLocked sets timebases and screen states correctly. */ - @SmallTest + @Test public void testNoteScreenStateLocked() throws Exception { final MockClock clocks = new MockClock(); // holds realtime and uptime in ms MockBatteryStatsImpl bi = new MockBatteryStatsImpl(clocks); @@ -512,7 +523,7 @@ public class BatteryStatsNoteTest extends TestCase { * Test BatteryStatsImpl.noteScreenStateLocked sets timebases and screen states correctly for * multi display devices */ - @SmallTest + @Test public void testNoteScreenStateLocked_multiDisplay() throws Exception { final MockClock clocks = new MockClock(); // holds realtime and uptime in ms MockBatteryStatsImpl bi = new MockBatteryStatsImpl(clocks); @@ -606,7 +617,7 @@ public class BatteryStatsNoteTest extends TestCase { * Off ------- ---------------------- * Doze ---------------- */ - @SmallTest + @Test public void testNoteScreenStateTimersLocked() throws Exception { final MockClock clocks = new MockClock(); // holds realtime and uptime in ms MockBatteryStatsImpl bi = new MockBatteryStatsImpl(clocks); @@ -656,7 +667,7 @@ public class BatteryStatsNoteTest extends TestCase { * Test BatteryStatsImpl.noteScreenStateLocked updates timers correctly for multi display * devices. */ - @SmallTest + @Test public void testNoteScreenStateTimersLocked_multiDisplay() throws Exception { final MockClock clocks = new MockClock(); // holds realtime and uptime in ms MockBatteryStatsImpl bi = new MockBatteryStatsImpl(clocks); @@ -807,7 +818,7 @@ public class BatteryStatsNoteTest extends TestCase { /** * Test BatteryStatsImpl.noteScreenBrightnessLocked updates timers correctly. */ - @SmallTest + @Test public void testScreenBrightnessLocked_multiDisplay() throws Exception { final MockClock clocks = new MockClock(); // holds realtime and uptime in ms MockBatteryStatsImpl bi = new MockBatteryStatsImpl(clocks); @@ -929,7 +940,7 @@ public class BatteryStatsNoteTest extends TestCase { checkScreenBrightnesses(overallExpected, perDisplayExpected, bi, bk.currentTimeMs); } - @SmallTest + @Test public void testAlarmStartAndFinishLocked() throws Exception { final MockClock clocks = new MockClock(); // holds realtime and uptime in ms MockBatteryStatsImpl bi = new MockBatteryStatsImpl(clocks); @@ -967,7 +978,7 @@ public class BatteryStatsNoteTest extends TestCase { assertThat(iterator.next()).isNull(); } - @SmallTest + @Test public void testAlarmStartAndFinishLocked_workSource() throws Exception { final MockClock clocks = new MockClock(); // holds realtime and uptime in ms MockBatteryStatsImpl bi = new MockBatteryStatsImpl(clocks); @@ -1013,7 +1024,7 @@ public class BatteryStatsNoteTest extends TestCase { assertEquals(500, item.eventTag.uid); } - @SmallTest + @Test public void testNoteWakupAlarmLocked() { final MockClock clocks = new MockClock(); // holds realtime and uptime in ms MockBatteryStatsImpl bi = new MockBatteryStatsImpl(clocks); @@ -1031,7 +1042,7 @@ public class BatteryStatsNoteTest extends TestCase { assertEquals(1, pkg.getWakeupAlarmStats().size()); } - @SmallTest + @Test public void testNoteWakupAlarmLocked_workSource_uid() { final MockClock clocks = new MockClock(); // holds realtime and uptime in ms MockBatteryStatsImpl bi = new MockBatteryStatsImpl(clocks); @@ -1064,7 +1075,7 @@ public class BatteryStatsNoteTest extends TestCase { assertEquals(1, pkg.getWakeupAlarmStats().size()); } - @SmallTest + @Test public void testNoteWakupAlarmLocked_workSource_workChain() { final MockClock clocks = new MockClock(); // holds realtime and uptime in ms MockBatteryStatsImpl bi = new MockBatteryStatsImpl(clocks); @@ -1090,7 +1101,7 @@ public class BatteryStatsNoteTest extends TestCase { assertEquals(0, pkg.getWakeupAlarmStats().size()); } - @SmallTest + @Test public void testNoteGpsChanged() { final MockClock clocks = new MockClock(); // holds realtime and uptime in ms MockBatteryStatsImpl bi = new MockBatteryStatsImpl(clocks); @@ -1114,7 +1125,7 @@ public class BatteryStatsNoteTest extends TestCase { assertFalse(t.isRunningLocked()); } - @SmallTest + @Test public void testNoteGpsChanged_workSource() { final MockClock clocks = new MockClock(); // holds realtime and uptime in ms MockBatteryStatsImpl bi = new MockBatteryStatsImpl(clocks); @@ -1138,7 +1149,7 @@ public class BatteryStatsNoteTest extends TestCase { assertFalse(t.isRunningLocked()); } - @SmallTest + @Test public void testUpdateDisplayMeasuredEnergyStatsLocked() { final MockClock clocks = new MockClock(); // holds realtime and uptime in ms final MockBatteryStatsImpl bi = new MockBatteryStatsImpl(clocks); @@ -1223,7 +1234,7 @@ public class BatteryStatsNoteTest extends TestCase { checkMeasuredCharge("H", uid1, blame1, uid2, blame2, globalDoze, bi); } - @SmallTest + @Test public void testUpdateCustomMeasuredEnergyStatsLocked_neverCalled() { final MockClock clocks = new MockClock(); // holds realtime and uptime in ms final MockBatteryStatsImpl bi = new MockBatteryStatsImpl(clocks); @@ -1237,7 +1248,7 @@ public class BatteryStatsNoteTest extends TestCase { checkCustomBatteryConsumption("0", 0, 0, uid1, 0, 0, uid2, 0, 0, bi); } - @SmallTest + @Test public void testUpdateCustomMeasuredEnergyStatsLocked() { final MockClock clocks = new MockClock(); // holds realtime and uptime in ms final MockBatteryStatsImpl bi = new MockBatteryStatsImpl(clocks); @@ -1314,7 +1325,7 @@ public class BatteryStatsNoteTest extends TestCase { "D", totalBlameA, totalBlameB, uid1, blame1A, blame1B, uid2, blame2A, blame2B, bi); } - @SmallTest + @Test public void testGetPerStateActiveRadioDurationMs_noModemActivity() { final MockClock clock = new MockClock(); // holds realtime and uptime in ms final MockBatteryStatsImpl bi = new MockBatteryStatsImpl(clock); @@ -1470,7 +1481,7 @@ public class BatteryStatsNoteTest extends TestCase { expectedTxDurationsMs, bi, state.currentTimeMs); } - @SmallTest + @Test public void testGetPerStateActiveRadioDurationMs_initialModemActivity() { final MockClock clock = new MockClock(); // holds realtime and uptime in ms final MockBatteryStatsImpl bi = new MockBatteryStatsImpl(clock); @@ -1612,7 +1623,7 @@ public class BatteryStatsNoteTest extends TestCase { expectedTxDurationsMs, bi, state.currentTimeMs); } - @SmallTest + @Test public void testGetPerStateActiveRadioDurationMs_withModemActivity() { final MockClock clock = new MockClock(); // holds realtime and uptime in ms final MockBatteryStatsImpl bi = new MockBatteryStatsImpl(clock); @@ -1852,7 +1863,7 @@ public class BatteryStatsNoteTest extends TestCase { expectedTxDurationsMs, bi, state.currentTimeMs); } - @SmallTest + @Test public void testGetPerStateActiveRadioDurationMs_withSpecificInfoModemActivity() { final MockClock clock = new MockClock(); // holds realtime and uptime in ms final MockBatteryStatsImpl bi = new MockBatteryStatsImpl(clock); @@ -2145,19 +2156,19 @@ public class BatteryStatsNoteTest extends TestCase { expectedTxDurationsMs, bi, state.currentTimeMs); } - @SmallTest + @Test @SuppressWarnings("GuardedBy") public void testProcStateSyncScheduling_mobileRadioActiveState() { final MockClock clock = new MockClock(); // holds realtime and uptime in ms final MockBatteryStatsImpl bi = new MockBatteryStatsImpl(clock); - final MutableInt lastProcStateChangeFlags = new MutableInt(0); + final int[] lastProcStateChangeFlags = new int[1]; MockBatteryStatsImpl.DummyExternalStatsSync externalStatsSync = new MockBatteryStatsImpl.DummyExternalStatsSync() { @Override public void scheduleSyncDueToProcessStateChange(int flags, long delayMillis) { - lastProcStateChangeFlags.value = flags; + lastProcStateChangeFlags[0] = flags; } }; @@ -2170,19 +2181,19 @@ public class BatteryStatsNoteTest extends TestCase { bi.noteMobileRadioPowerStateLocked(DataConnectionRealTimeInfo.DC_POWER_STATE_HIGH, curr, UID); - lastProcStateChangeFlags.value = 0; + lastProcStateChangeFlags[0] = 0; clock.realtime = clock.uptime = 2002; bi.noteUidProcessStateLocked(UID, ActivityManager.PROCESS_STATE_IMPORTANT_FOREGROUND); final int allProcFlags = BatteryStatsImpl.ExternalStatsSync.UPDATE_ON_PROC_STATE_CHANGE; - assertEquals(allProcFlags, lastProcStateChangeFlags.value); + assertEquals(allProcFlags, lastProcStateChangeFlags[0]); // Note mobile radio is off. curr = 1000L * (clock.realtime = clock.uptime = 3003); bi.noteMobileRadioPowerStateLocked(DataConnectionRealTimeInfo.DC_POWER_STATE_LOW, curr, UID); - lastProcStateChangeFlags.value = 0; + lastProcStateChangeFlags[0] = 0; clock.realtime = clock.uptime = 4004; bi.noteUidProcessStateLocked(UID, ActivityManager.PROCESS_STATE_CACHED_EMPTY); @@ -2190,10 +2201,10 @@ public class BatteryStatsNoteTest extends TestCase { & ~BatteryStatsImpl.ExternalStatsSync.UPDATE_RADIO; assertEquals( "An inactive radio should not be queried on proc state change", - noRadioProcFlags, lastProcStateChangeFlags.value); + noRadioProcFlags, lastProcStateChangeFlags[0]); } - @SmallTest + @Test public void testNoteMobileRadioPowerStateLocked() { long curr; boolean update; @@ -2243,7 +2254,7 @@ public class BatteryStatsNoteTest extends TestCase { update); } - @SmallTest + @Test public void testNoteMobileRadioPowerStateLocked_rateLimited() { long curr; boolean update; diff --git a/services/tests/powerstatstests/src/com/android/server/power/stats/BatteryStatsSensorTest.java b/services/tests/powerstatstests/src/com/android/server/power/stats/BatteryStatsSensorTest.java index 9c70f376ca14..96780c322445 100644 --- a/services/tests/powerstatstests/src/com/android/server/power/stats/BatteryStatsSensorTest.java +++ b/services/tests/powerstatstests/src/com/android/server/power/stats/BatteryStatsSensorTest.java @@ -16,24 +16,36 @@ package com.android.server.power.stats; +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertNotNull; +import static org.junit.Assert.assertNull; + import android.app.ActivityManager; import android.os.BatteryStats; +import android.platform.test.ravenwood.RavenwoodRule; import android.view.Display; import androidx.test.filters.SmallTest; -import junit.framework.TestCase; +import org.junit.Rule; +import org.junit.Test; /** * Test BatteryStatsImpl Sensor Timers. */ -public class BatteryStatsSensorTest extends TestCase { +@SmallTest +public class BatteryStatsSensorTest { + + @Rule + public final RavenwoodRule mRavenwood = new RavenwoodRule.Builder() + .setProvideMainThread(true) + .build(); private static final int UID = 10500; private static final int UID_2 = 10501; // second uid for testing pool usage private static final int SENSOR_ID = -10000; - @SmallTest + @Test public void testSensorStartStop() throws Exception { final MockClock clocks = new MockClock(); MockBatteryStatsImpl bi = new MockBatteryStatsImpl(clocks); @@ -70,7 +82,7 @@ public class BatteryStatsSensorTest extends TestCase { clocks.realtime * 1000, BatteryStats.STATS_SINCE_CHARGED)); } - @SmallTest + @Test public void testCountingWhileOffBattery() throws Exception { final MockClock clocks = new MockClock(); MockBatteryStatsImpl bi = new MockBatteryStatsImpl(clocks); @@ -106,7 +118,7 @@ public class BatteryStatsSensorTest extends TestCase { assertEquals(0, sensorTimer.getCountLocked(BatteryStats.STATS_SINCE_CHARGED)); } - @SmallTest + @Test public void testCountingWhileOnBattery() throws Exception { final MockClock clocks = new MockClock(); MockBatteryStatsImpl bi = new MockBatteryStatsImpl(clocks); @@ -141,7 +153,7 @@ public class BatteryStatsSensorTest extends TestCase { assertEquals(1, sensorTimer.getCountLocked(BatteryStats.STATS_SINCE_CHARGED)); } - @SmallTest + @Test public void testBatteryStatusOnToOff() throws Exception { final MockClock clocks = new MockClock(); MockBatteryStatsImpl bi = new MockBatteryStatsImpl(clocks); @@ -187,7 +199,7 @@ public class BatteryStatsSensorTest extends TestCase { sensorTimer.getTotalTimeLocked(curr, BatteryStats.STATS_SINCE_CHARGED)); } - @SmallTest + @Test public void testBatteryStatusOffToOn() throws Exception { final MockClock clocks = new MockClock(); MockBatteryStatsImpl bi = new MockBatteryStatsImpl(clocks); @@ -238,7 +250,7 @@ public class BatteryStatsSensorTest extends TestCase { assertEquals(0, sensorTimer.getCountLocked(BatteryStats.STATS_SINCE_CHARGED)); } - @SmallTest + @Test public void testPooledBackgroundUsage() throws Exception { final MockClock clocks = new MockClock(); MockBatteryStatsImpl bi = new MockBatteryStatsImpl(clocks); @@ -375,7 +387,7 @@ public class BatteryStatsSensorTest extends TestCase { assertEquals(2, bgTimer2.getCountLocked(BatteryStats.STATS_SINCE_CHARGED)); } - @SmallTest + @Test public void testSensorReset() throws Exception { final MockClock clocks = new MockClock(); MockBatteryStatsImpl bi = new MockBatteryStatsImpl(clocks); @@ -419,7 +431,7 @@ public class BatteryStatsSensorTest extends TestCase { assertNull(sensor); } - @SmallTest + @Test public void testSensorResetTimes() throws Exception { final MockClock clocks = new MockClock(); MockBatteryStatsImpl bi = new MockBatteryStatsImpl(clocks); diff --git a/services/tests/powerstatstests/src/com/android/server/power/stats/BatteryStatsServTest.java b/services/tests/powerstatstests/src/com/android/server/power/stats/BatteryStatsServTest.java index 200eb1d0ad15..6f683ae5e0c0 100644 --- a/services/tests/powerstatstests/src/com/android/server/power/stats/BatteryStatsServTest.java +++ b/services/tests/powerstatstests/src/com/android/server/power/stats/BatteryStatsServTest.java @@ -18,16 +18,25 @@ package com.android.server.power.stats; import android.os.BatteryStats; import android.os.Parcel; +import android.platform.test.ravenwood.RavenwoodRule; import androidx.test.filters.SmallTest; import junit.framework.Assert; -import junit.framework.TestCase; + +import org.junit.Rule; +import org.junit.Test; /** * Provides test cases for android.os.BatteryStats. */ -public class BatteryStatsServTest extends TestCase { +@SmallTest +public class BatteryStatsServTest { + @Rule + public final RavenwoodRule mRavenwood = new RavenwoodRule.Builder() + .setProvideMainThread(true) + .build(); + private static final String TAG = "BatteryStatsServTest"; public static class TestServ extends BatteryStatsImpl.Uid.Pkg.Serv { @@ -90,7 +99,7 @@ public class BatteryStatsServTest extends TestCase { /** * Test that the constructor and detach methods touch the time bast observer list. */ - @SmallTest + @Test public void testConstructAndDetach() throws Exception { MockBatteryStatsImpl bsi = new MockBatteryStatsImpl(); @@ -104,7 +113,7 @@ public class BatteryStatsServTest extends TestCase { /** * Test parceling and unparceling. */ - @SmallTest + @Test public void testParceling() throws Exception { MockBatteryStatsImpl bsi = new MockBatteryStatsImpl(); TestServ orig = new TestServ(bsi); @@ -133,7 +142,7 @@ public class BatteryStatsServTest extends TestCase { /** * Test getLaunchTimeToNow() */ - @SmallTest + @Test public void testLaunchTimeToNow() throws Exception { MockBatteryStatsImpl bsi = new MockBatteryStatsImpl(); TestServ serv = new TestServ(bsi); @@ -151,7 +160,7 @@ public class BatteryStatsServTest extends TestCase { /** * Test getStartTimeToNow() */ - @SmallTest + @Test public void testStartTimeToNow() throws Exception { MockBatteryStatsImpl bsi = new MockBatteryStatsImpl(); TestServ serv = new TestServ(bsi); @@ -168,7 +177,7 @@ public class BatteryStatsServTest extends TestCase { /** * Test startLaunchedLocked while not previously launched */ - @SmallTest + @Test public void testStartLaunchedLockedWhileLaunched() throws Exception { MockBatteryStatsImpl bsi = new MockBatteryStatsImpl() { @Override @@ -197,7 +206,7 @@ public class BatteryStatsServTest extends TestCase { /** * Test startLaunchedLocked while previously launched */ - @SmallTest + @Test public void testStartLaunchedLockedWhileNotLaunched() throws Exception { MockBatteryStatsImpl bsi = new MockBatteryStatsImpl() { @Override @@ -224,7 +233,7 @@ public class BatteryStatsServTest extends TestCase { /** * Test stopLaunchedLocked when not previously launched. */ - @SmallTest + @Test public void testStopLaunchedLockedWhileNotLaunched() throws Exception { MockBatteryStatsImpl bsi = new MockBatteryStatsImpl() { @Override @@ -254,7 +263,7 @@ public class BatteryStatsServTest extends TestCase { * Test stopLaunchedLocked when previously launched, with measurable time between * start and stop. */ - @SmallTest + @Test public void testStopLaunchedLockedWhileLaunchedNormal() throws Exception { MockBatteryStatsImpl bsi = new MockBatteryStatsImpl() { @Override @@ -283,7 +292,7 @@ public class BatteryStatsServTest extends TestCase { * Test stopLaunchedLocked when previously launched, with no measurable time between * start and stop. */ - @SmallTest + @Test public void testStopLaunchedLockedWhileLaunchedTooQuick() throws Exception { MockBatteryStatsImpl bsi = new MockBatteryStatsImpl(); TestServ serv = new TestServ(bsi); @@ -306,7 +315,7 @@ public class BatteryStatsServTest extends TestCase { /** * Test startRunningLocked while previously running */ - @SmallTest + @Test public void testStartRunningLockedWhileRunning() throws Exception { MockBatteryStatsImpl bsi = new MockBatteryStatsImpl() { @Override @@ -335,7 +344,7 @@ public class BatteryStatsServTest extends TestCase { /** * Test startRunningLocked while not previously launched */ - @SmallTest + @Test public void testStartRunningLockedWhileNotRunning() throws Exception { MockBatteryStatsImpl bsi = new MockBatteryStatsImpl() { @Override @@ -364,7 +373,7 @@ public class BatteryStatsServTest extends TestCase { * Test stopRunningLocked when previously launched, with measurable time between * start and stop. */ - @SmallTest + @Test public void testStopRunningLockedWhileRunningNormal() throws Exception { MockBatteryStatsImpl bsi = new MockBatteryStatsImpl() { @Override @@ -393,7 +402,7 @@ public class BatteryStatsServTest extends TestCase { * Test stopRunningLocked when previously launched, with measurable time between * start and stop. */ - @SmallTest + @Test public void testStopRunningLockedWhileRunningTooQuick() throws Exception { MockBatteryStatsImpl bsi = new MockBatteryStatsImpl(); TestServ serv = new TestServ(bsi); @@ -416,7 +425,7 @@ public class BatteryStatsServTest extends TestCase { /** * Test that getBatteryStats returns the BatteryStatsImpl passed in to the contstructor. */ - @SmallTest + @Test public void testGetBatteryStats() throws Exception { MockBatteryStatsImpl bsi = new MockBatteryStatsImpl(); TestServ serv = new TestServ(bsi); @@ -427,7 +436,7 @@ public class BatteryStatsServTest extends TestCase { /** * Test getLaunches */ - @SmallTest + @Test public void testGetLaunches() throws Exception { MockBatteryStatsImpl bsi = new MockBatteryStatsImpl(); TestServ serv = new TestServ(bsi); @@ -449,7 +458,7 @@ public class BatteryStatsServTest extends TestCase { /** * Test getStartTime while running */ - @SmallTest + @Test public void testGetStartTimeRunning() throws Exception { MockBatteryStatsImpl bsi = new MockBatteryStatsImpl(); TestServ serv = new TestServ(bsi); @@ -475,7 +484,7 @@ public class BatteryStatsServTest extends TestCase { /** * Test getStartTime while not running */ - @SmallTest + @Test public void testGetStartTimeNotRunning() throws Exception { MockBatteryStatsImpl bsi = new MockBatteryStatsImpl(); TestServ serv = new TestServ(bsi); @@ -502,7 +511,7 @@ public class BatteryStatsServTest extends TestCase { /** * Test getStarts */ - @SmallTest + @Test public void testGetStarts() throws Exception { MockBatteryStatsImpl bsi = new MockBatteryStatsImpl(); TestServ serv = new TestServ(bsi); @@ -521,4 +530,3 @@ public class BatteryStatsServTest extends TestCase { Assert.assertEquals(8085, serv.getLaunches()); } } - diff --git a/services/tests/powerstatstests/src/com/android/server/power/stats/BatteryStatsUserLifecycleTests.java b/services/tests/powerstatstests/src/com/android/server/power/stats/BatteryStatsUserLifecycleTests.java index face849620d7..05d8a005d21e 100644 --- a/services/tests/powerstatstests/src/com/android/server/power/stats/BatteryStatsUserLifecycleTests.java +++ b/services/tests/powerstatstests/src/com/android/server/power/stats/BatteryStatsUserLifecycleTests.java @@ -46,6 +46,7 @@ import java.util.concurrent.TimeUnit; @LargeTest @RunWith(AndroidJUnit4.class) +@android.platform.test.annotations.IgnoreUnderRavenwood public class BatteryStatsUserLifecycleTests { private static final long POLL_INTERVAL_MS = 500; diff --git a/services/tests/powerstatstests/src/com/android/server/power/stats/BatteryUsageStatsProviderTest.java b/services/tests/powerstatstests/src/com/android/server/power/stats/BatteryUsageStatsProviderTest.java index 2e0ba0083850..6cd79bc09fb6 100644 --- a/services/tests/powerstatstests/src/com/android/server/power/stats/BatteryUsageStatsProviderTest.java +++ b/services/tests/powerstatstests/src/com/android/server/power/stats/BatteryUsageStatsProviderTest.java @@ -23,6 +23,7 @@ import static org.mockito.Mockito.when; import android.app.ActivityManager; import android.content.Context; +import android.hardware.SensorManager; import android.os.BatteryConsumer; import android.os.BatteryManager; import android.os.BatteryStats; @@ -32,6 +33,7 @@ import android.os.ConditionVariable; import android.os.Parcel; import android.os.Process; import android.os.UidBatteryConsumer; +import android.platform.test.ravenwood.RavenwoodRule; import androidx.test.InstrumentationRegistry; import androidx.test.filters.SmallTest; @@ -40,36 +42,69 @@ import androidx.test.runner.AndroidJUnit4; import com.android.internal.os.BatteryStatsHistoryIterator; import com.android.internal.os.PowerProfile; +import org.junit.Before; import org.junit.Rule; import org.junit.Test; import org.junit.runner.RunWith; import java.io.File; +import java.io.IOException; +import java.nio.file.Files; import java.util.List; -import java.util.Random; @SmallTest @RunWith(AndroidJUnit4.class) public class BatteryUsageStatsProviderTest { + @Rule(order = 0) + public final RavenwoodRule mRavenwood = new RavenwoodRule.Builder() + .setProvideMainThread(true) + .build(); + private static final int APP_UID = Process.FIRST_APPLICATION_UID + 42; private static final long MINUTE_IN_MS = 60 * 1000; private static final double PRECISION = 0.00001; - private final File mHistoryDir = createTemporaryDirectory(); + private File mHistoryDir; - @Rule + @Rule(order = 1) public final BatteryUsageStatsRule mStatsRule = new BatteryUsageStatsRule(12345, mHistoryDir) .setAveragePower(PowerProfile.POWER_FLASHLIGHT, 360.0) .setAveragePower(PowerProfile.POWER_AUDIO, 720.0); + private MockClock mMockClock = mStatsRule.getMockClock(); + private Context mContext; + + @Before + public void setup() throws IOException { + mHistoryDir = Files.createTempDirectory("BatteryUsageStatsProviderTest").toFile(); + clearDirectory(mHistoryDir); + + if (RavenwoodRule.isUnderRavenwood()) { + mContext = mock(Context.class); + SensorManager sensorManager = mock(SensorManager.class); + when(mContext.getSystemService(SensorManager.class)).thenReturn(sensorManager); + } else { + mContext = InstrumentationRegistry.getContext(); + } + } + + private void clearDirectory(File dir) { + if (dir.exists()) { + for (File child : dir.listFiles()) { + if (child.isDirectory()) { + clearDirectory(child); + } + child.delete(); + } + } + } @Test public void test_getBatteryUsageStats() { BatteryStatsImpl batteryStats = prepareBatteryStats(); - Context context = InstrumentationRegistry.getContext(); - BatteryUsageStatsProvider provider = new BatteryUsageStatsProvider(context, null, + BatteryUsageStatsProvider provider = new BatteryUsageStatsProvider(mContext, null, mStatsRule.getPowerProfile(), mStatsRule.getCpuScalingPolicies(), null, mMockClock); final BatteryUsageStats batteryUsageStats = @@ -105,8 +140,7 @@ public class BatteryUsageStatsProviderTest { public void test_selectPowerComponents() { BatteryStatsImpl batteryStats = prepareBatteryStats(); - Context context = InstrumentationRegistry.getContext(); - BatteryUsageStatsProvider provider = new BatteryUsageStatsProvider(context, null, + BatteryUsageStatsProvider provider = new BatteryUsageStatsProvider(mContext, null, mStatsRule.getPowerProfile(), mStatsRule.getCpuScalingPolicies(), null, mMockClock); final BatteryUsageStats batteryUsageStats = @@ -211,8 +245,7 @@ public class BatteryUsageStatsProviderTest { batteryStats.noteAlarmFinishLocked("foo", null, APP_UID, 3_001_000, 2_001_000); } - Context context = InstrumentationRegistry.getContext(); - BatteryUsageStatsProvider provider = new BatteryUsageStatsProvider(context, null, + BatteryUsageStatsProvider provider = new BatteryUsageStatsProvider(mContext, null, mStatsRule.getPowerProfile(), mStatsRule.getCpuScalingPolicies(), null, mMockClock); final BatteryUsageStats batteryUsageStats = @@ -300,8 +333,7 @@ public class BatteryUsageStatsProviderTest { } } - Context context = InstrumentationRegistry.getContext(); - BatteryUsageStatsProvider provider = new BatteryUsageStatsProvider(context, null, + BatteryUsageStatsProvider provider = new BatteryUsageStatsProvider(mContext, null, mStatsRule.getPowerProfile(), mStatsRule.getCpuScalingPolicies(), null, mMockClock); final BatteryUsageStats batteryUsageStats = @@ -311,7 +343,9 @@ public class BatteryUsageStatsProviderTest { Parcel parcel = Parcel.obtain(); parcel.writeParcelable(batteryUsageStats, 0); - assertThat(parcel.dataSize()).isAtMost(128_000); + if (!RavenwoodRule.isUnderRavenwood()) { + assertThat(parcel.dataSize()).isAtMost(128_000); + } parcel.setDataPosition(0); @@ -375,7 +409,6 @@ public class BatteryUsageStatsProviderTest { @Test public void testAggregateBatteryStats() { - Context context = InstrumentationRegistry.getContext(); BatteryStatsImpl batteryStats = mStatsRule.getBatteryStats(); setTime(5 * MINUTE_IN_MS); @@ -384,11 +417,11 @@ public class BatteryUsageStatsProviderTest { } PowerStatsStore powerStatsStore = new PowerStatsStore( - new File(context.getCacheDir(), "BatteryUsageStatsProviderTest"), + new File(mHistoryDir, "powerstatsstore"), mStatsRule.getHandler(), null); powerStatsStore.reset(); - BatteryUsageStatsProvider provider = new BatteryUsageStatsProvider(context, null, + BatteryUsageStatsProvider provider = new BatteryUsageStatsProvider(mContext, null, mStatsRule.getPowerProfile(), mStatsRule.getCpuScalingPolicies(), powerStatsStore, mMockClock); @@ -485,7 +518,6 @@ public class BatteryUsageStatsProviderTest { @Test public void testAggregateBatteryStats_incompatibleSnapshot() { - Context context = InstrumentationRegistry.getContext(); MockBatteryStatsImpl batteryStats = mStatsRule.getBatteryStats(); batteryStats.initMeasuredEnergyStats(new String[]{"FOO", "BAR"}); @@ -511,7 +543,7 @@ public class BatteryUsageStatsProviderTest { when(powerStatsStore.loadPowerStatsSpan(1, BatteryUsageStatsSection.TYPE)) .thenReturn(span1); - BatteryUsageStatsProvider provider = new BatteryUsageStatsProvider(context, null, + BatteryUsageStatsProvider provider = new BatteryUsageStatsProvider(mContext, null, mStatsRule.getPowerProfile(), mStatsRule.getCpuScalingPolicies(), powerStatsStore, mMockClock); @@ -523,20 +555,4 @@ public class BatteryUsageStatsProviderTest { .isEqualTo(batteryStats.getCustomEnergyConsumerNames()); assertThat(stats.getStatsDuration()).isEqualTo(1234); } - - private static final Random sRandom = new Random(); - - /** - * Creates a unique new temporary directory under "java.io.tmpdir". - */ - private static File createTemporaryDirectory() { - while (true) { - String candidateName = - BatteryUsageStatsProviderTest.class.getSimpleName() + sRandom.nextInt(); - File result = new File(System.getProperty("java.io.tmpdir"), candidateName); - if (result.mkdir()) { - return result; - } - } - } } diff --git a/services/tests/powerstatstests/src/com/android/server/power/stats/BatteryUsageStatsRule.java b/services/tests/powerstatstests/src/com/android/server/power/stats/BatteryUsageStatsRule.java index ba2b53854cd7..8bdb0292bf00 100644 --- a/services/tests/powerstatstests/src/com/android/server/power/stats/BatteryUsageStatsRule.java +++ b/services/tests/powerstatstests/src/com/android/server/power/stats/BatteryUsageStatsRule.java @@ -49,6 +49,7 @@ import org.mockito.stubbing.Answer; import java.io.File; import java.util.Arrays; +@SuppressWarnings("SynchronizeOnNonFinalField") public class BatteryUsageStatsRule implements TestRule { public static final BatteryUsageStatsQuery POWER_PROFILE_MODEL_ONLY = new BatteryUsageStatsQuery.Builder() @@ -71,6 +72,8 @@ public class BatteryUsageStatsRule implements TestRule { private int mDisplayCount = -1; private int mPerUidModemModel = -1; private NetworkStats mNetworkStats; + private boolean[] mSupportedStandardBuckets; + private String[] mCustomPowerComponentNames; public BatteryUsageStatsRule() { this(0, null); @@ -102,6 +105,11 @@ public class BatteryUsageStatsRule implements TestRule { mBatteryStats = new MockBatteryStatsImpl(mMockClock, mHistoryDir, mHandler); mBatteryStats.setPowerProfile(mPowerProfile); mBatteryStats.setCpuScalingPolicies(new CpuScalingPolicies(mCpusByPolicy, mFreqsByPolicy)); + synchronized (mBatteryStats) { + mBatteryStats.initEnergyConsumerStatsLocked(mSupportedStandardBuckets, + mCustomPowerComponentNames); + } + mBatteryStats.informThatAllExternalStatsAreFlushed(); mBatteryStats.onSystemReady(); @@ -230,13 +238,15 @@ public class BatteryUsageStatsRule implements TestRule { /** Call only after setting the power profile information. */ public BatteryUsageStatsRule initMeasuredEnergyStatsLocked( String[] customPowerComponentNames) { - final boolean[] supportedStandardBuckets = - new boolean[EnergyConsumerStats.NUMBER_STANDARD_POWER_BUCKETS]; - Arrays.fill(supportedStandardBuckets, true); - synchronized (mBatteryStats) { - mBatteryStats.initEnergyConsumerStatsLocked(supportedStandardBuckets, - customPowerComponentNames); - mBatteryStats.informThatAllExternalStatsAreFlushed(); + mCustomPowerComponentNames = customPowerComponentNames; + mSupportedStandardBuckets = new boolean[EnergyConsumerStats.NUMBER_STANDARD_POWER_BUCKETS]; + Arrays.fill(mSupportedStandardBuckets, true); + if (mBatteryStats != null) { + synchronized (mBatteryStats) { + mBatteryStats.initEnergyConsumerStatsLocked(mSupportedStandardBuckets, + mCustomPowerComponentNames); + mBatteryStats.informThatAllExternalStatsAreFlushed(); + } } return this; } diff --git a/services/tests/powerstatstests/src/com/android/server/power/stats/BatteryUsageStatsTest.java b/services/tests/powerstatstests/src/com/android/server/power/stats/BatteryUsageStatsTest.java index 079ea2c7832f..851cf4a535a2 100644 --- a/services/tests/powerstatstests/src/com/android/server/power/stats/BatteryUsageStatsTest.java +++ b/services/tests/powerstatstests/src/com/android/server/power/stats/BatteryUsageStatsTest.java @@ -37,6 +37,7 @@ import android.os.BatteryUsageStats; import android.os.Parcel; import android.os.UidBatteryConsumer; import android.os.UserBatteryConsumer; +import android.platform.test.ravenwood.RavenwoodRule; import android.util.Xml; import androidx.test.filters.SmallTest; @@ -45,6 +46,7 @@ import androidx.test.runner.AndroidJUnit4; import com.android.modules.utils.TypedXmlPullParser; import com.android.modules.utils.TypedXmlSerializer; +import org.junit.Rule; import org.junit.Test; import org.junit.runner.RunWith; @@ -62,6 +64,10 @@ import java.util.stream.Collectors; @SmallTest @RunWith(AndroidJUnit4.class) public class BatteryUsageStatsTest { + @Rule(order = 0) + public final RavenwoodRule mRavenwood = new RavenwoodRule.Builder() + .setProvideMainThread(true) + .build(); private static final int USER_ID = 42; private static final int APP_UID1 = 271; @@ -115,12 +121,13 @@ public class BatteryUsageStatsTest { final Parcel parcel = Parcel.obtain(); parcel.writeParcelable(outBatteryUsageStats, 0); - assertThat(parcel.dataSize()).isLessThan(2000); + // Under ravenwood this parcel is larger. On a device, 2K would suffice + assertThat(parcel.dataSize()).isLessThan(128_000); parcel.setDataPosition(0); final BatteryUsageStats inBatteryUsageStats = - parcel.readParcelable(getClass().getClassLoader()); + parcel.readParcelable(getClass().getClassLoader(), BatteryUsageStats.class); parcel.recycle(); assertThat(inBatteryUsageStats.getUidBatteryConsumers()).hasSize(uidCount); diff --git a/services/tests/powerstatstests/src/com/android/server/power/stats/BluetoothPowerCalculatorTest.java b/services/tests/powerstatstests/src/com/android/server/power/stats/BluetoothPowerCalculatorTest.java index 4d4337c16757..fe6424f91d83 100644 --- a/services/tests/powerstatstests/src/com/android/server/power/stats/BluetoothPowerCalculatorTest.java +++ b/services/tests/powerstatstests/src/com/android/server/power/stats/BluetoothPowerCalculatorTest.java @@ -18,6 +18,9 @@ package com.android.server.power.stats; import static com.google.common.truth.Truth.assertThat; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.when; + import android.annotation.Nullable; import android.bluetooth.BluetoothActivityEnergyInfo; import android.bluetooth.UidTraffic; @@ -28,6 +31,7 @@ import android.os.Parcel; import android.os.Process; import android.os.UidBatteryConsumer; import android.os.WorkSource; +import android.platform.test.ravenwood.RavenwoodRule; import androidx.test.filters.SmallTest; import androidx.test.runner.AndroidJUnit4; @@ -46,10 +50,15 @@ import java.util.List; @SmallTest @SuppressWarnings("GuardedBy") public class BluetoothPowerCalculatorTest { + @Rule(order = 0) + public final RavenwoodRule mRavenwood = new RavenwoodRule.Builder() + .setProvideMainThread(true) + .build(); + private static final double PRECISION = 0.00001; private static final int APP_UID = Process.FIRST_APPLICATION_UID + 42; - @Rule + @Rule(order = 1) public final BatteryUsageStatsRule mStatsRule = new BatteryUsageStatsRule() .setAveragePower(PowerProfile.POWER_BLUETOOTH_CONTROLLER_IDLE, 10.0) .setAveragePower(PowerProfile.POWER_BLUETOOTH_CONTROLLER_RX, 50.0) @@ -331,33 +340,53 @@ public class BluetoothPowerCalculatorTest { assertThat(usageDurationMillis).isEqualTo(durationMs); } - private UidTraffic createUidTraffic(int uid, long traffic1, long traffic2) { - final Parcel uidTrafficParcel = Parcel.obtain(); - uidTrafficParcel.writeInt(uid); - uidTrafficParcel.writeLong(traffic1); - uidTrafficParcel.writeLong(traffic2); - uidTrafficParcel.setDataPosition(0); - - UidTraffic traffic = UidTraffic.CREATOR.createFromParcel(uidTrafficParcel); - uidTrafficParcel.recycle(); - return traffic; + private UidTraffic createUidTraffic(int appUid, long rxBytes, long txBytes) { + if (RavenwoodRule.isUnderRavenwood()) { + UidTraffic uidTraffic = mock(UidTraffic.class); + when(uidTraffic.getUid()).thenReturn(appUid); + when(uidTraffic.getRxBytes()).thenReturn(rxBytes); + when(uidTraffic.getTxBytes()).thenReturn(txBytes); + return uidTraffic; + } else { + final Parcel uidTrafficParcel = Parcel.obtain(); + uidTrafficParcel.writeInt(appUid); + uidTrafficParcel.writeLong(rxBytes); + uidTrafficParcel.writeLong(txBytes); + uidTrafficParcel.setDataPosition(0); + + UidTraffic traffic = UidTraffic.CREATOR.createFromParcel(uidTrafficParcel); + uidTrafficParcel.recycle(); + return traffic; + } } private BluetoothActivityEnergyInfo createBtEnergyInfo(long timestamp, int stackState, long txTime, long rxTime, long idleTime, long energyUsed, List<UidTraffic> traffic) { - final Parcel btActivityEnergyInfoParcel = Parcel.obtain(); - btActivityEnergyInfoParcel.writeLong(timestamp); - btActivityEnergyInfoParcel.writeInt(stackState); - btActivityEnergyInfoParcel.writeLong(txTime); - btActivityEnergyInfoParcel.writeLong(rxTime); - btActivityEnergyInfoParcel.writeLong(idleTime); - btActivityEnergyInfoParcel.writeLong(energyUsed); - btActivityEnergyInfoParcel.writeTypedList(traffic); - btActivityEnergyInfoParcel.setDataPosition(0); - - BluetoothActivityEnergyInfo info = BluetoothActivityEnergyInfo.CREATOR - .createFromParcel(btActivityEnergyInfoParcel); - btActivityEnergyInfoParcel.recycle(); - return info; + if (RavenwoodRule.isUnderRavenwood()) { + BluetoothActivityEnergyInfo info = mock(BluetoothActivityEnergyInfo.class); + when(info.getTimestampMillis()).thenReturn(timestamp); + when(info.getBluetoothStackState()).thenReturn(stackState); + when(info.getControllerTxTimeMillis()).thenReturn(txTime); + when(info.getControllerRxTimeMillis()).thenReturn(rxTime); + when(info.getControllerIdleTimeMillis()).thenReturn(idleTime); + when(info.getControllerEnergyUsed()).thenReturn(energyUsed); + when(info.getUidTraffic()).thenReturn(ImmutableList.copyOf(traffic)); + return info; + } else { + final Parcel btActivityEnergyInfoParcel = Parcel.obtain(); + btActivityEnergyInfoParcel.writeLong(timestamp); + btActivityEnergyInfoParcel.writeInt(stackState); + btActivityEnergyInfoParcel.writeLong(txTime); + btActivityEnergyInfoParcel.writeLong(rxTime); + btActivityEnergyInfoParcel.writeLong(idleTime); + btActivityEnergyInfoParcel.writeLong(energyUsed); + btActivityEnergyInfoParcel.writeTypedList(traffic); + btActivityEnergyInfoParcel.setDataPosition(0); + + BluetoothActivityEnergyInfo info = BluetoothActivityEnergyInfo.CREATOR + .createFromParcel(btActivityEnergyInfoParcel); + btActivityEnergyInfoParcel.recycle(); + return info; + } } } diff --git a/services/tests/powerstatstests/src/com/android/server/power/stats/BstatsCpuTimesValidationTest.java b/services/tests/powerstatstests/src/com/android/server/power/stats/BstatsCpuTimesValidationTest.java index ccace40bb056..29e2f5ee163a 100644 --- a/services/tests/powerstatstests/src/com/android/server/power/stats/BstatsCpuTimesValidationTest.java +++ b/services/tests/powerstatstests/src/com/android/server/power/stats/BstatsCpuTimesValidationTest.java @@ -75,6 +75,7 @@ import java.util.regex.Pattern; @LargeTest @RunWith(AndroidJUnit4.class) +@android.platform.test.annotations.IgnoreUnderRavenwood public class BstatsCpuTimesValidationTest { private static final String TAG = BstatsCpuTimesValidationTest.class.getSimpleName(); diff --git a/services/tests/powerstatstests/src/com/android/server/power/stats/CameraPowerCalculatorTest.java b/services/tests/powerstatstests/src/com/android/server/power/stats/CameraPowerCalculatorTest.java index 5fce32f0598a..7225f2d3995c 100644 --- a/services/tests/powerstatstests/src/com/android/server/power/stats/CameraPowerCalculatorTest.java +++ b/services/tests/powerstatstests/src/com/android/server/power/stats/CameraPowerCalculatorTest.java @@ -21,6 +21,7 @@ import static com.google.common.truth.Truth.assertThat; import android.os.BatteryConsumer; import android.os.Process; import android.os.UidBatteryConsumer; +import android.platform.test.ravenwood.RavenwoodRule; import androidx.test.filters.SmallTest; import androidx.test.runner.AndroidJUnit4; @@ -34,12 +35,17 @@ import org.junit.runner.RunWith; @RunWith(AndroidJUnit4.class) @SmallTest public class CameraPowerCalculatorTest { + @Rule(order = 0) + public final RavenwoodRule mRavenwood = new RavenwoodRule.Builder() + .setProvideMainThread(true) + .build(); + private static final double PRECISION = 0.00001; private static final int APP1_UID = Process.FIRST_APPLICATION_UID + 42; private static final int APP2_UID = Process.FIRST_APPLICATION_UID + 43; - @Rule + @Rule(order = 1) public final BatteryUsageStatsRule mStatsRule = new BatteryUsageStatsRule() .setAveragePower(PowerProfile.POWER_CAMERA, 360.0) .initMeasuredEnergyStatsLocked(); diff --git a/services/tests/powerstatstests/src/com/android/server/power/stats/CpuAggregatedPowerStatsProcessorTest.java b/services/tests/powerstatstests/src/com/android/server/power/stats/CpuAggregatedPowerStatsProcessorTest.java index 993d834b9500..5c0e26887505 100644 --- a/services/tests/powerstatstests/src/com/android/server/power/stats/CpuAggregatedPowerStatsProcessorTest.java +++ b/services/tests/powerstatstests/src/com/android/server/power/stats/CpuAggregatedPowerStatsProcessorTest.java @@ -33,6 +33,7 @@ import static org.junit.Assert.fail; import android.os.BatteryConsumer; import android.os.PersistableBundle; +import android.platform.test.ravenwood.RavenwoodRule; import android.util.LongArray; import androidx.test.filters.SmallTest; @@ -55,7 +56,12 @@ import java.util.Map; @RunWith(AndroidJUnit4.class) @SmallTest public class CpuAggregatedPowerStatsProcessorTest { - @Rule + @Rule(order = 0) + public final RavenwoodRule mRavenwood = new RavenwoodRule.Builder() + .setProvideMainThread(true) + .build(); + + @Rule(order = 1) public final BatteryUsageStatsRule mStatsRule = new BatteryUsageStatsRule() .setAveragePower(PowerProfile.POWER_CPU_ACTIVE, 720) .setCpuScalingPolicy(0, new int[]{0, 1}, new int[]{100, 200}) diff --git a/services/tests/powerstatstests/src/com/android/server/power/stats/CpuPowerCalculatorTest.java b/services/tests/powerstatstests/src/com/android/server/power/stats/CpuPowerCalculatorTest.java index 888bc623f669..71a65c85d9e1 100644 --- a/services/tests/powerstatstests/src/com/android/server/power/stats/CpuPowerCalculatorTest.java +++ b/services/tests/powerstatstests/src/com/android/server/power/stats/CpuPowerCalculatorTest.java @@ -32,6 +32,7 @@ import android.os.BatteryStats; import android.os.BatteryUsageStatsQuery; import android.os.Process; import android.os.UidBatteryConsumer; +import android.platform.test.ravenwood.RavenwoodRule; import android.util.SparseArray; import androidx.test.filters.SmallTest; @@ -55,6 +56,11 @@ import org.mockito.MockitoAnnotations; @SmallTest @SuppressWarnings("GuardedBy") public class CpuPowerCalculatorTest { + @Rule(order = 0) + public final RavenwoodRule mRavenwood = new RavenwoodRule.Builder() + .setProvideMainThread(true) + .build(); + private static final double PRECISION = 0.00001; private static final int APP_UID1 = Process.FIRST_APPLICATION_UID + 42; @@ -62,7 +68,7 @@ public class CpuPowerCalculatorTest { private static final int NUM_CPU_FREQS = 2 + 2; // 2 clusters * 2 freqs each - @Rule + @Rule(order = 1) public final BatteryUsageStatsRule mStatsRule = new BatteryUsageStatsRule() .setAveragePower(PowerProfile.POWER_CPU_ACTIVE, 720) .setCpuScalingPolicy(0, new int[]{0, 1}, new int[]{100, 200}) @@ -93,14 +99,13 @@ public class CpuPowerCalculatorTest { private SystemServerCpuThreadReader mMockSystemServerCpuThreadReader; @Mock private KernelSingleUidTimeReader mMockKernelSingleUidTimeReader; + private boolean[] mSupportedPowerBuckets; @Before public void setUp() { MockitoAnnotations.initMocks(this); - final boolean[] supportedPowerBuckets = - new boolean[EnergyConsumerStats.NUMBER_STANDARD_POWER_BUCKETS]; - supportedPowerBuckets[EnergyConsumerStats.POWER_BUCKET_CPU] = true; + mSupportedPowerBuckets = new boolean[EnergyConsumerStats.NUMBER_STANDARD_POWER_BUCKETS]; when(mMockCpuUidFreqTimeReader.isFastCpuTimesReader()).thenReturn(true); @@ -112,8 +117,7 @@ public class CpuPowerCalculatorTest { .setKernelCpuUidUserSysTimeReader(mMockKernelCpuUidUserSysTimeReader) .setKernelCpuUidActiveTimeReader(mMockKerneCpuUidActiveTimeReader) .setKernelSingleUidTimeReader(mMockKernelSingleUidTimeReader) - .setSystemServerCpuThreadReader(mMockSystemServerCpuThreadReader) - .initEnergyConsumerStatsLocked(supportedPowerBuckets, new String[0]); + .setSystemServerCpuThreadReader(mMockSystemServerCpuThreadReader); } @Test @@ -216,6 +220,10 @@ public class CpuPowerCalculatorTest { @Test public void testMeasuredEnergyBasedModel() { + mSupportedPowerBuckets[EnergyConsumerStats.POWER_BUCKET_CPU] = true; + mStatsRule.getBatteryStats().initEnergyConsumerStatsLocked(mSupportedPowerBuckets, + new String[0]); + when(mMockUserInfoProvider.exists(anyInt())).thenReturn(true); when(mMockKernelCpuSpeedReaders[0].readDelta()).thenReturn(new long[]{1000, 2000}); @@ -397,6 +405,10 @@ public class CpuPowerCalculatorTest { @Test public void testMeasuredEnergyBasedModel_perProcessState() { + mSupportedPowerBuckets[EnergyConsumerStats.POWER_BUCKET_CPU] = true; + mStatsRule.getBatteryStats().initEnergyConsumerStatsLocked(mSupportedPowerBuckets, + new String[0]); + when(mMockUserInfoProvider.exists(anyInt())).thenReturn(true); when(mMockKernelCpuSpeedReaders[0].readDelta()).thenReturn(new long[]{1000, 2000}); diff --git a/services/tests/powerstatstests/src/com/android/server/power/stats/CpuPowerStatsCollectorValidationTest.java b/services/tests/powerstatstests/src/com/android/server/power/stats/CpuPowerStatsCollectorValidationTest.java index 38a5d1943f8b..cbce7e804de5 100644 --- a/services/tests/powerstatstests/src/com/android/server/power/stats/CpuPowerStatsCollectorValidationTest.java +++ b/services/tests/powerstatstests/src/com/android/server/power/stats/CpuPowerStatsCollectorValidationTest.java @@ -52,6 +52,7 @@ import java.util.regex.Pattern; @RunWith(AndroidJUnit4.class) @LargeTest +@android.platform.test.annotations.IgnoreUnderRavenwood public class CpuPowerStatsCollectorValidationTest { @Rule public final CheckFlagsRule mCheckFlagsRule = diff --git a/services/tests/powerstatstests/src/com/android/server/power/stats/CustomEnergyConsumerPowerCalculatorTest.java b/services/tests/powerstatstests/src/com/android/server/power/stats/CustomEnergyConsumerPowerCalculatorTest.java index 245faaf15cc8..4ab706e28cf8 100644 --- a/services/tests/powerstatstests/src/com/android/server/power/stats/CustomEnergyConsumerPowerCalculatorTest.java +++ b/services/tests/powerstatstests/src/com/android/server/power/stats/CustomEnergyConsumerPowerCalculatorTest.java @@ -21,6 +21,7 @@ import static com.google.common.truth.Truth.assertThat; import android.os.BatteryConsumer; import android.os.Process; import android.os.UidBatteryConsumer; +import android.platform.test.ravenwood.RavenwoodRule; import android.util.SparseLongArray; import androidx.test.filters.SmallTest; @@ -34,11 +35,16 @@ import org.junit.runner.RunWith; @SmallTest @SuppressWarnings("GuardedBy") public class CustomEnergyConsumerPowerCalculatorTest { + @Rule(order = 0) + public final RavenwoodRule mRavenwood = new RavenwoodRule.Builder() + .setProvideMainThread(true) + .build(); + private static final double PRECISION = 0.00001; private static final int APP_UID = Process.FIRST_APPLICATION_UID + 42; - @Rule + @Rule(order = 1) public final BatteryUsageStatsRule mStatsRule = new BatteryUsageStatsRule() .initMeasuredEnergyStatsLocked(new String[]{"CUSTOM_COMPONENT1", "CUSTOM_COMPONENT2"}); diff --git a/services/tests/powerstatstests/src/com/android/server/power/stats/FlashlightPowerCalculatorTest.java b/services/tests/powerstatstests/src/com/android/server/power/stats/FlashlightPowerCalculatorTest.java index 0f85fdc375fb..757025ecc6f8 100644 --- a/services/tests/powerstatstests/src/com/android/server/power/stats/FlashlightPowerCalculatorTest.java +++ b/services/tests/powerstatstests/src/com/android/server/power/stats/FlashlightPowerCalculatorTest.java @@ -21,6 +21,7 @@ import static com.google.common.truth.Truth.assertThat; import android.os.BatteryConsumer; import android.os.Process; import android.os.UidBatteryConsumer; +import android.platform.test.ravenwood.RavenwoodRule; import androidx.test.filters.SmallTest; import androidx.test.runner.AndroidJUnit4; @@ -34,11 +35,16 @@ import org.junit.runner.RunWith; @RunWith(AndroidJUnit4.class) @SmallTest public class FlashlightPowerCalculatorTest { + @Rule(order = 0) + public final RavenwoodRule mRavenwood = new RavenwoodRule.Builder() + .setProvideMainThread(true) + .build(); + private static final double PRECISION = 0.00001; private static final int APP_UID = Process.FIRST_APPLICATION_UID + 42; - @Rule + @Rule(order = 1) public final BatteryUsageStatsRule mStatsRule = new BatteryUsageStatsRule() .setAveragePower(PowerProfile.POWER_FLASHLIGHT, 360.0); diff --git a/services/tests/powerstatstests/src/com/android/server/power/stats/GnssPowerCalculatorTest.java b/services/tests/powerstatstests/src/com/android/server/power/stats/GnssPowerCalculatorTest.java index 3f2a6d04c1e6..3b5658c2e40a 100644 --- a/services/tests/powerstatstests/src/com/android/server/power/stats/GnssPowerCalculatorTest.java +++ b/services/tests/powerstatstests/src/com/android/server/power/stats/GnssPowerCalculatorTest.java @@ -21,6 +21,7 @@ import static com.google.common.truth.Truth.assertThat; import android.os.BatteryConsumer; import android.os.Process; import android.os.UidBatteryConsumer; +import android.platform.test.ravenwood.RavenwoodRule; import androidx.test.filters.SmallTest; import androidx.test.runner.AndroidJUnit4; @@ -35,12 +36,16 @@ import org.junit.runner.RunWith; @SmallTest @SuppressWarnings("GuardedBy") public class GnssPowerCalculatorTest { + @Rule(order = 0) + public final RavenwoodRule mRavenwood = new RavenwoodRule.Builder() + .setProvideMainThread(true) + .build(); private static final double PRECISION = 0.00001; private static final int APP_UID = Process.FIRST_APPLICATION_UID + 42; private static final int APP_UID2 = Process.FIRST_APPLICATION_UID + 222; - @Rule + @Rule(order = 1) public final BatteryUsageStatsRule mStatsRule = new BatteryUsageStatsRule() .setAveragePower(PowerProfile.POWER_GPS_ON, 360.0) .setAveragePower(PowerProfile.POWER_GPS_SIGNAL_QUALITY_BASED, diff --git a/services/tests/powerstatstests/src/com/android/server/power/stats/IdlePowerCalculatorTest.java b/services/tests/powerstatstests/src/com/android/server/power/stats/IdlePowerCalculatorTest.java index 3d150af711f1..487d86446a19 100644 --- a/services/tests/powerstatstests/src/com/android/server/power/stats/IdlePowerCalculatorTest.java +++ b/services/tests/powerstatstests/src/com/android/server/power/stats/IdlePowerCalculatorTest.java @@ -19,6 +19,7 @@ package com.android.server.power.stats; import static com.google.common.truth.Truth.assertThat; import android.os.BatteryConsumer; +import android.platform.test.ravenwood.RavenwoodRule; import androidx.test.filters.SmallTest; import androidx.test.runner.AndroidJUnit4; @@ -32,9 +33,14 @@ import org.junit.runner.RunWith; @RunWith(AndroidJUnit4.class) @SmallTest public class IdlePowerCalculatorTest { + @Rule(order = 0) + public final RavenwoodRule mRavenwood = new RavenwoodRule.Builder() + .setProvideMainThread(true) + .build(); + private static final double PRECISION = 0.00001; - @Rule + @Rule(order = 1) public final BatteryUsageStatsRule mStatsRule = new BatteryUsageStatsRule() .setAveragePower(PowerProfile.POWER_CPU_IDLE, 720.0) .setAveragePower(PowerProfile.POWER_CPU_SUSPEND, 360.0); diff --git a/services/tests/powerstatstests/src/com/android/server/power/stats/KernelWakelockReaderTest.java b/services/tests/powerstatstests/src/com/android/server/power/stats/KernelWakelockReaderTest.java index 2edfc8e1e408..e02386656cb5 100644 --- a/services/tests/powerstatstests/src/com/android/server/power/stats/KernelWakelockReaderTest.java +++ b/services/tests/powerstatstests/src/com/android/server/power/stats/KernelWakelockReaderTest.java @@ -24,6 +24,7 @@ import junit.framework.TestCase; import java.nio.charset.Charset; +@android.platform.test.annotations.IgnoreUnderRavenwood public class KernelWakelockReaderTest extends TestCase { /** * Helper class that builds the mock Kernel module file /d/wakeup_sources. diff --git a/services/tests/powerstatstests/src/com/android/server/power/stats/LongSamplingCounterArrayTest.java b/services/tests/powerstatstests/src/com/android/server/power/stats/LongSamplingCounterArrayTest.java index 2e962c364ed2..1807ac5c6115 100644 --- a/services/tests/powerstatstests/src/com/android/server/power/stats/LongSamplingCounterArrayTest.java +++ b/services/tests/powerstatstests/src/com/android/server/power/stats/LongSamplingCounterArrayTest.java @@ -24,7 +24,6 @@ import static com.android.server.power.stats.BatteryStatsImpl.TimeBase; import static org.junit.Assert.assertArrayEquals; import static org.mockito.Mockito.verify; import static org.mockito.Mockito.verifyNoMoreInteractions; -import static org.mockito.Mockito.verifyZeroInteractions; import static org.mockito.Mockito.when; import android.os.Parcel; @@ -159,7 +158,7 @@ public class LongSamplingCounterArrayTest { // Test with detachIfReset=false mCounterArray.reset(false /* detachIfReset */); assertArrayEquals(ZEROES, mCounterArray.mCounts); - verifyZeroInteractions(mTimeBase); + verifyNoMoreInteractions(mTimeBase); updateCounts(COUNTS); // Test with detachIfReset=true diff --git a/services/tests/powerstatstests/src/com/android/server/power/stats/LongSamplingCounterTest.java b/services/tests/powerstatstests/src/com/android/server/power/stats/LongSamplingCounterTest.java index 0eac625051fc..4b608e35c11e 100644 --- a/services/tests/powerstatstests/src/com/android/server/power/stats/LongSamplingCounterTest.java +++ b/services/tests/powerstatstests/src/com/android/server/power/stats/LongSamplingCounterTest.java @@ -24,7 +24,6 @@ import static com.android.server.power.stats.BatteryStatsImpl.TimeBase; import static org.junit.Assert.assertEquals; import static org.mockito.Mockito.verify; import static org.mockito.Mockito.verifyNoMoreInteractions; -import static org.mockito.Mockito.verifyZeroInteractions; import static org.mockito.Mockito.when; import android.os.Parcel; @@ -140,7 +139,7 @@ public class LongSamplingCounterTest { // Test with detachIfReset=false mCounter.reset(false /* detachIfReset */); assertEquals(0, getCount()); - verifyZeroInteractions(mTimeBase); + verifyNoMoreInteractions(mTimeBase); mCounter.addCountLocked(COUNT, true); assertEquals(COUNT, getCount()); diff --git a/services/tests/powerstatstests/src/com/android/server/power/stats/MemoryPowerCalculatorTest.java b/services/tests/powerstatstests/src/com/android/server/power/stats/MemoryPowerCalculatorTest.java index 2cce449c6c05..3a27188e2643 100644 --- a/services/tests/powerstatstests/src/com/android/server/power/stats/MemoryPowerCalculatorTest.java +++ b/services/tests/powerstatstests/src/com/android/server/power/stats/MemoryPowerCalculatorTest.java @@ -19,6 +19,7 @@ package com.android.server.power.stats; import static com.google.common.truth.Truth.assertThat; import android.os.BatteryConsumer; +import android.platform.test.ravenwood.RavenwoodRule; import androidx.test.filters.SmallTest; import androidx.test.runner.AndroidJUnit4; @@ -32,9 +33,14 @@ import org.junit.runner.RunWith; @RunWith(AndroidJUnit4.class) @SmallTest public class MemoryPowerCalculatorTest { + @Rule(order = 0) + public final RavenwoodRule mRavenwood = new RavenwoodRule.Builder() + .setProvideMainThread(true) + .build(); + private static final double PRECISION = 0.00001; - @Rule + @Rule(order = 1) public final BatteryUsageStatsRule mStatsRule = new BatteryUsageStatsRule() .setAveragePower(PowerProfile.POWER_MEMORY, new double[] {360.0, 720.0, 1080.0}); diff --git a/services/tests/powerstatstests/src/com/android/server/power/stats/MockBatteryStatsImpl.java b/services/tests/powerstatstests/src/com/android/server/power/stats/MockBatteryStatsImpl.java index 78c4bac14a74..9f069130502f 100644 --- a/services/tests/powerstatstests/src/com/android/server/power/stats/MockBatteryStatsImpl.java +++ b/services/tests/powerstatstests/src/com/android/server/power/stats/MockBatteryStatsImpl.java @@ -26,6 +26,7 @@ import android.os.Looper; import android.util.SparseArray; import com.android.internal.annotations.GuardedBy; +import com.android.internal.os.BatteryStatsHistory; import com.android.internal.os.Clock; import com.android.internal.os.CpuScalingPolicies; import com.android.internal.os.KernelCpuSpeedReader; @@ -70,7 +71,9 @@ public class MockBatteryStatsImpl extends BatteryStatsImpl { MockBatteryStatsImpl(Clock clock, File historyDirectory, Handler handler, PowerStatsUidResolver powerStatsUidResolver) { - super(clock, historyDirectory, handler, powerStatsUidResolver); + super(clock, historyDirectory, handler, powerStatsUidResolver, + mock(FrameworkStatsLogger.class), mock(BatteryStatsHistory.TraceDelegate.class), + mock(BatteryStatsHistory.EventLogger.class)); initTimersAndCounters(); setMaxHistoryBuffer(128 * 1024); @@ -107,7 +110,9 @@ public class MockBatteryStatsImpl extends BatteryStatsImpl { } public Queue<UidToRemove> getPendingRemovedUids() { - return mPendingRemovedUids; + synchronized (this) { + return mPendingRemovedUids; + } } public boolean isOnBattery() { @@ -275,6 +280,10 @@ public class MockBatteryStatsImpl extends BatteryStatsImpl { mHandler = handler; } + @Override + protected void updateBatteryPropertiesLocked() { + } + public static class DummyExternalStatsSync implements ExternalStatsSync { public int flags = 0; diff --git a/services/tests/powerstatstests/src/com/android/server/power/stats/PowerStatsAggregatorTest.java b/services/tests/powerstatstests/src/com/android/server/power/stats/PowerStatsAggregatorTest.java index 22a7351d0b9e..af5b462e017d 100644 --- a/services/tests/powerstatstests/src/com/android/server/power/stats/PowerStatsAggregatorTest.java +++ b/services/tests/powerstatstests/src/com/android/server/power/stats/PowerStatsAggregatorTest.java @@ -60,7 +60,7 @@ public class PowerStatsAggregatorTest { public void setup() throws ParseException { mHistory = new BatteryStatsHistory(32, 1024, mock(BatteryStatsHistory.HistoryStepDetailsCalculator.class), mClock, - mMonotonicClock, mock(BatteryStatsHistory.TraceDelegate.class)); + mMonotonicClock, mock(BatteryStatsHistory.TraceDelegate.class), null); AggregatedPowerStatsConfig config = new AggregatedPowerStatsConfig(); config.trackPowerComponent(TEST_POWER_COMPONENT) @@ -178,7 +178,7 @@ public class PowerStatsAggregatorTest { } @NonNull - private static CharSequence formatDateTime(long timeInMillis) { + private static String formatDateTime(long timeInMillis) { SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss"); format.getCalendar().setTimeZone(TimeZone.getTimeZone("GMT")); return format.format(new Date(timeInMillis)); diff --git a/services/tests/powerstatstests/src/com/android/server/power/stats/PowerStatsExporterTest.java b/services/tests/powerstatstests/src/com/android/server/power/stats/PowerStatsExporterTest.java index 3560a2620c8f..18d7b909150b 100644 --- a/services/tests/powerstatstests/src/com/android/server/power/stats/PowerStatsExporterTest.java +++ b/services/tests/powerstatstests/src/com/android/server/power/stats/PowerStatsExporterTest.java @@ -99,7 +99,7 @@ public class PowerStatsExporterTest { mPowerStatsStore = new PowerStatsStore(storeDirectory, new TestHandler(), config); mHistory = new BatteryStatsHistory(Parcel.obtain(), storeDirectory, 0, 10000, mock(BatteryStatsHistory.HistoryStepDetailsCalculator.class), mClock, - mMonotonicClock, null); + mMonotonicClock, null, null); mPowerStatsAggregator = new PowerStatsAggregator(config, mHistory); mCpuStatsArrayLayout = new CpuPowerStatsCollector.CpuStatsArrayLayout(); diff --git a/services/tests/powerstatstests/src/com/android/server/power/stats/ScreenPowerCalculatorTest.java b/services/tests/powerstatstests/src/com/android/server/power/stats/ScreenPowerCalculatorTest.java index 372307985f04..88d4ea75501d 100644 --- a/services/tests/powerstatstests/src/com/android/server/power/stats/ScreenPowerCalculatorTest.java +++ b/services/tests/powerstatstests/src/com/android/server/power/stats/ScreenPowerCalculatorTest.java @@ -25,6 +25,7 @@ import android.app.ActivityManager; import android.os.BatteryConsumer; import android.os.Process; import android.os.UidBatteryConsumer; +import android.platform.test.ravenwood.RavenwoodRule; import android.view.Display; import androidx.test.filters.SmallTest; @@ -38,14 +39,18 @@ import org.junit.runner.RunWith; @SmallTest @SuppressWarnings("GuardedBy") public class ScreenPowerCalculatorTest { + @Rule(order = 0) + public final RavenwoodRule mRavenwood = new RavenwoodRule.Builder() + .setProvideMainThread(true) + .build(); + private static final double PRECISION = 0.00001; private static final int APP_UID1 = Process.FIRST_APPLICATION_UID + 42; private static final int APP_UID2 = Process.FIRST_APPLICATION_UID + 43; private static final long MINUTE_IN_MS = 60 * 1000; private static final long MINUTE_IN_US = 60 * 1000 * 1000; - private static final long HOUR_IN_MS = 60 * MINUTE_IN_MS; - @Rule + @Rule(order = 1) public final BatteryUsageStatsRule mStatsRule = new BatteryUsageStatsRule() .setAveragePowerForOrdinal(POWER_GROUP_DISPLAY_SCREEN_ON, 0, 36.0) .setAveragePowerForOrdinal(POWER_GROUP_DISPLAY_SCREEN_FULL, 0, 48.0) diff --git a/services/tests/powerstatstests/src/com/android/server/power/stats/SensorPowerCalculatorTest.java b/services/tests/powerstatstests/src/com/android/server/power/stats/SensorPowerCalculatorTest.java index 474527040839..c01f05f43c04 100644 --- a/services/tests/powerstatstests/src/com/android/server/power/stats/SensorPowerCalculatorTest.java +++ b/services/tests/powerstatstests/src/com/android/server/power/stats/SensorPowerCalculatorTest.java @@ -27,6 +27,7 @@ import android.hardware.input.InputSensorInfo; import android.os.BatteryConsumer; import android.os.Process; import android.os.UidBatteryConsumer; +import android.platform.test.ravenwood.RavenwoodRule; import androidx.test.filters.SmallTest; import androidx.test.runner.AndroidJUnit4; @@ -40,6 +41,11 @@ import java.util.List; @RunWith(AndroidJUnit4.class) @SmallTest public class SensorPowerCalculatorTest { + @Rule(order = 0) + public final RavenwoodRule mRavenwood = new RavenwoodRule.Builder() + .setProvideMainThread(true) + .build(); + private static final double PRECISION = 0.00001; private static final int SENSOR_HANDLE_1 = 1; @@ -47,7 +53,7 @@ public class SensorPowerCalculatorTest { private static final int APP_UID = Process.FIRST_APPLICATION_UID + 42; - @Rule + @Rule(order = 1) public final BatteryUsageStatsRule mStatsRule = new BatteryUsageStatsRule(); @Test @@ -60,10 +66,12 @@ public class SensorPowerCalculatorTest { .thenReturn(List.of(sensor1, sensor2)); final BatteryStatsImpl stats = mStatsRule.getBatteryStats(); - stats.noteStartSensorLocked(APP_UID, SENSOR_HANDLE_1, 1000, 1000); - stats.noteStopSensorLocked(APP_UID, SENSOR_HANDLE_1, 2000, 2000); - stats.noteStartSensorLocked(APP_UID, SENSOR_HANDLE_2, 3000, 3000); - stats.noteStopSensorLocked(APP_UID, SENSOR_HANDLE_2, 5000, 5000); + synchronized (stats) { + stats.noteStartSensorLocked(APP_UID, SENSOR_HANDLE_1, 1000, 1000); + stats.noteStopSensorLocked(APP_UID, SENSOR_HANDLE_1, 2000, 2000); + stats.noteStartSensorLocked(APP_UID, SENSOR_HANDLE_2, 3000, 3000); + stats.noteStopSensorLocked(APP_UID, SENSOR_HANDLE_2, 5000, 5000); + } SensorPowerCalculator calculator = new SensorPowerCalculator(sensorManager); @@ -84,11 +92,20 @@ public class SensorPowerCalculatorTest { .isWithin(PRECISION).of(0.5); } - private Sensor createSensor(int handle, int type, double power) { - return new Sensor(new InputSensorInfo("name", "vendor", 0 /* version */, - handle, type, 100.0f /*maxRange */, 0.02f /* resolution */, - (float) power, 1000 /* minDelay */, 0 /* fifoReservedEventCount */, - 0 /* fifoMaxEventCount */, "" /* stringType */, "" /* requiredPermission */, - 0 /* maxDelay */, 0 /* flags */, 0 /* id */)); + private Sensor createSensor(int handle, int type, float power) { + if (RavenwoodRule.isUnderRavenwood()) { + Sensor sensor = mock(Sensor.class); + + when(sensor.getHandle()).thenReturn(handle); + when(sensor.getType()).thenReturn(type); + when(sensor.getPower()).thenReturn(power); + return sensor; + } else { + return new Sensor(new InputSensorInfo("name", "vendor", 0 /* version */, + handle, type, 100.0f /*maxRange */, 0.02f /* resolution */, + (float) power, 1000 /* minDelay */, 0 /* fifoReservedEventCount */, + 0 /* fifoMaxEventCount */, "" /* stringType */, "" /* requiredPermission */, + 0 /* maxDelay */, 0 /* flags */, 0 /* id */)); + } } } diff --git a/services/tests/powerstatstests/src/com/android/server/power/stats/UserPowerCalculatorTest.java b/services/tests/powerstatstests/src/com/android/server/power/stats/UserPowerCalculatorTest.java index f14745ef2daa..438f0ec36177 100644 --- a/services/tests/powerstatstests/src/com/android/server/power/stats/UserPowerCalculatorTest.java +++ b/services/tests/powerstatstests/src/com/android/server/power/stats/UserPowerCalculatorTest.java @@ -25,6 +25,7 @@ import android.os.Process; import android.os.UidBatteryConsumer; import android.os.UserBatteryConsumer; import android.os.UserHandle; +import android.platform.test.ravenwood.RavenwoodRule; import androidx.test.filters.SmallTest; import androidx.test.runner.AndroidJUnit4; @@ -36,6 +37,11 @@ import org.junit.runner.RunWith; @RunWith(AndroidJUnit4.class) @SmallTest public class UserPowerCalculatorTest { + @Rule(order = 0) + public final RavenwoodRule mRavenwood = new RavenwoodRule.Builder() + .setProvideMainThread(true) + .build(); + public static final int USER1 = 0; public static final int USER2 = 1625; @@ -43,7 +49,7 @@ public class UserPowerCalculatorTest { private static final int APP_UID2 = Process.FIRST_APPLICATION_UID + 272; private static final int APP_UID3 = Process.FIRST_APPLICATION_UID + 314; - @Rule + @Rule(order = 1) public final BatteryUsageStatsRule mStatsRule = new BatteryUsageStatsRule(); @Test diff --git a/services/tests/powerstatstests/src/com/android/server/power/stats/VideoPowerCalculatorTest.java b/services/tests/powerstatstests/src/com/android/server/power/stats/VideoPowerCalculatorTest.java index f578aa3b46be..b9b710118cc7 100644 --- a/services/tests/powerstatstests/src/com/android/server/power/stats/VideoPowerCalculatorTest.java +++ b/services/tests/powerstatstests/src/com/android/server/power/stats/VideoPowerCalculatorTest.java @@ -21,6 +21,7 @@ import static com.google.common.truth.Truth.assertThat; import android.os.BatteryConsumer; import android.os.Process; import android.os.UidBatteryConsumer; +import android.platform.test.ravenwood.RavenwoodRule; import androidx.test.filters.SmallTest; import androidx.test.runner.AndroidJUnit4; @@ -34,11 +35,16 @@ import org.junit.runner.RunWith; @RunWith(AndroidJUnit4.class) @SmallTest public class VideoPowerCalculatorTest { + @Rule(order = 0) + public final RavenwoodRule mRavenwood = new RavenwoodRule.Builder() + .setProvideMainThread(true) + .build(); + private static final double PRECISION = 0.00001; private static final int APP_UID = Process.FIRST_APPLICATION_UID + 42; - @Rule + @Rule(order = 1) public final BatteryUsageStatsRule mStatsRule = new BatteryUsageStatsRule() .setAveragePower(PowerProfile.POWER_VIDEO, 360.0); diff --git a/services/tests/powerstatstests/src/com/android/server/power/stats/WakelockPowerCalculatorTest.java b/services/tests/powerstatstests/src/com/android/server/power/stats/WakelockPowerCalculatorTest.java index f1961855f12f..5b7762d7de65 100644 --- a/services/tests/powerstatstests/src/com/android/server/power/stats/WakelockPowerCalculatorTest.java +++ b/services/tests/powerstatstests/src/com/android/server/power/stats/WakelockPowerCalculatorTest.java @@ -23,6 +23,7 @@ import android.os.BatteryStats; import android.os.Process; import android.os.UidBatteryConsumer; import android.os.WorkSource; +import android.platform.test.ravenwood.RavenwoodRule; import androidx.test.filters.SmallTest; import androidx.test.runner.AndroidJUnit4; @@ -36,12 +37,17 @@ import org.junit.runner.RunWith; @RunWith(AndroidJUnit4.class) @SmallTest public class WakelockPowerCalculatorTest { + @Rule(order = 0) + public final RavenwoodRule mRavenwood = new RavenwoodRule.Builder() + .setProvideMainThread(true) + .build(); + private static final double PRECISION = 0.00001; private static final int APP_UID = Process.FIRST_APPLICATION_UID + 42; private static final int APP_PID = 3145; - @Rule + @Rule(order = 1) public final BatteryUsageStatsRule mStatsRule = new BatteryUsageStatsRule() .setAveragePower(PowerProfile.POWER_CPU_IDLE, 360.0); @@ -51,10 +57,12 @@ public class WakelockPowerCalculatorTest { BatteryStatsImpl batteryStats = mStatsRule.getBatteryStats(); - batteryStats.noteStartWakeFromSourceLocked(new WorkSource(APP_UID), APP_PID, "awake", "", - BatteryStats.WAKE_TYPE_PARTIAL, true, 1000, 1000); - batteryStats.noteStopWakeFromSourceLocked(new WorkSource(APP_UID), APP_PID, "awake", "", - BatteryStats.WAKE_TYPE_PARTIAL, 2000, 2000); + synchronized (batteryStats) { + batteryStats.noteStartWakeFromSourceLocked(new WorkSource(APP_UID), APP_PID, "awake", + "", BatteryStats.WAKE_TYPE_PARTIAL, true, 1000, 1000); + batteryStats.noteStopWakeFromSourceLocked(new WorkSource(APP_UID), APP_PID, "awake", + "", BatteryStats.WAKE_TYPE_PARTIAL, 2000, 2000); + } mStatsRule.setTime(10_000, 6_000); diff --git a/services/tests/powerstatstests/src/com/android/server/power/stats/WifiPowerCalculatorTest.java b/services/tests/powerstatstests/src/com/android/server/power/stats/WifiPowerCalculatorTest.java index 113be8b19518..8e221be261e9 100644 --- a/services/tests/powerstatstests/src/com/android/server/power/stats/WifiPowerCalculatorTest.java +++ b/services/tests/powerstatstests/src/com/android/server/power/stats/WifiPowerCalculatorTest.java @@ -23,6 +23,9 @@ import static android.os.BatteryStats.POWER_DATA_UNAVAILABLE; import static com.google.common.truth.Truth.assertThat; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.when; + import android.app.usage.NetworkStatsManager; import android.net.NetworkCapabilities; import android.net.NetworkStats; @@ -33,6 +36,7 @@ import android.os.Process; import android.os.UidBatteryConsumer; import android.os.WorkSource; import android.os.connectivity.WifiActivityEnergyInfo; +import android.platform.test.ravenwood.RavenwoodRule; import androidx.test.filters.SmallTest; import androidx.test.runner.AndroidJUnit4; @@ -44,10 +48,17 @@ import org.junit.Test; import org.junit.runner.RunWith; import org.mockito.Mock; +import java.util.List; + @RunWith(AndroidJUnit4.class) @SmallTest @SuppressWarnings("GuardedBy") public class WifiPowerCalculatorTest { + @Rule(order = 0) + public final RavenwoodRule mRavenwood = new RavenwoodRule.Builder() + .setProvideMainThread(true) + .build(); + private static final double PRECISION = 0.00001; private static final int APP_UID = Process.FIRST_APPLICATION_UID + 42; @@ -55,7 +66,7 @@ public class WifiPowerCalculatorTest { @Mock NetworkStatsManager mNetworkStatsManager; - @Rule + @Rule(order = 1) public final BatteryUsageStatsRule mStatsRule = new BatteryUsageStatsRule() .setAveragePower(PowerProfile.POWER_WIFI_CONTROLLER_IDLE, 360.0) .setAveragePower(PowerProfile.POWER_WIFI_CONTROLLER_RX, 480.0) @@ -64,6 +75,7 @@ public class WifiPowerCalculatorTest { .setAveragePower(PowerProfile.POWER_WIFI_SCAN, 480.0) .setAveragePower(PowerProfile.POWER_WIFI_BATCHED_SCAN, 720.0) .setAveragePower(PowerProfile.POWER_WIFI_ACTIVE, 1080.0) + .setAveragePower(PowerProfile.POWER_WIFI_CONTROLLER_OPERATING_VOLTAGE, 3700) .initMeasuredEnergyStatsLocked(); /** Sets up a batterystats object with pre-populated network values. */ @@ -78,21 +90,54 @@ public class WifiPowerCalculatorTest { return batteryStats; } - private NetworkStats buildNetworkStats(long elapsedRealtime, int rxBytes, int rxPackets, - int txBytes, int txPackets) { - return new NetworkStats(elapsedRealtime, 1) - .addEntry(new NetworkStats.Entry("wifi", APP_UID, 0, 0, - METERED_NO, ROAMING_NO, DEFAULT_NETWORK_NO, rxBytes, rxPackets, - txBytes, txPackets, 100)) - .addEntry(new NetworkStats.Entry("wifi", Process.WIFI_UID, 0, 0, - METERED_NO, ROAMING_NO, DEFAULT_NETWORK_NO, 1111, 111, - 2222, 22, 111)); + private NetworkStats buildNetworkStats(long elapsedRealtime, long rxBytes, long rxPackets, + long txBytes, long txPackets) { + if (RavenwoodRule.isUnderRavenwood()) { + NetworkStats stats = mock(NetworkStats.class); +// when(stats.getElapsedRealtime()).thenReturn(elapsedRealtime); + + NetworkStats.Entry entry1 = mock(NetworkStats.Entry.class); +// when(entry1.getIface()).thenReturn("wifi"); + when(entry1.getUid()).thenReturn(APP_UID); + when(entry1.getMetered()).thenReturn(METERED_NO); + when(entry1.getRoaming()).thenReturn(ROAMING_NO); + when(entry1.getDefaultNetwork()).thenReturn(DEFAULT_NETWORK_NO); + when(entry1.getRxBytes()).thenReturn(rxBytes); + when(entry1.getRxPackets()).thenReturn(rxPackets); + when(entry1.getTxBytes()).thenReturn(txBytes); + when(entry1.getTxPackets()).thenReturn(txPackets); + when(entry1.getOperations()).thenReturn(100L); + + NetworkStats.Entry entry2 = mock(NetworkStats.Entry.class); +// when(entry2.getIface()).thenReturn("wifi"); + when(entry2.getUid()).thenReturn(Process.WIFI_UID); + when(entry2.getMetered()).thenReturn(METERED_NO); + when(entry2.getRoaming()).thenReturn(ROAMING_NO); + when(entry2.getDefaultNetwork()).thenReturn(DEFAULT_NETWORK_NO); + when(entry2.getRxBytes()).thenReturn(1111L); + when(entry2.getRxPackets()).thenReturn(111L); + when(entry2.getTxBytes()).thenReturn(2222L); + when(entry2.getTxPackets()).thenReturn(22L); + when(entry2.getOperations()).thenReturn(111L); + + when(stats.iterator()).thenAnswer(inv->List.of(entry1, entry2).iterator()); + + return stats; + } else { + return new NetworkStats(elapsedRealtime, 1) + .addEntry(new NetworkStats.Entry("wifi", APP_UID, 0, 0, + METERED_NO, ROAMING_NO, DEFAULT_NETWORK_NO, rxBytes, rxPackets, + txBytes, txPackets, 100)) + .addEntry(new NetworkStats.Entry("wifi", Process.WIFI_UID, 0, 0, + METERED_NO, ROAMING_NO, DEFAULT_NETWORK_NO, 1111, 111, + 2222, 22, 111)); + } } /** Sets up an WifiActivityEnergyInfo for ActivityController-model-based tests. */ private WifiActivityEnergyInfo setupPowerControllerBasedModelEnergyNumbersInfo() { - return new WifiActivityEnergyInfo(10000, - WifiActivityEnergyInfo.STACK_STATE_STATE_ACTIVE, 1000, 2000, 3000, 4000); + return buildWifiActivityEnergyInfo(10000L, WifiActivityEnergyInfo.STACK_STATE_STATE_ACTIVE, + 1000L, 2000L, 3000L, 4000L); } @Test @@ -142,7 +187,7 @@ public class WifiPowerCalculatorTest { uid.setProcessStateForTest( BatteryStats.Uid.PROCESS_STATE_FOREGROUND, 1000); - batteryStats.updateWifiState(new WifiActivityEnergyInfo(2000, + batteryStats.updateWifiState(buildWifiActivityEnergyInfo(2000, WifiActivityEnergyInfo.STACK_STATE_STATE_ACTIVE, 1000, 2000, 3000, 4000), POWER_DATA_UNAVAILABLE, 2000, 2000, mNetworkStatsManager); @@ -152,7 +197,7 @@ public class WifiPowerCalculatorTest { mStatsRule.setNetworkStats(buildNetworkStats(4000, 5000, 200, 7000, 80)); - batteryStats.updateWifiState(new WifiActivityEnergyInfo(4000, + batteryStats.updateWifiState(buildWifiActivityEnergyInfo(4000, WifiActivityEnergyInfo.STACK_STATE_STATE_ACTIVE, 5000, 6000, 7000, 8000), POWER_DATA_UNAVAILABLE, 4000, 4000, mNetworkStatsManager); @@ -231,7 +276,7 @@ public class WifiPowerCalculatorTest { uid.setProcessStateForTest( BatteryStats.Uid.PROCESS_STATE_FOREGROUND, 1000); - batteryStats.updateWifiState(new WifiActivityEnergyInfo(2000, + batteryStats.updateWifiState(buildWifiActivityEnergyInfo(2000, WifiActivityEnergyInfo.STACK_STATE_STATE_ACTIVE, 1000, 2000, 3000, 4000), 1_000_000, 2000, 2000, mNetworkStatsManager); @@ -241,7 +286,7 @@ public class WifiPowerCalculatorTest { mStatsRule.setNetworkStats(buildNetworkStats(4000, 5000, 200, 7000, 80)); - batteryStats.updateWifiState(new WifiActivityEnergyInfo(4000, + batteryStats.updateWifiState(buildWifiActivityEnergyInfo(4000, WifiActivityEnergyInfo.STACK_STATE_STATE_ACTIVE, 5000, 6000, 7000, 8000), 5_000_000, 4000, 4000, mNetworkStatsManager); @@ -329,4 +374,43 @@ public class WifiPowerCalculatorTest { assertThat(uidConsumer.getPowerModel(BatteryConsumer.POWER_COMPONENT_WIFI)) .isEqualTo(BatteryConsumer.POWER_MODEL_ENERGY_CONSUMPTION); } + + private WifiActivityEnergyInfo buildWifiActivityEnergyInfo(long timeSinceBoot, + int stackState, long txDuration, long rxDuration, long scanDuration, + long idleDuration) { + if (RavenwoodRule.isUnderRavenwood()) { + WifiActivityEnergyInfo info = mock(WifiActivityEnergyInfo.class); + when(info.getTimeSinceBootMillis()).thenReturn(timeSinceBoot); + when(info.getStackState()).thenReturn(stackState); + when(info.getControllerTxDurationMillis()).thenReturn(txDuration); + when(info.getControllerRxDurationMillis()).thenReturn(rxDuration); + when(info.getControllerScanDurationMillis()).thenReturn(scanDuration); + when(info.getControllerIdleDurationMillis()).thenReturn(idleDuration); + long energy = calculateEnergyMicroJoules(txDuration, rxDuration, idleDuration); + when(info.getControllerEnergyUsedMicroJoules()).thenReturn(energy); + return info; + } else { + return new WifiActivityEnergyInfo(timeSinceBoot, stackState, txDuration, rxDuration, + scanDuration, idleDuration); + } + } + + // See WifiActivityEnergyInfo + private long calculateEnergyMicroJoules( + long txDurationMillis, long rxDurationMillis, long idleDurationMillis) { + PowerProfile powerProfile = mStatsRule.getPowerProfile(); + final double idleCurrent = powerProfile.getAveragePower( + PowerProfile.POWER_WIFI_CONTROLLER_IDLE); + final double rxCurrent = powerProfile.getAveragePower( + PowerProfile.POWER_WIFI_CONTROLLER_RX); + final double txCurrent = powerProfile.getAveragePower( + PowerProfile.POWER_WIFI_CONTROLLER_TX); + final double voltage = powerProfile.getAveragePower( + PowerProfile.POWER_WIFI_CONTROLLER_OPERATING_VOLTAGE) / 1000.0; + + return (long) ((txDurationMillis * txCurrent + + rxDurationMillis * rxCurrent + + idleDurationMillis * idleCurrent) + * voltage); + } } diff --git a/tools/hoststubgen/hoststubgen/helper-framework-runtime-src/framework/com/android/hoststubgen/nativesubstitution/CursorWindow_host.java b/tools/hoststubgen/hoststubgen/helper-framework-runtime-src/framework/com/android/hoststubgen/nativesubstitution/CursorWindow_host.java index 631fc0273c94..eba99107f126 100644 --- a/tools/hoststubgen/hoststubgen/helper-framework-runtime-src/framework/com/android/hoststubgen/nativesubstitution/CursorWindow_host.java +++ b/tools/hoststubgen/hoststubgen/helper-framework-runtime-src/framework/com/android/hoststubgen/nativesubstitution/CursorWindow_host.java @@ -17,6 +17,7 @@ package com.android.hoststubgen.nativesubstitution; import android.database.Cursor; import android.database.sqlite.SQLiteException; +import android.os.Parcel; import android.util.Base64; import java.text.DecimalFormat; @@ -31,6 +32,7 @@ public class CursorWindow_host { private static final HashMap<Long, CursorWindow_host> sInstances = new HashMap<>(); private static long sNextId = 1; + private String mName; private int mColumnNum; private static class Row { String[] fields; @@ -41,6 +43,7 @@ public class CursorWindow_host { public static long nativeCreate(String name, int cursorWindowSize) { CursorWindow_host instance = new CursorWindow_host(); + instance.mName = name; long instanceId = sNextId++; sInstances.put(instanceId, instance); return instanceId; @@ -50,6 +53,10 @@ public class CursorWindow_host { sInstances.remove(windowPtr); } + public static String nativeGetName(long windowPtr) { + return sInstances.get(windowPtr).mName; + } + public static boolean nativeSetNumColumns(long windowPtr, int columnNum) { sInstances.get(windowPtr).mColumnNum = columnNum; return true; @@ -156,4 +163,30 @@ public class CursorWindow_host { return null; } } + + public static void nativeWriteToParcel(long windowPtr, Parcel parcel) { + CursorWindow_host window = sInstances.get(windowPtr); + parcel.writeString(window.mName); + parcel.writeInt(window.mColumnNum); + parcel.writeInt(window.mRows.size()); + for (int row = 0; row < window.mRows.size(); row++) { + parcel.writeStringArray(window.mRows.get(row).fields); + parcel.writeIntArray(window.mRows.get(row).types); + } + } + + public static long nativeCreateFromParcel(Parcel parcel) { + long windowPtr = nativeCreate(null, 0); + CursorWindow_host window = sInstances.get(windowPtr); + window.mName = parcel.readString(); + window.mColumnNum = parcel.readInt(); + int rowCount = parcel.readInt(); + for (int row = 0; row < rowCount; row++) { + Row r = new Row(); + r.fields = parcel.createStringArray(); + r.types = parcel.createIntArray(); + window.mRows.add(r); + } + return windowPtr; + } } diff --git a/tools/hoststubgen/hoststubgen/helper-framework-runtime-src/framework/com/android/hoststubgen/nativesubstitution/LongArrayMultiStateCounter_host.java b/tools/hoststubgen/hoststubgen/helper-framework-runtime-src/framework/com/android/hoststubgen/nativesubstitution/LongArrayMultiStateCounter_host.java index a1356237e5a4..4d39d88d58c3 100644 --- a/tools/hoststubgen/hoststubgen/helper-framework-runtime-src/framework/com/android/hoststubgen/nativesubstitution/LongArrayMultiStateCounter_host.java +++ b/tools/hoststubgen/hoststubgen/helper-framework-runtime-src/framework/com/android/hoststubgen/nativesubstitution/LongArrayMultiStateCounter_host.java @@ -143,6 +143,16 @@ public class LongArrayMultiStateCounter_host { updateValue(values, timestampMs); } + public void addCounts(long[] delta) { + if (!mEnabled) { + return; + } + + for (int i = 0; i < mArrayLength; i++) { + mStates[mCurrentState].mCounter[i] += delta[i]; + } + } + public void getValues(long[] values, int state) { System.arraycopy(mStates[state].mCounter, 0, values, 0, mArrayLength); } @@ -331,6 +341,10 @@ public class LongArrayMultiStateCounter_host { LongArrayContainer_host.getInstance(containerInstanceId), timestampMs); } + public static void native_addCounts(long instanceId, long containerInstanceId) { + getInstance(instanceId).addCounts(LongArrayContainer_host.getInstance(containerInstanceId)); + } + public static void native_getCounts(long instanceId, long containerInstanceId, int state) { getInstance(instanceId).getValues(LongArrayContainer_host.getInstance(containerInstanceId), state); diff --git a/tools/hoststubgen/hoststubgen/helper-framework-runtime-src/framework/com/android/hoststubgen/nativesubstitution/LongMultiStateCounter_host.java b/tools/hoststubgen/hoststubgen/helper-framework-runtime-src/framework/com/android/hoststubgen/nativesubstitution/LongMultiStateCounter_host.java new file mode 100644 index 000000000000..a5d0fc6872de --- /dev/null +++ b/tools/hoststubgen/hoststubgen/helper-framework-runtime-src/framework/com/android/hoststubgen/nativesubstitution/LongMultiStateCounter_host.java @@ -0,0 +1,263 @@ +/* + * Copyright (C) 2024 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.hoststubgen.nativesubstitution; + +import android.os.BadParcelableException; +import android.os.Parcel; + +import java.util.HashMap; + +/** + * Native implementation substitutions for the LongMultiStateCounter class. + */ +public class LongMultiStateCounter_host { + + /** + * A reimplementation of {@link com.android.internal.os.LongMultiStateCounter}, only in + * Java instead of native. The majority of the code (in C++) can be found in + * /frameworks/native/libs/battery/MultiStateCounter.h + */ + private static class LongMultiStateCounterRavenwood { + private final int mStateCount; + private int mCurrentState; + private long mLastStateChangeTimestampMs = -1; + private long mLastUpdateTimestampMs = -1; + private boolean mEnabled = true; + + private static class State { + private long mTimeInStateSinceUpdate; + private long mCounter; + } + + private final State[] mStates; + private long mValue; + + LongMultiStateCounterRavenwood(int stateCount) { + mStateCount = stateCount; + mStates = new State[stateCount]; + for (int i = 0; i < mStateCount; i++) { + mStates[i] = new State(); + } + } + + public void setEnabled(boolean enabled, long timestampMs) { + if (enabled == mEnabled) { + return; + } + + if (!enabled) { + setState(mCurrentState, timestampMs); + mEnabled = false; + } else { + if (timestampMs < mLastUpdateTimestampMs) { + timestampMs = mLastUpdateTimestampMs; + } + + if (mLastStateChangeTimestampMs >= 0) { + mLastStateChangeTimestampMs = timestampMs; + } + mEnabled = true; + } + } + + public void setState(int state, long timestampMs) { + if (mEnabled && mLastStateChangeTimestampMs >= 0 && mLastUpdateTimestampMs >= 0) { + if (timestampMs < mLastUpdateTimestampMs) { + timestampMs = mLastUpdateTimestampMs; + } + + if (timestampMs >= mLastStateChangeTimestampMs) { + mStates[mCurrentState].mTimeInStateSinceUpdate += + timestampMs - mLastStateChangeTimestampMs; + } else { + for (int i = 0; i < mStateCount; i++) { + mStates[i].mTimeInStateSinceUpdate = 0; + } + } + } + mCurrentState = state; + mLastStateChangeTimestampMs = timestampMs; + } + + public long updateValue(long value, long timestampMs) { + long returnValue = 0; + if (mEnabled || mLastUpdateTimestampMs < mLastStateChangeTimestampMs) { + if (timestampMs < mLastStateChangeTimestampMs) { + timestampMs = mLastStateChangeTimestampMs; + } + + setState(mCurrentState, timestampMs); + + if (mLastUpdateTimestampMs >= 0) { + if (timestampMs > mLastUpdateTimestampMs) { + long delta = value - mValue; + if (delta >= 0) { + returnValue = delta; + long timeSinceUpdate = timestampMs - mLastUpdateTimestampMs; + for (int i = 0; i < mStateCount; i++) { + long timeInState = mStates[i].mTimeInStateSinceUpdate; + if (timeInState > 0) { + mStates[i].mCounter += delta * timeInState / timeSinceUpdate; + mStates[i].mTimeInStateSinceUpdate = 0; + } + } + } else { + for (int i = 0; i < mStateCount; i++) { + mStates[i].mTimeInStateSinceUpdate = 0; + } + } + } else if (timestampMs < mLastUpdateTimestampMs) { + for (int i = 0; i < mStateCount; i++) { + mStates[i].mTimeInStateSinceUpdate = 0; + } + } + } + } + mValue = value; + mLastUpdateTimestampMs = timestampMs; + return returnValue; + } + + public void incrementValue(long count, long timestampMs) { + updateValue(mValue + count, timestampMs); + } + + public long getValue(int state) { + return mStates[state].mCounter; + } + + public void reset() { + mLastStateChangeTimestampMs = -1; + mLastUpdateTimestampMs = -1; + for (int i = 0; i < mStateCount; i++) { + mStates[i].mTimeInStateSinceUpdate = 0; + mStates[i].mCounter = 0; + } + } + + public void writeToParcel(Parcel parcel) { + parcel.writeInt(mStateCount); + for (int i = 0; i < mStateCount; i++) { + parcel.writeLong(mStates[i].mCounter); + } + } + + public void initFromParcel(Parcel parcel) { + try { + for (int i = 0; i < mStateCount; i++) { + mStates[i].mCounter = parcel.readLong(); + } + } catch (Exception e) { + throw new BadParcelableException(e); + } + } + + @Override + public String toString() { + StringBuilder sb = new StringBuilder(); + sb.append("["); + for (int state = 0; state < mStateCount; state++) { + if (state != 0) { + sb.append(", "); + } + sb.append(state).append(": ").append(mStates[state].mCounter); + } + sb.append("]"); + if (mLastUpdateTimestampMs >= 0) { + sb.append(" updated: ").append(mLastUpdateTimestampMs); + } + if (mLastStateChangeTimestampMs >= 0) { + sb.append(" currentState: ").append(mCurrentState); + if (mLastStateChangeTimestampMs > mLastUpdateTimestampMs) { + sb.append(" stateChanged: ").append(mLastStateChangeTimestampMs); + } + } else { + sb.append(" currentState: none"); + } + return sb.toString(); + } + } + + private static final HashMap<Long, LongMultiStateCounterRavenwood> sInstances = + new HashMap<>(); + private static long sNextId = 1; + + public static long native_init(int stateCount) { + LongMultiStateCounterRavenwood instance = new LongMultiStateCounterRavenwood(stateCount); + long instanceId = sNextId++; + sInstances.put(instanceId, instance); + return instanceId; + } + + private static LongMultiStateCounterRavenwood getInstance(long instanceId) { + return sInstances.get(instanceId); + } + + public static void native_setEnabled(long instanceId, boolean enabled, + long timestampMs) { + getInstance(instanceId).setEnabled(enabled, timestampMs); + } + + public static int native_getStateCount(long instanceId) { + return getInstance(instanceId).mStateCount; + } + + public static long native_updateValue(long instanceId, long value, long timestampMs) { + return getInstance(instanceId).updateValue(value, timestampMs); + } + + public static void native_setState(long instanceId, int state, long timestampMs) { + getInstance(instanceId).setState(state, timestampMs); + } + + public static void native_incrementValue(long instanceId, long count, long timestampMs) { + getInstance(instanceId).incrementValue(count, timestampMs); + } + + public static long native_getCount(long instanceId, int state) { + return getInstance(instanceId).getValue(state); + } + + public static void native_reset(long instanceId) { + getInstance(instanceId).reset(); + } + + public static void native_writeToParcel(long instanceId, Parcel parcel, int flags) { + getInstance(instanceId).writeToParcel(parcel); + } + + public static long native_initFromParcel(Parcel parcel) { + int stateCount = parcel.readInt(); + if (stateCount < 0 || stateCount > 0xEFFF) { + throw new BadParcelableException("stateCount out of range"); + } + // LongMultiStateCounter.cpp uses AParcel, which throws on out-of-data. + if (parcel.dataPosition() >= parcel.dataSize()) { + throw new RuntimeException("Bad parcel"); + } + long instanceId = native_init(stateCount); + getInstance(instanceId).initFromParcel(parcel); + if (parcel.dataPosition() > parcel.dataSize()) { + throw new RuntimeException("Bad parcel"); + } + return instanceId; + } + + public static String native_toString(long instanceId) { + return getInstance(instanceId).toString(); + } +} |