MIDTERM

Launch in MPowerPlayer

import java.util.Enumeration;

import javax.microedition.lcdui.Alert;
import javax.microedition.lcdui.AlertType;
import javax.microedition.lcdui.Choice;
import javax.microedition.lcdui.ChoiceGroup;
import javax.microedition.lcdui.Command;
import javax.microedition.lcdui.CommandListener;
import javax.microedition.lcdui.Display;
import javax.microedition.lcdui.Displayable;
import javax.microedition.lcdui.Form;
import javax.microedition.lcdui.Item;
import javax.microedition.lcdui.ItemStateListener;
import javax.microedition.lcdui.List;
import javax.microedition.lcdui.Screen;
import javax.microedition.lcdui.TextField;
import javax.microedition.midlet.MIDlet;
import javax.microedition.rms.RecordComparator;
import javax.microedition.rms.RecordEnumeration;
import javax.microedition.rms.RecordFilter;
import javax.microedition.rms.RecordStore;
import javax.microedition.rms.RecordStoreException;

/**
 * functionality: browsing, entry, deletion, and searching
 */
public class NewIdeaMIDletOne extends MIDlet implements CommandListener,
    ItemStateListener {

  private RecordStore ideas;
  private static final int T_LEN = 100;
  private static final int I_LEN = 200;
  final private static int ERROR = 0;
  final private static int INFO = 1;
  private Display display;
  private Alert alert;
  private Command cmdAdd;
  private Command cmdBack;
  private Command cmdCancel;
  private Command cmdExit;
  private Command cmdSelect;
  private Command cmdSearch;
  private Command cmdDelete;
  private List mainScr;
  private String[] mainScrChoices = { "Search", "Add New", "Browse", "Delete", "Options" };
  private Form searchScr;
  private TextField s_title;
  private TextField s_idea;
  private Form entryScr;
  private TextField e_idea;
  private TextField e_title;
  private int e_id;
  private List nameScr;
  private Form optionScr;
  private ChoiceGroup sortChoice;
  private int sortOrder = 1;
  private List deleteScr;
 
  public NewIdeaMIDletOne() {
    display = Display.getDisplay(this);

    cmdAdd = new Command("Add", Command.OK, 1);
    cmdBack = new Command("Back", Command.BACK, 2);
    cmdCancel = new Command("Cancel", Command.BACK, 2);
    cmdExit = new Command("Exit", Command.EXIT, 2);
    cmdSelect = new Command("Select", Command.OK, 1);
    cmdDelete = new Command("Delete", Command.OK, 1);
    cmdSearch = new Command("Search", Command.SCREEN, 3);
    
    alert = new Alert("", "", null, AlertType.INFO);
    alert.setTimeout(2000);

    try {
      ideas = RecordStore.openRecordStore("IdeaStorage", true);
    } catch (RecordStoreException e) {
      ideas = null;
    }
  }

  protected void startApp() {
    if (ideas == null) {
      displayAlert(ERROR, "Could not open list of ideas", null);
    } else {
      genMainScr();
    }
  }

  protected void pauseApp() {
  }

  protected void destroyApp(boolean unconditional) {
    if (ideas != null) {
      try {
        ideas.closeRecordStore();
      } catch (Exception e) {
      }
    }
  }

  private void displayAlert(int type, String msg, Screen s) {
    alert.setString(msg);

    switch (type) {
    case ERROR:
      alert.setTitle("Error!");
      alert.setType(AlertType.ERROR);
      break;
    case INFO:
      alert.setTitle("Info");
      alert.setType(AlertType.INFO);
      break;
    }
    display.setCurrent(alert, s == null ? display.getCurrent() : s);
  }

  private void midletExit() {
    destroyApp(false);
    notifyDestroyed();
  }

  private Screen genMainScr() {
    if (mainScr == null) {
      mainScr = new List("Menu", List.IMPLICIT, mainScrChoices, null);
      mainScr.addCommand(cmdSelect);
      mainScr.addCommand(cmdExit);
      mainScr.setCommandListener(this);
    }
    display.setCurrent(mainScr);
    return mainScr;
  }

  private Screen genOptionScr() {
    if (optionScr == null) {
      optionScr = new Form("Options");
      optionScr.addCommand(cmdBack);
      optionScr.setCommandListener(this);

      sortChoice = new ChoiceGroup("Sort by", Choice.EXCLUSIVE);
      sortChoice.append("Title", null);
      sortChoice.append("Idea", null);
      sortChoice.setSelectedIndex(sortOrder, true);
      optionScr.append(sortChoice);
      optionScr.setItemStateListener(this);
    }
    display.setCurrent(optionScr);
    return optionScr;
  }

  private Screen genSearchScr() {
    if (searchScr == null) {
      searchScr = new Form("Search");
      searchScr.addCommand(cmdBack);
      searchScr.addCommand(cmdSearch);
      searchScr.setCommandListener(this);
      s_title = new TextField("Title:", "", I_LEN, TextField.ANY);
      s_idea = new TextField("Idea:", "", T_LEN, TextField.ANY);
      searchScr.append(s_idea);
      searchScr.append(s_title);
    }

    s_idea.delete(0, s_idea.size());
    s_title.delete(0, s_title.size());
    display.setCurrent(searchScr);
    return searchScr;
  }

  private Screen genEntryScr() {
    if (entryScr == null) {
      entryScr = new Form("Add new");
      entryScr.addCommand(cmdCancel);
      entryScr.addCommand(cmdAdd);
      entryScr.setCommandListener(this);

      e_title = new TextField("Title:", "", T_LEN, TextField.ANY);
      e_idea = new TextField("Idea:", "", I_LEN, TextField.ANY);
      entryScr.append(e_title);
      entryScr.append(e_idea);
    }

    e_title.delete(0, e_title.size());
    e_idea.delete(0, e_idea.size());

    display.setCurrent(entryScr);
    return entryScr;
  }

  private Screen genNameScr(String title, String f, String l, boolean local) {
    SimpleComparator sc;
    SimpleFilter sf = null;
    RecordEnumeration re;

    if (local) {
      sc = new SimpleComparator(
          sortOrder == 0 ? SimpleComparator.SORT_BY_TITLE
              : SimpleComparator.SORT_BY_IDEA);

      if (f != null || l != null) {
        sf = new SimpleFilter(f, l);
      }

      try {
        re = ideas.enumerateRecords(sf, sc, false);
      } catch (Exception e) {
        displayAlert(ERROR, "Could not create enumeration: " + e, null);
        return null;
      }

    nameScr = null;
    if (re.hasNextElement()) {
      nameScr = new List(title, List.IMPLICIT);
      nameScr.addCommand(cmdBack);
      nameScr.setCommandListener(this);

      try {
        while (re.hasNextElement()) {
          byte[] b = re.nextRecord();
          nameScr.append(SimpleRecord.getTitle(b) + " - "
              + SimpleRecord.getIdea(b) + " " , null);
        }
      } catch (Exception e) {
        displayAlert(ERROR, "Error while building idea list: " + e,
            null);
        return null;
      }
      display.setCurrent(nameScr);

    } else {
      displayAlert(INFO, "No ideas found", null);
    }
    }
    return nameScr;
  }

  /* ********************************************************************************* */  
  
  private Screen genRemoveScr(String title, String f, String l, boolean local) {
     SimpleComparator sc;
     SimpleFilter sf = null;
     RecordEnumeration re;

     if (local) {
       sc = new SimpleComparator(
           sortOrder == 0 ? SimpleComparator.SORT_BY_TITLE
               : SimpleComparator.SORT_BY_IDEA);

       if (f != null || l != null) {
         sf = new SimpleFilter(f, l);
       }

       try {
         re = ideas.enumerateRecords(sf, sc, false);
       } catch (Exception e) {
         displayAlert(ERROR, "Could not create enumeration: " + e, null);
         return null;
       }
    
     deleteScr = null;
     if (re.hasNextElement()) {
       deleteScr = new List(title, List.IMPLICIT);
       deleteScr.addCommand(cmdBack);
       deleteScr.addCommand(cmdDelete);
       deleteScr.setCommandListener(this);

       try {
         while (re.hasNextElement()) {
           byte[] b = re.nextRecord();
           deleteScr.append(SimpleRecord.getTitle(b) + " - "
               + SimpleRecord.getIdea(b) + " " , null);
         }
       } catch (Exception e) {
         displayAlert(ERROR, "Error while building idea list: " + e,
             null);
         return null;
       }
       display.setCurrent(deleteScr);

     } else {
       displayAlert(INFO, "No ideas found", null);
     }
     }
     return deleteScr;
 }

/* ********************************************************************************* */
  
  private void addEntry() {

    String f = e_title.getString();
    String l = e_idea.getString();

    byte[] b = SimpleRecord.createRecord(f, l);
    try {
      ideas.addRecord(b, 0, b.length);
      displayAlert(INFO, "Record added", mainScr);
    } catch (RecordStoreException rse) {
      displayAlert(ERROR, "Could not add record" + rse, mainScr);
    }
  }
  
/* ********************************************************************************************** */ 
  
  private void deleteEntry() {

     byte[] b = SimpleRecord.deleteRecord(e_id);
     try {
          ideas.deleteRecord(b.length);
          displayAlert(INFO, "Record deleted", mainScr);
        } catch (RecordStoreException rse){
          displayAlert(ERROR, "Could not delete record" + rse, mainScr);
        }
   }
   
/*  **************************************************************************************** */
  
  public void commandAction(Command c, Displayable d) {
    if (d == mainScr) {
      if (c == cmdExit) {
        midletExit(); 
      } else if ((c == List.SELECT_COMMAND) || (c == cmdSelect)) {
        switch (mainScr.getSelectedIndex()) {
        case 0:
          genSearchScr();
          break;
        case 1:
          genEntryScr();
          break;
        case 2:
          genNameScr("Browse", null, null, true);
          break;
        case 3:
            genRemoveScr("Remove", null, null, true);
            break;
        case 4:
            genOptionScr();
            break;
        default:
          displayAlert(ERROR, "Unexpected index!", mainScr);
        }
      }
    } else if (d == nameScr) {
      if (c == cmdBack) {
        genMainScr();
      } 
    } else if (d == deleteScr) {
        if (c == cmdBack) {
          genMainScr();
        } else if (c == cmdDelete) {
          deleteEntry();
        }
    } else if (d == entryScr) {
      if (c == cmdCancel) {
        genMainScr();
      } else if (c == cmdAdd) {
        addEntry();
      }
    } else if (d == optionScr) {
      if (c == cmdBack) {
        genMainScr();
      }
    } else if (d == searchScr) {
      if (c == cmdBack) {
        genMainScr();
      } else if (c == cmdSearch) {

        genNameScr("Search Result", s_idea.getString(), s_title
            .getString(), c == cmdSearch);
      }
    } 
  }   

  public void itemStateChanged(Item item) {
    if (item == sortChoice) {
      sortOrder = sortChoice.getSelectedIndex();
    }
  }
}

class Query implements RecordEnumeration {
  private Enumeration resultsEnumeration;
 
  public boolean hasNextElement() {
    return resultsEnumeration.hasMoreElements();
  }

  public byte[] nextRecord() {
    return (byte[]) resultsEnumeration.nextElement();
  }

  public boolean hasPreviousElement() {
    return false;
  }

  public void destroy() {
  }

  public boolean isKeptUpdated() {
    return false;
  }

  public void keepUpdated(boolean b) {
    return;
  }

  public int nextRecordId() {
    return 0;
  }

  public int numRecords() {
    return 0;
  }

  public byte[] previousRecord() {
    return null;
  }

  public int previousRecordId() {
    return 0;
  }

  public void rebuild() {
    return;
  }

  public void reset() {
    return;
  }
}


class SimpleFilter implements RecordFilter {

  private String first;

  private String last;

  public SimpleFilter(String f, String l) {
    first = f.toLowerCase();
    last = l.toLowerCase();
  }

  public boolean matches(byte[] r) {

    String f = SimpleRecord.getTitle(r).toLowerCase();
    String l = SimpleRecord.getIdea(r).toLowerCase();

    return f.startsWith(first) && l.startsWith(last);
  }
}

class SimpleComparator implements RecordComparator {

  public final static int SORT_BY_TITLE = 1;

  public final static int SORT_BY_IDEA = 2;

  private int sortOrder = -1;

  SimpleComparator(int s) {
    switch (s) {
    case SORT_BY_TITLE:
    case SORT_BY_IDEA:    
      this.sortOrder = s;
      break;
    default:
      this.sortOrder = SORT_BY_IDEA;
      break;
    }
  }

  public int compare(byte[] r1, byte[] r2) {

    String n1 = null;
    String n2 = null;

    if (sortOrder == SORT_BY_TITLE) {
        n1 = SimpleRecord.getTitle(r1).toLowerCase();
        n2 = SimpleRecord.getTitle(r2).toLowerCase();
      } else if (sortOrder == SORT_BY_IDEA) {
        n1 = SimpleRecord.getIdea(r1).toLowerCase();
        n2 = SimpleRecord.getIdea(r2).toLowerCase();
      }    
    
    int n = n1.compareTo(n2);
    if (n < 0) {
      return RecordComparator.PRECEDES;
    }
    if (n > 0) {
      return RecordComparator.FOLLOWS;
    }

    return RecordComparator.EQUIVALENT;
  }
}

final class SimpleRecord {

  private final static int TITLE_INDEX = 0;
  private final static int IDEA_INDEX = 20;
  private final static int FIELD_LEN = 20;
  private final static int MAX_REC_LEN = 60;
  private static StringBuffer recBuf = new StringBuffer(MAX_REC_LEN);

  private SimpleRecord() {
  }

  private static void clearBuf() {
    for (int i = 0; i < MAX_REC_LEN; i++) {
      recBuf.insert(i, ' ');
    }
    recBuf.setLength(MAX_REC_LEN);
  }

  public static byte[] createRecord(String z_title, String z_idea) {
    clearBuf();
    recBuf.insert(TITLE_INDEX, z_title);
    recBuf.insert(IDEA_INDEX, z_idea);
    recBuf.setLength(MAX_REC_LEN);
    return recBuf.toString().getBytes();
  }
/* ********************************************************************************** 
  public static byte[] removeRecord(int z_id, int z_ida) {
     clearBuf();
     recBuf.delete(TITLE_INDEX, z_id);
     recBuf.delete(IDEA_INDEX, z_ida);
     recBuf.setLength(MAX_REC_LEN);
     return recBuf.toString().getBytes();
 }
  ********************************************************************************** */
  
  
  public static String getTitle(byte[] b) {
    return new String(b, TITLE_INDEX, FIELD_LEN).trim();
  }

  public static String getIdea(byte[] b) {
    return new String(b, IDEA_INDEX, FIELD_LEN).trim();
  }

}