Changeset 266

Timestamp:

08/04/08 09:17:20 PM (4 months ago)

Author:

octorian

Message:

Initial IMAP IDLE implementation

Location:

trunk/LogicMail/src/org/logicprobe/LogicMail

Files:

• mail/AbstractMailConnectionHandler.java (modified) (2 diffs)
• mail/imap/ImapClient.java (modified) (2 diffs)
• mail/imap/ImapProtocol.java (modified) (3 diffs)
• mail/IncomingMailClient.java (modified) (2 diffs)
• mail/IncomingMailConnectionHandler.java (modified) (2 diffs)
• mail/pop/PopClient.java (modified) (2 diffs)
• util/Connection.java (modified) (10 diffs)

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

@@ -315 +315 @@
          * a new request arrives, or it is commanded to shutdown.
          * </p>
-         */
-        protected abstract void handleBeginIdle();
+     * 
+     * @throw IOException on I/O errors
+     * @throw MailException on protocol errors
+         */
+        protected abstract void handleBeginIdle() throws IOException, MailException;
         
     /**
@@ -373 +376 @@
         protected Queue getRequestQueue() {
                 return this.requestQueue;
+        }
+        
+        /**
+         * Gets whether a shutdown is currently in progress.
+         * @return True if shutdown is in progress.
+         */
+        protected boolean getShutdownInProgress() {
+                return this.shutdownInProgress;
+        }
+        
+        /**
+         * Sleep the connection thread.
+         * @param time Time to sleep, in milliseconds.
+         */
+        protected void sleepConnectionThread(long time) {
+                if(!connectionThread.isShutdown()) {
+                        try {
+                                ConnectionThread.sleep(time);
+                        } catch (InterruptedException e) { }
+                }
         }
         

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

@@ -269 +269 @@
         return true;
     }
+
+    public boolean hasIdle() {
+                return true;
+        }
     
     public FolderTreeItem getFolderTree() throws IOException, MailException {
@@ -575 +579 @@
         imapProtocol.executeAppend(folder.getPath(), rawMessage, flags);
     }
+
+        public void idleModeBegin() throws IOException, MailException {
+                imapProtocol.executeIdle();
+        }
+
+        public void idleModeEnd() throws IOException, MailException {
+                imapProtocol.executeIdleDone();
+        }
+
+        public boolean idleModePoll() throws IOException, MailException {
+                return imapProtocol.executeIdlePoll();
+        }
 }

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

@@ -48 +48 @@
 public class ImapProtocol {
     private Connection connection;
+    private String idleCommandTag;
 
     /**
@@ -889 +890 @@
 
     /**
+     * Execute the "IDLE" command.
+     */
+    public void executeIdle() throws IOException, MailException {
+        if(EventLogger.getMinimumLevel() >= EventLogger.DEBUG_INFO) {
+            EventLogger.logEvent(
+            AppInfo.GUID,
+            ("ImapProtocol.executeIdle()").getBytes(),
+            EventLogger.DEBUG_INFO);
+        }
+        idleCommandTag = executeNoReply("IDLE", null);
+    }
+    
+    /**
+     * Execute the "DONE" command.
+     */
+    public void executeIdleDone() throws IOException, MailException {
+        if(EventLogger.getMinimumLevel() >= EventLogger.DEBUG_INFO) {
+            EventLogger.logEvent(
+            AppInfo.GUID,
+            ("ImapProtocol.executeIdleDone()").getBytes(),
+            EventLogger.DEBUG_INFO);
+        }
+        executeUntagged("DONE", null, idleCommandTag);
+        idleCommandTag = null;
+    }
+    
+    /**
+     * Polls the connection during the IDLE state.
+     * For now, this is a simple implementation.  It just checks for
+     * the presence of a "+ ?? recent" untagged response, and returns
+     * true if one is found.
+     */
+    public boolean executeIdlePoll() throws IOException, MailException {
+                String result = receive();
+                if(result != null && result.startsWith("*") && result.toLowerCase().endsWith("recent")) {
+                        return true;
+                }
+                else {
+                        return false;
+                }
+    }
+    
+    /**
      * Executes an IMAP command several times, with different arguments,
      * and return the replies as an array of strings.
@@ -1006 +1050 @@
         return result;
     }
+    
+    /**
+     * Attempts to read a line of text from the server, without sending
+     * anything first.
+     * @return Returned string, or null if nothing is available
+     */
+    protected String receive()
+        throws IOException, MailException
+        {
+        String result;
+        
+        if(connection.available() > 0) {
+                System.err.println("-->connection.available() == " + connection.available());
+                result = connection.receive();
+                System.err.println("-->Read in "+result.length());
+                System.err.println("-->connection.available() == " + connection.available());
+        }
+        else {
+                result = null;
+        }
+        return result;
+        }
+    
+    /**
+     * Executes an IMAP command directly and expects no reply.
+     * @param command IMAP command
+     * @param arguments Arguments for the command
+     * @return Tag used to send the command
+     */
+    protected String executeNoReply(String command, String arguments)
+        throws IOException, MailException
+        {
+        String tag = "A" + commandCount++ + " ";
+        connection.sendCommand(tag + command + (arguments == null ? "" : " " + arguments));
+
+        return tag;
+    }
+    
+    /**
+     * Executes an IMAP command without a tag prefix,
+     * and returns the reply as an array of strings.
+     * @param command IMAP command
+     * @param arguments Arguments for the command
+     * @param Known tag that indicates the end of the result
+     * @return List of returned strings
+     */
+    protected String[] executeUntagged(String command, String arguments, String endTag)
+        throws IOException, MailException
+    {
+        String[] result = new String[0];
+        
+        connection.sendCommand(command + (arguments == null ? "" : " " + arguments));
+        
+        String temp = connection.receive();
+        while (!temp.startsWith(endTag)) {
+            Arrays.add(result, temp);
+            temp = connection.receive();
+        }
+
+        temp = temp.substring(endTag.length());
+        if (temp.startsWith("BAD ") || temp.startsWith("NO ")) {
+            throw new MailException(temp);
+        }
+        return result;
+    }
 }

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

@@ -69 +69 @@
     
     /**
+     * Return whether the underlying protocol supports an idle connection mode.
+     * 
+     * @return True if an idle mode is supported, false otherwise
+     */
+    public abstract boolean hasIdle();
+    
+    /**
      * Get the mail folder tree.
      * This should return null if folders are not supported
@@ -173 +180 @@
      */
     public abstract void undeleteMessage(FolderMessage folderMessage) throws IOException, MailException;
+
+    /**
+     * Begins the idle mode for the underlying protocol.
+     * This should do nothing if the underlying protocol does not support idling.
+     * 
+     * @throws IOException on I/O errors
+     * @throws MailException on protocol errors
+     */
+    public abstract void idleModeBegin() throws IOException, MailException;
+    
+    /**
+     * Ends the idle mode for the underlying protocol.
+     * This should do nothing if the underlying protocol does not support idling.
+     * 
+     * @throws IOException on I/O errors
+     * @throws MailException on protocol errors
+     */
+    public abstract void idleModeEnd() throws IOException, MailException;
+
+    /**
+     * Polls the connecting during the idle mode for the underlying protocol.
+     * This should do nothing if the underlying protocol does not support idling.
+     * 
+     * @return True if the mailbox has new data, false otherwise.
+     * @throws IOException on I/O errors
+     * @throws MailException on protocol errors
+     */
+    public abstract boolean idleModePoll() throws IOException, MailException;
 }

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

@@ -39 +39 @@
 import org.logicprobe.LogicMail.message.Message;
 import org.logicprobe.LogicMail.message.MessageFlags;
+import org.logicprobe.LogicMail.util.Queue;
 
 public class IncomingMailConnectionHandler extends AbstractMailConnectionHandler {
@@ -113 +114 @@
          * Handles the start of the IDLE state.
          */
-        protected void handleBeginIdle() {
+        protected void handleBeginIdle() throws IOException, MailException {
+                if(incomingClient.hasIdle()) {
+                        incomingClient.idleModeBegin();
+                        boolean endIdle = false;
+                        while(!endIdle) {
+                                sleepConnectionThread(500);
+                                if(incomingClient.idleModePoll()) {
+                                        addRequest(
+                                                        IncomingMailConnectionHandler.REQUEST_FOLDER_MESSAGES_RECENT,
+                                                        new Object[] { incomingClient.getActiveFolder() });
+                                        endIdle = true;
+                                }
+                                else if(getShutdownInProgress()) {
+                                        endIdle = true;
+                                }
+                                else
+                                {
+                                        Queue requestQueue = getRequestQueue();
+                                        synchronized(requestQueue) {
+                                                if(requestQueue.element() != null) {
+                                                        endIdle = true;
+                                                }
+                                        }
+                                }
+                        }
+                        incomingClient.idleModeEnd();
+                }
         }
 

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

@@ -210 +210 @@
     }
 
+    public boolean hasIdle() {
+                return false;
+        }
+
     public FolderTreeItem getFolderTree() throws IOException, MailException {
         return null;
@@ -336 +340 @@
         // Undelete is not supported, so we do nothing here.
     }
+
+        public void idleModeBegin() throws IOException, MailException {
+                // Idle mode is not supported, so we do nothing here.
+        }
+
+        public void idleModeEnd() throws IOException, MailException {
+                // Idle mode is not supported, so we do nothing here.
+        }
+
+        public boolean idleModePoll() throws IOException, MailException {
+                // Idle mode is not supported, so we do nothing here.
+                return false;
+        }
 }

trunk/LogicMail/src/org/logicprobe/LogicMail/util/Connection.java

@@ -103 +103 @@
     protected OutputStream output;
     private boolean useWiFi;
+    private int fakeAvailable = -1;
     
     /**
@@ -114 +115 @@
     private byte[] buffer = new byte[128];
     
-    /**
-     * Holds the actual number of bytes in the buffer.
-     */
-    private int count;
-
     /**
      * Holds a list of open connections
@@ -150 +146 @@
         
         String protocolStr = (useSSL ? "ssl" : "socket");
-        // This param, which allows bypassing the MDS proxy, should probably
+        // This parameter, which allows bypassing the MDS proxy, should probably
         // be a global user configurable option
         String paramStr = (deviceSide ? ";deviceside=true" : "");
@@ -287 +283 @@
      * Sends a string to the server. This method is used internally for
      * all outgoing communication to the server. The main thing it does
-     * it terminate the line with a CR/LF. If there are occurences of CR or
+     * it terminate the line with a CR/LF. If there are occurrences of CR or
      * LF inside the string, the method ensures that proper CR/LF sequences
-     * are sent for them, since this is what most internet protocols expect.
+     * are sent for them, since this is what most Internet protocols expect.
      *
      * @see #receive
@@ -316 +312 @@
                 
                 /**
-                 * Find next occurence of a line separator or the end of the
+                 * Find next occurrence of a line separator or the end of the
                  * string.
                  */
@@ -384 +380 @@
     }
 
+    /**
+     * Returns the number of bytes available for reading.
+     * Used to poll the connection without blocking.
+     * 
+     * @see InputStream#available()
+     */
+    public int available() throws IOException {
+        if(fakeAvailable == -1) {
+                return input.available();
+        }
+        else {
+                return fakeAvailable;
+        }
+    }
+    
     /**
      * Receives a string from the server. This method is used internally for
@@ -403 +414 @@
          * characters belonging to a line were read. The result was
          * a high level of heap fragmentation, which made applications
-         * instable on MIDP devices (that don't provide compacting GC,
+         * unstable on MIDP devices (that don't provide compacting GC,
          * that is).
          *
@@ -423 +434 @@
         StringBuffer resultBuffer = new StringBuffer();
         boolean stop = false;
+        int actualAvailable = input.available();
+        int readBytes = 0;
+        int count;
         
         /**
@@ -470 +484 @@
                  */
                 // Note: We really should look for CRLF, and not use this
-                // half-assed approach which screws up on mid-lime LFs. (DK)
+                // approach which screws up on mid-line LFs. (DK)
                 else {
                     byte b = buffer[count];
+                    readBytes++;
                     
                     /**
@@ -504 +519 @@
             EventLogger.logEvent(AppInfo.GUID, ("[RECV] " + resultBuffer.toString()).getBytes(), EventLogger.DEBUG_INFO);
         }
+        if(actualAvailable > readBytes) {
+                fakeAvailable = actualAvailable - readBytes;
+        }
+        else {
+                fakeAvailable = -1;
+        }
         
         return resultBuffer.toString();