Convert SysUiState to kotlin to prepare multi-display refactor (94e94532) · Commits · e / os / android_frameworks_base

packages/SystemUI/src/com/android/systemui/model/SysUiState.java→packages/SystemUI/src/com/android/systemui/model/SysUiState.kt

+140 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2019 The Android Open Source Project
		* Copyright (C) 2025 The Android Open Source Project
		*
		* Licensed under the Apache License, Version 2.0 (the "License");
		* you may not use this file except in compliance with the License.
		@@ -13,139 +13,128 @@
		* See the License for the specific language governing permissions and
		* limitations under the License.
		*/

		package com.android.systemui.model;

		import android.annotation.NonNull;
		import android.util.Log;

		import com.android.systemui.Dumpable;
		import com.android.systemui.dagger.SysUISingleton;
		import com.android.systemui.settings.DisplayTracker;
		import com.android.systemui.shared.system.QuickStepContract;
		import com.android.systemui.shared.system.QuickStepContract.SystemUiStateFlags;

		import dalvik.annotation.optimization.NeverCompile;

		import java.io.PrintWriter;
		import java.util.ArrayList;
		import java.util.List;

		/**
		* Contains sysUi state flags and notifies registered
		* listeners whenever changes happen.
		*/
		package com.android.systemui.model

		import android.util.Log
		import com.android.systemui.Dumpable
		import com.android.systemui.dagger.SysUISingleton
		import com.android.systemui.settings.DisplayTracker
		import com.android.systemui.shared.system.QuickStepContract
		import com.android.systemui.shared.system.QuickStepContract.SystemUiStateFlags
		import dalvik.annotation.optimization.NeverCompile
		import java.io.PrintWriter

		/** Contains sysUi state flags and notifies registered listeners whenever changes happen. */
		@SysUISingleton
		public class SysUiState implements Dumpable {

		private static final String TAG = SysUiState.class.getSimpleName();
		public static final boolean DEBUG = false;
		class SysUiState(
		private val displayTracker: DisplayTracker,
		private val sceneContainerPlugin: SceneContainerPlugin?,
		) : Dumpable {
		/** Returns the current sysui state flags. */
		@get:SystemUiStateFlags
		@SystemUiStateFlags
		var flags: Long = 0
		private set

		private final DisplayTracker mDisplayTracker;
		private final SceneContainerPlugin mSceneContainerPlugin;
		private @SystemUiStateFlags long mFlags;
		private final List<SysUiStateCallback> mCallbacks = new ArrayList<>();
		private long mFlagsToSet = 0;
		private long mFlagsToClear = 0;

		public SysUiState(DisplayTracker displayTracker, SceneContainerPlugin sceneContainerPlugin) {
		mDisplayTracker = displayTracker;
		mSceneContainerPlugin = sceneContainerPlugin;
		}
		private val callbacks: MutableList<SysUiStateCallback> = ArrayList()
		private var flagsToSet: Long = 0
		private var flagsToClear: Long = 0

		/**
		* Add listener to be notified of changes made to SysUI state.
		* The callback will also be called as part of this function.
		* Add listener to be notified of changes made to SysUI state. The callback will also be called
		* as part of this function.
		*/
		public void addCallback(@NonNull SysUiStateCallback callback) {
		mCallbacks.add(callback);
		callback.onSystemUiStateChanged(mFlags);
		fun addCallback(callback: SysUiStateCallback) {
		callbacks.add(callback)
		callback.onSystemUiStateChanged(flags)
		}

		/** Callback will no longer receive events on state change */
		public void removeCallback(@NonNull SysUiStateCallback callback) {
		mCallbacks.remove(callback);
		}

		/** Returns the current sysui state flags. */
		@SystemUiStateFlags
		public long getFlags() {
		return mFlags;
		fun removeCallback(callback: SysUiStateCallback) {
		callbacks.remove(callback)
		}

		public boolean isFlagEnabled(@SystemUiStateFlags long flag) {
		return (mFlags & flag) != 0;
		fun isFlagEnabled(@SystemUiStateFlags flag: Long): Boolean {
		return (flags and flag) != 0L
		}

		/** Methods to this call can be chained together before calling {@link #commitUpdate(int)}. */
		public SysUiState setFlag(@SystemUiStateFlags long flag, boolean enabled) {
		final Boolean overrideOrNull = mSceneContainerPlugin != null
		? mSceneContainerPlugin.flagValueOverride(flag) : null;
		/** Methods to this call can be chained together before calling [.commitUpdate]. */
		fun setFlag(@SystemUiStateFlags flag: Long, enabled: Boolean): SysUiState {
		var enabled = enabled
		val overrideOrNull = sceneContainerPlugin?.flagValueOverride(flag)
		if (overrideOrNull != null && enabled != overrideOrNull) {
		if (DEBUG) {
		Log.d(TAG, "setFlag for flag " + flag + " and value " + enabled + " overridden to "
		+ overrideOrNull + " by scene container plugin");
		Log.d(
		TAG,
		"setFlag for flag $flag and value $enabled overridden to $overrideOrNull by scene container plugin",
		)
		}

		enabled = overrideOrNull;
		enabled = overrideOrNull
		}

		if (enabled) {
		mFlagsToSet \|= flag;
		flagsToSet = flagsToSet or flag
		} else {
		mFlagsToClear \|= flag;
		flagsToClear = flagsToClear or flag
		}
		return this;
		return this
		}

		/** Call to save all the flags updated from {@link #setFlag(long, boolean)}. */
		public void commitUpdate(int displayId) {
		updateFlags(displayId);
		mFlagsToSet = 0;
		mFlagsToClear = 0;
		/** Call to save all the flags updated from [.setFlag]. */
		fun commitUpdate(displayId: Int) {
		updateFlags(displayId)
		flagsToSet = 0
		flagsToClear = 0
		}

		private void updateFlags(int displayId) {
		if (displayId != mDisplayTracker.getDefaultDisplayId()) {
		private fun updateFlags(displayId: Int) {
		if (displayId != displayTracker.defaultDisplayId) {
		// Ignore non-default displays for now
		Log.w(TAG, "Ignoring flag update for display: " + displayId, new Throwable());
		return;
		Log.w(TAG, "Ignoring flag update for display: $displayId", Throwable())
		return
		}

		long newState = mFlags;
		newState \|= mFlagsToSet;
		newState &= ~mFlagsToClear;
		notifyAndSetSystemUiStateChanged(newState, mFlags);
		var newState = flags
		newState = newState or flagsToSet
		newState = newState and flagsToClear.inv()
		notifyAndSetSystemUiStateChanged(newState, flags)
		}

		/** Notify all those who are registered that the state has changed. */
		private void notifyAndSetSystemUiStateChanged(long newFlags, long oldFlags) {
		private fun notifyAndSetSystemUiStateChanged(newFlags: Long, oldFlags: Long) {
		if (DEBUG) {
		Log.d(TAG, "SysUiState changed: old=" + oldFlags + " new=" + newFlags);
		Log.d(TAG, "SysUiState changed: old=$oldFlags new=$newFlags")
		}
		if (newFlags != oldFlags) {
		mCallbacks.forEach(callback -> callback.onSystemUiStateChanged(newFlags));
		mFlags = newFlags;
		callbacks.forEach { callback: SysUiStateCallback ->
		callback.onSystemUiStateChanged(newFlags)
		}

		flags = newFlags
		}
		}

		@NeverCompile
		@Override
		public void dump(PrintWriter pw, String[] args) {
		pw.println("SysUiState state:");
		pw.print(" mSysUiStateFlags="); pw.println(mFlags);
		pw.println(" " + QuickStepContract.getSystemUiStateString(mFlags));
		pw.print(" backGestureDisabled=");
		pw.println(QuickStepContract.isBackGestureDisabled(mFlags, false /* forTrackpad */));
		pw.print(" assistantGestureDisabled=");
		pw.println(QuickStepContract.isAssistantGestureDisabled(mFlags));
		override fun dump(pw: PrintWriter, args: Array<String>) {
		pw.println("SysUiState state:")
		pw.print(" mSysUiStateFlags=")
		pw.println(flags)
		pw.println(" " + QuickStepContract.getSystemUiStateString(flags))
		pw.print(" backGestureDisabled=")
		pw.println(QuickStepContract.isBackGestureDisabled(flags, false /* forTrackpad */))
		pw.print(" assistantGestureDisabled=")
		pw.println(QuickStepContract.isAssistantGestureDisabled(flags))
		}

		/** Callback to be notified whenever system UI state flags are changed. */
		public interface SysUiStateCallback{
		interface SysUiStateCallback {
		/** To be called when any SysUiStateFlag gets updated */
		void onSystemUiStateChanged(@SystemUiStateFlags long sysUiFlags);
		}
		fun onSystemUiStateChanged(@SystemUiStateFlags sysUiFlags: Long)
		}


		companion object {
		private val TAG: String = SysUiState::class.java.simpleName
		const val DEBUG: Boolean = false
		}
		}