flutter::EventChannel< T > Class Template Reference

#include <event_channel.h>

Public Member Functions
	EventChannel (BinaryMessenger *messenger, const std::string &name, const MethodCodec< T > *codec)
	~EventChannel ()=default
	EventChannel (EventChannel const &)=delete
EventChannel &	operator= (EventChannel const &)=delete
void	SetStreamHandler (std::unique_ptr< StreamHandler< T >> handler)

Detailed Description

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

Definition at line 33 of file event_channel.h.

Constructor & Destructor Documentation

EventChannel() [1/2]

template<typename T = EncodableValue>

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

inline

Definition at line 37 of file event_channel.h.

References flutter::EventChannel< T >::operator=(), and flutter::EventChannel< T >::~EventChannel().

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

~EventChannel()

template<typename T = EncodableValue>

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

default

Referenced by flutter::EventChannel< T >::EventChannel().

EventChannel() [2/2]

template<typename T = EncodableValue>

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

delete

Member Function Documentation

operator=()

template<typename T = EncodableValue>

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

delete

Referenced by flutter::EventChannel< T >::EventChannel(), and flutter::EventChannel< T >::SetStreamHandler().

SetStreamHandler()

template<typename T = EncodableValue>

void flutter::EventChannel< T >::SetStreamHandler ( std::unique_ptr< StreamHandler< T >>  handler )

inline

Definition at line 50 of file event_channel.h.

References flutter::MethodCodec< T >::EncodeErrorEnvelope(), flutter::MethodCodec< T >::EncodeSuccessEnvelope(), error, event, message, method_call, flutter::name, flutter::EventChannel< T >::operator=(), result, flutter::BinaryMessenger::Send(), and flutter::BinaryMessenger::SetMessageHandler().

Referenced by flutter::TEST().

                                                                 {
    if (!handler) {
      messenger_->SetMessageHandler(name_, nullptr);
      is_listening_ = false;
      return;
    }

    // std::function requires a copyable lambda, so convert to a shared pointer.
    // This is safe since only one copy of the shared_pointer will ever be
    // accessed.
    std::shared_ptr<StreamHandler<T>> shared_handler(handler.release());
    const MethodCodec<T>* codec = codec_;
    const std::string channel_name = name_;
    const BinaryMessenger* messenger = messenger_;
    BinaryMessageHandler binary_handler = [shared_handler, codec, channel_name,
                                           messenger,
                                           this](const uint8_t* message,
                                                 const size_t message_size,
                                                 BinaryReply reply) {
      constexpr char kOnListenMethod[] = "listen";
      constexpr char kOnCancelMethod[] = "cancel";

      std::unique_ptr<MethodCall<T>> method_call =
          codec->DecodeMethodCall(message, message_size);
      if (!method_call) {
        std::cerr << "Unable to construct method call from message on channel: "
                  << channel_name << std::endl;
        reply(nullptr, 0);
        return;
      }

      const std::string& method = method_call->method_name();
      if (method.compare(kOnListenMethod) == 0) {
        if (is_listening_) {
          std::unique_ptr<StreamHandlerError<T>> error =
              shared_handler->OnCancel(nullptr);
          if (error) {
            std::cerr << "Failed to cancel existing stream: "
                      << (error->error_code) << ", " << (error->error_message)
                      << ", " << (error->error_details);
          }
        }
        is_listening_ = true;

        std::unique_ptr<std::vector<uint8_t>> result;
        auto sink = std::make_unique<EventSinkImplementation>(
            messenger, channel_name, codec);
        std::unique_ptr<StreamHandlerError<T>> error =
            shared_handler->OnListen(method_call->arguments(), std::move(sink));
        if (error) {
          result = codec->EncodeErrorEnvelope(
              error->error_code, error->error_message, error->error_details);
        } else {
          result = codec->EncodeSuccessEnvelope();
        }
        reply(result->data(), result->size());
      } else if (method.compare(kOnCancelMethod) == 0) {
        std::unique_ptr<std::vector<uint8_t>> result;
        if (is_listening_) {
          std::unique_ptr<StreamHandlerError<T>> error =
              shared_handler->OnCancel(method_call->arguments());
          if (error) {
            result = codec->EncodeErrorEnvelope(
                error->error_code, error->error_message, error->error_details);
          } else {
            result = codec->EncodeSuccessEnvelope();
          }
          is_listening_ = false;
        } else {
          result = codec->EncodeErrorEnvelope(
              "error", "No active stream to cancel", nullptr);
        }
        reply(result->data(), result->size());
      } else {
        reply(nullptr, 0);
      }
    };
    messenger_->SetMessageHandler(name_, std::move(binary_handler));
  }

---

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

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