How to appear and disappear an object on screen us

Question

I am trying to learn game development in android. First I am trying to appear and disappear an object on screen using game loop for every five second. But I did not get succeed. I have read different tutorials and forums. I applied all things as in tutorials but still object is drawing continuously. It is not disappearing. I a not getting what I am missing? Please guide me.

The complete code is here:

MainGameActivity.java

package com.example.showandhideobject;

import android.app.Activity;
import android.os.Bundle;
import android.view.Window;
import android.view.WindowManager;

public class MainGameActivity extends Activity {

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        requestWindowFeature(Window.FEATURE_NO_TITLE);
        getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN, WindowManager.LayoutParams.FLAG_FULLSCREEN);
        setContentView(new MainGamePanel(this));
    }  
}

MainGamePanel .java

package com.example.showandhideobject;

import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.graphics.Canvas;
import android.graphics.Color;
import android.util.Log;
import android.view.SurfaceHolder;
import android.view.SurfaceView;

public class MainGamePanel extends SurfaceView implements
        SurfaceHolder.Callback {

    private MainGameThread thread;
    private ImageObject image;

    // private long gameStartTime;

    public MainGamePanel(Context context) {
        super(context);
        // adding the callback (this) to the surface holder to intercept events
        getHolder().addCallback(this);
        // create the game loop thread
        thread = new MainGameThread(getHolder(), this);

        Bitmap imageBitMap = BitmapFactory.decodeResource(getResources(),
                R.drawable.rose);
        image = new ImageObject(imageBitMap, 100, 150);
        image.setAppeared(false);
        image.setDisappearTime(System.currentTimeMillis());

        // make the GamePanel focusable so it can handle events
        setFocusable(true);
    }

    @Override
    public void surfaceChanged(SurfaceHolder holder, int format, int width,
            int height) {
    }

    @Override
    public void surfaceCreated(SurfaceHolder holder) {
        // at this point the surface is created and
        // we can safely start the game loop

        thread.setRunning(true);
        thread.start();

    }

    @Override
    public void surfaceDestroyed(SurfaceHolder holder) {
    }

    public void update() {

        Log.i("Image Status:::::::::::::    ",
                Boolean.valueOf(image.isAppeared()).toString());

        if (!image.isAppeared()
                && System.currentTimeMillis() - image.getDisappearTime() >= 5000) {

            Log.i("Image Object:::::::  ", "Showing");
            image.setAppeared(true);
            image.setAppearTime(System.currentTimeMillis());

        }
        if (image.isAppeared()
                && (System.currentTimeMillis() - image.getAppearTime() >= 5000)) {

            Log.i("Image Object:::::::  ", "Not Showing");
            image.setAppeared(false);
            image.setDisappearTime(System.currentTimeMillis());
        }
    }

    public void render(Canvas canvas) {

        if (image.isAppeared()) {
            image.draw(canvas);
        }
    }

}

MainGameThread.java

package com.example.showandhideobject;

import android.graphics.Canvas;
import android.util.Log;
import android.view.SurfaceHolder;

public class MainGameThread extends Thread {

    // Surface holder that can access the physical surface
    private SurfaceHolder surfaceHolder;

    // The actual view that handles inputs
    // and draws to the surface
    private MainGamePanel gamePanel;

    // flag to hold game state
    private boolean running;

    public boolean isRunning() {
        return running;
    }

    public void setRunning(boolean running) {
        this.running = running;
    }

    public MainGameThread(SurfaceHolder surfaceHolder, MainGamePanel gamePanel) {
        super();
        this.surfaceHolder = surfaceHolder;
        this.gamePanel = gamePanel;
    }

    @Override
    public void run() {
        Canvas canvas;

        while (isRunning()) {
            canvas = null;
            // try locking the canvas for exclusive pixel editing
            // in the surface
            try {
                canvas = this.surfaceHolder.lockCanvas();
                synchronized (surfaceHolder) {
                    Log.i("With in :::::::::", "Game Loop");
                    // update game state
                    gamePanel.update();
                    // render state to the screen and draw the canvas on the
                    // panel

                    gamePanel.render(canvas);
                    // gamePanel.onDraw(canvas);
                }
            } finally {
                // in case of an exception the surface is not left in an
                // inconsistent state
                if (canvas != null) {
                    surfaceHolder.unlockCanvasAndPost(canvas);
                }
            } // end finally
        }
    }
}

ImageObject.java

package com.example.showandhideobject;

import android.graphics.Bitmap;
import android.graphics.Canvas;

public class ImageObject {

    private Bitmap bitmap; // the actual bitmap
    private int x; // the X coordinate
    private int y; // the Y coordinate
    private boolean isAppeared;
    private long appearTime;
    private long disappearTime;

    // Constructor for this class
    public ImageObject(Bitmap bitmap, int x, int y) {
        this.bitmap = bitmap;
        this.x = x;
        this.y = y;
    }

    public Bitmap getBitmap() {
        return bitmap;
    }

    public void setBitmap(Bitmap bitmap) {
        this.bitmap = bitmap;
    }

    public int getX() {
        return x;
    }

    public void setX(int x) {
        this.x = x;
    }

    public int getY() {
        return y;
    }

    public void setY(int y) {
        this.y = y;
    }

    public boolean isAppeared() {
        return isAppeared;
    }

    public void setAppeared(boolean isAppeared) {
        this.isAppeared = isAppeared;
    }

    public long getAppearTime() {
        return appearTime;
    }

    public void setAppearTime(long appearTime) {
        this.appearTime = appearTime;
    }

    public long getDisappearTime() {
        return disappearTime;
    }

    public void setDisappearTime(long disappearTime) {
        this.disappearTime = disappearTime;
    }

    /* Method to draw images on Canvas */
    public void draw(Canvas canvas) {
        canvas.drawBitmap(bitmap, x - (bitmap.getWidth() / 2),
                y - (bitmap.getHeight() / 2), null);
    }
}

Answer 1

in this part

if (image.isAppeared()) {
    image.draw(canvas);
}

you never clear your canvas. What you are doing is actually drawing your image over and over on the same spot.

You probably need to redraw a background in cas isAppeared() is false

Edit

you can also use canvas.save() before drawing the image, and canvas.restore() when you don't want the image anymore.

Answer 2

Change the method render in MainGamePanel.java to

if (image.isAppeared() && canvas != null) {
        image.draw(canvas);
}

Answer 3

Don't try to optimise too early, game rendering is usually inefficient as almost always most of the screen is expected to change.

Loop should be:

1. always draw the background to canvas
2. always draw all game objects to the canvas, let them decide if they are visible or not which will simplify the MainGamePanel class
3. finally always display canvas (by copying to the image as you are doing)

To expand on point 2:

/* Method to draw images on Canvas */  
public void draw(Canvas canvas) { 
    if(!isAppeared) return; //let the object decide when it should be drawn
    canvas.drawBitmap(bitmap, x - (bitmap.getWidth() / 2),  
            y - (bitmap.getHeight() / 2), null);  
}