Changeset 449 for trunk/LogicMail/src/org/logicprobe/LogicMail/util/Connection.java

Timestamp:

06/03/09 05:40:24 PM (9 months ago)

Author:

octorian

Message:

 

Files:

• trunk/LogicMail/src/org/logicprobe/LogicMail/util/Connection.java (modified) (27 diffs)

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

@@ -60 +60 @@
 package org.logicprobe.LogicMail.util;
 
+import net.rim.device.api.system.EventLogger;
+import net.rim.device.api.ui.UiApplication;
+import net.rim.device.api.ui.component.Dialog;
+import net.rim.device.api.util.DataBuffer;
+
+import org.logicprobe.LogicMail.AppInfo;
+import org.logicprobe.LogicMail.conf.GlobalConfig;
+import org.logicprobe.LogicMail.conf.MailSettings;
+
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.OutputStream;
+
 import java.util.Vector;
+
+import javax.microedition.io.Connector;
 import javax.microedition.io.SocketConnection;
 import javax.microedition.io.StreamConnection;
-import javax.microedition.io.Connector;
-import net.rim.device.api.system.EventLogger;
-import net.rim.device.api.ui.UiApplication;
-import net.rim.device.api.ui.component.Dialog;
-import org.logicprobe.LogicMail.AppInfo;
-import org.logicprobe.LogicMail.conf.GlobalConfig;
-import org.logicprobe.LogicMail.conf.MailSettings;
+
 
 /**
@@ -93 +99 @@
  */
 public class Connection {
+    /**
+     * Byte array holding carriage return and line feed
+     */
+    private static final byte[] CRLF = new byte[] { 13, 10 };
+
+    /**
+     * Holds a list of open connections
+     */
+    private static Vector openConnections = new Vector();
     private String serverName;
     private int serverPort;
@@ -104 +119 @@
     private boolean useWiFi;
     private int fakeAvailable = -1;
-    
-    /**
-     * Byte array holding carriage return and line feed
-     */
-    private static final byte[] CRLF = new byte[] {13, 10};
-    
+
     /**
      * Provides a buffer used for incoming data.
      */
     private byte[] buffer = new byte[128];
-    
-    /**
-     * Holds a list of open connections
-     */
-    private static Vector openConnections = new Vector();
-    
-    public Connection(String serverName, int serverPort, boolean useSSL, boolean deviceSide) {
+
+    /**
+     * Provides a dynamic buffer for building results
+     */
+    DataBuffer resultBuffer = new DataBuffer();
+
+    public Connection(String serverName, int serverPort, boolean useSSL,
+        boolean deviceSide) {
         this.serverName = serverName;
         this.serverPort = serverPort;
@@ -130 +141 @@
         this.globalConfig = MailSettings.getInstance().getGlobalConfig();
     }
-    
+
     /**
      * Opens a connection.
      */
-    public void open() throws IOException {
-        if(input != null || output != null || socket != null) {
+    public synchronized void open() throws IOException {
+        if ((input != null) || (output != null) || (socket != null)) {
             close();
         }
 
-        synchronized(openConnections) {
-            if(!openConnections.contains(this)) {
+        synchronized (openConnections) {
+            if (!openConnections.contains(this)) {
                 openConnections.addElement(this);
             }
         }
-        
+
         String protocolStr = (useSSL ? "ssl" : "socket");
+
         // This parameter, which allows bypassing the MDS proxy, should probably
         // be a global user configurable option
@@ -151 +163 @@
 
         useWiFi = false;
-        if(globalConfig.getWifiMode() == GlobalConfig.WIFI_PROMPT) {
+
+        if (globalConfig.getWifiMode() == GlobalConfig.WIFI_PROMPT) {
             UiApplication.getUiApplication().invokeAndWait(new Runnable() {
-                public void run() {
-                    useWiFi = (Dialog.ask(Dialog.D_YES_NO, "Connect through WiFi?") == Dialog.YES);
-                }
-            });
-        }
-        else if(globalConfig.getWifiMode() == GlobalConfig.WIFI_ALWAYS) {
+                    public void run() {
+                        useWiFi = (Dialog.ask(Dialog.D_YES_NO,
+                                "Connect through WiFi?") == Dialog.YES);
+                    }
+                });
+        } else if (globalConfig.getWifiMode() == GlobalConfig.WIFI_ALWAYS) {
             useWiFi = true;
         }
-        
-        if(useWiFi) {
+
+        if (useWiFi) {
             paramStr = paramStr + ";interface=wifi";
         }
-        
-        String connectStr = protocolStr + "://" + serverName + ":" + serverPort + paramStr;
-        
-        if(EventLogger.getMinimumLevel() >= EventLogger.INFORMATION) {
-            String msg = "Opening connection:\r\n"+connectStr+"\r\n";
-            EventLogger.logEvent(AppInfo.GUID, msg.getBytes(), EventLogger.INFORMATION);
-        }
-        
-        socket = (StreamConnection)Connector.open(connectStr, Connector.READ_WRITE, true);
+
+        String connectStr = protocolStr + "://" + serverName + ":" +
+            serverPort + paramStr;
+
+        if (EventLogger.getMinimumLevel() >= EventLogger.INFORMATION) {
+            String msg = "Opening connection:\r\n" + connectStr + "\r\n";
+            EventLogger.logEvent(AppInfo.GUID, msg.getBytes(),
+                EventLogger.INFORMATION);
+        }
+
+        socket = (StreamConnection) Connector.open(connectStr,
+                Connector.READ_WRITE, true);
         input = socket.openDataInputStream();
         output = socket.openDataOutputStream();
-        localAddress = ((SocketConnection)socket).getLocalAddress();
-
-        if(EventLogger.getMinimumLevel() >= EventLogger.INFORMATION) {
-            String msg =
-                "Connection established:\r\n"+
-                "Socket: "+socket.getClass().toString()+"\r\n"+
-                "Local address: "+localAddress+"\r\n";
-            EventLogger.logEvent(AppInfo.GUID, msg.getBytes(), EventLogger.INFORMATION);
-        }
-    }
-    
+        localAddress = ((SocketConnection) socket).getLocalAddress();
+
+        if (EventLogger.getMinimumLevel() >= EventLogger.INFORMATION) {
+            String msg = "Connection established:\r\n" + "Socket: " +
+                socket.getClass().toString() + "\r\n" + "Local address: " +
+                localAddress + "\r\n";
+            EventLogger.logEvent(AppInfo.GUID, msg.getBytes(),
+                EventLogger.INFORMATION);
+        }
+    }
+
     /**
      * Closes a connection.
      */
-    public void close() throws IOException {
+    public synchronized void close() throws IOException {
         try {
-            if(input != null) {
+            if (input != null) {
                 input.close();
                 input = null;
@@ -199 +215 @@
             input = null;
         }
+
         try {
-            if(output != null) {
+            if (output != null) {
                 output.close();
                 output = null;
@@ -207 +224 @@
             output = null;
         }
+
         try {
-            if(socket != null) {
+            if (socket != null) {
                 socket.close();
                 socket = null;
@@ -216 +234 @@
         }
 
-        synchronized(openConnections) {
-            if(openConnections.contains(this)) {
+        synchronized (openConnections) {
+            if (openConnections.contains(this)) {
                 openConnections.removeElement(this);
             }
         }
-        
-        EventLogger.logEvent(AppInfo.GUID, "Connection closed".getBytes(), EventLogger.INFORMATION);
-    }
-    
+
+        EventLogger.logEvent(AppInfo.GUID, "Connection closed".getBytes(),
+            EventLogger.INFORMATION);
+    }
+
     /**
      * Determine whether open connections exist
@@ -232 +251 @@
     public static boolean hasOpenConnections() {
         boolean result;
-        synchronized(openConnections) {
+
+        synchronized (openConnections) {
             result = !openConnections.isEmpty();
         }
+
         return result;
     }
-    
+
     /**
      * Close all open connections
      */
     public static void closeAllConnections() {
-        synchronized(openConnections) {
+        synchronized (openConnections) {
             int size = openConnections.size();
-            for(int i = 0; i < size; i++) {
+
+            for (int i = 0; i < size; i++) {
                 try {
-                    ((Connection)openConnections.elementAt(i)).close();
-                } catch (IOException e) { }
-            }
+                    ((Connection) openConnections.elementAt(i)).close();
+                } catch (IOException e) {
+                }
+            }
+
             openConnections.removeAllElements();
         }
     }
-    
+
     /**
      * Determine whether we are currently connected
@@ -258 +282 @@
      */
     public boolean isConnected() {
-        if(socket != null)
+        if (socket != null) {
             return true;
-        else
+        } else {
             return false;
-    }
-    
+        }
+    }
+
     /**
      * Get the local address to which this connection is bound
@@ -271 +296 @@
         return localAddress;
     }
-    
+
     /**
      * Get the server name used when this connection was created
@@ -279 +304 @@
         return serverName;
     }
-    
+
     /**
      * Sends a string to the server. This method is used internally for
@@ -289 +314 @@
      * @see #receive
      */
-    public void send(String s) throws IOException {
+    public synchronized void send(String s) throws IOException {
         byte[] bytes = s.getBytes();
         int length = bytes.length;
-        
+
         /**
          * Special case for empty strings: Only CR/LF is sent.
          */
         if (s.length() == 0) {
-            if(globalConfig.getConnDebug()) {
-                EventLogger.logEvent(AppInfo.GUID, "[SEND]".getBytes(), EventLogger.DEBUG_INFO);
-            }
-            
+            if (globalConfig.getConnDebug()) {
+                EventLogger.logEvent(AppInfo.GUID, "[SEND]".getBytes(),
+                    EventLogger.DEBUG_INFO);
+            }
+
             output.write(CRLF, 0, 2);
         }
@@ -308 +334 @@
         else {
             int i = 0;
+
             while (i < length) {
                 int j = i;
-                
+
                 /**
                  * Find next occurrence of a line separator or the end of the
                  * string.
                  */
-                while ((j < length) && (bytes[j] != 0x0A) && (bytes[j] != 0x0D)) {
+                while ((j < length) && (bytes[j] != 0x0A) &&
+                        (bytes[j] != 0x0D)) {
                     j++;
                 }
-                
-                if(globalConfig.getConnDebug()) {
-                    EventLogger.logEvent(AppInfo.GUID, ("[SEND] " + s.substring(i, j)).getBytes(), EventLogger.DEBUG_INFO);
-                }
-                
+
+                if (globalConfig.getConnDebug()) {
+                    EventLogger.logEvent(AppInfo.GUID,
+                        ("[SEND] " + s.substring(i, j)).getBytes(),
+                        EventLogger.DEBUG_INFO);
+                }
+
                 /**
                  * Write the string up to there and terminate it properly.
                  */
-                output.write((s.substring(i, j)+"\r\n").getBytes());
-                
+                output.write((s.substring(i, j) + "\r\n").getBytes());
+
                 /**
                  * If we stopped at a CR, ignore a possibly following LF.
                  */
-                if ((j < length - 1) && (bytes[j] == 0x0D) && (bytes[j + 1] == 0x0A)) {
+                if ((j < (length - 1)) && (bytes[j] == 0x0D) &&
+                        (bytes[j + 1] == 0x0A)) {
                     j++;
                 }
-                
+
                 i = j + 1;
             }
         }
+
         output.flush();
     }
-    
+
     /**
      * Sends a string to the server, terminating it with a CRLF.
@@ -346 +378 @@
      * is a prepared protocol command.
      */
-    public void sendCommand(String s) throws IOException {
-        if(globalConfig.getConnDebug()) {
-            EventLogger.logEvent(AppInfo.GUID, ("[SEND CMD] " + s).getBytes(), EventLogger.DEBUG_INFO);
-        }
-
-        if(s == null) {
+    public synchronized void sendCommand(String s) throws IOException {
+        if (globalConfig.getConnDebug()) {
+            EventLogger.logEvent(AppInfo.GUID, ("[SEND CMD] " + s).getBytes(),
+                EventLogger.DEBUG_INFO);
+        }
+
+        if (s == null) {
             output.write(CRLF, 0, 2);
-        }
-        else {
-            output.write((s+"\r\n").getBytes());
-        }
+        } else {
+            output.write((s + "\r\n").getBytes());
+        }
+
         output.flush();
     }
-    
+
     /**
      * Sends a string to the server. This method is used to bypass all
@@ -368 +401 @@
      * @see #send
      */
-    public void sendRaw(String s) throws IOException {
+    public synchronized void sendRaw(String s) throws IOException {
         byte[] bytes = s.getBytes();
-        
-        if(globalConfig.getConnDebug()) {
-            EventLogger.logEvent(AppInfo.GUID, ("[SEND RAW]\r\n" + s).getBytes(), EventLogger.DEBUG_INFO);
-        }
-        
+
+        if (globalConfig.getConnDebug()) {
+            EventLogger.logEvent(AppInfo.GUID,
+                ("[SEND RAW]\r\n" + s).getBytes(), EventLogger.DEBUG_INFO);
+        }
+
         output.write(bytes, 0, bytes.length);
-        
+
         output.flush();
     }
@@ -383 +417 @@
      * 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;
-        }
-    }
-    
+        if (fakeAvailable == -1) {
+            return input.available();
+        } else {
+            return fakeAvailable;
+        }
+    }
+
     /**
      * Receives a string from the server. This method is used internally for
@@ -404 +437 @@
      * @see #send
      */
-    public String receive() throws IOException {
+    public synchronized String receive() throws IOException {
         /**
          * A note on how this method works and why it is designed the
@@ -432 +465 @@
          * but there's not much one can about that.
          */
-        StringBuffer resultBuffer = new StringBuffer();
         boolean stop = false;
+        resultBuffer.reset();
+
         int actualAvailable = input.available();
         int readBytes = 0;
         int count;
-        
+
         /**
          * The "stop" flag will be set as soon as we have received
@@ -445 +479 @@
         while (!stop) {
             count = 0;
-            
+
             /**
              * The inner block reads single bytes from the InputStream
@@ -453 +487 @@
             while (true) {
                 int actual = input.read(buffer, count, 1);
-                
+
                 /**
                  * If -1 is returned, the InputStream is already closed,
@@ -461 +495 @@
                  */
                 if (actual == -1) {
-                    EventLogger.logEvent(AppInfo.GUID, "Unable to read from socket, closing connection".getBytes(), EventLogger.INFORMATION);
+                    EventLogger.logEvent(AppInfo.GUID,
+                        "Unable to read from socket, closing connection".getBytes(),
+                        EventLogger.INFORMATION);
+
                     try {
                         close();
-                    } catch (IOException e) { }
-                    
+                    } catch (IOException e) {
+                    }
+
                     throw new IOException("Connection closed");
                 }
-                
                 /**
                  * If no bytes have been received, we wait a little
@@ -476 +513 @@
                     try {
                         Thread.yield();
-                    } catch (Exception e) { }
-                }
-                
+                    } catch (Exception e) {
+                    }
+                }
                 /**
                  * If a byte has been read, examine it and put it in the
                  * buffer.
                  */
+
                 // Note: We really should look for CRLF, and not use this
                 // approach which screws up on mid-line LFs. (DK)
@@ -488 +526 @@
                     byte b = buffer[count];
                     readBytes++;
-                    
+
                     /**
                      * Ignore all CRs.
@@ -500 +538 @@
                     else if (b == 0x0A) {
                         stop = true;
+
                         break;
                     }
@@ -507 +546 @@
                     else {
                         count++;
+
                         if (count == buffer.length) {
                             break;
@@ -513 +553 @@
                 }
             }
-            resultBuffer.append(new String(buffer, 0, count));
-        }
-        
-        if(globalConfig.getConnDebug()) {
-            EventLogger.logEvent(AppInfo.GUID, ("[RECV] " + resultBuffer.toString()).getBytes(), EventLogger.DEBUG_INFO);
-        }
-        if(actualAvailable > readBytes) {
-                fakeAvailable = actualAvailable - readBytes;
-        }
-        else {
-                fakeAvailable = -1;
-        }
-        
-        return resultBuffer.toString();
+
+            resultBuffer.write(buffer, 0, count);
+        }
+
+        String result = new String(resultBuffer.toArray());
+
+        if (globalConfig.getConnDebug()) {
+            EventLogger.logEvent(AppInfo.GUID,
+                ("[RECV] " + result).getBytes(),
+                EventLogger.DEBUG_INFO);
+        }
+
+        if (actualAvailable > readBytes) {
+            fakeAvailable = actualAvailable - readBytes;
+        } else {
+            fakeAvailable = -1;
+        }
+
+        return result;
     }
 }
-