| Flutter macOS Embedder |

FlutterEngine.mm
Go to the documentation of this file.
1 // Copyright 2013 The Flutter Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4
5 #import "flutter/shell/platform/darwin/macos/framework/Headers/FlutterEngine.h"
6 #import "flutter/shell/platform/darwin/macos/framework/Source/FlutterEngine_Internal.h"
7
8 #include <algorithm>
9 #include <iostream>
10 #include <vector>
11
12 #include "flutter/common/constants.h"
13 #include "flutter/shell/platform/common/app_lifecycle_state.h"
14 #include "flutter/shell/platform/common/engine_switches.h"
15 #include "flutter/shell/platform/embedder/embedder.h"
16
17 #import "flutter/shell/platform/darwin/common/framework/Source/FlutterBinaryMessengerRelay.h"
18 #import "flutter/shell/platform/darwin/macos/framework/Headers/FlutterAppDelegate.h"
19 #import "flutter/shell/platform/darwin/macos/framework/Source/FlutterAppDelegate_Internal.h"
20 #import "flutter/shell/platform/darwin/macos/framework/Source/FlutterCompositor.h"
21 #import "flutter/shell/platform/darwin/macos/framework/Source/FlutterDartProject_Internal.h"
22 #import "flutter/shell/platform/darwin/macos/framework/Source/FlutterDisplayLink.h"
23 #import "flutter/shell/platform/darwin/macos/framework/Source/FlutterMenuPlugin.h"
24 #import "flutter/shell/platform/darwin/macos/framework/Source/FlutterMouseCursorPlugin.h"
25 #import "flutter/shell/platform/darwin/macos/framework/Source/FlutterPlatformViewController.h"
26 #import "flutter/shell/platform/darwin/macos/framework/Source/FlutterRenderer.h"
27 #import "flutter/shell/platform/darwin/macos/framework/Source/FlutterTimeConverter.h"
28 #import "flutter/shell/platform/darwin/macos/framework/Source/FlutterVSyncWaiter.h"
29 #import "flutter/shell/platform/darwin/macos/framework/Source/FlutterViewController_Internal.h"
30 #import "flutter/shell/platform/darwin/macos/framework/Source/FlutterViewEngineProvider.h"
31
32 @class FlutterEngineRegistrar;
33
34 NSString* const kFlutterPlatformChannel = @"flutter/platform";
35 NSString* const kFlutterSettingsChannel = @"flutter/settings";
36 NSString* const kFlutterLifecycleChannel = @"flutter/lifecycle";
37
38 using flutter::kFlutterImplicitViewId;
39
40 /**
41 * Constructs and returns a FlutterLocale struct corresponding to |locale|, which must outlive
42 * the returned struct.
43 */
44 static FlutterLocale FlutterLocaleFromNSLocale(NSLocale* locale) {
45 FlutterLocale flutterLocale = {};
46 flutterLocale.struct_size = sizeof(FlutterLocale);
47 flutterLocale.language_code = [[locale objectForKey:NSLocaleLanguageCode] UTF8String];
48 flutterLocale.country_code = [[locale objectForKey:NSLocaleCountryCode] UTF8String];
49 flutterLocale.script_code = [[locale objectForKey:NSLocaleScriptCode] UTF8String];
50 flutterLocale.variant_code = [[locale objectForKey:NSLocaleVariantCode] UTF8String];
51 return flutterLocale;
52 }
53
54 /// The private notification for voice over.
55 static NSString* const kEnhancedUserInterfaceNotification =
56 @"NSApplicationDidChangeAccessibilityEnhancedUserInterfaceNotification";
57 static NSString* const kEnhancedUserInterfaceKey = @"AXEnhancedUserInterface";
58
59 /// Clipboard plain text format.
60 constexpr char kTextPlainFormat[] = "text/plain";
61
62 #pragma mark -
63
64 // Records an active handler of the messenger (FlutterEngine) that listens to
65 // platform messages on a given channel.
66 @interface FlutterEngineHandlerInfo : NSObject
67
68 - (instancetype)initWithConnection:(NSNumber*)connection
69 handler:(FlutterBinaryMessageHandler)handler;
70
71 @property(nonatomic, readonly) FlutterBinaryMessageHandler handler;
72 @property(nonatomic, readonly) NSNumber* connection;
73
74 @end
75
76 @implementation FlutterEngineHandlerInfo
77 - (instancetype)initWithConnection:(NSNumber*)connection
78 handler:(FlutterBinaryMessageHandler)handler {
79 self = [super init];
80 NSAssert(self, @"Super init cannot be nil");
81 _connection = connection;
82 _handler = handler;
83 return self;
84 }
85 @end
86
87 #pragma mark -
88
89 /**
90 * Private interface declaration for FlutterEngine.
91 */
92 @interface FlutterEngine () <FlutterBinaryMessenger, FlutterMouseCursorPluginDelegate>
93
94 /**
95 * A mutable array that holds one bool value that determines if responses to platform messages are
96 * clear to execute. This value should be read or written only inside of a synchronized block and
97 * will return `NO` after the FlutterEngine has been dealloc'd.
98 */
99 @property(nonatomic, strong) NSMutableArray<NSNumber*>* isResponseValid;
100
101 /**
102 * All delegates added via plugin calls to addApplicationDelegate.
103 */
104 @property(nonatomic, strong) NSPointerArray* pluginAppDelegates;
105
106 /**
107 * All registrars returned from registrarForPlugin:
108 */
109 @property(nonatomic, readonly)
110 NSMutableDictionary<NSString*, FlutterEngineRegistrar*>* pluginRegistrars;
111
112 - (nullable FlutterViewController*)viewControllerForIdentifier:
113 (FlutterViewIdentifier)viewIdentifier;
114
115 /**
116 * An internal method that adds the view controller with the given ID.
117 *
118 * This method assigns the controller with the ID, puts the controller into the
119 * map, and does assertions related to the implicit view ID.
120 */
121 - (void)registerViewController:(FlutterViewController*)controller
122 forIdentifier:(FlutterViewIdentifier)viewIdentifier;
123
124 /**
125 * An internal method that removes the view controller with the given ID.
126 *
127 * This method clears the ID of the controller, removes the controller from the
128 * map. This is an no-op if the view ID is not associated with any view
129 * controllers.
130 */
131 - (void)deregisterViewControllerForIdentifier:(FlutterViewIdentifier)viewIdentifier;
132
133 /**
134 * Shuts down the engine if view requirement is not met, and headless execution
135 * is not allowed.
136 */
137 - (void)shutDownIfNeeded;
138
139 /**
140 * Sends the list of user-preferred locales to the Flutter engine.
141 */
142 - (void)sendUserLocales;
143
144 /**
145 * Handles a platform message from the engine.
146 */
147 - (void)engineCallbackOnPlatformMessage:(const FlutterPlatformMessage*)message;
148
149 /**
150 * Invoked right before the engine is restarted.
151 *
152 * This should reset states to as if the application has just started. It
153 * usually indicates a hot restart (Shift-R in Flutter CLI.)
154 */
155 - (void)engineCallbackOnPreEngineRestart;
156
157 /**
158 * Requests that the task be posted back the to the Flutter engine at the target time. The target
159 * time is in the clock used by the Flutter engine.
160 */
161 - (void)postMainThreadTask:(FlutterTask)task targetTimeInNanoseconds:(uint64_t)targetTime;
162
163 /**
164 * Loads the AOT snapshots and instructions from the elf bundle (app_elf_snapshot.so) into _aotData,
165 * if it is present in the assets directory.
166 */
167 - (void)loadAOTData:(NSString*)assetsDir;
168
169 /**
170 * Creates a platform view channel and sets up the method handler.
171 */
172 - (void)setUpPlatformViewChannel;
173
174 /**
175 * Creates an accessibility channel and sets up the message handler.
176 */
177 - (void)setUpAccessibilityChannel;
178
179 /**
180 * Handles messages received from the Flutter engine on the _*Channel channels.
181 */
182 - (void)handleMethodCall:(FlutterMethodCall*)call result:(FlutterResult)result;
183
184 @end
185
186 #pragma mark -
187
188 @implementation FlutterEngineTerminationHandler {
189 __weak FlutterEngine* _engine;
190 FlutterTerminationCallback _terminator;
191 }
192
193 - (instancetype)initWithEngine:(FlutterEngine*)engine
194 terminator:(FlutterTerminationCallback)terminator {
195 self = [super init];
196 _acceptingRequests = NO;
197 _engine = engine;
198 _terminator = terminator ? terminator : ^(id sender) {
199 // Default to actually terminating the application. The terminator exists to
200 // allow tests to override it so that an actual exit doesn't occur.
201 [[NSApplication sharedApplication] terminate:sender];
202 };
203 id<NSApplicationDelegate> appDelegate = [[NSApplication sharedApplication] delegate];
204 if ([appDelegate respondsToSelector:@selector(setTerminationHandler:)]) {
205 FlutterAppDelegate* flutterAppDelegate = reinterpret_cast<FlutterAppDelegate*>(appDelegate);
206 flutterAppDelegate.terminationHandler = self;
207 }
208 return self;
209 }
210
211 // This is called by the method call handler in the engine when the application
212 // requests termination itself.
213 - (void)handleRequestAppExitMethodCall:(NSDictionary<NSString*, id>*)arguments
214 result:(FlutterResult)result {
215 NSString* type = arguments[@"type"];
216 // Ignore the "exitCode" value in the arguments because AppKit doesn't have
217 // any good way to set the process exit code other than calling exit(), and
218 // that bypasses all of the native applicationShouldExit shutdown events,
219 // etc., which we don't want to skip.
220
221 FlutterAppExitType exitType =
222 [type isEqualTo:@"cancelable"] ? kFlutterAppExitTypeCancelable : kFlutterAppExitTypeRequired;
223
224 [self requestApplicationTermination:[NSApplication sharedApplication]
225 exitType:exitType
226 result:result];
227 }
228
229 // This is called by the FlutterAppDelegate whenever any termination request is
230 // received.
231 - (void)requestApplicationTermination:(id)sender
232 exitType:(FlutterAppExitType)type
233 result:(nullable FlutterResult)result {
234 _shouldTerminate = YES;
235 if (![self acceptingRequests]) {
236 // Until the Dart application has signaled that it is ready to handle
237 // termination requests, the app will just terminate when asked.
238 type = kFlutterAppExitTypeRequired;
239 }
240 switch (type) {
241 case kFlutterAppExitTypeCancelable: {
242 FlutterJSONMethodCodec* codec = [FlutterJSONMethodCodec sharedInstance];
243 FlutterMethodCall* methodCall =
244 [FlutterMethodCall methodCallWithMethodName:@"System.requestAppExit" arguments:nil];
245 [_engine sendOnChannel:kFlutterPlatformChannel
246 message:[codec encodeMethodCall:methodCall]
247 binaryReply:^(NSData* _Nullable reply) {
248 NSAssert(_terminator, @"terminator shouldn't be nil");
249 id decoded_reply = [codec decodeEnvelope:reply];
250 if ([decoded_reply isKindOfClass:[FlutterError class]]) {
251 FlutterError* error = (FlutterError*)decoded_reply;
252 NSLog(@"Method call returned error[%@]: %@ %@", [error code], [error message],
253 [error details]);
254 _terminator(sender);
255 return;
256 }
257 if (![decoded_reply isKindOfClass:[NSDictionary class]]) {
258 NSLog(@"Call to System.requestAppExit returned an unexpected object: %@",
259 decoded_reply);
260 _terminator(sender);
261 return;
262 }
263 NSDictionary* replyArgs = (NSDictionary*)decoded_reply;
264 if ([replyArgs[@"response"] isEqual:@"exit"]) {
265 _terminator(sender);
266 } else if ([replyArgs[@"response"] isEqual:@"cancel"]) {
267 _shouldTerminate = NO;
268 }
269 if (result != nil) {
270 result(replyArgs);
271 }
272 }];
273 break;
274 }
275 case kFlutterAppExitTypeRequired:
276 NSAssert(_terminator, @"terminator shouldn't be nil");
277 _terminator(sender);
278 break;
279 }
280 }
281
282 @end
283
284 #pragma mark -
285
286 @implementation FlutterPasteboard
287
288 - (NSInteger)clearContents {
289 return [[NSPasteboard generalPasteboard] clearContents];
290 }
291
292 - (NSString*)stringForType:(NSPasteboardType)dataType {
293 return [[NSPasteboard generalPasteboard] stringForType:dataType];
294 }
295
296 - (BOOL)setString:(nonnull NSString*)string forType:(nonnull NSPasteboardType)dataType {
297 return [[NSPasteboard generalPasteboard] setString:string forType:dataType];
298 }
299
300 @end
301
302 #pragma mark -
303
304 /**
305 * `FlutterPluginRegistrar` implementation handling a single plugin.
306 */
307 @interface FlutterEngineRegistrar : NSObject <FlutterPluginRegistrar>
308 - (instancetype)initWithPlugin:(nonnull NSString*)pluginKey
309 flutterEngine:(nonnull FlutterEngine*)flutterEngine;
310
311 - (nullable NSView*)viewForIdentifier:(FlutterViewIdentifier)viewIdentifier;
312
313 /**
314 * The value published by this plugin, or NSNull if nothing has been published.
315 *
316 * The unusual NSNull is for the documented behavior of valuePublishedByPlugin:.
317 */
318 @property(nonatomic, readonly, nonnull) NSObject* publishedValue;
319 @end
320
321 @implementation FlutterEngineRegistrar {
322 NSString* _pluginKey;
323 __weak FlutterEngine* _flutterEngine;
324 }
325
326 @dynamic view;
327
328 - (instancetype)initWithPlugin:(NSString*)pluginKey flutterEngine:(FlutterEngine*)flutterEngine {
329 self = [super init];
330 if (self) {
331 _pluginKey = [pluginKey copy];
332 _flutterEngine = flutterEngine;
333 _publishedValue = [NSNull null];
334 }
335 return self;
336 }
337
338 #pragma mark - FlutterPluginRegistrar
339
340 - (id<FlutterBinaryMessenger>)messenger {
341 return _flutterEngine.binaryMessenger;
342 }
343
344 - (id<FlutterTextureRegistry>)textures {
345 return _flutterEngine.renderer;
346 }
347
348 - (NSView*)view {
349 return [self viewForIdentifier:kFlutterImplicitViewId];
350 }
351
352 - (NSView*)viewForIdentifier:(FlutterViewIdentifier)viewIdentifier {
353 FlutterViewController* controller = [_flutterEngine viewControllerForIdentifier:viewIdentifier];
354 if (controller == nil) {
355 return nil;
356 }
357 if (!controller.viewLoaded) {
358 [controller loadView];
359 }
360 return controller.flutterView;
361 }
362
363 - (void)addMethodCallDelegate:(nonnull id<FlutterPlugin>)delegate
364 channel:(nonnull FlutterMethodChannel*)channel {
365 [channel setMethodCallHandler:^(FlutterMethodCall* call, FlutterResult result) {
366 [delegate handleMethodCall:call result:result];
367 }];
368 }
369
370 - (void)addApplicationDelegate:(NSObject<FlutterAppLifecycleDelegate>*)delegate {
371 id<NSApplicationDelegate> appDelegate = [[NSApplication sharedApplication] delegate];
372 if ([appDelegate conformsToProtocol:@protocol(FlutterAppLifecycleProvider)]) {
373 id<FlutterAppLifecycleProvider> lifeCycleProvider =
374 static_cast<id<FlutterAppLifecycleProvider>>(appDelegate);
375 [lifeCycleProvider addApplicationLifecycleDelegate:delegate];
376 [_flutterEngine.pluginAppDelegates addPointer:(__bridge void*)delegate];
377 }
378 }
379
380 - (void)registerViewFactory:(nonnull NSObject<FlutterPlatformViewFactory>*)factory
381 withId:(nonnull NSString*)factoryId {
382 [[_flutterEngine platformViewController] registerViewFactory:factory withId:factoryId];
383 }
384
385 - (void)publish:(NSObject*)value {
386 _publishedValue = value;
387 }
388
389 - (NSString*)lookupKeyForAsset:(NSString*)asset {
390 return [FlutterDartProject lookupKeyForAsset:asset];
391 }
392
393 - (NSString*)lookupKeyForAsset:(NSString*)asset fromPackage:(NSString*)package {
394 return [FlutterDartProject lookupKeyForAsset:asset fromPackage:package];
395 }
396
397 @end
398
399 // Callbacks provided to the engine. See the called methods for documentation.
400 #pragma mark - Static methods provided to engine configuration
401
402 static void OnPlatformMessage(const FlutterPlatformMessage* message, void* user_data) {
403 FlutterEngine* engine = (__bridge FlutterEngine*)user_data;
404 [engine engineCallbackOnPlatformMessage:message];
405 }
406
407 #pragma mark -
408
409 @implementation FlutterEngine {
410 // The embedding-API-level engine object.
411 FLUTTER_API_SYMBOL(FlutterEngine) _engine;
412
413 // The project being run by this engine.
414 FlutterDartProject* _project;
415
416 // A mapping of channel names to the registered information for those channels.
417 NSMutableDictionary<NSString*, FlutterEngineHandlerInfo*>* _messengerHandlers;
418
419 // A self-incremental integer to assign to newly assigned channels as
420 // identification.
421 FlutterBinaryMessengerConnection _currentMessengerConnection;
422
423 // Whether the engine can continue running after the view controller is removed.
424 BOOL _allowHeadlessExecution;
425
426 // Pointer to the Dart AOT snapshot and instruction data.
427 _FlutterEngineAOTData* _aotData;
428
429 // _macOSCompositor is created when the engine is created and its destruction is handled by ARC
430 // when the engine is destroyed.
431 std::unique_ptr<flutter::FlutterCompositor> _macOSCompositor;
432
433 // The information of all views attached to this engine mapped from IDs.
434 //
435 // It can't use NSDictionary, because the values need to be weak references.
436 NSMapTable* _viewControllers;
437
438 // FlutterCompositor is copied and used in embedder.cc.
439 FlutterCompositor _compositor;
440
441 // Method channel for platform view functions. These functions include creating, disposing and
442 // mutating a platform view.
443 FlutterMethodChannel* _platformViewsChannel;
444
445 // Used to support creation and deletion of platform views and registering platform view
446 // factories. Lifecycle is tied to the engine.
447 FlutterPlatformViewController* _platformViewController;
448
449 // A message channel for sending user settings to the flutter engine.
450 FlutterBasicMessageChannel* _settingsChannel;
451
452 // A message channel for accessibility.
453 FlutterBasicMessageChannel* _accessibilityChannel;
454
455 // A method channel for miscellaneous platform functionality.
456 FlutterMethodChannel* _platformChannel;
457
458 FlutterThreadSynchronizer* _threadSynchronizer;
459
460 // Whether the application is currently the active application.
461 BOOL _active;
462
463 // Whether any portion of the application is currently visible.
464 BOOL _visible;
465
466 // Proxy to allow plugins, channels to hold a weak reference to the binary messenger (self).
467 FlutterBinaryMessengerRelay* _binaryMessenger;
468
469 // Map from ViewId to vsync waiter. Note that this is modified on main thread
470 // but accessed on UI thread, so access must be @synchronized.
471 NSMapTable<NSNumber*, FlutterVSyncWaiter*>* _vsyncWaiters;
472
473 // Weak reference to last view that received a pointer event. This is used to
474 // pair cursor change with a view.
475 __weak FlutterView* _lastViewWithPointerEvent;
476 }
477
478 - (instancetype)initWithName:(NSString*)labelPrefix project:(FlutterDartProject*)project {
479 return [self initWithName:labelPrefix project:project allowHeadlessExecution:YES];
480 }
481
482 static const int kMainThreadPriority = 47;
483
484 static void SetThreadPriority(FlutterThreadPriority priority) {
485 if (priority == kDisplay || priority == kRaster) {
486 pthread_t thread = pthread_self();
487 sched_param param;
488 int policy;
489 if (!pthread_getschedparam(thread, &policy, &param)) {
490 param.sched_priority = kMainThreadPriority;
491 pthread_setschedparam(thread, policy, &param);
492 }
493 pthread_set_qos_class_self_np(QOS_CLASS_USER_INTERACTIVE, 0);
494 }
495 }
496
497 - (instancetype)initWithName:(NSString*)labelPrefix
498 project:(FlutterDartProject*)project
499 allowHeadlessExecution:(BOOL)allowHeadlessExecution {
500 self = [super init];
501 NSAssert(self, @"Super init cannot be nil");
502 _pasteboard = [[FlutterPasteboard alloc] init];
503 _active = NO;
504 _visible = NO;
505 _project = project ?: [[FlutterDartProject alloc] init];
506 _messengerHandlers = [[NSMutableDictionary alloc] init];
507 _binaryMessenger = [[FlutterBinaryMessengerRelay alloc] initWithParent:self];
508 _pluginAppDelegates = [NSPointerArray weakObjectsPointerArray];
509 _pluginRegistrars = [[NSMutableDictionary alloc] init];
510 _currentMessengerConnection = 1;
511 _allowHeadlessExecution = allowHeadlessExecution;
512 _semanticsEnabled = NO;
513 _binaryMessenger = [[FlutterBinaryMessengerRelay alloc] initWithParent:self];
514 _isResponseValid = [[NSMutableArray alloc] initWithCapacity:1];
515 [_isResponseValid addObject:@YES];
516
517 _embedderAPI.struct_size = sizeof(FlutterEngineProcTable);
518 FlutterEngineGetProcAddresses(&_embedderAPI);
519
520 _viewControllers = [NSMapTable weakToWeakObjectsMapTable];
521 _renderer = [[FlutterRenderer alloc] initWithFlutterEngine:self];
522
523 NSNotificationCenter* notificationCenter = [NSNotificationCenter defaultCenter];
524 [notificationCenter addObserver:self
525 selector:@selector(sendUserLocales)
526 name:NSCurrentLocaleDidChangeNotification
527 object:nil];
528
529 _platformViewController = [[FlutterPlatformViewController alloc] init];
530 _threadSynchronizer = [[FlutterThreadSynchronizer alloc] init];
531 // The macOS compositor must be initialized in the initializer because it is
532 // used when adding views, which might happen before runWithEntrypoint.
533 _macOSCompositor = std::make_unique<flutter::FlutterCompositor>(
534 [[FlutterViewEngineProvider alloc] initWithEngine:self],
535 [[FlutterTimeConverter alloc] initWithEngine:self], _platformViewController);
536
537 [self setUpPlatformViewChannel];
538 [self setUpAccessibilityChannel];
539 [self setUpNotificationCenterListeners];
540 id<NSApplicationDelegate> appDelegate = [[NSApplication sharedApplication] delegate];
541 if ([appDelegate conformsToProtocol:@protocol(FlutterAppLifecycleProvider)]) {
542 _terminationHandler = [[FlutterEngineTerminationHandler alloc] initWithEngine:self
543 terminator:nil];
544 id<FlutterAppLifecycleProvider> lifecycleProvider =
545 static_cast<id<FlutterAppLifecycleProvider>>(appDelegate);
546 [lifecycleProvider addApplicationLifecycleDelegate:self];
547 } else {
548 _terminationHandler = nil;
549 }
550
551 _vsyncWaiters = [NSMapTable strongToStrongObjectsMapTable];
552
553 return self;
554 }
555
556 - (void)dealloc {
557 id<NSApplicationDelegate> appDelegate = [[NSApplication sharedApplication] delegate];
558 if ([appDelegate conformsToProtocol:@protocol(FlutterAppLifecycleProvider)]) {
559 id<FlutterAppLifecycleProvider> lifecycleProvider =
560 static_cast<id<FlutterAppLifecycleProvider>>(appDelegate);
561 [lifecycleProvider removeApplicationLifecycleDelegate:self];
562
563 // Unregister any plugins that registered as app delegates, since they are not guaranteed to
564 // live after the engine is destroyed, and their delegation registration is intended to be bound
565 // to the engine and its lifetime.
566 for (id<FlutterAppLifecycleDelegate> delegate in _pluginAppDelegates) {
567 if (delegate) {
568 [lifecycleProvider removeApplicationLifecycleDelegate:delegate];
569 }
570 }
571 }
572 // Clear any published values, just in case a plugin has created a retain cycle with the
573 // registrar.
574 for (NSString* pluginName in _pluginRegistrars) {
575 [_pluginRegistrars[pluginName] publish:[NSNull null]];
576 }
577 @synchronized(_isResponseValid) {
578 [_isResponseValid removeAllObjects];
579 [_isResponseValid addObject:@NO];
580 }
581 [self shutDownEngine];
582 if (_aotData) {
583 _embedderAPI.CollectAOTData(_aotData);
584 }
585 }
586
587 - (BOOL)runWithEntrypoint:(NSString*)entrypoint {
588 if (self.running) {
589 return NO;
590 }
591
592 if (!_allowHeadlessExecution && [_viewControllers count] == 0) {
593 NSLog(@"Attempted to run an engine with no view controller without headless mode enabled.");
594 return NO;
595 }
596
597 [self addInternalPlugins];
598
599 // The first argument of argv is required to be the executable name.
600 std::vector<const char*> argv = {[self.executableName UTF8String]};
601 std::vector<std::string> switches = self.switches;
602
603 // Enable Impeller only if specifically asked for from the project or cmdline arguments.
604 if (_project.enableImpeller ||
605 std::find(switches.begin(), switches.end(), "--enable-impeller=true") != switches.end()) {
606 switches.push_back("--enable-impeller=true");
607 }
608
609 std::transform(switches.begin(), switches.end(), std::back_inserter(argv),
610 [](const std::string& arg) -> const char* { return arg.c_str(); });
611
612 std::vector<const char*> dartEntrypointArgs;
613 for (NSString* argument in [_project dartEntrypointArguments]) {
614 dartEntrypointArgs.push_back([argument UTF8String]);
615 }
616
617 FlutterProjectArgs flutterArguments = {};
618 flutterArguments.struct_size = sizeof(FlutterProjectArgs);
619 flutterArguments.assets_path = _project.assetsPath.UTF8String;
620 flutterArguments.icu_data_path = _project.ICUDataPath.UTF8String;
621 flutterArguments.command_line_argc = static_cast<int>(argv.size());
622 flutterArguments.command_line_argv = argv.empty() ? nullptr : argv.data();
623 flutterArguments.platform_message_callback = (FlutterPlatformMessageCallback)OnPlatformMessage;
624 flutterArguments.update_semantics_callback2 = [](const FlutterSemanticsUpdate2* update,
625 void* user_data) {
626 // TODO(dkwingsmt): This callback only supports single-view, therefore it
627 // only operates on the implicit view. To support multi-view, we need a
628 // way to pass in the ID (probably through FlutterSemanticsUpdate).
629 FlutterEngine* engine = (__bridge FlutterEngine*)user_data;
630 [[engine viewControllerForIdentifier:kFlutterImplicitViewId] updateSemantics:update];
631 };
632 flutterArguments.custom_dart_entrypoint = entrypoint.UTF8String;
633 flutterArguments.shutdown_dart_vm_when_done = true;
634 flutterArguments.dart_entrypoint_argc = dartEntrypointArgs.size();
635 flutterArguments.dart_entrypoint_argv = dartEntrypointArgs.data();
636 flutterArguments.root_isolate_create_callback = _project.rootIsolateCreateCallback;
637 flutterArguments.log_message_callback = [](const char* tag, const char* message,
638 void* user_data) {
639 if (tag && tag[0]) {
640 std::cout << tag << ": ";
641 }
642 std::cout << message << std::endl;
643 };
644
645 static size_t sTaskRunnerIdentifiers = 0;
646 const FlutterTaskRunnerDescription cocoa_task_runner_description = {
647 .struct_size = sizeof(FlutterTaskRunnerDescription),
648 .user_data = (void*)CFBridgingRetain(self),
649 .runs_task_on_current_thread_callback = [](void* user_data) -> bool {
650 return [[NSThread currentThread] isMainThread];
651 },
652 .post_task_callback = [](FlutterTask task, uint64_t target_time_nanos,
653 void* user_data) -> void {
654 [((__bridge FlutterEngine*)(user_data)) postMainThreadTask:task
655 targetTimeInNanoseconds:target_time_nanos];
656 },
657 .identifier = ++sTaskRunnerIdentifiers,
658 };
659 const FlutterCustomTaskRunners custom_task_runners = {
660 .struct_size = sizeof(FlutterCustomTaskRunners),
661 .platform_task_runner = &cocoa_task_runner_description,
662 .thread_priority_setter = SetThreadPriority};
663 flutterArguments.custom_task_runners = &custom_task_runners;
664
665 [self loadAOTData:_project.assetsPath];
666 if (_aotData) {
667 flutterArguments.aot_data = _aotData;
668 }
669
670 flutterArguments.compositor = [self createFlutterCompositor];
671
672 flutterArguments.on_pre_engine_restart_callback = [](void* user_data) {
673 FlutterEngine* engine = (__bridge FlutterEngine*)user_data;
674 [engine engineCallbackOnPreEngineRestart];
675 };
676
677 flutterArguments.vsync_callback = [](void* user_data, intptr_t baton) {
678 FlutterEngine* engine = (__bridge FlutterEngine*)user_data;
679 [engine onVSync:baton];
680 };
681
682 FlutterRendererConfig rendererConfig = [_renderer createRendererConfig];
683 FlutterEngineResult result = _embedderAPI.Initialize(
684 FLUTTER_ENGINE_VERSION, &rendererConfig, &flutterArguments, (__bridge void*)(self), &_engine);
685 if (result != kSuccess) {
686 NSLog(@"Failed to initialize Flutter engine: error %d", result);
687 return NO;
688 }
689
690 result = _embedderAPI.RunInitialized(_engine);
691 if (result != kSuccess) {
692 NSLog(@"Failed to run an initialized engine: error %d", result);
693 return NO;
694 }
695
696 [self sendUserLocales];
697
698 // Update window metric for all view controllers.
699 NSEnumerator* viewControllerEnumerator = [_viewControllers objectEnumerator];
700 FlutterViewController* nextViewController;
701 while ((nextViewController = [viewControllerEnumerator nextObject])) {
702 [self updateWindowMetricsForViewController:nextViewController];
703 }
704
705 [self updateDisplayConfig];
706 // Send the initial user settings such as brightness and text scale factor
707 // to the engine.
708 [self sendInitialSettings];
709 return YES;
710 }
711
712 - (void)loadAOTData:(NSString*)assetsDir {
713 if (!_embedderAPI.RunsAOTCompiledDartCode()) {
714 return;
715 }
716
717 BOOL isDirOut = false; // required for NSFileManager fileExistsAtPath.
718 NSFileManager* fileManager = [NSFileManager defaultManager];
719
720 // This is the location where the test fixture places the snapshot file.
721 // For applications built by Flutter tool, this is in "App.framework".
722 NSString* elfPath = [NSString pathWithComponents:@[ assetsDir, @"app_elf_snapshot.so" ]];
723
724 if (![fileManager fileExistsAtPath:elfPath isDirectory:&isDirOut]) {
725 return;
726 }
727
728 FlutterEngineAOTDataSource source = {};
729 source.type = kFlutterEngineAOTDataSourceTypeElfPath;
730 source.elf_path = [elfPath cStringUsingEncoding:NSUTF8StringEncoding];
731
732 auto result = _embedderAPI.CreateAOTData(&source, &_aotData);
733 if (result != kSuccess) {
734 NSLog(@"Failed to load AOT data from: %@", elfPath);
735 }
736 }
737
738 - (void)registerViewController:(FlutterViewController*)controller
739 forIdentifier:(FlutterViewIdentifier)viewIdentifier {
740 _macOSCompositor->AddView(viewIdentifier);
741 NSAssert(controller != nil, @"The controller must not be nil.");
742 NSAssert(controller.engine == nil,
743 @"The FlutterViewController is unexpectedly attached to "
744 @"engine %@ before initialization.",
745 controller.engine);
746 NSAssert([_viewControllers objectForKey:@(viewIdentifier)] == nil,
747 @"The requested view ID is occupied.");
748 [_viewControllers setObject:controller forKey:@(viewIdentifier)];
749 [controller setUpWithEngine:self
750 viewIdentifier:viewIdentifier
751 threadSynchronizer:_threadSynchronizer];
752 NSAssert(controller.viewIdentifier == viewIdentifier, @"Failed to assign view ID.");
753 // Verify that the controller's property are updated accordingly. Failing the
754 // assertions is likely because either the FlutterViewController or the
755 // FlutterEngine is mocked. Please subclass these classes instead.
756 NSAssert(controller.attached, @"The FlutterViewController should switch to the attached mode "
757 @"after it is added to a FlutterEngine.");
758 NSAssert(controller.engine == self,
759 @"The FlutterViewController was added to %@, but its engine unexpectedly became %@.",
760 self, controller.engine);
761
762 if (controller.viewLoaded) {
763 [self viewControllerViewDidLoad:controller];
764 }
765 }
766
767 - (void)viewControllerViewDidLoad:(FlutterViewController*)viewController {
768 __weak FlutterEngine* weakSelf = self;
769 FlutterTimeConverter* timeConverter = [[FlutterTimeConverter alloc] initWithEngine:self];
770 FlutterVSyncWaiter* waiter = [[FlutterVSyncWaiter alloc]
771 initWithDisplayLink:[FlutterDisplayLink displayLinkWithView:viewController.view]
772 block:^(CFTimeInterval timestamp, CFTimeInterval targetTimestamp,
773 uintptr_t baton) {
774 uint64_t timeNanos = [timeConverter CAMediaTimeToEngineTime:timestamp];
775 uint64_t targetTimeNanos =
776 [timeConverter CAMediaTimeToEngineTime:targetTimestamp];
777 FlutterEngine* engine = weakSelf;
778 if (engine) {
779 // It is a bit unfortunate that embedder requires OnVSync call on
780 // platform thread just to immediately redispatch it to UI thread.
781 // We are already on UI thread right now, but have to do the
782 // extra hop to main thread.
783 [engine->_threadSynchronizer performOnPlatformThread:^{
784 engine->_embedderAPI.OnVsync(_engine, baton, timeNanos, targetTimeNanos);
785 }];
786 }
787 }];
788 FML_DCHECK([_vsyncWaiters objectForKey:@(viewController.viewIdentifier)] == nil);
789 @synchronized(_vsyncWaiters) {
790 [_vsyncWaiters setObject:waiter forKey:@(viewController.viewIdentifier)];
791 }
792 }
793
794 - (void)deregisterViewControllerForIdentifier:(FlutterViewIdentifier)viewIdentifier {
795 _macOSCompositor->RemoveView(viewIdentifier);
796 FlutterViewController* controller = [self viewControllerForIdentifier:viewIdentifier];
797 // The controller can be nil. The engine stores only a weak ref, and this
798 // method could have been called from the controller's dealloc.
799 if (controller != nil) {
800 [controller detachFromEngine];
801 NSAssert(!controller.attached,
802 @"The FlutterViewController unexpectedly stays attached after being removed. "
803 @"In unit tests, this is likely because either the FlutterViewController or "
804 @"the FlutterEngine is mocked. Please subclass these classes instead.");
805 }
806 [_viewControllers removeObjectForKey:@(viewIdentifier)];
807 @synchronized(_vsyncWaiters) {
808 [_vsyncWaiters removeObjectForKey:@(viewIdentifier)];
809 }
810 }
811
812 - (void)shutDownIfNeeded {
813 if ([_viewControllers count] == 0 && !_allowHeadlessExecution) {
814 [self shutDownEngine];
815 }
816 }
817
818 - (FlutterViewController*)viewControllerForIdentifier:(FlutterViewIdentifier)viewIdentifier {
819 FlutterViewController* controller = [_viewControllers objectForKey:@(viewIdentifier)];
820 NSAssert(controller == nil || controller.viewIdentifier == viewIdentifier,
821 @"The stored controller has unexpected view ID.");
822 return controller;
823 }
824
825 - (void)setViewController:(FlutterViewController*)controller {
826 FlutterViewController* currentController =
827 [_viewControllers objectForKey:@(kFlutterImplicitViewId)];
828 if (currentController == controller) {
829 // From nil to nil, or from non-nil to the same controller.
830 return;
831 }
832 if (currentController == nil && controller != nil) {
833 // From nil to non-nil.
834 NSAssert(controller.engine == nil,
835 @"Failed to set view controller to the engine: "
836 @"The given FlutterViewController is already attached to an engine %@. "
837 @"If you wanted to create an FlutterViewController and set it to an existing engine, "
838 @"you should use FlutterViewController#init(engine:, nibName, bundle:) instead.",
839 controller.engine);
840 [self registerViewController:controller forIdentifier:kFlutterImplicitViewId];
841 } else if (currentController != nil && controller == nil) {
842 NSAssert(currentController.viewIdentifier == kFlutterImplicitViewId,
843 @"The default controller has an unexpected ID %llu", currentController.viewIdentifier);
844 // From non-nil to nil.
845 [self deregisterViewControllerForIdentifier:kFlutterImplicitViewId];
846 [self shutDownIfNeeded];
847 } else {
848 // From non-nil to a different non-nil view controller.
849 NSAssert(NO,
850 @"Failed to set view controller to the engine: "
851 @"The engine already has an implicit view controller %@. "
852 @"If you wanted to make the implicit view render in a different window, "
853 @"you should attach the current view controller to the window instead.",
854 [_viewControllers objectForKey:@(kFlutterImplicitViewId)]);
855 }
856 }
857
858 - (FlutterViewController*)viewController {
859 return [self viewControllerForIdentifier:kFlutterImplicitViewId];
860 }
861
862 - (FlutterCompositor*)createFlutterCompositor {
863 _compositor = {};
864 _compositor.struct_size = sizeof(FlutterCompositor);
865 _compositor.user_data = _macOSCompositor.get();
866
867 _compositor.create_backing_store_callback = [](const FlutterBackingStoreConfig* config, //
868 FlutterBackingStore* backing_store_out, //
869 void* user_data //
870 ) {
871 return reinterpret_cast<flutter::FlutterCompositor*>(user_data)->CreateBackingStore(
872 config, backing_store_out);
873 };
874
875 _compositor.collect_backing_store_callback = [](const FlutterBackingStore* backing_store, //
876 void* user_data //
877 ) { return true; };
878
879 _compositor.present_view_callback = [](const FlutterPresentViewInfo* info) {
880 return reinterpret_cast<flutter::FlutterCompositor*>(info->user_data)
881 ->Present(info->view_id, info->layers, info->layers_count);
882 };
883
884 _compositor.avoid_backing_store_cache = true;
885
886 return &_compositor;
887 }
888
889 - (id<FlutterBinaryMessenger>)binaryMessenger {
890 return _binaryMessenger;
891 }
892
893 #pragma mark - Framework-internal methods
894
895 - (void)addViewController:(FlutterViewController*)controller {
896 // FlutterEngine can only handle the implicit view for now. Adding more views
897 // throws an assertion.
898 NSAssert(self.viewController == nil,
899 @"The engine already has a view controller for the implicit view.");
900 self.viewController = controller;
901 }
902
903 - (void)removeViewController:(nonnull FlutterViewController*)viewController {
904 [self deregisterViewControllerForIdentifier:viewController.viewIdentifier];
905 [self shutDownIfNeeded];
906 }
907
908 - (BOOL)running {
909 return _engine != nullptr;
910 }
911
912 - (void)updateDisplayConfig:(NSNotification*)notification {
913 [self updateDisplayConfig];
914 }
915
916 - (NSArray<NSScreen*>*)screens {
917 return [NSScreen screens];
918 }
919
920 - (void)updateDisplayConfig {
921 if (!_engine) {
922 return;
923 }
924
925 std::vector<FlutterEngineDisplay> displays;
926 for (NSScreen* screen : [self screens]) {
927 CGDirectDisplayID displayID =
928 static_cast<CGDirectDisplayID>([screen.deviceDescription[@"NSScreenNumber"] integerValue]);
929
930 double devicePixelRatio = screen.backingScaleFactor;
931 FlutterEngineDisplay display;
932 display.struct_size = sizeof(display);
933 display.display_id = displayID;
934 display.single_display = false;
935 display.width = static_cast<size_t>(screen.frame.size.width) * devicePixelRatio;
936 display.height = static_cast<size_t>(screen.frame.size.height) * devicePixelRatio;
937 display.device_pixel_ratio = devicePixelRatio;
938
939 CVDisplayLinkRef displayLinkRef = nil;
940 CVReturn error = CVDisplayLinkCreateWithCGDisplay(displayID, &displayLinkRef);
941
942 if (error == 0) {
943 CVTime nominal = CVDisplayLinkGetNominalOutputVideoRefreshPeriod(displayLinkRef);
944 if (!(nominal.flags & kCVTimeIsIndefinite)) {
945 double refreshRate = static_cast<double>(nominal.timeScale) / nominal.timeValue;
946 display.refresh_rate = round(refreshRate);
947 }
948 CVDisplayLinkRelease(displayLinkRef);
949 } else {
950 display.refresh_rate = 0;
951 }
952
953 displays.push_back(display);
954 }
955 _embedderAPI.NotifyDisplayUpdate(_engine, kFlutterEngineDisplaysUpdateTypeStartup,
956 displays.data(), displays.size());
957 }
958
959 - (void)onSettingsChanged:(NSNotification*)notification {
960 // TODO(jonahwilliams): https://github.com/flutter/flutter/issues/32015.
961 NSString* brightness =
962 [[NSUserDefaults standardUserDefaults] stringForKey:@"AppleInterfaceStyle"];
963 [_settingsChannel sendMessage:@{
964 @"platformBrightness" : [brightness isEqualToString:@"Dark"] ? @"dark" : @"light",
965 // TODO(jonahwilliams): https://github.com/flutter/flutter/issues/32006.
966 @"textScaleFactor" : @1.0,
967 @"alwaysUse24HourFormat" : @([FlutterHourFormat isAlwaysUse24HourFormat]),
968 }];
969 }
970
971 - (void)sendInitialSettings {
972 // TODO(jonahwilliams): https://github.com/flutter/flutter/issues/32015.
973 [[NSDistributedNotificationCenter defaultCenter]
974 addObserver:self
975 selector:@selector(onSettingsChanged:)
976 name:@"AppleInterfaceThemeChangedNotification"
977 object:nil];
978 [self onSettingsChanged:nil];
979 }
980
981 - (FlutterEngineProcTable&)embedderAPI {
982 return _embedderAPI;
983 }
984
985 - (nonnull NSString*)executableName {
986 return [[[NSProcessInfo processInfo] arguments] firstObject] ?: @"Flutter";
987 }
988
989 - (void)updateWindowMetricsForViewController:(FlutterViewController*)viewController {
990 if (!_engine || !viewController || !viewController.viewLoaded) {
991 return;
992 }
993 NSAssert([self viewControllerForIdentifier:viewController.viewIdentifier] == viewController,
994 @"The provided view controller is not attached to this engine.");
995 NSView* view = viewController.flutterView;
996 CGRect scaledBounds = [view convertRectToBacking:view.bounds];
997 CGSize scaledSize = scaledBounds.size;
998 double pixelRatio = view.bounds.size.width == 0 ? 1 : scaledSize.width / view.bounds.size.width;
999 auto displayId = [view.window.screen.deviceDescription[@"NSScreenNumber"] integerValue];
1000 const FlutterWindowMetricsEvent windowMetricsEvent = {
1001 .struct_size = sizeof(windowMetricsEvent),
1002 .width = static_cast<size_t>(scaledSize.width),
1003 .height = static_cast<size_t>(scaledSize.height),
1004 .pixel_ratio = pixelRatio,
1005 .left = static_cast<size_t>(scaledBounds.origin.x),
1006 .top = static_cast<size_t>(scaledBounds.origin.y),
1007 .display_id = static_cast<uint64_t>(displayId),
1008 .view_id = viewController.viewIdentifier,
1009 };
1010 _embedderAPI.SendWindowMetricsEvent(_engine, &windowMetricsEvent);
1011 }
1012
1013 - (void)sendPointerEvent:(const FlutterPointerEvent&)event {
1014 _embedderAPI.SendPointerEvent(_engine, &event, 1);
1015 _lastViewWithPointerEvent = [self viewControllerForIdentifier:kFlutterImplicitViewId].flutterView;
1016 }
1017
1018 - (void)sendKeyEvent:(const FlutterKeyEvent&)event
1019 callback:(FlutterKeyEventCallback)callback
1020 userData:(void*)userData {
1021 _embedderAPI.SendKeyEvent(_engine, &event, callback, userData);
1022 }
1023
1024 - (void)setSemanticsEnabled:(BOOL)enabled {
1025 if (_semanticsEnabled == enabled) {
1026 return;
1027 }
1028 _semanticsEnabled = enabled;
1029
1030 // Update all view controllers' bridges.
1031 NSEnumerator* viewControllerEnumerator = [_viewControllers objectEnumerator];
1032 FlutterViewController* nextViewController;
1033 while ((nextViewController = [viewControllerEnumerator nextObject])) {
1034 [nextViewController notifySemanticsEnabledChanged];
1035 }
1036
1037 _embedderAPI.UpdateSemanticsEnabled(_engine, _semanticsEnabled);
1038 }
1039
1040 - (void)dispatchSemanticsAction:(FlutterSemanticsAction)action
1041 toTarget:(uint16_t)target
1042 withData:(fml::MallocMapping)data {
1043 _embedderAPI.DispatchSemanticsAction(_engine, target, action, data.GetMapping(), data.GetSize());
1044 }
1045
1046 - (FlutterPlatformViewController*)platformViewController {
1047 return _platformViewController;
1048 }
1049
1050 #pragma mark - Private methods
1051
1052 - (void)sendUserLocales {
1053 if (!self.running) {
1054 return;
1055 }
1056
1057 // Create a list of FlutterLocales corresponding to the preferred languages.
1058 NSMutableArray<NSLocale*>* locales = [NSMutableArray array];
1059 std::vector<FlutterLocale> flutterLocales;
1060 flutterLocales.reserve(locales.count);
1061 for (NSString* localeID in [NSLocale preferredLanguages]) {
1062 NSLocale* locale = [[NSLocale alloc] initWithLocaleIdentifier:localeID];
1063 [locales addObject:locale];
1064 flutterLocales.push_back(FlutterLocaleFromNSLocale(locale));
1065 }
1066 // Convert to a list of pointers, and send to the engine.
1067 std::vector<const FlutterLocale*> flutterLocaleList;
1068 flutterLocaleList.reserve(flutterLocales.size());
1069 std::transform(flutterLocales.begin(), flutterLocales.end(),
1070 std::back_inserter(flutterLocaleList),
1071 [](const auto& arg) -> const auto* { return &arg; });
1072 _embedderAPI.UpdateLocales(_engine, flutterLocaleList.data(), flutterLocaleList.size());
1073 }
1074
1075 - (void)engineCallbackOnPlatformMessage:(const FlutterPlatformMessage*)message {
1076 NSData* messageData = nil;
1077 if (message->message_size > 0) {
1078 messageData = [NSData dataWithBytesNoCopy:(void*)message->message
1079 length:message->message_size
1080 freeWhenDone:NO];
1081 }
1082 NSString* channel = @(message->channel);
1083 __block const FlutterPlatformMessageResponseHandle* responseHandle = message->response_handle;
1084 __block FlutterEngine* weakSelf = self;
1085 NSMutableArray* isResponseValid = self.isResponseValid;
1086 FlutterEngineSendPlatformMessageResponseFnPtr sendPlatformMessageResponse =
1087 _embedderAPI.SendPlatformMessageResponse;
1088 FlutterBinaryReply binaryResponseHandler = ^(NSData* response) {
1089 @synchronized(isResponseValid) {
1090 if (![isResponseValid[0] boolValue]) {
1091 // Ignore, engine was killed.
1092 return;
1093 }
1094 if (responseHandle) {
1095 sendPlatformMessageResponse(weakSelf->_engine, responseHandle,
1096 static_cast<const uint8_t*>(response.bytes), response.length);
1097 responseHandle = NULL;
1098 } else {
1099 NSLog(@"Error: Message responses can be sent only once. Ignoring duplicate response "
1100 "on channel '%@'.",
1101 channel);
1102 }
1103 }
1104 };
1105
1106 FlutterEngineHandlerInfo* handlerInfo = _messengerHandlers[channel];
1107 if (handlerInfo) {
1108 handlerInfo.handler(messageData, binaryResponseHandler);
1109 } else {
1110 binaryResponseHandler(nil);
1111 }
1112 }
1113
1114 - (void)engineCallbackOnPreEngineRestart {
1115 NSEnumerator* viewControllerEnumerator = [_viewControllers objectEnumerator];
1116 FlutterViewController* nextViewController;
1117 while ((nextViewController = [viewControllerEnumerator nextObject])) {
1118 [nextViewController onPreEngineRestart];
1119 }
1120 }
1121
1122 - (void)onVSync:(uintptr_t)baton {
1123 @synchronized(_vsyncWaiters) {
1124 // TODO(knopp): Use vsync waiter for correct view.
1125 // https://github.com/flutter/flutter/issues/142845
1126 FlutterVSyncWaiter* waiter = [_vsyncWaiters objectForKey:@(kFlutterImplicitViewId)];
1127 [waiter waitForVSync:baton];
1128 }
1129 }
1130
1131 /**
1132 * Note: Called from dealloc. Should not use accessors or other methods.
1133 */
1134 - (void)shutDownEngine {
1135 if (_engine == nullptr) {
1136 return;
1137 }
1138
1139 [_threadSynchronizer shutdown];
1140 _threadSynchronizer = nil;
1141
1142 FlutterEngineResult result = _embedderAPI.Deinitialize(_engine);
1143 if (result != kSuccess) {
1144 NSLog(@"Could not de-initialize the Flutter engine: error %d", result);
1145 }
1146
1147 // Balancing release for the retain in the task runner dispatch table.
1148 CFRelease((CFTypeRef)self);
1149
1150 result = _embedderAPI.Shutdown(_engine);
1151 if (result != kSuccess) {
1152 NSLog(@"Failed to shut down Flutter engine: error %d", result);
1153 }
1154 _engine = nullptr;
1155 }
1156
1157 - (void)setUpPlatformViewChannel {
1158 _platformViewsChannel =
1159 [FlutterMethodChannel methodChannelWithName:@"flutter/platform_views"
1160 binaryMessenger:self.binaryMessenger
1161 codec:[FlutterStandardMethodCodec sharedInstance]];
1162
1163 __weak FlutterEngine* weakSelf = self;
1164 [_platformViewsChannel setMethodCallHandler:^(FlutterMethodCall* call, FlutterResult result) {
1165 [[weakSelf platformViewController] handleMethodCall:call result:result];
1166 }];
1167 }
1168
1169 - (void)setUpAccessibilityChannel {
1170 _accessibilityChannel = [FlutterBasicMessageChannel
1171 messageChannelWithName:@"flutter/accessibility"
1172 binaryMessenger:self.binaryMessenger
1173 codec:[FlutterStandardMessageCodec sharedInstance]];
1174 __weak FlutterEngine* weakSelf = self;
1175 [_accessibilityChannel setMessageHandler:^(id message, FlutterReply reply) {
1176 [weakSelf handleAccessibilityEvent:message];
1177 }];
1178 }
1179 - (void)setUpNotificationCenterListeners {
1180 NSNotificationCenter* center = [NSNotificationCenter defaultCenter];
1181 // macOS fires this private message when VoiceOver turns on or off.
1182 [center addObserver:self
1183 selector:@selector(onAccessibilityStatusChanged:)
1184 name:kEnhancedUserInterfaceNotification
1185 object:nil];
1186 [center addObserver:self
1187 selector:@selector(applicationWillTerminate:)
1188 name:NSApplicationWillTerminateNotification
1189 object:nil];
1190 [center addObserver:self
1191 selector:@selector(windowDidChangeScreen:)
1192 name:NSWindowDidChangeScreenNotification
1193 object:nil];
1194 [center addObserver:self
1195 selector:@selector(updateDisplayConfig:)
1196 name:NSApplicationDidChangeScreenParametersNotification
1197 object:nil];
1198 }
1199
1200 - (void)addInternalPlugins {
1201 __weak FlutterEngine* weakSelf = self;
1202 [FlutterMouseCursorPlugin registerWithRegistrar:[self registrarForPlugin:@"mousecursor"]
1203 delegate:self];
1204 [FlutterMenuPlugin registerWithRegistrar:[self registrarForPlugin:@"menu"]];
1205 _settingsChannel =
1206 [FlutterBasicMessageChannel messageChannelWithName:kFlutterSettingsChannel
1207 binaryMessenger:self.binaryMessenger
1208 codec:[FlutterJSONMessageCodec sharedInstance]];
1209 _platformChannel =
1210 [FlutterMethodChannel methodChannelWithName:kFlutterPlatformChannel
1211 binaryMessenger:self.binaryMessenger
1212 codec:[FlutterJSONMethodCodec sharedInstance]];
1213 [_platformChannel setMethodCallHandler:^(FlutterMethodCall* call, FlutterResult result) {
1214 [weakSelf handleMethodCall:call result:result];
1215 }];
1216 }
1217
1218 - (void)didUpdateMouseCursor:(NSCursor*)cursor {
1219 // Mouse cursor plugin does not specify which view is responsible for changing the cursor,
1220 // so the reasonable assumption here is that cursor change is a result of a mouse movement
1221 // and thus the cursor will be paired with last Flutter view that reveived mouse event.
1222 [_lastViewWithPointerEvent didUpdateMouseCursor:cursor];
1223 }
1224
1225 - (void)applicationWillTerminate:(NSNotification*)notification {
1226 [self shutDownEngine];
1227 }
1228
1229 - (void)windowDidChangeScreen:(NSNotification*)notification {
1230 // Update window metric for all view controllers since the display_id has
1231 // changed.
1232 NSEnumerator* viewControllerEnumerator = [_viewControllers objectEnumerator];
1233 FlutterViewController* nextViewController;
1234 while ((nextViewController = [viewControllerEnumerator nextObject])) {
1235 [self updateWindowMetricsForViewController:nextViewController];
1236 }
1237 }
1238
1239 - (void)onAccessibilityStatusChanged:(NSNotification*)notification {
1240 BOOL enabled = [notification.userInfo[kEnhancedUserInterfaceKey] boolValue];
1241 NSEnumerator* viewControllerEnumerator = [_viewControllers objectEnumerator];
1242 FlutterViewController* nextViewController;
1243 while ((nextViewController = [viewControllerEnumerator nextObject])) {
1244 [nextViewController onAccessibilityStatusChanged:enabled];
1245 }
1246
1247 self.semanticsEnabled = enabled;
1248 }
1249 - (void)handleAccessibilityEvent:(NSDictionary<NSString*, id>*)annotatedEvent {
1250 NSString* type = annotatedEvent[@"type"];
1251 if ([type isEqualToString:@"announce"]) {
1252 NSString* message = annotatedEvent[@"data"][@"message"];
1253 NSNumber* assertiveness = annotatedEvent[@"data"][@"assertiveness"];
1254 if (message == nil) {
1255 return;
1256 }
1257
1258 NSAccessibilityPriorityLevel priority = [assertiveness isEqualToNumber:@1]
1259 ? NSAccessibilityPriorityHigh
1260 : NSAccessibilityPriorityMedium;
1261
1262 [self announceAccessibilityMessage:message withPriority:priority];
1263 }
1264 }
1265
1266 - (void)announceAccessibilityMessage:(NSString*)message
1267 withPriority:(NSAccessibilityPriorityLevel)priority {
1268 NSAccessibilityPostNotificationWithUserInfo(
1269 [self viewControllerForIdentifier:kFlutterImplicitViewId].flutterView,
1270 NSAccessibilityAnnouncementRequestedNotification,
1271 @{NSAccessibilityAnnouncementKey : message, NSAccessibilityPriorityKey : @(priority)});
1272 }
1273 - (void)handleMethodCall:(FlutterMethodCall*)call result:(FlutterResult)result {
1274 if ([call.method isEqualToString:@"SystemNavigator.pop"]) {
1275 [[NSApplication sharedApplication] terminate:self];
1276 result(nil);
1277 } else if ([call.method isEqualToString:@"SystemSound.play"]) {
1278 [self playSystemSound:call.arguments];
1279 result(nil);
1280 } else if ([call.method isEqualToString:@"Clipboard.getData"]) {
1281 result([self getClipboardData:call.arguments]);
1282 } else if ([call.method isEqualToString:@"Clipboard.setData"]) {
1283 [self setClipboardData:call.arguments];
1284 result(nil);
1285 } else if ([call.method isEqualToString:@"Clipboard.hasStrings"]) {
1286 result(@{@"value" : @([self clipboardHasStrings])});
1287 } else if ([call.method isEqualToString:@"System.exitApplication"]) {
1288 if ([self terminationHandler] == nil) {
1289 // If the termination handler isn't set, then either we haven't
1290 // initialized it yet, or (more likely) the NSApp delegate isn't a
1291 // FlutterAppDelegate, so it can't cancel requests to exit. So, in that
1292 // case, just terminate when requested.
1293 [NSApp terminate:self];
1294 result(nil);
1295 } else {
1296 [[self terminationHandler] handleRequestAppExitMethodCall:call.arguments result:result];
1297 }
1298 } else if ([call.method isEqualToString:@"System.initializationComplete"]) {
1299 if ([self terminationHandler] != nil) {
1300 [self terminationHandler].acceptingRequests = YES;
1301 }
1302 result(nil);
1303 } else {
1304 result(FlutterMethodNotImplemented);
1305 }
1306 }
1307
1308 - (void)playSystemSound:(NSString*)soundType {
1309 if ([soundType isEqualToString:@"SystemSoundType.alert"]) {
1310 NSBeep();
1311 }
1312 }
1313
1314 - (NSDictionary*)getClipboardData:(NSString*)format {
1315 if ([format isEqualToString:@(kTextPlainFormat)]) {
1316 NSString* stringInPasteboard = [self.pasteboard stringForType:NSPasteboardTypeString];
1317 return stringInPasteboard == nil ? nil : @{@"text" : stringInPasteboard};
1318 }
1319 return nil;
1320 }
1321
1322 - (void)setClipboardData:(NSDictionary*)data {
1323 NSString* text = data[@"text"];
1324 [self.pasteboard clearContents];
1325 if (text && ![text isEqual:[NSNull null]]) {
1326 [self.pasteboard setString:text forType:NSPasteboardTypeString];
1327 }
1328 }
1329
1330 - (BOOL)clipboardHasStrings {
1331 return [self.pasteboard stringForType:NSPasteboardTypeString].length > 0;
1332 }
1333
1334 - (std::vector<std::string>)switches {
1335 return flutter::GetSwitchesFromEnvironment();
1336 }
1337
1338 - (FlutterThreadSynchronizer*)testThreadSynchronizer {
1339 return _threadSynchronizer;
1340 }
1341
1342 #pragma mark - FlutterAppLifecycleDelegate
1343
1344 - (void)setApplicationState:(flutter::AppLifecycleState)state {
1345 NSString* nextState =
1346 [[NSString alloc] initWithCString:flutter::AppLifecycleStateToString(state)];
1347 [self sendOnChannel:kFlutterLifecycleChannel
1348 message:[nextState dataUsingEncoding:NSUTF8StringEncoding]];
1349 }
1350
1351 /**
1352 * Called when the |FlutterAppDelegate| gets the applicationWillBecomeActive
1353 * notification.
1354 */
1355 - (void)handleWillBecomeActive:(NSNotification*)notification {
1356 _active = YES;
1357 if (!_visible) {
1358 [self setApplicationState:flutter::AppLifecycleState::kHidden];
1359 } else {
1360 [self setApplicationState:flutter::AppLifecycleState::kResumed];
1361 }
1362 }
1363
1364 /**
1365 * Called when the |FlutterAppDelegate| gets the applicationWillResignActive
1366 * notification.
1367 */
1368 - (void)handleWillResignActive:(NSNotification*)notification {
1369 _active = NO;
1370 if (!_visible) {
1371 [self setApplicationState:flutter::AppLifecycleState::kHidden];
1372 } else {
1373 [self setApplicationState:flutter::AppLifecycleState::kInactive];
1374 }
1375 }
1376
1377 /**
1378 * Called when the |FlutterAppDelegate| gets the applicationDidUnhide
1379 * notification.
1380 */
1381 - (void)handleDidChangeOcclusionState:(NSNotification*)notification {
1382 NSApplicationOcclusionState occlusionState = [[NSApplication sharedApplication] occlusionState];
1383 if (occlusionState & NSApplicationOcclusionStateVisible) {
1384 _visible = YES;
1385 if (_active) {
1386 [self setApplicationState:flutter::AppLifecycleState::kResumed];
1387 } else {
1388 [self setApplicationState:flutter::AppLifecycleState::kInactive];
1389 }
1390 } else {
1391 _visible = NO;
1392 [self setApplicationState:flutter::AppLifecycleState::kHidden];
1393 }
1394 }
1395
1396 #pragma mark - FlutterBinaryMessenger
1397
1398 - (void)sendOnChannel:(nonnull NSString*)channel message:(nullable NSData*)message {
1399 [self sendOnChannel:channel message:message binaryReply:nil];
1400 }
1401
1402 - (void)sendOnChannel:(NSString*)channel
1403 message:(NSData* _Nullable)message
1404 binaryReply:(FlutterBinaryReply _Nullable)callback {
1405 FlutterPlatformMessageResponseHandle* response_handle = nullptr;
1406 if (callback) {
1407 struct Captures {
1408 FlutterBinaryReply reply;
1409 };
1410 auto captures = std::make_unique<Captures>();
1411 captures->reply = callback;
1412 auto message_reply = [](const uint8_t* data, size_t data_size, void* user_data) {
1413 auto captures = reinterpret_cast<Captures*>(user_data);
1414 NSData* reply_data = nil;
1415 if (data != nullptr && data_size > 0) {
1416 reply_data = [NSData dataWithBytes:static_cast<const void*>(data) length:data_size];
1417 }
1418 captures->reply(reply_data);
1419 delete captures;
1420 };
1421
1422 FlutterEngineResult create_result = _embedderAPI.PlatformMessageCreateResponseHandle(
1423 _engine, message_reply, captures.get(), &response_handle);
1424 if (create_result != kSuccess) {
1425 NSLog(@"Failed to create a FlutterPlatformMessageResponseHandle (%d)", create_result);
1426 return;
1427 }
1428 captures.release();
1429 }
1430
1431 FlutterPlatformMessage platformMessage = {
1432 .struct_size = sizeof(FlutterPlatformMessage),
1433 .channel = [channel UTF8String],
1434 .message = static_cast<const uint8_t*>(message.bytes),
1435 .message_size = message.length,
1436 .response_handle = response_handle,
1437 };
1438
1439 FlutterEngineResult message_result = _embedderAPI.SendPlatformMessage(_engine, &platformMessage);
1440 if (message_result != kSuccess) {
1441 NSLog(@"Failed to send message to Flutter engine on channel '%@' (%d).", channel,
1442 message_result);
1443 }
1444
1445 if (response_handle != nullptr) {
1446 FlutterEngineResult release_result =
1447 _embedderAPI.PlatformMessageReleaseResponseHandle(_engine, response_handle);
1448 if (release_result != kSuccess) {
1449 NSLog(@"Failed to release the response handle (%d).", release_result);
1450 };
1451 }
1452 }
1453
1454 - (FlutterBinaryMessengerConnection)setMessageHandlerOnChannel:(nonnull NSString*)channel
1455 binaryMessageHandler:
1456 (nullable FlutterBinaryMessageHandler)handler {
1457 _currentMessengerConnection += 1;
1458 _messengerHandlers[channel] =
1459 [[FlutterEngineHandlerInfo alloc] initWithConnection:@(_currentMessengerConnection)
1460 handler:[handler copy]];
1461 return _currentMessengerConnection;
1462 }
1463
1464 - (void)cleanUpConnection:(FlutterBinaryMessengerConnection)connection {
1465 // Find the _messengerHandlers that has the required connection, and record its
1466 // channel.
1467 NSString* foundChannel = nil;
1468 for (NSString* key in [_messengerHandlers allKeys]) {
1469 FlutterEngineHandlerInfo* handlerInfo = [_messengerHandlers objectForKey:key];
1470 if ([handlerInfo.connection isEqual:@(connection)]) {
1471 foundChannel = key;
1472 break;
1473 }
1474 }
1475 if (foundChannel) {
1476 [_messengerHandlers removeObjectForKey:foundChannel];
1477 }
1478 }
1479
1480 #pragma mark - FlutterPluginRegistry
1481
1482 - (id<FlutterPluginRegistrar>)registrarForPlugin:(NSString*)pluginName {
1483 id<FlutterPluginRegistrar> registrar = self.pluginRegistrars[pluginName];
1484 if (!registrar) {
1485 FlutterEngineRegistrar* registrarImpl =
1486 [[FlutterEngineRegistrar alloc] initWithPlugin:pluginName flutterEngine:self];
1487 self.pluginRegistrars[pluginName] = registrarImpl;
1488 registrar = registrarImpl;
1489 }
1490 return registrar;
1491 }
1492
1493 - (nullable NSObject*)valuePublishedByPlugin:(NSString*)pluginName {
1494 return self.pluginRegistrars[pluginName].publishedValue;
1495 }
1496
1497 #pragma mark - FlutterTextureRegistrar
1498
1499 - (int64_t)registerTexture:(id<FlutterTexture>)texture {
1500 return [_renderer registerTexture:texture];
1501 }
1502
1503 - (BOOL)registerTextureWithID:(int64_t)textureId {
1504 return _embedderAPI.RegisterExternalTexture(_engine, textureId) == kSuccess;
1505 }
1506
1507 - (void)textureFrameAvailable:(int64_t)textureID {
1508 [_renderer textureFrameAvailable:textureID];
1509 }
1510
1511 - (BOOL)markTextureFrameAvailable:(int64_t)textureID {
1512 return _embedderAPI.MarkExternalTextureFrameAvailable(_engine, textureID) == kSuccess;
1513 }
1514
1515 - (void)unregisterTexture:(int64_t)textureID {
1516 [_renderer unregisterTexture:textureID];
1517 }
1518
1519 - (BOOL)unregisterTextureWithID:(int64_t)textureID {
1520 return _embedderAPI.UnregisterExternalTexture(_engine, textureID) == kSuccess;
1521 }
1522
1523 #pragma mark - Task runner integration
1524
1525 - (void)runTaskOnEmbedder:(FlutterTask)task {
1526 if (_engine) {
1527 auto result = _embedderAPI.RunTask(_engine, &task);
1528 if (result != kSuccess) {
1529 NSLog(@"Could not post a task to the Flutter engine.");
1530 }
1531 }
1532 }
1533
1534 - (void)postMainThreadTask:(FlutterTask)task targetTimeInNanoseconds:(uint64_t)targetTime {
1535 __weak FlutterEngine* weakSelf = self;
1536 auto worker = ^{
1537 [weakSelf runTaskOnEmbedder:task];
1538 };
1539
1540 const auto engine_time = _embedderAPI.GetCurrentTime();
1541 if (targetTime <= engine_time) {
1542 dispatch_async(dispatch_get_main_queue(), worker);
1543
1544 } else {
1545 dispatch_after(dispatch_time(DISPATCH_TIME_NOW, targetTime - engine_time),
1546 dispatch_get_main_queue(), worker);
1547 }
1548 }
1549
1550 // Getter used by test harness, only exposed through the FlutterEngine(Test) category
1551 - (flutter::FlutterCompositor*)macOSCompositor {
1552 return _macOSCompositor.get();
1553 }
1554
1555 @end
kEnhancedUserInterfaceKey
static NSString *const kEnhancedUserInterfaceKey
Definition: FlutterEngine.mm:57
+[FlutterMouseCursorPlugin registerWithRegistrar:delegate:]
void registerWithRegistrar:delegate:(nonnull id< FlutterPluginRegistrar > registrar,[delegate] nullable id< FlutterMouseCursorPluginDelegate > delegate)
+[FlutterBasicMessageChannel messageChannelWithName:binaryMessenger:codec:]
instancetype messageChannelWithName:binaryMessenger:codec:(NSString *name,[binaryMessenger] NSObject< FlutterBinaryMessenger > *messenger,[codec] NSObject< FlutterMessageCodec > *codec)
Definition: FlutterChannels.mm:82
_terminator
FlutterTerminationCallback _terminator
Definition: FlutterEngine.mm:188
FlutterPasteboard
Definition: FlutterEngine.mm:286
-[FlutterViewController attached]
BOOL attached()
Definition: FlutterViewController.mm:529
FlutterAppDelegate_Internal.h
_platformChannel
FlutterMethodChannel * _platformChannel
Definition: FlutterEngine.mm:456
FlutterEngine
Definition: FlutterEngine.h:31
FlutterMouseCursorPlugin
Definition: FlutterMouseCursorPlugin.h:23
_vsyncWaiters
NSMapTable< NSNumber *, FlutterVSyncWaiter * > * _vsyncWaiters
Definition: FlutterEngine.mm:471
FlutterPlugin-p
Definition: FlutterPluginMacOS.h:29
_platformViewController
FlutterPlatformViewController * _platformViewController
Definition: FlutterEngine.mm:447
kTextPlainFormat
constexpr char kTextPlainFormat[]
Clipboard plain text format.
Definition: FlutterEngine.mm:60
kFlutterPlatformChannel
NSString *const kFlutterPlatformChannel
Definition: FlutterEngine.mm:34
+[FlutterMethodCall methodCallWithMethodName:arguments:]
instancetype methodCallWithMethodName:arguments:(NSString *method,[arguments] id _Nullable arguments)
FlutterBasicMessageChannel
Definition: FlutterChannels.h:37
FlutterTimeConverter.h
FlutterViewController
Definition: FlutterViewController.h:73
FlutterMethodChannel
Definition: FlutterChannels.h:220
FlutterEngine.h
FlutterMethodNotImplemented
FLUTTER_DARWIN_EXPORT NSObject const * FlutterMethodNotImplemented
-[FlutterViewController onAccessibilityStatusChanged:]
void onAccessibilityStatusChanged:(BOOL enabled)
FlutterPlatformViewController
Definition: FlutterPlatformViewController.h:17
FlutterTextureRegistry-p
Definition: FlutterTexture.h:45
FlutterVSyncWaiter.h
FlutterPlatformViewController.h
FlutterEngineHandlerInfo::handler
FlutterBinaryMessageHandler handler
Definition: FlutterEngine.mm:71
user_data
void * user_data
Definition: texture_registrar_unittests.cc:27
_lastViewWithPointerEvent
__weak FlutterView * _lastViewWithPointerEvent
Definition: FlutterEngine.mm:475
FlutterEngine_Internal.h
+[FlutterDartProject lookupKeyForAsset:]
NSString * lookupKeyForAsset:(NSString *asset)
Definition: FlutterDartProject.mm:116
FlutterError
Definition: FlutterCodecs.h:246
FlutterViewEngineProvider.h
flutter::FlutterCompositor
Definition: FlutterCompositor.h:36
_currentMessengerConnection
FlutterBinaryMessengerConnection _currentMessengerConnection
Definition: FlutterEngine.mm:421
FlutterMethodCall::method
NSString * method
Definition: FlutterCodecs.h:233
kMainThreadPriority
static const int kMainThreadPriority
Definition: FlutterEngine.mm:482
_settingsChannel
FlutterBasicMessageChannel * _settingsChannel
Definition: FlutterEngine.mm:450
FlutterRenderer.h
_project
FlutterDartProject * _project
Definition: FlutterEngine.mm:409
FlutterVSyncWaiter
Definition: FlutterVSyncWaiter.h:8
FlutterViewController::engine
FlutterEngine * engine
Definition: FlutterViewController.h:78
FlutterEngineRegistrar::publishedValue
NSObject * publishedValue
Definition: FlutterEngine.mm:318
FlutterDisplayLink
Definition: FlutterDisplayLink.h:15
FlutterPluginRegistrar-p
Definition: FlutterPluginRegistrarMacOS.h:28
FlutterAppLifecycleProvider-p
Definition: FlutterAppDelegate.h:21
_viewControllers
NSMapTable * _viewControllers
Definition: FlutterEngine.mm:436
FlutterEngine::binaryMessenger
id< FlutterBinaryMessenger > binaryMessenger
Definition: FlutterEngine.h:92
app_lifecycle_state.h
FlutterViewEngineProvider
Definition: FlutterViewEngineProvider.h:18
_macOSCompositor
std::unique_ptr< flutter::FlutterCompositor > _macOSCompositor
Definition: FlutterEngine.mm:431
FlutterAppLifecycleDelegate-p
Definition: FlutterAppLifecycleDelegate.h:21
FlutterRenderer
Definition: FlutterRenderer.h:18
FlutterBinaryMessageHandler
void(^ FlutterBinaryMessageHandler)(NSData *_Nullable message, FlutterBinaryReply reply)
Definition: FlutterBinaryMessenger.h:30
-[FlutterVSyncWaiter waitForVSync:]
void waitForVSync:(uintptr_t baton)
Definition: FlutterVSyncWaiter.mm:108
kEnhancedUserInterfaceNotification
static NSString *const kEnhancedUserInterfaceNotification
The private notification for voice over.
Definition: FlutterEngine.mm:55
FlutterMouseCursorPlugin.h
-[FlutterMethodChannel setMethodCallHandler:]
void setMethodCallHandler:(FlutterMethodCallHandler _Nullable handler)
FlutterStandardMessageCodec
Definition: FlutterCodecs.h:209
FlutterBinaryMessengerRelay.h
-[FlutterViewController onPreEngineRestart]
void onPreEngineRestart()
Definition: FlutterViewController.mm:488
FlutterMethodCall
Definition: FlutterCodecs.h:220
FlutterHourFormat
Definition: FlutterHourFormat.h:10
FlutterThreadSynchronizer
Definition: FlutterThreadSynchronizer.h:18
flutter
Definition: AccessibilityBridgeMac.h:16
FlutterMouseCursorPluginDelegate-p
Definition: FlutterMouseCursorPlugin.h:13
flutter::GetSwitchesFromEnvironment
std::vector< std::string > GetSwitchesFromEnvironment()
Definition: engine_switches.cc:14
FlutterAppDelegate
Definition: FlutterAppDelegate.h:54
engine_switches.h
_visible
BOOL _visible
Definition: FlutterEngine.mm:464
FlutterResult
void(^ FlutterResult)(id _Nullable result)
Definition: FlutterChannels.h:194
OnPlatformMessage
static void OnPlatformMessage(const FlutterPlatformMessage *message, void *user_data)
Definition: FlutterEngine.mm:402
FlutterDisplayLink.h
FlutterAppDelegate.h
FlutterTimeConverter
Converts between the time representation used by Flutter Engine and CAMediaTime.
Definition: FlutterTimeConverter.h:13
kFlutterLifecycleChannel
NSString *const kFlutterLifecycleChannel
Definition: FlutterEngine.mm:36
_active
BOOL _active
Definition: FlutterEngine.mm:461
-[FlutterPlugin-p handleMethodCall:result:]
void handleMethodCall:result:(FlutterMethodCall *call,[result] FlutterResult result)
_binaryMessenger
FlutterBinaryMessengerRelay * _binaryMessenger
Definition: FlutterEngine.mm:467
+[FlutterMethodChannel methodChannelWithName:binaryMessenger:codec:]
instancetype methodChannelWithName:binaryMessenger:codec:(NSString *name,[binaryMessenger] NSObject< FlutterBinaryMessenger > *messenger,[codec] NSObject< FlutterMethodCodec > *codec)
-[FlutterTimeConverter CAMediaTimeToEngineTime:]
uint64_t CAMediaTimeToEngineTime:(CFTimeInterval time)
Definition: FlutterTimeConverter.mm:26
FlutterPlatformViewFactory-p
Definition: FlutterPlatformViews.h:13
_messengerHandlers
NSMutableDictionary< NSString *, FlutterEngineHandlerInfo * > * _messengerHandlers
Definition: FlutterEngine.mm:417
_aotData
_FlutterEngineAOTData * _aotData
Definition: FlutterEngine.mm:427
FlutterDartProject_Internal.h
FlutterViewController_Internal.h
_accessibilityChannel
FlutterBasicMessageChannel * _accessibilityChannel
Definition: FlutterEngine.mm:453
kFlutterSettingsChannel
NSString *const kFlutterSettingsChannel
Definition: FlutterEngine.mm:35
_compositor
FlutterCompositor _compositor
Definition: FlutterEngine.mm:439
-[FlutterPasteboard clearContents]
NSInteger clearContents()
Definition: FlutterEngine.mm:288
-[FlutterEngineTerminationHandler requestApplicationTermination:exitType:result:]
void requestApplicationTermination:exitType:result:(NSApplication *sender,[exitType] FlutterAppExitType type,[result] nullable FlutterResult result)
FlutterViewController::viewIdentifier
FlutterViewIdentifier viewIdentifier
Definition: FlutterViewController.h:130
FlutterView
Definition: FlutterView.h:35
FlutterBinaryMessengerRelay
Definition: FlutterBinaryMessengerRelay.h:14
+[FlutterDisplayLink displayLinkWithView:]
instancetype displayLinkWithView:(NSView *view)
Definition: FlutterDisplayLink.mm:350
FlutterJSONMethodCodec
Definition: FlutterCodecs.h:455
+[FlutterDartProject lookupKeyForAsset:fromPackage:]
NSString * lookupKeyForAsset:fromPackage:(NSString *asset,[fromPackage] NSString *package)
Definition: FlutterDartProject.mm:125
FlutterEngineRegistrar
Definition: FlutterEngine.mm:307
FlutterTexture-p
Definition: FlutterTexture.h:21
+[FlutterHourFormat isAlwaysUse24HourFormat]
BOOL isAlwaysUse24HourFormat()
Definition: FlutterHourFormat.mm:8
flutter::AppLifecycleState
AppLifecycleState
Definition: app_lifecycle_state.h:32
FlutterDartProject
Definition: FlutterDartProject.mm:24
FlutterEngineHandlerInfo
Definition: FlutterEngine.mm:66
_allowHeadlessExecution
BOOL _allowHeadlessExecution
Definition: FlutterEngine.mm:424
FlutterBinaryMessenger-p
Definition: FlutterBinaryMessenger.h:49
FlutterEngineTerminationHandler
Definition: FlutterEngine.mm:188
FlutterEngineHandlerInfo::connection
NSNumber * connection
Definition: FlutterEngine.mm:72
_flutterEngine
__weak FlutterEngine * _flutterEngine
Definition: FlutterEngine.mm:321
_connection
FlutterBinaryMessengerConnection _connection
Definition: FlutterChannels.mm:72
FlutterLocaleFromNSLocale
static FlutterLocale FlutterLocaleFromNSLocale(NSLocale *locale)
Definition: FlutterEngine.mm:44
FlutterViewIdentifier
int64_t FlutterViewIdentifier
Definition: FlutterViewController.h:21
FlutterStandardMethodCodec
Definition: FlutterCodecs.h:469
FlutterBinaryMessengerConnection
int64_t FlutterBinaryMessengerConnection
Definition: FlutterBinaryMessenger.h:32
FlutterCompositor.h
_threadSynchronizer
FlutterThreadSynchronizer * _threadSynchronizer
Definition: FlutterEngine.mm:458
FlutterBinaryReply
NS_ASSUME_NONNULL_BEGIN typedef void(^ FlutterBinaryReply)(NSData *_Nullable reply)
FlutterMethodCall::arguments
id arguments
Definition: FlutterCodecs.h:238
+[FlutterMessageCodec-p sharedInstance]
instancetype sharedInstance()
_platformViewsChannel
FlutterMethodChannel * _platformViewsChannel
Definition: FlutterEngine.mm:443
FlutterJSONMessageCodec
Definition: FlutterCodecs.h:81
FlutterTerminationCallback
NS_ASSUME_NONNULL_BEGIN typedef void(^ FlutterTerminationCallback)(id _Nullable sender)