io.flutter.plugin.common.StandardMessageCodec Class Reference

Inheritance diagram for io.flutter.plugin.common.StandardMessageCodec:

Classes
class	ExposedByteArrayOutputStream

Public Member Functions
ByteBuffer	encodeMessage (@Nullable Object message)
Object	decodeMessage (@Nullable ByteBuffer message)
Public Member Functions inherited from io.flutter.plugin.common.MessageCodec< Object >
ByteBuffer	encodeMessage ( @Nullable T message)
T	decodeMessage ( @Nullable ByteBuffer message)

Static Public Attributes
static final StandardMessageCodec	INSTANCE = new StandardMessageCodec()

Protected Member Functions
void	writeValue (@NonNull ByteArrayOutputStream stream, @Nullable Object value)
final Object	readValue (@NonNull ByteBuffer buffer)
Object	readValueOfType (byte type, @NonNull ByteBuffer buffer)

Static Protected Member Functions
static final void	writeSize (@NonNull ByteArrayOutputStream stream, int value)
static final void	writeChar (@NonNull ByteArrayOutputStream stream, int value)
static final void	writeInt (@NonNull ByteArrayOutputStream stream, int value)
static final void	writeLong (@NonNull ByteArrayOutputStream stream, long value)
static final void	writeFloat (@NonNull ByteArrayOutputStream stream, float value)
static final void	writeDouble (@NonNull ByteArrayOutputStream stream, double value)
static final void	writeBytes ( @NonNull ByteArrayOutputStream stream, @NonNull byte[] bytes)
static final void	writeAlignment (@NonNull ByteArrayOutputStream stream, int alignment)
static final int	readSize (@NonNull ByteBuffer buffer)
static final byte[]	readBytes (@NonNull ByteBuffer buffer)
static final void	readAlignment (@NonNull ByteBuffer buffer, int alignment)

Detailed Description

MessageCodec using the Flutter standard binary encoding.

This codec is guaranteed to be compatible with the corresponding StandardMessageCodec on the Dart side. These parts of the Flutter SDK are evolved synchronously.

Supported messages are acyclic values of these forms:

• null
• Booleans
• Bytes, Shorts, Integers, Longs
• BigIntegers (see below)
• Floats, Doubles
• Strings
• byte[], int[], long[], float[], double[]
• Lists of supported values
• Maps with supported keys and values

On the Dart side, these values are represented as follows:

• null: null
• Boolean: bool
• Byte, Short, Integer, Long: int
• Float, Double: double
• String: String
• byte[]: Uint8List
• int[]: Int32List
• long[]: Int64List
• float[]: Float32List
• double[]: Float64List
• List: List
• Map: Map

BigIntegers are represented in Dart as strings with the hexadecimal representation of the integer's value.

To extend the codec, overwrite the writeValue and readValueOfType methods.

Definition at line 65 of file StandardMessageCodec.java.

Member Function Documentation

decodeMessage()

Object io.flutter.plugin.common.StandardMessageCodec.decodeMessage ( @Nullable ByteBuffer  message )

inline

Definition at line 84 of file StandardMessageCodec.java.

                                                            {
    if (message == null) {
      return null;
    }
    message.order(ByteOrder.nativeOrder());
    final Object value = readValue(message);
    if (message.hasRemaining()) {
      throw new IllegalArgumentException("Message corrupted");
    }
    return value;
  }

encodeMessage()

ByteBuffer io.flutter.plugin.common.StandardMessageCodec.encodeMessage ( @Nullable Object  message )

inline

Definition at line 71 of file StandardMessageCodec.java.

                                                            {
    if (message == null) {
      return null;
    }
    final ExposedByteArrayOutputStream stream = new ExposedByteArrayOutputStream();
    writeValue(stream, message);
    final ByteBuffer buffer = ByteBuffer.allocateDirect(stream.size());
    buffer.put(stream.buffer(), 0, stream.size());
    return buffer;
  }

readAlignment()

static final void io.flutter.plugin.common.StandardMessageCodec.readAlignment ( @NonNull ByteBuffer  buffer, int  alignment  )

inlinestaticprotected

Reads alignment padding bytes as written by writeAlignment.

Definition at line 326 of file StandardMessageCodec.java.

                                                                                       {
    final int mod = buffer.position() % alignment;
    if (mod != 0) {
      buffer.position(buffer.position() + alignment - mod);
    }
  }

readBytes()

static final byte[] io.flutter.plugin.common.StandardMessageCodec.readBytes ( @NonNull ByteBuffer  buffer )

inlinestaticprotected

Reads a byte array as written by writeBytes.

Definition at line 318 of file StandardMessageCodec.java.

                                                                      {
    final int length = readSize(buffer);
    final byte[] bytes = new byte[length];
    buffer.get(bytes);
    return bytes;
  }

readSize()

static final int io.flutter.plugin.common.StandardMessageCodec.readSize ( @NonNull ByteBuffer  buffer )

inlinestaticprotected

Reads an int representing a size as written by writeSize.

Definition at line 302 of file StandardMessageCodec.java.

                                                                  {
    if (!buffer.hasRemaining()) {
      throw new IllegalArgumentException("Message corrupted");
    }
    final int value = buffer.get() & 0xff;
    if (value < 254) {
      return value;
    } else if (value == 254) {
      return buffer.getChar();
    } else {
      return buffer.getInt();
    }
  }

readValue()

final Object io.flutter.plugin.common.StandardMessageCodec.readValue ( @NonNull ByteBuffer  buffer )

inlineprotected

Reads a value as written by writeValue.

Definition at line 335 of file StandardMessageCodec.java.

                                                               {
    if (!buffer.hasRemaining()) {
      throw new IllegalArgumentException("Message corrupted");
    }
    final byte type = buffer.get();
    return readValueOfType(type, buffer);
  }

readValueOfType()

Object io.flutter.plugin.common.StandardMessageCodec.readValueOfType ( byte  type, @NonNull ByteBuffer  buffer  )

inlineprotected

Reads a value of the specified type.

Subclasses may extend the codec by overriding this method, calling super for types that the extension does not handle.

Definition at line 350 of file StandardMessageCodec.java.

                                                                          {
    final Object result;
    switch (type) {
      case NULL:
        result = null;
        break;
      case TRUE:
        result = true;
        break;
      case FALSE:
        result = false;
        break;
      case INT:
        result = buffer.getInt();
        break;
      case LONG:
        result = buffer.getLong();
        break;
      case BIGINT:
        {
          final byte[] hex = readBytes(buffer);
          result = new BigInteger(new String(hex, UTF8), 16);
          break;
        }
      case DOUBLE:
        readAlignment(buffer, 8);
        result = buffer.getDouble();
        break;
      case STRING:
        {
          final byte[] bytes = readBytes(buffer);
          result = new String(bytes, UTF8);
          break;
        }
      case BYTE_ARRAY:
        {
          result = readBytes(buffer);
          break;
        }
      case INT_ARRAY:
        {
          final int length = readSize(buffer);
          final int[] array = new int[length];
          readAlignment(buffer, 4);
          buffer.asIntBuffer().get(array);
          result = array;
          buffer.position(buffer.position() + 4 * length);
          break;
        }
      case LONG_ARRAY:
        {
          final int length = readSize(buffer);
          final long[] array = new long[length];
          readAlignment(buffer, 8);
          buffer.asLongBuffer().get(array);
          result = array;
          buffer.position(buffer.position() + 8 * length);
          break;
        }
      case DOUBLE_ARRAY:
        {
          final int length = readSize(buffer);
          final double[] array = new double[length];
          readAlignment(buffer, 8);
          buffer.asDoubleBuffer().get(array);
          result = array;
          buffer.position(buffer.position() + 8 * length);
          break;
        }
      case LIST:
        {
          final int size = readSize(buffer);
          final List<Object> list = new ArrayList<>(size);
          for (int i = 0; i < size; i++) {
            list.add(readValue(buffer));
          }
          result = list;
          break;
        }
      case MAP:
        {
          final int size = readSize(buffer);
          final Map<Object, Object> map = new HashMap<>();
          for (int i = 0; i < size; i++) {
            map.put(readValue(buffer), readValue(buffer));
          }
          result = map;
          break;
        }
      case FLOAT_ARRAY:
        {
          final int length = readSize(buffer);
          final float[] array = new float[length];
          readAlignment(buffer, 4);
          buffer.asFloatBuffer().get(array);
          result = array;
          buffer.position(buffer.position() + 4 * length);
          break;
        }
      default:
        throw new IllegalArgumentException("Message corrupted");
    }
    return result;
  }

writeAlignment()

static final void io.flutter.plugin.common.StandardMessageCodec.writeAlignment ( @NonNull ByteArrayOutputStream  stream, int  alignment  )

inlinestaticprotected

Writes a number of padding bytes to the specified stream to ensure that the next value is aligned to a whole multiple of the specified alignment. An example usage with alignment = 8 is to ensure doubles are word-aligned in the stream.

Definition at line 204 of file StandardMessageCodec.java.

                                                                                                   {
    final int mod = stream.size() % alignment;
    if (mod != 0) {
      for (int i = 0; i < alignment - mod; i++) {
        stream.write(0);
      }
    }
  }

writeBytes()

static final void io.flutter.plugin.common.StandardMessageCodec.writeBytes ( @NonNull ByteArrayOutputStream  stream, @NonNull byte[]  bytes  )

inlinestaticprotected

Writes the length and then the actual bytes of the specified array to the specified stream.

Definition at line 193 of file StandardMessageCodec.java.

                                                                    {
    writeSize(stream, bytes.length);
    stream.write(bytes, 0, bytes.length);
  }

writeChar()

static final void io.flutter.plugin.common.StandardMessageCodec.writeChar ( @NonNull ByteArrayOutputStream  stream, int  value  )

inlinestaticprotected

Writes the least significant two bytes of the specified int to the specified stream.

Definition at line 134 of file StandardMessageCodec.java.

                                                                                          {
    if (LITTLE_ENDIAN) {
      stream.write(value);
      stream.write(value >>> 8);
    } else {
      stream.write(value >>> 8);
      stream.write(value);
    }
  }

writeDouble()

static final void io.flutter.plugin.common.StandardMessageCodec.writeDouble ( @NonNull ByteArrayOutputStream  stream, double  value  )

inlinestaticprotected

Writes the specified double as 8 bytes to the specified stream.

Definition at line 188 of file StandardMessageCodec.java.

                                                                                               {
    writeLong(stream, Double.doubleToLongBits(value));
  }

writeFloat()

static final void io.flutter.plugin.common.StandardMessageCodec.writeFloat ( @NonNull ByteArrayOutputStream  stream, float  value  )

inlinestaticprotected

Writes the specified double as 4 bytes to the specified stream

Definition at line 183 of file StandardMessageCodec.java.

                                                                                             {
    writeInt(stream, Float.floatToIntBits(value));
  }

writeInt()

static final void io.flutter.plugin.common.StandardMessageCodec.writeInt ( @NonNull ByteArrayOutputStream  stream, int  value  )

inlinestaticprotected

Writes the specified int as 4 bytes to the specified stream.

Definition at line 145 of file StandardMessageCodec.java.

                                                                                         {
    if (LITTLE_ENDIAN) {
      stream.write(value);
      stream.write(value >>> 8);
      stream.write(value >>> 16);
      stream.write(value >>> 24);
    } else {
      stream.write(value >>> 24);
      stream.write(value >>> 16);
      stream.write(value >>> 8);
      stream.write(value);
    }
  }

writeLong()

static final void io.flutter.plugin.common.StandardMessageCodec.writeLong ( @NonNull ByteArrayOutputStream  stream, long  value  )

inlinestaticprotected

Writes the specified long as 8 bytes to the specified stream.

Definition at line 160 of file StandardMessageCodec.java.

                                                                                           {
    if (LITTLE_ENDIAN) {
      stream.write((byte) value);
      stream.write((byte) (value >>> 8));
      stream.write((byte) (value >>> 16));
      stream.write((byte) (value >>> 24));
      stream.write((byte) (value >>> 32));
      stream.write((byte) (value >>> 40));
      stream.write((byte) (value >>> 48));
      stream.write((byte) (value >>> 56));
    } else {
      stream.write((byte) (value >>> 56));
      stream.write((byte) (value >>> 48));
      stream.write((byte) (value >>> 40));
      stream.write((byte) (value >>> 32));
      stream.write((byte) (value >>> 24));
      stream.write((byte) (value >>> 16));
      stream.write((byte) (value >>> 8));
      stream.write((byte) value);
    }
  }

writeSize()

static final void io.flutter.plugin.common.StandardMessageCodec.writeSize ( @NonNull ByteArrayOutputStream  stream, int  value  )

inlinestaticprotected

Writes an int representing a size to the specified stream. Uses an expanding code of 1 to 5 bytes to optimize for small values.

Definition at line 118 of file StandardMessageCodec.java.

                                                                                          {
    if (BuildConfig.DEBUG && 0 > value) {
      Log.e(TAG, "Attempted to write a negative size.");
    }
    if (value < 254) {
      stream.write(value);
    } else if (value <= 0xffff) {
      stream.write(254);
      writeChar(stream, value);
    } else {
      stream.write(255);
      writeInt(stream, value);
    }
  }

writeValue()

void io.flutter.plugin.common.StandardMessageCodec.writeValue ( @NonNull ByteArrayOutputStream  stream, @Nullable Object  value  )

inlineprotected

Writes a type discriminator byte and then a byte serialization of the specified value to the specified stream.

Subclasses can extend the codec by overriding this method, calling super for values that the extension does not handle.

Definition at line 220 of file StandardMessageCodec.java.

                                                                                           {
    if (value == null || value.equals(null)) {
      stream.write(NULL);
    } else if (value instanceof Boolean) {
      stream.write(((Boolean) value).booleanValue() ? TRUE : FALSE);
    } else if (value instanceof Number) {
      if (value instanceof Integer || value instanceof Short || value instanceof Byte) {
        stream.write(INT);
        writeInt(stream, ((Number) value).intValue());
      } else if (value instanceof Long) {
        stream.write(LONG);
        writeLong(stream, (long) value);
      } else if (value instanceof Float || value instanceof Double) {
        stream.write(DOUBLE);
        writeAlignment(stream, 8);
        writeDouble(stream, ((Number) value).doubleValue());
      } else if (value instanceof BigInteger) {
        stream.write(BIGINT);
        writeBytes(stream, ((BigInteger) value).toString(16).getBytes(UTF8));
      } else {
        throw new IllegalArgumentException("Unsupported Number type: " + value.getClass());
      }
    } else if (value instanceof CharSequence) {
      stream.write(STRING);
      writeBytes(stream, value.toString().getBytes(UTF8));
    } else if (value instanceof byte[]) {
      stream.write(BYTE_ARRAY);
      writeBytes(stream, (byte[]) value);
    } else if (value instanceof int[]) {
      stream.write(INT_ARRAY);
      final int[] array = (int[]) value;
      writeSize(stream, array.length);
      writeAlignment(stream, 4);
      for (final int n : array) {
        writeInt(stream, n);
      }
    } else if (value instanceof long[]) {
      stream.write(LONG_ARRAY);
      final long[] array = (long[]) value;
      writeSize(stream, array.length);
      writeAlignment(stream, 8);
      for (final long n : array) {
        writeLong(stream, n);
      }
    } else if (value instanceof double[]) {
      stream.write(DOUBLE_ARRAY);
      final double[] array = (double[]) value;
      writeSize(stream, array.length);
      writeAlignment(stream, 8);
      for (final double d : array) {
        writeDouble(stream, d);
      }
    } else if (value instanceof List) {
      stream.write(LIST);
      final List<?> list = (List) value;
      writeSize(stream, list.size());
      for (final Object o : list) {
        writeValue(stream, o);
      }
    } else if (value instanceof Map) {
      stream.write(MAP);
      final Map<?, ?> map = (Map) value;
      writeSize(stream, map.size());
      for (final Entry<?, ?> entry : map.entrySet()) {
        writeValue(stream, entry.getKey());
        writeValue(stream, entry.getValue());
      }
    } else if (value instanceof float[]) {
      stream.write(FLOAT_ARRAY);
      final float[] array = (float[]) value;
      writeSize(stream, array.length);
      writeAlignment(stream, 4);
      for (final float f : array) {
        writeFloat(stream, f);
      }
    } else {
      throw new IllegalArgumentException(
          "Unsupported value: '" + value + "' of type '" + value.getClass() + "'");
    }
  }

Member Data Documentation

INSTANCE

final StandardMessageCodec io.flutter.plugin.common.StandardMessageCodec.INSTANCE = new StandardMessageCodec()

static

Definition at line 67 of file StandardMessageCodec.java.

---

The documentation for this class was generated from the following file:

• shell/platform/android/io/flutter/plugin/common/StandardMessageCodec.java