Changeset 529

Timestamp:

11/08/09 12:41:11 (2 years ago)

Author:

octorian

Message:

Initial implementation of basic offline message cache and folder sync.

Location:

trunk/LogicMail/src/org/logicprobe/LogicMail

Files:

• mail/AbstractMailStore.java (modified) (3 diffs)
• mail/FolderMessagesEvent.java (modified) (2 diffs)
• mail/IncomingMailClient.java (modified) (3 diffs)
• mail/IncomingMailConnectionHandler.java (modified) (3 diffs)
• mail/LocalMailStore.java (modified) (5 diffs)
• mail/LocalMessageToken.java (modified) (2 diffs)
• mail/MessageToken.java (modified) (2 diffs)
• mail/NetworkMailStore.java (modified) (3 diffs)
• mail/imap/ImapClient.java (modified) (11 diffs)
• mail/imap/ImapMessageToken.java (modified) (2 diffs)
• mail/imap/ImapProtocol.java (modified) (6 diffs)
• mail/pop/PopClient.java (modified) (3 diffs)
• mail/pop/PopMessageToken.java (modified) (2 diffs)
• model/AccountNode.java (modified) (1 diff)
• model/MailFileManager.java (added)
• model/MailboxNode.java (modified) (3 diffs)
• model/MessageNode.java (modified) (18 diffs)
• model/MessageNodeReader.java (modified) (9 diffs)
• model/MessageNodeWriter.java (modified) (1 diff)
• model/OutboxMailboxNode.java (modified) (1 diff)

trunk/LogicMail/src/org/logicprobe/LogicMail/mail/AbstractMailStore.java

@@ -154 +154 @@
     /**
      * Requests the message listing from a particular folder.
+     * All message tokens must refer to messages that exist within the provided
+     * folder item, or the results may be unexpected.
      * 
      * <p>Successful completion is indicated by a call to
@@ -159 +161 @@
      * 
      * @param folder The folder to request a message listing for.
-     * @param indices The set of indices for the messages to get headers for.
-     */
-    public abstract void requestFolderMessagesSet(FolderTreeItem folder, int[] indices);
+     * @param messageTokens The set of tokens for the messages to get headers for.
+     */
+    public abstract void requestFolderMessagesSet(FolderTreeItem folder, MessageToken[] messageTokens);
     
     /**
      * Requests the recent message listing from a particular folder.
      * 
-     * <p>Successful completion is indicated by a call to
+     * <p>
+     * Successful completion is indicated by a call to
      * {@link FolderListener#folderMessagesAvailable(FolderMessagesEvent)}.
+     * If <tt>flagsOnly</tt> is set to <b>true</b>, then the envelope and
+     * structure fields of the returned <tt>FolderMessage</tt> objects
+     * will be set to <b>null</b>.
+     * </p>
      * 
      * @param folder The folder to request a message listing for.
-     */
-    public abstract void requestFolderMessagesRecent(FolderTreeItem folder);
+     * @param flagsOnly If true, only tokens and flags will be fetched
+     */
+    public abstract void requestFolderMessagesRecent(FolderTreeItem folder, boolean flagsOnly);
+    
+    /**
+     * Requests the recent message listing from a particular folder.
+     * 
+     * <p>Successful completion is indicated by a call to
+     * {@link FolderListener#folderMessagesAvailable(FolderMessagesEvent)}.
+     * 
+     * @param folder The folder to request a message listing for.
+     */
+    public void requestFolderMessagesRecent(FolderTreeItem folder) {
+        requestFolderMessagesRecent(folder, false);
+    }
     
     /**
@@ -404 +424 @@
      * @param folder The folder which has available messages
      * @param messages The messages that are now available
-     */
-    protected void fireFolderMessagesAvailable(FolderTreeItem folder, FolderMessage[] messages) {
+     * @param flagsOnly True if the message data only includes flags
+     */
+    protected void fireFolderMessagesAvailable(FolderTreeItem folder, FolderMessage[] messages, boolean flagsOnly) {
         Object[] listeners = listenerList.getListeners(FolderListener.class);
         FolderMessagesEvent e = null;
         for(int i=0; i<listeners.length; i++) {
             if(e == null) {
-                e = new FolderMessagesEvent(this, folder, messages);
+                e = new FolderMessagesEvent(this, folder, messages, flagsOnly);
             }
             ((FolderListener)listeners[i]).folderMessagesAvailable(e);

trunk/LogicMail/src/org/logicprobe/LogicMail/mail/FolderMessagesEvent.java

@@ -36 +36 @@
 public class FolderMessagesEvent extends FolderEvent {
         private FolderMessage[] messages;
+        private boolean flagsOnly;
         
-        public FolderMessagesEvent(Object source, FolderTreeItem folder, FolderMessage[] messages) {
+        public FolderMessagesEvent(Object source, FolderTreeItem folder, FolderMessage[] messages, boolean flagsOnly) {
                 super(source, folder);
                 this.messages = messages;
+                this.flagsOnly = flagsOnly;
         }
 
+        public FolderMessagesEvent(Object source, FolderTreeItem folder, FolderMessage[] messages) {
+                this(source, folder, messages, false);
+        }
+        
         /**
          * Gets the folder messages that have been made available
@@ -51 +57 @@
                 return messages;
         }
+        
+        /**
+         * Checks if the newly available folder messages contain only
+         * flag information.
+         * 
+         * @return true, if updated messages are flags only
+         */
+        public boolean isFlagsOnly() {
+                return flagsOnly;
+        }
 }

trunk/LogicMail/src/org/logicprobe/LogicMail/mail/IncomingMailClient.java

@@ -201 +201 @@
     
     /**
+     * Get a list of the messages in the selected folder
+     * which match the provided tokens.
+     * 
+     * @param messageTokens Tokens of the messages
+     * @param progressHandler the progress handler
+     * @return List of message envelopes
+     * 
+     * @throws IOException on I/O errors
+     * @throws MailException on protocol errors
+     */
+    FolderMessage[] getFolderMessages(MessageToken[] messageTokens, MailProgressHandler progressHandler)
+        throws IOException, MailException;
+    
+    /**
      * Get a list of new messages in the selected folder.
      * <p>
@@ -211 +225 @@
      * </p>
      * 
-     * @param progressHandler the progress handler
+     * @param flagsOnly If true, only tokens and flags will be fetched
+     * @param progressHandler the progress handler
+     * 
      * @return List of message envelopes
      * 
@@ -217 +233 @@
      * @throws MailException on protocol errors
      */
-    FolderMessage[] getNewFolderMessages(MailProgressHandler progressHandler) throws IOException, MailException;
+    FolderMessage[] getNewFolderMessages(boolean flagsOnly, MailProgressHandler progressHandler) throws IOException, MailException;
     
     /**

trunk/LogicMail/src/org/logicprobe/LogicMail/mail/IncomingMailConnectionHandler.java

@@ -35 +35 @@
 import java.util.Vector;
 
-import net.rim.device.api.system.UnsupportedOperationException;
-
 import org.logicprobe.LogicMail.LogicMailResource;
 import org.logicprobe.LogicMail.message.FolderMessage;
@@ -105 +103 @@
                         handleRequestFolderMessagesSet(
                                         (FolderTreeItem)params[0],
-                                        (int[])params[1]);
+                                        (MessageToken[])params[1]);
                         break;
                 case REQUEST_FOLDER_MESSAGES_RECENT:
                         handleRequestFolderMessagesRecent(
-                                        (FolderTreeItem)params[0]);
+                                        (FolderTreeItem)params[0], ((Boolean)params[1]).booleanValue());
                         break;
                 case REQUEST_MESSAGE:
@@ -238 +236 @@
         }
         
-        private void handleRequestFolderMessagesSet(FolderTreeItem folder, int[] indices) throws IOException, MailException {
-                throw new UnsupportedOperationException("Not yet implemented");
-//              checkActiveFolder(folder);
-//              
-//              FolderMessage[] messages = incomingClient.getFolderMessages(firstIndex, lastIndex);
-//              
-//              MailConnectionHandlerListener listener = getListener();
-//              if(messages != null && messages.length > 0 && listener != null) {
-//                      listener.mailConnectionRequestComplete(REQUEST_FOLDER_MESSAGES_SET, new Object[] { folder, messages });
-//              }
-        }
-        
-        private void handleRequestFolderMessagesRecent(FolderTreeItem folder) throws IOException, MailException {
+        private void handleRequestFolderMessagesSet(FolderTreeItem folder, MessageToken[] messageTokens) throws IOException, MailException {
+                String message = resources.getString(LogicMailResource.MAILCONNECTION_REQUEST_FOLDER_MESSAGES);
+                showStatus(message + "...");
+                checkActiveFolder(folder);
+                
+                FolderMessage[] messages = incomingClient.getFolderMessages(messageTokens, getProgressHandler(message));
+                
+                MailConnectionHandlerListener listener = getListener();
+                if(messages != null && messages.length > 0 && listener != null) {
+                        listener.mailConnectionRequestComplete(REQUEST_FOLDER_MESSAGES_SET, new Object[] { folder, messages });
+                }
+        }
+        
+        private void handleRequestFolderMessagesRecent(FolderTreeItem folder, boolean flagsOnly) throws IOException, MailException {
                 String message = resources.getString(LogicMailResource.MAILCONNECTION_REQUEST_FOLDER_MESSAGES);
                 showStatus(message + "...");
                 checkActiveFolder(folder);
         
-                FolderMessage[] messages = incomingClient.getNewFolderMessages(getProgressHandler(message));
+                FolderMessage[] messages = incomingClient.getNewFolderMessages(flagsOnly, getProgressHandler(message));
                 
                 MailConnectionHandlerListener listener = getListener();
                 if(messages != null && messages.length > 0 && listener != null) {
-                        listener.mailConnectionRequestComplete(REQUEST_FOLDER_MESSAGES_RECENT, new Object[] { folder, messages });
+                        listener.mailConnectionRequestComplete(REQUEST_FOLDER_MESSAGES_RECENT, new Object[] { folder, messages, new Boolean(flagsOnly) });
                 }
         }

trunk/LogicMail/src/org/logicprobe/LogicMail/mail/LocalMailStore.java

@@ -39 +39 @@
 import javax.microedition.io.file.FileConnection;
 
+import net.rim.device.api.system.UnsupportedOperationException;
+
 import org.logicprobe.LogicMail.conf.MailSettings;
 import org.logicprobe.LogicMail.message.FolderMessage;
@@ -138 +140 @@
 
     public void requestFolderMessagesRange(FolderTreeItem folder, int firstIndex, int lastIndex) {
-        // TODO Auto-generated method stub
-    }
-
-    public void requestFolderMessagesSet(FolderTreeItem folder, int[] indices) {
-        // TODO Auto-generated method stub
-    }
-
-    public void requestFolderMessagesRecent(FolderTreeItem folder) {
+        throw new UnsupportedOperationException("Not yet implemented");
+        }
+
+        public void requestFolderMessagesSet(FolderTreeItem folder, MessageToken[] messageTokens) {
+                throw new UnsupportedOperationException("Not yet implemented");
+        }
+
+    public void requestFolderMessagesRecent(FolderTreeItem folder, boolean flagsOnly) {
+        // The flagsOnly parameter has no effect on local mail stores,
+        // and it is not likely to ever be called on them anyways.
         FolderTreeItem requestFolder = getMatchingFolderTreeItem(folder.getPath());
         
@@ -169 +173 @@
                 
                 if(folderMessages != null) {
-                        fireFolderMessagesAvailable(requestFolder, folderMessages);
+                        fireFolderMessagesAvailable(requestFolder, folderMessages, false);
                 }
                 }
@@ -224 +228 @@
     
     public void requestMessageDelete(MessageToken messageToken, MessageFlags messageFlags) {
-        // TODO Auto-generated method stub
+        throw new UnsupportedOperationException("Not yet implemented");
     }
 
     public void requestMessageUndelete(MessageToken messageToken, MessageFlags messageFlags) {
-        // TODO Auto-generated method stub
+        throw new UnsupportedOperationException("Not yet implemented");
     }
 
     public void requestMessageAnswered(MessageToken messageToken, MessageFlags messageFlags) {
-        // TODO Auto-generated method stub
+        throw new UnsupportedOperationException("Not yet implemented");
     }
 
@@ -264 +268 @@
                 
                 if(folderMessage != null) {
-                        fireFolderMessagesAvailable(requestFolder, new FolderMessage[] { folderMessage });
+                        fireFolderMessagesAvailable(requestFolder, new FolderMessage[] { folderMessage }, false);
                 }
                 }

trunk/LogicMail/src/org/logicprobe/LogicMail/mail/LocalMessageToken.java

@@ -90 +90 @@
      * @return Unique ID.
      */
-    String getMessageUid() {
+    public String getMessageUid() {
         return this.messageUid;
     }
@@ -145 +145 @@
                 return hashCode;
         }
+        
+        /* (non-Javadoc)
+         * @see java.lang.Object#toString()
+         */
+        public String toString() {
+                StringBuffer buf = new StringBuffer();
+                buf.append("LocalMessageToken [");
+                buf.append("uniqueId="); buf.append(uniqueId);
+                buf.append(", folderPath=\""); buf.append(folderPath); buf.append("\"");
+                buf.append(", messageUid=\""); buf.append(messageUid); buf.append("\"");
+                buf.append("]");
+                return buf.toString();
+        }
 }

trunk/LogicMail/src/org/logicprobe/LogicMail/mail/MessageToken.java

@@ -47 +47 @@
 public interface MessageToken extends Serializable {
         /**
+         * Gets the message UID, which is a protocol-specific way of uniquely
+         * identifying a message within its mailbox.  This is different from
+         * the {@link Serializable#getUniqueId()}, as it is a <tt>String</tt>
+         * identifier known to the mail protocol and does not have to be
+         * unique beyond the mailbox.
+         * 
+         * @return the message UID
+         */
+        String getMessageUid(); 
+        
+        /**
          * Returns whether this token represents a message contained within
          * the specified mail folder.
@@ -53 +64 @@
          * @return True if contained, false otherwise
          */
-        public abstract boolean containedWithin(FolderTreeItem folderTreeItem);
+        boolean containedWithin(FolderTreeItem folderTreeItem);
 }

trunk/LogicMail/src/org/logicprobe/LogicMail/mail/NetworkMailStore.java

@@ -128 +128 @@
         }
 
-        public void requestFolderMessagesSet(FolderTreeItem folder, int[] indices) {
-                throw new UnsupportedOperationException("Not yet implemented");
-        }
-        
-        public void requestFolderMessagesRecent(FolderTreeItem folder) {
+        public void requestFolderMessagesSet(FolderTreeItem folder, MessageToken[] messageTokens) {
+                connectionHandler.addRequest(
+                                IncomingMailConnectionHandler.REQUEST_FOLDER_MESSAGES_SET,
+                                new Object[] { folder, messageTokens });
+        }
+        
+        public void requestFolderMessagesRecent(FolderTreeItem folder, boolean flagsOnly) {
                 connectionHandler.addRequest(
                                 IncomingMailConnectionHandler.REQUEST_FOLDER_MESSAGES_RECENT,
-                                new Object[] { folder });
+                                new Object[] { folder, new Boolean(flagsOnly) });
         }
         
@@ -192 +194 @@
                 case IncomingMailConnectionHandler.REQUEST_FOLDER_MESSAGES_RANGE:
                 case IncomingMailConnectionHandler.REQUEST_FOLDER_MESSAGES_SET:
+                        results = (Object[])result;
+                        fireFolderMessagesAvailable((FolderTreeItem)results[0], (FolderMessage[])results[1], false);
+                        break;
                 case IncomingMailConnectionHandler.REQUEST_FOLDER_MESSAGES_RECENT:
                         results = (Object[])result;
-                        fireFolderMessagesAvailable((FolderTreeItem)results[0], (FolderMessage[])results[1]);
+                        fireFolderMessagesAvailable((FolderTreeItem)results[0], (FolderMessage[])results[1], ((Boolean)results[2]).booleanValue());
                         break;
                 case IncomingMailConnectionHandler.REQUEST_MESSAGE:
@@ -218 +223 @@
                 case IncomingMailConnectionHandler.REQUEST_MESSAGE_APPEND:
                         results = (Object[])result;
-                        fireFolderMessagesAvailable((FolderTreeItem)results[0], (FolderMessage[])results[1]);
+                        fireFolderMessagesAvailable((FolderTreeItem)results[0], (FolderMessage[])results[1], false);
                         break;
                 case IncomingMailConnectionHandler.REQUEST_MESSAGE_COPY:

trunk/LogicMail/src/org/logicprobe/LogicMail/mail/imap/ImapClient.java

@@ -585 +585 @@
      */
     public FolderMessage[] getFolderMessages(int firstIndex, int lastIndex, MailProgressHandler progressHandler) throws IOException, MailException {
+        return getFolderMessages(firstIndex, lastIndex, false, progressHandler);
+    }
+    
+    private FolderMessage[] getFolderMessages(int firstIndex, int lastIndex, boolean flagsOnly, MailProgressHandler progressHandler) throws IOException, MailException {
         // Sanity check
         if(activeMailbox == null) {
@@ -595 +599 @@
         }
         
-        ImapProtocol.FetchEnvelopeResponse[] response =
+        FolderMessage[] result;
+        if(flagsOnly) {
+            ImapProtocol.FetchFlagsResponse[] flagsResponse =
+                imapProtocol.executeFetchFlags(firstIndex, lastIndex, progressHandler);
+                result = prepareFolderMessagesFlags(flagsResponse);
+        }
+        else {
+            ImapProtocol.FetchEnvelopeResponse[] envResponse =
                 imapProtocol.executeFetchEnvelope(firstIndex, lastIndex, progressHandler);
+                result = prepareFolderMessagesEnvelope(envResponse);
+        }
         
-        return prepareFolderMessages(response);
-    }
-
-    /* (non-Javadoc)
-     * @see org.logicprobe.LogicMail.mail.IncomingMailClient#getNewFolderMessages(org.logicprobe.LogicMail.mail.MailProgressHandler)
-     */
-    public FolderMessage[] getNewFolderMessages(MailProgressHandler progressHandler) throws IOException, MailException {
+        return result;
+    }
+
+        /* (non-Javadoc)
+         * @see org.logicprobe.LogicMail.mail.IncomingMailClient#getFolderMessages(org.logicprobe.LogicMail.mail.MessageToken[], org.logicprobe.LogicMail.mail.MailProgressHandler)
+         */
+        public FolderMessage[] getFolderMessages(MessageToken[] messageTokens, MailProgressHandler progressHandler)
+                        throws IOException, MailException {
+                // TODO Auto-generated method stub
+        // Sanity check
+        if(activeMailbox == null) {
+                throw new MailException("Mailbox not selected");
+        }
+
+        int[] uids = new int[messageTokens.length];
+        for(int i=0; i<messageTokens.length; i++) {
+                uids[i] = ((ImapMessageToken)messageTokens[i]).getImapMessageUid();
+        }
+        ImapProtocol.FetchEnvelopeResponse[] envResponse =
+            imapProtocol.executeFetchEnvelopeUid(uids, progressHandler);
+        
+                return prepareFolderMessagesEnvelope(envResponse);
+        }
+
+    /* (non-Javadoc)
+     * @see org.logicprobe.LogicMail.mail.IncomingMailClient#getNewFolderMessages(boolean, org.logicprobe.LogicMail.mail.MailProgressHandler)
+     */
+    public FolderMessage[] getNewFolderMessages(boolean flagsOnly, MailProgressHandler progressHandler) throws IOException, MailException {
         // Sanity check
         if(activeMailbox == null) {
@@ -615 +649 @@
                         int msgCount = activeMailbox.getMsgCount();
                 int firstIndex = Math.max(1, msgCount - count);
-                result = getFolderMessages(firstIndex, activeMailbox.getMsgCount(), progressHandler);
+                result = getFolderMessages(firstIndex, activeMailbox.getMsgCount(), flagsOnly, progressHandler);
                 seenMailboxes.put(activeMailbox, new Object());
         }
         else {
                 int uidNext = ((ImapProtocol.SelectResponse)knownMailboxes.get(activeMailbox)).uidNext;
-                ImapProtocol.FetchEnvelopeResponse[] response =
-                        imapProtocol.executeFetchEnvelopeUid(uidNext, progressHandler);
-                result = prepareFolderMessages(response);
+                if(flagsOnly) {
+                        ImapProtocol.FetchFlagsResponse[] flagsResponse =
+                                imapProtocol.executeFetchFlagsUid(uidNext, progressHandler);
+                        result = prepareFolderMessagesFlags(flagsResponse);
+                }
+                else {
+                        ImapProtocol.FetchEnvelopeResponse[] envResponse =
+                                imapProtocol.executeFetchEnvelopeUid(uidNext, progressHandler);
+                        result = prepareFolderMessagesEnvelope(envResponse);
+                }
                 
                 if(result.length > 0) {
@@ -632 +673 @@
     }
 
-    private FolderMessage[] prepareFolderMessages(ImapProtocol.FetchEnvelopeResponse[] response) {
+    private FolderMessage[] prepareFolderMessagesEnvelope(ImapProtocol.FetchEnvelopeResponse[] response) {
         FolderMessage[] folderMessages = new FolderMessage[response.length];
         for(int i=0;i<response.length;i++) {
@@ -652 +693 @@
     }
     
+    private FolderMessage[] prepareFolderMessagesFlags(ImapProtocol.FetchFlagsResponse[] response) {
+        FolderMessage[] folderMessages = new FolderMessage[response.length];
+        for(int i=0;i<response.length;i++) {
+            folderMessages[i] = new FolderMessage(
+                        new ImapMessageToken(activeMailbox.getPath(), response[i].uid),
+                        null,
+                        response[i].index,
+                        response[i].uid);
+            folderMessages[i].setSeen(response[i].flags.seen);
+            folderMessages[i].setAnswered(response[i].flags.answered);
+            folderMessages[i].setDeleted(response[i].flags.deleted);
+            folderMessages[i].setRecent(response[i].flags.recent);
+            folderMessages[i].setFlagged(response[i].flags.flagged);
+            folderMessages[i].setDraft(response[i].flags.draft);
+            folderMessages[i].setJunk(response[i].flags.junk);
+        }
+        return folderMessages;
+    }
+    
     /* (non-Javadoc)
      * @see org.logicprobe.LogicMail.mail.IncomingMailClient#getMessage(org.logicprobe.LogicMail.mail.MessageToken, org.logicprobe.LogicMail.mail.MailProgressHandler)
@@ -661 +721 @@
         }
         
-        ImapParser.MessageSection structure = getMessageStructure(imapMessageToken.getMessageUid());
+        ImapParser.MessageSection structure = getMessageStructure(imapMessageToken.getImapMessageUid());
         Hashtable contentMap = new Hashtable();
         MimeMessagePart rootPart =
-            getMessagePart(contentMap, imapMessageToken.getMessageUid(),
+            getMessagePart(contentMap, imapMessageToken.getImapMessageUid(),
                            structure, accountConfig.getMaxMessageSize(),
                            progressHandler);
@@ -693 +753 @@
 
         
-        String data = getMessageBody(imapMessageToken.getMessageUid(), partAddress, progressHandler);
+        String data = getMessageBody(imapMessageToken.getImapMessageUid(), partAddress, progressHandler);
         MimeMessageContent content;
         try {
@@ -835 +895 @@
         
         ImapProtocol.MessageFlags updatedFlags =
-            imapProtocol.executeStore(imapMessageToken.getMessageUid(), true, new String[] { "\\Deleted" });
+            imapProtocol.executeStore(imapMessageToken.getImapMessageUid(), true, new String[] { "\\Deleted" });
         refreshMessageFlags(updatedFlags, messageFlags);
     }
@@ -850 +910 @@
         
         ImapProtocol.MessageFlags updatedFlags =
-            imapProtocol.executeStore(imapMessageToken.getMessageUid(), false, new String[] { "\\Deleted" });
+            imapProtocol.executeStore(imapMessageToken.getImapMessageUid(), false, new String[] { "\\Deleted" });
         refreshMessageFlags(updatedFlags, messageFlags);
     }
@@ -867 +927 @@
         
         ImapProtocol.MessageFlags updatedFlags =
-            imapProtocol.executeStore(imapMessageToken.getMessageUid(), true, new String[] { "\\Answered" });
+            imapProtocol.executeStore(imapMessageToken.getImapMessageUid(), true, new String[] { "\\Answered" });
         refreshMessageFlags(updatedFlags, messageFlags);
     }
@@ -907 +967 @@
         }
         
-        imapProtocol.executeCopy(imapMessageToken.getMessageUid(), destinationFolder.getPath());
+        imapProtocol.executeCopy(imapMessageToken.getImapMessageUid(), destinationFolder.getPath());
     }
     

trunk/LogicMail/src/org/logicprobe/LogicMail/mail/imap/ImapMessageToken.java

@@ -92 +92 @@
      * @return IMAP unique ID.
      */
-    int getMessageUid() {
+    int getImapMessageUid() {
         return this.messageUid;
+    }
+    
+    /* (non-Javadoc)
+     * @see org.logicprobe.LogicMail.mail.MessageToken#getMessageUid()
+     */
+    public String getMessageUid() {
+        return Integer.toHexString(messageUid).toLowerCase();
     }
     
@@ -147 +154 @@
                 return hashCode;
         }
+        
+        /* (non-Javadoc)
+         * @see java.lang.Object#toString()
+         */
+        public String toString() {
+                StringBuffer buf = new StringBuffer();
+                buf.append("ImapMessageToken [");
+                buf.append("uniqueId="); buf.append(uniqueId);
+                buf.append(", folderPath=\""); buf.append(folderPath); buf.append("\"");
+                buf.append(", messageUid="); buf.append(messageUid);
+                buf.append("]");
+                return buf.toString();
+        }
 }

trunk/LogicMail/src/org/logicprobe/LogicMail/mail/imap/ImapProtocol.java

@@ -442 +442 @@
 
     /**
+     * Execute the "FETCH (FLAGS UID)" command
+     * @param firstIndex Index of the first message
+     * @param lastIndex Index of the last message
+     * @param progressHandler the progress handler
+     * @return Array of FetchFlagsResponse objects
+     */
+    public FetchFlagsResponse[] executeFetchFlags(
+                int firstIndex,
+            int lastIndex,
+            MailProgressHandler progressHandler) throws IOException, MailException {
+        if (EventLogger.getMinimumLevel() >= EventLogger.DEBUG_INFO) {
+            EventLogger.logEvent(AppInfo.GUID,
+                ("ImapProtocol.executeFetchFlags(" + firstIndex + ", " +
+                lastIndex + ")").getBytes(), EventLogger.DEBUG_INFO);
+        }
+        
+        String[] rawList = execute("FETCH",
+                Integer.toString(firstIndex) + ":" +
+                Integer.toString(lastIndex) + " (FLAGS UID)", progressHandler);
+        
+        return prepareFetchFlagsResponse(rawList, progressHandler);
+    }
+
+    /**
+     * Execute the "UID FETCH (FLAGS UID)" command
+     * @param uidNext Unique ID of the next message
+     * @param progressHandler the progress handler
+     * @return Array of FetchFlagsResponse objects
+     */
+    public FetchFlagsResponse[] executeFetchFlagsUid(
+                int uidNext,
+            MailProgressHandler progressHandler) throws IOException, MailException {
+        if (EventLogger.getMinimumLevel() >= EventLogger.DEBUG_INFO) {
+            EventLogger.logEvent(AppInfo.GUID,
+                ("ImapProtocol.executeFetchFlagsUid(" + uidNext + ")").getBytes(),
+                EventLogger.DEBUG_INFO);
+        }
+        
+        String[] rawList = execute("UID FETCH",
+                Integer.toString(uidNext) + ":*" + " (FLAGS UID)", progressHandler);
+        
+        return prepareFetchFlagsResponse(rawList, progressHandler);
+    }
+    
+    private FetchFlagsResponse[] prepareFetchFlagsResponse(
+            String[] rawList, MailProgressHandler progressHandler) throws IOException, MailException {
+
+        if(progressHandler != null) { progressHandler.mailProgress(MailProgressHandler.TYPE_PROCESSING, 0, -1); }
+        // Preprocess the returned text to clean up mid-field line breaks
+        // This should all become unnecessary once execute()
+        // becomes more intelligent in how it handles replies
+        Vector rawList2 = prepareCleanFetchResponse(rawList);
+
+        Vector flagResponses = new Vector();
+        int size = rawList2.size();
+
+        if(progressHandler != null) { progressHandler.mailProgress(MailProgressHandler.TYPE_PROCESSING, 0, size); }
+        for (int i = 0; i < size; i++) {
+            try {
+                String rawText = (String) rawList2.elementAt(i);
+
+                Vector parsedText = null;
+
+                try {
+                    parsedText = StringParser.nestedParenStringLexer(rawText.substring(
+                                rawText.indexOf('(')));
+                } catch (Exception exp) {
+                    parsedText = null;
+                }
+
+                FetchFlagsResponse flagRespItem = new FetchFlagsResponse();
+                flagRespItem.flags = null;
+
+                // Iterate through results, locating and parsing the
+                // FLAGS and ENVELOPE sections in an order-independent way.
+                int parsedSize = parsedText.size();
+
+                for (int j = 0; j < parsedSize; j++) {
+                    if (parsedText.elementAt(j) instanceof String) {
+                        if (((String)parsedText.elementAt(j)).equals("FLAGS")
+                                        && (parsedSize > (j + 1))
+                                        && parsedText.elementAt(j + 1) instanceof Vector) {
+                            flagRespItem.flags = ImapParser.parseMessageFlags((Vector) parsedText.elementAt(j + 1));
+                        }
+                        else if (((String)parsedText.elementAt(j)).equals("UID")
+                                        && (parsedSize > (j + 1))
+                                        && parsedText.elementAt(j + 1) instanceof String) {
+                            try {
+                                flagRespItem.uid = Integer.parseInt((String) parsedText.elementAt(j + 1));
+                            } catch (NumberFormatException e) {
+                                flagRespItem.uid = -1;
+                            }
+                        }
+                    }
+                }
+
+                if (flagRespItem.flags == null) {
+                    flagRespItem.flags = new MessageFlags();
+                }
+
+                // Find the message index in the reply
+                int midx = Integer.parseInt(rawText.substring(rawText.indexOf(
+                                ' '), rawText.indexOf("FETCH") - 1).trim());
+
+                flagRespItem.index = midx;
+                flagResponses.addElement(flagRespItem);
+            } catch (Exception exp) {
+                System.err.println("Parse error: " + exp);
+            }
+            if(progressHandler != null) { progressHandler.mailProgress(MailProgressHandler.TYPE_PROCESSING, i, size); }
+        }
+
+        FetchFlagsResponse[] result = new FetchFlagsResponse[flagResponses.size()];
+        flagResponses.copyInto(result);
+        if(progressHandler != null) { progressHandler.mailProgress(MailProgressHandler.TYPE_PROCESSING, size, size); }
+
+        return result;
+    }
+    
+    /**
      * Execute the "FETCH (FLAGS UID ENVELOPE BODYSTRUCTURE)" command
      * @param firstIndex Index of the first message
      * @param lastIndex Index of the last message
+     * @param progressHandler the progress handler
      * @return Array of FetchEnvelopeResponse objects
      */
-    public FetchEnvelopeResponse[] executeFetchEnvelope(int firstIndex,
-        int lastIndex, MailProgressHandler progressHandler) throws IOException, MailException {
+    public FetchEnvelopeResponse[] executeFetchEnvelope(
+                int firstIndex,
+                int lastIndex,
+                MailProgressHandler progressHandler) throws IOException, MailException {
         if (EventLogger.getMinimumLevel() >= EventLogger.DEBUG_INFO) {
             EventLogger.logEvent(AppInfo.GUID,
@@ -465 +588 @@
      * Execute the "UID FETCH (FLAGS UID ENVELOPE BODYSTRUCTURE)" command
      * @param uidNext Unique ID of the next message
+     * @param progressHandler the progress handler
      * @return Array of FetchEnvelopeResponse objects
      */
@@ -480 +604 @@
         return prepareFetchEnvelopeResponse(rawList, progressHandler);
     }
+    
+    /**
+     * Execute the "UID FETCH (FLAGS UID ENVELOPE BODYSTRUCTURE)" command
+     * @param uids Set of unique IDs for the messages to fetch
+     * @param progressHandler the progress handler
+     * @return Array of FetchEnvelopeResponse objects
+     */
+    public FetchEnvelopeResponse[] executeFetchEnvelopeUid(int[] uids, MailProgressHandler progressHandler)
+        throws IOException, MailException {
+        if(uids.length == 0) { return new FetchEnvelopeResponse[0]; }
+        StringBuffer buf = new StringBuffer();
+        for(int i=0; i<uids.length - 1; i++) {
+                buf.append(uids[i]);
+                buf.append(',');
+        }
+        buf.append(uids[uids.length - 1]);
+        String uidList = buf.toString();
+        
+        if (EventLogger.getMinimumLevel() >= EventLogger.DEBUG_INFO) {
+            EventLogger.logEvent(AppInfo.GUID,
+                ("ImapProtocol.executeFetchEnvelopeUid(" + uidList + ")").getBytes(),
+                EventLogger.DEBUG_INFO);
+        }
+
+        String[] rawList = execute("UID FETCH",
+                        uidList + " (FLAGS UID ENVELOPE BODYSTRUCTURE)", progressHandler);
+
+        return prepareFetchEnvelopeResponse(rawList, progressHandler);
+    }
 
     private FetchEnvelopeResponse[] prepareFetchEnvelopeResponse(
         String[] rawList, MailProgressHandler progressHandler) throws IOException, MailException {
+
+        if(progressHandler != null) { progressHandler.mailProgress(MailProgressHandler.TYPE_PROCESSING, 0, -1); }
         // Preprocess the returned text to clean up mid-field line breaks
         // This should all become unnecessary once execute()
         // becomes more intelligent in how it handles replies
-        String line;
-        StringBuffer lineBuf = new StringBuffer();
-        Vector rawList2 = new Vector();
-
-        if(progressHandler != null) { progressHandler.mailProgress(MailProgressHandler.TYPE_PROCESSING, 0, -1); }
-        for (int i = 0; i < rawList.length; i++) {
-            line = rawList[i];
-
-            if ((line.length() > 0) && lineBuf.toString().startsWith("* ") &&
-                    line.startsWith("* ")) {
-                rawList2.addElement(lineBuf.toString());
-                lineBuf = new StringBuffer();
-            }
-
-            lineBuf.append(line);
-
-            if ((i == (rawList.length - 1)) &&
-                    lineBuf.toString().startsWith("* ")) {
-                rawList2.addElement(lineBuf.toString());
-            }
-        }
+        Vector rawList2 = prepareCleanFetchResponse(rawList);
 
         Vector envResponses = new Vector();
@@ -594 +729 @@
         return result;
     }
+    
+    private static Vector prepareCleanFetchResponse(String[] rawList) {
+        Vector cleanList = new Vector();
+        String line;
+        StringBuffer lineBuf = new StringBuffer();
+        for (int i = 0; i < rawList.length; i++) {
+            line = rawList[i];
+
+            if ((line.length() > 0) && lineBuf.toString().startsWith("* ") &&
+                    line.startsWith("* ")) {
+                cleanList.addElement(lineBuf.toString());
+                lineBuf = new StringBuffer();
+            }
+
+            lineBuf.append(line);
+
+            if ((i == (rawList.length - 1)) &&
+                    lineBuf.toString().startsWith("* ")) {
+                cleanList.addElement(lineBuf.toString());
+            }
+        }
+        return cleanList;
+    }
 
     /**
@@ -1137 +1295 @@
      * @param command IMAP command
      * @param arguments Arguments for the command
+     * @param progressHandler the progress handler
      * @return List of returned strings
      */
@@ -1351 +1510 @@
 
     /**
-     * Container for a FETCH (ENVELOPE) response
-     */
-    public static class FetchEnvelopeResponse {
+     * Container for a FETCH (FLAGS) response
+     */
+    public static class FetchFlagsResponse {
         public int index;
         public int uid;
         public MessageFlags flags;
+    }
+    
+    /**
+     * Container for a FETCH (ENVELOPE) response
+     */
+    public static class FetchEnvelopeResponse extends FetchFlagsResponse {
         public MessageEnvelope envelope;
         public ImapParser.MessageSection structure;

trunk/LogicMail/src/org/logicprobe/LogicMail/mail/pop/PopClient.java

@@ -335 +335 @@
      */
     public FolderMessage[] getFolderMessages(int firstIndex, int lastIndex, MailProgressHandler progressHandler) throws IOException, MailException {
-        FolderMessage[] folderMessages = new FolderMessage[(lastIndex - firstIndex)+1];
+        return getFolderMessages(firstIndex, lastIndex, false, progressHandler);
+    }
+    
+    private FolderMessage[] getFolderMessages(int firstIndex, int lastIndex, boolean flagsOnly, MailProgressHandler progressHandler) throws IOException, MailException {
+        int[] indices = new int[(lastIndex - firstIndex)+1];
+        for(int i=firstIndex; i<=lastIndex; i++) {
+                indices[i] = i;
+        }
+        
+        return getFolderMessagesImpl(indices, flagsOnly, progressHandler);
+    }
+
+        /* (non-Javadoc)
+         * @see org.logicprobe.LogicMail.mail.IncomingMailClient#getFolderMessages(org.logicprobe.LogicMail.mail.MessageToken[], org.logicprobe.LogicMail.mail.MailProgressHandler)
+         */
+        public FolderMessage[] getFolderMessages(MessageToken[] messageTokens, MailProgressHandler progressHandler)
+                        throws IOException, MailException {
+                // Since POP servers typically lock the mailbox while a client is connected,
+                // and given the typical use case of this method, we will make the assumption
+                // that the message indices in the provided tokens exactly match the messages
+                // we want to retrieve headers for.
+                
+                int[] indices = new int[messageTokens.length];
+                for(int i=0; i<messageTokens.length; i++) {
+                        indices[i] = ((PopMessageToken)messageTokens[i]).getMessageIndex();
+                }
+                
+                return getFolderMessagesImpl(indices, false, progressHandler);
+        }
+
+    private FolderMessage[] getFolderMessagesImpl(int[] indices, boolean flagsOnly, MailProgressHandler progressHandler)
+                throws IOException, MailException {
+        FolderMessage[] folderMessages = new FolderMessage[indices.length];
         int index = 0;
         String[] headerText;
@@ -342 +374 @@
         int preCount;
         int postCount = connection.getBytesReceived();
-        for(int i=firstIndex; i<=lastIndex; i++) {
+        for(int i=0; i<indices.length; i++) {
                 preCount = postCount;
-            headerText = popProtocol.executeTop(i, 0);
-            uid = popProtocol.executeUidl(i);
-            env = MailMessageParser.parseMessageEnvelope(headerText);
+            if(!flagsOnly) {
+                headerText = popProtocol.executeTop(indices[i], 0);
+                env = MailMessageParser.parseMessageEnvelope(headerText);
+                }
+            else {
+                env = null;
+            }
+            uid = popProtocol.executeUidl(indices[i]);
             folderMessages[index++] = new FolderMessage(
-                        new PopMessageToken(i, uid),
-                        env, i, uid.hashCode());
+                        new PopMessageToken(indices[i], uid),
+                        env, indices[i], uid.hashCode());
             postCount = connection.getBytesReceived();
             if(progressHandler != null) { progressHandler.mailProgress(MailProgressHandler.TYPE_NETWORK, (postCount - preCount), -1); }
@@ -355 +392 @@
         return folderMessages;
     }
-
-    /* (non-Javadoc)
-     * @see org.logicprobe.LogicMail.mail.IncomingMailClient#getNewFolderMessages(org.logicprobe.LogicMail.mail.MailProgressHandler)
-     */
-    public FolderMessage[] getNewFolderMessages(MailProgressHandler progressHandler) throws IOException, MailException {
+    
+    /* (non-Javadoc)
+     * @see org.logicprobe.LogicMail.mail.IncomingMailClient#getNewFolderMessages(boolean, org.logicprobe.LogicMail.mail.MailProgressHandler)
+     */
+    public FolderMessage[] getNewFolderMessages(boolean flagsOnly, MailProgressHandler progressHandler) throws IOException, MailException {
         int count = MailSettings.getInstance().getGlobalConfig().getRetMsgCount();
                 int msgCount = activeMailbox.getMsgCount();
         int firstIndex = Math.max(1, msgCount - count);
-        return getFolderMessages(firstIndex, activeMailbox.getMsgCount(), progressHandler);
+        return getFolderMessages(firstIndex, activeMailbox.getMsgCount(), flagsOnly, progressHandler);
     }
 

trunk/LogicMail/src/org/logicprobe/LogicMail/mail/pop/PopMessageToken.java

@@ -109 +109 @@
      * @return POP unique ID
      */
-    String getMessageUid() {
+    public String getMessageUid() {
         return this.messageUid;
     }
@@ -160 +160 @@
                 return hashCode;
         }
+        
+        /* (non-Javadoc)
+         * @see java.lang.Object#toString()
+         */
+        public String toString() {
+                StringBuffer buf = new StringBuffer();
+                buf.append("PopMessageToken [");
+                buf.append("uniqueId="); buf.append(uniqueId);
+                buf.append(", messageIndex="); buf.append(messageIndex);
+                buf.append(", messageUid=\""); buf.append(messageUid); buf.append("\"");
+                buf.append("]");
+                return buf.toString();
+        }
 }

trunk/LogicMail/src/org/logicprobe/LogicMail/model/AccountNode.java

@@ -572 +572 @@
 
             MailboxNode mailboxNode = (MailboxNode) pathMailboxMap.get(e.getFolder().getPath());
-
-            // Determine what MessageNodes need to be created, and add them.
             FolderMessage[] folderMessages = e.getMessages();
-            Vector addedMessages = new Vector();
-
-            for (int i = 0; i < folderMessages.length; i++) {
-                addedMessages.addElement(new MessageNode(folderMessages[i]));
-            }
-
-            MessageNode[] addedMessagesArray = new MessageNode[addedMessages.size()];
-            addedMessages.copyInto(addedMessagesArray);
-            mailboxNode.addMessages(addedMessagesArray);
+
+            if(e.isFlagsOnly()) {
+                // Only flags have been retrieved, so the existing messages need to
+                // be checked and additional actions requested accordingly.
+                //TODO: Implement flags-only logic
+                Vector messagesToFetch = null;
+                    for (int i = 0; i < folderMessages.length; i++) {
+                        MessageNode messageNode =
+                                mailboxNode.getMessageByToken(folderMessages[i].getMessageToken());
+                        if(messageNode != null) {
+                                messageNode.setFlags(MessageNode.convertMessageFlags(folderMessages[i].getFlags()));
+                        }
+                        else {
+                                if(messagesToFetch == null) { messagesToFetch = new Vector(); }
+                                messagesToFetch.addElement(folderMessages[i].getMessageToken());
+                                System.err.println("-->Need to fetch: " + folderMessages[i].getMessageToken());
+                        }
+                    }
+                    if(messagesToFetch != null) {
+                        MessageToken[] fetchArray = new MessageToken[messagesToFetch.size()];
+                        messagesToFetch.copyInto(fetchArray);
+                        mailStore.requestFolderMessagesSet(e.getFolder(), fetchArray);
+                    }
+            }
+            else {
+                    // Determine what MessageNodes need to be created, and add them.
+                    Vector addedMessages = new Vector();
+        
+                    for (int i = 0; i < folderMessages.length; i++) {
+                        addedMessages.addElement(new MessageNode(folderMessages[i]));
+                    }
+        
+                    MessageNode[] addedMessagesArray = new MessageNode[addedMessages.size()];
+                    addedMessages.copyInto(addedMessagesArray);
+                    mailboxNode.addMessages(addedMessagesArray);
+            }
         }
     }

trunk/LogicMail/src/org/logicprobe/LogicMail/model/MailboxNode.java

@@ -37 +37 @@
 import java.util.Vector;
 
+import net.rim.device.api.system.EventLogger;
 import net.rim.device.api.util.Comparator;
 import net.rim.device.api.util.SimpleSortingVector;
 
+import org.logicprobe.LogicMail.AppInfo;
 import org.logicprobe.LogicMail.mail.FolderTreeItem;
 import org.logicprobe.LogicMail.mail.MessageToken;
@@ -501 +503 @@
                         messageMap.put(message, message);
                         messageTokenMap.put(message.getMessageToken(), message);
+                        if(!message.isCached() && message.isCachable()) {
+                                try {
+                                        MailFileManager.getInstance().writeMessage(message);
+                                        message.setCached(true);
+                                } catch (IOException e) {
+                                        System.err.println("-->Unable to write message: " + e.getMessage());
+                                        e.printStackTrace();
+                                } catch (Throwable t) {
+                                        System.err.println("-->Unable to write message: " + t.getMessage());
+                                        t.printStackTrace();
+                                }
+                        }
                         return true;
                 }
@@ -689 +703 @@
      */
     public void refreshMessages() {
-        parentAccount.getMailStore().requestFolderMessagesRecent(this.folderTreeItem);
+        // Fetch messages stored in the cache
+        if(parentAccount.getAccountConfig() != null) {
+                //TODO: Make this thread-safe and prevent redundant calls
+                Thread fetchThread = new Thread() {
+                        public void run() {
+                                try {
+                                        MessageNode[] messages =
+                                                MailFileManager.getInstance().readMessageNodes(MailboxNode.this);
+                                        MailboxNode.this.addMessages(messages);
+                                } catch (IOException e) {
+                                        EventLogger.logEvent(AppInfo.GUID,
+                                        ("Unable to read messages from cache\r\n"
+                                                + e.getMessage()).getBytes(),
+                                        EventLogger.ERROR);
+                                }
+                                
+                        // Request flags and tokens for recent messages from the mail store
+                        parentAccount.getMailStore().requestFolderMessagesRecent(folderTreeItem, true);
+                        }
+                };
+                fetchThread.start();
+        }
+        else {
+                parentAccount.getMailStore().requestFolderMessagesRecent(this.folderTreeItem);
+        }
     }
     

trunk/LogicMail/src/org/logicprobe/LogicMail/model/MessageNode.java

@@ -124 +124 @@
         /** Hash code used to verify uniqueness of message nodes */
         private int hashCode = -1;
+        /** True if the message is up-to-date in the cache */
+        private boolean cached;
         /** Bit-field set of message flags. */
         private int flags;
@@ -247 +249 @@
         }
         
+        /**
+         * Checks if the message is up-to-date in the cache.
+         * 
+         * @return true, if the message is cached
+         */
+        boolean isCached() {
+                return this.cached;
+        }
+        
+        /**
+         * Checks if the message is capable of being cached.
+         * 
+         * @return true, if the message is associated with a mailbox from a non-local account
+         */
+        boolean isCachable() {
+                if(parent != null
+                                && parent.getParentAccount() != null
+                                && parent.getParentAccount().getAccountConfig() != null) {
+                        return true;
+                }
+                else {
+                        return false;
+                }
+        }
+        
+        /**
+         * Sets whether the message is up-to-date in the cache.
+         * 
+         * @param cached the new cached state
+         */
+        void setCached(boolean cached) {
+                this.cached = cached;
+        }
+        
         /* (non-Javadoc)
          * @see org.logicprobe.LogicMail.model.Node#accept(org.logicprobe.LogicMail.model.NodeVisitor)
@@ -287 +323 @@
          */
         protected void setMessageToken(MessageToken messageToken) {
+                cached = false;
                 this.messageToken = messageToken;
         }
@@ -305 +342 @@
          */
         public void setFlags(int flags) {
+                cached = false;
                 this.flags = flags;
         }
@@ -323 +361 @@
          */
         public void setDate(Date date) {
+                cached = false;
                 this.date = date;
         }
@@ -341 +380 @@
          */
         public void setSubject(String subject) {
+                cached = false;
                 this.subject = subject;
         }
@@ -359 +399 @@
          */
         public void setFrom(Address[] from) {
+                cached = false;
                 this.from = from;
         }
@@ -377 +418 @@
          */
         public void setSender(Address[] sender) {
+                cached = false;
                 this.sender = sender;
         }
@@ -395 +437 @@
          */
         public void setReplyTo(Address[] replyTo) {
+                cached = false;
                 this.replyTo = replyTo;
         }
@@ -413 +456 @@
          */
         public void setTo(Address[] to) {
+                cached = false;
                 this.to = to;
         }
@@ -431 +475 @@
          */
         public void setCc(Address[] cc) {
+                cached = false;
                 this.cc = cc;
         }
@@ -449 +494 @@
          */
         public void setBcc(Address[] bcc) {
+                cached = false;
                 this.bcc = bcc;
         }
@@ -467 +513 @@
          */
         public void setInReplyTo(String inReplyTo) {
+                cached = false;
                 this.inReplyTo = inReplyTo;
         }
@@ -485 +532 @@
          */
         public void setMessageId(String messageId) {
+                cached = false;
                 this.messageId = messageId;
         }
@@ -496 +544 @@
                 boolean fireEvent;
                 synchronized(messageContent) {
+                        cached = false;
                         this.messageStructure = messageStructure;
                         if(this.messageStructure != null) {
@@ -519 +568 @@
         void putMessageContent(MimeMessageContent mimeMessageContent) {
                 synchronized(mimeMessageContent) {
+                        cached = false;
                         this.messageContent.put(mimeMessageContent.getMessagePart(), mimeMessageContent);
                 }
@@ -535 +585 @@
         void putMessageContent(MimeMessageContent[] messageContent) {
                 synchronized(messageContent) {
+                        cached = false;
                         for(int i=0; i<messageContent.length; i++) {
                                 this.messageContent.put(messageContent[i].getMessagePart(), messageContent[i]);
@@ -979 +1030 @@
      */
         public boolean refreshMessage() {
+                // TODO: Add code to refresh message from cache first
                 boolean result = false;
                 if(!refreshInProgress) {

trunk/LogicMail/src/org/logicprobe/LogicMail/model/MessageNodeReader.java

@@ -36 +36 @@
 import java.util.Hashtable;
 
+import org.logicprobe.LogicMail.AppInfo;
 import org.logicprobe.LogicMail.mail.MessageToken;
 import org.logicprobe.LogicMail.message.MimeMessageContent;
@@ -41 +42 @@
 import org.logicprobe.LogicMail.util.SerializationUtils;
 
+import net.rim.device.api.system.EventLogger;
 import net.rim.device.api.util.Arrays;
 import net.rim.device.api.util.CRC32;
 
+/**
+ * Reads in <tt>MessageNode</tt> objects from an input stream.
+ * <p>
+ * Allows for separate reading of header information and content,
+ * to facilitate partial loading of cached messages.
+ * The specific data format is described in detail within
+ * {@link MessageNodeWriter}.
+ * </p>
+ */
 public class MessageNodeReader {
         private DataInputStream input;
@@ -54 +65 @@
         };
         
+        /**
+         * Instantiates a new message node reader.
+         * 
+         * @param input the input
+         */
         public MessageNodeReader(DataInputStream input) {
                 this.input = input;
@@ -124 +140 @@
         }
         
+        /**
+         * Checks if more content is available for reading.
+         * 
+         * @return true, if content is available
+         */
         public boolean isContentAvailable() {
                 if(!headerParsed) { throw new IllegalStateException(); }
@@ -129 +150 @@
         }
         
+        /**
+         * Gets the next content section of the message.
+         * 
+         * @return the next content section
+         * 
+         * @throws IOException Signals that an I/O exception has occurred.
+         */
         public MimeMessageContent getNextContent() throws IOException {
                 if(!headerParsed || contentCount == 0) { throw new IllegalStateException(); }
-                System.err.println("-->getNextContent(): contentCount=" + contentCount + ", available=" + input.available());
+                if (EventLogger.getMinimumLevel() >= EventLogger.DEBUG_INFO) {
+                        EventLogger.logEvent(AppInfo.GUID,
+                ("MessageNodeReader.getNextContent()\r\n"
+                        + "contentCount=" + contentCount
+                        + ", available=" + input.available()).getBytes(),
+                EventLogger.DEBUG_INFO);
+        }
+                
                 contentCount--;
                 
@@ -144 +179 @@
                 
                 if(storedChecksum != checksum) {
-                        System.err.println("-->Content checksum mismatch");
+                        EventLogger.logEvent(AppInfo.GUID,
+                ("MessageNodeReader.getNextContent()\r\nContent checksum mismatch").getBytes(),
+                EventLogger.ERROR);
                         return null;
                 }
@@ -153 +190 @@
                 }
                 else {
-                        System.err.println("-->Content deserialization error");
+                        EventLogger.logEvent(AppInfo.GUID,
+                ("MessageNodeReader.getNextContent()\r\nContent deserialization error").getBytes(),
+                EventLogger.ERROR);
                         return null;
                 }
@@ -161 +200 @@
                 // Validate the header start text
                 if(!Arrays.equals(fileHeader, 0, headerStart, 0, headerStart.length)) {
-                        System.err.println("-->Header start mismatch");
+                        EventLogger.logEvent(AppInfo.GUID,
+                ("MessageNodeReader.validateHeader()\r\nHeader start mismatch").getBytes(),
+                EventLogger.ERROR);
                         return false;
                 }
@@ -171 +212 @@
                 int checksum = CRC32.update(CRC32.INITIAL_VALUE, headerCopy);
                 if(headerChecksum != checksum) {
-                        System.err.println("-->Header checksum mismatch");
+                        EventLogger.logEvent(AppInfo.GUID,
+                ("MessageNodeReader.validateHeader()\r\nHeader checksum mismatch").getBytes(),
+                EventLogger.ERROR);
                         return false;
                 }

trunk/LogicMail/src/org/logicprobe/LogicMail/model/MessageNodeWriter.java

@@ -97 +97 @@
         };
         
+        /**
+         * Instantiates a new message node writer.
+         * 
+         * @param output the output stream
+         */
         public MessageNodeWriter(DataOutputStream output) {
                 this.output = output;
         }
         
+        /**
+         * Write a complete message node to the output stream.
+         * 
+         * @param messageNode the message node
+         * 
+         * @throws IOException Signals that an I/O exception has occurred.
+         */
         public void write(MessageNode messageNode) throws IOException {
                 byte[] messageToken = generateMessageToken(messageNode);

trunk/LogicMail/src/org/logicprobe/LogicMail/model/OutboxMailboxNode.java

@@ -223 +223 @@
                 }
 
+                public String getMessageUid() {
+                        return Integer.toHexString(messageId).toLowerCase();
+                }
+                
                 public long getUniqueId() {
                         // Empty because this special token is not intended to be serialized