Changeset 693 for trunk/LogicMail/src/org/logicprobe

Timestamp:

08/22/10 14:10:19 (18 months ago)

Author:

octorian

Message:

Made cache loading and flags refresh happen simultaneously. Still need to work cache-file cleanup.

Location:

trunk/LogicMail/src/org/logicprobe/LogicMail

Files:

• model/AccountNode.java (modified) (1 diff)
• model/MailFileManager.java (modified) (1 diff)
• model/MailboxNode.java (modified) (11 diffs)
• model/MessageNodeCallback.java (modified) (1 diff)
• model/OutboxMailboxNode.java (modified) (1 diff)
• ui/MailHomeScreen.java (modified) (1 diff)

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

@@ -610 +610 @@
                 // Only flags have been retrieved, so the existing messages need to
                 // be checked and additional actions requested accordingly.
-                //TODO: Implement flags-only logic
                     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()));
-                                
-                                // Update the token based on the token that came along
-                                // with the flags.  This will update any volatile state
-                                // information, such as POP message indices
-                                messageNode.getMessageToken().updateToken(folderMessages[i].getMessageToken());
-                                messageNode.setExistsOnServer(true);
-                        }
-                        else {
-                            synchronized(folderMessagesToFetch) {
-                                Vector messagesToFetch = (Vector)folderMessagesToFetch.get(e.getFolder());
-                                if(messagesToFetch == null) {
-                                    messagesToFetch = new Vector();
-                                    folderMessagesToFetch.put(e.getFolder(), messagesToFetch);
-                                }
-                                messagesToFetch.addElement(folderMessages[i].getMessageToken());
-                            }
-                        }
+                        if(!mailboxNode.updateMessageFlags(folderMessages[i].getMessageToken(), folderMessages[i].getFlags())) {
+                        // Message does not currently exist in the mailbox, and
+                        // is not in the process of being loaded from cache.
+                        synchronized(folderMessagesToFetch) {
+                            Vector messagesToFetch = (Vector)folderMessagesToFetch.get(e.getFolder());
+                            if(messagesToFetch == null) {
+                                messagesToFetch = new Vector();
+                                folderMessagesToFetch.put(e.getFolder(), messagesToFetch);
+                            }
+                            messagesToFetch.addElement(folderMessages[i].getMessageToken());
+                        }
+                        }
                     }
             }

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

@@ -232 +232 @@
         
         String[] fileUrls = getMessageFiles(mailboxNode);
+        Vector fileUrlsToLoad = new Vector(fileUrls.length);
         for(int i=0; i<fileUrls.length; i++) {
-            MessageNode messageNode = readMessageNode(fileUrls[i]);
+            int p = fileUrls[i].lastIndexOf('/');
+            int q = fileUrls[i].lastIndexOf('.');
+            if(p != -1 && q != -1 && p < q) {
+                String messageUid = fileUrls[i].substring(p + 1, q);
+                if(callback.messageNodeAvailable(messageUid)) {
+                    fileUrlsToLoad.addElement(fileUrls[i]);
+                }
+            }
+        }
+        
+        int size = fileUrlsToLoad.size();
+        for(int i=0; i<size; i++) {
+            MessageNode messageNode = readMessageNode((String)fileUrlsToLoad.elementAt(i));
             if(messageNode != null) {
                 if(loadContent) {

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

@@ -69 +69 @@
         private Hashtable messageMap;
         private Hashtable messageTokenMap;
+        private Hashtable messageTokenUidSet;
         private EventListenerList listenerList = new EventListenerList();
         private int type;
@@ -75 +76 @@
         private int unseenMessageCount;
     private Vector pendingExpungeMessages = new Vector();
+    
+    private Hashtable messagesBeingLoaded = new Hashtable();
+    private Hashtable unappliedFlagUpdates = new Hashtable();
     
     /**
@@ -144 +148 @@
                 this.messageMap = new Hashtable();
                 this.messageTokenMap = new Hashtable();
+                this.messageTokenUidSet = new Hashtable();
                 if(folderTreeItem != null) {
                         this.setFolderTreeItem(new FolderTreeItem(folderTreeItem));
@@ -539 +544 @@
                 boolean messageAdded;
                 synchronized(messages) {
+                    messagesBeingLoaded.remove(message.getMessageToken().getMessageUid());
                         messageAdded = addMessageImpl(message);
                 }
@@ -587 +593 @@
                         messageMap.put(message, message);
                         messageTokenMap.put(message.getMessageToken(), message);
+                        messageTokenUidSet.put(message.getMessageToken().getMessageUid(), Boolean.TRUE);
+                        
+                        Object[] element = (Object[])unappliedFlagUpdates.remove(
+                                message.getMessageToken().getMessageUid());
+                        if(element != null) {
+                            MessageToken messageToken = (MessageToken)element[0];
+                            MessageFlags messageFlags = (MessageFlags)element[1];
+                // Message already exists in the mailbox, and just needs
+                // its flags updated.
+                            message.setFlags(MessageNode.convertMessageFlags(messageFlags));
+
+                // Update the token based on the token that came along
+                // with the flags.  This will update any volatile state
+                // information, such as POP message indices
+                            message.getMessageToken().updateToken(messageToken);
+                            message.setExistsOnServer(true);
+                        }
                         message.commitMessage();
                         return true;
@@ -607 +630 @@
                                 messageMap.remove(message);
                                 messageTokenMap.remove(message.getMessageToken());
+                                messageTokenUidSet.remove(message.getMessageToken().getMessageUid());
                         }
                 }
@@ -641 +665 @@
                 messageMap.remove(messageNode);
                 messageTokenMap.remove(messageNode.getMessageToken());
+                messageTokenUidSet.remove(messageNode.getMessageToken().getMessageUid());
                 tokensToRemove[i] = messageNode.getMessageToken();
                 removedMessageNodes[i] = messageNode;
@@ -674 +699 @@
 
     /**
+     * Attempt to update the flags for a message within this mailbox.
+     * If the <code>MessageNode</code> for the token already exists within
+     * the mailbox, its flags will be updated.  If it does not exist, but is in
+     * the process of being loaded from cache, the flag change will be saved
+     * and applied as the message load completes.  If the message neither
+     * exists nor is being loaded, false will be returned.
+     *
+     * @param messageToken the message token
+     * @param messageFlags the flags to update
+     * @return true, if the update was applied or saved
+     */
+    boolean updateMessageFlags(MessageToken messageToken, MessageFlags messageFlags) {
+        boolean result = false;
+        synchronized(messages) {
+            if(messagesBeingLoaded.containsKey(messageToken.getMessageUid())) {
+                unappliedFlagUpdates.put(messageToken.getMessageUid(), new Object[] { messageToken, messageFlags });
+                result = true;
+            }
+            else {
+                MessageNode messageNode = (MessageNode)messageTokenMap.get(messageToken);
+                if(messageNode != null) {
+                    // Message already exists in the mailbox, and just needs
+                    // its flags updated.
+                    messageNode.setFlags(MessageNode.convertMessageFlags(messageFlags));
+
+                    // Update the token based on the token that came along
+                    // with the flags.  This will update any volatile state
+                    // information, such as POP message indices
+                    messageNode.getMessageToken().updateToken(messageToken);
+                    messageNode.setExistsOnServer(true);
+
+                    result = true;
+                }
+            }
+        }
+        return result;
+    }
+    
+    /**
      * Called when the mail store notifies of a completed expunge operation on
      * this folder, so anything we expected to be expunged can be cleaned out.
@@ -702 +766 @@
                         messageMap.clear();
                         messageTokenMap.clear();
+                        messageTokenUidSet.clear();
                 }
         updateUnseenMessages(false);
@@ -932 +997 @@
             if(parentAccount.getAccountConfig() != null) {
                 if(fetchThread == null || !fetchThread.isAlive()) {
+                    // Request flags and tokens for recent messages from the mail store
+                    parentAccount.getMailStore().requestFolderMessagesRecent(
+                            folderTreeItem,
+                            fetchFlagsOnly,
+                            new MailStoreRequestCallback() {
+                                public void mailStoreRequestComplete() {
+                                    synchronized(fetchLock) {
+                                        fetchFlagsOnly = false;
+                                    }
+                                }
+                                public void mailStoreRequestFailed(Throwable exception) { }
+                            });
+                    
+                    // Start the cache loading process
                     fetchThread = new RefreshMessagesThread();
                     fetchThread.start();
@@ -959 +1038 @@
         }
 
+        public boolean messageNodeAvailable(String messageUid) {
+            boolean result;
+            synchronized(messages) {
+                if(messageTokenUidSet.containsKey(messageUid)) {
+                    result = false;
+                }
+                else {
+                    messagesBeingLoaded.put(messageUid, Boolean.TRUE);
+                    result = true;
+                }
+            }
+            return result;
+        }
+
         public void messageNodeUpdated(MessageNode messageNode) {
             if(messageNode != null) {
+                // If the initial flags fetch is complete, then ignore all
+                // nodes loaded from cache that don't have pending flag updates.
+                synchronized(fetchLock) {
+                    if(!fetchFlagsOnly) {
+                        synchronized(messages) {
+                            if(!unappliedFlagUpdates.containsKey(messageNode.getMessageToken().getMessageUid())) {
+                                return;
+                            }
+                        }
+                    }
+                }
                 MailboxNode.this.addMessage(messageNode);
             }
-            else {
-                // Request flags and tokens for recent messages from the mail store
-                parentAccount.getMailStore().requestFolderMessagesRecent(
-                        folderTreeItem,
-                        fetchFlagsOnly,
-                        new MailStoreRequestCallback() {
-                            public void mailStoreRequestComplete() {
-                                synchronized(fetchLock) {
-                                    fetchFlagsOnly = false;
-                                }
-                            }
-                            public void mailStoreRequestFailed(Throwable exception) { }
-                        });
-            }
-        }        
+        }
     }
     

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

@@ -38 +38 @@
 public interface MessageNodeCallback {
     /**
+     * Called when a <code>MessageNode</code> is about to be loaded, to check
+     * whether or not to proceed with the load operation.
+     * Since this is expected to be called from <code>MailFileManager</code>
+     * prior to actually loading message data, only the filename-based UID can
+     * be provided.
+     * 
+     * @param messageUid the string-form UID for the message to be loaded
+     * @return true, if the message should be loaded
+     */
+    boolean messageNodeAvailable(String messageUid);
+    
+    /**
      * Called when a <code>MessageNode</code> is created or updated,
      * depending on the purpose of the method that invoked the this

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

@@ -196 +196 @@
         }
 
+        public boolean messageNodeAvailable(String messageUid) {
+            return true;
+        }
+        
         public void messageNodeUpdated(MessageNode messageNode) {
             if(messageNode instanceof OutgoingMessageNode) {

trunk/LogicMail/src/org/logicprobe/LogicMail/ui/MailHomeScreen.java

@@ -441 +441 @@
 
     public void refreshMailTreeNode(MailHomeTreeNode node) {
-        int nodeId = nodeIdMap.get(node);
+        final int nodeId = nodeIdMap.get(node);
         if(nodeId != -1) {
-            synchronized(UiApplication.getEventLock()) {
-                treeField.invalidateNode(nodeId);
-            }
+            UiApplication.getUiApplication().invokeLater(new Runnable() {
+                public void run() {
+                    treeField.invalidateNode(nodeId);
+                }
+            });
         }
     }