/*
|
* Copyright (C) 2018 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.server.wm;
|
|
import static android.view.InsetsState.TYPE_IME;
|
import static android.view.InsetsState.TYPE_NAVIGATION_BAR;
|
import static android.view.InsetsState.TYPE_TOP_BAR;
|
import static android.view.ViewRootImpl.NEW_INSETS_MODE_FULL;
|
import static android.view.ViewRootImpl.NEW_INSETS_MODE_NONE;
|
import static android.view.ViewRootImpl.sNewInsetsMode;
|
|
import android.annotation.NonNull;
|
import android.annotation.Nullable;
|
import android.util.ArrayMap;
|
import android.util.ArraySet;
|
import android.util.SparseArray;
|
import android.view.InsetsSource;
|
import android.view.InsetsSourceControl;
|
import android.view.InsetsState;
|
import android.view.ViewRootImpl;
|
|
import java.io.PrintWriter;
|
import java.util.ArrayList;
|
import java.util.function.Consumer;
|
|
/**
|
* Manages global window inset state in the system represented by {@link InsetsState}.
|
*/
|
class InsetsStateController {
|
|
private final InsetsState mLastState = new InsetsState();
|
private final InsetsState mState = new InsetsState();
|
private final DisplayContent mDisplayContent;
|
|
private final ArrayMap<Integer, InsetsSourceProvider> mControllers = new ArrayMap<>();
|
private final ArrayMap<WindowState, ArrayList<Integer>> mWinControlTypeMap = new ArrayMap<>();
|
private final SparseArray<WindowState> mTypeWinControlMap = new SparseArray<>();
|
private final ArraySet<WindowState> mPendingControlChanged = new ArraySet<>();
|
|
private final Consumer<WindowState> mDispatchInsetsChanged = w -> {
|
if (w.isVisible()) {
|
w.notifyInsetsChanged();
|
}
|
};
|
|
InsetsStateController(DisplayContent displayContent) {
|
mDisplayContent = displayContent;
|
}
|
|
/**
|
* When dispatching window state to the client, we'll need to exclude the source that represents
|
* the window that is being dispatched.
|
*
|
* @param target The client we dispatch the state to.
|
* @return The state stripped of the necessary information.
|
*/
|
InsetsState getInsetsForDispatch(WindowState target) {
|
final InsetsSourceProvider provider = target.getInsetProvider();
|
if (provider == null) {
|
return mState;
|
}
|
|
final InsetsState state = new InsetsState();
|
state.set(mState);
|
final int type = provider.getSource().getType();
|
state.removeSource(type);
|
|
// Navigation bar doesn't get influenced by anything else
|
if (type == TYPE_NAVIGATION_BAR) {
|
state.removeSource(TYPE_IME);
|
state.removeSource(TYPE_TOP_BAR);
|
}
|
return state;
|
}
|
|
@Nullable InsetsSourceControl[] getControlsForDispatch(WindowState target) {
|
ArrayList<Integer> controlled = mWinControlTypeMap.get(target);
|
if (controlled == null) {
|
return null;
|
}
|
final int size = controlled.size();
|
final InsetsSourceControl[] result = new InsetsSourceControl[size];
|
for (int i = 0; i < size; i++) {
|
result[i] = mControllers.get(controlled.get(i)).getControl();
|
}
|
return result;
|
}
|
|
/**
|
* @return The provider of a specific type.
|
*/
|
InsetsSourceProvider getSourceProvider(int type) {
|
return mControllers.computeIfAbsent(type,
|
key -> new InsetsSourceProvider(mState.getSource(key), this, mDisplayContent));
|
}
|
|
/**
|
* Called when a layout pass has occurred.
|
*/
|
void onPostLayout() {
|
mState.setDisplayFrame(mDisplayContent.getBounds());
|
for (int i = mControllers.size() - 1; i>= 0; i--) {
|
mControllers.valueAt(i).onPostLayout();
|
}
|
if (!mLastState.equals(mState)) {
|
mLastState.set(mState, true /* copySources */);
|
notifyInsetsChanged();
|
}
|
}
|
|
void onInsetsModified(WindowState windowState, InsetsState state) {
|
boolean changed = false;
|
for (int i = state.getSourcesCount() - 1; i >= 0; i--) {
|
final InsetsSource source = state.sourceAt(i);
|
final InsetsSourceProvider provider = mControllers.get(source.getType());
|
if (provider == null) {
|
continue;
|
}
|
changed |= provider.onInsetsModified(windowState, source);
|
}
|
if (changed) {
|
notifyInsetsChanged();
|
}
|
}
|
|
void onImeTargetChanged(@Nullable WindowState imeTarget) {
|
onControlChanged(TYPE_IME, imeTarget);
|
notifyPendingInsetsControlChanged();
|
}
|
|
/**
|
* Called when the top opaque fullscreen window that is able to control the system bars changes.
|
*
|
* @param controllingWindow The window that is now able to control the system bars appearance
|
* and visibility.
|
*/
|
void onBarControllingWindowChanged(@Nullable WindowState controllingWindow) {
|
// TODO: Apply policy that determines whether controllingWindow is able to control system
|
// bars
|
|
// TODO: Depending on the form factor, mapping is different
|
onControlChanged(TYPE_TOP_BAR, controllingWindow);
|
onControlChanged(TYPE_NAVIGATION_BAR, controllingWindow);
|
notifyPendingInsetsControlChanged();
|
}
|
|
void notifyControlRevoked(@NonNull WindowState previousControllingWin,
|
InsetsSourceProvider provider) {
|
removeFromControlMaps(previousControllingWin, provider.getSource().getType());
|
}
|
|
private void onControlChanged(int type, @Nullable WindowState win) {
|
final WindowState previous = mTypeWinControlMap.get(type);
|
if (win == previous) {
|
return;
|
}
|
final InsetsSourceProvider controller = getSourceProvider(type);
|
if (controller == null) {
|
return;
|
}
|
if (!controller.isControllable()) {
|
return;
|
}
|
controller.updateControlForTarget(win, false /* force */);
|
if (previous != null) {
|
removeFromControlMaps(previous, type);
|
mPendingControlChanged.add(previous);
|
}
|
if (win != null) {
|
addToControlMaps(win, type);
|
mPendingControlChanged.add(win);
|
}
|
}
|
|
private void removeFromControlMaps(@NonNull WindowState win, int type) {
|
final ArrayList<Integer> array = mWinControlTypeMap.get(win);
|
if (array == null) {
|
return;
|
}
|
array.remove((Integer) type);
|
if (array.isEmpty()) {
|
mWinControlTypeMap.remove(win);
|
}
|
mTypeWinControlMap.remove(type);
|
}
|
|
private void addToControlMaps(@NonNull WindowState win, int type) {
|
final ArrayList<Integer> array = mWinControlTypeMap.computeIfAbsent(win,
|
key -> new ArrayList<>());
|
array.add(type);
|
mTypeWinControlMap.put(type, win);
|
}
|
|
void notifyControlChanged(WindowState target) {
|
mPendingControlChanged.add(target);
|
notifyPendingInsetsControlChanged();
|
}
|
|
private void notifyPendingInsetsControlChanged() {
|
if (mPendingControlChanged.isEmpty()) {
|
return;
|
}
|
mDisplayContent.mWmService.mAnimator.addAfterPrepareSurfacesRunnable(() -> {
|
for (int i = mPendingControlChanged.size() - 1; i >= 0; i--) {
|
final WindowState controllingWin = mPendingControlChanged.valueAt(i);
|
controllingWin.notifyInsetsControlChanged();
|
}
|
mPendingControlChanged.clear();
|
});
|
}
|
|
private void notifyInsetsChanged() {
|
mDisplayContent.forAllWindows(mDispatchInsetsChanged, true /* traverseTopToBottom */);
|
}
|
|
void dump(String prefix, PrintWriter pw) {
|
pw.println(prefix + "WindowInsetsStateController");
|
mState.dump(prefix + " ", pw);
|
pw.println(prefix + " " + "Control map:");
|
for (int i = mTypeWinControlMap.size() - 1; i >= 0; i--) {
|
pw.print(prefix + " ");
|
pw.println(InsetsState.typeToString(mTypeWinControlMap.keyAt(i)) + " -> "
|
+ mTypeWinControlMap.valueAt(i));
|
}
|
}
|
}
|
