Changeset 616


Ignore:
Timestamp:
01/18/10 16:43:59 (2 years ago)
Author:
octorian
Message:

Added infrastructure to be notified of request-level success and failure with the mail store.

Location:
trunk
Files:
1 added
11 edited

Legend:

Unmodified
Added
Removed

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

    r588 r616  
    301301         */ 
    302302        protected void handleRequestFailed(int type, Object[] params, Throwable exception) { 
    303             // Empty default implementation 
     303        if(this.listener != null) { 
     304            listener.mailConnectionRequestFailed(type, params, exception); 
     305        } 
    304306        } 
    305307         

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

    r585 r616  
    403403    /** 
    404404     * Notifies all registered <tt>MailStoreListener</tt>s that 
     405     * a mail store request as completed.  
     406     *  
     407     * @param type The type of the event, which should be a constant defined on <code>RequestEvent</code>. 
     408     */ 
     409    protected void fireMailStoreRequestComplete(int type) { 
     410        Object[] listeners = listenerList.getListeners(MailStoreListener.class); 
     411        RequestEvent e = null; 
     412        for(int i=0; i<listeners.length; i++) { 
     413            if(e == null) { 
     414                e = new RequestEvent(this, type, null, null); 
     415            } 
     416            ((MailStoreListener)listeners[i]).mailStoreRequestComplete(e); 
     417        } 
     418    } 
     419     
     420    /** 
     421     * Notifies all registered <tt>MailStoreListener</tt>s that 
     422     * a mail store request has failed. 
     423     *  
     424     * @param root The type of the event, which should be a constant defined on <code>RequestEvent</code>. 
     425     * @param params The parameters passed along with the request. 
     426     * @param exception The exception that caused the request to fail, if applicable. 
     427     */ 
     428    protected void fireMailStoreRequestFailed(int type, Object[] params, Throwable exception) { 
     429        Object[] listeners = listenerList.getListeners(MailStoreListener.class); 
     430        RequestEvent e = null; 
     431        for(int i=0; i<listeners.length; i++) { 
     432            if(e == null) { 
     433                e = new RequestEvent(this, type, params, exception); 
     434            } 
     435            ((MailStoreListener)listeners[i]).mailStoreRequestFailed(e); 
     436        } 
     437    } 
     438     
     439    /** 
     440     * Notifies all registered <tt>MailStoreListener</tt>s that 
    405441     * the folder tree has been updated.  
    406442     *  

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

    r582 r616  
    4444 
    4545public class IncomingMailConnectionHandler extends AbstractMailConnectionHandler { 
    46         private IncomingMailClient incomingClient; 
    47          
    48         // The various mail store requests, mirroring the 
    49         // "requestXXXX()" methods from AbstractMailStore 
    50         public static final int REQUEST_FOLDER_TREE             = 10; 
     46    private IncomingMailClient incomingClient; 
     47 
     48    // The various mail store requests, mirroring the 
     49    // "requestXXXX()" methods from AbstractMailStore 
     50    public static final int REQUEST_FOLDER_TREE             = 10; 
    5151    public static final int REQUEST_FOLDER_EXPUNGE          = 11; 
    52         public static final int REQUEST_FOLDER_STATUS           = 12; 
    53         public static final int REQUEST_FOLDER_MESSAGES_RANGE   = 13; 
    54         public static final int REQUEST_FOLDER_MESSAGES_SET     = 14; 
    55         public static final int REQUEST_FOLDER_MESSAGES_RECENT  = 15; 
    56         public static final int REQUEST_MESSAGE                 = 20; 
    57         public static final int REQUEST_MESSAGE_PARTS           = 21; 
    58         public static final int REQUEST_MESSAGE_DELETE          = 22; 
    59         public static final int REQUEST_MESSAGE_UNDELETE        = 23; 
    60         public static final int REQUEST_MESSAGE_ANSWERED        = 24; 
    61         public static final int REQUEST_MESSAGE_APPEND          = 25; 
    62         public static final int REQUEST_MESSAGE_COPY            = 26; 
    63          
    64         /** 
    65         * Maximum amount of time to spend in the idle state. 
    66         * Currently set to 5 minutes. (1000 ms/sec * 60 sec/min * 5 min) 
    67         */ 
    68         private static final int IDLE_TIMEOUT = 300000; 
    69          
    70         /** 
    71         * Interval to poll the connection in the idle state. 
    72         * Currently set to 500ms. 
    73         */ 
    74         private static final int IDLE_POLL_INTERVAL = 500; 
    75          
    76         public IncomingMailConnectionHandler(IncomingMailClient client) { 
    77                 super(client); 
    78                 this.incomingClient = client; 
    79         } 
    80  
    81         /** 
    82         * Handles a specific request during the REQUESTS state. 
    83         *  
    84         * @param type Type identifier for the request. 
    85         * @param params Parameters for the request. 
     52    public static final int REQUEST_FOLDER_STATUS           = 12; 
     53    public static final int REQUEST_FOLDER_MESSAGES_RANGE   = 13; 
     54    public static final int REQUEST_FOLDER_MESSAGES_SET     = 14; 
     55    public static final int REQUEST_FOLDER_MESSAGES_RECENT  = 15; 
     56    public static final int REQUEST_MESSAGE                 = 20; 
     57    public static final int REQUEST_MESSAGE_PARTS           = 21; 
     58    public static final int REQUEST_MESSAGE_DELETE          = 22; 
     59    public static final int REQUEST_MESSAGE_UNDELETE        = 23; 
     60    public static final int REQUEST_MESSAGE_ANSWERED        = 24; 
     61    public static final int REQUEST_MESSAGE_APPEND          = 25; 
     62    public static final int REQUEST_MESSAGE_COPY            = 26; 
     63 
     64    /** 
     65    * Maximum amount of time to spend in the idle state. 
     66    * Currently set to 5 minutes. (1000 ms/sec * 60 sec/min * 5 min) 
     67    */ 
     68    private static final int IDLE_TIMEOUT = 300000; 
     69 
     70    /** 
     71    * Interval to poll the connection in the idle state. 
     72    * Currently set to 500ms. 
     73    */ 
     74    private static final int IDLE_POLL_INTERVAL = 500; 
     75 
     76    public IncomingMailConnectionHandler(IncomingMailClient client) { 
     77        super(client); 
     78        this.incomingClient = client; 
     79    } 
     80 
     81    /** 
     82    * Handles a specific request during the REQUESTS state. 
     83    *  
     84    * @param type Type identifier for the request. 
     85    * @param params Parameters for the request. 
    8686     * @throws IOException on I/O errors 
    8787     * @throws MailException on protocol errors 
    88         */ 
    89         protected void handleRequest(int type, Object[] params) throws IOException, MailException { 
    90                 switch(type) { 
    91                 case REQUEST_FOLDER_TREE: 
    92                         handleRequestFolderTree(); 
    93                         break; 
    94                 case REQUEST_FOLDER_EXPUNGE: 
    95                     handleRequestFolderExpunge((FolderTreeItem)params[0]); 
    96                     break; 
    97                 case REQUEST_FOLDER_STATUS: 
    98                         handleRequestFolderStatus((FolderTreeItem[])params[0]); 
    99                         break; 
    100                 case REQUEST_FOLDER_MESSAGES_RANGE: 
    101                         handleRequestFolderMessagesRange( 
    102                                         (FolderTreeItem)params[0], 
    103                                         ((Integer)params[1]).intValue(), 
    104                                         ((Integer)params[2]).intValue()); 
    105                         break; 
    106                 case REQUEST_FOLDER_MESSAGES_SET: 
    107                         handleRequestFolderMessagesSet( 
    108                                         (FolderTreeItem)params[0], 
    109                                         (MessageToken[])params[1]); 
    110                         break; 
    111                 case REQUEST_FOLDER_MESSAGES_RECENT: 
    112                         handleRequestFolderMessagesRecent( 
    113                                         (FolderTreeItem)params[0], ((Boolean)params[1]).booleanValue()); 
    114                         break; 
    115                 case REQUEST_MESSAGE: 
    116                         handleRequestMessage((MessageToken)params[0]); 
    117                         break; 
    118                 case REQUEST_MESSAGE_PARTS: 
    119                         handleRequestMessageParts((MessageToken)params[0], (MimeMessagePart[])params[1]); 
    120                         break; 
    121                 case REQUEST_MESSAGE_DELETE: 
    122                         handleRequestMessageDelete((MessageToken)params[0], (MessageFlags)params[1]); 
    123                         break; 
    124                 case REQUEST_MESSAGE_UNDELETE: 
    125                         handleRequestMessageUndelete((MessageToken)params[0], (MessageFlags)params[1]); 
    126                         break; 
    127                 case REQUEST_MESSAGE_ANSWERED: 
    128                         handleRequestMessageAnswered((MessageToken)params[0], (MessageFlags)params[1]); 
    129                         break; 
    130                 case REQUEST_MESSAGE_APPEND: 
    131                         handleRequestMessageAppend((FolderTreeItem)params[0], (String)params[1], (MessageFlags)params[2]); 
    132                         break; 
    133                 case REQUEST_MESSAGE_COPY: 
    134                         handleRequestMessageCopy((MessageToken)params[0], (FolderTreeItem)params[1]); 
    135                 } 
    136         } 
     88    */ 
     89    protected void handleRequest(int type, Object[] params) throws IOException, MailException { 
     90        switch(type) { 
     91        case REQUEST_FOLDER_TREE: 
     92            handleRequestFolderTree(); 
     93            break; 
     94        case REQUEST_FOLDER_EXPUNGE: 
     95            handleRequestFolderExpunge((FolderTreeItem)params[0]); 
     96            break; 
     97        case REQUEST_FOLDER_STATUS: 
     98            handleRequestFolderStatus((FolderTreeItem[])params[0]); 
     99            break; 
     100        case REQUEST_FOLDER_MESSAGES_RANGE: 
     101            handleRequestFolderMessagesRange( 
     102                    (FolderTreeItem)params[0], 
     103                    ((Integer)params[1]).intValue(), 
     104                    ((Integer)params[2]).intValue()); 
     105            break; 
     106        case REQUEST_FOLDER_MESSAGES_SET: 
     107            handleRequestFolderMessagesSet( 
     108                    (FolderTreeItem)params[0], 
     109                    (MessageToken[])params[1]); 
     110            break; 
     111        case REQUEST_FOLDER_MESSAGES_RECENT: 
     112            handleRequestFolderMessagesRecent( 
     113                    (FolderTreeItem)params[0], ((Boolean)params[1]).booleanValue()); 
     114            break; 
     115        case REQUEST_MESSAGE: 
     116            handleRequestMessage((MessageToken)params[0]); 
     117            break; 
     118        case REQUEST_MESSAGE_PARTS: 
     119            handleRequestMessageParts((MessageToken)params[0], (MimeMessagePart[])params[1]); 
     120            break; 
     121        case REQUEST_MESSAGE_DELETE: 
     122            handleRequestMessageDelete((MessageToken)params[0], (MessageFlags)params[1]); 
     123            break; 
     124        case REQUEST_MESSAGE_UNDELETE: 
     125            handleRequestMessageUndelete((MessageToken)params[0], (MessageFlags)params[1]); 
     126            break; 
     127        case REQUEST_MESSAGE_ANSWERED: 
     128            handleRequestMessageAnswered((MessageToken)params[0], (MessageFlags)params[1]); 
     129            break; 
     130        case REQUEST_MESSAGE_APPEND: 
     131            handleRequestMessageAppend((FolderTreeItem)params[0], (String)params[1], (MessageFlags)params[2]); 
     132            break; 
     133        case REQUEST_MESSAGE_COPY: 
     134            handleRequestMessageCopy((MessageToken)params[0], (FolderTreeItem)params[1]); 
     135        } 
     136    } 
    137137 
    138138    /** 
    139         * Handles the start of the IDLE state. 
    140         */ 
    141         protected void handleBeginIdle() throws IOException, MailException { 
    142                 if(incomingClient.hasIdle()) { 
    143                         incomingClient.idleModeBegin(); 
    144                         boolean endIdle = false; 
    145                         int idleTime = 0; 
    146                         while(!endIdle) { 
    147                                 sleepConnectionThread(IDLE_POLL_INTERVAL); 
    148                                 idleTime += IDLE_POLL_INTERVAL; 
    149                                 if(incomingClient.idleModePoll()) { 
    150                                         addRequest( 
    151                                                         IncomingMailConnectionHandler.REQUEST_FOLDER_MESSAGES_RECENT, 
    152                                                         new Object[] { incomingClient.getActiveFolder() }); 
    153                                         endIdle = true; 
    154                                 } 
    155                                 else if(getShutdownInProgress()) { 
    156                                         endIdle = true; 
    157                                 } 
    158                                 else if(idleTime >= IDLE_TIMEOUT) { 
    159                                         endIdle = true; 
    160                                 } 
    161                                 else 
    162                                 { 
    163                                         Queue requestQueue = getRequestQueue(); 
    164                                         synchronized(requestQueue) { 
    165                                                 if(requestQueue.element() != null) { 
    166                                                         endIdle = true; 
    167                                                 } 
    168                                         } 
    169                                 } 
    170                         } 
    171                         incomingClient.idleModeEnd(); 
    172                          
    173                         // If the idle state was ended due to a timeout, perform a no-operation 
    174                         // command on the mail server as a final explicit check for new messages. 
    175                         if(idleTime >= IDLE_TIMEOUT) { 
    176                                 if(incomingClient.noop()) { 
    177                                         addRequest( 
    178                                                         IncomingMailConnectionHandler.REQUEST_FOLDER_MESSAGES_RECENT, 
    179                                                         new Object[] { incomingClient.getActiveFolder() }); 
    180                                 } 
    181                                 else { 
    182                                         // If we had a non-INBOX folder selected, then an idle timeout 
    183                                         // should switch the active folder back to the INBOX. 
    184                                         FolderTreeItem inboxMailbox = incomingClient.getInboxFolder(); 
    185                                         FolderTreeItem activeMailbox = incomingClient.getActiveFolder(); 
    186                                         if(inboxMailbox != null && !inboxMailbox.getPath().equalsIgnoreCase(activeMailbox.getPath())) { 
    187                                                 incomingClient.setActiveFolder(inboxMailbox); 
    188                                         } 
    189                                 } 
    190                         } 
    191                 } 
    192                 else { 
    193                         Queue requestQueue = getRequestQueue(); 
    194                         synchronized(requestQueue) { 
    195                                 if(requestQueue.element() != null) { 
    196                                         return; 
    197                                 } 
    198                                 else { 
    199                                         try { 
    200                                                 requestQueue.wait(); 
    201                                         } catch (InterruptedException e) { } 
    202                                 } 
    203                         } 
    204                 } 
    205         } 
    206  
    207         private void handleRequestFolderTree() throws IOException, MailException { 
    208                 String message = resources.getString(LogicMailResource.MAILCONNECTION_REQUEST_FOLDER_TREE); 
    209                 showStatus(message); 
    210                 FolderTreeItem root = incomingClient.getFolderTree(getProgressHandler(message)); 
    211  
    212                 MailConnectionHandlerListener listener = getListener(); 
    213                 if(root != null && listener != null) { 
    214                         listener.mailConnectionRequestComplete(REQUEST_FOLDER_TREE, root); 
    215                 } 
    216         } 
     139    * Handles the start of the IDLE state. 
     140    */ 
     141    protected void handleBeginIdle() throws IOException, MailException { 
     142        if(incomingClient.hasIdle()) { 
     143            incomingClient.idleModeBegin(); 
     144            boolean endIdle = false; 
     145            int idleTime = 0; 
     146            while(!endIdle) { 
     147                sleepConnectionThread(IDLE_POLL_INTERVAL); 
     148                idleTime += IDLE_POLL_INTERVAL; 
     149                if(incomingClient.idleModePoll()) { 
     150                    addRequest( 
     151                            IncomingMailConnectionHandler.REQUEST_FOLDER_MESSAGES_RECENT, 
     152                            new Object[] { incomingClient.getActiveFolder() }); 
     153                    endIdle = true; 
     154                } 
     155                else if(getShutdownInProgress()) { 
     156                    endIdle = true; 
     157                } 
     158                else if(idleTime >= IDLE_TIMEOUT) { 
     159                    endIdle = true; 
     160                } 
     161                else 
     162                { 
     163                    Queue requestQueue = getRequestQueue(); 
     164                    synchronized(requestQueue) { 
     165                        if(requestQueue.element() != null) { 
     166                            endIdle = true; 
     167                        } 
     168                    } 
     169                } 
     170            } 
     171            incomingClient.idleModeEnd(); 
     172 
     173            // If the idle state was ended due to a timeout, perform a no-operation 
     174            // command on the mail server as a final explicit check for new messages. 
     175            if(idleTime >= IDLE_TIMEOUT) { 
     176                if(incomingClient.noop()) { 
     177                    addRequest( 
     178                            IncomingMailConnectionHandler.REQUEST_FOLDER_MESSAGES_RECENT, 
     179                            new Object[] { incomingClient.getActiveFolder() }); 
     180                } 
     181                else { 
     182                    // If we had a non-INBOX folder selected, then an idle timeout 
     183                    // should switch the active folder back to the INBOX. 
     184                    FolderTreeItem inboxMailbox = incomingClient.getInboxFolder(); 
     185                    FolderTreeItem activeMailbox = incomingClient.getActiveFolder(); 
     186                    if(inboxMailbox != null && !inboxMailbox.getPath().equalsIgnoreCase(activeMailbox.getPath())) { 
     187                        incomingClient.setActiveFolder(inboxMailbox); 
     188                    } 
     189                } 
     190            } 
     191        } 
     192        else { 
     193            Queue requestQueue = getRequestQueue(); 
     194            synchronized(requestQueue) { 
     195                if(requestQueue.element() != null) { 
     196                    return; 
     197                } 
     198                else { 
     199                    try { 
     200                        requestQueue.wait(); 
     201                    } catch (InterruptedException e) { } 
     202                } 
     203            } 
     204        } 
     205    } 
     206 
     207    private void handleRequestFolderTree() throws IOException, MailException { 
     208        String message = resources.getString(LogicMailResource.MAILCONNECTION_REQUEST_FOLDER_TREE); 
     209        showStatus(message); 
     210        FolderTreeItem root = incomingClient.getFolderTree(getProgressHandler(message)); 
     211 
     212        MailConnectionHandlerListener listener = getListener(); 
     213        if(root != null && listener != null) { 
     214            listener.mailConnectionRequestComplete(REQUEST_FOLDER_TREE, root); 
     215        } 
     216    } 
    217217 
    218218    private void handleRequestFolderExpunge(FolderTreeItem folder) throws IOException, MailException { 
    … …  
    221221        checkActiveFolder(folder); 
    222222        incomingClient.expungeActiveFolder(); 
    223          
     223 
    224224        MailConnectionHandlerListener listener = getListener(); 
    225225        if(listener != null) { 
    … …  
    227227        } 
    228228    } 
    229      
    230         private void handleRequestFolderStatus(FolderTreeItem[] folders) throws IOException, MailException { 
    231                 String message = resources.getString(LogicMailResource.MAILCONNECTION_REQUEST_FOLDER_STATUS); 
    232                 showStatus(message); 
    233                 incomingClient.refreshFolderStatus(folders, getProgressHandler(message)); 
    234                  
    235                 MailConnectionHandlerListener listener = getListener(); 
    236                 if(listener != null) { 
    237                         listener.mailConnectionRequestComplete(REQUEST_FOLDER_STATUS, folders); 
    238                 } 
    239         } 
    240          
     229 
     230    private void handleRequestFolderStatus(FolderTreeItem[] folders) throws IOException, MailException { 
     231        String message = resources.getString(LogicMailResource.MAILCONNECTION_REQUEST_FOLDER_STATUS); 
     232        showStatus(message); 
     233        incomingClient.refreshFolderStatus(folders, getProgressHandler(message)); 
     234 
     235        MailConnectionHandlerListener listener = getListener(); 
     236        if(listener != null) { 
     237            listener.mailConnectionRequestComplete(REQUEST_FOLDER_STATUS, folders); 
     238        } 
     239    } 
     240 
    241241    private static class GetFolderMessageCallback implements FolderMessageCallback { 
    242242        private int maxCount; 
    … …  
    247247        private FolderMessage[] folderMessages; 
    248248        private int count; 
    249          
     249 
    250250        public GetFolderMessageCallback(int maxCount, int type, FolderTreeItem folder, MailConnectionHandlerListener listener) { 
    251251            this(maxCount, type, folder, listener, null); 
    252252        } 
    253          
     253 
    254254        public GetFolderMessageCallback(int maxCount, int type, FolderTreeItem folder, MailConnectionHandlerListener listener, Object param) { 
    255255            this.maxCount = maxCount; 
    … …  
    260260            this.count = 0; 
    261261        } 
    262          
     262 
    263263        public void folderMessageUpdate(FolderMessage folderMessage) { 
    264264            FolderMessage[] resultMessages = null; 
    … …  
    295295                    } 
    296296                } 
    297                  
     297 
    298298                // If this is the last update of the sequence, make sure we notify 
    299299                // the listener with a null array so it knows we are done. 
    … …  
    310310    }; 
    311311 
    312          
    313         private void handleRequestFolderMessagesRange(FolderTreeItem folder, int firstIndex, int lastIndex) throws IOException, MailException { 
    314                 String message = resources.getString(LogicMailResource.MAILCONNECTION_REQUEST_FOLDER_MESSAGES); 
    315                 showStatus(message + "..."); 
    316                 checkActiveFolder(folder); 
    317                  
    318                 incomingClient.getFolderMessages( 
    319                         firstIndex, lastIndex, 
    320                         new GetFolderMessageCallback( 
    321                                 getFolderMessageUpdateFrequency(), 
    322                                 REQUEST_FOLDER_MESSAGES_RANGE, 
    323                                 folder, 
    324                                 getListener()), 
    325                         getProgressHandler(message)); 
    326         } 
    327          
    328         private void handleRequestFolderMessagesSet(FolderTreeItem folder, MessageToken[] messageTokens) throws IOException, MailException { 
    329                 String message = resources.getString(LogicMailResource.MAILCONNECTION_REQUEST_FOLDER_MESSAGES); 
    330                 showStatus(message + "..."); 
    331                 checkActiveFolder(folder); 
    332                  
    333                 incomingClient.getFolderMessages( 
    334                         messageTokens, 
    335                         new GetFolderMessageCallback( 
    336                                 getFolderMessageUpdateFrequency(), 
    337                                 REQUEST_FOLDER_MESSAGES_SET, 
    338                                 folder, 
    339                                 getListener()), 
    340                         getProgressHandler(message)); 
    341         } 
    342          
    343         private void handleRequestFolderMessagesRecent(FolderTreeItem folder, boolean flagsOnly) throws IOException, MailException { 
    344                 String message = resources.getString(LogicMailResource.MAILCONNECTION_REQUEST_FOLDER_MESSAGES); 
    345                 showStatus(message + "..."); 
    346                 checkActiveFolder(folder); 
    347          
    348                 incomingClient.getNewFolderMessages( 
    349                         flagsOnly, 
    350                         new GetFolderMessageCallback( 
    351                                 getFolderMessageUpdateFrequency(), 
    352                                 REQUEST_FOLDER_MESSAGES_RECENT, 
    353                                 folder, 
    354                                 getListener(), 
    355                                 new Boolean(flagsOnly)), 
    356                         getProgressHandler(message)); 
    357         } 
    358          
    359         private int getFolderMessageUpdateFrequency() { 
    360             // Replace this with a more general method: 
    361             int frequency; 
    362             if(incomingClient instanceof org.logicprobe.LogicMail.mail.imap.ImapClient) { 
    363                 frequency = 5; 
    364             } 
    365             else if(incomingClient instanceof org.logicprobe.LogicMail.mail.pop.PopClient) { 
    366                 frequency = 2; 
    367             } 
    368             else { 
    369                 frequency = 10; 
    370             } 
    371             return frequency; 
    372         } 
    373          
    374         private void handleRequestMessage(MessageToken messageToken) throws IOException, MailException { 
    375                 String statusMessage = resources.getString(LogicMailResource.MAILCONNECTION_REQUEST_MESSAGE); 
    376                 showStatus(statusMessage); 
    377                 checkActiveFolder(messageToken); 
    378                  
    379                 Message message = incomingClient.getMessage(messageToken, getProgressHandler(statusMessage)); 
    380                  
    381                 MailConnectionHandlerListener listener = getListener(); 
    382                 if(message != null && listener != null) { 
    383                         listener.mailConnectionRequestComplete(REQUEST_MESSAGE, new Object[] { messageToken, message.getStructure(), message.getAllContent() }); 
    384                 } 
    385         } 
    386  
    387         private void handleRequestMessageParts(MessageToken messageToken, MimeMessagePart[] messageParts) throws IOException, MailException { 
    388                 String statusMessage = resources.getString(LogicMailResource.MAILCONNECTION_REQUEST_MESSAGE); 
    389                 showStatus(statusMessage); 
    390                 checkActiveFolder(messageToken); 
    391  
    392                 MimeMessageContent[] messageContent; 
    393                  
    394                 // Replace this with a more general method: 
    395                 if(incomingClient instanceof org.logicprobe.LogicMail.mail.imap.ImapClient) { 
    396                         Vector messageContentVector = new Vector(); 
    397                         for(int i=0; i<messageParts.length; i++) { 
    398                                 MimeMessageContent content = 
    399                                         ((org.logicprobe.LogicMail.mail.imap.ImapClient)incomingClient).getMessagePart(messageToken, messageParts[i], getProgressHandler(statusMessage)); 
    400                                 if(content != null) { 
    401                                         messageContentVector.addElement(content); 
    402                                 } 
    403                         } 
    404                         messageContent = new MimeMessageContent[messageContentVector.size()]; 
    405                         messageContentVector.copyInto(messageContent); 
    406                 } 
    407                 else { 
    408                         messageContent = null; 
    409                 } 
    410                  
    411                 MailConnectionHandlerListener listener = getListener(); 
    412                 if(messageContent != null && listener != null) { 
    413                         listener.mailConnectionRequestComplete(REQUEST_MESSAGE_PARTS, new Object[] { messageToken, messageContent }); 
    414                 } 
    415         } 
    416          
    417         private void handleRequestMessageDelete(MessageToken messageToken, MessageFlags messageFlags) throws IOException, MailException { 
    418                 showStatus(resources.getString(LogicMailResource.MAILCONNECTION_REQUEST_MESSAGE_DELETE)); 
    419                 checkActiveFolder(messageToken); 
    420                  
    421                 incomingClient.deleteMessage(messageToken, messageFlags); 
    422                  
    423                 MailConnectionHandlerListener listener = getListener(); 
    424                 if(listener != null) { 
    425                         listener.mailConnectionRequestComplete(REQUEST_MESSAGE_DELETE, new Object[] { messageToken, messageFlags }); 
    426                 } 
    427         } 
    428          
    429         private void handleRequestMessageUndelete(MessageToken messageToken, MessageFlags messageFlags) throws IOException, MailException { 
    430                 showStatus(resources.getString(LogicMailResource.MAILCONNECTION_REQUEST_MESSAGE_UNDELETE)); 
    431                 checkActiveFolder(messageToken); 
    432                  
    433                 incomingClient.undeleteMessage(messageToken, messageFlags); 
    434  
    435                 MailConnectionHandlerListener listener = getListener(); 
    436                 if(listener != null) { 
    437                         listener.mailConnectionRequestComplete(REQUEST_MESSAGE_UNDELETE, new Object[] { messageToken, messageFlags }); 
    438                 } 
    439         } 
    440          
    441         private void handleRequestMessageAnswered(MessageToken messageToken, MessageFlags messageFlags) throws IOException, MailException { 
    442                 showStatus(resources.getString(LogicMailResource.MAILCONNECTION_REQUEST_MESSAGE_ANSWERED)); 
    443                 // Replace this with a more general method: 
    444                 if(incomingClient instanceof org.logicprobe.LogicMail.mail.imap.ImapClient) { 
    445                         ((org.logicprobe.LogicMail.mail.imap.ImapClient)incomingClient).messageAnswered(messageToken, messageFlags); 
    446                 } 
    447                 messageFlags.setAnswered(true); 
    448                  
    449                 MailConnectionHandlerListener listener = getListener(); 
    450                 if(listener != null) { 
    451                         listener.mailConnectionRequestComplete(REQUEST_MESSAGE_ANSWERED, new Object[] { messageToken, messageFlags }); 
    452                 } 
    453         } 
    454          
    455         private void handleRequestMessageAppend(FolderTreeItem folder, String rawMessage, MessageFlags initialFlags) throws IOException, MailException { 
    456                 showStatus(resources.getString(LogicMailResource.MAILCONNECTION_REQUEST_MESSAGE_APPEND)); 
    457                 // Clean up this interface: 
    458                 if(incomingClient.hasAppend()) { 
    459                         incomingClient.appendMessage(folder, rawMessage, initialFlags); 
    460                 } 
    461                  
    462                 MailConnectionHandlerListener listener = getListener(); 
    463                 if(listener != null) { 
    464                         // Using a null FolderMessage since no information is returned on the appended message: 
    465                         listener.mailConnectionRequestComplete(REQUEST_MESSAGE_APPEND, new Object[] { folder, null }); 
    466                 } 
    467         } 
    468  
    469         private void handleRequestMessageCopy(MessageToken messageToken, FolderTreeItem destinationFolder) throws IOException, MailException { 
    470                 showStatus(resources.getString(LogicMailResource.MAILCONNECTION_REQUEST_MESSAGE_COPY)); 
    471                 if(incomingClient.hasCopy()) { 
    472                         checkActiveFolder(messageToken); 
    473                         incomingClient.copyMessage(messageToken, destinationFolder); 
    474                 } 
    475                  
    476                 MailConnectionHandlerListener listener = getListener(); 
    477                 if(listener != null) { 
    478                         // Using a null FolderMessage since no information is returned on the appended message: 
    479                         listener.mailConnectionRequestComplete(REQUEST_MESSAGE_COPY, new Object[] { messageToken, destinationFolder }); 
    480                 } 
    481         } 
    482          
    483         private void checkActiveFolder(FolderTreeItem requestFolder) throws IOException, MailException { 
    484                 if(incomingClient.getActiveFolder() == null || !incomingClient.getActiveFolder().getPath().equals(requestFolder.getPath())) { 
    485                         incomingClient.setActiveFolder(requestFolder); 
    486                 } 
    487         } 
    488  
    489         private void checkActiveFolder(MessageToken messageToken) throws IOException, MailException { 
    490                 incomingClient.setActiveFolder(messageToken); 
    491         } 
     312    private void handleRequestFolderMessagesRange(FolderTreeItem folder, int firstIndex, int lastIndex) throws IOException, MailException { 
     313        String message = resources.getString(LogicMailResource.MAILCONNECTION_REQUEST_FOLDER_MESSAGES); 
     314        showStatus(message + "..."); 
     315        checkActiveFolder(folder); 
     316 
     317        incomingClient.getFolderMessages( 
     318                firstIndex, lastIndex, 
     319                new GetFolderMessageCallback( 
     320                        getFolderMessageUpdateFrequency(), 
     321                        REQUEST_FOLDER_MESSAGES_RANGE, 
     322                        folder, 
     323                        getListener()), 
     324                        getProgressHandler(message)); 
     325    } 
     326     
     327    private void handleRequestFolderMessagesSet(FolderTreeItem folder, MessageToken[] messageTokens) throws IOException, MailException { 
     328        String message = resources.getString(LogicMailResource.MAILCONNECTION_REQUEST_FOLDER_MESSAGES); 
     329        showStatus(message + "..."); 
     330        checkActiveFolder(folder); 
     331 
     332        incomingClient.getFolderMessages( 
     333                messageTokens, 
     334                new GetFolderMessageCallback( 
     335                        getFolderMessageUpdateFrequency(), 
     336                        REQUEST_FOLDER_MESSAGES_SET, 
     337                        folder, 
     338                        getListener()), 
     339                        getProgressHandler(message)); 
     340    } 
     341     
     342    private void handleRequestFolderMessagesRecent(FolderTreeItem folder, boolean flagsOnly) throws IOException, MailException { 
     343        String message = resources.getString(LogicMailResource.MAILCONNECTION_REQUEST_FOLDER_MESSAGES); 
     344        showStatus(message + "..."); 
     345        checkActiveFolder(folder); 
     346 
     347        incomingClient.getNewFolderMessages( 
     348                flagsOnly, 
     349                new GetFolderMessageCallback( 
     350                        getFolderMessageUpdateFrequency(), 
     351                        REQUEST_FOLDER_MESSAGES_RECENT, 
     352                        folder, 
     353                        getListener(), 
     354                        new Boolean(flagsOnly)), 
     355                        getProgressHandler(message)); 
     356    } 
     357 
     358    private int getFolderMessageUpdateFrequency() { 
     359        // Replace this with a more general method: 
     360        int frequency; 
     361        if(incomingClient instanceof org.logicprobe.LogicMail.mail.imap.ImapClient) { 
     362            frequency = 5; 
     363        } 
     364        else if(incomingClient instanceof org.logicprobe.LogicMail.mail.pop.PopClient) { 
     365            frequency = 2; 
     366        } 
     367        else { 
     368            frequency = 10; 
     369        } 
     370        return frequency; 
     371    } 
     372     
     373    private void handleRequestMessage(MessageToken messageToken) throws IOException, MailException { 
     374        String statusMessage = resources.getString(LogicMailResource.MAILCONNECTION_REQUEST_MESSAGE); 
     375        showStatus(statusMessage); 
     376        checkActiveFolder(messageToken); 
     377 
     378        Message message = incomingClient.getMessage(messageToken, getProgressHandler(statusMessage)); 
     379 
     380        MailConnectionHandlerListener listener = getListener(); 
     381        if(message != null && listener != null) { 
     382            listener.mailConnectionRequestComplete(REQUEST_MESSAGE, new Object[] { messageToken, message.getStructure(), message.getAllContent() }); 
     383        } 
     384    } 
     385     
     386    private void handleRequestMessageParts(MessageToken messageToken, MimeMessagePart[] messageParts) throws IOException, MailException { 
     387        String statusMessage = resources.getString(LogicMailResource.MAILCONNECTION_REQUEST_MESSAGE); 
     388        showStatus(statusMessage); 
     389        checkActiveFolder(messageToken); 
     390 
     391        MimeMessageContent[] messageContent; 
     392 
     393        // Replace this with a more general method: 
     394        if(incomingClient instanceof org.logicprobe.LogicMail.mail.imap.ImapClient) { 
     395            Vector messageContentVector = new Vector(); 
     396            for(int i=0; i<messageParts.length; i++) { 
     397                MimeMessageContent content = 
     398                    ((org.logicprobe.LogicMail.mail.imap.ImapClient)incomingClient).getMessagePart(messageToken, messageParts[i], getProgressHandler(statusMessage)); 
     399                if(content != null) { 
     400                    messageContentVector.addElement(content); 
     401                } 
     402            } 
     403            messageContent = new MimeMessageContent[messageContentVector.size()]; 
     404            messageContentVector.copyInto(messageContent); 
     405        } 
     406        else { 
     407            messageContent = null; 
     408        } 
     409 
     410        MailConnectionHandlerListener listener = getListener(); 
     411        if(messageContent != null && listener != null) { 
     412            listener.mailConnectionRequestComplete(REQUEST_MESSAGE_PARTS, new Object[] { messageToken, messageContent }); 
     413        } 
     414    } 
     415 
     416    private void handleRequestMessageDelete(MessageToken messageToken, MessageFlags messageFlags) throws IOException, MailException { 
     417        showStatus(resources.getString(LogicMailResource.MAILCONNECTION_REQUEST_MESSAGE_DELETE)); 
     418        checkActiveFolder(messageToken); 
     419 
     420        incomingClient.deleteMessage(messageToken, messageFlags); 
     421 
     422        MailConnectionHandlerListener listener = getListener(); 
     423        if(listener != null) { 
     424            listener.mailConnectionRequestComplete(REQUEST_MESSAGE_DELETE, new Object[] { messageToken, messageFlags }); 
     425        } 
     426    } 
     427     
     428    private void handleRequestMessageUndelete(MessageToken messageToken, MessageFlags messageFlags) throws IOException, MailException { 
     429        showStatus(resources.getString(LogicMailResource.MAILCONNECTION_REQUEST_MESSAGE_UNDELETE)); 
     430        checkActiveFolder(messageToken); 
     431 
     432        incomingClient.undeleteMessage(messageToken, messageFlags); 
     433 
     434        MailConnectionHandlerListener listener = getListener(); 
     435        if(listener != null) { 
     436            listener.mailConnectionRequestComplete(REQUEST_MESSAGE_UNDELETE, new Object[] { messageToken, messageFlags }); 
     437        } 
     438    } 
     439     
     440    private void handleRequestMessageAnswered(MessageToken messageToken, MessageFlags messageFlags) throws IOException, MailException { 
     441        showStatus(resources.getString(LogicMailResource.MAILCONNECTION_REQUEST_MESSAGE_ANSWERED)); 
     442        // Replace this with a more general method: 
     443        if(incomingClient instanceof org.logicprobe.LogicMail.mail.imap.ImapClient) { 
     444            ((org.logicprobe.LogicMail.mail.imap.ImapClient)incomingClient).messageAnswered(messageToken, messageFlags); 
     445        } 
     446        messageFlags.setAnswered(true); 
     447 
     448        MailConnectionHandlerListener listener = getListener(); 
     449        if(listener != null) { 
     450            listener.mailConnectionRequestComplete(REQUEST_MESSAGE_ANSWERED, new Object[] { messageToken, messageFlags }); 
     451        } 
     452    } 
     453     
     454    private void handleRequestMessageAppend(FolderTreeItem folder, String rawMessage, MessageFlags initialFlags) throws IOException, MailException { 
     455        showStatus(resources.getString(LogicMailResource.MAILCONNECTION_REQUEST_MESSAGE_APPEND)); 
     456        // Clean up this interface: 
     457        if(incomingClient.hasAppend()) { 
     458            incomingClient.appendMessage(folder, rawMessage, initialFlags); 
     459        } 
     460 
     461        MailConnectionHandlerListener listener = getListener(); 
     462        if(listener != null) { 
     463            // Using a null FolderMessage since no information is returned on the appended message: 
     464            listener.mailConnectionRequestComplete(REQUEST_MESSAGE_APPEND, new Object[] { folder, null }); 
     465        } 
     466    } 
     467     
     468    private void handleRequestMessageCopy(MessageToken messageToken, FolderTreeItem destinationFolder) throws IOException, MailException { 
     469        showStatus(resources.getString(LogicMailResource.MAILCONNECTION_REQUEST_MESSAGE_COPY)); 
     470        if(incomingClient.hasCopy()) { 
     471            checkActiveFolder(messageToken); 
     472            incomingClient.copyMessage(messageToken, destinationFolder); 
     473        } 
     474 
     475        MailConnectionHandlerListener listener = getListener(); 
     476        if(listener != null) { 
     477            // Using a null FolderMessage since no information is returned on the appended message: 
     478            listener.mailConnectionRequestComplete(REQUEST_MESSAGE_COPY, new Object[] { messageToken, destinationFolder }); 
     479        } 
     480    } 
     481 
     482    private void checkActiveFolder(FolderTreeItem requestFolder) throws IOException, MailException { 
     483        if(incomingClient.getActiveFolder() == null || !incomingClient.getActiveFolder().getPath().equals(requestFolder.getPath())) { 
     484            incomingClient.setActiveFolder(requestFolder); 
     485        } 
     486    } 
     487 
     488    private void checkActiveFolder(MessageToken messageToken) throws IOException, MailException { 
     489        incomingClient.setActiveFolder(messageToken); 
     490    } 
    492491} 

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

    r591 r616  
    3939import javax.microedition.io.file.FileConnection; 
    4040 
     41import net.rim.device.api.system.EventLogger; 
    4142import net.rim.device.api.system.UnsupportedOperationException; 
    4243 
     44import org.logicprobe.LogicMail.AppInfo; 
    4345import org.logicprobe.LogicMail.conf.GlobalConfig; 
    4446import org.logicprobe.LogicMail.conf.MailSettings; 
    … …  
    120122     
    121123    public void requestFolderTree() { 
     124        fireMailStoreRequestComplete(RequestEvent.TYPE_FOLDER_TREE); 
    122125        fireFolderTreeUpdated(rootFolder); 
    123126    } 
    … …  
    137140         
    138141        public void run() { 
     142            Throwable throwable = null; 
    139143            boolean expunged = false; 
    140144            try { 
    … …  
    144148                expunged = true; 
    145149            } catch (IOException e) { 
    146                 System.err.println("Unable to expunge folder: " + e.toString()); 
     150                EventLogger.logEvent(AppInfo.GUID, ("Unable to expunge folder: " + e.toString()).getBytes(), EventLogger.ERROR); 
     151                throwable = e; 
    147152            } 
    148153             
    149154            if(expunged) { 
     155                fireMailStoreRequestComplete(RequestEvent.TYPE_FOLDER_EXPUNGE); 
    150156                fireFolderExpunged(requestFolder); 
     157            } 
     158            else { 
     159                fireMailStoreRequestFailed(RequestEvent.TYPE_FOLDER_EXPUNGE, new Object[] { requestFolder }, throwable); 
    151160            } 
    152161        } 
    … …  
    169178            } 
    170179        } 
    171  
     180         
     181        fireMailStoreRequestComplete(RequestEvent.TYPE_FOLDER_STATUS); 
    172182        for (int i = 0; i < folders.length; i++) { 
    173183            fireFolderStatusChanged(folders[i]); 
    … …  
    199209         
    200210                public void run() { 
     211                    Throwable throwable = null; 
    201212                FolderMessage[] folderMessages = null; 
    202213                try { 
    … …  
    205216                        maildirFolder.close(); 
    206217                } catch (IOException e) { 
    207                         System.err.println("Unable to read folder: " + e.toString()); 
     218                EventLogger.logEvent(AppInfo.GUID, ("Unable to read folder: " + e.toString()).getBytes(), EventLogger.ERROR); 
     219                        throwable = e; 
    208220                } 
    209221                 
    210222                if(folderMessages != null) { 
     223                    fireMailStoreRequestComplete(RequestEvent.TYPE_FOLDER_MESSAGES_RECENT); 
    211224                        fireFolderMessagesAvailable(requestFolder, folderMessages, false); 
     225                } 
     226                else { 
     227                    fireMailStoreRequestFailed(RequestEvent.TYPE_FOLDER_MESSAGES_RECENT, new Object[] { requestFolder }, throwable); 
    212228                } 
    213229                } 
    … …  
    232248         
    233249                public void run() { 
     250                    Throwable throwable = null; 
    234251                        String messageSource = null; 
    235252                        Message message = null; 
    … …  
    249266                } 
    250267                } catch (IOException e) { 
    251                         System.err.println("Unable to read message: " + e.toString()); 
     268                EventLogger.logEvent(AppInfo.GUID, ("Unable to read message: " + e.toString()).getBytes(), EventLogger.ERROR); 
     269                        message = null; 
     270                        messageSource = null; 
     271                        throwable = e; 
    252272                } 
    253273                 
    254274                if(message != null && messageSource != null) { 
     275                    fireMailStoreRequestComplete(RequestEvent.TYPE_MESSAGE); 
    255276                        fireMessageAvailable(localMessageToken, message.getStructure(), message.getAllContent(), messageSource); 
     277                } 
     278                else { 
     279                    fireMailStoreRequestFailed(RequestEvent.TYPE_MESSAGE, new Object[] { localMessageToken }, throwable); 
    256280                } 
    257281                } 
    … …  
    269293            MessageFlags newFlags = copyMessageFlags(messageFlags); 
    270294            newFlags.setDeleted(true); 
    271             threadQueue.invokeLater(new UpdateMessageFlagsRunnable(requestFolder, localMessageToken, newFlags)); 
     295            threadQueue.invokeLater(new UpdateMessageFlagsRunnable(requestFolder, localMessageToken, newFlags, RequestEvent.TYPE_MESSAGE_DELETE)); 
    272296        } 
    273297    } 
    … …  
    280304            MessageFlags newFlags = copyMessageFlags(messageFlags); 
    281305            newFlags.setDeleted(false); 
    282             threadQueue.invokeLater(new UpdateMessageFlagsRunnable(requestFolder, localMessageToken, newFlags)); 
     306            threadQueue.invokeLater(new UpdateMessageFlagsRunnable(requestFolder, localMessageToken, newFlags, RequestEvent.TYPE_MESSAGE_UNDELETE)); 
    283307        } 
    284308    } 
    … …  
    291315            MessageFlags newFlags = copyMessageFlags(messageFlags); 
    292316            newFlags.setAnswered(true); 
    293             threadQueue.invokeLater(new UpdateMessageFlagsRunnable(requestFolder, localMessageToken, newFlags)); 
     317            threadQueue.invokeLater(new UpdateMessageFlagsRunnable(requestFolder, localMessageToken, newFlags, RequestEvent.TYPE_MESSAGE_ANSWERED)); 
    294318        } 
    295319    } 
    … …  
    298322        private LocalMessageToken localMessageToken; 
    299323        private MessageFlags messageFlags; 
     324        private int requestType; 
    300325         
    301326        public UpdateMessageFlagsRunnable( 
    302327                FolderTreeItem requestFolder, 
    303328                LocalMessageToken localMessageToken, 
    304                 MessageFlags messageFlags) { 
     329                MessageFlags messageFlags, 
     330                int requestType) { 
    305331            super(requestFolder); 
    306332            this.localMessageToken = localMessageToken; 
    307333            this.messageFlags = messageFlags; 
     334            this.requestType = requestType; 
    308335        } 
    309336 
    310337        public void run() { 
     338            Throwable throwable = null; 
    311339            boolean flagsUpdated = false; 
     340            boolean success; 
    312341            try { 
    313342                maildirFolder.open(); 
    314343                flagsUpdated = maildirFolder.setMessageFlags(localMessageToken, messageFlags); 
    315344                maildirFolder.close(); 
     345                success = true; 
    316346            } catch (IOException e) { 
    317                 System.err.println("Unable to read folder: " + e.toString()); 
     347                EventLogger.logEvent(AppInfo.GUID, ("Unable to read folder: " + e.toString()).getBytes(), EventLogger.ERROR); 
     348                success = false; 
     349                throwable = e; 
     350            } 
     351             
     352            if(success) { 
     353                fireMailStoreRequestComplete(requestType); 
     354            } 
     355            else { 
     356                fireMailStoreRequestFailed(requestType, new Object[] { localMessageToken, messageFlags }, throwable); 
    318357            } 
    319358             
    … …  
    343382         
    344383                public void run() { 
     384                    Throwable throwable = null; 
    345385                FolderMessage folderMessage = null; 
    346386                try { 
    … …  
    349389                        maildirFolder.close(); 
    350390                } catch (IOException e) { 
    351                         System.err.println("Unable to read folder: " + e.toString()); 
     391                EventLogger.logEvent(AppInfo.GUID, ("Unable to read folder: " + e.toString()).getBytes(), EventLogger.ERROR); 
     392                        throwable = e; 
    352393                } 
    353394                 
    354395                if(folderMessage != null) { 
     396                    fireMailStoreRequestComplete(RequestEvent.TYPE_MESSAGE_APPEND); 
    355397                        fireFolderMessagesAvailable(requestFolder, new FolderMessage[] { folderMessage }, false); 
     398                } 
     399                else { 
     400                    fireMailStoreRequestFailed(RequestEvent.TYPE_MESSAGE_APPEND, new Object[] { requestFolder, rawMessage, initialFlags }, throwable); 
    356401                } 
    357402                } 
    … …  
    405450                                fileConnection.close(); 
    406451                        } catch (IOException e) { 
    407                                 System.err.println("Error preparing root path: " + e.toString()); 
     452                    EventLogger.logEvent(AppInfo.GUID, ("Error preparing root path: " + e.toString()).getBytes(), EventLogger.ERROR); 
    408453                        } 
    409454                         

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

    r220 r616  
    4444         */ 
    4545        public void mailConnectionRequestComplete(int type, Object result); 
     46         
     47    /** 
     48     * Indicates that a request has failed. 
     49     *  
     50     * @param type The type of the request. 
     51     * @param params The parameters passed along with the request. 
     52     * @param exception The exception that caused the request to fail, if applicable. 
     53     */ 
     54    public void mailConnectionRequestFailed(int type, Object[] params, Throwable exception); 
    4655} 

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

    r220 r616  
    3838 */ 
    3939public interface MailStoreListener extends EventListener { 
     40    /** 
     41     * Invoked when a mail store request is completed. 
     42     *  
     43     * @param e the event data 
     44     */ 
     45    void mailStoreRequestComplete(RequestEvent e); 
     46     
     47    /** 
     48     * Invoked when a mail store request fails. 
     49     *  
     50     * @param e the event data 
     51     */ 
     52    void mailStoreRequestFailed(RequestEvent e); 
     53     
    4054        /** 
    4155         * Invoked when the folder tree is updated. 
    … …  
    4357         * @param e Folder event data 
    4458         */ 
    45         public void folderTreeUpdated(FolderEvent e); 
     59        void folderTreeUpdated(FolderEvent e); 
    4660} 

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

    r589 r616  
    5050                                connectionHandler_mailConnectionRequestComplete(type, result); 
    5151                        } 
     52 
     53            public void mailConnectionRequestFailed(int type, Object[] params, Throwable exception) { 
     54                connectionHandler_mailConnectionRequestFailed(type, params, exception); 
     55            } 
    5256                }); 
    5357                this.connectionHandler.start(); 
    5458        } 
    55          
    56         /** 
     59 
     60    /** 
    5761         * Gets the outgoing account configuration associated with this network mail sender. 
    5862         *  
    … …  
    9498                        fireMessageSent((MessageEnvelope)results[0], (Message)results[1], (String)results[2]); 
    9599                        break; 
    96                 case OutgoingMailConnectionHandler.REQUEST_SEND_MESSAGE_FAILED: 
    97             results = (Object[])result; 
    98             fireMessageSendFailed((MessageEnvelope)results[0], (Message)results[1]); 
     100        } 
     101        } 
     102         
     103        private void connectionHandler_mailConnectionRequestFailed(int type, Object[] params, Throwable exception) { 
     104        switch(type) { 
     105        case OutgoingMailConnectionHandler.REQUEST_SEND_MESSAGE: 
     106            fireMessageSendFailed((MessageEnvelope)params[0], (Message)params[1]); 
    99107            break; 
    100108        } 
    101         } 
     109    } 
    102110} 

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

    r585 r616  
    5454                                connectionHandler_mailConnectionRequestComplete(type, result); 
    5555                        } 
     56            public void mailConnectionRequestFailed(int type, Object[] params, Throwable exception) { 
     57                connectionHandler_mailConnectionRequestFailed(type, params, exception); 
     58            } 
    5659                }); 
    5760                this.connectionHandler.start(); 
    … …  
    192195                switch(type) { 
    193196                case IncomingMailConnectionHandler.REQUEST_FOLDER_TREE: 
     197                    fireMailStoreRequestComplete(RequestEvent.TYPE_FOLDER_TREE); 
    194198                        fireFolderTreeUpdated((FolderTreeItem)result); 
    195199                        break; 
    196200                case IncomingMailConnectionHandler.REQUEST_FOLDER_EXPUNGE: 
     201                    fireMailStoreRequestComplete(RequestEvent.TYPE_FOLDER_EXPUNGE); 
    197202                    fireFolderExpunged((FolderTreeItem)result); 
    198203                    break; 
    199204                case IncomingMailConnectionHandler.REQUEST_FOLDER_STATUS: 
     205                    fireMailStoreRequestComplete(RequestEvent.TYPE_FOLDER_STATUS); 
    200206                        FolderTreeItem[] folders = (FolderTreeItem[])result; 
    201207                        for(int i=0; i<folders.length; i++) { 
    … …  
    204210                        break; 
    205211                case IncomingMailConnectionHandler.REQUEST_FOLDER_MESSAGES_RANGE: 
     212                    fireMailStoreRequestComplete(RequestEvent.TYPE_FOLDER_MESSAGES_RANGE); 
     213            results = (Object[])result; 
     214            fireFolderMessagesAvailable((FolderTreeItem)results[0], (FolderMessage[])results[1], false); 
     215                    break; 
    206216                case IncomingMailConnectionHandler.REQUEST_FOLDER_MESSAGES_SET: 
     217                    fireMailStoreRequestComplete(RequestEvent.TYPE_FOLDER_MESSAGES_SET); 
    207218                        results = (Object[])result; 
    208219                        fireFolderMessagesAvailable((FolderTreeItem)results[0], (FolderMessage[])results[1], false); 
    209220                        break; 
    210221                case IncomingMailConnectionHandler.REQUEST_FOLDER_MESSAGES_RECENT: 
     222                    fireMailStoreRequestComplete(RequestEvent.TYPE_FOLDER_MESSAGES_RECENT); 
    211223                        results = (Object[])result; 
    212224                        fireFolderMessagesAvailable((FolderTreeItem)results[0], (FolderMessage[])results[1], ((Boolean)results[2]).booleanValue()); 
    213225                        break; 
    214226                case IncomingMailConnectionHandler.REQUEST_MESSAGE: 
     227                    fireMailStoreRequestComplete(RequestEvent.TYPE_MESSAGE); 
    215228                        results = (Object[])result; 
    216229                        fireMessageAvailable((MessageToken)results[0], (MimeMessagePart)results[1], (MimeMessageContent[])results[2], null); 
    217230                        break; 
    218231                case IncomingMailConnectionHandler.REQUEST_MESSAGE_PARTS: 
     232                    fireMailStoreRequestComplete(RequestEvent.TYPE_MESSAGE_PARTS); 
    219233                        results = (Object[])result; 
    220234                        fireMessageContentAvailable((MessageToken)results[0], (MimeMessageContent[])results[1]); 
    221235                        break; 
    222236                case IncomingMailConnectionHandler.REQUEST_MESSAGE_DELETE: 
     237                    fireMailStoreRequestComplete(RequestEvent.TYPE_MESSAGE_DELETE); 
    223238                        results = (Object[])result; 
    224239                        fireMessageDeleted((MessageToken)results[0], (MessageFlags)results[1]); 
    225240                        break; 
    226241                case IncomingMailConnectionHandler.REQUEST_MESSAGE_UNDELETE: 
     242                    fireMailStoreRequestComplete(RequestEvent.TYPE_MESSAGE_UNDELETE); 
    227243                        results = (Object[])result; 
    228244                        fireMessageUndeleted((MessageToken)results[0], (MessageFlags)results[1]); 
    229245                        break; 
    230246                case IncomingMailConnectionHandler.REQUEST_MESSAGE_ANSWERED: 
     247                    fireMailStoreRequestComplete(RequestEvent.TYPE_MESSAGE_ANSWERED); 
    231248                        results = (Object[])result; 
    232249                        fireMessageFlagsChanged((MessageToken)results[0], (MessageFlags)results[1]); 
    233250                        break; 
    234251                case IncomingMailConnectionHandler.REQUEST_MESSAGE_APPEND: 
     252                    fireMailStoreRequestComplete(RequestEvent.TYPE_MESSAGE_APPEND); 
    235253                        results = (Object[])result; 
    236254                        fireFolderMessagesAvailable((FolderTreeItem)results[0], (FolderMessage[])results[1], false); 
    237255                        break; 
    238256                case IncomingMailConnectionHandler.REQUEST_MESSAGE_COPY: 
    239                         break; 
    240                 } 
     257                    fireMailStoreRequestComplete(RequestEvent.TYPE_MESSAGE_COPY); 
     258                        break; 
     259                } 
     260        } 
     261         
     262        private void connectionHandler_mailConnectionRequestFailed(int type, Object[] params, Throwable exception) { 
     263        switch(type) { 
     264        case IncomingMailConnectionHandler.REQUEST_FOLDER_TREE: 
     265            fireMailStoreRequestFailed(RequestEvent.TYPE_FOLDER_TREE, params, exception); 
     266            break; 
     267        case IncomingMailConnectionHandler.REQUEST_FOLDER_EXPUNGE: 
     268            fireMailStoreRequestFailed(RequestEvent.TYPE_FOLDER_EXPUNGE, params, exception); 
     269            break; 
     270        case IncomingMailConnectionHandler.REQUEST_FOLDER_STATUS: 
     271            fireMailStoreRequestFailed(RequestEvent.TYPE_FOLDER_STATUS, params, exception); 
     272            break; 
     273        case IncomingMailConnectionHandler.REQUEST_FOLDER_MESSAGES_RANGE: 
     274            fireMailStoreRequestFailed(RequestEvent.TYPE_FOLDER_MESSAGES_RANGE, params, exception); 
     275            break; 
     276        case IncomingMailConnectionHandler.REQUEST_FOLDER_MESSAGES_SET: 
     277            fireMailStoreRequestFailed(RequestEvent.TYPE_FOLDER_MESSAGES_SET, params, exception); 
     278            break; 
     279        case IncomingMailConnectionHandler.REQUEST_FOLDER_MESSAGES_RECENT: 
     280            fireMailStoreRequestFailed(RequestEvent.TYPE_FOLDER_MESSAGES_RECENT, params, exception); 
     281            break; 
     282        case IncomingMailConnectionHandler.REQUEST_MESSAGE: 
     283            fireMailStoreRequestFailed(RequestEvent.TYPE_MESSAGE, params, exception); 
     284            break; 
     285        case IncomingMailConnectionHandler.REQUEST_MESSAGE_PARTS: 
     286            fireMailStoreRequestFailed(RequestEvent.TYPE_MESSAGE_PARTS, params, exception); 
     287            break; 
     288        case IncomingMailConnectionHandler.REQUEST_MESSAGE_DELETE: 
     289            fireMailStoreRequestFailed(RequestEvent.TYPE_MESSAGE_DELETE, params, exception); 
     290            break; 
     291        case IncomingMailConnectionHandler.REQUEST_MESSAGE_UNDELETE: 
     292            fireMailStoreRequestFailed(RequestEvent.TYPE_MESSAGE_UNDELETE, params, exception); 
     293            break; 
     294        case IncomingMailConnectionHandler.REQUEST_MESSAGE_ANSWERED: 
     295            fireMailStoreRequestFailed(RequestEvent.TYPE_MESSAGE_ANSWERED, params, exception); 
     296            break; 
     297        case IncomingMailConnectionHandler.REQUEST_MESSAGE_APPEND: 
     298            fireMailStoreRequestFailed(RequestEvent.TYPE_MESSAGE_APPEND, params, exception); 
     299            break; 
     300        case IncomingMailConnectionHandler.REQUEST_MESSAGE_COPY: 
     301            fireMailStoreRequestFailed(RequestEvent.TYPE_MESSAGE_COPY, params, exception); 
     302            break; 
     303        } 
    241304        } 
    242305} 

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

    r588 r616  
    2020        // "requestXXXX()" methods from AbstractMailSender 
    2121        public static final int REQUEST_SEND_MESSAGE = 10; 
    22     public static final int REQUEST_SEND_MESSAGE_FAILED = 20; 
    2322         
    2423        public OutgoingMailConnectionHandler(OutgoingMailClient client) { 
    … …  
    5958                        break; 
    6059                } 
    61         } 
    62  
    63         protected void handleRequestFailed(int type, Object[] params, Throwable exception) { 
    64         switch(type) { 
    65         case REQUEST_SEND_MESSAGE: 
    66             handleRequestSendMessageFailed( 
    67                     (MessageEnvelope)params[0], (Message)params[1], exception); 
    68             break; 
    69         } 
    7060        } 
    7161 
    … …  
    113103                } 
    114104        } 
    115      
    116     private void handleRequestSendMessageFailed(MessageEnvelope envelope, Message message, Throwable exception) { 
    117         MailConnectionHandlerListener listener = getListener(); 
    118         if(listener != null) { 
    119             listener.mailConnectionRequestComplete(REQUEST_SEND_MESSAGE_FAILED, new Object[] { envelope, message }); 
    120         } 
    121     } 
    122105} 

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

    r615 r616  
    4343import org.logicprobe.LogicMail.mail.MessageToken; 
    4444import org.logicprobe.LogicMail.mail.NetworkMailStore; 
     45import org.logicprobe.LogicMail.mail.RequestEvent; 
    4546import org.logicprobe.LogicMail.message.FolderMessage; 
    4647import org.logicprobe.LogicMail.message.Message; 
    … …  
    115116 
    116117        this.mailStore.addMailStoreListener(new MailStoreListener() { 
    117                 public void folderTreeUpdated(FolderEvent e) { 
    118                     mailStore_FolderTreeUpdated(e); 
    119                 } 
    120             }); 
     118            public void mailStoreRequestComplete(RequestEvent e) { 
     119            } 
     120            public void mailStoreRequestFailed(RequestEvent e) { 
     121            } 
     122            public void folderTreeUpdated(FolderEvent e) { 
     123                mailStore_FolderTreeUpdated(e); 
     124            } 
     125        }); 
    121126 
    122127        this.mailStore.addFolderListener(new FolderListener() { 
    123                 public void folderStatusChanged(FolderEvent e) { 
    124                     mailStore_FolderStatusChanged(e); 
    125                 } 
    126  
    127                 public void folderMessagesAvailable(FolderMessagesEvent e) { 
    128                     mailStore_FolderMessagesAvailable(e); 
    129                 } 
    130  
    131                 public void folderExpunged(FolderEvent e) { 
    132                     mailStore_FolderExpunged(e); 
    133                 } 
    134             }); 
     128            public void folderStatusChanged(FolderEvent e) { 
     129                mailStore_FolderStatusChanged(e); 
     130            } 
     131 
     132            public void folderMessagesAvailable(FolderMessagesEvent e) { 
     133                mailStore_FolderMessagesAvailable(e); 
     134            } 
     135 
     136            public void folderExpunged(FolderEvent e) { 
     137                mailStore_FolderExpunged(e); 
     138            } 
     139        }); 
    135140 
    136141        this.mailStore.addMessageListener(new MessageListener() { 
    137                 public void messageAvailable(MessageEvent e) { 
    138                     mailStore_messageAvailable(e); 
    139                 } 
    140  
    141                 public void messageFlagsChanged(MessageEvent e) { 
    142                     mailStore_messageFlagsChanged(e); 
    143                 } 
    144  
    145                 public void messageDeleted(MessageEvent e) { 
    146                     mailStore_messageDeleted(e); 
    147                 } 
    148  
    149                 public void messageUndeleted(MessageEvent e) { 
    150                     mailStore_messageUndeleted(e); 
    151                 } 
    152             }); 
     142            public void messageAvailable(MessageEvent e) { 
     143                mailStore_messageAvailable(e); 
     144            } 
     145 
     146            public void messageFlagsChanged(MessageEvent e) { 
     147                mailStore_messageFlagsChanged(e); 
     148            } 
     149 
     150            public void messageDeleted(MessageEvent e) { 
     151                mailStore_messageDeleted(e); 
     152            } 
     153 
     154            public void messageUndeleted(MessageEvent e) { 
     155                mailStore_messageUndeleted(e); 
     156            } 
     157        }); 
    153158 
    154159        if (!mailStore.hasFolders()) { 
    155160            // Create the fake INBOX node for non-folder-capable mail stores 
    156161            this.rootMailbox = new MailboxNode(new FolderTreeItem("", "", ""), 
    157                         false, 
     162                    false, 
    158163                    -1); 
    159164            this.rootMailbox.setParentAccount(this); 
    160165 
    161166            MailboxNode inboxNode = new MailboxNode(new FolderTreeItem( 
    162                         "INBOX", "INBOX", "", true), false, MailboxNode.TYPE_INBOX); 
     167                    "INBOX", "INBOX", "", true), false, MailboxNode.TYPE_INBOX); 
    163168            inboxNode.setParentAccount(this); 
    164169            this.rootMailbox.addMailbox(inboxNode); 

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

    r585 r616  
    6363        private FakeIncomingMailClient fakeIncomingMailClient; 
    6464 
     65        private RequestEvent eventMailStoreRequestCompleted; 
     66    private RequestEvent eventMailStoreRequestFailed; 
    6567        private FolderEvent eventFolderTreeUpdated; 
    6668        private Vector eventFolderMessagesAvailable = new Vector(); 
    … …  
    8486 
    8587        instance.addMailStoreListener(new MailStoreListener() { 
     88            public void mailStoreRequestComplete(RequestEvent e) { 
     89                eventMailStoreRequestCompleted = e; 
     90            } 
     91            public void mailStoreRequestFailed(RequestEvent e) { 
     92                eventMailStoreRequestFailed = e; 
     93            } 
    8694                        public void folderTreeUpdated(FolderEvent e) { 
    8795                                eventFolderTreeUpdated = e; 
    … …  
    177185        instance.shutdown(true); 
    178186         
     187        assertNotNull(eventMailStoreRequestCompleted); 
     188        assertEquals(RequestEvent.TYPE_FOLDER_TREE, eventMailStoreRequestCompleted.getType()); 
     189        assertNull(eventMailStoreRequestFailed); 
     190         
    179191        assertNotNull(eventFolderTreeUpdated); 
    180192        assertEquals(fakeIncomingMailClient.folderTree, eventFolderTreeUpdated.getFolder()); 
    … …  
    188200        instance.shutdown(true); 
    189201         
     202        assertNotNull(eventMailStoreRequestCompleted); 
     203        assertEquals(RequestEvent.TYPE_FOLDER_STATUS, eventMailStoreRequestCompleted.getType()); 
     204        assertNull(eventMailStoreRequestFailed); 
     205         
    190206        assertNotNull(eventFolderStatusChanged); 
    191207        assertEquals("INBOX", eventFolderStatusChanged.getFolder().getName()); 
    … …  
    202218        instance.shutdown(true); 
    203219         
     220        assertNotNull(eventMailStoreRequestCompleted); 
     221        assertEquals(RequestEvent.TYPE_FOLDER_MESSAGES_RANGE, eventMailStoreRequestCompleted.getType()); 
     222        assertNull(eventMailStoreRequestFailed); 
     223         
    204224        // Cannot assume the number of events that will be fired, 
    205225        // but only the number of folder messages contained within 
    … …  
    246266        instance.shutdown(true); 
    247267         
     268        assertNotNull(eventMailStoreRequestCompleted); 
     269        assertEquals(RequestEvent.TYPE_MESSAGE, eventMailStoreRequestCompleted.getType()); 
     270        assertNull(eventMailStoreRequestFailed); 
     271         
    248272        assertNotNull(eventMessageAvailable); 
    249273        assertEquals(MessageEvent.TYPE_FULLY_LOADED, eventMessageAvailable.getType()); 
    … …  
    267291        instance.shutdown(true); 
    268292         
     293        assertNotNull(eventMailStoreRequestCompleted); 
     294        assertEquals(RequestEvent.TYPE_MESSAGE_DELETE, eventMailStoreRequestCompleted.getType()); 
     295        assertNull(eventMailStoreRequestFailed); 
     296         
    269297        assertNotNull(eventMessageDeleted); 
    270298        assertEquals(MessageEvent.TYPE_FLAGS_CHANGED, eventMessageDeleted.getType()); 
    … …  
    285313        instance.shutdown(true); 
    286314         
     315        assertNotNull(eventMailStoreRequestCompleted); 
     316        assertEquals(RequestEvent.TYPE_MESSAGE_UNDELETE, eventMailStoreRequestCompleted.getType()); 
     317        assertNull(eventMailStoreRequestFailed); 
     318         
    287319        assertNotNull(eventMessageUndeleted); 
    288320        assertEquals(MessageEvent.TYPE_FLAGS_CHANGED, eventMessageUndeleted.getType()); 
Note: See TracChangeset for help on using the changeset viewer.