在画布，动态壁纸项目上旋转多个位图； 为什么每个额外的位图会使每个drawFrame（）这么慢？ （包括代码！）

Question

I am working on a live wallpaper (my first actually :)), and I seem to have a reached an impasse:

If you haven't guessed it by the variable names and the code, the live wallpaper in question is a clock. Its components must follow a very strict degrees/time ratio (in total there will be over a dozen bitmaps rotating at different rates, in different directions (some following the same ratios/rules)).

Anyways... As it stands, every additional bitmap that is added pretty much doubles the length of execution of drawFrame(). If I was going to stop at 3 moving parts, it wouldn't be so bad, it looks OK as is; but increase the amount of bitmaps by 9 (or even 2 or 3 more) and the frame rate becomes unacceptable.

I am not re-decoding bitmaps every turn as is recommended...

What should I do to remedy this situation?

I was thinking of looking into openGL surface/engine, but i saw an exchange on SO where a user was handling over 100 bitmaps at once without problem ( Android drawBitmap Performance For Lots of Bitmaps? ), which got me hoping I could do the same.

I also included an appropriate version of each image in the respective drawable -_dpi folders. The images are not particularly large, file size is fairly small as there are very colors and lots of transparent portions (largest is = screen size, smallest = 90%widthscreen/50% height of screen -- so for xhdpi 720 1280 biggest and 565*562 smallest)

So basically, according to my research, my code should be snappy... but it's not. Clearly I am wrong :), please help me get it right!

Thank you very much.

void drawFrame()
    {
        timeSinceLastRun = AnimationUtils.currentAnimationTimeMillis() - timeAtLastRun;
        timeAtLastRun = AnimationUtils.currentAnimationTimeMillis();

        final SurfaceHolder holder = getSurfaceHolder();
        Canvas c = null;
        try
        {

            c = holder.lockCanvas();
            if (c != null)
            {
                c.save();
                c.drawColor(0xff000000);
                drawTouchPoint(c);
                if(isItPhase1)
                {
                    skipToPosition(c,0,0,false,1);
                    skipToPosition(c,1,1,false,2);
                    skipToPosition(c,2,2,true,3);
                }
                else
                {

                    animateGears(c,0,0,0,0);
                    animateGears(c,1,1,1,1);
                    animateGears(c,2,2,2,2);
                }

                c.restore();
            }
        }
        finally
        {
            if (c != null)
                holder.unlockCanvasAndPost(c);
        }

        mHandler.removeCallbacks(mDrawPattern);
        if (mVisible)
        {
            mHandler.postDelayed(mDrawPattern, 1000/25);
        }
    }

    private void skipToPosition(Canvas c, int xP, int yP, boolean lastTest, int timeBasis)
    {
        if(isItFirstRun)
        {
            gears[0] = BitmapFactory.decodeResource(getResources(), 
                    l.werner.mechanicalclocklivewallpaperversion0001.R.drawable.seconds_gear);

            gears[1] = BitmapFactory.decodeResource(getResources(), 
                    l.werner.mechanicalclocklivewallpaperversion0001.R.drawable.minutes_gear);

            gears[2] = BitmapFactory.decodeResource(getResources(), 
                    l.werner.mechanicalclocklivewallpaperversion0001.R.drawable.hours_gear);

            m[0] = new Matrix();
            m[1] = new Matrix();
            m[2] = new Matrix();
            m2[0] = new Matrix();
            m2[1] = new Matrix();
            m2[2] = new Matrix();

            x[0] = 0;
            x[1] = 0;
            x[2] = 0;
            y[0] = 0.006f;
            y[1] = 0.0001f;
            y[2] = (0.000001666666666666666666666666666666667f);
            timeSinceLastRun = 0;
            movementPerTurn = 0;
            isItFirstRun = !isItFirstRun;
        }
        Calendar cal = Calendar.getInstance();
        float second = cal.get(Calendar.SECOND);
        float minute = cal.get(Calendar.MINUTE);
        float hour = cal.get(Calendar.HOUR);
        if(timeBasis == 1)
            x[xP] = x[xP] + (360f*(second/60f));
        else if(timeBasis == 2)
            x[xP] = x[xP] + (360f*(minute/60f));
        else if(timeBasis == 3)
            x[xP] = x[xP] + (360f*(hour/12f));
        if(lastTest)
        {
            isItPhase1 = !isItPhase1;
        }
    }

    void animateGears(Canvas c, int xP, int yP, int g, int mP)
    {
        movementPerTurn = y[yP] * timeSinceLastRun;

        x[xP] = x[xP] + movementPerTurn;

        m[mP].setRotate(((float)x[xP]*1f), 0.5f*gears[g].getWidth(),0.5f*gears[g].getHeight());
        m2[mP].setTranslate(c.getWidth()/2f - 0.5f*gears[g].getWidth(),
                c.getHeight()/2f - 0.5f*gears[g].getHeight());
        m[mP].setConcat(m2[mP], m[mP]);

        c.drawBitmap(gears[g], m[mP] , null);
    }

Answer 1

Consider using separate thread for animation. You may easily test this solution by using live wallpaper template I've posted on GitHub and see if it will make you a difference.