Primer proyecto

*********************MIDlet**********************
/**
* ProyectoMidlet
* @author Leticia Estrada González
* 210174
* Marzo 2010
*/

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

public class ProyectoMidlet extends MIDlet implements CommandListener
{
     //ATRIBUTOS
     private Display display;
     private List listaMenu;
     private Command comandoSalir;
     private Command comandoAceptar;
     private Form formaPreguntas;

     //Cosntructor
     public ProyectoMidlet()
     {
          display = Display.getDisplay( this );
          comandoSalir = new Command("Salir",Command.OK,1);
          comandoAceptar = new Command("Aceptar",Command.OK,1);
          formaPreguntas = new Form("Preguntas");
     }//ProyectoMidlet

     //MÉTODOS
     public void startApp()
     {
          listaMenu = new List("Selecciona una opción", Choice.IMPLICIT);
          listaMenu.append("Culturas", null);
          listaMenu.append("Presidentes", null);
          listaMenu.append("Historia", null);
          listaMenu.addCommand(comandoSalir);
          listaMenu.addCommand(comandoAceptar);
          listaMenu.setCommandListener(this);
         display.setCurrent(listaMenu);
     }//startApp

     public void pauseApp()
    {
    }//pauseApp

     public void destroyApp(boolean unconditional)
    {
    }//destroyApp

     public void commandAction (Command c, Displayable d)
     {
          if (c == comandoSalir)
          {
                try
               {
                     destroyApp(true);
                     notifyDestroyed();
               }//try

              catch(Exception e)
              {
                   System.out.println(e.toString());
              }//catch
         }//if
         else if (c == comandoAceptar)
               {
                     Questionnaire questionnaire = new Questionnaire(
                      listaMenu.getString(listaMenu.getSelectedIndex()),
                      "/Cuestionario"+(listaMenu.getSelectedIndex()+1)+".txt",this);
                      questionnaire.apply();
                      String s="preguntas="+questionnaire.getNumberOfQuestions()+",           correctas="+questionnaire.getNumberOfCorrectAnswers();
                      Ticker ticker= new Ticker(s);
                       listaMenu.setTicker(ticker);
                }//if
     }//CommandAction

     public Display getDisplay()
     {
          return display;
     }//getDisplay

     public Form getFormaPreguntas()
     {
          return formaPreguntas;
     }//getFormaPreguntas

     public List getListaMenu()
    {
          return listaMenu;
     }//getListaMenu
}

*****************Questionnaire**********************
/**
* Questionnaire
* @author Leticia Estrada González
* 210174
* Marzo 2010
*/

import javax.microedition.lcdui.*;

// Se definen tanto los atributos como los métodos que conforman a la clase Questionnaire
public class Questionnaire
{
     // ATRIBUTOS
     private String name;
     private String fileLocation;
     private int numberOfQuestions;
     private int numberOfCorrectAnswers;
     private ProyectoMidlet theMidlet;
     private Cuestionario cuestionario;
     private ChoiceGroup grupo;
     private Command comandoSiguiente;

     // MÉTODOS

     // Constuctor de la clase
     // Se le pasa el nombre y la localización del archivo .txt donde estan las preguntas
     // y las posibles respuestas
     public Questionnaire(String aName, String aFileLocation, ProyectoMidlet aMidlet)
     {
          name=aName;
          fileLocation = aFileLocation;
          theMidlet = aMidlet;
          numberOfCorrectAnswers = 0;
          numberOfQuestions = 0;
          comandoSiguiente = new Command("Siguiente", Command.OK, 1);
     }//Questionnaire

     // Nombre del cuestionario
     public String getName()
     {
          return name;
     }//getName

     //Presenta el cuestionario en el celular, para que el usuario lo responda
     public void apply()
     {
          Lectura lectura = new Lectura(fileLocation);
          String cadena = lectura.getContent();
          Analiza analiza= new Analiza(cadena);
          cuestionario = analiza.getCuestionario();
          grupo = new ChoiceGroup(cuestionario.getPregunta(numberOfQuestions).getSentenciaPregunta(),Choice.EXCLUSIVE);
          for (int i=0; i<cuestionario.getPregunta(numberOfQuestions).getNumOpciones();i++)
               grupo.append(cuestionario.getPregunta(numberOfQuestions).getOpcionPregunta(i), null);
          theMidlet.getFormaPreguntas().deleteAll();
          theMidlet.getFormaPreguntas().append(grupo);
          theMidlet.getFormaPreguntas().addCommand(comandoSiguiente);
          theMidlet.getFormaPreguntas().setCommandListener(new CommandListener() {
               public void commandAction(Command c, Displayable d) {
                    if (c==comandoSiguiente)
                         if(numberOfQuestions < cuestionario.getNumeroPreguntas())
                         {
                               if (cuestionario.getPregunta(numberOfQuestions).getCorrectoIncorrecto(grupo.getSelectedIndex()))
                                   numberOfCorrectAnswers = numberOfCorrectAnswers + 1;
                              numberOfQuestions = numberOfQuestions + 1;
                              System.out.println(numberOfQuestions);
                              System.out.println(numberOfCorrectAnswers);
                              apply();
                         }
                         else
                               theMidlet.getDisplay().setCurrent(theMidlet.getListaMenu());
          }
     });
     theMidlet.getDisplay().setCurrent(theMidlet.getFormaPreguntas());
}//apply

     // Proporciona el número de preguntas que tiene el cuestionario
     public int getNumberOfQuestions()
     {
          System.out.println(numberOfQuestions);
          return numberOfQuestions;
     }//getNumberOfQuestions

     // Proporciona el número de preguntas correctamente contestadas por el usuario
     public int getNumberOfCorrectAnswers()
     {
          System.out.println(numberOfCorrectAnswers);
          return numberOfCorrectAnswers;
      }//getNumberOfCorrectAnswers
}//Questionnaire

********************Lectura************************
/**
* Lectura del archivo plano txt
* Código expuesto en clase y retomado para mi proyecto
* @author Gerardo Ayala San Martin
*/

// Paquete para la lectura del archivo
import java.io.InputStream;

public class Lectura
{
     // ATRIBUTOS
     InputStream inputStream;

     // Constructor
     public Lectura(String textFileRoute)
     {
          inputStream=this.getClass().getResourceAsStream(textFileRoute);
     }

     // MÉTODOS
     public String getContent()
     {
          //Variables
          StringBuffer stringBuffer = null;
          int aByte;
          try
          {
               stringBuffer = new StringBuffer();
               //Lectura del archivo
               aByte=0;
               while ((aByte = inputStream.read())!= -1)
               {
                    stringBuffer.append((char) aByte);
               }//while
          }//try
          catch (Exception exception)
          {
               System.out.println("No se puede leer el archivo: "+ exception);
          }//catch
          return stringBuffer.toString();
     }//getContent
}//Lectura

********************Analiza************************
/*
* Analiza
* @author Leticia Estrada González
* 210174
* Marzo 2010
*/

//En la Clase Analiza se lleva a cabo el analisis de una cadena, llamada cadenota,
//la cual esta conformada por toda la estructura del archivo .txt

public class Analiza
{
     // ATRIBUTOS
     String cadena;
     Cuestionario cuestionario;

     //Constructor
     public Analiza(String aCadena)
     {
          cadena = aCadena;
          cadena = reemplazaCadena(cadena,"\r\n","");
          cuestionario = new Cuestionario(nombreCuestionario(),cuentaEtiqueta(cadena,"<question>"));
          cadena = quitaEtiqueta(cadena,"<questionnaire>","</questionnaire>");
          cadena = reemplazaCadena(cadena,cuestionario.getNombreCuestionario(),"");
          obtienePreguntas(cadena);
     }

     //MÉTODOS

     //Método que retorna la posición en que se encuentra una determinada cadena
     //dentro de la cadenota
     public int regresaPosicionCadena(String cadenota, String subCadena)
     {
          if (subCadena.length()<cadenota.length())
         {
               for (int i=0 ; i<=(cadenota.length()- subCadena.length()) ; i++)
               {
                    if (subCadena.equals(cadenota.substring(i, i+subCadena.length())))
                         return i;
               }//for
         }//if
         return -1;
     }//regresaPosicionCadena

     //Método que elimina los caracteres "\r\n" de la cadenota
     public String reemplazaCadena(String cadenota, String subCadena, String reemplazo)
     {
          int posicion = regresaPosicionCadena(cadenota,subCadena);
          while(posicion!=-1)
          {
               cadenota = cadenota.substring(0,posicion)+reemplazo+cadenota.substring(posicion+subCadena.length());
               posicion = regresaPosicionCadena(cadenota,subCadena);
          }//while
          return cadenota;
     }//reemplazaCadena

     //Método que retorna el número de etiquetas que hay en la cadenota
     public int cuentaEtiqueta(String cadenota, String etiqueta)
     {
          int conteo = 0;
          int posicion = regresaPosicionCadena(cadenota,etiqueta);
          while (posicion!=-1)
          {
               conteo = conteo + 1;
               cadenota = cadenota.substring(posicion + etiqueta.length());
               posicion = regresaPosicionCadena(cadenota,etiqueta);
          }//while
          return conteo;
     }//cuentaEtiqueta

     //Método que quita la etiqueta tanto inicial como final de la cadenota
     public String quitaEtiqueta(String cadenota, String etiquetaInicial, String etiquetaFinal)
     {
          cadenota = reemplazaCadena(cadenota,etiquetaInicial,"");
          cadenota = reemplazaCadena(cadenota,etiquetaFinal,"");
          return cadenota;
     }//quitaEtiqueta

     //Método que retorna el contenido que hay entre dos etiquetas
     public String regresaContenidoEntreCadenas(String cadenota, String subCadenaInicial, String subCadenaFinal)
     {
          return cadenota.substring(regresaPosicionCadena(cadenota,subCadenaInicial)+subCadenaInicial.length(),regresaPosicionCadena(cadenota,subCadenaFinal));
     }//regresaContenidoEntreCadenas

     //Método que retorna la cadena
     public String getCadena()
     {
          return this.cadena;
     }//getCadena

     //Método que retorna el contenido que exite entre las etiquetas "<questionnaire>","<question>",
     //es decir, el nombre del cuestionario
     public String nombreCuestionario()
     {
          return regresaContenidoEntreCadenas(this.cadena, "<questionnaire>","<question>" );
     }//nombreCuestionario

     public void obtienePreguntas(String cadenota)
     {
          for (int i=0 ; i<cuestionario.getNumeroPreguntas() ; i++)
          {
               String stringPregunta = regresaContenidoEntreCadenas(cadenota,"<question>","</question>");
               String sentenciaPregunta = stringPregunta.substring(0,regresaPosicionCadena(stringPregunta, "<answer>"));
               String stringOpcionesPregunta = stringPregunta.substring(regresaPosicionCadena(stringPregunta, "<answer>"));
               Pregunta pregunta = new Pregunta(sentenciaPregunta,cuentaEtiqueta(stringOpcionesPregunta,"<answer>"));
               for(int j=0; j<pregunta.getNumOpciones(); j++)
               {
                    pregunta.setOpcionPregunta(regresaContenidoEntreCadenas(stringOpcionesPregunta,"<answer>","<isCorrect>"),j);
                     if (regresaContenidoEntreCadenas(stringOpcionesPregunta,"<isCorrect>","</isCorrect>").equals("true"))
pregunta.setCorrectoIncorrecto(true,j);
                    else
                             pregunta.setCorrectoIncorrecto(false,j);
                    stringOpcionesPregunta = stringOpcionesPregunta.substring(regresaPosicionCadena(stringOpcionesPregunta,"</answer>")+9);
               }//for j
               cadenota = cadenota.substring(regresaPosicionCadena(cadenota,"</question>")+11);
               cuestionario.setPregunta(pregunta,i);
          }//for i
     }//obtienePreguntas

     //Método que regresa el cuestionario
     public Cuestionario getCuestionario()
     {
          return cuestionario;
     }//getCuestionario
}

****************Cuestionario **********************
/**
* Cuestionario
* @author Leticia Estrada González
* 210174
* Marzo 2010
*/
public class Cuestionario
{
     //ATRIBUTOS
     private String nombre;
     private Pregunta preguntas[];

     //Constructores
     public Cuestionario()
     {
          nombre = "";
          preguntas = new Pregunta[5];
     }//Cuestionario()

     public Cuestionario(String aNombre)
     {
          nombre = aNombre;
          preguntas = new Pregunta[5];
     }//Cuestionario

     public Cuestionario(String aNombre, int numeroPreguntas)
     {
          nombre = aNombre;
          preguntas = new Pregunta[numeroPreguntas];
     }//Cuestionario(String aNombre, int numeroPreguntas)

     public void setNombreCuestionario(String aNombre)
     {
          nombre = aNombre;
     }//setNombreCuestionario

     public String getNombreCuestionario()
     {
          return nombre;
     }//getNombreCuestionario

     public Pregunta getPregunta(int indice)
     {
          return preguntas[indice];
     }//getPregunta

     public void setPregunta(Pregunta aPregunta, int indice)
     {
          preguntas[indice] = aPregunta;
     }//setPregunta

     public int getNumeroPreguntas()
     {
          return preguntas.length;
     }//getNumeroPreguntas
}

*********************Pregunta*********************
/**
* Estructura de la pregunta
* @author Leticia Estrada González
* 210174
* Marzo 2010
*/

public class Pregunta
{
     //ATRIBUTOS
     private String sentenciaPregunta;
     private String opcionesPregunta[];
     private boolean correctoIncorrecto[];

     // Constuctor de la clase
     public Pregunta()
     {
          this.sentenciaPregunta = "";
          this.opcionesPregunta = new String[5];
          this.correctoIncorrecto = new boolean[4];
     }//Pregunta()

     //sobrecarga del constructor, se le pasa como parámetro solamente la pregunta
     public Pregunta(String sentenciaPregunta)
     {
          this.sentenciaPregunta = sentenciaPregunta;
          this.opcionesPregunta = new String[5];
          this.correctoIncorrecto = new boolean[4];
     }//Pregunta

     //sobrecarga del constructor, se le pasa como parámetros la pregunta y el número de opciones
     public Pregunta(String sentenciaPregunta, int numOpciones)
     {
          this.sentenciaPregunta = sentenciaPregunta;
          this.opcionesPregunta = new String[numOpciones];
          this.correctoIncorrecto = new boolean[numOpciones];
     }//Pregunta

     //MÉTODOS
     // Método que regresa el número de opciones de la pregunta
     public int getNumOpciones()
     {
          return this.opcionesPregunta.length;
     }//getNumOpciones

     // Método que regresa la opción con su respectivo indice
     public String getOpcionPregunta(int indice)
     {
          return this.opcionesPregunta[indice];
     }//getOpcionesPregunta

     // Método que establece la opcion de la pregunta y su indice
     public void setOpcionPregunta(String opcionPregunta,int indice)
     {
     this.opcionesPregunta[indice]=opcionPregunta;
     }//setOpcionesPregunta

     // Método que regresa la pregunta
     public String getSentenciaPregunta()
     {
          return this.sentenciaPregunta;
     }//getSentenciaPregunta

     public void setSentenciaPregunta(String sentenciaPregunta)
     {
          this.sentenciaPregunta = sentenciaPregunta ;
     }//setSentenciasPregunta

     public boolean getCorrectoIncorrecto(int indice)
     {
          return correctoIncorrecto[indice];
     }//getCorrectoIncorrecto

     public void setCorrectoIncorrecto(boolean correctoIncorrecto, int indice)
     {
          this.correctoIncorrecto[indice]=correctoIncorrecto;
     }//setCorrectoIncorrecto
}