flutter::PlatformMessageHandlerIos Class Reference

#include <platform_message_handler_ios.h>

Inheritance diagram for flutter::PlatformMessageHandlerIos:

Classes
struct	HandlerInfo

Public Member Functions
	PlatformMessageHandlerIos (fml::RefPtr< fml::TaskRunner > platform_task_runner)
void	HandlePlatformMessage (std::unique_ptr< PlatformMessage > message) override
bool	DoesHandlePlatformMessageOnPlatformThread () const override
void	InvokePlatformMessageResponseCallback (int response_id, std::unique_ptr< fml::Mapping > mapping) override
void	InvokePlatformMessageEmptyResponseCallback (int response_id) override
void	SetMessageHandler (const std::string &channel, FlutterBinaryMessageHandler handler, NSObject< FlutterTaskQueue > *task_queue)

Static Public Member Functions
static NSObject< FlutterTaskQueue > *	MakeBackgroundTaskQueue ()

Detailed Description

Definition at line 19 of file platform_message_handler_ios.h.

Constructor & Destructor Documentation

PlatformMessageHandlerIos()

flutter::PlatformMessageHandlerIos::PlatformMessageHandlerIos ( fml::RefPtr< fml::TaskRunner >  platform_task_runner )

explicit

Definition at line 43 of file platform_message_handler_ios.mm.

    : platform_task_runner_(std::move(platform_task_runner)) {}

Member Function Documentation

DoesHandlePlatformMessageOnPlatformThread()

bool flutter::PlatformMessageHandlerIos::DoesHandlePlatformMessageOnPlatformThread ( ) const

override

Definition at line 99 of file platform_message_handler_ios.mm.

                                                                                {
  return false;
}

HandlePlatformMessage()

void flutter::PlatformMessageHandlerIos::HandlePlatformMessage ( std::unique_ptr< PlatformMessage >  message )

override

Definition at line 47 of file platform_message_handler_ios.mm.

                                                                                            {
  // This can be called from any isolate's thread.
  @autoreleasepool {
    fml::RefPtr<flutter::PlatformMessageResponse> completer = message->response();
    HandlerInfo handler_info;
    {
      // TODO(gaaclarke): This mutex is a bottleneck for multiple isolates sending
      // messages at the same time. This could be potentially changed to a
      // read-write lock.
      std::lock_guard lock(message_handlers_mutex_);
      auto it = message_handlers_.find(message->channel());
      if (it != message_handlers_.end()) {
        handler_info = it->second;
      }
    }
    if (handler_info.handler) {
      FlutterBinaryMessageHandler handler = handler_info.handler;
      NSData* data = nil;
      if (message->hasData()) {
        data = ConvertMappingToNSData(message->releaseData());
      }
 
      uint64_t platform_message_id = platform_message_counter++;
      TRACE_EVENT_ASYNC_BEGIN1("flutter", "PlatformChannel ScheduleHandler", platform_message_id,
                               "channel", message->channel().c_str());
      dispatch_block_t run_handler = ^{
        handler(data, ^(NSData* reply) {
          TRACE_EVENT_ASYNC_END0("flutter", "PlatformChannel ScheduleHandler", platform_message_id);
          // Called from any thread.
          if (completer) {
            if (reply) {
              completer->Complete(ConvertNSDataToMappingPtr(reply));
            } else {
              completer->CompleteEmpty();
            }
          }
        });
      };
 
      if (handler_info.task_queue.get()) {
        [handler_info.task_queue.get() dispatch:run_handler];
      } else {
        dispatch_async(dispatch_get_main_queue(), run_handler);
      }
    } else {
      if (completer) {
        completer->CompleteEmpty();
      }
    }
  }
}

References flutter::ConvertMappingToNSData(), flutter::ConvertNSDataToMappingPtr(), flutter::PlatformMessageHandlerIos::HandlerInfo::handler, platform_message_counter, and flutter::PlatformMessageHandlerIos::HandlerInfo::task_queue.

InvokePlatformMessageEmptyResponseCallback()

void flutter::PlatformMessageHandlerIos::InvokePlatformMessageEmptyResponseCallback ( int  response_id )

override

Definition at line 111 of file platform_message_handler_ios.mm.

                                                                                          {
  // Called from any thread.
  // TODO(gaaclarke): This vestigal from the Android implementation, find a way
  // to migrate this to PlatformMessageHandlerAndroid.
}

InvokePlatformMessageResponseCallback()

void flutter::PlatformMessageHandlerIos::InvokePlatformMessageResponseCallback ( int  response_id, std::unique_ptr< fml::Mapping >  mapping  )

override

Definition at line 103 of file platform_message_handler_ios.mm.

                                       {
  // Called from any thread.
  // TODO(gaaclarke): This vestigal from the Android implementation, find a way
  // to migrate this to PlatformMessageHandlerAndroid.
}

MakeBackgroundTaskQueue()

NSObject< FlutterTaskQueue > * flutter::PlatformMessageHandlerIos::MakeBackgroundTaskQueue ( )

static

Definition at line 39 of file platform_message_handler_ios.mm.

                                                                               {
  return [[[FLTSerialTaskQueue alloc] init] autorelease];
}

SetMessageHandler()

void flutter::PlatformMessageHandlerIos::SetMessageHandler	(	const std::string &	channel,
		FlutterBinaryMessageHandler	handler,
		NSObject< FlutterTaskQueue > *	task_queue
	)

TODO(gaaclarke): This should be migrated to a lockfree datastructure.

Definition at line 117 of file platform_message_handler_ios.mm.

                                                                                          {
  FML_CHECK(platform_task_runner_->RunsTasksOnCurrentThread());
  // Use `respondsToSelector` instead of `conformsToProtocol` to accomodate
  // injecting your own `FlutterTaskQueue`. This is not a supported usage but
  // not one worth breaking.
  FML_CHECK(!task_queue || [task_queue respondsToSelector:@selector(dispatch:)]);
  /// TODO(gaaclarke): This should be migrated to a lockfree datastructure.
  std::lock_guard lock(message_handlers_mutex_);
  message_handlers_.erase(channel);
  if (handler) {
    message_handlers_[channel] = {
        .task_queue = fml::scoped_nsprotocol(
            [static_cast<NSObject<FlutterTaskQueueDispatch>*>(task_queue) retain]),
        .handler =
            fml::ScopedBlock<FlutterBinaryMessageHandler>{
                handler, fml::scoped_policy::OwnershipPolicy::kRetain},
    };
  }
}

---

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

• shell/platform/darwin/ios/platform_message_handler_ios.h
• shell/platform/darwin/ios/platform_message_handler_ios.mm