Merge "Convert SysUiState to kotlin to prepare multi-display refactor" into main

/*

 * 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.

 * 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

    }

}