Question

So from reading/research about memory leaks it suggests to make all inner classes static to avoid memory leaks. However, by looking at the SDK samples (specifically TicTacToeLib) they implement their callbacks without the use of static inner classes. Will this cause a memory leak? If not, why?

private Handler mHandler = new Handler(new MyHandlerCallback());


private class MyHandlerCallback implements Callback {
        public boolean handleMessage(Message msg) {
            if (msg.what == MSG_COMPUTER_TURN) {

                // Pick a non-used cell at random. That's about all the AI you need for this game.
                State[] data = mGameView.getData();
                int used = 0;
                while (used != 0x1F) {
                    int index = mRnd.nextInt(9);
                    if (((used >> index) & 1) == 0) {
                        used |= 1 << index;
                        if (data[index] == State.EMPTY) {
                            mGameView.setCell(index, mGameView.getCurrentPlayer());
                            break;
                        }
                    }
                }

                finishTurn();
                return true;
            }
            return false;
        }
    }

Answer 1

Yes, this sample will cause a leak in case it keeps a Message in the queue. But it’s not a very severe leak since it is usually limited to a rather short amount of time.

But there is a rather simple way to prevent the leak:

Put the following two classes into your project

/** Callback that decouples the wrapped Callback via WeakReference */
public class SafeCallback implements Handler.Callback {
    private final WeakReference<Handler.Callback> mCallback;
    public SafeCallback(Handler.Callback callback) {
        mCallback = new WeakReference<Handler.Callback>(callback);
    }
    @Override
    public boolean handleMessage(Message msg) {
        Handler.Callback callback = mCallback.get();
        if (callback != null)
            return callback.handleMessage(msg);
        // else warn, return true, ..?
        return false;
    }
}

---

/** replacement for anonymous inner Handler implementations */
public abstract class SafeHandler implements Handler.Callback {
    @Override
    public abstract boolean handleMessage(Message msg);

    public final Handler get() {
        return new Handler(new SafeCallback(this));
    }
    public final Handler get(Looper looper) {
        return new Handler(looper, new SafeCallback(this));
    }
}

And now you can use Handler / Callback almost as you used to do but it’s no longer leaking.

So either like

public class TestActivity extends Activity {
    private Handler mHandler;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        mHandler = new SafeHandler() { // << instead of new Handler() {
            @Override
            public boolean handleMessage(Message msg) {
                // handle message
                return false;
            }
        }.get(); // << Notice this added .get()
    }
}

or like

public class TestActivity2 extends Activity implements Handler.Callback {

    private Handler mHandler;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        mHandler = new Handler(new SafeCallback(this)); // << wrapped in SafeCallback
    }

    @Override
    public boolean handleMessage(Message msg) {
        // handle message
        return false;
    }
}

---

The leak problem with Handler is that each Message / Runnable (which is actually wrapped in a Message) knows it’s target, i.e. has a hard reference to the Handler or Callback. And if that target is a non-static inner class, it will have an implicit hard reference to the outer class which is typically an Activity.

That means that as long as there are Messages enqueued for your Handler, your whole Activity can’t be garbage collected.

To solve this issue that chain of hard references from Message to Activity has to be broken. The SafeCallback class does exactly that by keeping just a WeakReference towards your Activity.

That means, the Message has now a hard reference to SafeCallback but the part bind there can now be garbage collected. In case that happens Handler.Callback callback = mCallback.get(); will turn out null and the Message is simply discarded. There is no more useful target anyways. It is still leaking the SafeCallback itself but that’s a pretty much empty class so it won’t lead to problems.