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