fl_standard_method_codec.cc File Reference

#include "flutter/shell/platform/linux/public/flutter_linux/fl_standard_method_codec.h"
#include <gmodule.h>
#include "flutter/shell/platform/linux/public/flutter_linux/fl_standard_message_codec.h"

Go to the source code of this file.

Classes
struct	_FlStandardMethodCodec

Enumerations
enum	{ kPropMessageCodec = 1 , kPropLast }

Functions
	G_DEFINE_TYPE (FlStandardMethodCodec, fl_standard_method_codec, fl_method_codec_get_type()) static void fl_standard_method_codec_set_property(GObject *object
	switch (prop_id)
static void	fl_standard_method_codec_get_property (GObject *object, guint prop_id, GValue *value, GParamSpec *pspec)
static void	fl_standard_method_codec_dispose (GObject *object)
static GBytes *	fl_standard_method_codec_encode_method_call (FlMethodCodec *codec, const gchar *name, FlValue *args, GError **error)
static gboolean	fl_standard_method_codec_decode_method_call (FlMethodCodec *codec, GBytes *message, gchar **name, FlValue **args, GError **error)
static GBytes *	fl_standard_method_codec_encode_success_envelope (FlMethodCodec *codec, FlValue *result, GError **error)
static GBytes *	fl_standard_method_codec_encode_error_envelope (FlMethodCodec *codec, const gchar *code, const gchar *message, FlValue *details, GError **error)
static FlMethodResponse *	fl_standard_method_codec_decode_response (FlMethodCodec *codec, GBytes *message, GError **error)
static void	fl_standard_method_codec_class_init (FlStandardMethodCodecClass *klass)
static void	fl_standard_method_codec_init (FlStandardMethodCodec *self)
G_MODULE_EXPORT FlStandardMethodCodec *	fl_standard_method_codec_new ()
G_MODULE_EXPORT FlStandardMethodCodec *	fl_standard_method_codec_new_with_message_codec (FlStandardMessageCodec *message_codec)

Variables
static constexpr guint8	kEnvelopeTypeSuccess = 0
static constexpr guint8	kEnvelopeTypeError = 1
guint	prop_id
guint const GValue *	value
guint const GValue GParamSpec *	pspec

Enumeration Type Documentation

anonymous enum

anonymous enum

Enumerator
kPropMessageCodec
kPropLast

Definition at line 24 of file fl_standard_method_codec.cc.

{ kPropMessageCodec = 1, kPropLast };

Function Documentation

fl_standard_method_codec_class_init()

static void fl_standard_method_codec_class_init ( FlStandardMethodCodecClass *  klass )

static

Definition at line 263 of file fl_standard_method_codec.cc.

                                       {
  G_OBJECT_CLASS(klass)->set_property = fl_standard_method_codec_set_property;
  G_OBJECT_CLASS(klass)->get_property = fl_standard_method_codec_get_property;
  G_OBJECT_CLASS(klass)->dispose = fl_standard_method_codec_dispose;
 
  FL_METHOD_CODEC_CLASS(klass)->encode_method_call =
      fl_standard_method_codec_encode_method_call;
  FL_METHOD_CODEC_CLASS(klass)->decode_method_call =
      fl_standard_method_codec_decode_method_call;
  FL_METHOD_CODEC_CLASS(klass)->encode_success_envelope =
      fl_standard_method_codec_encode_success_envelope;
  FL_METHOD_CODEC_CLASS(klass)->encode_error_envelope =
      fl_standard_method_codec_encode_error_envelope;
  FL_METHOD_CODEC_CLASS(klass)->decode_response =
      fl_standard_method_codec_decode_response;
 
  g_object_class_install_property(
      G_OBJECT_CLASS(klass), kPropMessageCodec,
      g_param_spec_object(
          "message-codec", "message-codec", "Message codec to use",
          fl_message_codec_get_type(),
          static_cast<GParamFlags>(G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY |
                                   G_PARAM_STATIC_STRINGS)));
}

fl_standard_method_codec_decode_method_call()

static gboolean fl_standard_method_codec_decode_method_call ( FlMethodCodec *  codec, GBytes *  message, gchar **  name, FlValue **  args, GError **  error  )

static

Definition at line 94 of file fl_standard_method_codec.cc.

                    {
  FlStandardMethodCodec* self = FL_STANDARD_METHOD_CODEC(codec);
 
  size_t offset = 0;
  g_autoptr(FlValue) name_value = fl_standard_message_codec_read_value(
      self->message_codec, message, &offset, error);
  if (name_value == nullptr) {
    return FALSE;
  }
  if (fl_value_get_type(name_value) != FL_VALUE_TYPE_STRING) {
    g_set_error(error, FL_MESSAGE_CODEC_ERROR, FL_MESSAGE_CODEC_ERROR_FAILED,
                "Method call name wrong type");
    return FALSE;
  }
 
  g_autoptr(FlValue) args_value = fl_standard_message_codec_read_value(
      self->message_codec, message, &offset, error);
  if (args_value == nullptr) {
    return FALSE;
  }
 
  if (offset != g_bytes_get_size(message)) {
    g_set_error(error, FL_MESSAGE_CODEC_ERROR, FL_MESSAGE_CODEC_ERROR_FAILED,
                "Unexpected extra data");
    return FALSE;
  }
 
  *name = g_strdup(fl_value_get_string(name_value));
  *args = fl_value_ref(args_value);
 
  return TRUE;
}

fl_standard_method_codec_decode_response()

static FlMethodResponse * fl_standard_method_codec_decode_response ( FlMethodCodec *  codec, GBytes *  message, GError **  error  )

static

Definition at line 184 of file fl_standard_method_codec.cc.

                    {
  FlStandardMethodCodec* self = FL_STANDARD_METHOD_CODEC(codec);
 
  if (g_bytes_get_size(message) == 0) {
    g_set_error(error, FL_MESSAGE_CODEC_ERROR,
                FL_MESSAGE_CODEC_ERROR_OUT_OF_DATA, "Empty response");
    return nullptr;
  }
 
  // First byte is response type.
  const guint8* data =
      static_cast<const guint8*>(g_bytes_get_data(message, nullptr));
  guint8 type = data[0];
  size_t offset = 1;
 
  g_autoptr(FlMethodResponse) response = nullptr;
  if (type == kEnvelopeTypeError) {
    g_autoptr(FlValue) code = fl_standard_message_codec_read_value(
        self->message_codec, message, &offset, error);
    if (code == nullptr) {
      return nullptr;
    }
    if (fl_value_get_type(code) != FL_VALUE_TYPE_STRING) {
      g_set_error(error, FL_MESSAGE_CODEC_ERROR, FL_MESSAGE_CODEC_ERROR_FAILED,
                  "Error code wrong type");
      return nullptr;
    }
 
    g_autoptr(FlValue) error_message = fl_standard_message_codec_read_value(
        self->message_codec, message, &offset, error);
    if (error_message == nullptr) {
      return nullptr;
    }
    if (fl_value_get_type(error_message) != FL_VALUE_TYPE_STRING &&
        fl_value_get_type(error_message) != FL_VALUE_TYPE_NULL) {
      g_set_error(error, FL_MESSAGE_CODEC_ERROR, FL_MESSAGE_CODEC_ERROR_FAILED,
                  "Error message wrong type");
      return nullptr;
    }
 
    g_autoptr(FlValue) details = fl_standard_message_codec_read_value(
        self->message_codec, message, &offset, error);
    if (details == nullptr) {
      return nullptr;
    }
 
    response = FL_METHOD_RESPONSE(fl_method_error_response_new(
        fl_value_get_string(code),
        fl_value_get_type(error_message) == FL_VALUE_TYPE_STRING
            ? fl_value_get_string(error_message)
            : nullptr,
        fl_value_get_type(details) != FL_VALUE_TYPE_NULL ? details : nullptr));
  } else if (type == kEnvelopeTypeSuccess) {
    g_autoptr(FlValue) result = fl_standard_message_codec_read_value(
        self->message_codec, message, &offset, error);
 
    if (result == nullptr) {
      return nullptr;
    }
 
    response = FL_METHOD_RESPONSE(fl_method_success_response_new(result));
  } else {
    g_set_error(error, FL_MESSAGE_CODEC_ERROR, FL_MESSAGE_CODEC_ERROR_FAILED,
                "Unknown envelope type %02x", type);
    return nullptr;
  }
 
  if (offset != g_bytes_get_size(message)) {
    g_set_error(error, FL_MESSAGE_CODEC_ERROR, FL_MESSAGE_CODEC_ERROR_FAILED,
                "Unexpected extra data");
    return nullptr;
  }
 
  return FL_METHOD_RESPONSE(g_object_ref(response));
}

fl_standard_method_codec_dispose()

static void fl_standard_method_codec_dispose ( GObject *  object )

static

Definition at line 63 of file fl_standard_method_codec.cc.

                                                              {
  FlStandardMethodCodec* self = FL_STANDARD_METHOD_CODEC(object);
 
  g_clear_object(&self->message_codec);
 
  G_OBJECT_CLASS(fl_standard_method_codec_parent_class)->dispose(object);
}

fl_standard_method_codec_encode_error_envelope()

static GBytes * fl_standard_method_codec_encode_error_envelope ( FlMethodCodec *  codec, const gchar *  code, const gchar *  message, FlValue *  details, GError **  error  )

static

Definition at line 152 of file fl_standard_method_codec.cc.

                    {
  FlStandardMethodCodec* self = FL_STANDARD_METHOD_CODEC(codec);
 
  g_autoptr(GByteArray) buffer = g_byte_array_new();
  guint8 type = kEnvelopeTypeError;
  g_byte_array_append(buffer, &type, 1);
  g_autoptr(FlValue) code_value = fl_value_new_string(code);
  if (!fl_standard_message_codec_write_value(self->message_codec, buffer,
                                             code_value, error)) {
    return nullptr;
  }
  g_autoptr(FlValue) message_value =
      message != nullptr ? fl_value_new_string(message) : nullptr;
  if (!fl_standard_message_codec_write_value(self->message_codec, buffer,
                                             message_value, error)) {
    return nullptr;
  }
  if (!fl_standard_message_codec_write_value(self->message_codec, buffer,
                                             details, error)) {
    return nullptr;
  }
 
  return g_byte_array_free_to_bytes(
      static_cast<GByteArray*>(g_steal_pointer(&buffer)));
}

fl_standard_method_codec_encode_method_call()

static GBytes * fl_standard_method_codec_encode_method_call ( FlMethodCodec *  codec, const gchar *  name, FlValue *  args, GError **  error  )

static

Definition at line 72 of file fl_standard_method_codec.cc.

                                                                           {
  FlStandardMethodCodec* self = FL_STANDARD_METHOD_CODEC(codec);
 
  g_autoptr(GByteArray) buffer = g_byte_array_new();
  g_autoptr(FlValue) name_value = fl_value_new_string(name);
  if (!fl_standard_message_codec_write_value(self->message_codec, buffer,
                                             name_value, error)) {
    return nullptr;
  }
  if (!fl_standard_message_codec_write_value(self->message_codec, buffer, args,
                                             error)) {
    return nullptr;
  }
 
  return g_byte_array_free_to_bytes(
      static_cast<GByteArray*>(g_steal_pointer(&buffer)));
}

fl_standard_method_codec_encode_success_envelope()

static GBytes * fl_standard_method_codec_encode_success_envelope ( FlMethodCodec *  codec, FlValue *  result, GError **  error  )

static

Definition at line 133 of file fl_standard_method_codec.cc.

                    {
  FlStandardMethodCodec* self = FL_STANDARD_METHOD_CODEC(codec);
 
  g_autoptr(GByteArray) buffer = g_byte_array_new();
  guint8 type = kEnvelopeTypeSuccess;
  g_byte_array_append(buffer, &type, 1);
  if (!fl_standard_message_codec_write_value(self->message_codec, buffer,
                                             result, error)) {
    return nullptr;
  }
 
  return g_byte_array_free_to_bytes(
      static_cast<GByteArray*>(g_steal_pointer(&buffer)));
}

fl_standard_method_codec_get_property()

static void fl_standard_method_codec_get_property ( GObject *  object, guint  prop_id, GValue *  value, GParamSpec *  pspec  )

static

Definition at line 47 of file fl_standard_method_codec.cc.

                                                                     {
  FlStandardMethodCodec* self = FL_STANDARD_METHOD_CODEC(object);
 
  switch (prop_id) {
    case kPropMessageCodec:
      g_value_set_object(value, self->message_codec);
      break;
    default:
      G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
      break;
  }
}

fl_standard_method_codec_init()

static void fl_standard_method_codec_init ( FlStandardMethodCodec *  self )

static

Definition at line 289 of file fl_standard_method_codec.cc.

{}

fl_standard_method_codec_new()

G_MODULE_EXPORT FlStandardMethodCodec * fl_standard_method_codec_new

(

)

Definition at line 291 of file fl_standard_method_codec.cc.

                                                                      {
  g_autoptr(FlStandardMessageCodec) message_codec =
      fl_standard_message_codec_new();
  return fl_standard_method_codec_new_with_message_codec(message_codec);
}

fl_standard_method_codec_new_with_message_codec()

G_MODULE_EXPORT FlStandardMethodCodec * fl_standard_method_codec_new_with_message_codec

(

FlStandardMessageCodec *

message_codec

)

fl_standard_method_codec_new: @message_codec: A #FlMessageCodec.

Creates an #FlStandardMethodCodec with a custom message codec.

Returns: a new #FlStandardMethodCodec.

Definition at line 298 of file fl_standard_method_codec.cc.

                                           {
  return FL_STANDARD_METHOD_CODEC(
      g_object_new(fl_standard_method_codec_get_type(), "message-codec",
                   message_codec, nullptr));
}

G_DEFINE_TYPE()

G_DEFINE_TYPE	(	FlStandardMethodCodec	,
		fl_standard_method_codec	,
		fl_method_codec_get_type()
	)

switch()

switch

(

prop_id

)

Definition at line 36 of file fl_standard_method_codec.cc.

                   {
    case kPropMessageCodec:
      g_set_object(&self->message_codec,
                   FL_STANDARD_MESSAGE_CODEC(g_value_get_object(value)));
      break;
    default:
      G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
      break;
  }

Variable Documentation

kEnvelopeTypeError

constexpr guint8 kEnvelopeTypeError = 1

staticconstexpr

Definition at line 16 of file fl_standard_method_codec.cc.

kEnvelopeTypeSuccess

constexpr guint8 kEnvelopeTypeSuccess = 0

staticconstexpr

Definition at line 15 of file fl_standard_method_codec.cc.

prop_id

guint prop_id

Definition at line 31 of file fl_standard_method_codec.cc.

pspec

guint const GValue GParamSpec* pspec

Initial value:

{
  FlStandardMethodCodec* self = FL_STANDARD_METHOD_CODEC(object)

Definition at line 33 of file fl_standard_method_codec.cc.

value

guint const GValue* value

Definition at line 32 of file fl_standard_method_codec.cc.