| /* |
| * 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 android.graphics.Insets; |
| |
| /** |
| * Interface that allows the application to listen to animation events for windows that cause |
| * insets. |
| * @hide pending unhide |
| */ |
| public interface WindowInsetsAnimationListener { |
| |
| /** |
| * Called when an inset animation gets started. |
| * |
| * @param animation The animation that is about to start. |
| */ |
| void onStarted(InsetsAnimation animation); |
| |
| /** |
| * Called when the insets change as part of running an animation. Note that even if multiple |
| * animations for different types are running, there will only be one progress callback per |
| * frame. The {@code insets} passed as an argument represents the overall state and will include |
| * all types, regardless of whether they are animating or not. |
| * <p> |
| * Note that insets dispatch is hierarchical: It will start at the root of the view hierarchy, |
| * and then traverse it and invoke the callback of the specific {@link View} being traversed. |
| * The callback may return a modified instance by calling {@link WindowInsets#inset(int, int, int, int)} |
| * to indicate that a part of the insets have been used to offset or clip its children, and the |
| * children shouldn't worry about that part anymore. |
| * |
| * @param insets The current insets. |
| * @return The insets to dispatch to the subtree of the hierarchy. |
| */ |
| WindowInsets onProgress(WindowInsets insets); |
| |
| /** |
| * Called when an inset animation has finished. |
| * |
| * @param animation The animation that has finished running. |
| */ |
| void onFinished(InsetsAnimation animation); |
| |
| /** |
| * Class representing an animation of a set of windows that cause insets. |
| */ |
| class InsetsAnimation { |
| |
| private final @WindowInsets.Type.InsetType int mTypeMask; |
| private final Insets mLowerBound; |
| private final Insets mUpperBound; |
| |
| /** |
| * @hide |
| */ |
| InsetsAnimation(int typeMask, Insets lowerBound, Insets upperBound) { |
| mTypeMask = typeMask; |
| mLowerBound = lowerBound; |
| mUpperBound = upperBound; |
| } |
| |
| /** |
| * @return The bitmask of {@link WindowInsets.Type.InsetType}s that are animating. |
| */ |
| public @WindowInsets.Type.InsetType int getTypeMask() { |
| return mTypeMask; |
| } |
| |
| /** |
| * Queries the lower inset bound of the animation. If the animation is about showing or |
| * hiding a window that cause insets, the lower bound is {@link Insets#NONE} and the upper |
| * bound is the same as {@link WindowInsets#getInsets(int)} for the fully shown state. This |
| * is the same as {@link WindowInsetsAnimationController#getHiddenStateInsets} and |
| * {@link WindowInsetsAnimationController#getShownStateInsets} in case the listener gets |
| * invoked because of an animation that originates from |
| * {@link WindowInsetsAnimationController}. |
| * <p> |
| * However, if the size of a window that causes insets is changing, these are the |
| * lower/upper bounds of that size animation. |
| * <p> |
| * There are no overlapping animations for a specific type, but there may be two animations |
| * running at the same time for different inset types. |
| * |
| * @see #getUpperBound() |
| * @see WindowInsetsAnimationController#getHiddenStateInsets |
| * TODO: It's a bit weird that these are global per window but onProgress is hierarchical. |
| * TODO: If multiple types are animating, querying the bound per type isn't possible. Should |
| * we: |
| * 1. Offer bounds by type here? |
| * 2. Restrict one animation to one single type only? |
| * Returning WindowInsets here isn't feasible in case of overlapping animations: We can't |
| * fill in the insets for the types from the other animation into the WindowInsets object |
| * as it's changing as well. |
| */ |
| public Insets getLowerBound() { |
| return mLowerBound; |
| } |
| |
| /** |
| * @see #getLowerBound() |
| * @see WindowInsetsAnimationController#getShownStateInsets |
| */ |
| public Insets getUpperBound() { |
| return mUpperBound; |
| } |
| } |
| } |