/*
|
* 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 android.view;
|
|
import static android.view.InsetsState.INSET_SIDE_BOTTOM;
|
import static android.view.InsetsState.INSET_SIDE_LEFT;
|
import static android.view.InsetsState.INSET_SIDE_RIGHT;
|
import static android.view.InsetsState.INSET_SIDE_TOP;
|
import static android.view.InsetsState.toPublicType;
|
|
import android.annotation.Nullable;
|
import android.graphics.Insets;
|
import android.graphics.Matrix;
|
import android.graphics.Rect;
|
import android.os.UidProto.Sync;
|
import android.util.ArraySet;
|
import android.util.SparseArray;
|
import android.util.SparseIntArray;
|
import android.util.SparseSetArray;
|
import android.view.InsetsState.InsetSide;
|
import android.view.SyncRtSurfaceTransactionApplier.SurfaceParams;
|
import android.view.WindowInsets.Type.InsetType;
|
import android.view.WindowInsetsAnimationListener.InsetsAnimation;
|
import android.view.WindowManager.LayoutParams;
|
|
import com.android.internal.annotations.VisibleForTesting;
|
|
import java.util.ArrayList;
|
import java.util.function.Function;
|
import java.util.function.Supplier;
|
|
/**
|
* Implements {@link WindowInsetsAnimationController}
|
* @hide
|
*/
|
@VisibleForTesting
|
public class InsetsAnimationControlImpl implements WindowInsetsAnimationController {
|
|
private final Rect mTmpFrame = new Rect();
|
|
private final WindowInsetsAnimationControlListener mListener;
|
private final SparseArray<InsetsSourceConsumer> mConsumers;
|
private final SparseIntArray mTypeSideMap = new SparseIntArray();
|
private final SparseSetArray<InsetsSourceConsumer> mSideSourceMap = new SparseSetArray<>();
|
|
/** @see WindowInsetsAnimationController#getHiddenStateInsets */
|
private final Insets mHiddenInsets;
|
|
/** @see WindowInsetsAnimationController#getShownStateInsets */
|
private final Insets mShownInsets;
|
private final Matrix mTmpMatrix = new Matrix();
|
private final InsetsState mInitialInsetsState;
|
private final @InsetType int mTypes;
|
private final Supplier<SyncRtSurfaceTransactionApplier> mTransactionApplierSupplier;
|
private final InsetsController mController;
|
private final WindowInsetsAnimationListener.InsetsAnimation mAnimation;
|
private final Rect mFrame;
|
private Insets mCurrentInsets;
|
private Insets mPendingInsets;
|
private boolean mFinished;
|
private boolean mCancelled;
|
private int mFinishedShownTypes;
|
|
@VisibleForTesting
|
public InsetsAnimationControlImpl(SparseArray<InsetsSourceConsumer> consumers, Rect frame,
|
InsetsState state, WindowInsetsAnimationControlListener listener,
|
@InsetType int types,
|
Supplier<SyncRtSurfaceTransactionApplier> transactionApplierSupplier,
|
InsetsController controller) {
|
mConsumers = consumers;
|
mListener = listener;
|
mTypes = types;
|
mTransactionApplierSupplier = transactionApplierSupplier;
|
mController = controller;
|
mInitialInsetsState = new InsetsState(state, true /* copySources */);
|
mCurrentInsets = getInsetsFromState(mInitialInsetsState, frame, null /* typeSideMap */);
|
mHiddenInsets = calculateInsets(mInitialInsetsState, frame, consumers, false /* shown */,
|
null /* typeSideMap */);
|
mShownInsets = calculateInsets(mInitialInsetsState, frame, consumers, true /* shown */,
|
mTypeSideMap);
|
mFrame = new Rect(frame);
|
buildTypeSourcesMap(mTypeSideMap, mSideSourceMap, mConsumers);
|
|
// TODO: Check for controllability first and wait for IME if needed.
|
listener.onReady(this, types);
|
|
mAnimation = new WindowInsetsAnimationListener.InsetsAnimation(mTypes, mHiddenInsets,
|
mShownInsets);
|
mController.dispatchAnimationStarted(mAnimation);
|
}
|
|
@Override
|
public Insets getHiddenStateInsets() {
|
return mHiddenInsets;
|
}
|
|
@Override
|
public Insets getShownStateInsets() {
|
return mShownInsets;
|
}
|
|
@Override
|
public Insets getCurrentInsets() {
|
return mCurrentInsets;
|
}
|
|
@Override
|
@InsetType
|
public int getTypes() {
|
return mTypes;
|
}
|
|
@Override
|
public void changeInsets(Insets insets) {
|
if (mFinished) {
|
throw new IllegalStateException(
|
"Can't change insets on an animation that is finished.");
|
}
|
if (mCancelled) {
|
throw new IllegalStateException(
|
"Can't change insets on an animation that is cancelled.");
|
}
|
mPendingInsets = sanitize(insets);
|
mController.scheduleApplyChangeInsets();
|
}
|
|
@VisibleForTesting
|
/**
|
* @return Whether the finish callback of this animation should be invoked.
|
*/
|
public boolean applyChangeInsets(InsetsState state) {
|
if (mCancelled) {
|
return false;
|
}
|
final Insets offset = Insets.subtract(mShownInsets, mPendingInsets);
|
ArrayList<SurfaceParams> params = new ArrayList<>();
|
if (offset.left != 0) {
|
updateLeashesForSide(INSET_SIDE_LEFT, offset.left, mPendingInsets.left, params, state);
|
}
|
if (offset.top != 0) {
|
updateLeashesForSide(INSET_SIDE_TOP, offset.top, mPendingInsets.top, params, state);
|
}
|
if (offset.right != 0) {
|
updateLeashesForSide(INSET_SIDE_RIGHT, offset.right, mPendingInsets.right, params,
|
state);
|
}
|
if (offset.bottom != 0) {
|
updateLeashesForSide(INSET_SIDE_BOTTOM, offset.bottom, mPendingInsets.bottom, params,
|
state);
|
}
|
SyncRtSurfaceTransactionApplier applier = mTransactionApplierSupplier.get();
|
applier.scheduleApply(params.toArray(new SurfaceParams[params.size()]));
|
mCurrentInsets = mPendingInsets;
|
if (mFinished) {
|
mController.notifyFinished(this, mFinishedShownTypes);
|
}
|
return mFinished;
|
}
|
|
@Override
|
public void finish(int shownTypes) {
|
if (mCancelled) {
|
return;
|
}
|
InsetsState state = new InsetsState(mController.getState());
|
for (int i = mConsumers.size() - 1; i >= 0; i--) {
|
InsetsSourceConsumer consumer = mConsumers.valueAt(i);
|
boolean visible = (shownTypes & toPublicType(consumer.getType())) != 0;
|
state.getSource(consumer.getType()).setVisible(visible);
|
}
|
Insets insets = getInsetsFromState(state, mFrame, null /* typeSideMap */);
|
changeInsets(insets);
|
mFinished = true;
|
mFinishedShownTypes = shownTypes;
|
}
|
|
@VisibleForTesting
|
public void onCancelled() {
|
if (mFinished) {
|
return;
|
}
|
mCancelled = true;
|
mListener.onCancelled();
|
}
|
|
InsetsAnimation getAnimation() {
|
return mAnimation;
|
}
|
|
private Insets calculateInsets(InsetsState state, Rect frame,
|
SparseArray<InsetsSourceConsumer> consumers, boolean shown,
|
@Nullable @InsetSide SparseIntArray typeSideMap) {
|
for (int i = consumers.size() - 1; i >= 0; i--) {
|
state.getSource(consumers.valueAt(i).getType()).setVisible(shown);
|
}
|
return getInsetsFromState(state, frame, typeSideMap);
|
}
|
|
private Insets getInsetsFromState(InsetsState state, Rect frame,
|
@Nullable @InsetSide SparseIntArray typeSideMap) {
|
return state.calculateInsets(frame, false /* isScreenRound */,
|
false /* alwaysConsumerNavBar */, null /* displayCutout */,
|
null /* legacyContentInsets */, null /* legacyStableInsets */,
|
LayoutParams.SOFT_INPUT_ADJUST_RESIZE /* legacySoftInputMode*/, typeSideMap)
|
.getInsets(mTypes);
|
}
|
|
private Insets sanitize(Insets insets) {
|
return Insets.max(Insets.min(insets, mShownInsets), mHiddenInsets);
|
}
|
|
private void updateLeashesForSide(@InsetSide int side, int offset, int inset,
|
ArrayList<SurfaceParams> surfaceParams, InsetsState state) {
|
ArraySet<InsetsSourceConsumer> items = mSideSourceMap.get(side);
|
// TODO: Implement behavior when inset spans over multiple types
|
for (int i = items.size() - 1; i >= 0; i--) {
|
final InsetsSourceConsumer consumer = items.valueAt(i);
|
final InsetsSource source = mInitialInsetsState.getSource(consumer.getType());
|
final InsetsSourceControl control = consumer.getControl();
|
final SurfaceControl leash = consumer.getControl().getLeash();
|
|
mTmpMatrix.setTranslate(control.getSurfacePosition().x, control.getSurfacePosition().y);
|
mTmpFrame.set(source.getFrame());
|
addTranslationToMatrix(side, offset, mTmpMatrix, mTmpFrame);
|
|
state.getSource(source.getType()).setFrame(mTmpFrame);
|
surfaceParams.add(new SurfaceParams(leash, 1f, mTmpMatrix, null, 0, 0f, inset != 0));
|
}
|
}
|
|
private void addTranslationToMatrix(@InsetSide int side, int inset, Matrix m, Rect frame) {
|
switch (side) {
|
case INSET_SIDE_LEFT:
|
m.postTranslate(-inset, 0);
|
frame.offset(-inset, 0);
|
break;
|
case INSET_SIDE_TOP:
|
m.postTranslate(0, -inset);
|
frame.offset(0, -inset);
|
break;
|
case INSET_SIDE_RIGHT:
|
m.postTranslate(inset, 0);
|
frame.offset(inset, 0);
|
break;
|
case INSET_SIDE_BOTTOM:
|
m.postTranslate(0, inset);
|
frame.offset(0, inset);
|
break;
|
}
|
}
|
|
private static void buildTypeSourcesMap(SparseIntArray typeSideMap,
|
SparseSetArray<InsetsSourceConsumer> sideSourcesMap,
|
SparseArray<InsetsSourceConsumer> consumers) {
|
for (int i = typeSideMap.size() - 1; i >= 0; i--) {
|
int type = typeSideMap.keyAt(i);
|
int side = typeSideMap.valueAt(i);
|
sideSourcesMap.add(side, consumers.get(type));
|
}
|
}
|
}
|
