Files
Flexera-Launcher/quickstep/src/com/android/quickstep/MultiStateCallback.java
T
Zak Cohen 3eeb41de9a Rename flag IS_DOGFOOD to IS_STUDIO.
The flag is only set when building from Android Studio... and is never
used for dogfood.

Test: local
Change-Id: I898d585f4558c2437f0152ef102bea59c351f80b
2020-02-14 14:19:59 -08:00

178 lines
5.9 KiB
Java

/*
* Copyright (C) 2017 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.quickstep;
import static com.android.launcher3.Utilities.postAsyncCallback;
import static com.android.launcher3.util.Executors.MAIN_EXECUTOR;
import android.os.Looper;
import android.util.Log;
import android.util.SparseArray;
import com.android.launcher3.config.FeatureFlags;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.StringJoiner;
import java.util.function.Consumer;
/**
* Utility class to help manage multiple callbacks based on different states.
*/
public class MultiStateCallback {
private static final String TAG = "MultiStateCallback";
public static final boolean DEBUG_STATES = false;
private final SparseArray<LinkedList<Runnable>> mCallbacks = new SparseArray<>();
private final SparseArray<ArrayList<Consumer<Boolean>>> mStateChangeListeners =
new SparseArray<>();
private final String[] mStateNames;
private int mState = 0;
public MultiStateCallback(String[] stateNames) {
mStateNames = DEBUG_STATES ? stateNames : null;
}
/**
* Adds the provided state flags to the global state on the UI thread and executes any callbacks
* as a result.
*/
public void setStateOnUiThread(int stateFlag) {
if (Looper.myLooper() == Looper.getMainLooper()) {
setState(stateFlag);
} else {
postAsyncCallback(MAIN_EXECUTOR.getHandler(), () -> setState(stateFlag));
}
}
/**
* Adds the provided state flags to the global state and executes any callbacks as a result.
*/
public void setState(int stateFlag) {
if (DEBUG_STATES) {
Log.d(TAG, "[" + System.identityHashCode(this) + "] Adding "
+ convertToFlagNames(stateFlag) + " to " + convertToFlagNames(mState));
}
final int oldState = mState;
mState = mState | stateFlag;
int count = mCallbacks.size();
for (int i = 0; i < count; i++) {
int state = mCallbacks.keyAt(i);
if ((mState & state) == state) {
LinkedList<Runnable> callbacks = mCallbacks.valueAt(i);
while (!callbacks.isEmpty()) {
callbacks.pollFirst().run();
}
}
}
notifyStateChangeListeners(oldState);
}
/**
* Adds the provided state flags to the global state and executes any change handlers
* as a result.
*/
public void clearState(int stateFlag) {
if (DEBUG_STATES) {
Log.d(TAG, "[" + System.identityHashCode(this) + "] Removing "
+ convertToFlagNames(stateFlag) + " from " + convertToFlagNames(mState));
}
int oldState = mState;
mState = mState & ~stateFlag;
notifyStateChangeListeners(oldState);
}
private void notifyStateChangeListeners(int oldState) {
int count = mStateChangeListeners.size();
for (int i = 0; i < count; i++) {
int state = mStateChangeListeners.keyAt(i);
boolean wasOn = (state & oldState) == state;
boolean isOn = (state & mState) == state;
if (wasOn != isOn) {
ArrayList<Consumer<Boolean>> listeners = mStateChangeListeners.valueAt(i);
for (Consumer<Boolean> listener : listeners) {
listener.accept(isOn);
}
}
}
}
/**
* Sets a callback to be run when the provided states in the given {@param stateMask} is
* enabled. The callback is only run *once*, and if the states are already set at the time of
* this call then the callback will be made immediately.
*/
public void runOnceAtState(int stateMask, Runnable callback) {
if ((mState & stateMask) == stateMask) {
callback.run();
} else {
final LinkedList<Runnable> callbacks;
if (mCallbacks.indexOfKey(stateMask) >= 0) {
callbacks = mCallbacks.get(stateMask);
if (FeatureFlags.IS_STUDIO_BUILD && callbacks.contains(callback)) {
throw new IllegalStateException("Existing callback for state found");
}
} else {
callbacks = new LinkedList<>();
mCallbacks.put(stateMask, callbacks);
}
callbacks.add(callback);
}
}
/**
* Adds a persistent listener to be called states in the given {@param stateMask} are enabled
* or disabled.
*/
public void addChangeListener(int stateMask, Consumer<Boolean> listener) {
final ArrayList<Consumer<Boolean>> listeners;
if (mStateChangeListeners.indexOfKey(stateMask) >= 0) {
listeners = mStateChangeListeners.get(stateMask);
} else {
listeners = new ArrayList<>();
mStateChangeListeners.put(stateMask, listeners);
}
listeners.add(listener);
}
public int getState() {
return mState;
}
public boolean hasStates(int stateMask) {
return (mState & stateMask) == stateMask;
}
private String convertToFlagNames(int flags) {
StringJoiner joiner = new StringJoiner(", ", "[", " (" + flags + ")]");
for (int i = 0; i < mStateNames.length; i++) {
if ((flags & (1 << i)) != 0) {
joiner.add(mStateNames[i]);
}
}
return joiner.toString();
}
}