android-10.0.0_r47/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;

import android.content.Context;
import android.graphics.Rect;
import android.util.AttributeSet;
import android.view.LayoutInflater;
import android.view.View;
import android.view.animation.AnimationSet;
import android.view.animation.ScaleAnimation;
import android.view.animation.TranslateAnimation;
import android.widget.FrameLayout;
import android.widget.TextView;

import com.android.messaging.R;
import com.android.messaging.datamodel.data.MediaPickerMessagePartData;
import com.android.messaging.datamodel.data.MessagePartData;
import com.android.messaging.datamodel.data.PendingAttachmentData;
import com.android.messaging.datamodel.media.ImageRequestDescriptor;
import com.android.messaging.ui.AsyncImageView.AsyncImageViewDelayLoader;
import com.android.messaging.util.AccessibilityUtil;
import com.android.messaging.util.Assert;
import com.android.messaging.util.UiUtils;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;

/**
 * Holds and displays multiple attachments in a 4x2 grid. Each preview image "tile" can take
 * one of three sizes - small (1x1), wide (2x1) and large (2x2). We have a number of predefined
 * layout settings designed for holding 2, 3, 4+ attachments (these layout settings are
 * tweakable by design request to allow for max flexibility). For a visual example, consider the
 * following attachment layout:
 *
 * +---------------+----------------+
 * |               |                |
 * |               |       B        |
 * |               |                |
 * |       A       |-------+--------|
 * |               |       |        |
 * |               |   C   |    D   |
 * |               |       |        |
 * +---------------+-------+--------+
 *
 * In the above example, the layout consists of four tiles, A-D. A is a large tile, B is a
 * wide tile and C & D are both small tiles. A starts at (0,0) and ends at (1,1), B starts at
 * (2,0) and ends at (3,0), and so on. In our layout class we'd have these tiles in the order
 * of A-D, so that we make sure the last tile is always the one where we can put the overflow
 * indicator (e.g. "+2").
 */
public class MultiAttachmentLayout extends FrameLayout {

    public interface OnAttachmentClickListener {
        boolean onAttachmentClick(MessagePartData attachment, Rect viewBoundsOnScreen,
                boolean longPress);
    }

    private static final int GRID_WIDTH = 4;    // in # of cells
    private static final int GRID_HEIGHT = 2;   // in # of cells

    /**
     * Represents a preview image tile in the layout
     */
    private static class Tile {
        public final int startX;
        public final int startY;
        public final int endX;
        public final int endY;

        private Tile(final int startX, final int startY, final int endX, final int endY) {
            this.startX = startX;
            this.startY = startY;
            this.endX = endX;
            this.endY = endY;
        }

        public int getWidthMeasureSpec(final int cellWidth, final int padding) {
            return MeasureSpec.makeMeasureSpec((endX - startX + 1) * cellWidth - padding * 2,
                    MeasureSpec.EXACTLY);
        }

        public int getHeightMeasureSpec(final int cellHeight, final int padding) {
            return MeasureSpec.makeMeasureSpec((endY - startY + 1) * cellHeight - padding * 2,
                    MeasureSpec.EXACTLY);
        }

        public static Tile large(final int startX, final int startY) {
            return new Tile(startX, startY, startX + 1, startY + 1);
        }

        public static Tile wide(final int startX, final int startY) {
            return new Tile(startX, startY, startX + 1, startY);
        }

        public static Tile small(final int startX, final int startY) {
            return new Tile(startX, startY, startX, startY);
        }
    }

    /**
     * A layout simply contains a list of tiles, in the order of top-left -> bottom-right.
     */
    private static class Layout {
        public final List<Tile> tiles;
        public Layout(final Tile[] tilesArray) {
            tiles = Arrays.asList(tilesArray);
        }
    }

    /**
     * List of predefined layout configurations w.r.t no. of attachments.
     */
    private static final Layout[] ATTACHMENT_LAYOUTS_BY_COUNT = {
        null,   // Doesn't support zero attachments.
        null,   // Doesn't support one attachment. Single attachment preview is used instead.
        new Layout(new Tile[] { Tile.large(0, 0), Tile.large(2, 0) }),                  // 2 items
        new Layout(new Tile[] { Tile.large(0, 0), Tile.wide(2, 0), Tile.wide(2, 1) }),  // 3 items
        new Layout(new Tile[] { Tile.large(0, 0), Tile.wide(2, 0), Tile.small(2, 1),    // 4+ items
                Tile.small(3, 1) }),
    };

    /**
     * List of predefined RTL layout configurations w.r.t no. of attachments.
     */
    private static final Layout[] ATTACHMENT_RTL_LAYOUTS_BY_COUNT = {
        null,   // Doesn't support zero attachments.
        null,   // Doesn't support one attachment. Single attachment preview is used instead.
        new Layout(new Tile[] { Tile.large(2, 0), Tile.large(0, 0)}),                   // 2 items
        new Layout(new Tile[] { Tile.large(2, 0), Tile.wide(0, 0), Tile.wide(0, 1) }),  // 3 items
        new Layout(new Tile[] { Tile.large(2, 0), Tile.wide(0, 0), Tile.small(1, 1),    // 4+ items
                Tile.small(0, 1) }),
    };

    private Layout mCurrentLayout;
    private ArrayList<ViewWrapper> mPreviewViews;
    private int mPlusNumber;
    private TextView mPlusTextView;
    private OnAttachmentClickListener mAttachmentClickListener;
    private AsyncImageViewDelayLoader mImageViewDelayLoader;

    public MultiAttachmentLayout(final Context context, final AttributeSet attrs) {
        super(context, attrs);
        mPreviewViews = new ArrayList<ViewWrapper>();
    }

    public void bindAttachments(final Iterable<MessagePartData> attachments,
            final Rect transitionRect, final int count) {
        final ArrayList<ViewWrapper> previousViews = mPreviewViews;
        mPreviewViews = new ArrayList<ViewWrapper>();
        removeView(mPlusTextView);
        mPlusTextView = null;

        determineLayout(attachments, count);
        buildViews(attachments, previousViews, transitionRect);

        // Remove all previous views that couldn't be recycled.
        for (final ViewWrapper viewWrapper : previousViews) {
            removeView(viewWrapper.view);
        }
        requestLayout();
    }

    public OnAttachmentClickListener getOnAttachmentClickListener() {
        return mAttachmentClickListener;
    }

    public void setOnAttachmentClickListener(final OnAttachmentClickListener listener) {
        mAttachmentClickListener = listener;
    }

    public void setImageViewDelayLoader(final AsyncImageViewDelayLoader delayLoader) {
        mImageViewDelayLoader = delayLoader;
    }

    public void setColorFilter(int color) {
        for (ViewWrapper viewWrapper : mPreviewViews) {
            if (viewWrapper.view instanceof AsyncImageView) {
                ((AsyncImageView) viewWrapper.view).setColorFilter(color);
            }
        }
    }

    public void clearColorFilter() {
        for (ViewWrapper viewWrapper : mPreviewViews) {
            if (viewWrapper.view instanceof AsyncImageView) {
                ((AsyncImageView) viewWrapper.view).clearColorFilter();
            }
        }
    }

    private void determineLayout(final Iterable<MessagePartData> attachments, final int count) {
        Assert.isTrue(attachments != null);
        final boolean isRtl = AccessibilityUtil.isLayoutRtl(getRootView());
        if (isRtl) {
            mCurrentLayout = ATTACHMENT_RTL_LAYOUTS_BY_COUNT[Math.min(count,
                    ATTACHMENT_RTL_LAYOUTS_BY_COUNT.length - 1)];
        } else {
            mCurrentLayout = ATTACHMENT_LAYOUTS_BY_COUNT[Math.min(count,
                    ATTACHMENT_LAYOUTS_BY_COUNT.length - 1)];
        }

        // We must have a valid layout for the current configuration.
        Assert.notNull(mCurrentLayout);

        mPlusNumber = count - mCurrentLayout.tiles.size();
        Assert.isTrue(mPlusNumber >= 0);
    }

    private void buildViews(final Iterable<MessagePartData> attachments,
            final ArrayList<ViewWrapper> previousViews, final Rect transitionRect) {
        final LayoutInflater layoutInflater = LayoutInflater.from(getContext());
        final int count = mCurrentLayout.tiles.size();
        int i = 0;
        final Iterator<MessagePartData> iterator = attachments.iterator();
        while (iterator.hasNext() && i < count) {
            final MessagePartData attachment = iterator.next();
            ViewWrapper attachmentWrapper = null;
            // Try to recycle a previous view first
            for (int j = 0; j < previousViews.size(); j++) {
                final ViewWrapper previousView = previousViews.get(j);
                if (previousView.attachment.equals(attachment) &&
                        !(previousView.attachment instanceof PendingAttachmentData)) {
                    attachmentWrapper = previousView;
                    previousViews.remove(j);
                    break;
                }
            }

            if (attachmentWrapper == null) {
                final View view = AttachmentPreviewFactory.createAttachmentPreview(layoutInflater,
                        attachment, this, AttachmentPreviewFactory.TYPE_MULTIPLE,
                        false /* startImageRequest */, mAttachmentClickListener);

                if (view == null) {
                    // createAttachmentPreview can return null if something goes wrong (e.g.
                    // attachment has unsupported contentType)
                    continue;
                }
                if (view instanceof AsyncImageView && mImageViewDelayLoader != null) {
                    AsyncImageView asyncImageView = (AsyncImageView) view;
                    asyncImageView.setDelayLoader(mImageViewDelayLoader);
                }
                addView(view);
                attachmentWrapper = new ViewWrapper(view, attachment);
                // Help animate from single to multi by copying over the prev location
                if (count == 2 && i == 1 && transitionRect != null) {
                    attachmentWrapper.prevLeft = transitionRect.left;
                    attachmentWrapper.prevTop = transitionRect.top;
                    attachmentWrapper.prevWidth = transitionRect.width();
                    attachmentWrapper.prevHeight = transitionRect.height();
                }
            }
            i++;
            Assert.notNull(attachmentWrapper);
            mPreviewViews.add(attachmentWrapper);

            // The first view will animate in using PopupTransitionAnimation, but the remaining
            // views will slide from their previous position to their new position within the
            // layout
            if (i == 0) {
                AttachmentPreview.tryAnimateViewIn(attachment, attachmentWrapper.view);
            }
            attachmentWrapper.needsSlideAnimation = i > 0;
        }

        // Build the plus text view (e.g. "+2") for when there are more attachments than what
        // this layout can display.
        if (mPlusNumber > 0) {
            mPlusTextView = (TextView) layoutInflater.inflate(R.layout.attachment_more_text_view,
                    null /* parent */);
            mPlusTextView.setText(getResources().getString(R.string.attachment_more_items,
                    mPlusNumber));
            addView(mPlusTextView);
        }
    }

    @Override
    protected void onMeasure(final int widthMeasureSpec, final int heightMeasureSpec) {
        final int maxWidth = getResources().getDimensionPixelSize(
                R.dimen.multiple_attachment_preview_width);
        final int maxHeight = getResources().getDimensionPixelSize(
                R.dimen.multiple_attachment_preview_height);
        final int width = Math.min(MeasureSpec.getSize(widthMeasureSpec), maxWidth);
        final int height = maxHeight;
        final int cellWidth = width / GRID_WIDTH;
        final int cellHeight = height / GRID_HEIGHT;
        final int count = mPreviewViews.size();
        final int padding = getResources().getDimensionPixelOffset(
                R.dimen.multiple_attachment_preview_padding);
        for (int i = 0; i < count; i++) {
            final View view =  mPreviewViews.get(i).view;
            final Tile imageTile = mCurrentLayout.tiles.get(i);
            view.measure(imageTile.getWidthMeasureSpec(cellWidth, padding),
                    imageTile.getHeightMeasureSpec(cellHeight, padding));

            // Now that we know the size, we can request an appropriately-sized image.
            if (view instanceof AsyncImageView) {
                final ImageRequestDescriptor imageRequest =
                        AttachmentPreviewFactory.getImageRequestDescriptorForAttachment(
                                mPreviewViews.get(i).attachment,
                                view.getMeasuredWidth(),
                                view.getMeasuredHeight());
                ((AsyncImageView) view).setImageResourceId(imageRequest);
            }

            if (i == count - 1 && mPlusTextView != null) {
                // The plus text view always covers the last attachment.
                mPlusTextView.measure(imageTile.getWidthMeasureSpec(cellWidth, padding),
                        imageTile.getHeightMeasureSpec(cellHeight, padding));
            }
        }
        setMeasuredDimension(width, height);
    }

    @Override
    protected void onLayout(final boolean changed, final int left, final int top, final int right,
            final int bottom) {
        final int cellWidth = getMeasuredWidth() / GRID_WIDTH;
        final int cellHeight = getMeasuredHeight() / GRID_HEIGHT;
        final int padding = getResources().getDimensionPixelOffset(
                R.dimen.multiple_attachment_preview_padding);
        final int count = mPreviewViews.size();
        for (int i = 0; i < count; i++) {
            final ViewWrapper viewWrapper =  mPreviewViews.get(i);
            final View view = viewWrapper.view;
            final Tile imageTile = mCurrentLayout.tiles.get(i);
            final int tileLeft = imageTile.startX * cellWidth;
            final int tileTop = imageTile.startY * cellHeight;
            view.layout(tileLeft + padding, tileTop + padding,
                    tileLeft + view.getMeasuredWidth(),
                    tileTop + view.getMeasuredHeight());
            if (viewWrapper.needsSlideAnimation) {
                trySlideAttachmentView(viewWrapper);
                viewWrapper.needsSlideAnimation = false;
            } else {
                viewWrapper.prevLeft = view.getLeft();
                viewWrapper.prevTop = view.getTop();
                viewWrapper.prevWidth = view.getWidth();
                viewWrapper.prevHeight = view.getHeight();
            }

            if (i == count - 1 && mPlusTextView != null) {
                // The plus text view always covers the last attachment.
                mPlusTextView.layout(tileLeft + padding, tileTop + padding,
                        tileLeft + mPlusTextView.getMeasuredWidth(),
                        tileTop + mPlusTextView.getMeasuredHeight());
            }
        }
    }

    private void trySlideAttachmentView(final ViewWrapper viewWrapper) {
        if (!(viewWrapper.attachment instanceof MediaPickerMessagePartData)) {
            return;
        }
        final View view = viewWrapper.view;


        final int xOffset = viewWrapper.prevLeft - view.getLeft();
        final int yOffset = viewWrapper.prevTop - view.getTop();
        final float scaleX = viewWrapper.prevWidth / (float) view.getWidth();
        final float scaleY = viewWrapper.prevHeight / (float) view.getHeight();

        if (xOffset == 0 && yOffset == 0 && scaleX == 1 && scaleY == 1) {
            // Layout hasn't changed
            return;
        }

        final AnimationSet animationSet = new AnimationSet(
                true /* shareInterpolator */);
        animationSet.addAnimation(new TranslateAnimation(xOffset, 0, yOffset, 0));
        animationSet.addAnimation(new ScaleAnimation(scaleX, 1, scaleY, 1));
        animationSet.setDuration(
                UiUtils.MEDIAPICKER_TRANSITION_DURATION);
        animationSet.setInterpolator(UiUtils.DEFAULT_INTERPOLATOR);
        view.startAnimation(animationSet);
        view.invalidate();
        viewWrapper.prevLeft = view.getLeft();
        viewWrapper.prevTop = view.getTop();
        viewWrapper.prevWidth = view.getWidth();
        viewWrapper.prevHeight = view.getHeight();
    }

    public View findViewForAttachment(final MessagePartData attachment) {
        for (ViewWrapper wrapper : mPreviewViews) {
            if (wrapper.attachment.equals(attachment) &&
                    !(wrapper.attachment instanceof PendingAttachmentData)) {
                return wrapper.view;
            }
        }
        return null;
    }

    private static class ViewWrapper {
        final View view;
        final MessagePartData attachment;
        boolean needsSlideAnimation;
        int prevLeft;
        int prevTop;
        int prevWidth;
        int prevHeight;

        ViewWrapper(final View view, final MessagePartData attachment) {
            this.view = view;
            this.attachment = attachment;
        }
    }
}