Question

edit: Added a bounty. Hopefully this will draw some attention to the issue at hand.

I am currently trying to solve a problem in which an animation is continuously run on the main screen of an application animating a baby sleeping. this is done by having an imageView and replacing the current image in the animation with the next in line. Seing as there are more than 500 images this becomes very CPU intensive as each time an image is replaced the entire View Hierachy is re-calculated. Is there any way to NOT recalculate the entire view hierachy during this animation?

The run method looks like this :

        @Override
    public void run() {
        if (bitmap != null) {
            bitmap.recycle();
        }
        final String name = String.format(Locale.ENGLISH, pattern, current);
        final int id = getResources().getIdentifier(name, "drawable", getPackageName());
        if (id != 0) {
            bitmap = BitmapFactory.decodeResource(getResources(), id);
            view.setImageBitmap(bitmap);
        }
        current++;
        if (runAgain()) {
            frameCounter++;
            long nextAt = firstFrameAt + (frameCounter * interval);
            long delay = nextAt - SystemClock.elapsedRealtime() - 1;
            if (delay > 0) {
                handler.postDelayed(this, delay);
            } else {
                this.run();
            }
        }
    }

edit: I’ve been thinking about creating my own custom ImageView and overriding whatever method causes the problem. Would this be a viable solution?

Answer 1

I solved the problem by implementing my own custom ImageView overriding the following two methods:

@Override
public void setImageBitmap(final Bitmap bitmap) {
    if (VERSION.SDK_INT < VERSION_CODES.ICE_CREAM_SANDWICH) {

        // The currently set Drawable
        Bitmap oldBitmap = null;
        try
        {
            oldBitmap = ((BitmapDrawable)this.getDrawable()).getBitmap();   
        }catch(NullPointerException e)
        {
            Log.d("setImageBitmap", "oldBitmap is null");
        }

        if (null != oldBitmap && oldBitmap != bitmap) {
            final int oldWidth = oldBitmap.getWidth();
            final int oldHeight = oldBitmap.getHeight();

            /**
             * Ignore the next requestLayout call if the new Bitmap is the
             * same size as the currently displayed one.
             * */
            mIgnoreNextRequestLayout = oldHeight == bitmap.getHeight()
                    && oldWidth == bitmap.getWidth();
        }
    }

    super.setImageBitmap(bitmap);
}

@Override
public void requestLayout() {
    if (!mIgnoreNextRequestLayout) {
        super.requestLayout();
        Log.d("RequestLayout", "Requesting new layout");
    }
    else
        Log.d("RequestLayout", "Ignoring next requestLayout");

    // Reset Flag so that the requestLayout() will work again
    mIgnoreNextRequestLayout = false;
}