import org.apache.mina.filter.codec.ProtocolCodecException; //导入依赖的package包/类
public MessageDecoderResult decode(IoSession session, ByteBuffer in, ProtocolDecoderOutput out)
        throws ProtocolCodecException {
    int messageCount = 0;
    while (parseMessage(in, out)) {
        messageCount++;
    }
    if (messageCount > 0) {
        // Mina will compact the buffer because we can't detect a header
        if (in.remaining() < HEADER_PATTERN.length) {
            position = 0;
        }
        return MessageDecoderResult.OK;
    } else {
        // Mina will compact the buffer
        position -= in.position();
        return MessageDecoderResult.NEED_DATA;
    }
}
 

import org.apache.mina.filter.codec.ProtocolCodecException; //导入依赖的package包/类
@Override
public void decode ( final IoSession session, final IoBuffer data, final ProtocolDecoderOutput output ) throws Exception
{
    final short magic = data.getShort ();
    final byte version = data.get ();
    final int sequence = data.getInt ();
    final byte commandCode = data.get ();

    if ( magic != 1202 )
    {
        throw new ProtocolCodecException ( String.format ( "Magic code should be 1202 but is %s", magic ) );
    }
    if ( version != 1 )
    {
        throw new ProtocolCodecException ( String.format ( "Version should be %s but is %s", 1, version ) );
    }

    decodeMessage ( sequence, commandCode, data, output );
}
 

import org.apache.mina.filter.codec.ProtocolCodecException; //导入依赖的package包/类
private Object decodeData ( final IoBuffer data ) throws ProtocolCodecException
{
    data.order ( ByteOrder.LITTLE_ENDIAN );

    final byte dataType = data.get ();
    switch ( dataType )
    {
        case 0:
            return null;
        case 1:
            return data.get () != 0x00;
        case 2:
            return data.getInt ();
        case 3:
            return data.getLong ();
        case 4:
            return data.getFloat ();
        default:
            throw new ProtocolCodecException ( String.format ( "Data type %02x is unknown", dataType ) );
    }

}
 

import org.apache.mina.filter.codec.ProtocolCodecException; //导入依赖的package包/类
private boolean processWriteCommand ( final IoSession session, final IoBuffer data, final ProtocolDecoderOutput out ) throws ProtocolCodecException
{
    final int len = messageLength ( data );
    if ( len < 0 )
    {
        return false;
    }

    final int registerNumber = data.getUnsignedShort ();
    final int operationId = data.getInt ();
    final Variant value = decodeVariant ( session, data );

    out.write ( new WriteCommand ( registerNumber, value, operationId ) );

    return true;
}
 

import org.apache.mina.filter.codec.ProtocolCodecException; //导入依赖的package包/类
private boolean processWriteResult ( final IoSession session, final IoBuffer data, final ProtocolDecoderOutput out ) throws ProtocolCodecException
{
    final int len = messageLength ( data );
    if ( len < 0 )
    {
        return false;
    }

    try
    {
        final int operationId = data.getInt ();
        final int errorCode = data.getUnsignedShort ();
        final String errorMessage = decodeString ( session, data );

        out.write ( new WriteResult ( operationId, errorCode, errorMessage ) );
    }
    catch ( final CharacterCodingException e )
    {
        throw new ProtocolCodecException ( e );
    }

    return true;
}
 

import org.apache.mina.filter.codec.ProtocolCodecException; //导入依赖的package包/类
private boolean processDataUpdate ( final IoSession session, final IoBuffer data, final ProtocolDecoderOutput out ) throws ProtocolCodecException
{
    final int len = messageLength ( data );
    if ( len < 0 )
    {
        return false;
    }

    final int count = data.getUnsignedShort ();
    final List<DataUpdate.Entry> entries = new ArrayList<DataUpdate.Entry> ( count );
    for ( int i = 0; i < count; i++ )
    {
        entries.add ( decodeDataUpdateEntry ( data, session ) );
    }

    out.write ( new DataUpdate ( entries ) );

    return true;
}
 

import org.apache.mina.filter.codec.ProtocolCodecException; //导入依赖的package包/类
private boolean processBrowseAdded ( final IoSession session, final IoBuffer data, final ProtocolDecoderOutput out ) throws ProtocolCodecException
{
    final int len = messageLength ( data );
    if ( len < 0 )
    {
        return false;
    }

    final int count = data.getUnsignedShort ();

    final List<BrowseAdded.Entry> entries = new ArrayList<BrowseAdded.Entry> ( count );

    for ( int i = 0; i < count; i++ )
    {
        entries.add ( decodeBrowserAddEntry ( data, session ) );
    }

    out.write ( new BrowseAdded ( entries ) );

    return true;
}
 

import org.apache.mina.filter.codec.ProtocolCodecException; //导入依赖的package包/类
private boolean processHello ( final IoSession session, final IoBuffer data, final ProtocolDecoderOutput out ) throws ProtocolCodecException
{
    final int len = messageLength ( data );
    if ( len < 0 )
    {
        return false;
    }

    final byte version = data.get ();
    if ( version != 0x01 )
    {
        throw new ProtocolCodecException ( String.format ( "Protocol version %s is unsupported", version ) );
    }

    final short nodeId = data.getShort ();
    final EnumSet<Hello.Features> features = data.getEnumSetShort ( Hello.Features.class );

    out.write ( new Hello ( nodeId, features ) );

    return true;
}
 

import org.apache.mina.filter.codec.ProtocolCodecException; //导入依赖的package包/类
private void encodeBrowseUpdate ( final IoSession session, final Object message, final IoBuffer data ) throws ProtocolCodecException
{
    // length
    data.putUnsignedShort ( ( (BrowseAdded)message ).getEntries ().size () );

    final CharsetEncoder encoder = Sessions.getCharsetEncoder ( session );

    // data
    for ( final BrowseAdded.Entry entry : ( (BrowseAdded)message ).getEntries () )
    {
        data.putUnsignedShort ( entry.getRegister () );
        data.put ( entry.getDataType ().getDataType () );
        data.putEnumSet ( entry.getFlags () );

        try
        {
            data.putPrefixedString ( entry.getName (), encoder );
            data.putPrefixedString ( entry.getDescription (), encoder );
            data.putPrefixedString ( entry.getUnit (), encoder );
        }
        catch ( final CharacterCodingException e )
        {
            throw new ProtocolCodecException ( e );
        }
    }
}
 

import org.apache.mina.filter.codec.ProtocolCodecException; //导入依赖的package包/类
private void encodeProperties ( final IoBuffer data, final Map<String, String> properties ) throws ProtocolCodecException
{
    final CharsetEncoder encoder = this.defaultCharset.newEncoder ();

    data.putUnsignedShort ( properties.size () );
    for ( final Map.Entry<String, String> entry : properties.entrySet () )
    {
        try
        {
            data.putPrefixedString ( entry.getKey (), encoder );
            data.putPrefixedString ( entry.getValue (), encoder );
        }
        catch ( final CharacterCodingException e )
        {
            throw new ProtocolCodecException ( e );
        }
    }
}
 

import org.apache.mina.filter.codec.ProtocolCodecException; //导入依赖的package包/类
private byte checkType ( final IoBuffer buffer, final byte expectedType, final boolean allowNull ) throws Exception
{
    final byte type = buffer.get ();

    if ( allowNull && type == TYPE_NULL )
    {
        return type;
    }

    if ( type != expectedType )
    {
        if ( type == 0 && !allowNull )
        {
            throw new ProtocolCodecException ( String.format ( "Failed to decode. Field is transmitted as null but defined as not-null." ) );
        }

        throw new ProtocolCodecException ( String.format ( "Failed to decode string: Expected type %02x, found: %02x", expectedType, type ) );
    }
    return type;
}
 

import org.apache.mina.filter.codec.ProtocolCodecException; //导入依赖的package包/类
/**
 * Utility to extract messages from a file. This method will return each
 * message found to a provided listener. The message file will also be
 * memory mapped rather than fully loaded into physical memory. Therefore,
 * a large message file can be processed without using excessive memory.
 *
 * @param file
 * @param listener
 * @throws IOException
 * @throws ProtocolCodecException
 */
public void extractMessages(File file, final MessageListener listener) throws IOException,
        ProtocolCodecException {
    // Set up a read-only memory-mapped file
    FileChannel readOnlyChannel = new RandomAccessFile(file, "r").getChannel();
    MappedByteBuffer memoryMappedBuffer = readOnlyChannel.map(FileChannel.MapMode.READ_ONLY, 0,
            (int) readOnlyChannel.size());

    decode(null, ByteBuffer.wrap(memoryMappedBuffer), new ProtocolDecoderOutput() {

        public void write(Object message) {
            listener.onMessage((String) message);
        }

        public void flush() {
            // ignored
        }

    });
}
 

import org.apache.mina.filter.codec.ProtocolCodecException; //导入依赖的package包/类
/**
 * Read a leaf node of a given type and leaf type.
 * 
 * @param type The node type.
 * @param leafType The type of value contained in the leaf: must be
 *                one of the XdrCoding.TYPE_* values.
 * @return The node.
 * 
 * @throws ProtocolCodecException if the node was not valid constant
 *                 node of the specified type.
 */
private Node leaf (int type, int leafType)
  throws ProtocolCodecException
{
  switch (type)
  {
    case NAME:
      assertLeafType (leafType, TYPE_STRING);
      return new Field (getString (in));
    case CONST_STRING:
      assertLeafType (leafType, TYPE_STRING);
      return new Const (getString (in));
    case CONST_INT32:
      assertLeafType (leafType, TYPE_INT32);
      return new Const (in.getInt ());
    case CONST_INT64:
      assertLeafType (leafType, TYPE_INT64);
      return new Const (in.getLong ());
    case CONST_REAL64:
      assertLeafType (leafType, TYPE_REAL64);
      return new Const (in.getDouble ());
    default:
      throw new Error ();
  }
}
 

import org.apache.mina.filter.codec.ProtocolCodecException; //导入依赖的package包/类
/**
 * Encode an AST in Elvin XDR format.
 * 
 * @param out The buffer to encode to.
 * @param node The root of the AST.
 * 
 * @see #decodeAST(ByteBuffer)
 */
public static void encodeAST (ByteBuffer out, Node node)
  throws ProtocolCodecException
{
  if (node instanceof Const)
  {
    encodeConst (out, (Const)node);
  } else if (node instanceof Field)
  {
    out.putInt (NAME);
    out.putInt (TYPE_STRING);
    putString (out, ((Field)node).fieldName ());
  } else
  {
    out.putInt (typeCodeFor (node));
    out.putInt (0); // composite node base type is 0
    
    Collection<Node> children = node.children ();
    
    out.putInt (children.size ());
    
    for (Node child : children)
      encodeAST (out, child);
  }
}
 

import org.apache.mina.filter.codec.ProtocolCodecException; //导入依赖的package包/类
/**
 * Read a length-delimited 4-byte-aligned UTF-8 string.
 */
public static String getString (ByteBuffer in)
  throws BufferUnderflowException, ProtocolCodecException
{
  try
  {
    int length = getPositiveInt (in);

    if (length == 0)
    {
      return "";
    } else
    {
      String string = in.getString (length, UTF8_DECODER.get ());
      
      in.skip (paddingFor (length));
      
      return string;
    }
  } catch (CharacterCodingException ex)
  {
    throw new ProtocolCodecException ("Invalid UTF-8 string", ex);
  }
}
 

import org.apache.mina.filter.codec.ProtocolCodecException; //导入依赖的package包/类
/**
 * Read a name/value set.
 */
public static Map<String, Object> getNameValues (ByteBuffer in)
  throws ProtocolCodecException
{
  int pairs = getPositiveInt (in);
  
  if (pairs == 0)
    return emptyMap ();
  
  HashMap<String, Object> nameValues = new HashMap<String, Object> ();
  
  for ( ; pairs > 0; pairs--)
    nameValues.put (getString (in), getObject (in));

  return nameValues;
}
 

import org.apache.mina.filter.codec.ProtocolCodecException; //导入依赖的package包/类
/**
 * Read an object in type_id/value format.
 */
public static Object getObject (ByteBuffer in)
  throws ProtocolCodecException
{
  int type = in.getInt ();
  
  switch (type)
  {
    case TYPE_INT32:
      return in.getInt ();
    case TYPE_INT64:
      return in.getLong ();
    case TYPE_REAL64:
      return in.getDouble ();
    case TYPE_STRING:
      return getString (in);
    case TYPE_OPAQUE:
      return getBytes (in);
    default:
      throw new ProtocolCodecException ("Unknown type code: " + type);
  }
}
 

import org.apache.mina.filter.codec.ProtocolCodecException; //导入依赖的package包/类
/** {@inheritDoc} */
public void encode(IoSession session, Object message, ProtocolEncoderOutput out) throws ProtocolCodecException {
	final ProtocolState state = (ProtocolState) session.getAttribute(ProtocolState.SESSION_KEY);
	// pass the connection to the encoder for its use
	encoder.setConnection((RTMPConnection) session.getAttribute(RTMPConnection.RTMP_CONNECTION_KEY));
	try {
		// We need to synchronize on the output and flush the generated data to prevent two packages to the same channel
		// to be sent in different order thus resulting in wrong headers being generated.
		final IoBuffer buf = encoder.encode(state, message);
		if (buf != null) {
			out.write(buf);
			out.mergeAll();
			out.flush();
		} else {
			log.trace("Response buffer was null after encoding");
		}
	} catch (Exception ex) {
		log.error("Exception during encode", ex);
	}
}
 

import org.apache.mina.filter.codec.ProtocolCodecException; //导入依赖的package包/类
/**
 * Decode a PDU as a slave
 *
 * @param message
 *            the message PDU
 * @return the decoded messages
 * @throws IllegalStateException
 *             if the function code is not supported
 */
public static Object decodeAsSlave ( final Pdu message ) throws ProtocolCodecException
{
    final IoBuffer data = message.getData ();

    final byte functionCode = data.get ();

    switch ( functionCode )
    {
        case Constants.FUNCTION_CODE_READ_COILS:
        case Constants.FUNCTION_CODE_READ_DISCRETE_INPUTS:
        case Constants.FUNCTION_CODE_READ_HOLDING_REGISTERS:
        case Constants.FUNCTION_CODE_READ_INPUT_REGISTERS:
            return new ReadRequest ( message.getTransactionId (), message.getUnitIdentifier (), functionCode, data.getUnsignedShort (), data.getUnsignedShort () );
        case Constants.FUNCTION_CODE_WRITE_SINGLE_COIL:
        case Constants.FUNCTION_CODE_WRITE_SINGLE_REGISTER:
            return new WriteSingleDataRequest ( message.getTransactionId (), message.getUnitIdentifier (), functionCode, data.getUnsignedShort (), readBytes ( data, 2 ) );
        case Constants.FUNCTION_CODE_WRITE_MULTIPLE_COILS:
        case Constants.FUNCTION_CODE_WRITE_MULTIPLE_REGISTERS:
            final int startAddress = data.getUnsignedShort ();
            final int numRegisters = data.getUnsignedShort (); /* number of registers */
            final byte num = data.get ();
            if ( data.remaining () != num )
            {
                throw new ProtocolCodecException ( String.format ( "Wrong amount of data. Announced %s (bytes), found %s (bytes)", num, data.remaining () ) );
            }
            final byte[] b = new byte[data.remaining ()];
            data.get ( b );
            return new WriteMultiDataRequest ( message.getTransactionId (), message.getUnitIdentifier (), functionCode, startAddress, b, numRegisters );
        default:
            throw new IllegalStateException ( String.format ( "Function code %02x is not supported", functionCode ) );
    }
}
 

import org.apache.mina.filter.codec.ProtocolCodecException; //导入依赖的package包/类
private void decodeMessage ( final int sequence, final byte commandCode, final IoBuffer data, final ProtocolDecoderOutput output ) throws ProtocolCodecException
{
    switch ( commandCode )
    {
        case 3:
            decodeResponseConfiguration ( data, output, sequence );
            break;
        case 5:
            decodeResponseData ( data, output, sequence );
            break;
    }

}