Classes sorted by package:

core.comms
BaseMessaging

core.threads
BaseThread

core.ui
MainUIMidlet

core.ui.controller
AbstractController
AlbumController
BaseController
ControllerInterface
PhotoController
PhotoListController
PhotoViewController
ScreenSingleton

core.ui.datamodel
AlbumData
ImageAccessor
ImageData

core.ui.screens
AddPhotoToAlbum
AlbumListScreen
NewLabelScreen
PhotoListScreen
PhotoViewScreen
SplashScreen

core.util
Constants
ImageUtil

sms
NetworkScreen
SmsMessaging
SmsReceiverController
SmsReceiverThread
SmsSenderController
SmsSenderThread
  1 /*
  2  * Created on Sep 28, 2004
  3  */
  4 package ubc.midp.mobilephoto.core.ui.datamodel;
  5 
  6 import java.util.Hashtable;
  7 
  8 import javax.microedition.lcdui.Image;
  9 
 10 import lancs.midp.mobilephoto.lib.exceptions.ImageNotFoundException;
 11 import lancs.midp.mobilephoto.lib.exceptions.InvalidImageDataException;
 12 import lancs.midp.mobilephoto.lib.exceptions.InvalidPhotoAlbumNameException;
 13 import lancs.midp.mobilephoto.lib.exceptions.NullAlbumDataReference;
 14 import lancs.midp.mobilephoto.lib.exceptions.PersistenceMechanismException;
 15 import lancs.midp.mobilephoto.lib.exceptions.UnavailablePhotoAlbumException;
 16 
 17 /**
 18  @author tyoung
 19  
 20  * This class represents the data model for Photo Albums. A Photo Album object
 21  * is essentially a list of photos or images, stored in a Hashtable. Due to
 22  * constraints of the J2ME RecordStore implementation, the class stores a table
 23  * of the images, indexed by an identifier, and a second table of image metadata
 24  * (ie. labels, album name etc.)
 25  
 26  * This uses the ImageAccessor class to retrieve the image data from the
 27  * recordstore (and eventually file system etc.)
 28  */
 29 public class AlbumData {
 30 
 31   private ImageAccessor imageAccessor;
 32 
 33   //imageInfo holds image metadata like label, album name and 'foreign key' index to
 34   // corresponding RMS entry that stores the actual Image object
 35   protected Hashtable imageInfoTable = new Hashtable();
 36 
 37   public boolean existingRecords = false//If no records exist, try to reset
 38 
 39   /**
 40    *  Constructor. Creates a new instance of ImageAccessor
 41    */
 42   public AlbumData() {
 43     imageAccessor = new ImageAccessor(this);
 44   }
 45 
 46   /**
 47    *  Load any photo albums that are currently defined in the record store
 48    */
 49   public String[] getAlbumNames() {
 50 
 51     //Shouldn't load all the albums each time
 52     //Add a check somewhere in ImageAccessor to see if they've been
 53     //loaded into memory already, and avoid the extra work...
 54     try {
 55       imageAccessor.loadAlbums();
 56     catch (InvalidImageDataException e) {
 57       // TODO Auto-generated catch block
 58       e.printStackTrace();
 59     catch (PersistenceMechanismException e) {
 60       // TODO Auto-generated catch block
 61       e.printStackTrace();
 62     }
 63     return imageAccessor.getAlbumNames();
 64   }
 65 
 66   /**
 67    *  Get all images for a given Photo Album that exist in the Record Store.
 68    @throws UnavailablePhotoAlbumException 
 69    @throws InvalidImageDataException 
 70    @throws PersistenceMechanismException 
 71    */
 72   public ImageData[] getImages(String recordNamethrows UnavailablePhotoAlbumException  {
 73 
 74     ImageData[] result;
 75     try {
 76       result = imageAccessor.loadImageDataFromRMS(recordName);
 77     catch (PersistenceMechanismException e) {
 78       throw new UnavailablePhotoAlbumException(e);
 79       
 80     catch (InvalidImageDataException e) {
 81       throw new UnavailablePhotoAlbumException(e);
 82     }
 83 
 84     return result;
 85 
 86   }
 87 
 88   /**
 89    *  Define a new user photo album. This results in the creation of a new
 90    *  RMS Record store.
 91    @throws PersistenceMechanismException 
 92    @throws InvalidPhotoAlbumNameException 
 93    */
 94   public void createNewPhotoAlbum(String albumNamethrows PersistenceMechanismException, InvalidPhotoAlbumNameException {
 95     imageAccessor.createNewPhotoAlbum(albumName);
 96   }
 97   
 98   public void deletePhotoAlbum(String albumNamethrows PersistenceMechanismException{
 99     imageAccessor.deletePhotoAlbum(albumName);
100   }
101 
102   /**
103    *  Get a particular image (by name) from a photo album. The album name corresponds
104    *  to a record store.
105    @throws ImageNotFoundException 
106    @throws PersistenceMechanismException 
107    */
108   public Image getImageFromRecordStore(String recordStore, String imageNamethrows ImageNotFoundException, PersistenceMechanismException {
109 
110     ImageData imageInfo = null;
111     try {
112       imageInfo = imageAccessor.getImageInfo(imageName);
113     catch (NullAlbumDataReference e) {
114       imageAccessor = new ImageAccessor(this);
115     }
116     //Find the record ID and store name of the image to retrieve
117     int imageId = imageInfo.getForeignRecordId();
118     String album = imageInfo.getParentAlbumName();
119     //Now, load the image (on demand) from RMS and cache it in the hashtable
120     Image imageRec = imageAccessor.loadSingleImageFromRMS(album, imageName, imageId)//rs.getRecord(recordId);
121     return imageRec;
122 
123   }
124   public void addNewPhotoToAlbum(String label, String path, String albumthrows InvalidImageDataException, PersistenceMechanismException{
125     imageAccessor.addImageData(label, path, album);
126   }
127 
128   /**
129    *  Delete a photo from the photo album. This permanently deletes the image from the record store
130    @throws ImageNotFoundException 
131    @throws PersistenceMechanismException 
132    */
133   public void deleteImage(String imageName, String storeNamethrows PersistenceMechanismException, ImageNotFoundException {
134     try {
135       imageAccessor.deleteSingleImageFromRMS(imageName, storeName);
136     }
137     catch (NullAlbumDataReference e) {
138       imageAccessor = new ImageAccessor(this);
139       e.printStackTrace();
140     
141   }
142   
143   /**
144    *  Reset the image data for the application. This is a wrapper to the ImageAccessor.resetImageRecordStore
145    *  method. It is mainly used for testing purposes, to reset device data to the default album and photos.
146    @throws PersistenceMechanismException 
147    @throws InvalidImageDataException 
148    */
149   public void resetImageData() throws PersistenceMechanismException {
150     try {
151       imageAccessor.resetImageRecordStore();
152     catch (InvalidImageDataException e) {
153       e.printStackTrace();
154     }
155   }
156 
157   /**
158    * Get the hashtable that stores the image metadata in memory.
159    @return Returns the imageInfoTable.
160    */
161   public Hashtable getImageInfoTable() {
162     return imageInfoTable;
163   }
164 
165   /**
166    * Update the hashtable that stores the image metadata in memory
167    @param imageInfoTable
168    *            The imageInfoTable to set.
169    */
170   public void setImageInfoTable(Hashtable imageInfoTable) {
171     this.imageInfoTable = imageInfoTable;
172   }
173 
174   /**
175    * [EF] Added in order to have access to ImageData
176    @param imageAccessor
177    */
178   public void setImageAccessor(ImageAccessor imageAccessor) {
179     this.imageAccessor = imageAccessor;
180   }
181 
182   /**
183    * [EF] Added in order to have access to ImageData
184    @return
185    */
186   public ImageAccessor getImageAccessor() {
187     return imageAccessor;
188   }
189 }