Este midlet tiene varias partes:

  1. Por un lado está el Midlet o aplicación para el móvil
  2. Una clase tipo Canvas para hacer los gráficos
  3. Una clase hilo que se utiliza para que el canvas pinte una y otra vez con pausas.

/*
 * RandomCircles
 * Midlet que usa una pantalla de tipo Canvas para crear gráficos
 */
package hello;

import javax.microedition.midlet.*;
import javax.microedition.lcdui.*;
import java.util.*;

public class InfiniteCircles extends MIDlet implements CommandListener {
    private Command exitCommand;
    private Display pantalla;
    private CanvasForInfinite screen;
    private Repainter repintar;

    public InfiniteCircles () {
        // Tomamos la pantalla
       pantalla = Display.getDisplay(this);

       // Creamos el comando para salir
        exitCommand = new Command("Exit", Command.EXIT, 2);

        // Asociamos a Screen nuestro Canvas especial
        screen = new CanvasForInfinite();

        // Establecemos el comando para salir
        screen.addCommand(exitCommand);
        screen.setCommandListener(this);
        repintar = new Repainter(pantalla,screen);
    }

    /**
     * startApp
     * se ejecuta al inicio de la aplicación
     */
    public void startApp() throws MIDletStateChangeException {
        // Establecemos el formulario en la pantalla
        pantalla.setCurrent(screen);
        repintar.start();
    }

    /**
     * pauseApp
     * se ejecuta en caso de pausar la aplicación
     */
    public void pauseApp() {
    }

    /**
     * destroyApp
     * se ejecuta al terminar la aplicación
     */
    public void destroyApp(boolean unconditional) {
    }

    public void commandAction(Command c, Displayable s) {
      if (c == exitCommand) {
         destroyApp(false);
          notifyDestroyed();
     }
    }
}

class CanvasForInfinite extends Canvas  {

    // Dentro de canvas debe existir esta función
    public void paint(Graphics g) {
        // Declaramos variables para coordenadas, anchura, altura y radio
        int x,y,w,h,r,maxx, maxy;
        // Variable para generar números aleatorios
        Random rnd = new Random();

        maxx= maxy = x = y = w = h = r = 0;

        maxx = this.getWidth();
        maxy = this.getHeight();
        //try {

        for (int i = 0;i<5;i++)
        {
            // Establecemos color (r,g,b)
            g.setColor( rnd.nextInt(255),  rnd.nextInt(255), rnd.nextInt(255));
           //g.drawArc(rnd.nextInt(maxx), rnd.nextInt(maxy), maxx/2, maxy/2, 0, 360);

           // Para hacer estrellas
           //g.drawArc(rnd.nextInt(maxx), rnd.nextInt(maxy), 1, 1, 0, 360);
           g.drawArc(rnd.nextInt(maxx), rnd.nextInt(maxy), rnd.nextInt(4), rnd.nextInt(4), 0, 360);


             // dibujamos un arco, completo: 360

            //g.drawArc(rnd.nextInt(maxx), rnd.nextInt(maxy), rnd.nextInt(), rnd.nextInt(), 0, 360);
        }
            //g.drawString("Epa", 0, 0, Graphics.HCENTER | Graphics.TOP);
            //g.drawString("Vamos",(getWidth() / 2),0 Graphics.HCENTER | Graphics.TOP);
  /*
   } catch (InterruptedException iex) {
            g.drawString("Excepción: " + iex.getMessage(), 0, 0, Graphics.HCENTER | Graphics.TOP);
        }
  */
        }
}

 

//
// Y ahora la clase tipo runnable, es decir, un thread que se ejecuta en paralelo al midlet.
// Sacada de las demos de sun

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */

package hello;

import javax.microedition.lcdui.Canvas;
import javax.microedition.lcdui.Display;

/**
 * Class periodically repainting the canvas with all the balls.
 */
public class Repainter implements Runnable {

    /* target display */
    private Display display;
    /* canvas to repaint */
    private Canvas canvas;
    /* whether the repainting is stopped */
    private boolean stop;

    /**
     * Creates a new instance of repainter.
     *
     * @param display Target display
     * @param canvas  Canvas to repaint
     */
    public Repainter (Display display, Canvas canvas) {
        this.display = display;
        this.canvas = canvas;
    }

    /**
     * Starts the repainter
     */
    public void start () {
        stop = false;
        run ();
    }

    /**
     * Stops the repainter
     */
    public void stop () {
        stop = true;
    }

    /**
     * Actual repainting process being performed serially with actual display
     * updates.
     */
    public void run () {

        if (stop) {
            return;
        }

        try {
            // avoid insane repainting
            Thread.sleep (5);
        }
        catch (InterruptedException e) {
            // Never mind
        }

        canvas.repaint ();
        display.callSerially (this);
    }
}