Convert Condition.java to Kotlin.

Test: atest ConditionTest
Bug: 394520234
Flag: EXEMPT refactor
Change-Id: I6d15131d2396ff14161bd49642f6cef0901e2e29

15 files changed, 332 insertions, 374 deletions

diff --git a/packages/SystemUI/multivalentTests/src/com/android/systemui/shared/condition/ConditionExtensionsTest.kt b/packages/SystemUI/multivalentTests/src/com/android/systemui/shared/condition/ConditionExtensionsTest.kt
index 4bd02e0fab22..17509dc6a80f 100644
--- a/packages/SystemUI/multivalentTests/src/com/android/systemui/shared/condition/ConditionExtensionsTest.kt
+++ b/packages/SystemUI/multivalentTests/src/com/android/systemui/shared/condition/ConditionExtensionsTest.kt
@@ -19,6 +19,10 @@ import org.junit.runner.RunWith
 @RunWith(AndroidJUnit4::class)
 class ConditionExtensionsTest : SysuiTestCase() {
     private lateinit var testScope: TestScope
+    private val testCallback =
+        Condition.Callback {
+            // This is a no-op
+        }
 
     @Before
     fun setUp() {
@@ -33,7 +37,7 @@ class ConditionExtensionsTest : SysuiTestCase() {
 
             assertThat(condition.isConditionSet).isFalse()
 
-            condition.start()
+            condition.testStart()
             assertThat(condition.isConditionSet).isTrue()
             assertThat(condition.isConditionMet).isTrue()
         }
@@ -46,7 +50,7 @@ class ConditionExtensionsTest : SysuiTestCase() {
 
             assertThat(condition.isConditionSet).isFalse()
 
-            condition.start()
+            condition.testStart()
             assertThat(condition.isConditionSet).isTrue()
             assertThat(condition.isConditionMet).isFalse()
         }
@@ -56,7 +60,7 @@ class ConditionExtensionsTest : SysuiTestCase() {
         testScope.runTest {
             val flow = emptyFlow<Boolean>()
             val condition = flow.toCondition(scope = this, Condition.START_EAGERLY)
-            condition.start()
+            condition.testStop()
 
             assertThat(condition.isConditionSet).isFalse()
             assertThat(condition.isConditionMet).isFalse()
@@ -72,7 +76,7 @@ class ConditionExtensionsTest : SysuiTestCase() {
                     strategy = Condition.START_EAGERLY,
                     initialValue = true,
                 )
-            condition.start()
+            condition.testStart()
 
             assertThat(condition.isConditionSet).isTrue()
             assertThat(condition.isConditionMet).isTrue()
@@ -88,7 +92,7 @@ class ConditionExtensionsTest : SysuiTestCase() {
                     strategy = Condition.START_EAGERLY,
                     initialValue = false,
                 )
-            condition.start()
+            condition.testStart()
 
             assertThat(condition.isConditionSet).isTrue()
             assertThat(condition.isConditionMet).isFalse()
@@ -99,7 +103,7 @@ class ConditionExtensionsTest : SysuiTestCase() {
         testScope.runTest {
             val flow = MutableStateFlow(false)
             val condition = flow.toCondition(scope = this, strategy = Condition.START_EAGERLY)
-            condition.start()
+            condition.testStart()
 
             assertThat(condition.isConditionSet).isTrue()
             assertThat(condition.isConditionMet).isFalse()
@@ -110,7 +114,7 @@ class ConditionExtensionsTest : SysuiTestCase() {
             flow.value = false
             assertThat(condition.isConditionMet).isFalse()
 
-            condition.stop()
+            condition.testStop()
         }
 
     @Test
@@ -120,10 +124,18 @@ class ConditionExtensionsTest : SysuiTestCase() {
             val condition = flow.toCondition(scope = this, strategy = Condition.START_EAGERLY)
             assertThat(flow.subscriptionCount.value).isEqualTo(0)
 
-            condition.start()
+            condition.testStart()
             assertThat(flow.subscriptionCount.value).isEqualTo(1)
 
-            condition.stop()
+            condition.testStop()
             assertThat(flow.subscriptionCount.value).isEqualTo(0)
         }
+
+    fun Condition.testStart() {
+        addCallback(testCallback)
+    }
+
+    fun Condition.testStop() {
+        removeCallback(testCallback)
+    }
 }
diff --git a/packages/SystemUI/multivalentTests/src/com/android/systemui/shared/condition/FakeCondition.java b/packages/SystemUI/multivalentTests/src/com/android/systemui/shared/condition/FakeCondition.java
index 5416536305fc..da660e2f6009 100644
--- a/packages/SystemUI/multivalentTests/src/com/android/systemui/shared/condition/FakeCondition.java
+++ b/packages/SystemUI/multivalentTests/src/com/android/systemui/shared/condition/FakeCondition.java
@@ -40,7 +40,7 @@ public class FakeCondition extends Condition {
     }
 
     @Override
-    protected int getStartStrategy() {
+    public int getStartStrategy() {
         return START_EAGERLY;
     }
 
diff --git a/packages/SystemUI/shared/src/com/android/systemui/shared/condition/CombinedCondition.kt b/packages/SystemUI/shared/src/com/android/systemui/shared/condition/CombinedCondition.kt
index a2b6e2cf9ae3..f276a82baaef 100644
--- a/packages/SystemUI/shared/src/com/android/systemui/shared/condition/CombinedCondition.kt
+++ b/packages/SystemUI/shared/src/com/android/systemui/shared/condition/CombinedCondition.kt
@@ -41,7 +41,7 @@ class CombinedCondition
 constructor(
     private val scope: CoroutineScope,
     private val conditions: Collection<Condition>,
-    @Evaluator.ConditionOperand private val operand: Int
+    @Evaluator.ConditionOperand private val operand: Int,
 ) : Condition(scope, null, false) {
 
     private var job: Job? = null
@@ -54,7 +54,7 @@ constructor(
 
                 lazilyEvaluate(
                         conditions = groupedConditions.getOrDefault(true, emptyList()),
-                        filterUnknown = true
+                        filterUnknown = true,
                     )
                     .distinctUntilChanged()
                     .flatMapLatest { overriddenValue ->
@@ -62,7 +62,7 @@ constructor(
                         if (overriddenValue == null) {
                             lazilyEvaluate(
                                 conditions = groupedConditions.getOrDefault(false, emptyList()),
-                                filterUnknown = false
+                                filterUnknown = false,
                             )
                         } else {
                             flowOf(overriddenValue)
@@ -188,7 +188,6 @@ constructor(
         return startStrategy
     }
 
-    override fun getStartStrategy(): Int {
-        return _startStrategy
-    }
+    override val startStrategy: Int
+        get() = _startStrategy
 }
diff --git a/packages/SystemUI/shared/src/com/android/systemui/shared/condition/Condition.java b/packages/SystemUI/shared/src/com/android/systemui/shared/condition/Condition.java
deleted file mode 100644
index 670feeba6e8a..000000000000
--- a/packages/SystemUI/shared/src/com/android/systemui/shared/condition/Condition.java
+++ /dev/null
@@ -1,306 +0,0 @@
-/*
- * Copyright (C) 2022 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.systemui.shared.condition;
-
-import android.util.Log;
-
-import androidx.annotation.IntDef;
-import androidx.annotation.NonNull;
-import androidx.lifecycle.Lifecycle;
-import androidx.lifecycle.LifecycleEventObserver;
-import androidx.lifecycle.LifecycleOwner;
-
-import kotlinx.coroutines.CoroutineScope;
-
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.lang.ref.WeakReference;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Collection;
-import java.util.Iterator;
-import java.util.List;
-
-/**
- * Base class for a condition that needs to be fulfilled in order for {@link Monitor} to inform
- * its callbacks.
- */
-public abstract class Condition {
-    private final String mTag = getClass().getSimpleName();
-
-    private final ArrayList<WeakReference<Callback>> mCallbacks = new ArrayList<>();
-    private final boolean mOverriding;
-    private final CoroutineScope mScope;
-    private Boolean mIsConditionMet;
-    private boolean mStarted = false;
-
-    /**
-     * By default, conditions have an initial value of false and are not overriding.
-     */
-    public Condition(CoroutineScope scope) {
-        this(scope, false, false);
-    }
-
-    /**
-     * Constructor for specifying initial state and overriding condition attribute.
-     *
-     * @param initialConditionMet Initial state of the condition.
-     * @param overriding          Whether this condition overrides others.
-     */
-    protected Condition(CoroutineScope scope, Boolean initialConditionMet, boolean overriding) {
-        mIsConditionMet = initialConditionMet;
-        mOverriding = overriding;
-        mScope = scope;
-    }
-
-    /**
-     * Starts monitoring the condition.
-     */
-    protected abstract void start();
-
-    /**
-     * Stops monitoring the condition.
-     */
-    protected abstract void stop();
-
-    /**
-     * Condition should be started as soon as there is an active subscription.
-     */
-    public static final int START_EAGERLY = 0;
-    /**
-     * Condition should be started lazily only if needed. But once started, it will not be cancelled
-     * unless there are no more active subscriptions.
-     */
-    public static final int START_LAZILY = 1;
-    /**
-     * Condition should be started lazily only if needed, and can be stopped when not needed. This
-     * should be used for conditions which are expensive to keep running.
-     */
-    public static final int START_WHEN_NEEDED = 2;
-
-    @Retention(RetentionPolicy.SOURCE)
-    @IntDef({START_EAGERLY, START_LAZILY, START_WHEN_NEEDED})
-    @interface StartStrategy {
-    }
-
-    @StartStrategy
-    protected abstract int getStartStrategy();
-
-    /**
-     * Returns whether the current condition overrides
-     */
-    public boolean isOverridingCondition() {
-        return mOverriding;
-    }
-
-    /**
-     * Registers a callback to receive updates once started. This should be called before
-     * {@link #start()}. Also triggers the callback immediately if already started.
-     */
-    public void addCallback(@NonNull Callback callback) {
-        if (shouldLog()) Log.d(mTag, "adding callback");
-        mCallbacks.add(new WeakReference<>(callback));
-
-        if (mStarted) {
-            callback.onConditionChanged(this);
-            return;
-        }
-
-        start();
-        mStarted = true;
-    }
-
-    /**
-     * Removes the provided callback from further receiving updates.
-     */
-    public void removeCallback(@NonNull Callback callback) {
-        if (shouldLog()) Log.d(mTag, "removing callback");
-        final Iterator<WeakReference<Callback>> iterator = mCallbacks.iterator();
-        while (iterator.hasNext()) {
-            final Callback cb = iterator.next().get();
-            if (cb == null || cb == callback) {
-                iterator.remove();
-            }
-        }
-
-        if (!mCallbacks.isEmpty() || !mStarted) {
-            return;
-        }
-
-        stop();
-        mStarted = false;
-    }
-
-    /**
-     * Wrapper to {@link #addCallback(Callback)} when a lifecycle is in the resumed state
-     * and {@link #removeCallback(Callback)} when not resumed automatically.
-     */
-    public Callback observe(LifecycleOwner owner, Callback listener) {
-        return observe(owner.getLifecycle(), listener);
-    }
-
-    /**
-     * Wrapper to {@link #addCallback(Callback)} when a lifecycle is in the resumed state
-     * and {@link #removeCallback(Condition.Callback)} when not resumed automatically.
-     */
-    public Callback observe(Lifecycle lifecycle, Callback listener) {
-        lifecycle.addObserver((LifecycleEventObserver) (lifecycleOwner, event) -> {
-            if (event == Lifecycle.Event.ON_RESUME) {
-                addCallback(listener);
-            } else if (event == Lifecycle.Event.ON_PAUSE) {
-                removeCallback(listener);
-            }
-        });
-        return listener;
-    }
-
-    /**
-     * Updates the value for whether the condition has been fulfilled, and sends an update if the
-     * value changes and any callback is registered.
-     *
-     * @param isConditionMet True if the condition has been fulfilled. False otherwise.
-     */
-    protected void updateCondition(boolean isConditionMet) {
-        if (mIsConditionMet != null && mIsConditionMet == isConditionMet) {
-            return;
-        }
-
-        if (shouldLog()) Log.d(mTag, "updating condition to " + isConditionMet);
-        mIsConditionMet = isConditionMet;
-        sendUpdate();
-    }
-
-    /**
-     * Clears the set condition value. This is purposefully separate from
-     * {@link #updateCondition(boolean)} to avoid confusion around {@code null} values.
-     */
-    protected void clearCondition() {
-        if (mIsConditionMet == null) {
-            return;
-        }
-
-        if (shouldLog()) Log.d(mTag, "clearing condition");
-
-        mIsConditionMet = null;
-        sendUpdate();
-    }
-
-    private void sendUpdate() {
-        final Iterator<WeakReference<Callback>> iterator = mCallbacks.iterator();
-        while (iterator.hasNext()) {
-            final Callback cb = iterator.next().get();
-            if (cb == null) {
-                iterator.remove();
-            } else {
-                cb.onConditionChanged(this);
-            }
-        }
-    }
-
-    /**
-     * Returns whether the condition is set. This method should be consulted to understand the
-     * value of {@link #isConditionMet()}.
-     *
-     * @return {@code true} if value is present, {@code false} otherwise.
-     */
-    public boolean isConditionSet() {
-        return mIsConditionMet != null;
-    }
-
-    /**
-     * Returns whether the condition has been met. Note that this method will return {@code false}
-     * if the condition is not set as well.
-     */
-    public boolean isConditionMet() {
-        return Boolean.TRUE.equals(mIsConditionMet);
-    }
-
-    protected final boolean shouldLog() {
-        return Log.isLoggable(mTag, Log.DEBUG);
-    }
-
-    protected final String getTag() {
-        if (isOverridingCondition()) {
-            return mTag + "[OVRD]";
-        }
-
-        return mTag;
-    }
-
-    /**
-     * Returns the state of the condition.
-     * - "Invalid", condition hasn't been set / not monitored
-     * - "True", condition has been met
-     * - "False", condition has not been met
-     */
-    protected final String getState() {
-        if (!isConditionSet()) {
-            return "Invalid";
-        }
-        return isConditionMet() ? "True" : "False";
-    }
-
-    /**
-     * Creates a new condition which will only be true when both this condition and all the provided
-     * conditions are true.
-     */
-    public Condition and(@NonNull Collection<Condition> others) {
-        final List<Condition> conditions = new ArrayList<>();
-        conditions.add(this);
-        conditions.addAll(others);
-        return new CombinedCondition(mScope, conditions, Evaluator.OP_AND);
-    }
-
-    /**
-     * Creates a new condition which will only be true when both this condition and the provided
-     * condition is true.
-     */
-    public Condition and(@NonNull Condition... others) {
-        return and(Arrays.asList(others));
-    }
-
-    /**
-     * Creates a new condition which will only be true when either this condition or any of the
-     * provided conditions are true.
-     */
-    public Condition or(@NonNull Collection<Condition> others) {
-        final List<Condition> conditions = new ArrayList<>();
-        conditions.add(this);
-        conditions.addAll(others);
-        return new CombinedCondition(mScope, conditions, Evaluator.OP_OR);
-    }
-
-    /**
-     * Creates a new condition which will only be true when either this condition or the provided
-     * condition is true.
-     */
-    public Condition or(@NonNull Condition... others) {
-        return or(Arrays.asList(others));
-    }
-
-    /**
-     * Callback that receives updates about whether the condition has been fulfilled.
-     */
-    public interface Callback {
-        /**
-         * Called when the fulfillment of the condition changes.
-         *
-         * @param condition The condition in question.
-         */
-        void onConditionChanged(Condition condition);
-    }
-}
diff --git a/packages/SystemUI/shared/src/com/android/systemui/shared/condition/Condition.kt b/packages/SystemUI/shared/src/com/android/systemui/shared/condition/Condition.kt
new file mode 100644
index 000000000000..69236b48ed51
--- /dev/null
+++ b/packages/SystemUI/shared/src/com/android/systemui/shared/condition/Condition.kt
@@ -0,0 +1,270 @@
+/*
+ * Copyright (C) 2025 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.systemui.shared.condition
+
+import android.util.Log
+import androidx.annotation.IntDef
+import androidx.lifecycle.Lifecycle
+import androidx.lifecycle.LifecycleEventObserver
+import androidx.lifecycle.LifecycleOwner
+import java.lang.ref.WeakReference
+import kotlinx.coroutines.CoroutineScope
+
+/**
+ * Base class for a condition that needs to be fulfilled in order for [Monitor] to inform its
+ * callbacks.
+ */
+abstract class Condition
+/**
+ * Constructor for specifying initial state and overriding condition attribute.
+ *
+ * @param initialConditionMet Initial state of the condition.
+ * @param overriding Whether this condition overrides others.
+ */
+@JvmOverloads
+protected constructor(
+    private val _scope: CoroutineScope,
+    private var _isConditionMet: Boolean? = false,
+    /** Returns whether the current condition overrides */
+    val isOverridingCondition: Boolean = false,
+) {
+    private val mTag: String = javaClass.simpleName
+
+    private val _callbacks = mutableListOf<WeakReference<Callback>>()
+    private var _started = false
+
+    /** Starts monitoring the condition. */
+    protected abstract fun start()
+
+    /** Stops monitoring the condition. */
+    protected abstract fun stop()
+
+    @Retention(AnnotationRetention.SOURCE)
+    @IntDef(START_EAGERLY, START_LAZILY, START_WHEN_NEEDED)
+    annotation class StartStrategy
+
+    @get:StartStrategy abstract val startStrategy: Int
+
+    /**
+     * Registers a callback to receive updates once started. This should be called before [.start].
+     * Also triggers the callback immediately if already started.
+     */
+    fun addCallback(callback: Callback) {
+        if (shouldLog()) Log.d(mTag, "adding callback")
+        _callbacks.add(WeakReference(callback))
+
+        if (_started) {
+            callback.onConditionChanged(this)
+            return
+        }
+
+        start()
+        _started = true
+    }
+
+    /** Removes the provided callback from further receiving updates. */
+    fun removeCallback(callback: Callback) {
+        if (shouldLog()) Log.d(mTag, "removing callback")
+        val iterator = _callbacks.iterator()
+        while (iterator.hasNext()) {
+            val cb = iterator.next().get()
+            if (cb == null || cb === callback) {
+                iterator.remove()
+            }
+        }
+
+        if (_callbacks.isNotEmpty() || !_started) {
+            return
+        }
+
+        stop()
+        _started = false
+    }
+
+    /**
+     * Wrapper to [.addCallback] when a lifecycle is in the resumed state and [.removeCallback] when
+     * not resumed automatically.
+     */
+    fun observe(owner: LifecycleOwner, listener: Callback): Callback {
+        return observe(owner.lifecycle, listener)
+    }
+
+    /**
+     * Wrapper to [.addCallback] when a lifecycle is in the resumed state and [.removeCallback] when
+     * not resumed automatically.
+     */
+    fun observe(lifecycle: Lifecycle, listener: Callback): Callback {
+        lifecycle.addObserver(
+            LifecycleEventObserver { lifecycleOwner: LifecycleOwner?, event: Lifecycle.Event ->
+                if (event == Lifecycle.Event.ON_RESUME) {
+                    addCallback(listener)
+                } else if (event == Lifecycle.Event.ON_PAUSE) {
+                    removeCallback(listener)
+                }
+            }
+        )
+        return listener
+    }
+
+    /**
+     * Updates the value for whether the condition has been fulfilled, and sends an update if the
+     * value changes and any callback is registered.
+     *
+     * @param isConditionMet True if the condition has been fulfilled. False otherwise.
+     */
+    protected fun updateCondition(isConditionMet: Boolean) {
+        if (_isConditionMet != null && _isConditionMet == isConditionMet) {
+            return
+        }
+
+        if (shouldLog()) Log.d(mTag, "updating condition to $isConditionMet")
+        _isConditionMet = isConditionMet
+        sendUpdate()
+    }
+
+    /**
+     * Clears the set condition value. This is purposefully separate from [.updateCondition] to
+     * avoid confusion around `null` values.
+     */
+    fun clearCondition() {
+        if (_isConditionMet == null) {
+            return
+        }
+
+        if (shouldLog()) Log.d(mTag, "clearing condition")
+
+        _isConditionMet = null
+        sendUpdate()
+    }
+
+    private fun sendUpdate() {
+        val iterator = _callbacks.iterator()
+        while (iterator.hasNext()) {
+            val cb = iterator.next().get()
+            if (cb == null) {
+                iterator.remove()
+            } else {
+                cb.onConditionChanged(this)
+            }
+        }
+    }
+
+    val isConditionSet: Boolean
+        /**
+         * Returns whether the condition is set. This method should be consulted to understand the
+         * value of [.isConditionMet].
+         *
+         * @return `true` if value is present, `false` otherwise.
+         */
+        get() = _isConditionMet != null
+
+    val isConditionMet: Boolean
+        /**
+         * Returns whether the condition has been met. Note that this method will return `false` if
+         * the condition is not set as well.
+         */
+        get() = true == _isConditionMet
+
+    protected fun shouldLog(): Boolean {
+        return Log.isLoggable(mTag, Log.DEBUG)
+    }
+
+    val tag: String
+        get() {
+            if (isOverridingCondition) {
+                return "$mTag[OVRD]"
+            }
+
+            return mTag
+        }
+
+    val state: String
+        /**
+         * Returns the state of the condition.
+         * - "Invalid", condition hasn't been set / not monitored
+         * - "True", condition has been met
+         * - "False", condition has not been met
+         */
+        get() {
+            if (!isConditionSet) {
+                return "Invalid"
+            }
+            return if (isConditionMet) "True" else "False"
+        }
+
+    /**
+     * Creates a new condition which will only be true when both this condition and all the provided
+     * conditions are true.
+     */
+    fun and(others: Collection<Condition>): Condition {
+        val conditions: List<Condition> = listOf(this, *others.toTypedArray())
+        return CombinedCondition(_scope, conditions, Evaluator.OP_AND)
+    }
+
+    /**
+     * Creates a new condition which will only be true when both this condition and the provided
+     * condition is true.
+     */
+    fun and(vararg others: Condition): Condition {
+        return and(listOf(*others))
+    }
+
+    /**
+     * Creates a new condition which will only be true when either this condition or any of the
+     * provided conditions are true.
+     */
+    fun or(others: Collection<Condition>): Condition {
+        val conditions: MutableList<Condition> = ArrayList()
+        conditions.add(this)
+        conditions.addAll(others)
+        return CombinedCondition(_scope, conditions, Evaluator.OP_OR)
+    }
+
+    /**
+     * Creates a new condition which will only be true when either this condition or the provided
+     * condition is true.
+     */
+    fun or(vararg others: Condition): Condition {
+        return or(listOf(*others))
+    }
+
+    /** Callback that receives updates about whether the condition has been fulfilled. */
+    fun interface Callback {
+        /**
+         * Called when the fulfillment of the condition changes.
+         *
+         * @param condition The condition in question.
+         */
+        fun onConditionChanged(condition: Condition)
+    }
+
+    companion object {
+        /** Condition should be started as soon as there is an active subscription. */
+        const val START_EAGERLY: Int = 0
+
+        /**
+         * Condition should be started lazily only if needed. But once started, it will not be
+         * cancelled unless there are no more active subscriptions.
+         */
+        const val START_LAZILY: Int = 1
+
+        /**
+         * Condition should be started lazily only if needed, and can be stopped when not needed.
+         * This should be used for conditions which are expensive to keep running.
+         */
+        const val START_WHEN_NEEDED: Int = 2
+    }
+}
diff --git a/packages/SystemUI/shared/src/com/android/systemui/shared/condition/ConditionExtensions.kt b/packages/SystemUI/shared/src/com/android/systemui/shared/condition/ConditionExtensions.kt
index 84edc3577007..0f535cdfa5cc 100644
--- a/packages/SystemUI/shared/src/com/android/systemui/shared/condition/ConditionExtensions.kt
+++ b/packages/SystemUI/shared/src/com/android/systemui/shared/condition/ConditionExtensions.kt
@@ -14,7 +14,7 @@ import kotlinx.coroutines.launch
 fun Flow<Boolean>.toCondition(
     scope: CoroutineScope,
     @StartStrategy strategy: Int,
-    initialValue: Boolean? = null
+    initialValue: Boolean? = null,
 ): Condition {
     return object : Condition(scope, initialValue, false) {
         var job: Job? = null
@@ -28,7 +28,8 @@ fun Flow<Boolean>.toCondition(
             job = null
         }
 
-        override fun getStartStrategy() = strategy
+        override val startStrategy: Int
+            get() = strategy
     }
 }
 
@@ -36,13 +37,16 @@ fun Flow<Boolean>.toCondition(
 fun Condition.toFlow(): Flow<Boolean?> {
     return callbackFlow {
             val callback =
-                Condition.Callback { condition ->
-                    if (condition.isConditionSet) {
-                        trySend(condition.isConditionMet)
-                    } else {
-                        trySend(null)
+                object : Condition.Callback {
+                    override fun onConditionChanged(condition: Condition) {
+                        if (condition.isConditionSet) {
+                            trySend(condition.isConditionMet)
+                        } else {
+                            trySend(null)
+                        }
                     }
                 }
+
             addCallback(callback)
             callback.onConditionChanged(this@toFlow)
             awaitClose { removeCallback(callback) }
diff --git a/packages/SystemUI/src/com/android/systemui/communal/DeviceInactiveCondition.java b/packages/SystemUI/src/com/android/systemui/communal/DeviceInactiveCondition.java
index e456310febfd..4be9601f4277 100644
--- a/packages/SystemUI/src/com/android/systemui/communal/DeviceInactiveCondition.java
+++ b/packages/SystemUI/src/com/android/systemui/communal/DeviceInactiveCondition.java
@@ -102,7 +102,7 @@ public class DeviceInactiveCondition extends Condition {
     }
 
     @Override
-    protected int getStartStrategy() {
+    public int getStartStrategy() {
         return START_EAGERLY;
     }
 
diff --git a/packages/SystemUI/src/com/android/systemui/dreams/conditions/AssistantAttentionCondition.java b/packages/SystemUI/src/com/android/systemui/dreams/conditions/AssistantAttentionCondition.java
index d81949d08a66..c17094b7456c 100644
--- a/packages/SystemUI/src/com/android/systemui/dreams/conditions/AssistantAttentionCondition.java
+++ b/packages/SystemUI/src/com/android/systemui/dreams/conditions/AssistantAttentionCondition.java
@@ -63,7 +63,7 @@ public class AssistantAttentionCondition extends Condition {
     }
 
     @Override
-    protected int getStartStrategy() {
+    public int getStartStrategy() {
         return START_EAGERLY;
     }
 }
diff --git a/packages/SystemUI/src/com/android/systemui/dreams/conditions/DreamCondition.java b/packages/SystemUI/src/com/android/systemui/dreams/conditions/DreamCondition.java
index c7fe1e1e754b..fb4ed1419688 100644
--- a/packages/SystemUI/src/com/android/systemui/dreams/conditions/DreamCondition.java
+++ b/packages/SystemUI/src/com/android/systemui/dreams/conditions/DreamCondition.java
@@ -63,7 +63,7 @@ public class DreamCondition extends Condition {
     }
 
     @Override
-    protected int getStartStrategy() {
+    public int getStartStrategy() {
         return START_EAGERLY;
     }
 }
diff --git a/packages/SystemUI/src/com/android/systemui/lowlightclock/DirectBootCondition.kt b/packages/SystemUI/src/com/android/systemui/lowlightclock/DirectBootCondition.kt
index 4c1da0198498..57d709835b2c 100644
--- a/packages/SystemUI/src/com/android/systemui/lowlightclock/DirectBootCondition.kt
+++ b/packages/SystemUI/src/com/android/systemui/lowlightclock/DirectBootCondition.kt
@@ -54,7 +54,6 @@ constructor(
         job?.cancel()
     }
 
-    override fun getStartStrategy(): Int {
-        return START_EAGERLY
-    }
+    override val startStrategy: Int
+        get() = START_EAGERLY
 }
diff --git a/packages/SystemUI/src/com/android/systemui/lowlightclock/ForceLowLightCondition.java b/packages/SystemUI/src/com/android/systemui/lowlightclock/ForceLowLightCondition.java
index 7f21d0707f63..5ec81a9a94a1 100644
--- a/packages/SystemUI/src/com/android/systemui/lowlightclock/ForceLowLightCondition.java
+++ b/packages/SystemUI/src/com/android/systemui/lowlightclock/ForceLowLightCondition.java
@@ -131,7 +131,7 @@ public class ForceLowLightCondition extends Condition {
     }
 
     @Override
-    protected int getStartStrategy() {
+    public int getStartStrategy() {
         return START_EAGERLY;
     }
 }
diff --git a/packages/SystemUI/src/com/android/systemui/lowlightclock/LowLightCondition.java b/packages/SystemUI/src/com/android/systemui/lowlightclock/LowLightCondition.java
index e91be5028777..c1a24e7e020e 100644
--- a/packages/SystemUI/src/com/android/systemui/lowlightclock/LowLightCondition.java
+++ b/packages/SystemUI/src/com/android/systemui/lowlightclock/LowLightCondition.java
@@ -54,7 +54,7 @@ public class LowLightCondition extends Condition {
     }
 
     @Override
-    protected int getStartStrategy() {
+    public int getStartStrategy() {
         // As this condition keeps the lowlight sensor active, it should only run when needed.
         return START_WHEN_NEEDED;
     }
diff --git a/packages/SystemUI/src/com/android/systemui/lowlightclock/ScreenSaverEnabledCondition.java b/packages/SystemUI/src/com/android/systemui/lowlightclock/ScreenSaverEnabledCondition.java
index fd6ce1762a28..81572554cb86 100644
--- a/packages/SystemUI/src/com/android/systemui/lowlightclock/ScreenSaverEnabledCondition.java
+++ b/packages/SystemUI/src/com/android/systemui/lowlightclock/ScreenSaverEnabledCondition.java
@@ -70,7 +70,7 @@ public class ScreenSaverEnabledCondition extends Condition {
     }
 
     @Override
-    protected int getStartStrategy() {
+    public int getStartStrategy() {
         return START_EAGERLY;
     }
 
diff --git a/packages/SystemUI/src/com/android/systemui/process/condition/SystemProcessCondition.java b/packages/SystemUI/src/com/android/systemui/process/condition/SystemProcessCondition.java
index 694b525e7bc1..ea2bf6a44884 100644
--- a/packages/SystemUI/src/com/android/systemui/process/condition/SystemProcessCondition.java
+++ b/packages/SystemUI/src/com/android/systemui/process/condition/SystemProcessCondition.java
@@ -48,7 +48,7 @@ public class SystemProcessCondition extends Condition {
     }
 
     @Override
-    protected int getStartStrategy() {
+    public int getStartStrategy() {
         return START_EAGERLY;
     }
 }
diff --git a/packages/SystemUI/tests/src/com/android/systemui/shared/condition/CombinedConditionTest.kt b/packages/SystemUI/tests/src/com/android/systemui/shared/condition/CombinedConditionTest.kt
index 8418598c256b..116a2caa6dda 100644
--- a/packages/SystemUI/tests/src/com/android/systemui/shared/condition/CombinedConditionTest.kt
+++ b/packages/SystemUI/tests/src/com/android/systemui/shared/condition/CombinedConditionTest.kt
@@ -19,9 +19,9 @@ package com.android.systemui.shared.condition
 import androidx.test.ext.junit.runners.AndroidJUnit4
 import androidx.test.filters.SmallTest
 import com.android.systemui.SysuiTestCase
-import com.android.systemui.shared.condition.Condition.START_EAGERLY
-import com.android.systemui.shared.condition.Condition.START_LAZILY
-import com.android.systemui.shared.condition.Condition.START_WHEN_NEEDED
+import com.android.systemui.shared.condition.Condition.Companion.START_EAGERLY
+import com.android.systemui.shared.condition.Condition.Companion.START_LAZILY
+import com.android.systemui.shared.condition.Condition.Companion.START_WHEN_NEEDED
 import com.google.common.truth.Truth.assertThat
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
@@ -40,7 +40,7 @@ class CombinedConditionTest : SysuiTestCase() {
         scope: CoroutineScope,
         initialValue: Boolean?,
         overriding: Boolean = false,
-        @StartStrategy private val startStrategy: Int = START_WHEN_NEEDED,
+        @StartStrategy override val startStrategy: Int = START_WHEN_NEEDED,
     ) : Condition(scope, initialValue, overriding) {
         private var _started = false
         val started: Boolean
@@ -54,10 +54,6 @@ class CombinedConditionTest : SysuiTestCase() {
             _started = false
         }
 
-        override fun getStartStrategy(): Int {
-            return startStrategy
-        }
-
         fun setValue(value: Boolean?) {
             value?.also { updateCondition(value) } ?: clearCondition()
         }
@@ -75,13 +71,8 @@ class CombinedConditionTest : SysuiTestCase() {
         val combinedCondition =
             CombinedCondition(
                 scope = this,
-                conditions =
-                    listOf(
-                        eagerCondition,
-                        lazyCondition,
-                        startWhenNeededCondition,
-                    ),
-                operand = Evaluator.OP_OR
+                conditions = listOf(eagerCondition, lazyCondition, startWhenNeededCondition),
+                operand = Evaluator.OP_OR,
             )
 
         val callback = Condition.Callback {}
@@ -124,13 +115,8 @@ class CombinedConditionTest : SysuiTestCase() {
         val combinedCondition =
             CombinedCondition(
                 scope = this,
-                conditions =
-                    listOf(
-                        startWhenNeededCondition,
-                        lazyCondition,
-                        eagerCondition,
-                    ),
-                operand = Evaluator.OP_AND
+                conditions = listOf(startWhenNeededCondition, lazyCondition, eagerCondition),
+                operand = Evaluator.OP_AND,
             )
 
         val callback = Condition.Callback {}
@@ -175,7 +161,7 @@ class CombinedConditionTest : SysuiTestCase() {
                     FakeCondition(
                         scope = this,
                         initialValue = false,
-                        startStrategy = START_WHEN_NEEDED
+                        startStrategy = START_WHEN_NEEDED,
                     )
                 }
                 .toList()
@@ -214,7 +200,7 @@ class CombinedConditionTest : SysuiTestCase() {
                     FakeCondition(
                         scope = this,
                         initialValue = false,
-                        startStrategy = START_WHEN_NEEDED
+                        startStrategy = START_WHEN_NEEDED,
                     )
                 }
                 .toList()
@@ -262,7 +248,7 @@ class CombinedConditionTest : SysuiTestCase() {
                     FakeCondition(
                         scope = this,
                         initialValue = false,
-                        startStrategy = START_WHEN_NEEDED
+                        startStrategy = START_WHEN_NEEDED,
                     )
                 }
                 .toList()
@@ -300,9 +286,9 @@ class CombinedConditionTest : SysuiTestCase() {
                         overridingCondition1,
                         lazyCondition,
                         startWhenNeededCondition,
-                        overridingCondition2
+                        overridingCondition2,
                     ),
-                operand = Evaluator.OP_OR
+                operand = Evaluator.OP_OR,
             )
 
         val callback = Condition.Callback {}
@@ -414,11 +400,7 @@ class CombinedConditionTest : SysuiTestCase() {
     fun testEmptyConditions() = runSelfCancelingTest {
         for (operand in intArrayOf(Evaluator.OP_OR, Evaluator.OP_AND)) {
             val combinedCondition =
-                CombinedCondition(
-                    scope = this,
-                    conditions = emptyList(),
-                    operand = operand,
-                )
+                CombinedCondition(scope = this, conditions = emptyList(), operand = operand)
 
             val callback = Condition.Callback {}
             combinedCondition.addCallback(callback)
@@ -435,9 +417,7 @@ class CombinedConditionTest : SysuiTestCase() {
      * Executes the given block of execution within the scope of a dedicated [CoroutineScope] which
      * is then automatically canceled and cleaned-up.
      */
-    private fun runSelfCancelingTest(
-        block: suspend CoroutineScope.() -> Unit,
-    ) =
+    private fun runSelfCancelingTest(block: suspend CoroutineScope.() -> Unit) =
         runBlocking(IMMEDIATE) {
             val scope = CoroutineScope(coroutineContext + Job())
             block(scope)