Question

I know that creating static methods to create AlertDialogs is not a good sign. But, whenever I felt like creating some AlertDialogs, I always have to place them inside an Activity subclass. I’ve been looking around in SO, trying to find a good way to factor the code, so that I don’t have to initialize and create AlertDialogs from an Activity subclass.

Here is an example of my code, designed in such a way that I have to sacrifice performance speed for AlertDialogs, which is very necessary in my project plans.

public void onCreate(Bundle b) {
    super.onCreate(b);
    accelerometer = new Accelero();
    leaderboard = new Score(this);
    renderView = new RenderView(this);
    this.requestWindowFeature(Window.FEATURE_NO_TITLE);
    this.getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN, WindowManager.LayoutParams.FLAG_FULLSCREEN);
    setContentView(renderView);

    // TODO: Refactor this, to speed things up.
    AlertDialog.Builder builder = new AlertDialog.Builder(this);
    input = new EditText(this);
    builder.setView(input);
    builder.setTitle("Enter Name for High Score!");
    builder.setPositiveButton("Retry", new DialogInterface.OnClickListener() {
        public void onClick(DialogInterface dialog, int which) {
            // TODO: Polish the dialog.
            // TODO: Add a method of obtaining the score from RenderView.
            renderView.getStage().reset();
            renderView.setDialogFlag(false);
        }
    });
    builder.setNegativeButton("Back", new DialogInterface.OnClickListener() {
        public void onClick(DialogInterface dialog, int which) {
            PlayActivity.this.onBackPressed();
        }
    });
    renderView.setLosingDialog(builder.create());
    builder = new AlertDialog.Builder(this);
    builder.setTitle("You win!");
    builder.setPositiveButton("Next Stage", new DialogInterface.OnClickListener() {
        public void onClick(DialogInterface dialog, int which) {
            renderView.createStage(getAssets(), stageNumber);
            renderView.pauseGame();
        }
    });
    renderView.setWinningDialog(builder.create());
    builder = new AlertDialog.Builder(this);
    builder.setTitle("Game Paused!");
    builder.setPositiveButton("Back to Game", new DialogInterface.OnClickListener() {
        public void onClick(DialogInterface dialog, int which) {
            renderView.unpauseGame();
        }
    });
    builder.setNeutralButton("Restart", new DialogInterface.OnClickListener() {
        public void onClick(DialogInterface dialog, int which) {
            renderView.resetGame();
        }
    });
    builder.setNegativeButton("Main Menu", new DialogInterface.OnClickListener() {
        public void onClick(DialogInterface dialog, int which) {
            // TODO: Will probably improve some more on this.
            PlayActivity.this.finish();
        }
    });
    renderView.setPausingDialog(builder.create());
}

This isn’t what I wanted. I tried placing them in a new thread to run, but it leaks memory, so it didn’t work. Also, due to issues (Static AlertDialog methods will leak memory, etc.), I just don’t have any other ideas on fixing this.

I don’t know what to do next. So, may I ask, who else have a better way of initializing AlertDialogs without sacrificing performance speeds? Thanks in advance.

Answer 1

First thing I would do is to add some performance analysis instrumentation (measurements) to determine where the code is spending its time. Nothing is more painful than spending time trying to optimize something that doesn’t need optimization 😉

From looking at this I can see at least one simple optimization: This code creates 6 instances of 6 different anonymous classes just to handle the onClick() callbacks. IMHO that isn’t necessary. You could just use this as the callback interface and make sure that your activity implements DialogInterface.OnClickListener. Then write a single method in your activity that handles all the click events:

public void onClick(DialogInterface dialog, int which) {
    if (dialog == renderView.getLosingDialog()) {
        if (which == DialogInterface.BUTTON_POSITIVE) {
            // TODO: Polish the dialog.
            // TODO: Add a method of obtaining the score from RenderView.
            renderView.getStage().reset();
            renderView.setDialogFlag(false);
        } else if (which == DialogInterface.BUTTON_NEGATIVE) {
            PlayActivity.this.onBackPressed();
        }
    } else if dialog == renderView.getWinningDialog()) {
        // etc...
    } else if dialog == renderView.getPausingDialog()) {
        // etc...
    }
}

I can’t guarantee that this will improve performance, but it will definitely make the garbage collector very happy 🙂