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.

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

~EventChannel()

template<typename T = EncodableValue>

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

default

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

SetStreamHandler()

template<typename T = EncodableValue>

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

inline

Definition at line 54 of file event_channel.h.

                                                                 {
    if (!handler) {
      messenger_->SetMessageHandler(name_, nullptr);
      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,
         // Mutable state to track the handler's listening status.
         is_listening = bool(false)](const uint8_t* message,
                                     const size_t message_size,
                                     const BinaryReply& reply) mutable {
          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.get());
            } 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.get());
              } 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