Live Wallpaper Tutorial

问题:

I am trying to do the following from a live wallpaper tutorial I found here.

/**
 * Do the actual drawing stuff
 */
private void doDraw(Canvas canvas) {
    Bitmap b = BitmapFactory.decodeResource(context.getResources(), IMAGES[current]);
    canvas.drawColor(Color.BLACK);
    canvas.drawBitmap(b, 0, 0, null);
    Log.d(TAG, "Drawing finished.");
}

/**
 * Update the animation, sprites or whatever.
 * If there is nothing to animate set the wait
 * attribute of the thread to true
 */
private void updatePhysics() {
    // if nothing was updated :
    // this.wait = true;
    if(previousTime - System.currentTimeMillis() >= 41) { //24 FPS
        current = current < IMAGES.length ? current++ : 0;
    }
    Log.d(TAG, "Updated physics.");
}

But it doesn't seem to work. What am I doing wrong. The "Drawing finished." and "Updated physics." messages are getting printed. But I see the first image only. I'm testing it on the emulator.

Any help would be appreciated. Thanks

回答1:

I have worked out a simple sample live wallpaper where the color shift over time. Maybe you can use this as a starting point:

package com.cmwmobile.android.samples;

import android.graphics.Canvas;

import android.os.Handler;

import android.service.wallpaper.WallpaperService;

import android.view.SurfaceHolder;

/**
 * The SampleLiveWallpaperService class is responsible for showing the
 * animation and is an interface to android. 
 * @author Casper Wakkers - www.cmwmobile.com
 */
public class SampleLiveWallpaperService extends WallpaperService {
    private Handler handler = null;

    /**
     * Inner class representing the actual implementation of the
     * Live Wallpaper {@link Engine}.
     */
    private class SampleLiveWallpaperEngine extends Engine {
        private boolean visible = false;

        private int[] colors = {0, 0, 0} ;

        /**
         * Runnable implementation for the actual work.
         */
        private final Runnable runnableSomething = new Runnable() {
            /**
             * {@inheritDoc}
             */
            public void run() {
                drawSomething();
            }
        };
        /**
         * The drawSomething method is responsible for drawing the animation.
         */
        private void drawSomething() {
            final SurfaceHolder holder = getSurfaceHolder();

            Canvas canvas = null;

            try {
                canvas = holder.lockCanvas();

                if (canvas != null) {
                    canvas.drawARGB(200, colors[0], colors[1], colors[2]);
                }

                updateColors(colors);
            }
            finally {
                if (canvas != null) {
                    holder.unlockCanvasAndPost(canvas);
                }
            }

            // Reschedule the next redraw.
            handler.removeCallbacks(runnableSomething);

            if (visible) {
                // Play around with the delay for an optimal result.
                handler.postDelayed(runnableSomething, 25);
            }
        }
        /**
         * Method updateColors updates the colors by increasing the value
         * per RGB. The values are reset to zero if the maximum value is
         * reached.
         * @param colors to be updated.
         */
        private void updateColors(int[] colors) {
            if (colors[0] < 255) {
                colors[0]++;
            }
            else {
                if (colors[1] < 255) {
                    colors[1]++;
                }
                else {
                    if (colors[2] < 255) {
                        colors[2]++;
                    }
                    else {
                        colors[0] = 0;
                        colors[1] = 0;
                        colors[2] = 0;
                    }
                }
            }
        }
        /**
         * {@inheritDoc}
         */
        public void onDestroy() {
            super.onDestroy();

            handler.removeCallbacks(runnableSomething);
        }
        /**
         * {@inheritDoc}
         */
        public void onVisibilityChanged(boolean visible) {
            super.onVisibilityChanged(visible);

            this.visible = visible;

            if (visible) {
                drawSomething();
            }
            else {
                handler.removeCallbacks(runnableSomething);
            }
        }
    }

    /**
     * Constructor. Creates the {@link Handler}. 
     */
    public SampleLiveWallpaperService() {
        handler = new Handler();
    }
    /**
     * {@inheritDoc}
     */
    public Engine onCreateEngine() {
        return new SampleLiveWallpaperEngine();
    }
}

回答2:

I created a quick tutorial on my employers blog about using SVG in a Live Wallpaper, check it out if you like.
Part 1 http://blog.infrared5.com/2012/03/android-live-wallpaper/
Part 2 http://blog.infrared5.com/2012/03/android-live-wallpaper-part-2/