fl_standard_method_codec.cc

// Copyright 2013 The Flutter Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#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"

// See lib/src/services/message_codecs.dart in Flutter source for description of
// encoding.

// Envelope codes.
static constexpr guint8 kEnvelopeTypeSuccess = 0;
static constexpr guint8 kEnvelopeTypeError = 1;

struct _FlStandardMethodCodec {
  FlMethodCodec parent_instance;

  FlStandardMessageCodec* message_codec;
};

enum { kPropMessageCodec = 1, kPropLast };

G_DEFINE_TYPE(FlStandardMethodCodec,
              fl_standard_method_codec,
              fl_method_codec_get_type())

static void fl_standard_method_codec_set_property(GObject* object,
                                                  guint prop_id,
                                                  const GValue* value,
                                                  GParamSpec* pspec) {
  FlStandardMethodCodec* self = FL_STANDARD_METHOD_CODEC(object);

  switch (prop_id) {
    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;
  }
}

static void fl_standard_method_codec_get_property(GObject* object,
                                                  guint prop_id,
                                                  GValue* value,
                                                  GParamSpec* pspec) {
  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;
  }
}

static void fl_standard_method_codec_dispose(GObject* object) {
  FlStandardMethodCodec* self = FL_STANDARD_METHOD_CODEC(object);

  g_clear_object(&self->message_codec);

  G_OBJECT_CLASS(fl_standard_method_codec_parent_class)->dispose(object);
}

// Implements FlMethodCodec::encode_method_call.
static GBytes* fl_standard_method_codec_encode_method_call(FlMethodCodec* codec,
                                                           const gchar* name,
                                                           FlValue* args,
                                                           GError** error) {
  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)));
}

// Implements FlMethodCodec::decode_method_call.
static gboolean fl_standard_method_codec_decode_method_call(
    FlMethodCodec* codec,
    GBytes* message,
    gchar** name,
    FlValue** args,
    GError** error) {
  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;
}

// Implements FlMethodCodec::encode_success_envelope.
static GBytes* fl_standard_method_codec_encode_success_envelope(
    FlMethodCodec* codec,
    FlValue* result,
    GError** error) {
  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)));
}

// Implements FlMethodCodec::encode_error_envelope.
static GBytes* fl_standard_method_codec_encode_error_envelope(
    FlMethodCodec* codec,
    const gchar* code,
    const gchar* message,
    FlValue* details,
    GError** error) {
  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)));
}

// Implements FlMethodCodec::encode_decode_response.
static FlMethodResponse* fl_standard_method_codec_decode_response(
    FlMethodCodec* codec,
    GBytes* message,
    GError** error) {
  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));
}

static void fl_standard_method_codec_class_init(
    FlStandardMethodCodecClass* klass) {
  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)));
}

static void fl_standard_method_codec_init(FlStandardMethodCodec* self) {}

G_MODULE_EXPORT FlStandardMethodCodec* fl_standard_method_codec_new() {
  g_autoptr(FlStandardMessageCodec) message_codec =
      fl_standard_message_codec_new();
  return fl_standard_method_codec_new_with_message_codec(message_codec);
}

G_MODULE_EXPORT FlStandardMethodCodec*
fl_standard_method_codec_new_with_message_codec(
    FlStandardMessageCodec* message_codec) {
  return FL_STANDARD_METHOD_CODEC(
      g_object_new(fl_standard_method_codec_get_type(), "message-codec",
                   message_codec, nullptr));
}