Confusion over Canvas/OpenGl Techniques

I'm a completely newbie to android programming, having done some java for my computing levels but nothing too complex!

I'm working on a game where an object falls down the screen and has to be sorted into the relevant 'box' when it reaches the bottom. I've got a surface view running with a thread etc, using canvas draw methods, however, i can't for the life of me see how i will be able to make the falling object reach a speed where it'll present a challenge to the user.

Running the thread with a change of 1 in the y direction causes the object to crawl down the screen. Greater changes in Y lead to jumpy graphics.

Would OpenGL make any difference or are there other canvas methods i can implement?

Hope that makes sense!

Thanks in advance ----Thread------

public void run()
{
    Canvas canvas;
    while(running)
    {
        canvas = null;
        try{
        canvas = this.surfaceholder.lockCanvas();
        synchronized(surfaceholder)
        {
            gamepanel.Check();
            this.gamepanel.onDraw(canvas);

        }

        }finally
        {

            if(canvas != null)
            {
           开发者_C百科     surfaceholder.unlockCanvasAndPost(canvas);
            }
        }

    }
}

----SurfaceView-------

protected void onDraw(Canvas canvas){
canvas.drawBitmap(BitmapFactory.decodeResource(getResources(), R.drawable.gamebackground), 0, 0, null);
SortItOut.sortitout.Letter.draw(canvas);
}

-----Letter----- (Each object is a different letter)

public static void draw(Canvas canvas)
{
y += 1;
canvas.drawBitmap(LetterObject, x, y, null);
}

Those are the methods i would believe are relevant (The Check method is simply to check whether the object has reached the bottom of the screen).

---

You must load all your bitmaps in the constructor for the SurfaceView, never in onDraw()

---

Aside from the bitmap loading problem, you can make it fall faster my increasing the rate of the y change. If you do it too much, the box will appear to jump, but I bet you could get away with up to 10 pixel changes before that would happen (experiment).

You would only need to do OpenGL in this case if performance was slowing you down. I don't think that's the case. Although, I would stop loading the bitmap in the onDraw method and put it in the onCreate or some constructor. onDraw gets called hundreds of times and that's killing your app.