fl_json_message_codec.cc File Reference

#include "flutter/shell/platform/linux/public/flutter_linux/fl_json_message_codec.h"
#include <gmodule.h>
#include <cstring>
#include "rapidjson/reader.h"
#include "rapidjson/writer.h"

Go to the source code of this file.

Classes
struct	_FlJsonMessageCodec
struct	FlValueHandler

Functions
	G_DEFINE_TYPE (FlJsonMessageCodec, fl_json_message_codec, fl_message_codec_get_type()) static gboolean write_value(rapidjson
static GBytes *	fl_json_message_codec_encode_message (FlMessageCodec *codec, FlValue *message, GError **error)
static FlValue *	fl_json_message_codec_decode_message (FlMessageCodec *codec, GBytes *message, GError **error)
static void	fl_json_message_codec_class_init (FlJsonMessageCodecClass *klass)
static void	fl_json_message_codec_init (FlJsonMessageCodec *self)
G_MODULE_EXPORT FlJsonMessageCodec *	fl_json_message_codec_new ()
G_MODULE_EXPORT gchar *	fl_json_message_codec_encode (FlJsonMessageCodec *codec, FlValue *value, GError **error)
G_MODULE_EXPORT FlValue *	fl_json_message_codec_decode (FlJsonMessageCodec *codec, const gchar *text, GError **error)

Function Documentation

fl_json_message_codec_class_init()

static void fl_json_message_codec_class_init ( FlJsonMessageCodecClass *  klass )

static

Definition at line 297 of file fl_json_message_codec.cc.

                                                                             {
  FL_MESSAGE_CODEC_CLASS(klass)->encode_message =
      fl_json_message_codec_encode_message;
  FL_MESSAGE_CODEC_CLASS(klass)->decode_message =
      fl_json_message_codec_decode_message;
}

fl_json_message_codec_decode()

G_MODULE_EXPORT FlValue * fl_json_message_codec_decode	(	FlJsonMessageCodec *	codec,
		const gchar *	text,
		GError **	error
	)

fl_json_message_codec_decode: @codec: an #FlJsonMessageCodec. @text: UTF-8 text in JSON format. @error: (allow-none): #GError location to store the error occurring, or NULL.

Decodes a value from a JSON string.

Returns: an FlValue or NULL on error.

Definition at line 326 of file fl_json_message_codec.cc.

                                                                      {
  g_return_val_if_fail(FL_IS_JSON_CODEC(codec), nullptr);
 
  g_autoptr(GBytes) data = g_bytes_new_static(text, strlen(text));
  g_autoptr(FlValue) value = fl_json_message_codec_decode_message(
      FL_MESSAGE_CODEC(codec), data, error);
  if (value == nullptr) {
    return nullptr;
  }
 
  return fl_value_ref(value);
}

fl_json_message_codec_decode_message()

static FlValue * fl_json_message_codec_decode_message ( FlMessageCodec *  codec, GBytes *  message, GError **  error  )

static

Definition at line 258 of file fl_json_message_codec.cc.

                                                                     {
  gsize data_length;
  const gchar* data =
      static_cast<const char*>(g_bytes_get_data(message, &data_length));
  if (!g_utf8_validate(data, data_length, nullptr)) {
    g_set_error(error, FL_JSON_MESSAGE_CODEC_ERROR,
                FL_JSON_MESSAGE_CODEC_ERROR_INVALID_UTF8,
                "Message is not valid UTF8");
    return nullptr;
  }
 
  FlValueHandler handler;
  rapidjson::Reader reader;
  rapidjson::MemoryStream ss(data, data_length);
  if (!reader.Parse(ss, handler)) {
    if (handler.error != nullptr) {
      g_propagate_error(error, handler.error);
      handler.error = nullptr;
    } else {
      g_set_error(error, FL_JSON_MESSAGE_CODEC_ERROR,
                  FL_JSON_MESSAGE_CODEC_ERROR_INVALID_JSON,
                  "Message is not valid JSON");
    }
    return nullptr;
  }
 
  FlValue* value = handler.get_head();
  if (value == nullptr) {
    g_set_error(error, FL_JSON_MESSAGE_CODEC_ERROR,
                FL_JSON_MESSAGE_CODEC_ERROR_INVALID_JSON,
                "Message is not valid JSON");
    return nullptr;
  }
 
  return fl_value_ref(value);
}

fl_json_message_codec_encode()

G_MODULE_EXPORT gchar * fl_json_message_codec_encode	(	FlJsonMessageCodec *	codec,
		FlValue *	value,
		GError **	error
	)

fl_json_message_codec_encode: @codec: an #FlJsonMessageCodec. @value: value to encode. @error: (allow-none): #GError location to store the error occurring, or NULL.

Encodes a value to a JSON string.

Returns: a JSON representation of this value or NULL on error.

Definition at line 311 of file fl_json_message_codec.cc.

                                                                    {
  g_return_val_if_fail(FL_IS_JSON_CODEC(codec), nullptr);
 
  rapidjson::StringBuffer buffer;
  rapidjson::Writer<rapidjson::StringBuffer> writer(buffer);
 
  if (!write_value(writer, value, error)) {
    return nullptr;
  }
 
  return g_strdup(buffer.GetString());
}

fl_json_message_codec_encode_message()

static GBytes * fl_json_message_codec_encode_message ( FlMessageCodec *  codec, FlValue *  message, GError **  error  )

static

Definition at line 243 of file fl_json_message_codec.cc.

                                                                    {
  rapidjson::StringBuffer buffer;
  rapidjson::Writer<rapidjson::StringBuffer> writer(buffer);
 
  if (!write_value(writer, message, error)) {
    return nullptr;
  }
 
  const gchar* text = buffer.GetString();
  return g_bytes_new(text, strlen(text));
}

fl_json_message_codec_init()

static void fl_json_message_codec_init ( FlJsonMessageCodec *  self )

static

Definition at line 304 of file fl_json_message_codec.cc.

{}

fl_json_message_codec_new()

G_MODULE_EXPORT FlJsonMessageCodec * fl_json_message_codec_new

(

)

Definition at line 306 of file fl_json_message_codec.cc.

                                                                {
  return static_cast<FlJsonMessageCodec*>(
      g_object_new(fl_json_message_codec_get_type(), nullptr));
}

G_DEFINE_TYPE()

G_DEFINE_TYPE	(	FlJsonMessageCodec	,
		fl_json_message_codec	,
		fl_message_codec_get_type()
	)

Definition at line 20 of file fl_json_message_codec.cc.

                                            {
  if (value == nullptr) {
    writer.Null();
    return TRUE;
  }
 
  switch (fl_value_get_type(value)) {
    case FL_VALUE_TYPE_NULL:
      writer.Null();
      break;
    case FL_VALUE_TYPE_BOOL:
      writer.Bool(fl_value_get_bool(value));
      break;
    case FL_VALUE_TYPE_INT:
      writer.Int64(fl_value_get_int(value));
      break;
    case FL_VALUE_TYPE_FLOAT:
      writer.Double(fl_value_get_float(value));
      break;
    case FL_VALUE_TYPE_STRING:
      writer.String(fl_value_get_string(value));
      break;
    case FL_VALUE_TYPE_UINT8_LIST: {
      writer.StartArray();
      const uint8_t* data = fl_value_get_uint8_list(value);
      for (size_t i = 0; i < fl_value_get_length(value); i++) {
        writer.Int(data[i]);
      }
      writer.EndArray();
      break;
    }
    case FL_VALUE_TYPE_INT32_LIST: {
      writer.StartArray();
      const int32_t* data = fl_value_get_int32_list(value);
      for (size_t i = 0; i < fl_value_get_length(value); i++) {
        writer.Int(data[i]);
      }
      writer.EndArray();
      break;
    }
    case FL_VALUE_TYPE_INT64_LIST: {
      writer.StartArray();
      const int64_t* data = fl_value_get_int64_list(value);
      for (size_t i = 0; i < fl_value_get_length(value); i++) {
        writer.Int64(data[i]);
      }
      writer.EndArray();
      break;
    }
    case FL_VALUE_TYPE_FLOAT_LIST: {
      writer.StartArray();
      const double* data = fl_value_get_float_list(value);
      for (size_t i = 0; i < fl_value_get_length(value); i++) {
        writer.Double(data[i]);
      }
      writer.EndArray();
      break;
    }
    case FL_VALUE_TYPE_LIST: {
      writer.StartArray();
      for (size_t i = 0; i < fl_value_get_length(value); i++) {
        if (!write_value(writer, fl_value_get_list_value(value, i), error)) {
          return FALSE;
        }
      }
      writer.EndArray();
      break;
    }
    case FL_VALUE_TYPE_MAP: {
      writer.StartObject();
      for (size_t i = 0; i < fl_value_get_length(value); i++) {
        FlValue* key = fl_value_get_map_key(value, i);
        if (fl_value_get_type(key) != FL_VALUE_TYPE_STRING) {
          g_set_error(error, FL_JSON_MESSAGE_CODEC_ERROR,
                      FL_JSON_MESSAGE_CODEC_ERROR_INVALID_OBJECT_KEY_TYPE,
                      "Invalid object key type");
          return FALSE;
        }
        writer.Key(fl_value_get_string(key));
        if (!write_value(writer, fl_value_get_map_value(value, i), error)) {
          return FALSE;
        }
      }
      writer.EndObject();
      break;
    }
    default:
      g_set_error(error, FL_MESSAGE_CODEC_ERROR,
                  FL_MESSAGE_CODEC_ERROR_UNSUPPORTED_TYPE,
                  "Unexpected FlValue type %d", fl_value_get_type(value));
      return FALSE;
  }
 
  return TRUE;
}