flutter::BasicMessageChannel< T > Class Template Reference

#include <basic_message_channel.h>

Public Member Functions
	BasicMessageChannel (BinaryMessenger *messenger, const std::string &name, const MessageCodec< T > *codec)
	~BasicMessageChannel ()=default
	BasicMessageChannel (BasicMessageChannel const &)=delete
BasicMessageChannel &	operator= (BasicMessageChannel const &)=delete
void	Send (const T &message)
void	Send (const T &message, BinaryReply reply)
void	SetMessageHandler (const MessageHandler< T > &handler) const
void	Resize (int new_size)
void	SetWarnsOnOverflow (bool warns)

Detailed Description

template<typename T = EncodableValue>
class flutter::BasicMessageChannel< T >

Definition at line 56 of file basic_message_channel.h.

Constructor & Destructor Documentation

BasicMessageChannel() [1/2]

template<typename T = EncodableValue>

flutter::BasicMessageChannel< T >::BasicMessageChannel ( BinaryMessenger *  messenger, const std::string &  name, const MessageCodec< T > *  codec  )

inline

Definition at line 60 of file basic_message_channel.h.

      : messenger_(messenger), name_(name), codec_(codec) {}

~BasicMessageChannel()

template<typename T = EncodableValue>

flutter::BasicMessageChannel< T >::~BasicMessageChannel ( )

default

BasicMessageChannel() [2/2]

template<typename T = EncodableValue>

flutter::BasicMessageChannel< T >::BasicMessageChannel ( BasicMessageChannel< T > const &  )

delete

Member Function Documentation

operator=()

template<typename T = EncodableValue>

BasicMessageChannel& flutter::BasicMessageChannel< T >::operator= ( BasicMessageChannel< T > const &  )

delete

Resize()

template<typename T = EncodableValue>

void flutter::BasicMessageChannel< T >::Resize ( int  new_size )

inline

Definition at line 128 of file basic_message_channel.h.

                            {
    internal::ResizeChannel(messenger_, name_, new_size);
  }

References flutter::internal::ResizeChannel().

Referenced by flutter::TEST().

Send() [1/2]

template<typename T = EncodableValue>

void flutter::BasicMessageChannel< T >::Send ( const T &  message )

inline

Definition at line 72 of file basic_message_channel.h.

                              {
    std::unique_ptr<std::vector<uint8_t>> raw_message =
        codec_->EncodeMessage(message);
    messenger_->Send(name_, raw_message->data(), raw_message->size());
  }

References message, and flutter::BinaryMessenger::Send().

Send() [2/2]

template<typename T = EncodableValue>

void flutter::BasicMessageChannel< T >::Send ( const T &  message, BinaryReply  reply  )

inline

Definition at line 79 of file basic_message_channel.h.

                                                 {
    std::unique_ptr<std::vector<uint8_t>> raw_message =
        codec_->EncodeMessage(message);
    messenger_->Send(name_, raw_message->data(), raw_message->size(),
                     std::move(reply));
  }

References message, and flutter::BinaryMessenger::Send().

SetMessageHandler()

template<typename T = EncodableValue>

void flutter::BasicMessageChannel< T >::SetMessageHandler ( const MessageHandler< T > &  handler ) const

inline

Definition at line 92 of file basic_message_channel.h.

                                                                 {
    if (!handler) {
      messenger_->SetMessageHandler(name_, nullptr);
      return;
    }
    const auto* codec = codec_;
    std::string channel_name = name_;
    BinaryMessageHandler binary_handler = [handler, codec, channel_name](
                                              const uint8_t* binary_message,
                                              const size_t binary_message_size,
                                              const BinaryReply& binary_reply) {
      // Use this channel's codec to decode the message and build a reply
      // handler.
      std::unique_ptr<T> message =
          codec->DecodeMessage(binary_message, binary_message_size);
      if (!message) {
        std::cerr << "Unable to decode message on channel " << channel_name
                  << std::endl;
        binary_reply(nullptr, 0);
        return;
      }
 
      MessageReply<T> unencoded_reply = [binary_reply,
                                         codec](const T& unencoded_response) {
        auto binary_response = codec->EncodeMessage(unencoded_response);
        binary_reply(binary_response->data(), binary_response->size());
      };
      handler(*message, std::move(unencoded_reply));
    };
    messenger_->SetMessageHandler(name_, std::move(binary_handler));
  }

References message, and flutter::BinaryMessenger::SetMessageHandler().

Referenced by flutter::TEST().

SetWarnsOnOverflow()

template<typename T = EncodableValue>

void flutter::BasicMessageChannel< T >::SetWarnsOnOverflow ( bool  warns )

inline

Definition at line 137 of file basic_message_channel.h.

                                      {
    internal::SetChannelWarnsOnOverflow(messenger_, name_, warns);
  }

References flutter::internal::SetChannelWarnsOnOverflow().

Referenced by flutter::TEST().

---

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

• shell/platform/common/client_wrapper/include/flutter/basic_message_channel.h