diff options
30 files changed, 2832 insertions, 4 deletions
diff --git a/packages/SystemUI/AndroidManifest.xml b/packages/SystemUI/AndroidManifest.xml index 6491bf5c8f5b..72ae76a45cac 100644 --- a/packages/SystemUI/AndroidManifest.xml +++ b/packages/SystemUI/AndroidManifest.xml @@ -1171,5 +1171,16 @@ android:exported="false" /> + <service + android:name="com.google.android.systemui.lowlightclock.LowLightClockDreamService" + android:enabled="false" + android:exported="false" + android:directBootAware="true" + android:permission="android.permission.BIND_DREAM_SERVICE"> + <intent-filter> + <action android:name="android.service.dreams.DreamService" /> + <category android:name="android.intent.category.DEFAULT" /> + </intent-filter> + </service> </application> </manifest> diff --git a/packages/SystemUI/res/layout/low_light_clock_dream.xml b/packages/SystemUI/res/layout/low_light_clock_dream.xml new file mode 100644 index 000000000000..3d74a9fd8ae3 --- /dev/null +++ b/packages/SystemUI/res/layout/low_light_clock_dream.xml @@ -0,0 +1,39 @@ +<?xml version="1.0" encoding="utf-8"?> +<FrameLayout + xmlns:android="http://schemas.android.com/apk/res/android" + android:id="@+id/low_light_clock_dream" + android:layout_width="match_parent" + android:layout_height="match_parent" + android:background="@color/low_light_clock_background_color"> + + <TextClock + android:id="@+id/low_light_text_clock" + android:layout_width="match_parent" + android:layout_height="@dimen/low_light_clock_text_size" + android:layout_gravity="center" + android:fontFamily="google-sans-clock" + android:gravity="center_horizontal" + android:textColor="@color/low_light_clock_text_color" + android:autoSizeTextType="uniform" + android:autoSizeMaxTextSize="@dimen/low_light_clock_text_size" + android:format12Hour="h:mm" + android:format24Hour="H:mm"/> + + <TextView + android:id="@+id/charging_status_text_view" + android:layout_width="wrap_content" + android:layout_height="wrap_content" + android:layout_marginBottom="@dimen/keyguard_indication_margin_bottom" + android:gravity="center" + android:minHeight="@dimen/low_light_clock_charging_text_min_height" + android:layout_gravity="center_horizontal|bottom" + android:paddingStart="@dimen/keyguard_indication_text_padding" + android:paddingEnd="@dimen/keyguard_indication_text_padding" + android:textAppearance="@style/TextAppearance.Keyguard.BottomArea" + android:textSize="@dimen/low_light_clock_charging_text_size" + android:textFontWeight="@integer/low_light_clock_charging_text_font_weight" + android:maxLines="2" + android:ellipsize="end" + android:accessibilityLiveRegion="polite" /> + </FrameLayout> + diff --git a/packages/SystemUI/res/values/colors.xml b/packages/SystemUI/res/values/colors.xml index 36ede64f91d9..db8bbdb534a0 100644 --- a/packages/SystemUI/res/values/colors.xml +++ b/packages/SystemUI/res/values/colors.xml @@ -260,4 +260,8 @@ <!-- Rear Display Education --> <color name="rear_display_overlay_animation_background_color">#1E1B17</color> <color name="rear_display_overlay_dialog_background_color">#1E1B17</color> + + <!-- Low light Dream --> + <color name="low_light_clock_background_color">#000000</color> + <color name="low_light_clock_text_color">#CCCCCC</color> </resources> diff --git a/packages/SystemUI/res/values/dimens.xml b/packages/SystemUI/res/values/dimens.xml index 724a12c12490..c7f037f3d619 100644 --- a/packages/SystemUI/res/values/dimens.xml +++ b/packages/SystemUI/res/values/dimens.xml @@ -1614,6 +1614,18 @@ <!-- GLANCEABLE_HUB -> DREAMING transition: Amount to shift dream overlay on entering --> <dimen name="hub_to_dreaming_transition_dream_overlay_translation_x">824dp</dimen> + <!-- Low light clock --> + <!-- The text size of the low light clock is intentionally defined in dp to avoid scaling --> + <dimen name="low_light_clock_text_size">260dp</dimen> + <dimen name="low_light_clock_charging_text_size">14sp</dimen> + <dimen name="low_light_clock_charging_text_min_height">48dp</dimen> + <integer name="low_light_clock_charging_text_font_weight">500</integer> + + <dimen name="low_light_clock_translate_animation_offset">40dp</dimen> + <integer name="low_light_clock_translate_animation_duration_ms">1167</integer> + <integer name="low_light_clock_alpha_animation_in_start_delay_ms">233</integer> + <integer name="low_light_clock_alpha_animation_duration_ms">250</integer> + <!-- Distance that the full shade transition takes in order for media to fully transition to the shade --> <dimen name="lockscreen_shade_media_transition_distance">120dp</dimen> diff --git a/packages/SystemUI/src/com/android/systemui/communal/DeviceInactiveCondition.java b/packages/SystemUI/src/com/android/systemui/communal/DeviceInactiveCondition.java new file mode 100644 index 000000000000..2e1b5ad177b5 --- /dev/null +++ b/packages/SystemUI/src/com/android/systemui/communal/DeviceInactiveCondition.java @@ -0,0 +1,101 @@ +/* + * 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.systemui.communal; + +import static com.android.systemui.keyguard.WakefulnessLifecycle.WAKEFULNESS_ASLEEP; +import static com.android.systemui.keyguard.WakefulnessLifecycle.WAKEFULNESS_GOING_TO_SLEEP; + +import com.android.keyguard.KeyguardUpdateMonitor; +import com.android.keyguard.KeyguardUpdateMonitorCallback; +import com.android.systemui.dagger.qualifiers.Application; +import com.android.systemui.keyguard.WakefulnessLifecycle; +import com.android.systemui.shared.condition.Condition; +import com.android.systemui.statusbar.policy.KeyguardStateController; + +import kotlinx.coroutines.CoroutineScope; + +import javax.inject.Inject; + +/** + * Condition which estimates device inactivity in order to avoid launching a full-screen activity + * while the user is actively using the device. + */ +public class DeviceInactiveCondition extends Condition { + private final KeyguardStateController mKeyguardStateController; + private final WakefulnessLifecycle mWakefulnessLifecycle; + private final KeyguardUpdateMonitor mKeyguardUpdateMonitor; + private final KeyguardStateController.Callback mKeyguardStateCallback = + new KeyguardStateController.Callback() { + @Override + public void onKeyguardShowingChanged() { + updateState(); + } + }; + private final WakefulnessLifecycle.Observer mWakefulnessObserver = + new WakefulnessLifecycle.Observer() { + @Override + public void onStartedGoingToSleep() { + updateState(); + } + }; + private final KeyguardUpdateMonitorCallback mKeyguardUpdateCallback = + new KeyguardUpdateMonitorCallback() { + @Override + public void onDreamingStateChanged(boolean dreaming) { + updateState(); + } + }; + + @Inject + public DeviceInactiveCondition(@Application CoroutineScope scope, + KeyguardStateController keyguardStateController, + WakefulnessLifecycle wakefulnessLifecycle, + KeyguardUpdateMonitor keyguardUpdateMonitor) { + super(scope); + mKeyguardStateController = keyguardStateController; + mWakefulnessLifecycle = wakefulnessLifecycle; + mKeyguardUpdateMonitor = keyguardUpdateMonitor; + } + + @Override + protected void start() { + updateState(); + mKeyguardStateController.addCallback(mKeyguardStateCallback); + mKeyguardUpdateMonitor.registerCallback(mKeyguardUpdateCallback); + mWakefulnessLifecycle.addObserver(mWakefulnessObserver); + } + + @Override + protected void stop() { + mKeyguardStateController.removeCallback(mKeyguardStateCallback); + mKeyguardUpdateMonitor.removeCallback(mKeyguardUpdateCallback); + mWakefulnessLifecycle.removeObserver(mWakefulnessObserver); + } + + @Override + protected int getStartStrategy() { + return START_EAGERLY; + } + + private void updateState() { + final boolean asleep = + mWakefulnessLifecycle.getWakefulness() == WAKEFULNESS_ASLEEP + || mWakefulnessLifecycle.getWakefulness() == WAKEFULNESS_GOING_TO_SLEEP; + updateCondition(asleep || mKeyguardStateController.isShowing() + || mKeyguardUpdateMonitor.isDreaming()); + } +} diff --git a/packages/SystemUI/src/com/android/systemui/dagger/SystemUIModule.java b/packages/SystemUI/src/com/android/systemui/dagger/SystemUIModule.java index c02784dfab1b..fe5a82cb5b8c 100644 --- a/packages/SystemUI/src/com/android/systemui/dagger/SystemUIModule.java +++ b/packages/SystemUI/src/com/android/systemui/dagger/SystemUIModule.java @@ -81,6 +81,7 @@ import com.android.systemui.keyguard.ui.composable.LockscreenContent; import com.android.systemui.log.dagger.LogModule; import com.android.systemui.log.dagger.MonitorLog; import com.android.systemui.log.table.TableLogBuffer; +import com.android.systemui.lowlightclock.dagger.LowLightModule; import com.android.systemui.mediaprojection.MediaProjectionModule; import com.android.systemui.mediaprojection.appselector.MediaProjectionActivitiesModule; import com.android.systemui.mediaprojection.taskswitcher.MediaProjectionTaskSwitcherModule; @@ -285,7 +286,8 @@ import javax.inject.Named; UserModule.class, UtilModule.class, NoteTaskModule.class, - WalletModule.class + WalletModule.class, + LowLightModule.class }, subcomponents = { ComplicationComponent.class, diff --git a/packages/SystemUI/src/com/android/systemui/dreams/dagger/DreamModule.java b/packages/SystemUI/src/com/android/systemui/dreams/dagger/DreamModule.java index faab31eff4f7..15f73ee0eda6 100644 --- a/packages/SystemUI/src/com/android/systemui/dreams/dagger/DreamModule.java +++ b/packages/SystemUI/src/com/android/systemui/dreams/dagger/DreamModule.java @@ -48,6 +48,8 @@ import com.android.systemui.qs.tiles.viewmodel.QSTileUIConfig; import com.android.systemui.res.R; import com.android.systemui.touch.TouchInsetManager; +import com.google.android.systemui.lowlightclock.LowLightClockDreamService; + import dagger.Binds; import dagger.BindsOptionalOf; import dagger.Module; @@ -238,15 +240,24 @@ public interface DreamModule { ComponentName bindsLowLightClockDream(); /** + * Provides low light clock dream service component. + */ + @Provides + @Named(LOW_LIGHT_CLOCK_DREAM) + static ComponentName providesLowLightClockDream(Context context) { + return new ComponentName(context, LowLightClockDreamService.class); + } + + /** * Provides the component name of the low light dream, or null if not configured. */ @Provides @Nullable @Named(LOW_LIGHT_DREAM_SERVICE) static ComponentName providesLowLightDreamService(Context context, - @Named(LOW_LIGHT_CLOCK_DREAM) Optional<ComponentName> clockDream) { - if (Flags.lowLightClockDream() && clockDream.isPresent()) { - return clockDream.get(); + @Named(LOW_LIGHT_CLOCK_DREAM) ComponentName clockDream) { + if (Flags.lowLightClockDream()) { + return clockDream; } String lowLightDreamComponent = context.getResources().getString( diff --git a/packages/SystemUI/src/com/android/systemui/lowlightclock/AmbientLightModeMonitor.kt b/packages/SystemUI/src/com/android/systemui/lowlightclock/AmbientLightModeMonitor.kt new file mode 100644 index 000000000000..ece97bd27df7 --- /dev/null +++ b/packages/SystemUI/src/com/android/systemui/lowlightclock/AmbientLightModeMonitor.kt @@ -0,0 +1,137 @@ +/* + * 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.systemui.lowlightclock + +import android.annotation.IntDef +import android.hardware.Sensor +import android.hardware.SensorEvent +import android.hardware.SensorEventListener +import android.hardware.SensorManager +import android.util.Log +import com.android.systemui.Dumpable +import com.android.systemui.lowlightclock.dagger.LowLightModule.LIGHT_SENSOR +import com.android.systemui.util.sensors.AsyncSensorManager +import java.io.PrintWriter +import java.util.Optional +import javax.inject.Inject +import javax.inject.Named + +/** + * Monitors ambient light signals, applies a debouncing algorithm, and produces the current ambient + * light mode. + * + * @property algorithm the debounce algorithm which transforms light sensor events into an ambient + * light mode. + * @property sensorManager the sensor manager used to register sensor event updates. + */ +class AmbientLightModeMonitor +@Inject +constructor( + private val algorithm: Optional<DebounceAlgorithm>, + private val sensorManager: AsyncSensorManager, + @Named(LIGHT_SENSOR) private val lightSensor: Optional<Sensor>, +) : Dumpable { + companion object { + private const val TAG = "AmbientLightModeMonitor" + private val DEBUG = Log.isLoggable(TAG, Log.DEBUG) + + const val AMBIENT_LIGHT_MODE_LIGHT = 0 + const val AMBIENT_LIGHT_MODE_DARK = 1 + const val AMBIENT_LIGHT_MODE_UNDECIDED = 2 + } + + // Represents all ambient light modes. + @Retention(AnnotationRetention.SOURCE) + @IntDef(AMBIENT_LIGHT_MODE_LIGHT, AMBIENT_LIGHT_MODE_DARK, AMBIENT_LIGHT_MODE_UNDECIDED) + annotation class AmbientLightMode + + /** + * Start monitoring the current ambient light mode. + * + * @param callback callback that gets triggered when the ambient light mode changes. + */ + fun start(callback: Callback) { + if (DEBUG) Log.d(TAG, "start monitoring ambient light mode") + + if (lightSensor.isEmpty) { + if (DEBUG) Log.w(TAG, "light sensor not available") + return + } + + if (algorithm.isEmpty) { + if (DEBUG) Log.w(TAG, "debounce algorithm not available") + return + } + + algorithm.get().start(callback) + sensorManager.registerListener( + mSensorEventListener, + lightSensor.get(), + SensorManager.SENSOR_DELAY_NORMAL, + ) + } + + /** Stop monitoring the current ambient light mode. */ + fun stop() { + if (DEBUG) Log.d(TAG, "stop monitoring ambient light mode") + + if (algorithm.isPresent) { + algorithm.get().stop() + } + sensorManager.unregisterListener(mSensorEventListener) + } + + override fun dump(pw: PrintWriter, args: Array<out String>) { + pw.println() + pw.println("Ambient light mode monitor:") + pw.println(" lightSensor=$lightSensor") + pw.println() + } + + private val mSensorEventListener: SensorEventListener = + object : SensorEventListener { + override fun onSensorChanged(event: SensorEvent) { + if (event.values.isEmpty()) { + if (DEBUG) Log.w(TAG, "SensorEvent doesn't have any value") + return + } + + if (algorithm.isPresent) { + algorithm.get().onUpdateLightSensorEvent(event.values[0]) + } + } + + override fun onAccuracyChanged(sensor: Sensor, accuracy: Int) { + // Do nothing. + } + } + + /** Interface of the ambient light mode callback, which gets triggered when the mode changes. */ + interface Callback { + fun onChange(@AmbientLightMode mode: Int) + } + + /** Interface of the algorithm that transforms light sensor events to an ambient light mode. */ + interface DebounceAlgorithm { + // Setting Callback to nullable so mockito can verify without throwing NullPointerException. + fun start(callback: Callback?) + + fun stop() + + fun onUpdateLightSensorEvent(value: Float) + } +} diff --git a/packages/SystemUI/src/com/android/systemui/lowlightclock/ChargingStatusProvider.java b/packages/SystemUI/src/com/android/systemui/lowlightclock/ChargingStatusProvider.java new file mode 100644 index 000000000000..8cc399b0a22b --- /dev/null +++ b/packages/SystemUI/src/com/android/systemui/lowlightclock/ChargingStatusProvider.java @@ -0,0 +1,258 @@ +/* + * 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.systemui.lowlightclock; + +import android.content.Context; +import android.content.res.Resources; +import android.os.BatteryManager; +import android.os.RemoteException; +import android.text.format.Formatter; +import android.util.Log; + +import com.android.internal.app.IBatteryStats; +import com.android.internal.util.Preconditions; +import com.android.keyguard.KeyguardUpdateMonitor; +import com.android.keyguard.KeyguardUpdateMonitorCallback; +import com.android.settingslib.fuelgauge.BatteryStatus; +import com.android.systemui.dagger.qualifiers.Main; +import com.android.systemui.res.R; + +import java.text.NumberFormat; + +import javax.inject.Inject; + +/** + * Provides charging status as a string to a registered callback such that it can be displayed to + * the user (e.g. on the low-light clock). + * TODO(b/223681352): Make this code shareable with {@link KeyguardIndicationController}. + */ +public class ChargingStatusProvider { + private static final String TAG = "ChargingStatusProvider"; + + private final Resources mResources; + private final Context mContext; + private final IBatteryStats mBatteryInfo; + private final KeyguardUpdateMonitor mKeyguardUpdateMonitor; + private final BatteryState mBatteryState = new BatteryState(); + // This callback is registered with KeyguardUpdateMonitor, which only keeps weak references to + // its callbacks. Therefore, an explicit reference needs to be kept here to avoid the + // callback being GC'd. + private ChargingStatusCallback mChargingStatusCallback; + + private Callback mCallback; + + @Inject + public ChargingStatusProvider( + Context context, + @Main Resources resources, + IBatteryStats iBatteryStats, + KeyguardUpdateMonitor keyguardUpdateMonitor) { + mContext = context; + mResources = resources; + mBatteryInfo = iBatteryStats; + mKeyguardUpdateMonitor = keyguardUpdateMonitor; + } + + /** + * Start using the {@link ChargingStatusProvider}. + * @param callback A callback to be called when the charging status changes. + */ + public void startUsing(Callback callback) { + Preconditions.checkState( + mCallback == null, "ChargingStatusProvider already started!"); + mCallback = callback; + mChargingStatusCallback = new ChargingStatusCallback(); + mKeyguardUpdateMonitor.registerCallback(mChargingStatusCallback); + reportStatusToCallback(); + } + + /** + * Stop using the {@link ChargingStatusProvider}. + */ + public void stopUsing() { + mCallback = null; + + if (mChargingStatusCallback != null) { + mKeyguardUpdateMonitor.removeCallback(mChargingStatusCallback); + mChargingStatusCallback = null; + } + } + + private String computeChargingString() { + if (!mBatteryState.isValid()) { + return null; + } + + int chargingId; + + if (mBatteryState.isBatteryDefender()) { + return mResources.getString( + R.string.keyguard_plugged_in_charging_limited, + mBatteryState.getBatteryLevelAsPercentage()); + } else if (mBatteryState.isPowerCharged()) { + return mResources.getString(R.string.keyguard_charged); + } + + final long chargingTimeRemaining = mBatteryState.getChargingTimeRemaining(mBatteryInfo); + final boolean hasChargingTime = chargingTimeRemaining > 0; + if (mBatteryState.isPowerPluggedInWired()) { + switch (mBatteryState.getChargingSpeed(mContext)) { + case BatteryStatus.CHARGING_FAST: + chargingId = hasChargingTime + ? R.string.keyguard_indication_charging_time_fast + : R.string.keyguard_plugged_in_charging_fast; + break; + case BatteryStatus.CHARGING_SLOWLY: + chargingId = hasChargingTime + ? R.string.keyguard_indication_charging_time_slowly + : R.string.keyguard_plugged_in_charging_slowly; + break; + default: + chargingId = hasChargingTime + ? R.string.keyguard_indication_charging_time + : R.string.keyguard_plugged_in; + break; + } + } else if (mBatteryState.isPowerPluggedInWireless()) { + chargingId = hasChargingTime + ? R.string.keyguard_indication_charging_time_wireless + : R.string.keyguard_plugged_in_wireless; + } else if (mBatteryState.isPowerPluggedInDocked()) { + chargingId = hasChargingTime + ? R.string.keyguard_indication_charging_time_dock + : R.string.keyguard_plugged_in_dock; + } else { + chargingId = hasChargingTime + ? R.string.keyguard_indication_charging_time + : R.string.keyguard_plugged_in; + } + + final String percentage = mBatteryState.getBatteryLevelAsPercentage(); + if (hasChargingTime) { + final String chargingTimeFormatted = + Formatter.formatShortElapsedTimeRoundingUpToMinutes( + mContext, chargingTimeRemaining); + return mResources.getString(chargingId, chargingTimeFormatted, + percentage); + } else { + return mResources.getString(chargingId, percentage); + } + } + + private void reportStatusToCallback() { + if (mCallback != null) { + final boolean shouldShowStatus = + mBatteryState.isPowerPluggedIn() || mBatteryState.isBatteryDefenderEnabled(); + mCallback.onChargingStatusChanged(shouldShowStatus, computeChargingString()); + } + } + + private class ChargingStatusCallback extends KeyguardUpdateMonitorCallback { + @Override + public void onRefreshBatteryInfo(BatteryStatus status) { + mBatteryState.setBatteryStatus(status); + reportStatusToCallback(); + } + } + + /*** + * A callback to be called when the charging status changes. + */ + public interface Callback { + /*** + * Called when the charging status changes. + * @param shouldShowStatus Whether or not to show a charging status message. + * @param statusMessage A charging status message. + */ + void onChargingStatusChanged(boolean shouldShowStatus, String statusMessage); + } + + /*** + * A wrapper around {@link BatteryStatus} for fetching various properties of the current + * battery and charging state. + */ + private static class BatteryState { + private BatteryStatus mBatteryStatus; + + public void setBatteryStatus(BatteryStatus batteryStatus) { + mBatteryStatus = batteryStatus; + } + + public boolean isValid() { + return mBatteryStatus != null; + } + + public long getChargingTimeRemaining(IBatteryStats batteryInfo) { + try { + return isPowerPluggedIn() ? batteryInfo.computeChargeTimeRemaining() : -1; + } catch (RemoteException e) { + Log.e(TAG, "Error calling IBatteryStats: ", e); + return -1; + } + } + + public boolean isBatteryDefenderEnabled() { + return isValid() && mBatteryStatus.isPluggedIn() && isBatteryDefender(); + } + + public boolean isBatteryDefender() { + return isValid() && mBatteryStatus.isBatteryDefender(); + } + + public int getBatteryLevel() { + return isValid() ? mBatteryStatus.level : 0; + } + + public int getChargingSpeed(Context context) { + return isValid() ? mBatteryStatus.getChargingSpeed(context) : 0; + } + + public boolean isPowerCharged() { + return isValid() && mBatteryStatus.isCharged(); + } + + public boolean isPowerPluggedIn() { + return isValid() && mBatteryStatus.isPluggedIn() && isChargingOrFull(); + } + + public boolean isPowerPluggedInWired() { + return isValid() + && mBatteryStatus.isPluggedInWired() + && isChargingOrFull(); + } + + public boolean isPowerPluggedInWireless() { + return isValid() + && mBatteryStatus.isPluggedInWireless() + && isChargingOrFull(); + } + + public boolean isPowerPluggedInDocked() { + return isValid() && mBatteryStatus.isPluggedInDock() && isChargingOrFull(); + } + + private boolean isChargingOrFull() { + return isValid() + && (mBatteryStatus.status == BatteryManager.BATTERY_STATUS_CHARGING + || mBatteryStatus.isCharged()); + } + + private String getBatteryLevelAsPercentage() { + return NumberFormat.getPercentInstance().format(getBatteryLevel() / 100f); + } + } +} diff --git a/packages/SystemUI/src/com/android/systemui/lowlightclock/DirectBootCondition.kt b/packages/SystemUI/src/com/android/systemui/lowlightclock/DirectBootCondition.kt new file mode 100644 index 000000000000..4c1da0198498 --- /dev/null +++ b/packages/SystemUI/src/com/android/systemui/lowlightclock/DirectBootCondition.kt @@ -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.systemui.lowlightclock + +import android.content.Intent +import android.content.IntentFilter +import android.os.UserManager +import com.android.systemui.broadcast.BroadcastDispatcher +import com.android.systemui.dagger.qualifiers.Application +import com.android.systemui.shared.condition.Condition +import javax.inject.Inject +import kotlinx.coroutines.CoroutineScope +import kotlinx.coroutines.Job +import kotlinx.coroutines.flow.cancellable +import kotlinx.coroutines.flow.distinctUntilChanged +import kotlinx.coroutines.flow.map +import kotlinx.coroutines.launch + +class DirectBootCondition +@Inject +constructor( + broadcastDispatcher: BroadcastDispatcher, + private val userManager: UserManager, + @Application private val coroutineScope: CoroutineScope, +) : Condition(coroutineScope) { + private var job: Job? = null + private val directBootFlow = + broadcastDispatcher + .broadcastFlow(IntentFilter(Intent.ACTION_USER_UNLOCKED)) + .map { !userManager.isUserUnlocked } + .cancellable() + .distinctUntilChanged() + + override fun start() { + job = coroutineScope.launch { directBootFlow.collect { updateCondition(it) } } + updateCondition(!userManager.isUserUnlocked) + } + + override fun stop() { + job?.cancel() + } + + override fun getStartStrategy(): Int { + return START_EAGERLY + } +} diff --git a/packages/SystemUI/src/com/android/systemui/lowlightclock/ForceLowLightCondition.java b/packages/SystemUI/src/com/android/systemui/lowlightclock/ForceLowLightCondition.java new file mode 100644 index 000000000000..7f21d0707f63 --- /dev/null +++ b/packages/SystemUI/src/com/android/systemui/lowlightclock/ForceLowLightCondition.java @@ -0,0 +1,137 @@ +/* + * 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.systemui.lowlightclock; + +import android.text.TextUtils; +import android.util.Log; + +import androidx.annotation.NonNull; + +import com.android.systemui.dagger.qualifiers.Application; +import com.android.systemui.shared.condition.Condition; +import com.android.systemui.statusbar.commandline.Command; +import com.android.systemui.statusbar.commandline.CommandRegistry; + +import kotlinx.coroutines.CoroutineScope; + +import java.io.PrintWriter; +import java.util.List; + +import javax.inject.Inject; + +/** + * This condition registers for and fulfills cmd shell commands to force a device into or out of + * low-light conditions. + */ +public class ForceLowLightCondition extends Condition { + /** + * Command root + */ + public static final String COMMAND_ROOT = "low-light"; + /** + * Command for forcing device into low light. + */ + public static final String COMMAND_ENABLE_LOW_LIGHT = "enable"; + + /** + * Command for preventing a device from entering low light. + */ + public static final String COMMAND_DISABLE_LOW_LIGHT = "disable"; + + /** + * Command for clearing previously forced low-light conditions. + */ + public static final String COMMAND_CLEAR_LOW_LIGHT = "clear"; + + private static final String TAG = "ForceLowLightCondition"; + private static final boolean DEBUG = Log.isLoggable(TAG, Log.DEBUG); + + /** + * Default Constructor. + * + * @param commandRegistry command registry to register commands with. + */ + @Inject + public ForceLowLightCondition( + @Application CoroutineScope scope, + CommandRegistry commandRegistry + ) { + super(scope, null, true); + + if (DEBUG) { + Log.d(TAG, "registering commands"); + } + commandRegistry.registerCommand(COMMAND_ROOT, () -> new Command() { + @Override + public void execute(@NonNull PrintWriter pw, @NonNull List<String> args) { + if (args.size() != 1) { + pw.println("no command specified"); + help(pw); + return; + } + + final String cmd = args.get(0); + + if (TextUtils.equals(cmd, COMMAND_ENABLE_LOW_LIGHT)) { + logAndPrint(pw, "forcing low light"); + updateCondition(true); + } else if (TextUtils.equals(cmd, COMMAND_DISABLE_LOW_LIGHT)) { + logAndPrint(pw, "forcing to not enter low light"); + updateCondition(false); + } else if (TextUtils.equals(cmd, COMMAND_CLEAR_LOW_LIGHT)) { + logAndPrint(pw, "clearing any forced low light"); + clearCondition(); + } else { + pw.println("invalid command"); + help(pw); + } + } + + @Override + public void help(@NonNull PrintWriter pw) { + pw.println("Usage: adb shell cmd statusbar low-light <cmd>"); + pw.println("Supported commands:"); + pw.println(" - enable"); + pw.println(" forces device into low-light"); + pw.println(" - disable"); + pw.println(" forces device to not enter low-light"); + pw.println(" - clear"); + pw.println(" clears any previously forced state"); + } + + private void logAndPrint(PrintWriter pw, String message) { + pw.println(message); + if (DEBUG) { + Log.d(TAG, message); + } + } + }); + } + + @Override + protected void start() { + } + + @Override + protected void stop() { + } + + @Override + protected int getStartStrategy() { + return START_EAGERLY; + } +} diff --git a/packages/SystemUI/src/com/android/systemui/lowlightclock/LowLightClockAnimationProvider.java b/packages/SystemUI/src/com/android/systemui/lowlightclock/LowLightClockAnimationProvider.java new file mode 100644 index 000000000000..6de599803a57 --- /dev/null +++ b/packages/SystemUI/src/com/android/systemui/lowlightclock/LowLightClockAnimationProvider.java @@ -0,0 +1,127 @@ +/* + * 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.systemui.lowlightclock; + +import android.animation.Animator; +import android.animation.AnimatorSet; +import android.animation.ObjectAnimator; +import android.view.View; +import android.view.animation.Interpolator; + +import com.android.app.animation.Interpolators; +import com.android.dream.lowlight.util.TruncatedInterpolator; +import com.android.systemui.lowlightclock.dagger.LowLightModule; +import com.android.systemui.statusbar.CrossFadeHelper; + +import javax.inject.Inject; +import javax.inject.Named; + +/*** + * A class that provides the animations used by the low-light clock. + * + * The entry and exit animations are opposites, with the only difference being a delay before the + * text fades in on entry. + */ +public class LowLightClockAnimationProvider { + private final int mYTranslationAnimationInStartOffset; + private final long mYTranslationAnimationInDurationMillis; + private final long mAlphaAnimationInStartDelayMillis; + private final long mAlphaAnimationDurationMillis; + + /** + * Custom interpolator used for the translate out animation, which uses an emphasized easing + * like the translate in animation, but is scaled to match the length of the alpha animation. + */ + private final Interpolator mTranslationOutInterpolator; + + @Inject + public LowLightClockAnimationProvider( + @Named(LowLightModule.Y_TRANSLATION_ANIMATION_OFFSET) + int yTranslationAnimationInStartOffset, + @Named(LowLightModule.Y_TRANSLATION_ANIMATION_DURATION_MILLIS) + long yTranslationAnimationInDurationMillis, + @Named(LowLightModule.ALPHA_ANIMATION_IN_START_DELAY_MILLIS) + long alphaAnimationInStartDelayMillis, + @Named(LowLightModule.ALPHA_ANIMATION_DURATION_MILLIS) + long alphaAnimationDurationMillis) { + mYTranslationAnimationInStartOffset = yTranslationAnimationInStartOffset; + mYTranslationAnimationInDurationMillis = yTranslationAnimationInDurationMillis; + mAlphaAnimationInStartDelayMillis = alphaAnimationInStartDelayMillis; + mAlphaAnimationDurationMillis = alphaAnimationDurationMillis; + + mTranslationOutInterpolator = new TruncatedInterpolator(Interpolators.EMPHASIZED, + /*originalDuration=*/ mYTranslationAnimationInDurationMillis, + /*newDuration=*/ mAlphaAnimationDurationMillis); + } + + /*** + * Provides an animation for when the given views become visible. + * @param views Any number of views to animate in together. + */ + public Animator provideAnimationIn(View... views) { + final AnimatorSet animatorSet = new AnimatorSet(); + + for (View view : views) { + if (view == null) continue; + // Set the alpha to 0 to start because the alpha animation has a start delay. + CrossFadeHelper.fadeOut(view, 0f, false); + + final Animator alphaAnimator = + ObjectAnimator.ofFloat(view, View.ALPHA, 1f); + alphaAnimator.setStartDelay(mAlphaAnimationInStartDelayMillis); + alphaAnimator.setDuration(mAlphaAnimationDurationMillis); + alphaAnimator.setInterpolator(Interpolators.LINEAR); + + final Animator positionAnimator = ObjectAnimator + .ofFloat(view, View.TRANSLATION_Y, mYTranslationAnimationInStartOffset, 0f); + positionAnimator.setDuration(mYTranslationAnimationInDurationMillis); + positionAnimator.setInterpolator(Interpolators.EMPHASIZED); + + // The position animator must be started first since the alpha animator has a start + // delay. + animatorSet.playTogether(positionAnimator, alphaAnimator); + } + + return animatorSet; + } + + /*** + * Provides an animation for when the given views are going out of view. + * @param views Any number of views to animate out. + */ + public Animator provideAnimationOut(View... views) { + final AnimatorSet animatorSet = new AnimatorSet(); + + for (View view : views) { + if (view == null) continue; + final Animator alphaAnimator = + ObjectAnimator.ofFloat(view, View.ALPHA, 0f); + alphaAnimator.setDuration(mAlphaAnimationDurationMillis); + alphaAnimator.setInterpolator(Interpolators.LINEAR); + + final Animator positionAnimator = ObjectAnimator + .ofFloat(view, View.TRANSLATION_Y, mYTranslationAnimationInStartOffset); + // Use the same duration as the alpha animation plus our custom interpolator. + positionAnimator.setDuration(mAlphaAnimationDurationMillis); + positionAnimator.setInterpolator(mTranslationOutInterpolator); + animatorSet.playTogether(alphaAnimator, positionAnimator); + } + + return animatorSet; + } + +} diff --git a/packages/SystemUI/src/com/android/systemui/lowlightclock/LowLightCondition.java b/packages/SystemUI/src/com/android/systemui/lowlightclock/LowLightCondition.java new file mode 100644 index 000000000000..e91be5028777 --- /dev/null +++ b/packages/SystemUI/src/com/android/systemui/lowlightclock/LowLightCondition.java @@ -0,0 +1,77 @@ +/* + * 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.systemui.lowlightclock; + +import com.android.internal.logging.UiEventLogger; +import com.android.systemui.dagger.qualifiers.Application; +import com.android.systemui.shared.condition.Condition; + +import kotlinx.coroutines.CoroutineScope; + +import javax.inject.Inject; + +/** + * Condition for monitoring when the device enters and exits lowlight mode. + */ +public class LowLightCondition extends Condition { + private final AmbientLightModeMonitor mAmbientLightModeMonitor; + private final UiEventLogger mUiEventLogger; + + @Inject + public LowLightCondition(@Application CoroutineScope scope, + AmbientLightModeMonitor ambientLightModeMonitor, + UiEventLogger uiEventLogger) { + super(scope); + mAmbientLightModeMonitor = ambientLightModeMonitor; + mUiEventLogger = uiEventLogger; + } + + @Override + protected void start() { + mAmbientLightModeMonitor.start(this::onLowLightChanged); + } + + @Override + protected void stop() { + mAmbientLightModeMonitor.stop(); + + // Reset condition met to false. + updateCondition(false); + } + + @Override + protected int getStartStrategy() { + // As this condition keeps the lowlight sensor active, it should only run when needed. + return START_WHEN_NEEDED; + } + + private void onLowLightChanged(int lowLightMode) { + if (lowLightMode == AmbientLightModeMonitor.AMBIENT_LIGHT_MODE_UNDECIDED) { + // Ignore undecided mode changes. + return; + } + + final boolean isLowLight = lowLightMode == AmbientLightModeMonitor.AMBIENT_LIGHT_MODE_DARK; + if (isLowLight == isConditionMet()) { + // No change in condition, don't do anything. + return; + } + mUiEventLogger.log(isLowLight ? LowLightDockEvent.AMBIENT_LIGHT_TO_DARK + : LowLightDockEvent.AMBIENT_LIGHT_TO_LIGHT); + updateCondition(isLowLight); + } +} diff --git a/packages/SystemUI/src/com/android/systemui/lowlightclock/LowLightDisplayController.kt b/packages/SystemUI/src/com/android/systemui/lowlightclock/LowLightDisplayController.kt new file mode 100644 index 000000000000..9a9d813b18c5 --- /dev/null +++ b/packages/SystemUI/src/com/android/systemui/lowlightclock/LowLightDisplayController.kt @@ -0,0 +1,23 @@ +/* + * 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.systemui.lowlightclock + +interface LowLightDisplayController { + fun isDisplayBrightnessModeSupported(): Boolean + + fun setDisplayBrightnessModeEnabled(enabled: Boolean) +} diff --git a/packages/SystemUI/src/com/android/systemui/lowlightclock/LowLightDockEvent.kt b/packages/SystemUI/src/com/android/systemui/lowlightclock/LowLightDockEvent.kt new file mode 100644 index 000000000000..b99aeb6eeacc --- /dev/null +++ b/packages/SystemUI/src/com/android/systemui/lowlightclock/LowLightDockEvent.kt @@ -0,0 +1,31 @@ +/* + * 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.systemui.lowlightclock + +import com.android.internal.logging.UiEvent +import com.android.internal.logging.UiEventLogger + +enum class LowLightDockEvent(private val id: Int) : UiEventLogger.UiEventEnum { + @UiEvent(doc = "Ambient light changed from light to dark") AMBIENT_LIGHT_TO_DARK(999), + @UiEvent(doc = "The low light mode has started") LOW_LIGHT_STARTED(1000), + @UiEvent(doc = "Ambient light changed from dark to light") AMBIENT_LIGHT_TO_LIGHT(1001), + @UiEvent(doc = "The low light mode has stopped") LOW_LIGHT_STOPPED(1002); + + override fun getId(): Int { + return id + } +} diff --git a/packages/SystemUI/src/com/android/systemui/lowlightclock/LowLightLogger.kt b/packages/SystemUI/src/com/android/systemui/lowlightclock/LowLightLogger.kt new file mode 100644 index 000000000000..11d75215edf5 --- /dev/null +++ b/packages/SystemUI/src/com/android/systemui/lowlightclock/LowLightLogger.kt @@ -0,0 +1,28 @@ +/* + * Copyright (C) 2023 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.lowlightclock + +import com.android.systemui.log.LogBuffer +import com.android.systemui.log.core.LogLevel +import com.android.systemui.lowlightclock.dagger.LowLightLog +import javax.inject.Inject + +/** Logs to a {@link LogBuffer} anything related to low-light features. */ +class LowLightLogger @Inject constructor(@LowLightLog private val buffer: LogBuffer) { + /** Logs a debug message to the buffer. */ + fun d(tag: String, message: String) = buffer.log(tag, LogLevel.DEBUG, message) +} diff --git a/packages/SystemUI/src/com/android/systemui/lowlightclock/LowLightMonitor.java b/packages/SystemUI/src/com/android/systemui/lowlightclock/LowLightMonitor.java new file mode 100644 index 000000000000..912ace7675d5 --- /dev/null +++ b/packages/SystemUI/src/com/android/systemui/lowlightclock/LowLightMonitor.java @@ -0,0 +1,133 @@ +/* + * 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.systemui.lowlightclock; + +import static com.android.dream.lowlight.LowLightDreamManager.AMBIENT_LIGHT_MODE_LOW_LIGHT; +import static com.android.dream.lowlight.LowLightDreamManager.AMBIENT_LIGHT_MODE_REGULAR; +import static com.android.systemui.dreams.dagger.DreamModule.LOW_LIGHT_DREAM_SERVICE; +import static com.android.systemui.keyguard.ScreenLifecycle.SCREEN_ON; +import static com.android.systemui.lowlightclock.dagger.LowLightModule.LOW_LIGHT_PRECONDITIONS; + +import android.content.ComponentName; +import android.content.pm.PackageManager; + +import androidx.annotation.Nullable; + +import com.android.dream.lowlight.LowLightDreamManager; +import com.android.systemui.dagger.qualifiers.SystemUser; +import com.android.systemui.keyguard.ScreenLifecycle; +import com.android.systemui.shared.condition.Condition; +import com.android.systemui.shared.condition.Monitor; +import com.android.systemui.util.condition.ConditionalCoreStartable; + +import dagger.Lazy; + +import java.util.Set; + +import javax.inject.Inject; +import javax.inject.Named; + +/** + * Tracks environment (low-light or not) in order to correctly show or hide a low-light clock while + * dreaming. + */ +public class LowLightMonitor extends ConditionalCoreStartable implements Monitor.Callback, + ScreenLifecycle.Observer { + private static final String TAG = "LowLightMonitor"; + + private final Lazy<LowLightDreamManager> mLowLightDreamManager; + private final Monitor mConditionsMonitor; + private final Lazy<Set<Condition>> mLowLightConditions; + private Monitor.Subscription.Token mSubscriptionToken; + private ScreenLifecycle mScreenLifecycle; + private final LowLightLogger mLogger; + + private final ComponentName mLowLightDreamService; + + private final PackageManager mPackageManager; + + @Inject + public LowLightMonitor(Lazy<LowLightDreamManager> lowLightDreamManager, + @SystemUser Monitor conditionsMonitor, + @Named(LOW_LIGHT_PRECONDITIONS) Lazy<Set<Condition>> lowLightConditions, + ScreenLifecycle screenLifecycle, + LowLightLogger lowLightLogger, + @Nullable @Named(LOW_LIGHT_DREAM_SERVICE) ComponentName lowLightDreamService, + PackageManager packageManager) { + super(conditionsMonitor); + mLowLightDreamManager = lowLightDreamManager; + mConditionsMonitor = conditionsMonitor; + mLowLightConditions = lowLightConditions; + mScreenLifecycle = screenLifecycle; + mLogger = lowLightLogger; + mLowLightDreamService = lowLightDreamService; + mPackageManager = packageManager; + } + + @Override + public void onConditionsChanged(boolean allConditionsMet) { + mLogger.d(TAG, "Low light enabled: " + allConditionsMet); + + mLowLightDreamManager.get().setAmbientLightMode(allConditionsMet + ? AMBIENT_LIGHT_MODE_LOW_LIGHT : AMBIENT_LIGHT_MODE_REGULAR); + } + + @Override + public void onScreenTurnedOn() { + if (mSubscriptionToken == null) { + mLogger.d(TAG, "Screen turned on. Subscribing to low light conditions."); + + mSubscriptionToken = mConditionsMonitor.addSubscription( + new Monitor.Subscription.Builder(this) + .addConditions(mLowLightConditions.get()) + .build()); + } + } + + + @Override + public void onScreenTurnedOff() { + if (mSubscriptionToken != null) { + mLogger.d(TAG, "Screen turned off. Removing subscription to low light conditions."); + + mConditionsMonitor.removeSubscription(mSubscriptionToken); + mSubscriptionToken = null; + } + } + + @Override + protected void onStart() { + if (mLowLightDreamService != null) { + // Note that the dream service is disabled by default. This prevents the dream from + // appearing in settings on devices that don't have it explicitly excluded (done in + // the settings overlay). Therefore, the component is enabled if it is to be used + // here. + mPackageManager.setComponentEnabledSetting( + mLowLightDreamService, + PackageManager.COMPONENT_ENABLED_STATE_ENABLED, + PackageManager.DONT_KILL_APP + ); + } else { + // If there is no low light dream service, do not observe conditions. + return; + } + + mScreenLifecycle.addObserver(this); + if (mScreenLifecycle.getScreenState() == SCREEN_ON) { + onScreenTurnedOn(); + } + } +} diff --git a/packages/SystemUI/src/com/android/systemui/lowlightclock/ScreenSaverEnabledCondition.java b/packages/SystemUI/src/com/android/systemui/lowlightclock/ScreenSaverEnabledCondition.java new file mode 100644 index 000000000000..fd6ce1762a28 --- /dev/null +++ b/packages/SystemUI/src/com/android/systemui/lowlightclock/ScreenSaverEnabledCondition.java @@ -0,0 +1,87 @@ +/* + * 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.systemui.lowlightclock; + +import android.content.res.Resources; +import android.database.ContentObserver; +import android.os.UserHandle; +import android.provider.Settings; +import android.util.Log; + +import com.android.systemui.dagger.qualifiers.Application; +import com.android.systemui.dagger.qualifiers.Main; +import com.android.systemui.shared.condition.Condition; +import com.android.systemui.util.settings.SecureSettings; + +import kotlinx.coroutines.CoroutineScope; + +import javax.inject.Inject; + +/** + * Condition for monitoring if the screensaver setting is enabled. + */ +public class ScreenSaverEnabledCondition extends Condition { + private static final String TAG = ScreenSaverEnabledCondition.class.getSimpleName(); + + private final boolean mScreenSaverEnabledByDefaultConfig; + private final SecureSettings mSecureSettings; + + private final ContentObserver mScreenSaverSettingObserver = new ContentObserver(null) { + @Override + public void onChange(boolean selfChange) { + updateScreenSaverEnabledSetting(); + } + }; + + @Inject + public ScreenSaverEnabledCondition(@Application CoroutineScope scope, @Main Resources resources, + SecureSettings secureSettings) { + super(scope); + mScreenSaverEnabledByDefaultConfig = resources.getBoolean( + com.android.internal.R.bool.config_dreamsEnabledByDefault); + mSecureSettings = secureSettings; + } + + @Override + protected void start() { + mSecureSettings.registerContentObserverForUserSync( + Settings.Secure.SCREENSAVER_ENABLED, + mScreenSaverSettingObserver, UserHandle.USER_CURRENT); + updateScreenSaverEnabledSetting(); + } + + @Override + protected void stop() { + mSecureSettings.unregisterContentObserverSync(mScreenSaverSettingObserver); + } + + @Override + protected int getStartStrategy() { + return START_EAGERLY; + } + + private void updateScreenSaverEnabledSetting() { + final boolean enabled = mSecureSettings.getIntForUser( + Settings.Secure.SCREENSAVER_ENABLED, + mScreenSaverEnabledByDefaultConfig ? 1 : 0, + UserHandle.USER_CURRENT) != 0; + if (!enabled) { + Log.i(TAG, "Disabling low-light clock because screen saver has been disabled"); + } + updateCondition(enabled); + } +} diff --git a/packages/SystemUI/src/com/android/systemui/lowlightclock/dagger/LowLightLog.kt b/packages/SystemUI/src/com/android/systemui/lowlightclock/dagger/LowLightLog.kt new file mode 100644 index 000000000000..0819664c921c --- /dev/null +++ b/packages/SystemUI/src/com/android/systemui/lowlightclock/dagger/LowLightLog.kt @@ -0,0 +1,22 @@ +/* + * Copyright (C) 2023 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.lowlightclock.dagger + +import javax.inject.Qualifier + +/** A [com.android.systemui.log.LogBuffer] for logging related to low light features. */ +@Qualifier @MustBeDocumented @Retention(AnnotationRetention.RUNTIME) annotation class LowLightLog diff --git a/packages/SystemUI/src/com/android/systemui/lowlightclock/dagger/LowLightModule.java b/packages/SystemUI/src/com/android/systemui/lowlightclock/dagger/LowLightModule.java new file mode 100644 index 000000000000..c08be51c0699 --- /dev/null +++ b/packages/SystemUI/src/com/android/systemui/lowlightclock/dagger/LowLightModule.java @@ -0,0 +1,150 @@ +/* + * 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.systemui.lowlightclock.dagger; + +import android.content.res.Resources; +import android.hardware.Sensor; + +import com.android.dream.lowlight.dagger.LowLightDreamModule; +import com.android.systemui.CoreStartable; +import com.android.systemui.communal.DeviceInactiveCondition; +import com.android.systemui.dagger.SysUISingleton; +import com.android.systemui.dagger.qualifiers.Main; +import com.android.systemui.log.LogBuffer; +import com.android.systemui.log.LogBufferFactory; +import com.android.systemui.lowlightclock.AmbientLightModeMonitor; +import com.android.systemui.lowlightclock.DirectBootCondition; +import com.android.systemui.lowlightclock.ForceLowLightCondition; +import com.android.systemui.lowlightclock.LowLightCondition; +import com.android.systemui.lowlightclock.LowLightDisplayController; +import com.android.systemui.lowlightclock.LowLightMonitor; +import com.android.systemui.lowlightclock.ScreenSaverEnabledCondition; +import com.android.systemui.res.R; +import com.android.systemui.shared.condition.Condition; + +import dagger.Binds; +import dagger.BindsOptionalOf; +import dagger.Module; +import dagger.Provides; +import dagger.multibindings.ClassKey; +import dagger.multibindings.IntoMap; +import dagger.multibindings.IntoSet; + +import javax.inject.Named; + +@Module(includes = LowLightDreamModule.class) +public abstract class LowLightModule { + public static final String Y_TRANSLATION_ANIMATION_OFFSET = + "y_translation_animation_offset"; + public static final String Y_TRANSLATION_ANIMATION_DURATION_MILLIS = + "y_translation_animation_duration_millis"; + public static final String ALPHA_ANIMATION_IN_START_DELAY_MILLIS = + "alpha_animation_in_start_delay_millis"; + public static final String ALPHA_ANIMATION_DURATION_MILLIS = + "alpha_animation_duration_millis"; + public static final String LOW_LIGHT_PRECONDITIONS = "low_light_preconditions"; + public static final String LIGHT_SENSOR = "low_light_monitor_light_sensor"; + + + /** + * Provides a {@link LogBuffer} for logs related to low-light features. + */ + @Provides + @SysUISingleton + @LowLightLog + public static LogBuffer provideLowLightLogBuffer(LogBufferFactory factory) { + return factory.create("LowLightLog", 250); + } + + @Binds + @IntoSet + @Named(LOW_LIGHT_PRECONDITIONS) + abstract Condition bindScreenSaverEnabledCondition(ScreenSaverEnabledCondition condition); + + @Provides + @IntoSet + @Named(com.android.systemui.lowlightclock.dagger.LowLightModule.LOW_LIGHT_PRECONDITIONS) + static Condition provideLowLightCondition(LowLightCondition lowLightCondition, + DirectBootCondition directBootCondition) { + // Start lowlight if we are either in lowlight or in direct boot. The ordering of the + // conditions matters here since we don't want to start the lowlight condition if + // we are in direct boot mode. + return directBootCondition.or(lowLightCondition); + } + + @Binds + @IntoSet + @Named(LOW_LIGHT_PRECONDITIONS) + abstract Condition bindForceLowLightCondition(ForceLowLightCondition condition); + + @Binds + @IntoSet + @Named(LOW_LIGHT_PRECONDITIONS) + abstract Condition bindDeviceInactiveCondition(DeviceInactiveCondition condition); + + @BindsOptionalOf + abstract LowLightDisplayController bindsLowLightDisplayController(); + + @BindsOptionalOf + @Named(LIGHT_SENSOR) + abstract Sensor bindsLightSensor(); + + @BindsOptionalOf + abstract AmbientLightModeMonitor.DebounceAlgorithm bindsDebounceAlgorithm(); + + /** + * + */ + @Provides + @Named(Y_TRANSLATION_ANIMATION_OFFSET) + static int providesAnimationInOffset(@Main Resources resources) { + return resources.getDimensionPixelOffset( + R.dimen.low_light_clock_translate_animation_offset); + } + + /** + * + */ + @Provides + @Named(Y_TRANSLATION_ANIMATION_DURATION_MILLIS) + static long providesAnimationDurationMillis(@Main Resources resources) { + return resources.getInteger(R.integer.low_light_clock_translate_animation_duration_ms); + } + + /** + * + */ + @Provides + @Named(ALPHA_ANIMATION_IN_START_DELAY_MILLIS) + static long providesAlphaAnimationInStartDelayMillis(@Main Resources resources) { + return resources.getInteger(R.integer.low_light_clock_alpha_animation_in_start_delay_ms); + } + + /** + * + */ + @Provides + @Named(ALPHA_ANIMATION_DURATION_MILLIS) + static long providesAlphaAnimationDurationMillis(@Main Resources resources) { + return resources.getInteger(R.integer.low_light_clock_alpha_animation_duration_ms); + } + /** Inject into LowLightMonitor. */ + @Binds + @IntoMap + @ClassKey(LowLightMonitor.class) + abstract CoreStartable bindLowLightMonitor(LowLightMonitor lowLightMonitor); +} diff --git a/packages/SystemUI/src/com/google/android/systemui/lowlightclock/LowLightClockDreamService.java b/packages/SystemUI/src/com/google/android/systemui/lowlightclock/LowLightClockDreamService.java new file mode 100644 index 000000000000..8a5f7eaf8776 --- /dev/null +++ b/packages/SystemUI/src/com/google/android/systemui/lowlightclock/LowLightClockDreamService.java @@ -0,0 +1,161 @@ +/* + * 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.google.android.systemui.lowlightclock; + +import android.animation.Animator; +import android.animation.AnimatorListenerAdapter; +import android.annotation.Nullable; +import android.service.dreams.DreamService; +import android.util.Log; +import android.view.LayoutInflater; +import android.view.View; +import android.widget.TextClock; +import android.widget.TextView; + +import com.android.dream.lowlight.LowLightTransitionCoordinator; +import com.android.systemui.lowlightclock.ChargingStatusProvider; +import com.android.systemui.lowlightclock.LowLightClockAnimationProvider; +import com.android.systemui.lowlightclock.LowLightDisplayController; +import com.android.systemui.res.R; + +import java.util.Optional; + +import javax.inject.Inject; +import javax.inject.Provider; + +/** + * A dark themed text clock dream to be shown when the device is in a low light environment. + */ +public class LowLightClockDreamService extends DreamService implements + LowLightTransitionCoordinator.LowLightExitListener { + private static final String TAG = "LowLightClockDreamService"; + + private final ChargingStatusProvider mChargingStatusProvider; + private final LowLightDisplayController mDisplayController; + private final LowLightClockAnimationProvider mAnimationProvider; + private final LowLightTransitionCoordinator mLowLightTransitionCoordinator; + private boolean mIsDimBrightnessSupported = false; + + private TextView mChargingStatusTextView; + private TextClock mTextClock; + @Nullable + private Animator mAnimationIn; + @Nullable + private Animator mAnimationOut; + + @Inject + public LowLightClockDreamService( + ChargingStatusProvider chargingStatusProvider, + LowLightClockAnimationProvider animationProvider, + LowLightTransitionCoordinator lowLightTransitionCoordinator, + Optional<Provider<LowLightDisplayController>> displayController) { + super(); + + mAnimationProvider = animationProvider; + mDisplayController = displayController.map(Provider::get).orElse(null); + mChargingStatusProvider = chargingStatusProvider; + mLowLightTransitionCoordinator = lowLightTransitionCoordinator; + } + + @Override + public void onAttachedToWindow() { + super.onAttachedToWindow(); + + setInteractive(false); + setFullscreen(true); + + setContentView(LayoutInflater.from(getApplicationContext()).inflate( + R.layout.low_light_clock_dream, null)); + + mTextClock = findViewById(R.id.low_light_text_clock); + + mChargingStatusTextView = findViewById(R.id.charging_status_text_view); + + mChargingStatusProvider.startUsing(this::updateChargingMessage); + + mLowLightTransitionCoordinator.setLowLightExitListener(this); + } + + @Override + public void onDreamingStarted() { + mAnimationIn = mAnimationProvider.provideAnimationIn(mTextClock, mChargingStatusTextView); + mAnimationIn.start(); + + if (mDisplayController != null) { + mIsDimBrightnessSupported = mDisplayController.isDisplayBrightnessModeSupported(); + + if (mIsDimBrightnessSupported) { + Log.v(TAG, "setting dim brightness state"); + mDisplayController.setDisplayBrightnessModeEnabled(true); + } else { + Log.v(TAG, "dim brightness not supported"); + } + } + } + + @Override + public void onDreamingStopped() { + if (mIsDimBrightnessSupported) { + Log.v(TAG, "clearing dim brightness state"); + mDisplayController.setDisplayBrightnessModeEnabled(false); + } + } + + @Override + public void onWakeUp() { + if (mAnimationIn != null) { + mAnimationIn.cancel(); + } + mAnimationOut = mAnimationProvider.provideAnimationOut(mTextClock, mChargingStatusTextView); + mAnimationOut.addListener(new AnimatorListenerAdapter() { + @Override + public void onAnimationEnd(Animator animator) { + LowLightClockDreamService.super.onWakeUp(); + } + }); + mAnimationOut.start(); + } + + @Override + public void onDetachedFromWindow() { + super.onDetachedFromWindow(); + + if (mAnimationOut != null) { + mAnimationOut.cancel(); + } + + mChargingStatusProvider.stopUsing(); + + mLowLightTransitionCoordinator.setLowLightExitListener(null); + } + + private void updateChargingMessage(boolean showChargingStatus, String chargingStatusMessage) { + mChargingStatusTextView.setText(chargingStatusMessage); + mChargingStatusTextView.setVisibility(showChargingStatus ? View.VISIBLE : View.INVISIBLE); + } + + @Override + public Animator onBeforeExitLowLight() { + mAnimationOut = mAnimationProvider.provideAnimationOut(mTextClock, mChargingStatusTextView); + mAnimationOut.start(); + + // Return the animator so that the transition coordinator waits for the low light exit + // animations to finish before entering low light, as otherwise the default DreamActivity + // animation plays immediately and there's no time for this animation to play. + return mAnimationOut; + } +} diff --git a/packages/SystemUI/tests/src/com/android/systemui/lowlightclock/AmbientLightModeMonitorTest.kt b/packages/SystemUI/tests/src/com/android/systemui/lowlightclock/AmbientLightModeMonitorTest.kt new file mode 100644 index 000000000000..43ee388e44a7 --- /dev/null +++ b/packages/SystemUI/tests/src/com/android/systemui/lowlightclock/AmbientLightModeMonitorTest.kt @@ -0,0 +1,110 @@ +/* + * 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.systemui.lowlightclock + +import android.hardware.Sensor +import android.hardware.SensorEventListener +import android.testing.AndroidTestingRunner +import androidx.test.filters.SmallTest +import com.android.systemui.SysuiTestCase +import com.android.systemui.util.sensors.AsyncSensorManager +import java.util.Optional +import org.junit.Before +import org.junit.Test +import org.junit.runner.RunWith +import org.mockito.ArgumentCaptor +import org.mockito.Mock +import org.mockito.Mockito.any +import org.mockito.Mockito.anyInt +import org.mockito.Mockito.eq +import org.mockito.Mockito.mock +import org.mockito.Mockito.never +import org.mockito.Mockito.verify +import org.mockito.MockitoAnnotations + +@SmallTest +@RunWith(AndroidTestingRunner::class) +class AmbientLightModeMonitorTest : SysuiTestCase() { + @Mock private lateinit var sensorManager: AsyncSensorManager + @Mock private lateinit var sensor: Sensor + @Mock private lateinit var algorithm: AmbientLightModeMonitor.DebounceAlgorithm + + private lateinit var ambientLightModeMonitor: AmbientLightModeMonitor + + @Before + fun setUp() { + MockitoAnnotations.initMocks(this) + + ambientLightModeMonitor = + AmbientLightModeMonitor(Optional.of(algorithm), sensorManager, Optional.of(sensor)) + } + + @Test + fun shouldRegisterSensorEventListenerOnStart() { + val callback = mock(AmbientLightModeMonitor.Callback::class.java) + ambientLightModeMonitor.start(callback) + + verify(sensorManager).registerListener(any(), eq(sensor), anyInt()) + } + + @Test + fun shouldUnregisterSensorEventListenerOnStop() { + val callback = mock(AmbientLightModeMonitor.Callback::class.java) + ambientLightModeMonitor.start(callback) + + val sensorEventListener = captureSensorEventListener() + + ambientLightModeMonitor.stop() + + verify(sensorManager).unregisterListener(eq(sensorEventListener)) + } + + @Test + fun shouldStartDebounceAlgorithmOnStart() { + val callback = mock(AmbientLightModeMonitor.Callback::class.java) + ambientLightModeMonitor.start(callback) + + verify(algorithm).start(eq(callback)) + } + + @Test + fun shouldStopDebounceAlgorithmOnStop() { + val callback = mock(AmbientLightModeMonitor.Callback::class.java) + ambientLightModeMonitor.start(callback) + ambientLightModeMonitor.stop() + + verify(algorithm).stop() + } + + @Test + fun shouldNotRegisterForSensorUpdatesIfSensorNotAvailable() { + val ambientLightModeMonitor = + AmbientLightModeMonitor(Optional.of(algorithm), sensorManager, Optional.empty()) + + val callback = mock(AmbientLightModeMonitor.Callback::class.java) + ambientLightModeMonitor.start(callback) + + verify(sensorManager, never()).registerListener(any(), any(Sensor::class.java), anyInt()) + } + + // Captures [SensorEventListener], assuming it has been registered with [sensorManager]. + private fun captureSensorEventListener(): SensorEventListener { + val captor = ArgumentCaptor.forClass(SensorEventListener::class.java) + verify(sensorManager).registerListener(captor.capture(), any(), anyInt()) + return captor.value + } +} diff --git a/packages/SystemUI/tests/src/com/android/systemui/lowlightclock/ChargingStatusProviderTest.java b/packages/SystemUI/tests/src/com/android/systemui/lowlightclock/ChargingStatusProviderTest.java new file mode 100644 index 000000000000..2c8c1e1e70b1 --- /dev/null +++ b/packages/SystemUI/tests/src/com/android/systemui/lowlightclock/ChargingStatusProviderTest.java @@ -0,0 +1,226 @@ +/* + * 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.systemui.lowlightclock; + +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.ArgumentMatchers.eq; +import static org.mockito.Mockito.never; +import static org.mockito.Mockito.times; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; + +import android.content.res.Resources; +import android.os.BatteryManager; +import android.os.RemoteException; +import android.testing.AndroidTestingRunner; + +import androidx.test.filters.SmallTest; + +import com.android.internal.app.IBatteryStats; +import com.android.keyguard.KeyguardUpdateMonitor; +import com.android.keyguard.KeyguardUpdateMonitorCallback; +import com.android.settingslib.fuelgauge.BatteryStatus; +import com.android.systemui.SysuiTestCase; +import com.android.systemui.res.R; + +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.mockito.ArgumentCaptor; +import org.mockito.Mock; +import org.mockito.MockitoAnnotations; + +@SmallTest +@RunWith(AndroidTestingRunner.class) +public class ChargingStatusProviderTest extends SysuiTestCase { + @Mock + private Resources mResources; + @Mock + private IBatteryStats mBatteryInfo; + @Mock + private KeyguardUpdateMonitor mKeyguardUpdateMonitor; + @Mock + private ChargingStatusProvider.Callback mCallback; + + private ChargingStatusProvider mProvider; + + @Before + public void setup() { + MockitoAnnotations.initMocks(this); + + mProvider = new ChargingStatusProvider( + mContext, mResources, mBatteryInfo, mKeyguardUpdateMonitor); + } + + @Test + public void testStartUsingReportsStatusToCallback() { + mProvider.startUsing(mCallback); + verify(mCallback).onChargingStatusChanged(false, null); + } + + @Test + public void testStartUsingRegistersCallbackWithKeyguardUpdateMonitor() { + mProvider.startUsing(mCallback); + verify(mKeyguardUpdateMonitor).registerCallback(any()); + } + + @Test + public void testCallbackNotCalledAfterStopUsing() { + mProvider.startUsing(mCallback); + ArgumentCaptor<KeyguardUpdateMonitorCallback> keyguardUpdateMonitorCallbackArgumentCaptor = + ArgumentCaptor.forClass(KeyguardUpdateMonitorCallback.class); + verify(mKeyguardUpdateMonitor) + .registerCallback(keyguardUpdateMonitorCallbackArgumentCaptor.capture()); + mProvider.stopUsing(); + keyguardUpdateMonitorCallbackArgumentCaptor.getValue() + .onRefreshBatteryInfo(getChargingBattery()); + verify(mCallback, never()).onChargingStatusChanged(eq(true), any()); + } + + @Test + public void testKeyguardUpdateMonitorCallbackRemovedAfterStopUsing() { + mProvider.startUsing(mCallback); + ArgumentCaptor<KeyguardUpdateMonitorCallback> keyguardUpdateMonitorCallbackArgumentCaptor = + ArgumentCaptor.forClass(KeyguardUpdateMonitorCallback.class); + verify(mKeyguardUpdateMonitor) + .registerCallback(keyguardUpdateMonitorCallbackArgumentCaptor.capture()); + mProvider.stopUsing(); + verify(mKeyguardUpdateMonitor) + .removeCallback(keyguardUpdateMonitorCallbackArgumentCaptor.getValue()); + } + + @Test + public void testChargingStatusReportsHideWhenNotPluggedIn() { + ArgumentCaptor<KeyguardUpdateMonitorCallback> keyguardUpdateMonitorCallbackArgumentCaptor = + ArgumentCaptor.forClass(KeyguardUpdateMonitorCallback.class); + mProvider.startUsing(mCallback); + verify(mKeyguardUpdateMonitor) + .registerCallback(keyguardUpdateMonitorCallbackArgumentCaptor.capture()); + keyguardUpdateMonitorCallbackArgumentCaptor.getValue() + .onRefreshBatteryInfo(getUnpluggedBattery()); + // Once for init() and once for the status change. + verify(mCallback, times(2)).onChargingStatusChanged(false, null); + } + + @Test + public void testChargingStatusReportsShowWhenBatteryOverheated() { + ArgumentCaptor<KeyguardUpdateMonitorCallback> keyguardUpdateMonitorCallbackArgumentCaptor = + ArgumentCaptor.forClass(KeyguardUpdateMonitorCallback.class); + mProvider.startUsing(mCallback); + verify(mCallback).onChargingStatusChanged(false, null); + verify(mKeyguardUpdateMonitor) + .registerCallback(keyguardUpdateMonitorCallbackArgumentCaptor.capture()); + keyguardUpdateMonitorCallbackArgumentCaptor.getValue() + .onRefreshBatteryInfo(getBatteryDefender()); + verify(mCallback).onChargingStatusChanged(eq(true), any()); + } + + @Test + public void testChargingStatusReportsShowWhenPluggedIn() { + ArgumentCaptor<KeyguardUpdateMonitorCallback> keyguardUpdateMonitorCallbackArgumentCaptor = + ArgumentCaptor.forClass(KeyguardUpdateMonitorCallback.class); + mProvider.startUsing(mCallback); + verify(mCallback).onChargingStatusChanged(false, null); + verify(mKeyguardUpdateMonitor) + .registerCallback(keyguardUpdateMonitorCallbackArgumentCaptor.capture()); + keyguardUpdateMonitorCallbackArgumentCaptor.getValue() + .onRefreshBatteryInfo(getChargingBattery()); + verify(mCallback).onChargingStatusChanged(eq(true), any()); + } + + @Test + public void testChargingStatusReportsChargingLimitedWhenOverheated() { + ArgumentCaptor<KeyguardUpdateMonitorCallback> keyguardUpdateMonitorCallbackArgumentCaptor = + ArgumentCaptor.forClass(KeyguardUpdateMonitorCallback.class); + mProvider.startUsing(mCallback); + verify(mCallback).onChargingStatusChanged(false, null); + verify(mKeyguardUpdateMonitor) + .registerCallback(keyguardUpdateMonitorCallbackArgumentCaptor.capture()); + keyguardUpdateMonitorCallbackArgumentCaptor.getValue() + .onRefreshBatteryInfo(getBatteryDefender()); + verify(mResources).getString(eq(R.string.keyguard_plugged_in_charging_limited), any()); + } + + @Test + public void testChargingStatusReportsChargedWhenCharged() { + ArgumentCaptor<KeyguardUpdateMonitorCallback> keyguardUpdateMonitorCallbackArgumentCaptor = + ArgumentCaptor.forClass(KeyguardUpdateMonitorCallback.class); + mProvider.startUsing(mCallback); + verify(mCallback).onChargingStatusChanged(false, null); + verify(mKeyguardUpdateMonitor) + .registerCallback(keyguardUpdateMonitorCallbackArgumentCaptor.capture()); + keyguardUpdateMonitorCallbackArgumentCaptor.getValue() + .onRefreshBatteryInfo(getChargedBattery()); + verify(mResources).getString(R.string.keyguard_charged); + } + + @Test + public void testChargingStatusReportsPluggedInWhenDockedAndChargingTimeUnknown() throws + RemoteException { + ArgumentCaptor<KeyguardUpdateMonitorCallback> keyguardUpdateMonitorCallbackArgumentCaptor = + ArgumentCaptor.forClass(KeyguardUpdateMonitorCallback.class); + mProvider.startUsing(mCallback); + verify(mCallback).onChargingStatusChanged(false, null); + verify(mKeyguardUpdateMonitor) + .registerCallback(keyguardUpdateMonitorCallbackArgumentCaptor.capture()); + when(mBatteryInfo.computeChargeTimeRemaining()).thenReturn(-1L); + keyguardUpdateMonitorCallbackArgumentCaptor.getValue() + .onRefreshBatteryInfo(getChargingBattery()); + verify(mResources).getString( + eq(R.string.keyguard_plugged_in_dock), any()); + } + + @Test + public void testChargingStatusReportsTimeRemainingWhenDockedAndCharging() throws + RemoteException { + ArgumentCaptor<KeyguardUpdateMonitorCallback> keyguardUpdateMonitorCallbackArgumentCaptor = + ArgumentCaptor.forClass(KeyguardUpdateMonitorCallback.class); + mProvider.startUsing(mCallback); + verify(mCallback).onChargingStatusChanged(false, null); + verify(mKeyguardUpdateMonitor) + .registerCallback(keyguardUpdateMonitorCallbackArgumentCaptor.capture()); + when(mBatteryInfo.computeChargeTimeRemaining()).thenReturn(1L); + keyguardUpdateMonitorCallbackArgumentCaptor.getValue() + .onRefreshBatteryInfo(getChargingBattery()); + verify(mResources).getString( + eq(R.string.keyguard_indication_charging_time_dock), any(), any()); + } + + private BatteryStatus getUnpluggedBattery() { + return new BatteryStatus(BatteryManager.BATTERY_STATUS_NOT_CHARGING, + 80, BatteryManager.BATTERY_PLUGGED_ANY, BatteryManager.BATTERY_HEALTH_GOOD, + 0, true); + } + + private BatteryStatus getChargingBattery() { + return new BatteryStatus(BatteryManager.BATTERY_STATUS_CHARGING, + 80, BatteryManager.BATTERY_PLUGGED_DOCK, + BatteryManager.BATTERY_HEALTH_GOOD, 0, true); + } + + private BatteryStatus getChargedBattery() { + return new BatteryStatus(BatteryManager.BATTERY_STATUS_FULL, + 100, BatteryManager.BATTERY_PLUGGED_DOCK, + BatteryManager.BATTERY_HEALTH_GOOD, 0, true); + } + + private BatteryStatus getBatteryDefender() { + return new BatteryStatus(BatteryManager.BATTERY_STATUS_CHARGING, + 80, BatteryManager.BATTERY_PLUGGED_DOCK, + BatteryManager.CHARGING_POLICY_ADAPTIVE_LONGLIFE, 0, true); + } +} diff --git a/packages/SystemUI/tests/src/com/android/systemui/lowlightclock/DirectBootConditionTest.kt b/packages/SystemUI/tests/src/com/android/systemui/lowlightclock/DirectBootConditionTest.kt new file mode 100644 index 000000000000..173f243cb2b0 --- /dev/null +++ b/packages/SystemUI/tests/src/com/android/systemui/lowlightclock/DirectBootConditionTest.kt @@ -0,0 +1,102 @@ +/* + * 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.systemui.lowlightclock + +import android.content.Intent +import android.os.UserManager +import androidx.test.filters.SmallTest +import com.android.systemui.SysuiTestCase +import com.android.systemui.shared.condition.Condition +import com.android.systemui.util.mockito.whenever +import com.google.common.truth.Truth.assertThat +import kotlinx.coroutines.CoroutineScope +import kotlinx.coroutines.ExperimentalCoroutinesApi +import kotlinx.coroutines.test.advanceUntilIdle +import kotlinx.coroutines.test.runTest +import org.junit.Before +import org.junit.Test +import org.mockito.Mock +import org.mockito.MockitoAnnotations + +@SmallTest +@OptIn(ExperimentalCoroutinesApi::class) +class DirectBootConditionTest : SysuiTestCase() { + @Mock private lateinit var userManager: UserManager + @Mock private lateinit var callback: Condition.Callback + + @Before + fun setUp() { + MockitoAnnotations.initMocks(this) + } + + @Test + fun receiverRegisteredOnStart() = runTest { + val condition = buildCondition(this) + // No receivers are registered yet + assertThat(fakeBroadcastDispatcher.numReceiversRegistered).isEqualTo(0) + condition.addCallback(callback) + advanceUntilIdle() + // Receiver is registered after a callback is added + assertThat(fakeBroadcastDispatcher.numReceiversRegistered).isEqualTo(1) + condition.removeCallback(callback) + } + + @Test + fun unregisterReceiverOnStop() = runTest { + val condition = buildCondition(this) + + condition.addCallback(callback) + advanceUntilIdle() + + assertThat(fakeBroadcastDispatcher.numReceiversRegistered).isEqualTo(1) + + condition.removeCallback(callback) + advanceUntilIdle() + + // Receiver is unregistered when nothing is listening to the condition + assertThat(fakeBroadcastDispatcher.numReceiversRegistered).isEqualTo(0) + } + + @Test + fun callbackTriggeredWhenUserUnlocked() = runTest { + val condition = buildCondition(this) + + setUserUnlocked(false) + condition.addCallback(callback) + advanceUntilIdle() + + assertThat(condition.isConditionMet).isTrue() + + setUserUnlocked(true) + advanceUntilIdle() + + assertThat(condition.isConditionMet).isFalse() + condition.removeCallback(callback) + } + + private fun buildCondition(scope: CoroutineScope): DirectBootCondition { + return DirectBootCondition(fakeBroadcastDispatcher, userManager, scope) + } + + private fun setUserUnlocked(unlocked: Boolean) { + whenever(userManager.isUserUnlocked).thenReturn(unlocked) + fakeBroadcastDispatcher.sendIntentToMatchingReceiversOnly( + context, + Intent(Intent.ACTION_USER_UNLOCKED), + ) + } +} diff --git a/packages/SystemUI/tests/src/com/android/systemui/lowlightclock/ForceLowLightConditionTest.java b/packages/SystemUI/tests/src/com/android/systemui/lowlightclock/ForceLowLightConditionTest.java new file mode 100644 index 000000000000..7297e0f3bff5 --- /dev/null +++ b/packages/SystemUI/tests/src/com/android/systemui/lowlightclock/ForceLowLightConditionTest.java @@ -0,0 +1,110 @@ +/* + * 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.systemui.lowlightclock; + +import static com.google.common.truth.Truth.assertThat; + +import static org.mockito.ArgumentMatchers.eq; +import static org.mockito.Mockito.verify; + +import android.testing.AndroidTestingRunner; + +import androidx.test.filters.SmallTest; + +import com.android.systemui.SysuiTestCase; +import com.android.systemui.shared.condition.Condition; +import com.android.systemui.statusbar.commandline.Command; +import com.android.systemui.statusbar.commandline.CommandRegistry; + +import kotlin.jvm.functions.Function0; + +import kotlinx.coroutines.CoroutineScope; + +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.mockito.ArgumentCaptor; +import org.mockito.Mock; +import org.mockito.Mockito; +import org.mockito.MockitoAnnotations; + +import java.io.PrintWriter; +import java.util.Arrays; + +@SmallTest +@RunWith(AndroidTestingRunner.class) +public class ForceLowLightConditionTest extends SysuiTestCase { + @Mock + private CommandRegistry mCommandRegistry; + + @Mock + private Condition.Callback mCallback; + + @Mock + private PrintWriter mPrintWriter; + + @Mock + CoroutineScope mScope; + + private ForceLowLightCondition mCondition; + private Command mCommand; + + @Before + public void setUp() { + MockitoAnnotations.initMocks(this); + mCondition = new ForceLowLightCondition(mScope, mCommandRegistry); + mCondition.addCallback(mCallback); + ArgumentCaptor<Function0<Command>> commandCaptor = + ArgumentCaptor.forClass(Function0.class); + verify(mCommandRegistry).registerCommand(eq(ForceLowLightCondition.COMMAND_ROOT), + commandCaptor.capture()); + mCommand = commandCaptor.getValue().invoke(); + } + + @Test + public void testEnableLowLight() { + mCommand.execute(mPrintWriter, + Arrays.asList(ForceLowLightCondition.COMMAND_ENABLE_LOW_LIGHT)); + verify(mCallback).onConditionChanged(mCondition); + assertThat(mCondition.isConditionSet()).isTrue(); + assertThat(mCondition.isConditionMet()).isTrue(); + } + + @Test + public void testDisableLowLight() { + mCommand.execute(mPrintWriter, + Arrays.asList(ForceLowLightCondition.COMMAND_DISABLE_LOW_LIGHT)); + verify(mCallback).onConditionChanged(mCondition); + assertThat(mCondition.isConditionSet()).isTrue(); + assertThat(mCondition.isConditionMet()).isFalse(); + } + + @Test + public void testClearEnableLowLight() { + mCommand.execute(mPrintWriter, + Arrays.asList(ForceLowLightCondition.COMMAND_ENABLE_LOW_LIGHT)); + verify(mCallback).onConditionChanged(mCondition); + assertThat(mCondition.isConditionSet()).isTrue(); + assertThat(mCondition.isConditionMet()).isTrue(); + Mockito.clearInvocations(mCallback); + mCommand.execute(mPrintWriter, + Arrays.asList(ForceLowLightCondition.COMMAND_CLEAR_LOW_LIGHT)); + verify(mCallback).onConditionChanged(mCondition); + assertThat(mCondition.isConditionSet()).isFalse(); + assertThat(mCondition.isConditionMet()).isFalse(); + } +} diff --git a/packages/SystemUI/tests/src/com/android/systemui/lowlightclock/LowLightClockAnimationProviderTest.kt b/packages/SystemUI/tests/src/com/android/systemui/lowlightclock/LowLightClockAnimationProviderTest.kt new file mode 100644 index 000000000000..663880f098cd --- /dev/null +++ b/packages/SystemUI/tests/src/com/android/systemui/lowlightclock/LowLightClockAnimationProviderTest.kt @@ -0,0 +1,75 @@ +/* + * 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.systemui.lowlightclock + +import android.animation.Animator +import android.testing.AndroidTestingRunner +import android.testing.TestableLooper.RunWithLooper +import androidx.test.filters.SmallTest +import com.android.systemui.SysuiTestCase +import org.junit.Test +import org.junit.runner.RunWith +import org.mockito.kotlin.any +import org.mockito.kotlin.eq +import org.mockito.kotlin.mock +import org.mockito.kotlin.verify + +@SmallTest +@RunWith(AndroidTestingRunner::class) +@RunWithLooper(setAsMainLooper = true) +class LowLightClockAnimationProviderTest : SysuiTestCase() { + + private val underTest by lazy { + LowLightClockAnimationProvider( + Y_TRANSLATION_ANIMATION_OFFSET, + Y_TRANSLATION_ANIMATION_DURATION_MILLIS, + ALPHA_ANIMATION_IN_START_DELAY_MILLIS, + ALPHA_ANIMATION_DURATION_MILLIS, + ) + } + + @Test + fun animationOutEndsImmediatelyIfViewIsNull() { + val animator = underTest.provideAnimationOut(null, null) + + val listener = mock<Animator.AnimatorListener>() + animator.addListener(listener) + + animator.start() + verify(listener).onAnimationStart(any(), eq(false)) + verify(listener).onAnimationEnd(any(), eq(false)) + } + + @Test + fun animationInEndsImmediatelyIfViewIsNull() { + val animator = underTest.provideAnimationIn(null, null) + + val listener = mock<Animator.AnimatorListener>() + animator.addListener(listener) + + animator.start() + verify(listener).onAnimationStart(any(), eq(false)) + verify(listener).onAnimationEnd(any(), eq(false)) + } + + private companion object { + const val Y_TRANSLATION_ANIMATION_OFFSET = 100 + const val Y_TRANSLATION_ANIMATION_DURATION_MILLIS = 100L + const val ALPHA_ANIMATION_IN_START_DELAY_MILLIS = 200L + const val ALPHA_ANIMATION_DURATION_MILLIS = 300L + } +} diff --git a/packages/SystemUI/tests/src/com/android/systemui/lowlightclock/LowLightClockDreamServiceTest.java b/packages/SystemUI/tests/src/com/android/systemui/lowlightclock/LowLightClockDreamServiceTest.java new file mode 100644 index 000000000000..22a13cc41425 --- /dev/null +++ b/packages/SystemUI/tests/src/com/android/systemui/lowlightclock/LowLightClockDreamServiceTest.java @@ -0,0 +1,160 @@ +/* + * 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.systemui.lowlightclock; + +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.ArgumentMatchers.anyBoolean; +import static org.mockito.Mockito.clearInvocations; +import static org.mockito.Mockito.never; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; + +import android.animation.Animator; +import android.os.RemoteException; +import android.testing.AndroidTestingRunner; + +import androidx.test.filters.SmallTest; + +import com.android.dream.lowlight.LowLightTransitionCoordinator; +import com.android.systemui.SysuiTestCase; + +import com.google.android.systemui.lowlightclock.LowLightClockDreamService; + +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.mockito.Mock; +import org.mockito.MockitoAnnotations; + +import java.util.Optional; + +@SmallTest +@RunWith(AndroidTestingRunner.class) +public class LowLightClockDreamServiceTest extends SysuiTestCase { + @Mock + private ChargingStatusProvider mChargingStatusProvider; + @Mock + private LowLightDisplayController mDisplayController; + @Mock + private LowLightClockAnimationProvider mAnimationProvider; + @Mock + private LowLightTransitionCoordinator mLowLightTransitionCoordinator; + @Mock + Animator mAnimationInAnimator; + @Mock + Animator mAnimationOutAnimator; + + private LowLightClockDreamService mService; + + @Before + public void setUp() { + MockitoAnnotations.initMocks(this); + + mService = new LowLightClockDreamService( + mChargingStatusProvider, + mAnimationProvider, + mLowLightTransitionCoordinator, + Optional.of(() -> mDisplayController)); + + when(mAnimationProvider.provideAnimationIn(any(), any())).thenReturn(mAnimationInAnimator); + when(mAnimationProvider.provideAnimationOut(any())).thenReturn( + mAnimationOutAnimator); + } + + @Test + public void testSetDbmStateWhenSupported() throws RemoteException { + when(mDisplayController.isDisplayBrightnessModeSupported()).thenReturn(true); + + mService.onDreamingStarted(); + + verify(mDisplayController).setDisplayBrightnessModeEnabled(true); + } + + @Test + public void testNotSetDbmStateWhenNotSupported() throws RemoteException { + when(mDisplayController.isDisplayBrightnessModeSupported()).thenReturn(false); + + mService.onDreamingStarted(); + + verify(mDisplayController, never()).setDisplayBrightnessModeEnabled(anyBoolean()); + } + + @Test + public void testClearDbmState() throws RemoteException { + when(mDisplayController.isDisplayBrightnessModeSupported()).thenReturn(true); + + mService.onDreamingStarted(); + clearInvocations(mDisplayController); + + mService.onDreamingStopped(); + + verify(mDisplayController).setDisplayBrightnessModeEnabled(false); + } + + @Test + public void testAnimationsStartedOnDreamingStarted() { + mService.onDreamingStarted(); + + // Entry animation started. + verify(mAnimationInAnimator).start(); + } + + @Test + public void testAnimationsStartedOnWakeUp() { + // Start dreaming then wake up. + mService.onDreamingStarted(); + mService.onWakeUp(); + + // Entry animation started. + verify(mAnimationInAnimator).cancel(); + + // Exit animation started. + verify(mAnimationOutAnimator).start(); + } + + @Test + public void testAnimationsStartedBeforeExitingLowLight() { + mService.onBeforeExitLowLight(); + + // Exit animation started. + verify(mAnimationOutAnimator).start(); + } + + @Test + public void testWakeUpAnimationCancelledOnDetach() { + mService.onWakeUp(); + + // Exit animation started. + verify(mAnimationOutAnimator).start(); + + mService.onDetachedFromWindow(); + + verify(mAnimationOutAnimator).cancel(); + } + + @Test + public void testExitLowLightAnimationCancelledOnDetach() { + mService.onBeforeExitLowLight(); + + // Exit animation started. + verify(mAnimationOutAnimator).start(); + + mService.onDetachedFromWindow(); + + verify(mAnimationOutAnimator).cancel(); + } +} diff --git a/packages/SystemUI/tests/src/com/android/systemui/lowlightclock/LowLightConditionTest.java b/packages/SystemUI/tests/src/com/android/systemui/lowlightclock/LowLightConditionTest.java new file mode 100644 index 000000000000..2c216244985e --- /dev/null +++ b/packages/SystemUI/tests/src/com/android/systemui/lowlightclock/LowLightConditionTest.java @@ -0,0 +1,143 @@ +/* + * 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.systemui.lowlightclock; + +import static com.google.common.truth.Truth.assertThat; + +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.Mockito.never; +import static org.mockito.Mockito.reset; +import static org.mockito.Mockito.times; +import static org.mockito.Mockito.verify; + +import android.testing.AndroidTestingRunner; + +import androidx.test.filters.SmallTest; + +import com.android.internal.logging.UiEventLogger; +import com.android.systemui.SysuiTestCase; + +import kotlinx.coroutines.CoroutineScope; + +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.mockito.ArgumentCaptor; +import org.mockito.Mock; +import org.mockito.MockitoAnnotations; + +@SmallTest +@RunWith(AndroidTestingRunner.class) +public class LowLightConditionTest extends SysuiTestCase { + @Mock + private AmbientLightModeMonitor mAmbientLightModeMonitor; + @Mock + private UiEventLogger mUiEventLogger; + @Mock + CoroutineScope mScope; + private LowLightCondition mCondition; + + @Before + public void setUp() { + MockitoAnnotations.initMocks(this); + + mCondition = new LowLightCondition(mScope, mAmbientLightModeMonitor, mUiEventLogger); + mCondition.start(); + } + + @Test + public void testLowLightFalse() { + changeLowLightMode(AmbientLightModeMonitor.AMBIENT_LIGHT_MODE_LIGHT); + assertThat(mCondition.isConditionMet()).isFalse(); + } + + @Test + public void testLowLightTrue() { + changeLowLightMode(AmbientLightModeMonitor.AMBIENT_LIGHT_MODE_DARK); + assertThat(mCondition.isConditionMet()).isTrue(); + } + + @Test + public void testUndecidedLowLightStateIgnored() { + changeLowLightMode(AmbientLightModeMonitor.AMBIENT_LIGHT_MODE_DARK); + assertThat(mCondition.isConditionMet()).isTrue(); + changeLowLightMode(AmbientLightModeMonitor.AMBIENT_LIGHT_MODE_UNDECIDED); + assertThat(mCondition.isConditionMet()).isTrue(); + } + + @Test + public void testLowLightChange() { + changeLowLightMode(AmbientLightModeMonitor.AMBIENT_LIGHT_MODE_LIGHT); + assertThat(mCondition.isConditionMet()).isFalse(); + changeLowLightMode(AmbientLightModeMonitor.AMBIENT_LIGHT_MODE_DARK); + assertThat(mCondition.isConditionMet()).isTrue(); + } + + @Test + public void testResetIsConditionMetUponStop() { + changeLowLightMode(AmbientLightModeMonitor.AMBIENT_LIGHT_MODE_DARK); + assertThat(mCondition.isConditionMet()).isTrue(); + + mCondition.stop(); + assertThat(mCondition.isConditionMet()).isFalse(); + } + + @Test + public void testLoggingAmbientLightNotLowToLow() { + changeLowLightMode(AmbientLightModeMonitor.AMBIENT_LIGHT_MODE_DARK); + // Only logged once. + verify(mUiEventLogger, times(1)).log(any()); + // Logged with the correct state. + verify(mUiEventLogger).log(LowLightDockEvent.AMBIENT_LIGHT_TO_DARK); + } + + @Test + public void testLoggingAmbientLightLowToLow() { + changeLowLightMode(AmbientLightModeMonitor.AMBIENT_LIGHT_MODE_DARK); + reset(mUiEventLogger); + + changeLowLightMode(AmbientLightModeMonitor.AMBIENT_LIGHT_MODE_DARK); + // Doesn't log. + verify(mUiEventLogger, never()).log(any()); + } + + @Test + public void testLoggingAmbientLightNotLowToNotLow() { + changeLowLightMode(AmbientLightModeMonitor.AMBIENT_LIGHT_MODE_LIGHT); + // Doesn't log. + verify(mUiEventLogger, never()).log(any()); + } + + @Test + public void testLoggingAmbientLightLowToNotLow() { + changeLowLightMode(AmbientLightModeMonitor.AMBIENT_LIGHT_MODE_DARK); + reset(mUiEventLogger); + + changeLowLightMode(AmbientLightModeMonitor.AMBIENT_LIGHT_MODE_LIGHT); + // Only logged once. + verify(mUiEventLogger).log(any()); + // Logged with the correct state. + verify(mUiEventLogger).log(LowLightDockEvent.AMBIENT_LIGHT_TO_LIGHT); + } + + private void changeLowLightMode(int mode) { + ArgumentCaptor<AmbientLightModeMonitor.Callback> ambientLightCallbackCaptor = + ArgumentCaptor.forClass(AmbientLightModeMonitor.Callback.class); + verify(mAmbientLightModeMonitor).start(ambientLightCallbackCaptor.capture()); + ambientLightCallbackCaptor.getValue().onChange(mode); + } +} diff --git a/packages/SystemUI/tests/src/com/android/systemui/lowlightclock/LowLightMonitorTest.java b/packages/SystemUI/tests/src/com/android/systemui/lowlightclock/LowLightMonitorTest.java new file mode 100644 index 000000000000..69485e848a6a --- /dev/null +++ b/packages/SystemUI/tests/src/com/android/systemui/lowlightclock/LowLightMonitorTest.java @@ -0,0 +1,183 @@ +/* + * 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.systemui.lowlightclock; + +import static com.android.dream.lowlight.LowLightDreamManager.AMBIENT_LIGHT_MODE_LOW_LIGHT; +import static com.android.dream.lowlight.LowLightDreamManager.AMBIENT_LIGHT_MODE_REGULAR; +import static com.android.systemui.keyguard.ScreenLifecycle.SCREEN_ON; + +import static com.google.common.truth.Truth.assertThat; + +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.never; +import static org.mockito.Mockito.times; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; + +import android.content.ComponentName; +import android.content.pm.PackageManager; +import android.testing.AndroidTestingRunner; + +import androidx.test.filters.SmallTest; + +import com.android.dream.lowlight.LowLightDreamManager; +import com.android.systemui.SysuiTestCase; +import com.android.systemui.keyguard.ScreenLifecycle; +import com.android.systemui.shared.condition.Condition; +import com.android.systemui.shared.condition.Monitor; + +import dagger.Lazy; + +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.mockito.ArgumentCaptor; +import org.mockito.Captor; +import org.mockito.Mock; +import org.mockito.MockitoAnnotations; + +import java.util.Set; + +@SmallTest +@RunWith(AndroidTestingRunner.class) +public class LowLightMonitorTest extends SysuiTestCase { + + @Mock + private Lazy<LowLightDreamManager> mLowLightDreamManagerLazy; + @Mock + private LowLightDreamManager mLowLightDreamManager; + @Mock + private Monitor mMonitor; + @Mock + private ScreenLifecycle mScreenLifecycle; + @Mock + private LowLightLogger mLogger; + + private LowLightMonitor mLowLightMonitor; + + @Mock + Lazy<Set<Condition>> mLazyConditions; + + @Mock + private PackageManager mPackageManager; + + @Mock + private ComponentName mDreamComponent; + + Condition mCondition = mock(Condition.class); + Set<Condition> mConditionSet = Set.of(mCondition); + + @Captor + ArgumentCaptor<Monitor.Subscription> mPreconditionsSubscriptionCaptor; + + @Before + public void setUp() { + MockitoAnnotations.initMocks(this); + when(mLowLightDreamManagerLazy.get()).thenReturn(mLowLightDreamManager); + when(mLazyConditions.get()).thenReturn(mConditionSet); + mLowLightMonitor = new LowLightMonitor(mLowLightDreamManagerLazy, + mMonitor, mLazyConditions, mScreenLifecycle, mLogger, mDreamComponent, + mPackageManager); + } + + @Test + public void testSetAmbientLowLightWhenInLowLight() { + mLowLightMonitor.onConditionsChanged(true); + // Verify setting low light when condition is true + verify(mLowLightDreamManager).setAmbientLightMode(AMBIENT_LIGHT_MODE_LOW_LIGHT); + } + + @Test + public void testExitAmbientLowLightWhenNotInLowLight() { + mLowLightMonitor.onConditionsChanged(true); + mLowLightMonitor.onConditionsChanged(false); + // Verify ambient light toggles back to light mode regular + verify(mLowLightDreamManager).setAmbientLightMode(AMBIENT_LIGHT_MODE_REGULAR); + } + + @Test + public void testStartMonitorLowLightConditionsWhenScreenTurnsOn() { + mLowLightMonitor.onScreenTurnedOn(); + + // Verify subscribing to low light conditions monitor when screen turns on. + verify(mMonitor).addSubscription(any()); + } + + @Test + public void testStopMonitorLowLightConditionsWhenScreenTurnsOff() { + final Monitor.Subscription.Token token = mock(Monitor.Subscription.Token.class); + when(mMonitor.addSubscription(any())).thenReturn(token); + mLowLightMonitor.onScreenTurnedOn(); + + // Verify removing subscription when screen turns off. + mLowLightMonitor.onScreenTurnedOff(); + verify(mMonitor).removeSubscription(token); + } + + @Test + public void testSubscribeToLowLightConditionsOnlyOnceWhenScreenTurnsOn() { + final Monitor.Subscription.Token token = mock(Monitor.Subscription.Token.class); + when(mMonitor.addSubscription(any())).thenReturn(token); + + mLowLightMonitor.onScreenTurnedOn(); + mLowLightMonitor.onScreenTurnedOn(); + // Verify subscription is only added once. + verify(mMonitor, times(1)).addSubscription(any()); + } + + @Test + public void testSubscribedToExpectedConditions() { + final Monitor.Subscription.Token token = mock(Monitor.Subscription.Token.class); + when(mMonitor.addSubscription(any())).thenReturn(token); + + mLowLightMonitor.onScreenTurnedOn(); + mLowLightMonitor.onScreenTurnedOn(); + Set<Condition> conditions = captureConditions(); + // Verify Monitor is subscribed to the expected conditions + assertThat(conditions).isEqualTo(mConditionSet); + } + + @Test + public void testNotUnsubscribeIfNotSubscribedWhenScreenTurnsOff() { + mLowLightMonitor.onScreenTurnedOff(); + + // Verify doesn't remove subscription since there is none. + verify(mMonitor, never()).removeSubscription(any()); + } + + @Test + public void testSubscribeIfScreenIsOnWhenStarting() { + when(mScreenLifecycle.getScreenState()).thenReturn(SCREEN_ON); + mLowLightMonitor.start(); + // Verify to add subscription on start if the screen state is on + verify(mMonitor, times(1)).addSubscription(any()); + } + + @Test + public void testNoSubscribeIfDreamNotPresent() { + LowLightMonitor lowLightMonitor = new LowLightMonitor(mLowLightDreamManagerLazy, + mMonitor, mLazyConditions, mScreenLifecycle, mLogger, null, mPackageManager); + when(mScreenLifecycle.getScreenState()).thenReturn(SCREEN_ON); + lowLightMonitor.start(); + verify(mScreenLifecycle, never()).addObserver(any()); + } + + private Set<Condition> captureConditions() { + verify(mMonitor).addSubscription(mPreconditionsSubscriptionCaptor.capture()); + return mPreconditionsSubscriptionCaptor.getValue().getConditions(); + } +} diff --git a/packages/SystemUI/tests/src/com/android/systemui/lowlightclock/ScreenSaverEnabledConditionTest.java b/packages/SystemUI/tests/src/com/android/systemui/lowlightclock/ScreenSaverEnabledConditionTest.java new file mode 100644 index 000000000000..366c071fb93f --- /dev/null +++ b/packages/SystemUI/tests/src/com/android/systemui/lowlightclock/ScreenSaverEnabledConditionTest.java @@ -0,0 +1,108 @@ +/* + * 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.systemui.lowlightclock; + +import static com.google.common.truth.Truth.assertThat; + +import static org.mockito.ArgumentMatchers.anyInt; +import static org.mockito.ArgumentMatchers.eq; +import static org.mockito.Mockito.doReturn; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; + +import android.content.res.Resources; +import android.database.ContentObserver; +import android.os.UserHandle; +import android.provider.Settings; +import android.testing.AndroidTestingRunner; + +import androidx.test.filters.SmallTest; + +import com.android.systemui.SysuiTestCase; +import com.android.systemui.util.settings.SecureSettings; + +import kotlinx.coroutines.CoroutineScope; + +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.mockito.ArgumentCaptor; +import org.mockito.Captor; +import org.mockito.Mock; +import org.mockito.MockitoAnnotations; + +@SmallTest +@RunWith(AndroidTestingRunner.class) +public class ScreenSaverEnabledConditionTest extends SysuiTestCase { + @Mock + private Resources mResources; + @Mock + private SecureSettings mSecureSettings; + @Mock + CoroutineScope mScope; + @Captor + private ArgumentCaptor<ContentObserver> mSettingsObserverCaptor; + private ScreenSaverEnabledCondition mCondition; + + @Before + public void setUp() { + MockitoAnnotations.initMocks(this); + // Default dreams to enabled by default + doReturn(true).when(mResources).getBoolean( + com.android.internal.R.bool.config_dreamsEnabledByDefault); + + mCondition = new ScreenSaverEnabledCondition(mScope, mResources, mSecureSettings); + } + + @Test + public void testScreenSaverInitiallyEnabled() { + setScreenSaverEnabled(true); + mCondition.start(); + assertThat(mCondition.isConditionMet()).isTrue(); + } + + @Test + public void testScreenSaverInitiallyDisabled() { + setScreenSaverEnabled(false); + mCondition.start(); + assertThat(mCondition.isConditionMet()).isFalse(); + } + + @Test + public void testScreenSaverStateChanges() { + setScreenSaverEnabled(false); + mCondition.start(); + assertThat(mCondition.isConditionMet()).isFalse(); + + setScreenSaverEnabled(true); + final ContentObserver observer = captureSettingsObserver(); + observer.onChange(/* selfChange= */ false); + assertThat(mCondition.isConditionMet()).isTrue(); + } + + private void setScreenSaverEnabled(boolean enabled) { + when(mSecureSettings.getIntForUser(eq(Settings.Secure.SCREENSAVER_ENABLED), anyInt(), + eq(UserHandle.USER_CURRENT))).thenReturn(enabled ? 1 : 0); + } + + private ContentObserver captureSettingsObserver() { + verify(mSecureSettings).registerContentObserverForUserSync( + eq(Settings.Secure.SCREENSAVER_ENABLED), + mSettingsObserverCaptor.capture(), eq(UserHandle.USER_CURRENT)); + return mSettingsObserverCaptor.getValue(); + } +} |