mail/bitmap/AttachmentDrawable.java

package com.android.mail.bitmap;

import android.animation.Animator;
import android.animation.AnimatorListenerAdapter;
import android.animation.ValueAnimator;
import android.animation.ValueAnimator.AnimatorUpdateListener;
import android.content.Context;
import android.content.res.Resources;
import android.graphics.Canvas;
import android.graphics.ColorFilter;
import android.graphics.Paint;
import android.graphics.PixelFormat;
import android.graphics.Rect;
import android.graphics.drawable.Drawable;
import android.os.Handler;
import android.util.DisplayMetrics;
import android.view.animation.LinearInterpolator;

import com.android.bitmap.BitmapCache;
import com.android.bitmap.BitmapUtils;
import com.android.bitmap.DecodeAggregator;
import com.android.bitmap.DecodeTask;
import com.android.bitmap.DecodeTask.Request;
import com.android.bitmap.ReusableBitmap;
import com.android.bitmap.Trace;
import com.android.mail.R;
import com.android.mail.browse.ConversationItemViewCoordinates;
import com.android.mail.ui.SwipeableListView;
import com.android.mail.utils.LogUtils;
import com.android.mail.utils.RectUtils;

import java.util.concurrent.Executor;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

/**
 * This class encapsulates all functionality needed to display a single image attachment thumbnail,
 * including request creation/cancelling, data unbinding and re-binding, and fancy animations
 * to draw upon state changes.
 * <p>
 * The actual bitmap decode work is handled by {@link DecodeTask}.
 */
public class AttachmentDrawable extends Drawable implements DecodeTask.BitmapView,
        Drawable.Callback, Runnable, Parallaxable, DecodeAggregator.Callback {

    private ImageAttachmentRequest mCurrKey;
    private ReusableBitmap mBitmap;
    private final BitmapCache mCache;
    private final DecodeAggregator mDecodeAggregator;
    private DecodeTask mTask;
    private int mDecodeWidth;
    private int mDecodeHeight;
    private int mLoadState = LOAD_STATE_UNINITIALIZED;
    private float mParallaxFraction = 0.5f;
    private float mParallaxSpeedMultiplier;

    // each attachment gets its own placeholder and progress indicator, to be shown, hidden,
    // and animated based on Drawable#setVisible() changes, which are in turn driven by
    // #setLoadState().
    private Placeholder mPlaceholder;
    private Progress mProgress;

    private static final Executor SMALL_POOL_EXECUTOR = new ThreadPoolExecutor(4, 4,
            1, TimeUnit.SECONDS, new LinkedBlockingQueue<Runnable>());

    private static final Executor EXECUTOR = SMALL_POOL_EXECUTOR;

    private static final boolean LIMIT_BITMAP_DENSITY = true;

    private static final int MAX_BITMAP_DENSITY = DisplayMetrics.DENSITY_HIGH;

    private static final int LOAD_STATE_UNINITIALIZED = 0;
    private static final int LOAD_STATE_NOT_YET_LOADED = 1;
    private static final int LOAD_STATE_LOADING = 2;
    private static final int LOAD_STATE_LOADED = 3;
    private static final int LOAD_STATE_FAILED = 4;

    private final ConversationItemViewCoordinates mCoordinates;
    private final float mDensity;
    private final int mProgressDelayMs;
    private final Paint mPaint = new Paint();
    private final Rect mSrcRect = new Rect();
    private final Handler mHandler = new Handler();

    public final String LOG_TAG = "AttachPreview";

    public AttachmentDrawable(final Resources res, final BitmapCache cache,
            final DecodeAggregator decodeAggregator,
            final ConversationItemViewCoordinates coordinates, final Drawable placeholder,
            final Drawable progress) {
        mCoordinates = coordinates;
        mDensity = res.getDisplayMetrics().density;
        mCache = cache;
        this.mDecodeAggregator = decodeAggregator;
        mPaint.setFilterBitmap(true);

        final int fadeOutDurationMs = res.getInteger(R.integer.ap_fade_animation_duration);
        final int tileColor = res.getColor(R.color.ap_background_color);
        mProgressDelayMs = res.getInteger(R.integer.ap_progress_animation_delay);

        mPlaceholder = new Placeholder(placeholder.getConstantState().newDrawable(res), res,
                coordinates, fadeOutDurationMs, tileColor);
        mPlaceholder.setCallback(this);

        mProgress = new Progress(progress.getConstantState().newDrawable(res), res,
                coordinates, fadeOutDurationMs, tileColor);
        mProgress.setCallback(this);
    }

    public DecodeTask.Request getKey() {
        return mCurrKey;
    }

    public void setDecodeDimensions(int w, int h) {
        mDecodeWidth = w;
        mDecodeHeight = h;
    }

    public void setParallaxSpeedMultiplier(final float parallaxSpeedMultiplier) {
        mParallaxSpeedMultiplier = parallaxSpeedMultiplier;
    }

    public void showStaticPlaceholder() {
        setLoadState(LOAD_STATE_FAILED);
    }

    public void unbind() {
        setImage(null);
    }

    public void bind(Context context, String lookupUri, int rendition) {
        final Rect bounds = getBounds();
        if (bounds.isEmpty()) {
            throw new IllegalStateException("AttachmentDrawable must have bounds set before bind");
        }
        setImage(new ImageAttachmentRequest(context, lookupUri, rendition, bounds.width()));
    }

    private void setImage(final ImageAttachmentRequest key) {
        if (mCurrKey != null && mCurrKey.equals(key)) {
            return;
        }

        Trace.beginSection("set image");
        // avoid visual state transitions when the existing request and the new one are just
        // requests for different renditions of the same attachment
        final boolean onlyRenditionChange = (mCurrKey != null && mCurrKey.matches(key));

        if (mBitmap != null && !onlyRenditionChange) {
            mBitmap.releaseReference();
//            System.out.println("view.bind() decremented ref to old bitmap: " + mBitmap);
            mBitmap = null;
        }
        if (mCurrKey != null && SwipeableListView.ENABLE_ATTACHMENT_DECODE_AGGREGATOR) {
            mDecodeAggregator.forget(mCurrKey);
        }
        mCurrKey = key;

        if (mTask != null) {
            mTask.cancel();
            mTask = null;
        }

        mHandler.removeCallbacks(this);
        // start from a clean slate on every bind
        // this allows the initial transition to be specially instantaneous, so e.g. a cache hit
        // doesn't unnecessarily trigger a fade-in
        setLoadState(LOAD_STATE_UNINITIALIZED);

        if (key == null) {
            Trace.endSection();
            return;
        }

        // find cached entry here and skip decode if found.
        final ReusableBitmap cached = mCache.get(key, true /* incrementRefCount */);
        if (cached != null) {
            setBitmap(cached);
            LogUtils.d(LOG_TAG, "CACHE HIT key=%s", mCurrKey);
        } else {
            decode(!onlyRenditionChange);
            if (LogUtils.isLoggable(LOG_TAG, LogUtils.DEBUG)) {
                LogUtils.d(LOG_TAG, "CACHE MISS key=%s\ncache=%s",
                        mCurrKey, mCache.toDebugString());
            }
        }
        Trace.endSection();
    }

    @Override
    public void setParallaxFraction(float fraction) {
        mParallaxFraction = fraction;
    }

    @Override
    public void draw(final Canvas canvas) {
        final Rect bounds = getBounds();
        if (bounds.isEmpty()) {
            return;
        }

        if (mBitmap != null) {
            BitmapUtils
                    .calculateCroppedSrcRect(mBitmap.getLogicalWidth(), mBitmap.getLogicalHeight(),
                            bounds.width(), bounds.height(),
                            mCoordinates.attachmentPreviewsDecodeHeight, Integer.MAX_VALUE,
                            mParallaxFraction, false /* absoluteFraction */,
                            mParallaxSpeedMultiplier, mSrcRect);

            final int orientation = mBitmap.getOrientation();
            // calculateCroppedSrcRect() gave us the source rectangle "as if" the orientation has
            // been corrected. We need to decode the uncorrected source rectangle. Calculate true
            // coordinates.
            RectUtils.rotateRectForOrientation(orientation,
                    new Rect(0, 0, mBitmap.getLogicalWidth(), mBitmap.getLogicalHeight()),
                    mSrcRect);

            // We may need to rotate the canvas, so we also have to rotate the bounds.
            final Rect rotatedBounds = new Rect(bounds);
            RectUtils.rotateRect(orientation, bounds.centerX(), bounds.centerY(), rotatedBounds);

            // Rotate the canvas.
            canvas.save();
            canvas.rotate(orientation, bounds.centerX(), bounds.centerY());
            canvas.drawBitmap(mBitmap.bmp, mSrcRect, rotatedBounds, mPaint);
            canvas.restore();
        }

        // Draw the two possible overlay layers in reverse-priority order.
        // (each layer will no-op the draw when appropriate)
        // This ordering means cross-fade transitions are just fade-outs of each layer.
        mProgress.draw(canvas);
        mPlaceholder.draw(canvas);
    }

    @Override
    public void setAlpha(int alpha) {
        final int old = mPaint.getAlpha();
        mPaint.setAlpha(alpha);
        mPlaceholder.setAlpha(alpha);
        mProgress.setAlpha(alpha);
        if (alpha != old) {
            invalidateSelf();
        }
    }

    @Override
    public void setColorFilter(ColorFilter cf) {
        mPaint.setColorFilter(cf);
        mPlaceholder.setColorFilter(cf);
        mProgress.setColorFilter(cf);
        invalidateSelf();
    }

    @Override
    public int getOpacity() {
        return (mBitmap != null && (mBitmap.bmp.hasAlpha() || mPaint.getAlpha() < 255)) ?
                PixelFormat.TRANSLUCENT : PixelFormat.OPAQUE;
    }

    @Override
    protected void onBoundsChange(Rect bounds) {
        super.onBoundsChange(bounds);

        mPlaceholder.setBounds(bounds);
        mProgress.setBounds(bounds);
    }

    @Override
    public void onDecodeBegin(final Request key) {
        if (SwipeableListView.ENABLE_ATTACHMENT_DECODE_AGGREGATOR) {
            mDecodeAggregator.expect(key, this);
        } else {
            onBecomeFirstExpected(key);
        }
    }

    @Override
    public void onBecomeFirstExpected(final Request key) {
        if (!key.equals(mCurrKey)) {
            return;
        }
        // normally, we'd transition to the LOADING state now, but we want to delay that a bit
        // to minimize excess occurrences of the rotating spinner
        mHandler.postDelayed(this, mProgressDelayMs);
    }

    @Override
    public void run() {
        if (mLoadState == LOAD_STATE_NOT_YET_LOADED) {
            setLoadState(LOAD_STATE_LOADING);
        }
    }

    @Override
    public void onDecodeComplete(final Request key, final ReusableBitmap result) {
        if (SwipeableListView.ENABLE_ATTACHMENT_DECODE_AGGREGATOR) {
            mDecodeAggregator.execute(key, new Runnable() {
                @Override
                public void run() {
                    onDecodeCompleteImpl(key, result);
                }

                @Override
                public String toString() {
                    return "DONE";
                }
            });
        } else {
            onDecodeCompleteImpl(key, result);
        }
    }

    private void onDecodeCompleteImpl(final Request key, final ReusableBitmap result) {
        if (key.equals(mCurrKey)) {
            setBitmap(result);
        } else {
            // if the requests don't match (i.e. this request is stale), decrement the
            // ref count to allow the bitmap to be pooled
            if (result != null) {
                result.releaseReference();
            }
        }
    }

    @Override
    public void onDecodeCancel(final Request key) {
        if (SwipeableListView.ENABLE_ATTACHMENT_DECODE_AGGREGATOR) {
            mDecodeAggregator.forget(key);
        }
    }

    private void setBitmap(ReusableBitmap bmp) {
        if (mBitmap != null && mBitmap != bmp) {
            mBitmap.releaseReference();
        }
        mBitmap = bmp;
        setLoadState((bmp != null) ? LOAD_STATE_LOADED : LOAD_STATE_FAILED);
        invalidateSelf();
    }

    private void decode(boolean executeStateChange) {
        final int w;
        final int bufferW;
        final int bufferH;

        if (mCurrKey == null) {
            return;
        }

        Trace.beginSection("decode");
        if (LIMIT_BITMAP_DENSITY) {
            final float scale =
                    Math.min(1f, (float) MAX_BITMAP_DENSITY / DisplayMetrics.DENSITY_DEFAULT
                            / mDensity);
            w = (int) (mCurrKey.mDestW * scale);
            bufferW = (int) (mDecodeWidth * scale);
            bufferH = (int) (mDecodeHeight * scale);
        } else {
            w = mCurrKey.mDestW;
            bufferW = mDecodeWidth;
            bufferH = mDecodeHeight;
        }

        if (w == 0 || bufferH == 0) {
            Trace.endSection();
            return;
        }
//        System.out.println("ITEM " + this + " w=" + w + " h=" + bufferH + " key=" + mCurrKey);
        if (mTask != null) {
            mTask.cancel();
        }
        if (executeStateChange) {
            setLoadState(LOAD_STATE_NOT_YET_LOADED);
        }
        mTask = new DecodeTask(mCurrKey, w, bufferH, bufferW, bufferH, this, mCache);
        mTask.executeOnExecutor(EXECUTOR);
        Trace.endSection();
    }

    private void setLoadState(int loadState) {
        LogUtils.v(LOG_TAG, "IN AD.setState. old=%s new=%s key=%s this=%s", mLoadState, loadState,
                mCurrKey, this);
        if (mLoadState == loadState) {
            LogUtils.v(LOG_TAG, "OUT no-op AD.setState");
            return;
        }

        Trace.beginSection("set load state");
        switch (loadState) {
            // This state differs from LOADED in that the subsequent state transition away from
            // UNINITIALIZED will not have a fancy transition. This allows list item binds to
            // cached data to take immediate effect without unnecessary whizzery.
            case LOAD_STATE_UNINITIALIZED:
                mPlaceholder.reset();
                mProgress.reset();
                break;
            case LOAD_STATE_NOT_YET_LOADED:
                mPlaceholder.setPulseEnabled(true);
                mPlaceholder.setVisible(true);
                mProgress.setVisible(false);
                break;
            case LOAD_STATE_LOADING:
                mPlaceholder.setVisible(false);
                mProgress.setVisible(true);
                break;
            case LOAD_STATE_LOADED:
                mPlaceholder.setVisible(false);
                mProgress.setVisible(false);
                break;
            case LOAD_STATE_FAILED:
                mPlaceholder.setPulseEnabled(false);
                mPlaceholder.setVisible(true);
                mProgress.setVisible(false);
                break;
        }
        Trace.endSection();

        mLoadState = loadState;
        LogUtils.v(LOG_TAG, "OUT stateful AD.setState. new=%s placeholder=%s progress=%s",
                loadState, mPlaceholder.isVisible(), mProgress.isVisible());
    }

    @Override
    public void invalidateDrawable(Drawable who) {
        invalidateSelf();
    }

    @Override
    public void scheduleDrawable(Drawable who, Runnable what, long when) {
        scheduleSelf(what, when);
    }

    @Override
    public void unscheduleDrawable(Drawable who, Runnable what) {
        unscheduleSelf(what);
    }

    private static class Placeholder extends TileDrawable {

        private final ValueAnimator mPulseAnimator;
        private boolean mPulseEnabled = true;
        private float mPulseAlphaFraction = 1f;

        public Placeholder(Drawable placeholder, Resources res,
                ConversationItemViewCoordinates coordinates, int fadeOutDurationMs,
                int tileColor) {
            super(placeholder, coordinates.placeholderWidth, coordinates.placeholderHeight,
                    tileColor, fadeOutDurationMs);
            mPulseAnimator = ValueAnimator.ofInt(55, 255)
                    .setDuration(res.getInteger(R.integer.ap_placeholder_animation_duration));
            mPulseAnimator.setRepeatCount(ValueAnimator.INFINITE);
            mPulseAnimator.setRepeatMode(ValueAnimator.REVERSE);
            mPulseAnimator.addUpdateListener(new AnimatorUpdateListener() {
                @Override
                public void onAnimationUpdate(ValueAnimator animation) {
                    mPulseAlphaFraction = ((Integer) animation.getAnimatedValue()) / 255f;
                    setInnerAlpha(getCurrentAlpha());
                }
            });
            mFadeOutAnimator.addListener(new AnimatorListenerAdapter() {
                @Override
                public void onAnimationEnd(Animator animation) {
                    stopPulsing();
                }
            });
        }

        @Override
        public void setInnerAlpha(final int alpha) {
            super.setInnerAlpha((int) (alpha * mPulseAlphaFraction));
        }

        public void setPulseEnabled(boolean enabled) {
            mPulseEnabled = enabled;
            if (!mPulseEnabled) {
                stopPulsing();
            }
        }

        private void stopPulsing() {
            if (mPulseAnimator != null) {
                mPulseAnimator.cancel();
                mPulseAlphaFraction = 1f;
                setInnerAlpha(getCurrentAlpha());
            }
        }

        @Override
        public boolean setVisible(boolean visible) {
            final boolean changed = super.setVisible(visible);
            if (changed) {
                if (isVisible()) {
                    // start
                    if (mPulseAnimator != null && mPulseEnabled) {
                        mPulseAnimator.start();
                    }
                } else {
                    // can't cancel the pulsing yet-- wait for the fade-out animation to end
                    // one exception: if alpha is already zero, there is no fade-out, so stop now
                    if (getCurrentAlpha() == 0) {
                        stopPulsing();
                    }
                }
            }
            return changed;
        }

    }

    private static class Progress extends TileDrawable {

        private final ValueAnimator mRotateAnimator;

        public Progress(Drawable progress, Resources res,
                ConversationItemViewCoordinates coordinates, int fadeOutDurationMs,
                int tileColor) {
            super(progress, coordinates.progressBarWidth, coordinates.progressBarHeight,
                    tileColor, fadeOutDurationMs);

            mRotateAnimator = ValueAnimator.ofInt(0, 10000)
                    .setDuration(res.getInteger(R.integer.ap_progress_animation_duration));
            mRotateAnimator.setInterpolator(new LinearInterpolator());
            mRotateAnimator.setRepeatCount(ValueAnimator.INFINITE);
            mRotateAnimator.addUpdateListener(new AnimatorUpdateListener() {
                @Override
                public void onAnimationUpdate(ValueAnimator animation) {
                    setLevel((Integer) animation.getAnimatedValue());
                }
            });
            mFadeOutAnimator.addListener(new AnimatorListenerAdapter() {
                @Override
                public void onAnimationEnd(Animator animation) {
                    if (mRotateAnimator != null) {
                        mRotateAnimator.cancel();
                    }
                }
            });
        }

        @Override
        public boolean setVisible(boolean visible) {
            final boolean changed = super.setVisible(visible);
            if (changed) {
                if (isVisible()) {
                    if (mRotateAnimator != null) {
                        mRotateAnimator.start();
                    }
                } else {
                    // can't cancel the rotate yet-- wait for the fade-out animation to end
                    // one exception: if alpha is already zero, there is no fade-out, so stop now
                    if (getCurrentAlpha() == 0 && mRotateAnimator != null) {
                        mRotateAnimator.cancel();
                    }
                }
            }
            return changed;
        }

    }
}