connectioncompressed.java

手机邮箱撒的方式方式方式的

                    } // End while

                    // Process last character (cann't be too long)
                    if ( prevByte == 0xF0 || prevByteCount > 1) {
                        // Longer run or problematic char --> double char code
                        buff.OutAddByte((byte)(0xF0 + prevByteCount - 1));
                        buff.OutAddByte(prevByte);
                    } else {
                        // Single non problematic char (not binary 1111????) -> one byte code
                        buff.OutAddByte(prevByte); 
                    }
                    
                    buff.OutFlush();
                } catch (EOFException ex) {
                    throw new MyException(MyException.COM_HALTED);
                } catch (IOException e) {
                    throw new MyException(MyException.COM_OUT, e);
                }
                return;
            } // end RLE compression
            //#endif

            //#ifdef MUJMAIL_COMPRESSED_CONNECTION
            // Sending none compression
            if ( (compression == COMPRESSION_TYPE_NONE) ||
                 (compression == COMPRESSION_TYPE_GZIP) ) {
            //#endif
                try {
                    connector.write(command, 0, command.length);
                    connector.flush();
                } catch (EOFException ex) {
                    throw new MyException(MyException.COM_HALTED);
                } catch (IOException e) {
                    throw new MyException(MyException.COM_OUT, e);
                }
                return;
            //#ifdef MUJMAIL_COMPRESSED_CONNECTION
            } // end None compression
            //#endif
        } // end synchronized
    } // end send

    public String getLine() throws MyException {
        if (connector == null ) return null;

        synchronized (syncOut) {
            if (backMark) {
                backMark = false;
                if (DEBUG) { System.out.println( "DEBUG ConnectionCompressed.getLine() =" + lastLine.toString()); }
                return lastLine.toString();
            }
        
            lastLine.delete(0, lastLine.length());
            char ch;

            //#ifdef MUJMAIL_COMPRESSED_CONNECTION
            if ( (compression == COMPRESSION_TYPE_NONE) ||
                 (compression == COMPRESSION_TYPE_GZIP) ){
            //#endif
                while (!quit) {
                    ch = (char) buff.InGetByte();
                    lastLine.append(ch);
                    if (ch == '\n') {
                        dataReadIn += lastLine.length();
                        if (DEBUG) { System.out.println( "DEBUG ConnectionCompressed.getLine() =" + lastLine.toString()); }
                        return lastLine.toString();
                    }
                }
            //#ifdef MUJMAIL_COMPRESSED_CONNECTION
            }
            //#endif

            //#ifdef MUJMAIL_COMPRESSED_CONNECTION
            int i1;
            int i2;
            if (compression == COMPRESSION_TYPE_RLE) {
                try {
                    while (!quit) {
                        // Appending into output string part
                        // Check if any work to do
                        if ( RLE_Count > 0) {
                            if (RLE_Char == '\n') { // End of line --> stop decoding
                                RLE_Count--;
                                lastLine.append(RLE_Char);
                                dataReadIn += lastLine.length();
                                return lastLine.toString();
                            }
                            for(int i = 0; i < RLE_Count; i++)
                                lastLine.append(RLE_Char);
                        }

                        // Decoding part
                        i1 = buff.InLookInBuffer(0);
                        i2 = buff.InLookInBuffer(1);
                        if (i1 == InOutBuffer.NO_DATA_IN_BUFFER)
                            buff.InFillBuffer(true);
                        i1 = buff.InLookInBuffer(0); // i1 != InOutBuffer.NO_DATA_IN_BUFFER ... timeout exception guards this
                        i2 = buff.InLookInBuffer(1);

                        if ((i1 & 0xF0) == 0xF0) {
                            // Two byte char
                            if (i2 == InOutBuffer.NO_DATA_IN_BUFFER)
                                buff.InFillBuffer(true);
                            i2 = buff.InLookInBuffer(1);
                            buff.InGetByte();
                            buff.InGetByte();
                            RLE_Count = (i1 & 0x0F) + 1;
                            RLE_Char = (char)i2;
                        } else {
                            buff.InGetByte();
                            RLE_Char = (char)i1;
                            RLE_Count = 1;
                        }
                    } // end While quit
                } catch (MyException e) {
                    // Repait RLE state
                    RLE_Count = 0;
                    throw e;
                } catch (EOFException ex) {
                    RLE_Count = 0;
                    throw new MyException(MyException.COM_HALTED);
                } catch (IOException e) {
                    RLE_Count = 0;
                    throw new MyException(MyException.COM_IN, e);
                }
            } // end RLE
            //#endif

            // TODO getIt into InOutBuffer filling routine to quit connection as soon as possible
            if (quit) { //user pressed the stop button
                throw new MyException(MyException.COM_HALTED);
            }
            

        } // end sync

        //this situation never happens, cause it either throws TIMEOUT exception, 
        //or returns a line or another exception
        //all cases are handled above, but its here because JAVA wants it :)
        return "";
    }

    public synchronized boolean isConnected() {
        return connected;
    }

    public void unGetLine() {
        synchronized (syncIn) {
            backMark = true;
        }
    }
    //note: the available() method doesn't work with some SSL implementation
    //so practically, the POP3 and IMAP4 implementations 
    //are responsible for disconnecting from the server to get the input really cleared!
    public void clearInput() throws MyException {
        if (connector == null ) return;
        if (connected == false) return; 
        if (quit) {
            throw new MyException(MyException.COM_HALTED);
        }
        synchronized (syncIn) {
            backMark = false;

            //#ifdef MUJMAIL_COMPRESSED_CONNECTION
            if ( (compression == COMPRESSION_TYPE_NONE) ||
                 (compression == COMPRESSION_TYPE_GZIP) ) {
            //#endif
                try {
                    buff.InFillBuffer(false);
                    while (buff.InLookInBuffer(0) != InOutBuffer.NO_DATA_IN_BUFFER) {
                        buff.InSkipBuffer();
                        buff.InFillBuffer(false);
                    }
                } catch (EOFException ex) {
                    throw new MyException(MyException.COM_HALTED);
                } catch (IOException e) {
                    throw new MyException(MyException.COM_IN, e);
                }
            //#ifdef MUJMAIL_COMPRESSED_CONNECTION
            } // End no compressed
            //#endif

            //#ifdef MUJMAIL_COMPRESSED_CONNECTION
            if (compression == COMPRESSION_TYPE_RLE) {
                try {
                    byte b;
                    // Decode current buffer

                    // Check if char available in buffer
                    while ( !((buff.InLookInBuffer(0) == InOutBuffer.NO_DATA_IN_BUFFER) || 
                            (((buff.InLookInBuffer(0) & 0xF0) == 0xF0) && 
                            (buff.InLookInBuffer(1) == InOutBuffer.NO_DATA_IN_BUFFER))) ) {
                        
                        // Check if char available in buffer
                        while ( !((buff.InLookInBuffer(0) == InOutBuffer.NO_DATA_IN_BUFFER) || 
                                (((buff.InLookInBuffer(0) & 0xF0) == 0xF0) && 
                                (buff.InLookInBuffer(1) == InOutBuffer.NO_DATA_IN_BUFFER))) ) {
                            b = buff.InGetByte();
                            if ((b & 0xF0) == 0xF0) buff.InGetByte();
                        }
                        buff.InFillBuffer(false);
                    }
                } catch (EOFException ex) {
                    throw new MyException(MyException.COM_HALTED);
                } catch (IOException e) {
                    throw new MyException(MyException.COM_IN, e);
                }
            } // End RLE compression
            //#endif
        } // end sync
    }

    public boolean available() {
        if (connector == null) return false;
        if (connected == false) return false;
        try {
	        if (((ConnectorSocket)connector).getInputStream().available() > 0) {
	        	return true;
	        }
	        else {
	        	return false;
	        }
        } catch (IOException ex) {
        	ex.printStackTrace();
        }
        synchronized (syncIn) {
            //#ifdef MUJMAIL_COMPRESSED_CONNECTION
            if ( (compression == COMPRESSION_TYPE_NONE) ||
                 (compression == COMPRESSION_TYPE_GZIP) ) {
            //#endif
                    if (buff.InLookInBuffer(0) != InOutBuffer.NO_DATA_IN_BUFFER) {
                        return true;
                    }
                    try {
                        if (connector.available() > 0) return true;
                    } catch (Exception e) {}
                    return false;
            //#ifdef MUJMAIL_COMPRESSED_CONNECTION
            }
            //#endif    

            //#ifdef MUJMAIL_COMPRESSED_CONNECTION
            if (compression == COMPRESSION_TYPE_RLE) {
                    if (buff.InLookInBuffer(1) != InOutBuffer.NO_DATA_IN_BUFFER) return true;
                    if (buff.InLookInBuffer(0) != InOutBuffer.NO_DATA_IN_BUFFER && (buff.InLookInBuffer(0) & 0xF0) != 0xF0 ) return true;
                    try {
                        if (connector.available() > 1) return true;
                    } catch (Exception e) {}
                    // TODO available_bug --> what TODO? in separate tread try to still read?
                    return false;
            }
            //#endif
        } // End synch 
        //#ifdef MUJMAIL_COMPRESSED_CONNECTION
        return false;
        //#endif
    }
    
    public void quit() {
        quit = true;
    }

    public void unQuit() {
        quit = false;
    }

}