displayAreaGroupHierarchyBuilders) {
if (displayAreaGroupHierarchyBuilders == null) {
return;
}
final int count = displayAreaGroupHierarchyBuilders.size();
for (int i = 0; i < count; i++) {
DisplayAreaPolicyBuilder.PendingArea
leafArea = new DisplayAreaPolicyBuilder.PendingArea(
null /* feature */, APPLICATION_LAYER, parentPendingArea);
leafArea.mExisting = displayAreaGroupHierarchyBuilders.get(i).mRoot;
leafArea.mMaxLayer = APPLICATION_LAYER;
parentPendingArea.mChildren.add(leafArea);
}
}
boolean hasValidWindowingLayer() {
// The windowing layer feature can only be the first one as the top hierarchy.
return !mFeatures.isEmpty() && canBeWindowingLayer(mFeatures.get(0).mId);
}
private static int typeOfLayer(@NonNull WindowManagerPolicy policy, int layer) {
if (layer == APPLICATION_LAYER) {
return LEAF_TYPE_TASK_CONTAINERS;
} else if (layer == policy.getWindowLayerFromTypeLw(TYPE_INPUT_METHOD)
|| layer == policy.getWindowLayerFromTypeLw(TYPE_INPUT_METHOD_DIALOG)) {
return LEAF_TYPE_IME_CONTAINERS;
} else {
return LEAF_TYPE_TOKENS;
}
}
}
/** Supplier interface to provide a new created {@link DisplayArea}. */
interface NewDisplayAreaSupplier {
@Nullable
DisplayArea create(@NonNull WindowManagerService wms, DisplayArea.Type type,
@NonNull String name, int featureId);
}
/**
* A feature that requires {@link DisplayArea DisplayArea(s)}.
*/
static class Feature {
@NonNull
private final String mName;
private final int mId;
@NonNull
private final boolean[] mWindowLayers;
@NonNull
private final NewDisplayAreaSupplier mNewDisplayAreaSupplier;
private Feature(@NonNull String name, int id, @NonNull boolean[] windowLayers,
@NonNull NewDisplayAreaSupplier newDisplayAreaSupplier) {
mName = requireNonNull(name);
mId = id;
mWindowLayers = requireNonNull(windowLayers);
mNewDisplayAreaSupplier = requireNonNull(newDisplayAreaSupplier);
}
/**
* Returns the id of the feature.
*
* Must be unique among the features added to a {@link DisplayAreaPolicyBuilder}.
*
* @see android.window.DisplayAreaOrganizer#FEATURE_SYSTEM_FIRST
* @see android.window.DisplayAreaOrganizer#FEATURE_VENDOR_FIRST
*/
public int getId() {
return mId;
}
@Override
public String toString() {
return "Feature(\"" + mName + "\", " + mId + '}';
}
static class Builder {
@NonNull private final WindowManagerPolicy mPolicy;
@NonNull private final String mName;
private final int mId;
@NonNull private final boolean[] mLayers;
@NonNull private NewDisplayAreaSupplier mNewDisplayAreaSupplier = DisplayArea::new;
private boolean mExcludeRoundedCorner = true;
/**
* Builds a new feature that applies to a set of window types as specified by the
* builder methods.
*
*
The set of types is updated iteratively in the order of the method invocations.
* For example, {@code all().except(TYPE_STATUS_BAR)} expresses that a feature should
* apply to all types except TYPE_STATUS_BAR.
*
*
The builder starts out with the feature not applying to any types.
*
* @param name the name of the feature.
* @param id of the feature. {@see Feature#getId}
*/
Builder(@NonNull WindowManagerPolicy policy, @NonNull String name, int id) {
mPolicy = requireNonNull(policy);
mName = requireNonNull(name);
mId = id;
mLayers = new boolean[mPolicy.getMaxWindowLayer() + 1];
}
/**
* Set that the feature applies to all window types.
*/
@NonNull
Builder all() {
Arrays.fill(mLayers, true);
return this;
}
/**
* Set that the feature applies to the given window types.
*/
@NonNull
Builder and(int... types) {
for (int i = 0; i < types.length; i++) {
int type = types[i];
set(type, true);
}
return this;
}
/**
* Set that the feature does not apply to the given window types.
*/
@NonNull
Builder except(int... types) {
for (int i = 0; i < types.length; i++) {
int type = types[i];
set(type, false);
}
return this;
}
/**
* Set that the feature applies window types that are layerd at or below the layer of
* the given window type.
*/
@NonNull
Builder upTo(int typeInclusive) {
final int max = layerFromType(typeInclusive, false);
for (int i = 0; i < max; i++) {
mLayers[i] = true;
}
set(typeInclusive, true);
return this;
}
/**
* Sets the function to create new {@link DisplayArea} for this feature. By default, it
* uses {@link DisplayArea}'s constructor.
*/
@NonNull
Builder setNewDisplayAreaSupplier(
@NonNull NewDisplayAreaSupplier newDisplayAreaSupplier) {
mNewDisplayAreaSupplier = requireNonNull(newDisplayAreaSupplier);
return this;
}
// TODO(b/155340867): consider to remove the logic after using pure Surface for rounded
// corner overlay.
@NonNull
Builder setExcludeRoundedCornerOverlay(boolean excludeRoundedCorner) {
mExcludeRoundedCorner = excludeRoundedCorner;
return this;
}
@NonNull
Feature build() {
if (mExcludeRoundedCorner) {
// Always put the rounded corner layer to the top most layer.
mLayers[mPolicy.getMaxWindowLayer()] = false;
}
return new Feature(mName, mId, mLayers.clone(), mNewDisplayAreaSupplier);
}
private void set(int type, boolean value) {
mLayers[layerFromType(type, true)] = value;
if (type == TYPE_APPLICATION_OVERLAY) {
mLayers[layerFromType(type, true)] = value;
mLayers[layerFromType(TYPE_SYSTEM_ALERT, false)] = value;
mLayers[layerFromType(TYPE_SYSTEM_OVERLAY, false)] = value;
mLayers[layerFromType(TYPE_SYSTEM_ERROR, false)] = value;
}
}
private int layerFromType(int type, boolean internalWindows) {
return mPolicy.getWindowLayerFromTypeLw(type, internalWindows);
}
}
}
static class Result extends DisplayAreaPolicy {
@NonNull
private final List mDisplayAreaGroupRoots;
@VisibleForTesting
@NonNull
final BiFunction mSelectRootForWindowFunc;
@NonNull
private final Function mSelectTaskDisplayAreaFunc;
@NonNull
private final TaskDisplayArea mDefaultTaskDisplayArea;
Result(@NonNull WindowManagerService wmService,
int displayId,
@NonNull RootDisplayArea root,
@NonNull List displayAreaGroupRoots,
@NonNull BiFunction selectRootForWindowFunc,
@Nullable Function selectTaskDisplayAreaFunc) {
super(wmService, root);
mDisplayAreaGroupRoots = Collections.unmodifiableList(displayAreaGroupRoots);
mSelectRootForWindowFunc = selectRootForWindowFunc;
// Cache the default TaskDisplayArea for quick access.
final TaskDisplayArea defaultTda = mRoot.getItemFromTaskDisplayAreas(taskDisplayArea ->
taskDisplayArea.mFeatureId == FEATURE_DEFAULT_TASK_CONTAINER
? taskDisplayArea
: null);
if (defaultTda == null) {
throw new IllegalStateException(
"No display area with FEATURE_DEFAULT_TASK_CONTAINER");
}
mDefaultTaskDisplayArea = defaultTda;
mSelectTaskDisplayAreaFunc = selectTaskDisplayAreaFunc != null
? selectTaskDisplayAreaFunc
: new DefaultSelectTaskDisplayAreaFunction(displayId, mDefaultTaskDisplayArea);
}
@Override
public void addWindow(@NonNull WindowToken token) {
DisplayArea.Tokens area = findAreaForToken(token);
area.addChild(token);
}
@VisibleForTesting
DisplayArea.Tokens findAreaForToken(@NonNull WindowToken token) {
return mSelectRootForWindowFunc.apply(token.windowType, token.mOptions)
.findAreaForTokenInLayer(token);
}
@Override
public DisplayArea.Tokens findAreaForWindowType(int type, @Nullable Bundle options,
boolean ownerCanManageAppTokens, boolean roundedCornerOverlay) {
return mSelectRootForWindowFunc.apply(type, options).findAreaForWindowTypeInLayer(type,
ownerCanManageAppTokens, roundedCornerOverlay);
}
@VisibleForTesting
List getFeatures() {
Set features = new ArraySet<>();
features.addAll(mRoot.mFeatures);
for (int i = 0; i < mDisplayAreaGroupRoots.size(); i++) {
features.addAll(mDisplayAreaGroupRoots.get(i).mFeatures);
}
return new ArrayList<>(features);
}
@Override
public List> getDisplayAreas(int featureId) {
final List> displayAreas = new ArrayList<>();
getDisplayAreas(mRoot, featureId, displayAreas);
for (int i = 0; i < mDisplayAreaGroupRoots.size(); i++) {
getDisplayAreas(mDisplayAreaGroupRoots.get(i), featureId, displayAreas);
}
return displayAreas;
}
private static void getDisplayAreas(@NonNull RootDisplayArea root, int featureId,
@NonNull List> displayAreas) {
final List features = root.mFeatures;
for (int i = 0; i < features.size(); i++) {
final Feature feature = features.get(i);
if (feature.mId == featureId) {
displayAreas.addAll(root.mFeatureToDisplayAreas.get(feature));
}
}
}
@Override
public DisplayArea getWindowingArea() {
if (mRoot.mFeatures.isEmpty()) {
throw new IllegalStateException("There must be at least one feature.");
}
final Feature feature = mRoot.mFeatures.get(0);
if (canBeWindowingLayer(feature.mId)) {
final List> areas =
mRoot.mFeatureToDisplayAreas.get(feature);
if (areas.size() == 1) {
return areas.get(0);
}
}
throw new IllegalStateException("There must be exactly one DisplayArea at top for the "
+ "FEATURE_WINDOWED_MAGNIFICATION or FEATURE_WINDOWING_LAYER");
}
@Override
public TaskDisplayArea getDefaultTaskDisplayArea() {
return mDefaultTaskDisplayArea;
}
@NonNull
@Override
public TaskDisplayArea getTaskDisplayArea(@Nullable Bundle options) {
return mSelectTaskDisplayAreaFunc.apply(options);
}
}
static class PendingArea {
private final int mMinLayer;
@NonNull
private final ArrayList mChildren = new ArrayList<>();
@Nullable
private final Feature mFeature;
@Nullable
private final PendingArea mParent;
private int mMaxLayer;
/** If not {@code null}, use this instead of creating a {@link DisplayArea.Tokens}. */
@Nullable private DisplayArea mExisting;
/**
* Whether to skip creating a {@link DisplayArea.Tokens} if {@link #mExisting} is
* {@code null}.
*
* This will be set for {@link HierarchyBuilder#LEAF_TYPE_IME_CONTAINERS} and
* {@link HierarchyBuilder#LEAF_TYPE_TASK_CONTAINERS}, because we don't want to create
* {@link DisplayArea.Tokens} for them even if they are not set.
*/
private boolean mSkipTokens = false;
PendingArea(@Nullable Feature feature, int minLayer, @Nullable PendingArea parent) {
mMinLayer = minLayer;
mFeature = feature;
mParent = parent;
}
int computeMaxLayer() {
for (int i = 0; i < mChildren.size(); i++) {
mMaxLayer = Math.max(mMaxLayer, mChildren.get(i).computeMaxLayer());
}
return mMaxLayer;
}
void instantiateChildren(@NonNull DisplayArea parent,
@NonNull DisplayArea.Tokens[] areaForLayer,
int level, @NonNull Map>> areas) {
mChildren.sort(Comparator.comparingInt(pendingArea -> pendingArea.mMinLayer));
for (int i = 0; i < mChildren.size(); i++) {
final PendingArea child = mChildren.get(i);
final DisplayArea area = child.createArea(parent, areaForLayer);
if (area == null) {
// TaskDisplayArea and ImeContainer can be set at different hierarchy, so it can
// be null.
continue;
}
parent.addChild(area, WindowContainer.POSITION_TOP);
if (child.mFeature != null) {
areas.get(child.mFeature).add(area);
}
child.instantiateChildren(area, areaForLayer, level + 1, areas);
}
}
@Nullable
private DisplayArea createArea(@NonNull DisplayArea parent,
@NonNull DisplayArea.Tokens[] areaForLayer) {
if (mExisting != null) {
if (mExisting.asTokens() != null) {
// Store the WindowToken container for layers
fillAreaForLayers(mExisting.asTokens(), areaForLayer);
}
return mExisting;
}
if (mSkipTokens) {
return null;
}
final DisplayArea.Type type;
if (mMinLayer > APPLICATION_LAYER) {
type = DisplayArea.Type.ABOVE_TASKS;
} else if (mMaxLayer < APPLICATION_LAYER) {
type = DisplayArea.Type.BELOW_TASKS;
} else {
type = DisplayArea.Type.ANY;
}
if (mFeature == null) {
final DisplayArea.Tokens leaf = new DisplayArea.Tokens(parent.mWmService, type,
"Leaf:" + mMinLayer + ":" + mMaxLayer);
fillAreaForLayers(leaf, areaForLayer);
return leaf;
} else {
return mFeature.mNewDisplayAreaSupplier.create(parent.mWmService, type,
mFeature.mName + ":" + mMinLayer + ":" + mMaxLayer, mFeature.mId);
}
}
private void fillAreaForLayers(@NonNull DisplayArea.Tokens leaf,
@NonNull DisplayArea.Tokens[] areaForLayer) {
for (int i = mMinLayer; i <= mMaxLayer; i++) {
areaForLayer[i] = leaf;
}
}
}
}