content: /*
   * 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;
          }
      }
  }
  