Android- How to draw a bitmap after a set time in SurfaceView

Question

To clarify, I'm interested in doing a simple animation that changes from one bitmap to another after a few seconds, and then repeats. For example, if I drew a frowny face, how could I set it to be removed after a few seconds, and replaced it with a smiley face?

Here's some example code



public class MySurface extends SurfaceView implements Runnable {

SurfaceHolder ourHolder;
Thread ourThread = null;
boolean isRunning = true;

Bitmap frowny;
Bitmap smiley;

public MySurface(Context context) {
    super(context);
    init(context);

}

public MySurface(Context context, AttributeSet attrs) {
    super(context, attrs);
    init(context);
}

public MySurface(Context context, AttributeSet attrs, int defStyle) {
    super(context, attrs, defStyle);
    init(context);
}

private void init(Context context) {
    // do stuff that was in your original constructor...
    ourHolder = getHolder();
    ourThread = new Thread(this);
    ourThread.start();

    frowny = BitmapFactory.decodeResource(getResources(),
            R.drawable.frowny);
    smiley = BitmapFactory
            .decodeResource(getResources(), R.drawable.smiley);


}

public void pause() {
    isRunning = false;
    while (true) {
        try {
            ourThread.join();
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        break;
    }
    ourThread = null;
}

public void resume() {
    isRunning = true;

}

@SuppressLint("WrongCall")
public void run() {
    // TODO Auto-generated method stub
    while (isRunning) {
        if (!ourHolder.getSurface().isValid()) {
            continue;
        }

        Canvas c = ourHolder.lockCanvas();
        onDraw(c);
        ourHolder.unlockCanvasAndPost(c);

    }

}

@Override
protected void onDraw(Canvas canvas) {
    // TODO Auto-generated method stub
    super.onDraw(canvas);

    canvas.drawBitmap(frowny, (getWidth/2), (getHeight/2), null);

    //wait a period/remove frowny

    canvas.drawBitmap(smiley, (getWidth/2), (getHeight/2), null);



    postInvalidate();

  }

}

Answer 1

I would suggest using AsyncTask. In the doInBackground method, set a timer and then in the onPostExecute method, do the animation.

import android.app.Activity;
import android.os.AsyncTask;
import android.os.Bundle;
import android.provider.Settings.System;
import android.view.View;

public class AsyncTaskActivity extends Activity implements OnClickListener {

@Override
public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.main);
  myBitmapTask myTask = new myBitmapTask();
  myTask.execute();
}

private class myBitmapTask extends AsyncTask<Void, Void, Void> {

    @Override
    protected void onPreExecute() {}

    @Override
    protected String doInBackground(Void... params) {
        for (int i = 0; i < 5; i++) {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                Thread.interrupted();
            }
        }
        return null;
    }

    @Override
    protected void onPostExecute(Void... Params) {
        // do bitmap animation
    }

    @Override
    protected void onProgressUpdate(Void... values) {}
}
}

Note: this was not tested and was typed on my phone. Sorry for any typos.

Answer 2

I think a Handler is the way to go. Use a subclass to create a RefreshHander like this:

class RefreshHandler extends Handler {
    @Override
    public void handleMessage(Message msg) {
        updateImage(); // change your frown to a smiley
        view.invalidate(); // trigger onDraw()
    }

    public void sleep() {
        this.removeMessages(0);
        sendMessageDelayed(obtainMessage(0), DELAY, 0)); // how long to wait in ms
    }
}

Create a redrawHandler with private RefreshHandler redrawHandler = new RefreshHandler(); and then kick off the RefreshHander with redrawHandler.sleep();. After the DELAY, handleMessage() will be run.

Now in onDraw(), rather than draw the frown and then the smiley, just have it draw an image which is initially set to the frown (Bitmap image; image = frown;).

@Override
protected void onDraw(Canvas canvas) {
    super.onDraw(canvas);
    canvas.drawBitmap(image, (getWidth/2), (getHeight/2), null);
}

Use updateImage() to change that image to a smiley so that when the view is invalidated the next onDraw() will draw the smiley.

private void updateImage() {
    image = smiley;
}

Answer 3

I like to use the asyncTask method because It might be overkill for your application but you can use the same code for other more processing intense tasks. What I usually do is something like this in my activity.

public void callAsynchronousClass() {
    final Handler handler = new Handler();
    Timer timer = new Timer();
    TimerTask doAsynchronousTask = new TimerTask() {
        @Override
        public void run() {
            handler.post(new Runnable() {
                @Override
                public void run() {
                    if (processing) {
                        try {
                            AsynchronousClassICreated myAsyncTask = new
                                    AsynchronousClassICreated();
                        myAsyncTask.execute();                            
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }
            }
        });

    }
};
timer.schedule(doAsynchronousTask, 0, timeUntilUpdate);

This way you can still do as much processing as you want and then have the timer call the task repeatedly as many times as you want. Then you can use the on post execute method in the asyncTask like so.

public class AsynchronousssClassICreated extends AsyncTask<Void, Void, theDrawingToDo>{
    @Override
    protected void doInBackground(Void... params) {
    }

    @Override
    protected void onPostExecute(SomeClassToReturn theDrawingToDo) {
          //here is where you can do some drawing
    }

Anyway that’s how I like to do things like this. Like I said this might be overkill for what your looking for but it works for all sorts of cases where you might need a little more processing done as well.