flutter::MethodChannel< T > Class Template Reference

#include <method_channel.h>

Public Member Functions
	MethodChannel (BinaryMessenger *messenger, const std::string &name, const MethodCodec< T > *codec)
	~MethodChannel ()=default
	MethodChannel (MethodChannel const &)=delete
MethodChannel &	operator= (MethodChannel const &)=delete
void	InvokeMethod (const std::string &method, std::unique_ptr< T > arguments, std::unique_ptr< MethodResult< T > > result=nullptr)
void	SetMethodCallHandler (MethodCallHandler< T > handler) const
void	Resize (int new_size)
void	SetWarnsOnOverflow (bool warns)

Detailed Description

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

Definition at line 34 of file method_channel.h.

Constructor & Destructor Documentation

MethodChannel() [1/2]

template<typename T = EncodableValue>

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

inline

Definition at line 38 of file method_channel.h.

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

~MethodChannel()

template<typename T = EncodableValue>

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

default

MethodChannel() [2/2]

template<typename T = EncodableValue>

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

delete

Member Function Documentation

InvokeMethod()

template<typename T = EncodableValue>

void flutter::MethodChannel< T >::InvokeMethod ( const std::string &  method, std::unique_ptr< T >  arguments, std::unique_ptr< MethodResult< T > >  result = nullptr  )

inline

Definition at line 53 of file method_channel.h.

                                                                     {
    MethodCall<T> method_call(method, std::move(arguments));
    std::unique_ptr<std::vector<uint8_t>> message =
        codec_->EncodeMethodCall(method_call);
    if (!result) {
      messenger_->Send(name_, message->data(), message->size(), 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<MethodResult<T>> shared_result(result.release());
    const auto* codec = codec_;
    std::string channel_name = name_;
    BinaryReply reply_handler = [shared_result, codec, channel_name](
                                    const uint8_t* reply, size_t reply_size) {
      if (reply_size == 0) {
        shared_result->NotImplemented();
        return;
      }
      // Use this channel's codec to decode and handle the
      // reply.
      bool decoded = codec->DecodeAndProcessResponseEnvelope(
          reply, reply_size, shared_result.get());
      if (!decoded) {
        std::cerr << "Unable to decode reply to method "
                     "invocation on channel "
                  << channel_name << std::endl;
        shared_result->NotImplemented();
      }
    };
 
    messenger_->Send(name_, message->data(), message->size(),
                     std::move(reply_handler));
  }

operator=()

template<typename T = EncodableValue>

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

delete

Resize()

template<typename T = EncodableValue>

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

inline

Definition at line 130 of file method_channel.h.

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

SetMethodCallHandler()

template<typename T = EncodableValue>

void flutter::MethodChannel< T >::SetMethodCallHandler ( MethodCallHandler< T >  handler ) const

inline

Definition at line 99 of file method_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* message,
                                              size_t message_size,
                                              BinaryReply reply) {
      // Use this channel's codec to decode the call and build a result handler.
      auto result =
          std::make_unique<EngineMethodResult<T>>(std::move(reply), codec);
      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;
        result->NotImplemented();
        return;
      }
      handler(*method_call, std::move(result));
    };
    messenger_->SetMessageHandler(name_, std::move(binary_handler));
  }

SetWarnsOnOverflow()

template<typename T = EncodableValue>

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

inline

Definition at line 139 of file method_channel.h.

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

---

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

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