android-12.0.0_r34/s

/*
 * Copyright (C) 2015 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 com.android.messaging.ui.mediapicker;

import android.content.Context;
import android.content.res.Resources;
import android.os.Handler;
import android.util.AttributeSet;
import android.view.MotionEvent;
import android.view.View;
import android.view.ViewConfiguration;
import android.view.ViewGroup;
import android.view.animation.Animation;
import android.view.animation.Transformation;
import android.widget.LinearLayout;

import com.android.messaging.R;
import com.android.messaging.ui.PagingAwareViewPager;
import com.android.messaging.util.Assert;
import com.android.messaging.util.OsUtil;
import com.android.messaging.util.UiUtils;

/**
 * Custom layout panel which makes the MediaPicker animations seamless and synchronized
 * Designed to be very specific to the MediaPicker's usage
 */
public class MediaPickerPanel extends ViewGroup {
    /**
     * The window of time in which we might to decide to reinterpret the intent of a gesture.
     */
    private static final long TOUCH_RECAPTURE_WINDOW_MS = 500L;

    // The two view components to layout
    private LinearLayout mTabStrip;
    private boolean mFullScreenOnly;
    private PagingAwareViewPager mViewPager;

    /**
     * True if the MediaPicker is full screen or animating into it
     */
    private boolean mFullScreen;

    /**
     * True if the MediaPicker is open at all
     */
    private boolean mExpanded;

    /**
     * The current desired height of the MediaPicker.  This property may be animated and the
     * measure pass uses it to determine what size the components are.
     */
    private int mCurrentDesiredHeight;

    private final Handler mHandler = new Handler();

    /**
     * The media picker for dispatching events to the MediaPicker's listener
     */
    private MediaPicker mMediaPicker;

    /**
     * The computed default "half-screen" height of the view pager in px
     */
    private final int mDefaultViewPagerHeight;

    /**
     * The action bar height used to compute the padding on the view pager when it's full screen.
     */
    private final int mActionBarHeight;

    private TouchHandler mTouchHandler;

    static final int PAGE_NOT_SET = -1;

    public MediaPickerPanel(final Context context, final AttributeSet attrs) {
        super(context, attrs);
        // Cache the computed dimension
        mDefaultViewPagerHeight = getResources().getDimensionPixelSize(
                R.dimen.mediapicker_default_chooser_height);
        mActionBarHeight = getResources().getDimensionPixelSize(R.dimen.action_bar_height);
    }

    @Override
    protected void onFinishInflate() {
        super.onFinishInflate();
        mTabStrip = (LinearLayout) findViewById(R.id.mediapicker_tabstrip);
        mViewPager = (PagingAwareViewPager) findViewById(R.id.mediapicker_view_pager);
        mTouchHandler = new TouchHandler();
        setOnTouchListener(mTouchHandler);
        mViewPager.setOnTouchListener(mTouchHandler);

        // Make sure full screen mode is updated in landscape mode change when the panel is open.
        addOnLayoutChangeListener(new OnLayoutChangeListener() {
            private boolean mLandscapeMode = UiUtils.isLandscapeMode();

            @Override
            public void onLayoutChange(View v, int left, int top, int right, int bottom,
                    int oldLeft, int oldTop, int oldRight, int oldBottom) {
                final boolean newLandscapeMode = UiUtils.isLandscapeMode();
                if (mLandscapeMode != newLandscapeMode) {
                    mLandscapeMode = newLandscapeMode;
                    if (mExpanded) {
                        setExpanded(mExpanded, false /* animate */, mViewPager.getCurrentItem(),
                                true /* force */);
                    }
                }
            }
        });
    }

    @Override
    protected void onMeasure(final int widthMeasureSpec, final int heightMeasureSpec) {
        int requestedHeight = MeasureSpec.getSize(heightMeasureSpec);
        if (mMediaPicker.getChooserShowsActionBarInFullScreen()) {
            requestedHeight -= mActionBarHeight;
        }
        int desiredHeight = Math.min(mCurrentDesiredHeight, requestedHeight);
        if (mExpanded && desiredHeight == 0) {
            // If we want to be shown, we have to have a non-0 height.  Returning a height of 0 will
            // cause the framework to abort the animation from 0, so we must always have some
            // height once we start expanding
            desiredHeight = 1;
        } else if (!mExpanded && desiredHeight == 0) {
            mViewPager.setVisibility(View.GONE);
            mViewPager.setAdapter(null);
        }

        measureChild(mTabStrip, widthMeasureSpec, heightMeasureSpec);

        int tabStripHeight;
        if (requiresFullScreen()) {
            // Ensure that the tab strip is always visible, even in full screen.
            tabStripHeight = mTabStrip.getMeasuredHeight();
        } else {
            // Slide out the tab strip at the end of the animation to full screen.
            tabStripHeight = Math.min(mTabStrip.getMeasuredHeight(),
                    requestedHeight - desiredHeight);
        }

        // If we are animating and have an interim desired height, use the default height. We can't
        // take the max here as on some devices the mDefaultViewPagerHeight may be too big in
        // landscape mode after animation.
        final int tabAdjustedDesiredHeight = desiredHeight - tabStripHeight;
        final int viewPagerHeight =
                tabAdjustedDesiredHeight <= 1 ? mDefaultViewPagerHeight : tabAdjustedDesiredHeight;

        int viewPagerHeightMeasureSpec = MeasureSpec.makeMeasureSpec(
                viewPagerHeight, MeasureSpec.EXACTLY);
        measureChild(mViewPager, widthMeasureSpec, viewPagerHeightMeasureSpec);
        setMeasuredDimension(mViewPager.getMeasuredWidth(), desiredHeight);
    }

    @Override
    protected void onLayout(final boolean changed, final int left, final int top, final int right,
            final int bottom) {
        int y = top;
        final int width = right - left;

        final int viewPagerHeight = mViewPager.getMeasuredHeight();
        mViewPager.layout(0, y, width, y + viewPagerHeight);
        y += viewPagerHeight;

        mTabStrip.layout(0, y, width, y + mTabStrip.getMeasuredHeight());
    }

    void onChooserChanged() {
        if (mFullScreen) {
            setDesiredHeight(getDesiredHeight(), true);
        }
    }

    void setFullScreenOnly(boolean fullScreenOnly) {
        mFullScreenOnly = fullScreenOnly;
    }

    boolean isFullScreen() {
        return mFullScreen;
    }

    void setMediaPicker(final MediaPicker mediaPicker) {
        mMediaPicker = mediaPicker;
    }

    /**
     * Get the desired height of the media picker panel for when the panel is not in motion (i.e.
     * not being dragged by the user).
     */
    private int getDesiredHeight() {
        if (mFullScreen) {
            int fullHeight = getContext().getResources().getDisplayMetrics().heightPixels;
            if (OsUtil.isAtLeastKLP() && isAttachedToWindow()) {
                // When we're attached to the window, we can get an accurate height, not necessary
                // on older API level devices because they don't include the action bar height
                View composeContainer =
                        getRootView().findViewById(R.id.conversation_and_compose_container);
                if (composeContainer != null) {
                    // protect against composeContainer having been unloaded already
                    fullHeight -= UiUtils.getMeasuredBoundsOnScreen(composeContainer).top;
                }
            }
            if (mMediaPicker.getChooserShowsActionBarInFullScreen()) {
                return fullHeight - mActionBarHeight;
            } else {
                return fullHeight;
            }
        } else if (mExpanded) {
            return LayoutParams.WRAP_CONTENT;
        } else {
            return 0;
        }
    }

    private void setupViewPager(final int startingPage) {
        mViewPager.setVisibility(View.VISIBLE);
        if (startingPage >= 0 && startingPage < mMediaPicker.getPagerAdapter().getCount()) {
            mViewPager.setAdapter(mMediaPicker.getPagerAdapter());
            mViewPager.setCurrentItem(startingPage);
        }
        updateViewPager();
    }

    /**
     * Expand the media picker panel. Since we always set the pager adapter to null when the panel
     * is collapsed, we need to restore the adapter and the starting page.
     * @param expanded expanded or collapsed
     * @param animate need animation
     * @param startingPage the desired selected page to start
     */
    void setExpanded(final boolean expanded, final boolean animate, final int startingPage) {
        setExpanded(expanded, animate, startingPage, false /* force */);
    }

    private void setExpanded(final boolean expanded, final boolean animate, final int startingPage,
            final boolean force) {
        if (expanded == mExpanded && !force) {
            return;
        }
        mFullScreen = false;
        mExpanded = expanded;
        mHandler.post(new Runnable() {
            @Override
            public void run() {
                setDesiredHeight(getDesiredHeight(), animate);
            }
        });
        if (expanded) {
            setupViewPager(startingPage);
            mMediaPicker.dispatchOpened();
        } else {
            mMediaPicker.dispatchDismissed();
        }

        // Call setFullScreenView() when we are in landscape mode so it can go full screen as
        // soon as it is expanded.
        if (expanded && requiresFullScreen()) {
            setFullScreenView(true, animate);
        }
    }

    private boolean requiresFullScreen() {
        return mFullScreenOnly || UiUtils.isLandscapeMode();
    }

    private void setDesiredHeight(int height, final boolean animate) {
        final int startHeight = mCurrentDesiredHeight;
        if (height == LayoutParams.WRAP_CONTENT) {
            height = measureHeight();
        }
        clearAnimation();
        if (animate) {
            final int deltaHeight = height - startHeight;
            final Animation animation = new Animation() {
                @Override
                protected void applyTransformation(final float interpolatedTime,
                        final Transformation t) {
                    mCurrentDesiredHeight = (int) (startHeight + deltaHeight * interpolatedTime);
                    requestLayout();
                }

                @Override
                public boolean willChangeBounds() {
                    return true;
                }
            };
            animation.setDuration(UiUtils.MEDIAPICKER_TRANSITION_DURATION);
            animation.setInterpolator(UiUtils.EASE_OUT_INTERPOLATOR);
            startAnimation(animation);
        } else {
            mCurrentDesiredHeight = height;
        }
        requestLayout();
    }

    /**
     * @return The minimum total height of the view
     */
    private int measureHeight() {
        final int measureSpec = MeasureSpec.makeMeasureSpec(Integer.MAX_VALUE, MeasureSpec.AT_MOST);
        measureChild(mTabStrip, measureSpec, measureSpec);
        return mDefaultViewPagerHeight + mTabStrip.getMeasuredHeight();
    }

    /**
     * Enters or leaves full screen view
     *
     * @param fullScreen True to enter full screen view, false to leave
     * @param animate    True to animate the transition
     */
    void setFullScreenView(final boolean fullScreen, final boolean animate) {
        if (fullScreen == mFullScreen) {
            return;
        }

        if (requiresFullScreen() && !fullScreen) {
            setExpanded(false /* expanded */, true /* animate */, PAGE_NOT_SET);
            return;
        }
        mFullScreen = fullScreen;
        setDesiredHeight(getDesiredHeight(), animate);
        mMediaPicker.dispatchFullScreen(mFullScreen);
        updateViewPager();
    }

    /**
     * ViewPager should have its paging disabled when in full screen mode.
     */
    private void updateViewPager() {
        mViewPager.setPagingEnabled(!mFullScreen);
    }

    @Override
    public boolean onInterceptTouchEvent(final MotionEvent ev) {
        return mTouchHandler.onInterceptTouchEvent(ev) || super.onInterceptTouchEvent(ev);
    }

    /**
     * Helper class to handle touch events and swipe gestures
     */
    private class TouchHandler implements OnTouchListener {
        /**
         * The height of the view when the touch press started
         */
        private int mDownHeight = -1;

        /**
         * True if the panel moved at all (changed height) during the drag
         */
        private boolean mMoved = false;

        // The threshold constants converted from DP to px
        private final float mFlingThresholdPx;
        private final float mBigFlingThresholdPx;

        // The system defined pixel size to determine when a movement is considered a drag.
        private final int mTouchSlop;

        /**
         * A copy of the MotionEvent that started the drag/swipe gesture
         */
        private MotionEvent mDownEvent;

        /**
         * Whether we are currently moving down. We may not be able to move down in full screen
         * mode when the child view can swipe down (such as a list view).
         */
        private boolean mMovedDown = false;

        /**
         * Indicates whether the child view contained in the panel can swipe down at the beginning
         * of the drag event (i.e. the initial down). The MediaPanel can contain
         * scrollable children such as a list view / grid view. If the child view can swipe down,
         * We want to let the child view handle the scroll first instead of handling it ourselves.
         */
        private boolean mCanChildViewSwipeDown = false;

        /**
         * Necessary direction ratio for a fling to be considered in one direction this prevents
         * horizontal swipes with small vertical components from triggering vertical swipe actions
         */
        private static final float DIRECTION_RATIO = 1.1f;

        TouchHandler() {
            final Resources resources = getContext().getResources();
            final ViewConfiguration configuration = ViewConfiguration.get(getContext());
            mFlingThresholdPx = resources.getDimensionPixelSize(
                    R.dimen.mediapicker_fling_threshold);
            mBigFlingThresholdPx = resources.getDimensionPixelSize(
                    R.dimen.mediapicker_big_fling_threshold);
            mTouchSlop = configuration.getScaledTouchSlop();
        }

        /**
         * The media picker panel may contain scrollable children such as a GridView, which eats
         * all touch events before we get to it. Therefore, we'd like to intercept these events
         * before the children to determine if we should handle swiping down in full screen mode.
         * In non-full screen mode, we should handle all vertical scrolling events and leave
         * horizontal scrolling to the view pager.
         */
        public boolean onInterceptTouchEvent(final MotionEvent ev) {
            switch (ev.getActionMasked()) {
                case MotionEvent.ACTION_DOWN:
                    // Never capture the initial down, so that the children may handle it
                    // as well. Let the touch handler know about the down event as well.
                    mTouchHandler.onTouch(MediaPickerPanel.this, ev);

                    // Ask the MediaPicker whether the contained view can be swiped down.
                    // We record the value at the start of the drag to decide the swiping mode
                    // for the entire motion.
                    mCanChildViewSwipeDown = mMediaPicker.canSwipeDownChooser();
                    return false;

                case MotionEvent.ACTION_MOVE: {
                    if (mMediaPicker.isChooserHandlingTouch()) {
                        if (shouldAllowRecaptureTouch(ev)) {
                            mMediaPicker.stopChooserTouchHandling();
                            mViewPager.setPagingEnabled(true);
                            return false;
                        }
                        // If the chooser is claiming ownership on all touch events, then we
                        // shouldn't try to handle them (neither should the view pager).
                        mViewPager.setPagingEnabled(false);
                        return false;
                    } else if (mCanChildViewSwipeDown) {
                        // Never capture event if the child view can swipe down.
                        return false;
                    } else if (!mFullScreen && mMoved) {
                        // When we are not fullscreen, we own any vertical drag motion.
                        return true;
                    } else if (mMovedDown) {
                        // We are currently handling the down swipe ourselves, so always
                        // capture this event.
                        return true;
                    } else {
                        // The current interaction mode is undetermined, so always let the
                        // touch handler know about this event. However, don't capture this
                        // event so the child may handle it as well.
                        mTouchHandler.onTouch(MediaPickerPanel.this, ev);

                        // Capture the touch event from now on if we are handling the drag.
                        return mFullScreen ? mMovedDown : mMoved;
                    }
                }
            }
            return false;
        }

        /**
         * Determine whether we think the user is actually trying to expand or slide despite the
         * fact that they touched first on a chooser that captured the input.
         */
        private boolean shouldAllowRecaptureTouch(MotionEvent ev) {
            final long elapsedMs = ev.getEventTime() - ev.getDownTime();
            if (mDownEvent == null || elapsedMs == 0 || elapsedMs > TOUCH_RECAPTURE_WINDOW_MS) {
                // Either we don't have info to decide or it's been long enough that we no longer
                // want to reinterpret user intent.
                return false;
            }
            final float dx = ev.getRawX() - mDownEvent.getRawX();
            final float dy = ev.getRawY() - mDownEvent.getRawY();
            final float dt = elapsedMs / 1000.0f;
            final float maxAbsDelta = Math.max(Math.abs(dx), Math.abs(dy));
            final float velocity = maxAbsDelta / dt;
            return velocity > mFlingThresholdPx;
        }

        @Override
        public boolean onTouch(final View view, final MotionEvent motionEvent) {
            switch (motionEvent.getAction()) {
                case MotionEvent.ACTION_UP: {
                    if (!mMoved || mDownEvent == null) {
                        return false;
                    }
                    final float dx = motionEvent.getRawX() - mDownEvent.getRawX();
                    final float dy = motionEvent.getRawY() - mDownEvent.getRawY();

                    final float dt =
                            (motionEvent.getEventTime() - mDownEvent.getEventTime()) / 1000.0f;
                    final float yVelocity = dy / dt;

                    boolean handled = false;

                    // Vertical swipe occurred if the direction is as least mostly in the y
                    // component and has the required velocity (px/sec)
                    if ((dx == 0 || (Math.abs(dy) / Math.abs(dx)) > DIRECTION_RATIO) &&
                            Math.abs(yVelocity) > mFlingThresholdPx) {
                        if (yVelocity < 0 && mExpanded) {
                            setFullScreenView(true, true);
                            handled = true;
                        } else if (yVelocity > 0) {
                            if (mFullScreen && yVelocity < mBigFlingThresholdPx) {
                                setFullScreenView(false, true);
                            } else {
                                setExpanded(false, true, PAGE_NOT_SET);
                            }
                            handled = true;
                        }
                    }

                    if (!handled) {
                        // If they didn't swipe enough, animate back to resting state
                        setDesiredHeight(getDesiredHeight(), true);
                    }
                    resetState();
                    break;
                }
                case MotionEvent.ACTION_DOWN: {
                    mDownHeight = getHeight();
                    mDownEvent = MotionEvent.obtain(motionEvent);
                    // If we are here and care about the return value (i.e. this is not called
                    // from onInterceptTouchEvent), then presumably no children view in the panel
                    // handles the down event. We'd like to handle future ACTION_MOVE events, so
                    // always claim ownership on this event so it doesn't fall through and gets
                    // cancelled by the framework.
                    return true;
                }
                case MotionEvent.ACTION_MOVE: {
                    if (mDownEvent == null) {
                        return mMoved;
                    }

                    final float dx = mDownEvent.getRawX() - motionEvent.getRawX();
                    final float dy = mDownEvent.getRawY() - motionEvent.getRawY();
                    // Don't act if the move is mostly horizontal
                    if (Math.abs(dy) > mTouchSlop &&
                            (Math.abs(dy) / Math.abs(dx)) > DIRECTION_RATIO) {
                        setDesiredHeight((int) (mDownHeight + dy), false);
                        mMoved = true;
                        if (dy < -mTouchSlop) {
                            mMovedDown = true;
                        }
                    }
                    return mMoved;
                }

            }
            return mMoved;
        }

        private void resetState() {
            mDownEvent = null;
            mDownHeight = -1;
            mMoved = false;
            mMovedDown = false;
            mCanChildViewSwipeDown = false;
            updateViewPager();
        }
    }
}