Changeset 532

Timestamp:

11/09/09 23:56:19 (2 years ago)

Author:

octorian

Message:

Initial support for caching messages, and structure/content equals() and hashCode() implementations

Location:

trunk/LogicMail/src/org/logicprobe/LogicMail

Files:

• message/MimeMessageContent.java (modified) (1 diff)
• message/MimeMessagePart.java (modified) (1 diff)
• model/AccountNode.java (modified) (1 diff)
• model/MailFileManager.java (modified) (3 diffs)
• model/MailboxNode.java (modified) (1 diff)
• model/MessageNode.java (modified) (4 diffs)

trunk/LogicMail/src/org/logicprobe/LogicMail/message/MimeMessageContent.java

@@ -121 +121 @@
                 putRawData(data);
         }
+
+        /* (non-Javadoc)
+         * @see java.lang.Object#hashCode()
+         */
+        public int hashCode() {
+                final int prime = 31;
+                int result = 1;
+                result = prime * result + (int) (uniqueId ^ (uniqueId >>> 32));
+                return result;
+        }
+
+        /* (non-Javadoc)
+         * @see java.lang.Object#equals(java.lang.Object)
+         */
+        public boolean equals(Object obj) {
+                if (this == obj)
+                        return true;
+                if (obj == null)
+                        return false;
+                if (getClass() != obj.getClass())
+                        return false;
+                MimeMessageContent other = (MimeMessageContent) obj;
+                if (uniqueId != other.uniqueId)
+                        return false;
+                return true;
+        }
 }

trunk/LogicMail/src/org/logicprobe/LogicMail/message/MimeMessagePart.java

@@ -144 +144 @@
                 size = input.readInt();
         }
+
+        /* (non-Javadoc)
+         * @see java.lang.Object#hashCode()
+         */
+        public int hashCode() {
+                final int prime = 31;
+                int result = 1;
+                result = prime * result + (int) (uniqueId ^ (uniqueId >>> 32));
+                return result;
+        }
+
+        /* (non-Javadoc)
+         * @see java.lang.Object#equals(java.lang.Object)
+         */
+        public boolean equals(Object obj) {
+                if (this == obj)
+                        return true;
+                if (obj == null)
+                        return false;
+                if (getClass() != obj.getClass())
+                        return false;
+                MimeMessagePart other = (MimeMessagePart) obj;
+                if (uniqueId != other.uniqueId)
+                        return false;
+                return true;
+        }
 }

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

@@ -626 +626 @@
                 messageNode.setMessageSource(e.getMessageSource());
                 messageNode.putMessageContent(e.getMessageContent());
+                messageNode.commitMessage();
                 break;
                 case MessageEvent.TYPE_CONTENT_LOADED:
                 messageNode.putMessageContent(e.getMessageContent());
+                messageNode.commitMessage();
                 break;
                 }

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

@@ -47 +47 @@
 import org.logicprobe.LogicMail.conf.MailSettingsListener;
 import org.logicprobe.LogicMail.mail.MessageToken;
+import org.logicprobe.LogicMail.message.MimeMessageContent;
 
 /**
@@ -209 +210 @@
         }
         
+        public MessageNode readMessageNode(MailboxNode mailboxNode, MessageToken messageToken, boolean loadContent) throws IOException {
+                FileConnection fileConnection = getMailboxFileConnection(mailboxNode);
+                if(!fileConnection.exists()) { return null; }
+                
+                String mailboxUrl = fileConnection.getURL();
+                fileConnection.close();
+                String fileUrl =
+                                mailboxUrl
+                                + messageToken.getMessageUid()
+                                + MSG_SUFFIX;
+                MessageNode messageNode = readMessageNode(fileUrl);
+                if(loadContent) {
+                        MimeMessageContent[] content = readMessageContent(mailboxNode, messageToken);
+                        messageNode.putMessageContent(content);
+                }
+                return messageNode;
+        }
+        
+        public MimeMessageContent[] readMessageContent(MailboxNode mailboxNode, MessageToken messageToken) throws IOException {
+                FileConnection fileConnection = getMailboxFileConnection(mailboxNode);
+                if(!fileConnection.exists()) { return null; }
+                
+                String mailboxUrl = fileConnection.getURL();
+                fileConnection.close();
+                String fileUrl =
+                                mailboxUrl
+                                + messageToken.getMessageUid()
+                                + MSG_SUFFIX;
+                MimeMessageContent[] messageContent = readMessageContent(fileUrl, messageToken);
+                
+                return messageContent;
+        }
+        
         private FileConnection getMailboxFileConnection(MailboxNode mailboxNode) throws IOException {
                 // Build the account and mailbox UID strings
@@ -283 +317 @@
                 return result;
         }
+        
+        private MimeMessageContent[] readMessageContent(String fileUrl, MessageToken messageToken) {
+                FileConnection fileConnection = null;
+                Vector content = new Vector();
+                try {
+                        fileConnection = (FileConnection)Connector.open(fileUrl);
+                        DataInputStream input = fileConnection.openDataInputStream();
+                        MessageNodeReader reader = new MessageNodeReader(input);
+                        MessageToken tempToken = reader.read();
+                        if(messageToken.equals(tempToken)) {
+                                while(reader.isContentAvailable()) {
+                                        content.addElement(reader.getNextContent());
+                                }
+                        }
+                        input.close();
+                        fileConnection.close();
+                } catch (Exception e) {
+                        EventLogger.logEvent(AppInfo.GUID,
+                        ("Unable to read content: " + fileUrl
+                                + "\r\n" + e.getMessage()).getBytes(),
+                        EventLogger.ERROR);
+                } finally {
+                        if(fileConnection != null) {
+                                try { fileConnection.close(); } catch (Exception e) { }
+                        }
+                }
+                MimeMessageContent[] result = new MimeMessageContent[content.size()];
+                content.copyInto(result);
+                return result;
+        }
 }

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

@@ -503 +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();
-                                }
-                        }
+                        message.commitMessage();
                         return true;
                 }

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

@@ -31 +31 @@
 package org.logicprobe.LogicMail.model;
 
+import java.io.IOException;
 import java.util.Date;
 import java.util.Enumeration;
@@ -36 +37 @@
 import java.util.Vector;
 
+import net.rim.device.api.system.EventLogger;
 import net.rim.device.api.util.Arrays;
 import net.rim.device.api.util.Comparator;
@@ -591 +593 @@
                 }
                 fireMessageStatusChanged(MessageNodeEvent.TYPE_CONTENT_LOADED);
+        }
+        
+        /**
+         * Commits the current state of the message to the cache, if applicable.
+         * 
+         * @return True if written to cache, false otherwise
+         */
+        boolean commitMessage() {
+                boolean result = false;
+                synchronized(messageContent) {
+                        if(!isCached() && isCachable()) {
+                                try {
+                                        MailFileManager.getInstance().writeMessage(this);
+                                        setCached(true);
+                                        result = true;
+                                } catch (IOException e) {
+                                        System.err.println("-->Unable to write message: " + e.getMessage());
+                                } catch (Throwable t) {
+                                        System.err.println("-->Unable to write message: " + t.getMessage());
+                                }
+                        }
+                }
+                return result;
         }
         
@@ -1057 +1082 @@
                                         displayableParts = new MimeMessagePart[partsToFetch.size()];
                                         partsToFetch.copyInto(displayableParts);
-                                        mailStore.requestMessageParts(messageToken, displayableParts);
+                                        (new Thread(new RefreshMessagePartsRunnable(displayableParts))).start();
                                         result = true;
                                 }
                         }
                         else {
+                                (new Thread(new RefreshMessageWholeRunnable())).start();
+                                result = true;
+                        }
+                }
+                return result;
+        }
+
+        private class RefreshMessageWholeRunnable implements Runnable {
+                public void run() {
+                        boolean messageLoaded = false;
+                        try {
+                                MessageNode tempNode = MailFileManager.getInstance().readMessageNode(parent, messageToken, true);
+                                if(tempNode != null) {
+                                        setMessageStructure(tempNode.getMessageStructure());
+                                        setMessageSource(tempNode.getMessageSource());
+                                        putMessageContent(tempNode.getAllMessageContent());
+                                        messageLoaded = true;
+                                }
+                        } catch (IOException e) {
+                                EventLogger.logEvent(AppInfo.GUID,
+                                ("Unable to read message from cache\r\n"
+                                        + e.getMessage()).getBytes(),
+                                EventLogger.ERROR);
+                        }
+                        
+                        if(!messageLoaded) {
+                                AbstractMailStore mailStore = parent.getParentAccount().getMailStore();
                                 mailStore.requestMessage(messageToken);
-                                result = true;
-                        }
-                }
-                return result;
+                        }
+                }
+        };
+
+        private class RefreshMessagePartsRunnable implements Runnable {
+                private MimeMessagePart[] displayableParts;
+                RefreshMessagePartsRunnable(MimeMessagePart[] displayableParts) {
+                        this.displayableParts = displayableParts;
+                }
+                public void run() {
+                        Vector contentToLoad = new Vector(displayableParts.length);
+                        for(int i=0; i<displayableParts.length; i++) {
+                                contentToLoad.addElement(displayableParts[i]);
+                        }
+                        
+                        try {
+                                MimeMessageContent[] content = MailFileManager.getInstance().readMessageContent(parent, messageToken);
+                                if(content != null) {
+                                        putMessageContent(content);
+                                        for(int i=0; i<content.length; i++) {
+                                                contentToLoad.removeElement(content[i].getMessagePart());
+                                        }
+                                }
+                        } catch (IOException e) {
+                                EventLogger.logEvent(AppInfo.GUID,
+                                ("Unable to read message from cache\r\n"
+                                        + e.getMessage()).getBytes(),
+                                EventLogger.ERROR);
+                        }
+                        
+                        if(!contentToLoad.isEmpty()) {
+                                MimeMessagePart[] partsToLoad = new MimeMessagePart[contentToLoad.size()];
+                                contentToLoad.copyInto(partsToLoad);
+                                AbstractMailStore mailStore = parent.getParentAccount().getMailStore();
+                                mailStore.requestMessageParts(messageToken, partsToLoad);
+                        }
+                }
         }