src/com/cooliris/wallpaper/Slideshow.java

/*
 * Copyright (C) 2009 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.cooliris.wallpaper;

//import android.app.Service;
import com.cooliris.media.Vector3f;

import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.Paint;
import android.graphics.PorterDuffColorFilter;
import android.graphics.Rect;
import android.graphics.RectF;
import android.os.Handler;
import android.os.SystemClock;
import android.view.SurfaceHolder;
import android.view.SurfaceView;
import android.graphics.PorterDuff.Mode;

public class Slideshow extends SurfaceView implements SurfaceHolder.Callback {
    public Slideshow(Context context) {
        super(context);
        SurfaceHolder holder = getHolder();
        holder.addCallback(this);
    }

    public static final int SLIDESHOW_DURATION = 2000;

    public interface DataSource {
        /**
         * 
         * @param currentSlideshowCounter
         * @return
         */
        Bitmap getBitmapForIndex(Context context, int currentSlideshowCounter);
    }

    private final Handler mHandler = new Handler();
    private final Runnable mDrawFrame = new Runnable() {
        public void run() {
            drawFrame();
        }
    };
    private static final Paint sPaint = new Paint();
    static {
        sPaint.setFilterBitmap(true);
        sPaint.setDither(true);
    }
    private boolean mVisible = true;
    private DataSource mSource;
    private int mCurrentSlideshowCounter;
    private Bitmap mBitmap;
    private Rect mRect;
    private RectF mFrameRect;
    private static final Vector3f sGrow = new Vector3f();
    private Bitmap mQueuedBitmap;
    private Rect mQueuedRect;
    private RectF mQueuedFrameRect;
    private static final Vector3f sQueuedGrow = new Vector3f();

    private long mPrevTime;
    private long mTimeElapsed;

    public void setDataSource(DataSource source) {
        mSource = source;
    }

    public void surfaceChanged(SurfaceHolder holder, int format, int width, int height) {
        mHandler.post(mDrawFrame);
        if (mBitmap != null) {
            mRect = getRectToFitBitmap(mBitmap.getWidth(), mBitmap.getHeight(), width, height);
            mFrameRect.right = width;
            mFrameRect.bottom = height;
        }
        if (mQueuedBitmap != null) {
            mQueuedRect = getRectToFitBitmap(mQueuedBitmap.getWidth(), mQueuedBitmap.getHeight(), width, height);
            mQueuedFrameRect.right = width;
            mQueuedFrameRect.bottom = height;
        }
    }

    public void surfaceCreated(SurfaceHolder holder) {
        // We may need to make calls to super once this is a subclass of
        // WallpaperService.
        mHandler.post(mDrawFrame);
    }

    public void surfaceDestroyed(SurfaceHolder holder) {

    }

    public void drawFrame() {
        final SurfaceHolder holder = getHolder();
        Rect frame = holder.getSurfaceFrame();
        final Paint paint = sPaint;
        Canvas c = null;
        try {
            c = holder.lockCanvas();
            if (c != null) {
                long now = SystemClock.uptimeMillis();
                long delta = now - mPrevTime;
                if (delta > 50)
                    delta = 50;
                mTimeElapsed += delta;
                mPrevTime = now;
                performSetup(frame.width(), frame.height());
                // We draw the source bitmap
                if (mBitmap != null) {
                    if (mTimeElapsed > SLIDESHOW_DURATION) {
                        float alpha = ((float) (mTimeElapsed - SLIDESHOW_DURATION)) / 2000.0f;
                        paint.setColorFilter(null);
                        if (alpha < 1.0f) {
                            // int val = (int)(255 * (1.0f - alpha));
                            // int srcColor = Color.argb(val, 0, 0, 0);
                            // PorterDuffColorFilter colorFilter = new
                            // PorterDuffColorFilter(srcColor, Mode.SRC_IN);
                            // paint.setColorFilter(null);
                        }
                        c.drawBitmap(mBitmap, mRect, mFrameRect, paint);
                        if (alpha < 1.0f) {
                            int val = (int) (255 * alpha);
                            int srcColor = Color.argb(val, 0, 0, 0);
                            PorterDuffColorFilter colorFilter = new PorterDuffColorFilter(srcColor, Mode.DST_IN);
                            paint.setColorFilter(colorFilter);
                        }

                        c.drawBitmap(mQueuedBitmap, mQueuedRect, mQueuedFrameRect, paint);
                        performUpdate(mQueuedFrameRect, sQueuedGrow, delta);
                        if (alpha >= 1.0f) {
                            // We switch the image.
                            mRect = mQueuedRect;
                            mBitmap = mQueuedBitmap;
                            mFrameRect = mQueuedFrameRect;
                            sGrow.set(sQueuedGrow);
                            mQueuedBitmap = null;
                            mQueuedRect = null;
                            mQueuedFrameRect = null;
                            mTimeElapsed = 0;
                        }
                    } else {
                        paint.setColorFilter(null);
                        c.drawBitmap(mBitmap, mRect, mFrameRect, paint);
                    }
                    performUpdate(mFrameRect, sGrow, delta);
                }

            }
        } finally {
            if (c != null)
                holder.unlockCanvasAndPost(c);
        }
        mHandler.removeCallbacks(mDrawFrame);
        if (mVisible) {
            mHandler.postDelayed(mDrawFrame, 20);
        }
    }

    private void performUpdate(RectF rect, Vector3f grow, long delta) {
        float timeElapsed = ((float) (delta)) / 1000.0f;
        float amountToGrowX = timeElapsed * (rect.width() / 15.0f);
        float amountToGrowY = amountToGrowX * (rect.height() / rect.width());
        rect.top -= amountToGrowY * grow.x;
        rect.left -= amountToGrowX * grow.y;

        rect.bottom += amountToGrowY * (1 - grow.x);
        rect.right += amountToGrowX * (1 - grow.y);
    }

    private void performSetup(int viewWidth, int viewHeight) {
        if (mBitmap == null) {
            mBitmap = getRandomBitmap();
            if (mBitmap != null) {
                mRect = getRectToFitBitmap(mBitmap.getWidth(), mBitmap.getHeight(), viewWidth, viewHeight);
                mFrameRect = new RectF();
                mFrameRect.right = viewWidth;
                mFrameRect.bottom = viewHeight;
                sGrow.set((float) Math.random(), (float) Math.random(), 0);
            }
        }
        if (mQueuedBitmap == null) {
            mQueuedBitmap = getRandomBitmap();
            if (mQueuedBitmap == null) {
                mQueuedBitmap = mBitmap;
            }
            if (mQueuedBitmap != null) {
                mQueuedRect = getRectToFitBitmap(mQueuedBitmap.getWidth(), mQueuedBitmap.getHeight(), viewWidth, viewHeight);
                mQueuedFrameRect = new RectF();
                mQueuedFrameRect.right = viewWidth;
                mQueuedFrameRect.bottom = viewHeight;
                sQueuedGrow.set((float) Math.random(), (float) Math.random(), 0);
            }
        }
    }

    private Rect getRectToFitBitmap(int bitmapWidth, int bitmapHeight, int viewWidth, int viewHeight) {
        Rect rect = new Rect();
        float viewAspect = (float) viewHeight / viewWidth;
        float newWidth = bitmapWidth * viewAspect;
        if (bitmapHeight < newWidth) {
            // Vertically constrained.
            newWidth = bitmapHeight / viewAspect;
            rect.set((int) (bitmapWidth / 2 - newWidth / 2), 0, (int) (bitmapWidth / 2 + newWidth / 2), bitmapHeight);
        } else {
            // Horizontally constrained
            float newHeight = bitmapWidth * viewAspect;
            rect.set(0, (int) (bitmapHeight / 2 - newHeight / 2), bitmapWidth, (int) (bitmapHeight / 2 + newHeight / 2));
        }
        return rect;
    }

    private Bitmap getRandomBitmap() {
        if (mSource != null) {
            return mSource.getBitmapForIndex(getContext(), mCurrentSlideshowCounter++);
        }
        return null;
    }

    public void onVisibilityChanged(boolean visible) {
        mVisible = visible;
        if (!visible) {
            mHandler.removeCallbacks(mDrawFrame);
        }
        drawFrame();
    }

}