Changeset 562


Ignore:
Timestamp:
12/28/09 12:45:23 (2 years ago)
Author:
octorian
Message:

Incremental loading and offline cache updates (still some POP issues)

Location:
trunk
Files:
1 added
19 edited

Legend:

Unmodified
Added
Removed

  • trunk/LogicMail/src/org/logicprobe/LogicMail/conf/GlobalConfig.java

    r561 r562  
    8080 
    8181    /** Root URL for local file storage */ 
    82     private String localDataLocation; 
     82    private String localDataLocation = ""; 
    8383 
    8484    /** Mode for WiFi support */ 
    … …  
    129129        this.hideDeletedMsg = true; 
    130130        this.localHostname = ""; 
    131         this.localDataLocation = null; 
     131        this.localDataLocation = ""; 
    132132    } 
    133133 

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

    r529 r562  
    3434import java.io.IOException; 
    3535import org.logicprobe.LogicMail.conf.AccountConfig; 
    36 import org.logicprobe.LogicMail.message.FolderMessage; 
    3736import org.logicprobe.LogicMail.message.Message; 
    3837import org.logicprobe.LogicMail.message.MessageFlags; 
    … …  
    191190     * @param firstIndex Index of the first message 
    192191     * @param lastIndex Index of the last message 
    193      * @param progressHandler the progress handler 
    194      * @return List of message envelopes 
    195      *  
    196      * @throws IOException on I/O errors 
    197      * @throws MailException on protocol errors 
    198      */ 
    199     FolderMessage[] getFolderMessages(int firstIndex, int lastIndex, MailProgressHandler progressHandler) 
     192     * @param callback The callback to provide notifications as individual folder messages are loaded 
     193     * @param progressHandler the progress handler 
     194     *  
     195     * @throws IOException on I/O errors 
     196     * @throws MailException on protocol errors 
     197     */ 
     198    void getFolderMessages(int firstIndex, int lastIndex, FolderMessageCallback callback, MailProgressHandler progressHandler) 
    200199        throws IOException, MailException; 
    201200     
    … …  
    205204     *  
    206205     * @param messageTokens Tokens of the messages 
    207      * @param progressHandler the progress handler 
    208      * @return List of message envelopes 
    209      *  
    210      * @throws IOException on I/O errors 
    211      * @throws MailException on protocol errors 
    212      */ 
    213     FolderMessage[] getFolderMessages(MessageToken[] messageTokens, MailProgressHandler progressHandler) 
     206     * @param callback The callback to provide notifications as individual folder messages are loaded 
     207     * @param progressHandler the progress handler 
     208     *  
     209     * @throws IOException on I/O errors 
     210     * @throws MailException on protocol errors 
     211     */ 
     212    void getFolderMessages(MessageToken[] messageTokens, FolderMessageCallback callback, MailProgressHandler progressHandler) 
    214213        throws IOException, MailException; 
    215214     
    … …  
    226225     *  
    227226     * @param flagsOnly If true, only tokens and flags will be fetched 
    228      * @param progressHandler the progress handler 
    229      *  
    230      * @return List of message envelopes 
    231      *  
    232      * @throws IOException on I/O errors 
    233      * @throws MailException on protocol errors 
    234      */ 
    235     FolderMessage[] getNewFolderMessages(boolean flagsOnly, MailProgressHandler progressHandler) throws IOException, MailException; 
     227     * @param callback The callback to provide notifications as individual folder messages are loaded 
     228     * @param progressHandler the progress handler 
     229     *  
     230     * @throws IOException on I/O errors 
     231     * @throws MailException on protocol errors 
     232     */ 
     233    void getNewFolderMessages(boolean flagsOnly, FolderMessageCallback callback, MailProgressHandler progressHandler) throws IOException, MailException; 
    236234     
    237235    /** 

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

    r529 r562  
    223223        } 
    224224         
     225    private static class GetFolderMessageCallback implements FolderMessageCallback { 
     226        private int maxCount; 
     227        private int type; 
     228        private FolderTreeItem folder; 
     229        private MailConnectionHandlerListener listener; 
     230        private Object param; 
     231        private FolderMessage[] folderMessages; 
     232        private int count; 
     233         
     234        public GetFolderMessageCallback(int maxCount, int type, FolderTreeItem folder, MailConnectionHandlerListener listener) { 
     235            this(maxCount, type, folder, listener, null); 
     236        } 
     237         
     238        public GetFolderMessageCallback(int maxCount, int type, FolderTreeItem folder, MailConnectionHandlerListener listener, Object param) { 
     239            this.maxCount = maxCount; 
     240            this.type = type; 
     241            this.folder = folder; 
     242            this.listener = listener; 
     243            this.param = param; 
     244            this.count = 0; 
     245             
     246        } 
     247         
     248        public void folderMessageUpdate(FolderMessage folderMessage) { 
     249            FolderMessage[] resultMessages = null; 
     250            synchronized(this) { 
     251                if(folderMessage != null) { 
     252                    if(count == 0) { 
     253                        folderMessages = new FolderMessage[maxCount]; 
     254                    } 
     255                    folderMessages[count++] = folderMessage; 
     256                } 
     257 
     258                if(count == maxCount) { 
     259                    resultMessages = folderMessages; 
     260                    folderMessages = null; 
     261                    count = 0; 
     262                } 
     263                else if(folderMessage == null) { 
     264                    resultMessages = new FolderMessage[count]; 
     265                    for(int i=0; i<count; i++) { 
     266                        resultMessages[i] = folderMessages[i]; 
     267                    } 
     268                    folderMessages = null; 
     269                    count = 0; 
     270                } 
     271            } 
     272 
     273            if(resultMessages != null && listener != null) { 
     274                if(param == null) { 
     275                    listener.mailConnectionRequestComplete(type, new Object[] { folder, resultMessages }); 
     276                } 
     277                else { 
     278                    listener.mailConnectionRequestComplete(type, new Object[] { folder, resultMessages, param }); 
     279                } 
     280            } 
     281        } 
     282    }; 
     283 
     284         
    225285        private void handleRequestFolderMessagesRange(FolderTreeItem folder, int firstIndex, int lastIndex) throws IOException, MailException { 
    226286                String message = resources.getString(LogicMailResource.MAILCONNECTION_REQUEST_FOLDER_MESSAGES); 
    … …  
    228288                checkActiveFolder(folder); 
    229289                 
    230                 FolderMessage[] messages = incomingClient.getFolderMessages(firstIndex, lastIndex, getProgressHandler(message)); 
    231                  
    232                 MailConnectionHandlerListener listener = getListener(); 
    233                 if(messages != null && messages.length > 0 && listener != null) { 
    234                         listener.mailConnectionRequestComplete(REQUEST_FOLDER_MESSAGES_RANGE, new Object[] { folder, messages }); 
    235                 } 
     290                incomingClient.getFolderMessages( 
     291                        firstIndex, lastIndex, 
     292                        new GetFolderMessageCallback( 
     293                                getFolderMessageUpdateFrequency(), 
     294                                REQUEST_FOLDER_MESSAGES_RANGE, 
     295                                folder, 
     296                                getListener()), 
     297                        getProgressHandler(message)); 
    236298        } 
    237299         
    … …  
    241303                checkActiveFolder(folder); 
    242304                 
    243                 FolderMessage[] messages = incomingClient.getFolderMessages(messageTokens, getProgressHandler(message)); 
    244                  
    245                 MailConnectionHandlerListener listener = getListener(); 
    246                 if(messages != null && messages.length > 0 && listener != null) { 
    247                         listener.mailConnectionRequestComplete(REQUEST_FOLDER_MESSAGES_SET, new Object[] { folder, messages }); 
    248                 } 
     305                incomingClient.getFolderMessages( 
     306                        messageTokens, 
     307                        new GetFolderMessageCallback( 
     308                                getFolderMessageUpdateFrequency(), 
     309                                REQUEST_FOLDER_MESSAGES_SET, 
     310                                folder, 
     311                                getListener()), 
     312                        getProgressHandler(message)); 
    249313        } 
    250314         
    … …  
    254318                checkActiveFolder(folder); 
    255319         
    256                 FolderMessage[] messages = incomingClient.getNewFolderMessages(flagsOnly, getProgressHandler(message)); 
    257                  
    258                 MailConnectionHandlerListener listener = getListener(); 
    259                 if(messages != null && messages.length > 0 && listener != null) { 
    260                         listener.mailConnectionRequestComplete(REQUEST_FOLDER_MESSAGES_RECENT, new Object[] { folder, messages, new Boolean(flagsOnly) }); 
    261                 } 
     320                incomingClient.getNewFolderMessages( 
     321                        flagsOnly, 
     322                        new GetFolderMessageCallback( 
     323                                getFolderMessageUpdateFrequency(), 
     324                                REQUEST_FOLDER_MESSAGES_RECENT, 
     325                                folder, 
     326                                getListener(), 
     327                                new Boolean(flagsOnly)), 
     328                        getProgressHandler(message)); 
     329        } 
     330         
     331        private int getFolderMessageUpdateFrequency() { 
     332            // Replace this with a more general method: 
     333            int frequency; 
     334            if(incomingClient instanceof org.logicprobe.LogicMail.mail.imap.ImapClient) { 
     335                frequency = 5; 
     336            } 
     337            else if(incomingClient instanceof org.logicprobe.LogicMail.mail.pop.PopClient) { 
     338                frequency = 2; 
     339            } 
     340            else { 
     341                frequency = 10; 
     342            } 
     343            return frequency; 
    262344        } 
    263345         

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

    r529 r562  
    158158                return buf.toString(); 
    159159        } 
     160 
     161        /* (non-Javadoc) 
     162         * @see org.logicprobe.LogicMail.mail.MessageToken#updateToken(org.logicprobe.LogicMail.mail.MessageToken) 
     163         */ 
     164        public void updateToken(MessageToken messageToken) { 
     165            // Local tokens are complete and only have immutable data 
     166        } 
     167 
     168        /* (non-Javadoc) 
     169         * @see org.logicprobe.LogicMail.mail.MessageToken#isLoadable() 
     170         */ 
     171        public boolean isLoadable() { 
     172            return true; 
     173        } 
    160174} 

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

    r529 r562  
    6565         */ 
    6666        boolean containedWithin(FolderTreeItem folderTreeItem); 
     67 
     68        /** 
     69         * Update this message token with information from the provided 
     70         * message token.  This is meant to update volatile token fields 
     71         * that are not serialized or checked with {@link #equals(Object)}. 
     72         *  
     73         * @param messageToken other token to update from 
     74         */ 
     75    void updateToken(MessageToken messageToken); 
     76     
     77    /** 
     78     * Gets whether this token is sufficiently complete to load a message 
     79     * from a mail store.  Messages not loadable from a mail store should 
     80     * still be loadable from local cache. 
     81     *  
     82     * @return True if loadable, false otherwise 
     83     */ 
     84    boolean isLoadable(); 
    6785} 

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

    r529 r562  
    4444import org.logicprobe.LogicMail.conf.MailSettingsEvent; 
    4545import org.logicprobe.LogicMail.conf.MailSettingsListener; 
     46import org.logicprobe.LogicMail.mail.FolderMessageCallback; 
    4647import org.logicprobe.LogicMail.mail.FolderTreeItem; 
    4748import org.logicprobe.LogicMail.mail.IncomingMailClient; 
    … …  
    4950import org.logicprobe.LogicMail.mail.MailProgressHandler; 
    5051import org.logicprobe.LogicMail.mail.MessageToken; 
     52import org.logicprobe.LogicMail.mail.imap.ImapProtocol.FetchEnvelopeResponse; 
    5153import org.logicprobe.LogicMail.message.FolderMessage; 
    5254import org.logicprobe.LogicMail.message.Message; 
    … …  
    582584     
    583585    /* (non-Javadoc) 
    584      * @see org.logicprobe.LogicMail.mail.IncomingMailClient#getFolderMessages(int, int, org.logicprobe.LogicMail.mail.MailProgressHandler) 
    585      */ 
    586     public FolderMessage[] getFolderMessages(int firstIndex, int lastIndex, MailProgressHandler progressHandler) throws IOException, MailException { 
    587         return getFolderMessages(firstIndex, lastIndex, false, progressHandler); 
    588     } 
    589      
    590     private FolderMessage[] getFolderMessages(int firstIndex, int lastIndex, boolean flagsOnly, MailProgressHandler progressHandler) throws IOException, MailException { 
     586     * @see org.logicprobe.LogicMail.mail.IncomingMailClient#getFolderMessages(int, int, org.logicprobe.LogicMail.mail.FolderMessageCallback, org.logicprobe.LogicMail.mail.MailProgressHandler) 
     587     */ 
     588    public void getFolderMessages(int firstIndex, int lastIndex, FolderMessageCallback callback, MailProgressHandler progressHandler) throws IOException, MailException { 
     589        getFolderMessages(firstIndex, lastIndex, false, callback, progressHandler); 
     590    } 
     591     
     592    private class ImapFetchEnvelopeCallback implements ImapProtocol.FetchEnvelopeCallback { 
     593        private FolderMessageCallback callback; 
     594        public ImapFetchEnvelopeCallback(FolderMessageCallback callback) { 
     595            this.callback = callback; 
     596        } 
     597        public void responseAvailable(FetchEnvelopeResponse response) { 
     598            if(response != null) { 
     599                callback.folderMessageUpdate(ImapClient.this.prepareFolderMessagesEnvelope(response)); 
     600            } 
     601            else { 
     602                callback.folderMessageUpdate(null); 
     603            } 
     604        } 
     605    } 
     606     
     607    private void getFolderMessages(int firstIndex, int lastIndex, boolean flagsOnly, FolderMessageCallback callback, MailProgressHandler progressHandler) throws IOException, MailException { 
    591608        // Sanity check 
    592609        if(activeMailbox == null) { 
    … …  
    596613        // Make sure we do not FETCH an empty folder 
    597614        if(firstIndex > lastIndex) { 
    598             return new FolderMessage[0]; 
     615            callback.folderMessageUpdate(null); 
     616            return; 
    599617        } 
    600618         
    601         FolderMessage[] result; 
    602619        if(flagsOnly) { 
    603620            ImapProtocol.FetchFlagsResponse[] flagsResponse = 
    604621                imapProtocol.executeFetchFlags(firstIndex, lastIndex, progressHandler); 
    605                 result = prepareFolderMessagesFlags(flagsResponse); 
     622            FolderMessage[] result = prepareFolderMessagesFlags(flagsResponse); 
     623            for(int i=0; i<result.length; i++) { 
     624                callback.folderMessageUpdate(result[i]); 
     625            } 
    606626        } 
    607627        else { 
    608             ImapProtocol.FetchEnvelopeResponse[] envResponse = 
    609                 imapProtocol.executeFetchEnvelope(firstIndex, lastIndex, progressHandler); 
    610                 result = prepareFolderMessagesEnvelope(envResponse); 
    611         } 
    612          
    613         return result; 
     628            imapProtocol.executeFetchEnvelope(firstIndex, lastIndex, new ImapFetchEnvelopeCallback(callback), progressHandler); 
     629        } 
    614630    } 
    615631 
    616632        /* (non-Javadoc) 
    617          * @see org.logicprobe.LogicMail.mail.IncomingMailClient#getFolderMessages(org.logicprobe.LogicMail.mail.MessageToken[], org.logicprobe.LogicMail.mail.MailProgressHandler) 
     633         * @see org.logicprobe.LogicMail.mail.IncomingMailClient#getFolderMessages(org.logicprobe.LogicMail.mail.MessageToken[], org.logicprobe.LogicMail.mail.FolderMessageCallback, org.logicprobe.LogicMail.mail.MailProgressHandler) 
    618634         */ 
    619         public FolderMessage[] getFolderMessages(MessageToken[] messageTokens, MailProgressHandler progressHandler) 
     635        public void getFolderMessages(MessageToken[] messageTokens, FolderMessageCallback callback, MailProgressHandler progressHandler) 
    620636                        throws IOException, MailException { 
    621                 // TODO Auto-generated method stub 
    622637        // Sanity check 
    623638        if(activeMailbox == null) { 
    … …  
    629644                uids[i] = ((ImapMessageToken)messageTokens[i]).getImapMessageUid(); 
    630645        } 
    631         ImapProtocol.FetchEnvelopeResponse[] envResponse = 
    632             imapProtocol.executeFetchEnvelopeUid(uids, progressHandler); 
    633          
    634                 return prepareFolderMessagesEnvelope(envResponse); 
     646        imapProtocol.executeFetchEnvelopeUid(uids, new ImapFetchEnvelopeCallback(callback), progressHandler); 
    635647        } 
    636648 
    637     /* (non-Javadoc) 
    638      * @see org.logicprobe.LogicMail.mail.IncomingMailClient#getNewFolderMessages(boolean, org.logicprobe.LogicMail.mail.MailProgressHandler) 
    639      */ 
    640     public FolderMessage[] getNewFolderMessages(boolean flagsOnly, MailProgressHandler progressHandler) throws IOException, MailException { 
     649    private class ImapNewFetchEnvelopeCallback implements ImapProtocol.FetchEnvelopeCallback { 
     650        private FolderMessageCallback callback; 
     651        private FolderMessage lastFolderMessage; 
     652        public ImapNewFetchEnvelopeCallback(FolderMessageCallback callback) { 
     653            this.callback = callback; 
     654        } 
     655        public void responseAvailable(FetchEnvelopeResponse response) { 
     656            if(response != null) { 
     657                FolderMessage folderMessage = ImapClient.this.prepareFolderMessagesEnvelope(response); 
     658                callback.folderMessageUpdate(folderMessage); 
     659                lastFolderMessage = folderMessage; 
     660            } 
     661            else { 
     662                if(lastFolderMessage != null) { 
     663                    int uidNext = lastFolderMessage.getUid() + 1; 
     664                    ((ImapProtocol.SelectResponse)knownMailboxes.get(activeMailbox)).uidNext = uidNext; 
     665                } 
     666                callback.folderMessageUpdate(null); 
     667            } 
     668        } 
     669    } 
     670     
     671    /* (non-Javadoc) 
     672     * @see org.logicprobe.LogicMail.mail.IncomingMailClient#getNewFolderMessages(boolean, org.logicprobe.LogicMail.mail.FolderMessageCallback, org.logicprobe.LogicMail.mail.MailProgressHandler) 
     673     */ 
     674    public void getNewFolderMessages(boolean flagsOnly, FolderMessageCallback callback, MailProgressHandler progressHandler) throws IOException, MailException { 
    641675        // Sanity check 
    642676        if(activeMailbox == null) { 
    … …  
    644678        } 
    645679         
    646         FolderMessage[] result; 
    647680        if(!seenMailboxes.containsKey(activeMailbox)) { 
    648681                int count = MailSettings.getInstance().getGlobalConfig().getRetMsgCount(); 
    649682                        int msgCount = activeMailbox.getMsgCount(); 
    650683                int firstIndex = Math.max(1, msgCount - count); 
    651                 result = getFolderMessages(firstIndex, activeMailbox.getMsgCount(), flagsOnly, progressHandler); 
     684                getFolderMessages(firstIndex, activeMailbox.getMsgCount(), flagsOnly, callback, progressHandler); 
    652685                seenMailboxes.put(activeMailbox, new Object()); 
    653686        } 
    654687        else { 
     688            FolderMessage[] result; 
    655689                int uidNext = ((ImapProtocol.SelectResponse)knownMailboxes.get(activeMailbox)).uidNext; 
    656690                if(flagsOnly) { 
    … …  
    658692                                imapProtocol.executeFetchFlagsUid(uidNext, progressHandler); 
    659693                        result = prepareFolderMessagesFlags(flagsResponse); 
     694                    if(result.length > 0) { 
     695                        uidNext = result[result.length-1].getUid() + 1; 
     696                        ((ImapProtocol.SelectResponse)knownMailboxes.get(activeMailbox)).uidNext = uidNext; 
     697                    } 
     698                    for(int i=0; i<result.length; i++) { 
     699                        callback.folderMessageUpdate(result[i]); 
     700                    } 
    660701                } 
    661702                else { 
    662                         ImapProtocol.FetchEnvelopeResponse[] envResponse = 
    663                                 imapProtocol.executeFetchEnvelopeUid(uidNext, progressHandler); 
    664                         result = prepareFolderMessagesEnvelope(envResponse); 
     703                    imapProtocol.executeFetchEnvelopeUid(uidNext, new ImapNewFetchEnvelopeCallback(callback), progressHandler); 
    665704                } 
    666                  
    667                 if(result.length > 0) { 
    668                         uidNext = result[result.length-1].getUid() + 1; 
    669                         ((ImapProtocol.SelectResponse)knownMailboxes.get(activeMailbox)).uidNext = uidNext; 
    670                 } 
    671         } 
    672         return result; 
    673     } 
    674  
    675     private FolderMessage[] prepareFolderMessagesEnvelope(ImapProtocol.FetchEnvelopeResponse[] response) { 
    676         FolderMessage[] folderMessages = new FolderMessage[response.length]; 
    677         for(int i=0;i<response.length;i++) { 
    678             folderMessages[i] = new FolderMessage( 
    679                         new ImapMessageToken(activeMailbox.getPath(), response[i].uid), 
    680                         response[i].envelope, 
    681                         response[i].index, 
    682                         response[i].uid); 
    683             folderMessages[i].setSeen(response[i].flags.seen); 
    684             folderMessages[i].setAnswered(response[i].flags.answered); 
    685             folderMessages[i].setDeleted(response[i].flags.deleted); 
    686             folderMessages[i].setRecent(response[i].flags.recent); 
    687             folderMessages[i].setFlagged(response[i].flags.flagged); 
    688             folderMessages[i].setDraft(response[i].flags.draft); 
    689             folderMessages[i].setJunk(response[i].flags.junk); 
    690             folderMessages[i].setStructure(createMessagePartTree(response[i].structure)); 
    691         } 
    692         return folderMessages; 
     705        } 
     706    } 
     707 
     708    private FolderMessage prepareFolderMessagesEnvelope(ImapProtocol.FetchEnvelopeResponse response) { 
     709        FolderMessage folderMessage = new FolderMessage( 
     710                new ImapMessageToken(activeMailbox.getPath(), response.uid), 
     711                response.envelope, 
     712                response.index, 
     713                response.uid); 
     714        folderMessage.setSeen(response.flags.seen); 
     715        folderMessage.setAnswered(response.flags.answered); 
     716        folderMessage.setDeleted(response.flags.deleted); 
     717        folderMessage.setRecent(response.flags.recent); 
     718        folderMessage.setFlagged(response.flags.flagged); 
     719        folderMessage.setDraft(response.flags.draft); 
     720        folderMessage.setJunk(response.flags.junk); 
     721        folderMessage.setStructure(createMessagePartTree(response.structure)); 
     722        return folderMessage; 
    693723    } 
    694724     

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

    r529 r562  
    167167                return buf.toString(); 
    168168        } 
     169         
     170        /* (non-Javadoc) 
     171         * @see org.logicprobe.LogicMail.mail.MessageToken#updateToken(org.logicprobe.LogicMail.mail.MessageToken) 
     172         */ 
     173        public void updateToken(MessageToken messageToken) { 
     174            // IMAP tokens are complete and only have immutable data 
     175        } 
     176 
     177        /* (non-Javadoc) 
     178         * @see org.logicprobe.LogicMail.mail.MessageToken#isLoadable() 
     179         */ 
     180        public boolean isLoadable() { 
     181            return true; 
     182        } 
    169183} 

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

    r529 r562  
    565565     * @param firstIndex Index of the first message 
    566566     * @param lastIndex Index of the last message 
     567     * @param callback Callback for asynchronous notification of new envelopes 
    567568     * @param progressHandler the progress handler 
    568      * @return Array of FetchEnvelopeResponse objects 
    569      */ 
    570     public FetchEnvelopeResponse[] executeFetchEnvelope( 
     569     */ 
     570    public void executeFetchEnvelope( 
    571571                int firstIndex, 
    572572                int lastIndex, 
     573                FetchEnvelopeCallback callback, 
    573574                MailProgressHandler progressHandler) throws IOException, MailException { 
    574575        if (EventLogger.getMinimumLevel() >= EventLogger.DEBUG_INFO) { 
    … …  
    582583                Integer.toString(lastIndex) + " (FLAGS UID ENVELOPE BODYSTRUCTURE)", progressHandler); 
    583584 
    584         return prepareFetchEnvelopeResponse(rawList, progressHandler); 
     585        prepareFetchEnvelopeResponse(rawList, callback, progressHandler); 
    585586    } 
    586587 
    … …  
    588589     * Execute the "UID FETCH (FLAGS UID ENVELOPE BODYSTRUCTURE)" command 
    589590     * @param uidNext Unique ID of the next message 
     591     * @param callback Callback for asynchronous notification of new envelopes 
    590592     * @param progressHandler the progress handler 
    591      * @return Array of FetchEnvelopeResponse objects 
    592      */ 
    593     public FetchEnvelopeResponse[] executeFetchEnvelopeUid(int uidNext, MailProgressHandler progressHandler) 
     593     */ 
     594    public void executeFetchEnvelopeUid(int uidNext, FetchEnvelopeCallback callback, MailProgressHandler progressHandler) 
    594595        throws IOException, MailException { 
    595596        if (EventLogger.getMinimumLevel() >= EventLogger.DEBUG_INFO) { 
    … …  
    602603                Integer.toString(uidNext) + ":*" + " (FLAGS UID ENVELOPE BODYSTRUCTURE)", progressHandler); 
    603604 
    604         return prepareFetchEnvelopeResponse(rawList, progressHandler); 
     605        prepareFetchEnvelopeResponse(rawList, callback, progressHandler); 
    605606    } 
    606607     
    … …  
    608609     * Execute the "UID FETCH (FLAGS UID ENVELOPE BODYSTRUCTURE)" command 
    609610     * @param uids Set of unique IDs for the messages to fetch 
     611     * @param callback Callback for asynchronous notification of new envelopes 
    610612     * @param progressHandler the progress handler 
    611      * @return Array of FetchEnvelopeResponse objects 
    612      */ 
    613     public FetchEnvelopeResponse[] executeFetchEnvelopeUid(int[] uids, MailProgressHandler progressHandler) 
     613     */ 
     614    public void executeFetchEnvelopeUid(int[] uids, FetchEnvelopeCallback callback, MailProgressHandler progressHandler) 
    614615        throws IOException, MailException { 
    615         if(uids.length == 0) { return new FetchEnvelopeResponse[0]; } 
     616        if(uids.length == 0) { callback.responseAvailable(null); return; } 
    616617        StringBuffer buf = new StringBuffer(); 
    617618        for(int i=0; i<uids.length - 1; i++) { 
    … …  
    631632                        uidList + " (FLAGS UID ENVELOPE BODYSTRUCTURE)", progressHandler); 
    632633 
    633         return prepareFetchEnvelopeResponse(rawList, progressHandler); 
    634     } 
    635  
    636     private FetchEnvelopeResponse[] prepareFetchEnvelopeResponse( 
    637         String[] rawList, MailProgressHandler progressHandler) throws IOException, MailException { 
     634        prepareFetchEnvelopeResponse(rawList, callback, progressHandler); 
     635    } 
     636 
     637    private void prepareFetchEnvelopeResponse( 
     638        String[] rawList, FetchEnvelopeCallback callback, MailProgressHandler progressHandler) throws IOException, MailException { 
    638639 
    639640        if(progressHandler != null) { progressHandler.mailProgress(MailProgressHandler.TYPE_PROCESSING, 0, -1); } 
    … …  
    643644        Vector rawList2 = prepareCleanFetchResponse(rawList); 
    644645 
    645         Vector envResponses = new Vector(); 
    646646        int size = rawList2.size(); 
    647647 
    648648        if(progressHandler != null) { progressHandler.mailProgress(MailProgressHandler.TYPE_PROCESSING, 0, size); } 
    649649        for (int i = 0; i < size; i++) { 
     650            FetchEnvelopeResponse envRespItem = null; 
    650651            try { 
    651652                String rawText = (String) rawList2.elementAt(i); 
    … …  
    662663                } 
    663664 
    664                 FetchEnvelopeResponse envRespItem = new FetchEnvelopeResponse(); 
     665                envRespItem = new FetchEnvelopeResponse(); 
    665666                envRespItem.flags = null; 
    666667 
    … …  
    716717                envRespItem.envelope = env; 
    717718                envRespItem.structure = structure; 
    718                 envResponses.addElement(envRespItem); 
    719719            } catch (Exception exp) { 
    720720                System.err.println("Parse error: " + exp); 
     721                envRespItem = null; 
     722            } 
     723            if(envRespItem != null) { 
     724                callback.responseAvailable(envRespItem); 
    721725            } 
    722726            if(progressHandler != null) { progressHandler.mailProgress(MailProgressHandler.TYPE_PROCESSING, i, size); } 
    723727        } 
    724728 
    725         FetchEnvelopeResponse[] result = new FetchEnvelopeResponse[envResponses.size()]; 
    726         envResponses.copyInto(result); 
    727         if(progressHandler != null) { progressHandler.mailProgress(MailProgressHandler.TYPE_PROCESSING, size, size); } 
    728  
    729         return result; 
     729        callback.responseAvailable(null); 
    730730    } 
    731731     
    … …  
    15271527 
    15281528    /** 
     1529     * Callback for fetching envelopes. 
     1530     */ 
     1531    public static interface FetchEnvelopeCallback { 
     1532        void responseAvailable(FetchEnvelopeResponse response); 
     1533    } 
     1534     
     1535    /** 
    15291536     * Container for a LIST response 
    15301537     */ 

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

    r529 r562  
    4343import org.logicprobe.LogicMail.conf.MailSettingsListener; 
    4444import org.logicprobe.LogicMail.conf.PopConfig; 
     45import org.logicprobe.LogicMail.mail.FolderMessageCallback; 
    4546import org.logicprobe.LogicMail.mail.FolderTreeItem; 
    4647import org.logicprobe.LogicMail.mail.IncomingMailClient; 
    … …  
    6465 */ 
    6566public class PopClient implements IncomingMailClient { 
     67    private GlobalConfig globalConfig; 
    6668    private PopConfig accountConfig; 
    6769    private Connection connection; 
    … …  
    8688    /** Creates a new instance of PopClient */ 
    8789    public PopClient(GlobalConfig globalConfig, PopConfig accountConfig) { 
     90        this.globalConfig = globalConfig; 
    8891        this.accountConfig = accountConfig; 
    8992        connection = new Connection( 
    … …  
    332335     
    333336    /* (non-Javadoc) 
    334      * @see org.logicprobe.LogicMail.mail.IncomingMailClient#getFolderMessages(int, int, org.logicprobe.LogicMail.mail.MailProgressHandler) 
    335      */ 
    336     public FolderMessage[] getFolderMessages(int firstIndex, int lastIndex, MailProgressHandler progressHandler) throws IOException, MailException { 
    337         return getFolderMessages(firstIndex, lastIndex, false, progressHandler); 
    338     } 
    339      
    340     private FolderMessage[] getFolderMessages(int firstIndex, int lastIndex, boolean flagsOnly, MailProgressHandler progressHandler) throws IOException, MailException { 
    341         int[] indices = new int[(lastIndex - firstIndex)+1]; 
    342         for(int i=firstIndex; i<=lastIndex; i++) { 
    343                 indices[i] = i; 
    344         } 
    345          
    346         return getFolderMessagesImpl(indices, flagsOnly, progressHandler); 
     337     * @see org.logicprobe.LogicMail.mail.IncomingMailClient#getFolderMessages(int, int, org.logicprobe.LogicMail.mail.FolderMessageCallback, org.logicprobe.LogicMail.mail.MailProgressHandler) 
     338     */ 
     339    public void getFolderMessages(int firstIndex, int lastIndex, FolderMessageCallback callback, MailProgressHandler progressHandler) throws IOException, MailException { 
     340        getFolderMessages(firstIndex, lastIndex, false, callback, progressHandler); 
     341    } 
     342     
     343    /** 
     344     * Gets the folder messages from the mail server for a range of indices. 
     345     * In order to provide a more natural ordering of the results, messages 
     346     * are requested in an ordering based on the {@link GlobalConfig#getDispOrder()} 
     347     * value. 
     348     *  
     349     * @param firstIndex the first index of the range 
     350     * @param lastIndex the last index of the range 
     351     * @param flagsOnly whether to request only flags 
     352     * @param callback the callback for result notification 
     353     * @param progressHandler the progress handler 
     354     *  
     355     * @throws IOException Signals that an I/O exception has occurred. 
     356     * @throws MailException the mail exception 
     357     */ 
     358    private void getFolderMessages(int firstIndex, int lastIndex, boolean flagsOnly, FolderMessageCallback callback, MailProgressHandler progressHandler) throws IOException, MailException { 
     359        int[] indices = new int[(lastIndex - firstIndex)+1]; 
     360         
     361        if(globalConfig.getDispOrder()) { 
     362                int currentIndex = firstIndex; 
     363                for(int i=0; i<indices.length; i++) { 
     364                        indices[i] = currentIndex++; 
     365                } 
     366        } 
     367        else { 
     368            int currentIndex = lastIndex; 
     369            for(int i=0; i<indices.length; i++) { 
     370                indices[i] = currentIndex--; 
     371            } 
     372        } 
     373     
     374        getFolderMessagesImpl(indices, flagsOnly, callback, progressHandler); 
    347375    } 
    348376 
    349377        /* (non-Javadoc) 
    350          * @see org.logicprobe.LogicMail.mail.IncomingMailClient#getFolderMessages(org.logicprobe.LogicMail.mail.MessageToken[], org.logicprobe.LogicMail.mail.MailProgressHandler) 
     378         * @see org.logicprobe.LogicMail.mail.IncomingMailClient#getFolderMessages(org.logicprobe.LogicMail.mail.MessageToken[], org.logicprobe.LogicMail.mail.FolderMessageCallback, org.logicprobe.LogicMail.mail.MailProgressHandler) 
    351379         */ 
    352         public FolderMessage[] getFolderMessages(MessageToken[] messageTokens, MailProgressHandler progressHandler) 
     380        public void getFolderMessages(MessageToken[] messageTokens, FolderMessageCallback callback, MailProgressHandler progressHandler) 
    353381                        throws IOException, MailException { 
    354382                // Since POP servers typically lock the mailbox while a client is connected, 
    … …  
    362390                } 
    363391                 
    364                 return getFolderMessagesImpl(indices, false, progressHandler); 
    365         } 
    366  
    367     private FolderMessage[] getFolderMessagesImpl(int[] indices, boolean flagsOnly, MailProgressHandler progressHandler) 
     392                getFolderMessagesImpl(indices, false, callback, progressHandler); 
     393        } 
     394 
     395    private void getFolderMessagesImpl(int[] indices, boolean flagsOnly, FolderMessageCallback callback, MailProgressHandler progressHandler) 
    368396                throws IOException, MailException { 
    369         FolderMessage[] folderMessages = new FolderMessage[indices.length]; 
    370         int index = 0; 
    371397        String[] headerText; 
    372398        String uid; 
    … …  
    375401        int postCount = connection.getBytesReceived(); 
    376402        for(int i=0; i<indices.length; i++) { 
    377                 preCount = postCount; 
     403            preCount = postCount; 
    378404            if(!flagsOnly) { 
    379                 headerText = popProtocol.executeTop(indices[i], 0); 
    380                 env = MailMessageParser.parseMessageEnvelope(headerText); 
    381                 } 
     405                headerText = popProtocol.executeTop(indices[i], 0); 
     406                env = MailMessageParser.parseMessageEnvelope(headerText); 
     407            } 
    382408            else { 
    383                 env = null; 
     409                env = null; 
    384410            } 
    385411            uid = popProtocol.executeUidl(indices[i]); 
    386             folderMessages[index++] = new FolderMessage( 
    387                         new PopMessageToken(indices[i], uid), 
    388                         env, indices[i], uid.hashCode()); 
     412            FolderMessage folderMessage = new FolderMessage( 
     413                    new PopMessageToken(indices[i], uid), 
     414                    env, indices[i], uid.hashCode()); 
    389415            postCount = connection.getBytesReceived(); 
    390416            if(progressHandler != null) { progressHandler.mailProgress(MailProgressHandler.TYPE_NETWORK, (postCount - preCount), -1); } 
    391         } 
    392         return folderMessages; 
    393     } 
    394      
    395     /* (non-Javadoc) 
    396      * @see org.logicprobe.LogicMail.mail.IncomingMailClient#getNewFolderMessages(boolean, org.logicprobe.LogicMail.mail.MailProgressHandler) 
    397      */ 
    398     public FolderMessage[] getNewFolderMessages(boolean flagsOnly, MailProgressHandler progressHandler) throws IOException, MailException { 
     417 
     418            callback.folderMessageUpdate(folderMessage); 
     419        } 
     420        callback.folderMessageUpdate(null); 
     421    } 
     422     
     423    /* (non-Javadoc) 
     424     * @see org.logicprobe.LogicMail.mail.IncomingMailClient#getNewFolderMessages(boolean, org.logicprobe.LogicMail.mail.FolderMessageCallback, org.logicprobe.LogicMail.mail.MailProgressHandler) 
     425     */ 
     426    public void getNewFolderMessages(boolean flagsOnly, FolderMessageCallback callback, MailProgressHandler progressHandler) throws IOException, MailException { 
    399427        int count = MailSettings.getInstance().getGlobalConfig().getRetMsgCount(); 
    400428                int msgCount = activeMailbox.getMsgCount(); 
    401429        int firstIndex = Math.max(1, msgCount - count); 
    402         return getFolderMessages(firstIndex, activeMailbox.getMsgCount(), flagsOnly, progressHandler); 
     430        getFolderMessages(firstIndex, activeMailbox.getMsgCount(), flagsOnly, callback, progressHandler); 
    403431    } 
    404432 

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

    r529 r562  
    5555     
    5656    /** Index of the message within the mailbox */ 
    57     private int messageIndex; 
     57    private int messageIndex = -1; 
     58     
    5859    /** POP unique ID that identifies the message */ 
    5960    private String messageUid; 
    … …  
    125126        public void serialize(DataOutput output) throws IOException { 
    126127                output.writeLong(uniqueId); 
     128                output.writeUTF(messageUid); 
    127129        } 
    128130         
    … …  
    132134        public void deserialize(DataInput input) throws IOException { 
    133135                uniqueId = input.readLong(); 
     136                messageUid = input.readUTF(); 
    134137        } 
    135138 
    … …  
    138141         */ 
    139142        public boolean equals(Object obj) { 
    140                 if(obj instanceof PopMessageToken) { 
    141                         PopMessageToken rhs = (PopMessageToken)obj; 
    142                         return (this.messageIndex == rhs.messageIndex && 
    143                                         this.messageUid.equals(rhs.messageUid)); 
    144                 } 
    145                 else { 
    146                         return false; 
    147                 } 
     143            if(obj instanceof PopMessageToken) { 
     144                PopMessageToken rhs = (PopMessageToken)obj; 
     145                return this.messageUid.equals(rhs.messageUid); 
     146            } 
     147            else { 
     148                return false; 
     149            } 
    148150        } 
    149          
     151 
    150152        /* (non-Javadoc) 
    151153         * @see java.lang.Object#hashCode() 
    152154         */ 
    153155        public int hashCode() { 
    154                 if(hashCode == -1) { 
    155                         int hash = 7; 
    156                         hash = 31 * hash + messageIndex; 
    157                         hash = 31 * hash + (messageUid == null ? 0 : messageUid.hashCode()); 
    158                         hashCode = hash; 
    159                 } 
    160                 return hashCode; 
     156            if(hashCode == -1) { 
     157                int result = 1; 
     158                result = 31 * result + ((messageUid == null) ? 0 : messageUid.hashCode()); 
     159            } 
     160            return hashCode; 
    161161        } 
    162162         
    … …  
    173173                return buf.toString(); 
    174174        } 
     175 
     176    public void updateToken(MessageToken messageToken) { 
     177        if(messageToken.equals(this)) { 
     178            PopMessageToken rhs = (PopMessageToken)messageToken; 
     179            this.messageIndex = rhs.messageIndex; 
     180        } 
     181    } 
     182 
     183    public boolean isLoadable() { 
     184        return messageIndex != -1; 
     185    } 
    175186} 

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

    r532 r562  
    584584                        if(messageNode != null) { 
    585585                                messageNode.setFlags(MessageNode.convertMessageFlags(folderMessages[i].getFlags())); 
     586                                 
     587                                // Update the token based on the token that came along 
     588                                // with the flags.  This will update any volatile state 
     589                                // information, such as POP message indices 
     590                                messageNode.getMessageToken().updateToken(folderMessages[i].getMessageToken()); 
    586591                        } 
    587592                        else { 
    588593                                if(messagesToFetch == null) { messagesToFetch = new Vector(); } 
    589594                                messagesToFetch.addElement(folderMessages[i].getMessageToken()); 
    590                                 System.err.println("-->Need to fetch: " + folderMessages[i].getMessageToken()); 
    591595                        } 
    592596                    } 

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

    r532 r562  
    11001100                                MessageNode tempNode = MailFileManager.getInstance().readMessageNode(parent, messageToken, true); 
    11011101                                if(tempNode != null) { 
    1102                                         setMessageStructure(tempNode.getMessageStructure()); 
    1103                                         setMessageSource(tempNode.getMessageSource()); 
    1104                                         putMessageContent(tempNode.getAllMessageContent()); 
    1105                                         messageLoaded = true; 
     1102                                    MimeMessagePart messageStructure = tempNode.getMessageStructure(); 
     1103                                    MimeMessageContent[] messageContent = tempNode.getAllMessageContent(); 
     1104                                     
     1105                                    if(messageStructure != null && messageContent != null && messageContent.length > 0) { 
     1106                                        setMessageStructure(messageStructure); 
     1107                                        setMessageSource(tempNode.getMessageSource()); 
     1108                                        putMessageContent(messageContent); 
     1109                                        messageLoaded = true; 
     1110                                    } 
    11061111                                } 
    11071112                        } catch (IOException e) { 

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

    r529 r562  
    160160                SerializableHashtable table = new SerializableHashtable(); 
    161161                table.put(HEADER_KEY_FLAGS, new Integer(messageNode.getFlags())); 
    162                 table.put(HEADER_KEY_DATE, messageNode.getDate()); 
    163                 table.put(HEADER_KEY_SUBJECT, messageNode.getSubject()); 
     162                putInTable(table, HEADER_KEY_DATE, messageNode.getDate()); 
     163                putInTable(table, HEADER_KEY_SUBJECT, messageNode.getSubject()); 
    164164                table.put(HEADER_KEY_FROM, createAddressArray(messageNode.getFrom())); 
    165165                table.put(HEADER_KEY_SENDER, createAddressArray(messageNode.getSender())); 
    … …  
    168168                table.put(HEADER_KEY_CC, createAddressArray(messageNode.getCc())); 
    169169                table.put(HEADER_KEY_BCC, createAddressArray(messageNode.getBcc())); 
    170                 table.put(HEADER_KEY_INREPLYTO, messageNode.getInReplyTo()); 
    171                 table.put(HEADER_KEY_MESSAGEID, messageNode.getMessageId()); 
     170                putInTable(table, HEADER_KEY_INREPLYTO, messageNode.getInReplyTo()); 
     171                putInTable(table, HEADER_KEY_MESSAGEID, messageNode.getMessageId()); 
    172172                return SerializationUtils.serializeClass(table); 
     173        } 
     174         
     175        /** 
     176         * Puts an item in the table, checking the value for null first. 
     177         * This is a shortcut to simplify methods that populate a table. 
     178         *  
     179         * @param table the table being populated 
     180         * @param key the item key 
     181         * @param value the item value 
     182         */ 
     183        private static void putInTable(SerializableHashtable table, Object key, Object value) { 
     184            if(value != null) { 
     185                table.put(key, value); 
     186            } 
    173187        } 
    174188         

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

    r551 r562  
    235235            // Empty because this special token is not intended to be serialized 
    236236        } 
     237 
     238        public void updateToken(MessageToken messageToken) { 
     239            // Empty because this special token is not intended to be synchronized 
     240        } 
     241         
     242        public boolean isLoadable() { 
     243            return true; 
     244        } 
    237245    } 
    238246} 

  • trunk/LogicMail/src/org/logicprobe/LogicMail/ui/MessageScreen.java

    r506 r562  
    364364                // Add a collapsed TreeField to show attachments, if any exist 
    365365        MimeMessagePart[] attachmentParts = messageNode.getAttachmentParts(); 
    366         if(attachmentParts.length > 0) { 
     366        if(attachmentParts != null && attachmentParts.length > 0) { 
    367367                attachmentsTreeField = new TreeField(new TreeFieldCallback() { 
    368368                        public void drawTreeItem(TreeField treeField, Graphics graphics, int node, int y, int width, int indent) { 

  • trunk/LogicMailTests/src/org/logicprobe/LogicMail/mail/NetworkMailStoreTest.java

    r551 r562  
    3535import java.io.DataOutput; 
    3636import java.io.IOException; 
     37import java.util.Vector; 
    3738 
    3839import org.logicprobe.LogicMail.conf.AccountConfig; 
    … …  
    6364 
    6465        private FolderEvent eventFolderTreeUpdated; 
    65         private FolderMessagesEvent eventFolderMessagesAvailable; 
     66        private Vector eventFolderMessagesAvailable = new Vector(); 
    6667        private FolderEvent eventFolderStatusChanged; 
    6768        private MessageEvent eventMessageAvailable; 
    … …  
    9091        instance.addFolderListener(new FolderListener() { 
    9192                        public void folderMessagesAvailable(FolderMessagesEvent e) { 
    92                                 eventFolderMessagesAvailable = e; 
     93                                eventFolderMessagesAvailable.addElement(e); 
    9394                        } 
    9495                        public void folderStatusChanged(FolderEvent e) { 
    … …  
    199200        instance.shutdown(true); 
    200201         
    201         assertNotNull(eventFolderMessagesAvailable); 
    202         assertEquals("INBOX", eventFolderMessagesAvailable.getFolder().getName()); 
    203         assertNotNull(eventFolderMessagesAvailable.getMessages()); 
    204         assertEquals(2, eventFolderMessagesAvailable.getMessages().length); 
    205         assertEquals(52, eventFolderMessagesAvailable.getMessages()[0].getUid()); 
    206         assertEquals(53, eventFolderMessagesAvailable.getMessages()[1].getUid()); 
     202        // Cannot assume the number of events that will be fired, 
     203        // but only the number of folder messages contained within 
     204        // all of them put together. 
     205         
     206        int eventCount = eventFolderMessagesAvailable.size(); 
     207        assertTrue(eventCount > 0); 
     208         
     209        Vector folderMessagesAvailable = new Vector(); 
     210        for(int i=0; i<eventCount; i++) { 
     211            // Check general event properties 
     212            FolderMessagesEvent event = (FolderMessagesEvent)eventFolderMessagesAvailable.elementAt(i); 
     213            assertNotNull(event); 
     214            assertEquals("INBOX", event.getFolder().getName()); 
     215            assertNotNull(event.getMessages()); 
     216             
     217            // Collect folder messages within the event 
     218            FolderMessage[] messages = event.getMessages(); 
     219            for(int j=0; j<messages.length; j++) { 
     220                folderMessagesAvailable.addElement(messages[j]); 
     221            } 
     222        } 
     223         
     224        // Assert the folder messages 
     225        assertEquals(2, folderMessagesAvailable.size()); 
     226 
     227        FolderMessage folderMessage1 = (FolderMessage)folderMessagesAvailable.elementAt(0); 
     228        assertEquals(52, folderMessage1.getUid()); 
     229         
     230        FolderMessage folderMessage2 = (FolderMessage)folderMessagesAvailable.elementAt(1); 
     231        assertEquals(53, folderMessage2.getUid()); 
    207232    } 
    208233     
    … …  
    344369                public FolderTreeItem getInboxFolder() { return inboxFolder; } 
    345370                public FolderTreeItem getActiveFolder() { return activeFolder; } 
    346                 public FolderMessage[] getFolderMessages(int firstIndex, int lastIndex, MailProgressHandler progressHandler) 
    347                                 throws IOException, MailException { return this.folderMessages; } 
    348                 public FolderMessage[] getFolderMessages(MessageToken[] messageTokens, MailProgressHandler progressHandler) 
    349                                 throws IOException, MailException { return null; } 
    350                 public FolderMessage[] getNewFolderMessages(boolean flagsOnly, MailProgressHandler progressHandler) 
    351                                 throws IOException,     MailException { return null; } 
     371                public void getFolderMessages(int firstIndex, int lastIndex, FolderMessageCallback callback, MailProgressHandler progressHandler) 
     372                                throws IOException, MailException { 
     373                    for(int i=0; i<folderMessages.length; i++) { 
     374                        callback.folderMessageUpdate(folderMessages[i]); 
     375                    } 
     376                    callback.folderMessageUpdate(null); 
     377            } 
     378                public void getFolderMessages(MessageToken[] messageTokens, FolderMessageCallback callback, MailProgressHandler progressHandler) 
     379                                throws IOException, MailException { } 
     380                public void getNewFolderMessages(boolean flagsOnly, FolderMessageCallback callback, MailProgressHandler progressHandler) 
     381                                throws IOException,     MailException { } 
    352382                public FolderTreeItem getFolderTree(MailProgressHandler progressHandler) throws IOException, MailException { return this.folderTree; } 
    353383                public Message getMessage(MessageToken messageToken, MailProgressHandler progressHandler) 
    … …  
    383413                public boolean containedWithin(FolderTreeItem folderTreeItem) { return true; } 
    384414                public String getMessageUid() { return null; } 
     415        public void updateToken(MessageToken messageToken) { } 
     416        public boolean isLoadable() { return true; } 
    385417        } 
    386418} 

  • trunk/LogicMailTests/src/org/logicprobe/LogicMail/mail/imap/ImapProtocolTest.java

    r471 r562  
    4545import java.util.Vector; 
    4646 
    47  
    4847/** 
    4948 * Unit test for ImapProtocol 
    … …  
    346345            fail("Exception thrown during test: " + t.toString()); 
    347346            t.printStackTrace(); 
     347        } 
     348    } 
     349     
     350    private static class ShimCallback implements ImapProtocol.FetchEnvelopeCallback { 
     351        private Vector responses = new Vector(); 
     352         
     353        public void responseAvailable(ImapProtocol.FetchEnvelopeResponse response) { 
     354            if(response != null) { 
     355                responses.addElement(response); 
     356            } 
     357        } 
     358         
     359        public ImapProtocol.FetchEnvelopeResponse[] getResponses() { 
     360            ImapProtocol.FetchEnvelopeResponse[] result = new ImapProtocol.FetchEnvelopeResponse[responses.size()]; 
     361            responses.copyInto(result); 
     362            return result; 
    348363        } 
    349364    } 
    … …  
    364379                }); 
    365380 
    366             ImapProtocol.FetchEnvelopeResponse[] result = instance.executeFetchEnvelope(1, 1, null); 
     381            ShimCallback shim = new ShimCallback(); 
     382            instance.executeFetchEnvelope(1, 1, shim, null); 
     383            ImapProtocol.FetchEnvelopeResponse[] result = shim.getResponses(); 
     384             
    367385            assertNotNull(result); 
    368386            assertEquals(1, result.length); 
    … …  
    448466                }); 
    449467 
    450             ImapProtocol.FetchEnvelopeResponse[] result = instance.executeFetchEnvelope(1, 1, null); 
     468            ShimCallback shim = new ShimCallback(); 
     469            instance.executeFetchEnvelope(1, 1, shim, null); 
     470            ImapProtocol.FetchEnvelopeResponse[] result = shim.getResponses(); 
     471             
    451472            assertNotNull(result); 
    452473            assertEquals(1, result.length); 
    … …  
    532553                }); 
    533554 
    534             ImapProtocol.FetchEnvelopeResponse[] result = instance.executeFetchEnvelope(1, 1, null); 
     555            ShimCallback shim = new ShimCallback(); 
     556            instance.executeFetchEnvelope(1, 1, shim, null); 
     557            ImapProtocol.FetchEnvelopeResponse[] result = shim.getResponses(); 
     558 
    535559            assertNotNull(result); 
    536560            assertEquals(1, result.length); 
    … …  
    619643                }); 
    620644 
    621             ImapProtocol.FetchEnvelopeResponse[] result = instance.executeFetchEnvelope(1, 1, null); 
     645            ShimCallback shim = new ShimCallback(); 
     646            instance.executeFetchEnvelope(1, 1, shim, null); 
     647            ImapProtocol.FetchEnvelopeResponse[] result = shim.getResponses(); 
     648 
    622649            assertNotNull(result); 
    623650            assertEquals(1, result.length); 

  • trunk/LogicMailTests/src/org/logicprobe/LogicMail/model/MailboxNodeTest.java

    r538 r562  
    120120                public boolean containedWithin(FolderTreeItem folderTreeItem) { return true; } 
    121121                public String getMessageUid() { return null; } 
     122        public void updateToken(MessageToken messageToken) { } 
     123        public boolean isLoadable() { return true; } 
    122124        } 
    123125} 

  • trunk/LogicMailTests/src/org/logicprobe/LogicMail/model/MessageNodeWriterTest.java

    r538 r562  
    224224                        return "42"; 
    225225                } 
     226                 
     227        public void updateToken(MessageToken messageToken) { } 
     228        public boolean isLoadable() { return true; } 
    226229    } 
    227230     
Note: See TracChangeset for help on using the changeset viewer.