// Import section
import javax.microedition.midlet.*;
import javax.microedition.lcdui.*;
import javax.microedition.rms.*;
import javax.microedition.io.*;
import java.io.*;
import java.lang.*;
// A first MIDlet with simple text and a few commands. The
//CommandListener
// allows MID application to respond to screen commands while the
// ItemStateListener keep track of input
// items values being changed.
public class Appointment extends MIDlet
implements CommandListener, ItemStateListener {
// Screen commands
private Command exitCommand;
// Display a list of appointments already set in database
private Command displayCommand;
// Set up a new appointment
private Command setCommand;
// Display the Delete screen where
//multiple appointments can be
//selected for deletion
private Command deleteCommand;
// Save appointment in database
private Command saveCommand;
// Displays a menu of commands
private Command menuCommand;
// Delete selected appointments
private Command delCommand;
//The display for this MIDlet
private Display display;
// Input fields for setting name and date values for a new appointment
DateField apptDate;
TextField apptField;
private String apptName, apptTime;
// User Interface of the application
Form welcomeForm, menuForm, displayForm, setForm, deleteForm;
// Record store designated for storage of appointment information
RecordStore rs;
// To allow selection of appointments for delete or view
ChoiceGroup cg;
ChoiceGroup list;
// The vector contains a list of appointments selected for deletion
java.util.Vector vector = new java.util.Vector();
boolean deleted[];
java.util.Vector delRecords = new java.util.Vector();
// This will retrieve appointments in name - mm/dd/yyyy hh:mm AM_PM
//form from record store
public void getAppointments()
{
// Allows single selection
list = new ChoiceGroup("Appointments", ChoiceGroup.EXCLUSIVE);
// Allows multiple selections
cg = new ChoiceGroup("Appointments",ChoiceGroup.MULTIPLE);
String name;
String at;
try
{
// Open a Record store
rs = RecordStore.openRecordStore("MyAppointments",true);
// Display list of appointments already set.
// Ignore appointments which
// have been deleted and marked with a '@'
for (int j=0;j<rs.getNumRecords();j++)
{
at = new String("");
name = new String("");
byte b[] = rs.getRecord(j);
// The string will comply to a ####AAAA format
String str = new String(b,0,b.length);
System.out.println(str);
if (!(str.startsWith("@")))
{
for (int i=0;i<str.length();i++)
{
// Digits represent time information in total
// number of seconds
if (Character.isDigit(str.charAt(i)))
at += str.charAt(i);
else
name += str.charAt(i);
}
}
long time = 0;
String setAt = "";
if (!(at.trim().equals("")))
{
time = Long.parseLong(at);
// The time in seconds are converted to Date and
// Calendar objects to display time of appointment in
// user-desired format
java.util.Date date = new java.util.Date(time);
java.util.Calendar rightNow = java.util.Calendar.getInstance();
rightNow.setTime(date);
String year =
String.valueOf(rightNow.get(java.util.Calendar.YEAR));
String month =
String.valueOf(rightNow.get(java.util.Calendar.MONTH) + 1);
String day =
String.valueOf(rightNow.get(java.util.Calendar.DATE));
String am = "";
if ( rightNow.get(java.util.Calendar.AM_PM) == 0)
am = "PM";
else if (rightNow.get(java.util.Calendar.AM_PM) == 1)
am = "AM";
String hr = String.valueOf(rightNow.get(java.util.Calendar.HOUR));
String min = String.valueOf(rightNow.get(java.util.Calendar.MINUTE));
setAt = name + "-" + month + "/" + day + "/" + year
+ " " + hr + ":" + min + " " + am;
}
else
setAt = name;
// A list of appointments are formed for display and cancel
// purposes
list.append(setAt,null);
cg.append(setAt,null);
at = new String("");
name = new String("");
}
}
catch (javax.microedition.rms.RecordStoreException exc)
{
exc.printStackTrace();
}
catch (javax.microedition.rms.RecordStoreNotOpenException exc)
{
}
catch (Exception exc)
{
exc.printStackTrace();
}
}
// UI elements are created and initialized
public Appointment() {
display = Display.getDisplay(this);
exitCommand =
new Command("Exit", Command.SCREEN, 1);
displayCommand =
new Command("View",Command.BACK, 1);
setCommand =
new Command("Set",Command.BACK, 1);
deleteCommand =
new Command("Cancel",Command.BACK, 1);
saveCommand =
new Command("Save",Command.SCREEN, 1);
menuCommand =
new Command("Options",Command.SCREEN, 1);
delCommand =
new Command("Delete",Command.SCREEN, 1);
}
// Start the MIDlet by creating the TextBox and
// associating the exit command and listener.
public void startApp() {
try
{
// The first screen of the application
welcomeForm = new Form("Appointment");
getAppointments();
// If the list of appointments is empty, notify user
if (list.size() == 0)
{
welcomeForm.append("No appointments are set. Follow Menu->Set");
welcomeForm.addCommand(exitCommand);
welcomeForm.addCommand(menuCommand);
welcomeForm.setCommandListener(this);
welcomeForm.setItemStateListener(this);
display.setCurrent(welcomeForm);
}
// else display the list of appointments
else
{
welcomeForm.append(list);
welcomeForm.addCommand(menuCommand);
welcomeForm.setItemStateListener(this);
welcomeForm.setCommandListener(this);
display.setCurrent(welcomeForm);
}
menuForm = new Form("Options");
menuForm.append("Select View to display appointments already set");
menuForm.addCommand(displayCommand);
menuForm.addCommand(setCommand);
menuForm.addCommand(deleteCommand);
menuForm.setCommandListener(this);
menuForm.setItemStateListener(this);
displayForm = new Form("View");
setForm = new Form("Set An Appointment");
apptField = new TextField("Name","", 10,0);
apptDate = new DateField("Set At", DateField.DATE_TIME);
setForm.append(apptField);
setForm.append(apptDate);
setForm.addCommand(saveCommand);
setForm.addCommand(menuCommand);
setForm.setCommandListener(this);
setForm.setItemStateListener(this);
deleteForm = new Form("Delete");
}
catch (Exception exc)
{
exc.printStackTrace();
}
}
public void itemStateChanged(Item item)
{
java.util.Date date;
// The date value is set to a variable when the DateField item
// is changed
if (item == apptDate)
{
date = apptDate.getDate();
apptTime = String.valueOf(date.getTime());
}
// The name of appointment is set to a variable when the
// name input field is changed
if (item == apptField)
{
apptName = apptField.getString();
}
// If the ChoiceGroup item state on Delete form is changed,
it sets an array of
//appointments selected for deletion
if (item == cg)
{
cg.getSelectedFlags(deleted);
}
}
// Pause is a no-op because there are no background
// activities or record stores to be closed.
public void pauseApp() { }
// Destroy must cleanup everything not handled
// by the garbage collector.
// In this case there is nothing to cleanup.
public void destroyApp(boolean unconditional) { }
// Respond to commands. Here we are only implementing
// the exit command. In the exit command, cleanup and
// notify that the MIDlet has been destroyed.
public void commandAction(
Command c, Displayable s) {
// Exit the application after closing the record store
if (c == exitCommand) {
try
{
rs.closeRecordStore();
destroyApp(false);
notifyDestroyed();
}
catch (Exception exc) { exc.printStackTrace(); }
}
// Display the Set form screen which allows to create
// a new appointment
if (c== setCommand) {
display.setCurrent(setForm);
}
// Display a list of appointments
if (c==displayCommand)
{
getAppointments();
displayForm.append(list);
displayForm.addCommand(exitCommand);
displayForm.addCommand(menuCommand);
displayForm.setCommandListener(this);
displayForm.setItemStateListener(this);
display.setCurrent(displayForm);
}
// When hit Cancel, a selectable list of appointments is
//displayed. It allows to select
// multiple appointments for purpose of deletion
if (c==deleteCommand)
{
getAppointments();
deleteForm.append(cg);
deleted = new boolean[cg.size()];
deleteForm.addCommand(delCommand);
deleteForm.addCommand(menuCommand);
deleteForm.setCommandListener(this);
deleteForm.setItemStateListener(this);
display.setCurrent(deleteForm);
}
// When hit Menu, the menu form displays which provides
//options of setting appointments and cancel
if (c==menuCommand)
display.setCurrent(menuForm);
// When hit Save, insert record into record store as stream of bytes
if (c==saveCommand)
{
try
{
String appt = apptName + " " + apptTime;
byte bytes[] = appt.getBytes();
rs.addRecord(bytes,0,bytes.length);
}
catch (Exception exc)
{
exc.printStackTrace();
}
}
// Actually delete the set of selected appointments.
//The selected appointments are
// marked as invalid in the record store and are
//not displayed later
if (c==delCommand)
{
try
{
for (int m=0;m<deleted.length;m++)
{
boolean ifDeleted = deleted[m];
// In case a record is deleted, store some invalid characters
// that signify it is inactive
if (ifDeleted)
{
String deactive = "@";
byte b[] = deactive.getBytes();
rs.setRecord(m+1, b,0,b.length);
}
}
}
catch (Exception exc)
{
exc.printStackTrace();
}
}
}
}
|
