| 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 [self setUpPlatformViewChannel];
532 [self setUpAccessibilityChannel];
533 [self setUpNotificationCenterListeners];
534 id<NSApplicationDelegate> appDelegate = [[NSApplication sharedApplication] delegate];
535 if ([appDelegate conformsToProtocol:@protocol(FlutterAppLifecycleProvider)]) {
536 _terminationHandler = [[FlutterEngineTerminationHandler alloc] initWithEngine:self
537 terminator:nil];
538 id<FlutterAppLifecycleProvider> lifecycleProvider =
539 static_cast<id<FlutterAppLifecycleProvider>>(appDelegate);
540 [lifecycleProvider addApplicationLifecycleDelegate:self];
541 } else {
542 _terminationHandler = nil;
543 }
544
545 _vsyncWaiters = [NSMapTable strongToStrongObjectsMapTable];
546
547 return self;
548 }
549
550 - (void)dealloc {
551 id<NSApplicationDelegate> appDelegate = [[NSApplication sharedApplication] delegate];
552 if ([appDelegate conformsToProtocol:@protocol(FlutterAppLifecycleProvider)]) {
553 id<FlutterAppLifecycleProvider> lifecycleProvider =
554 static_cast<id<FlutterAppLifecycleProvider>>(appDelegate);
555 [lifecycleProvider removeApplicationLifecycleDelegate:self];
556
557 // Unregister any plugins that registered as app delegates, since they are not guaranteed to
558 // live after the engine is destroyed, and their delegation registration is intended to be bound
559 // to the engine and its lifetime.
560 for (id<FlutterAppLifecycleDelegate> delegate in _pluginAppDelegates) {
561 if (delegate) {
562 [lifecycleProvider removeApplicationLifecycleDelegate:delegate];
563 }
564 }
565 }
566 // Clear any published values, just in case a plugin has created a retain cycle with the
567 // registrar.
568 for (NSString* pluginName in _pluginRegistrars) {
569 [_pluginRegistrars[pluginName] publish:[NSNull null]];
570 }
571 @synchronized(_isResponseValid) {
572 [_isResponseValid removeAllObjects];
573 [_isResponseValid addObject:@NO];
574 }
575 [self shutDownEngine];
576 if (_aotData) {
577 _embedderAPI.CollectAOTData(_aotData);
578 }
579 }
580
581 - (BOOL)runWithEntrypoint:(NSString*)entrypoint {
582 if (self.running) {
583 return NO;
584 }
585
586 if (!_allowHeadlessExecution && [_viewControllers count] == 0) {
587 NSLog(@"Attempted to run an engine with no view controller without headless mode enabled.");
588 return NO;
589 }
590
591 [self addInternalPlugins];
592
593 // The first argument of argv is required to be the executable name.
594 std::vector<const char*> argv = {[self.executableName UTF8String]};
595 std::vector<std::string> switches = self.switches;
596
597 // Enable Impeller only if specifically asked for from the project or cmdline arguments.
598 if (_project.enableImpeller ||
599 std::find(switches.begin(), switches.end(), "--enable-impeller=true") != switches.end()) {
600 switches.push_back("--enable-impeller=true");
601 }
602
603 std::transform(switches.begin(), switches.end(), std::back_inserter(argv),
604 [](const std::string& arg) -> const char* { return arg.c_str(); });
605
606 std::vector<const char*> dartEntrypointArgs;
607 for (NSString* argument in [_project dartEntrypointArguments]) {
608 dartEntrypointArgs.push_back([argument UTF8String]);
609 }
610
611 FlutterProjectArgs flutterArguments = {};
612 flutterArguments.struct_size = sizeof(FlutterProjectArgs);
613 flutterArguments.assets_path = _project.assetsPath.UTF8String;
614 flutterArguments.icu_data_path = _project.ICUDataPath.UTF8String;
615 flutterArguments.command_line_argc = static_cast<int>(argv.size());
616 flutterArguments.command_line_argv = argv.empty() ? nullptr : argv.data();
617 flutterArguments.platform_message_callback = (FlutterPlatformMessageCallback)OnPlatformMessage;
618 flutterArguments.update_semantics_callback2 = [](const FlutterSemanticsUpdate2* update,
619 void* user_data) {
620 // TODO(dkwingsmt): This callback only supports single-view, therefore it
621 // only operates on the implicit view. To support multi-view, we need a
622 // way to pass in the ID (probably through FlutterSemanticsUpdate).
623 FlutterEngine* engine = (__bridge FlutterEngine*)user_data;
624 [[engine viewControllerForIdentifier:kFlutterImplicitViewId] updateSemantics:update];
625 };
626 flutterArguments.custom_dart_entrypoint = entrypoint.UTF8String;
627 flutterArguments.shutdown_dart_vm_when_done = true;
628 flutterArguments.dart_entrypoint_argc = dartEntrypointArgs.size();
629 flutterArguments.dart_entrypoint_argv = dartEntrypointArgs.data();
630 flutterArguments.root_isolate_create_callback = _project.rootIsolateCreateCallback;
631 flutterArguments.log_message_callback = [](const char* tag, const char* message,
632 void* user_data) {
633 if (tag && tag[0]) {
634 std::cout << tag << ": ";
635 }
636 std::cout << message << std::endl;
637 };
638
639 static size_t sTaskRunnerIdentifiers = 0;
640 const FlutterTaskRunnerDescription cocoa_task_runner_description = {
641 .struct_size = sizeof(FlutterTaskRunnerDescription),
642 .user_data = (void*)CFBridgingRetain(self),
643 .runs_task_on_current_thread_callback = [](void* user_data) -> bool {
644 return [[NSThread currentThread] isMainThread];
645 },
646 .post_task_callback = [](FlutterTask task, uint64_t target_time_nanos,
647 void* user_data) -> void {
648 [((__bridge FlutterEngine*)(user_data)) postMainThreadTask:task
649 targetTimeInNanoseconds:target_time_nanos];
650 },
651 .identifier = ++sTaskRunnerIdentifiers,
652 };
653 const FlutterCustomTaskRunners custom_task_runners = {
654 .struct_size = sizeof(FlutterCustomTaskRunners),
655 .platform_task_runner = &cocoa_task_runner_description,
656 .thread_priority_setter = SetThreadPriority};
657 flutterArguments.custom_task_runners = &custom_task_runners;
658
659 [self loadAOTData:_project.assetsPath];
660 if (_aotData) {
661 flutterArguments.aot_data = _aotData;
662 }
663
664 flutterArguments.compositor = [self createFlutterCompositor];
665
666 flutterArguments.on_pre_engine_restart_callback = [](void* user_data) {
667 FlutterEngine* engine = (__bridge FlutterEngine*)user_data;
668 [engine engineCallbackOnPreEngineRestart];
669 };
670
671 flutterArguments.vsync_callback = [](void* user_data, intptr_t baton) {
672 FlutterEngine* engine = (__bridge FlutterEngine*)user_data;
673 [engine onVSync:baton];
674 };
675
676 FlutterRendererConfig rendererConfig = [_renderer createRendererConfig];
677 FlutterEngineResult result = _embedderAPI.Initialize(
678 FLUTTER_ENGINE_VERSION, &rendererConfig, &flutterArguments, (__bridge void*)(self), &_engine);
679 if (result != kSuccess) {
680 NSLog(@"Failed to initialize Flutter engine: error %d", result);
681 return NO;
682 }
683
684 result = _embedderAPI.RunInitialized(_engine);
685 if (result != kSuccess) {
686 NSLog(@"Failed to run an initialized engine: error %d", result);
687 return NO;
688 }
689
690 [self sendUserLocales];
691
692 // Update window metric for all view controllers.
693 NSEnumerator* viewControllerEnumerator = [_viewControllers objectEnumerator];
694 FlutterViewController* nextViewController;
695 while ((nextViewController = [viewControllerEnumerator nextObject])) {
696 [self updateWindowMetricsForViewController:nextViewController];
697 }
698
699 [self updateDisplayConfig];
700 // Send the initial user settings such as brightness and text scale factor
701 // to the engine.
702 [self sendInitialSettings];
703 return YES;
704 }
705
706 - (void)loadAOTData:(NSString*)assetsDir {
707 if (!_embedderAPI.RunsAOTCompiledDartCode()) {
708 return;
709 }
710
711 BOOL isDirOut = false; // required for NSFileManager fileExistsAtPath.
712 NSFileManager* fileManager = [NSFileManager defaultManager];
713
714 // This is the location where the test fixture places the snapshot file.
715 // For applications built by Flutter tool, this is in "App.framework".
716 NSString* elfPath = [NSString pathWithComponents:@[ assetsDir, @"app_elf_snapshot.so" ]];
717
718 if (![fileManager fileExistsAtPath:elfPath isDirectory:&isDirOut]) {
719 return;
720 }
721
722 FlutterEngineAOTDataSource source = {};
723 source.type = kFlutterEngineAOTDataSourceTypeElfPath;
724 source.elf_path = [elfPath cStringUsingEncoding:NSUTF8StringEncoding];
725
726 auto result = _embedderAPI.CreateAOTData(&source, &_aotData);
727 if (result != kSuccess) {
728 NSLog(@"Failed to load AOT data from: %@", elfPath);
729 }
730 }
731
732 - (void)registerViewController:(FlutterViewController*)controller
733 forIdentifier:(FlutterViewIdentifier)viewIdentifier {
734 NSAssert(controller != nil, @"The controller must not be nil.");
735 NSAssert(controller.engine == nil,
736 @"The FlutterViewController is unexpectedly attached to "
737 @"engine %@ before initialization.",
738 controller.engine);
739 NSAssert([_viewControllers objectForKey:@(viewIdentifier)] == nil,
740 @"The requested view ID is occupied.");
741 [_viewControllers setObject:controller forKey:@(viewIdentifier)];
742 [controller setUpWithEngine:self
743 viewIdentifier:viewIdentifier
744 threadSynchronizer:_threadSynchronizer];
745 NSAssert(controller.viewIdentifier == viewIdentifier, @"Failed to assign view ID.");
746 // Verify that the controller's property are updated accordingly. Failing the
747 // assertions is likely because either the FlutterViewController or the
748 // FlutterEngine is mocked. Please subclass these classes instead.
749 NSAssert(controller.attached, @"The FlutterViewController should switch to the attached mode "
750 @"after it is added to a FlutterEngine.");
751 NSAssert(controller.engine == self,
752 @"The FlutterViewController was added to %@, but its engine unexpectedly became %@.",
753 self, controller.engine);
754
755 if (controller.viewLoaded) {
756 [self viewControllerViewDidLoad:controller];
757 }
758 }
759
760 - (void)viewControllerViewDidLoad:(FlutterViewController*)viewController {
761 __weak FlutterEngine* weakSelf = self;
762 FlutterTimeConverter* timeConverter = [[FlutterTimeConverter alloc] initWithEngine:self];
763 FlutterVSyncWaiter* waiter = [[FlutterVSyncWaiter alloc]
764 initWithDisplayLink:[FlutterDisplayLink displayLinkWithView:viewController.view]
765 block:^(CFTimeInterval timestamp, CFTimeInterval targetTimestamp,
766 uintptr_t baton) {
767 uint64_t timeNanos = [timeConverter CAMediaTimeToEngineTime:timestamp];
768 uint64_t targetTimeNanos =
769 [timeConverter CAMediaTimeToEngineTime:targetTimestamp];
770 FlutterEngine* engine = weakSelf;
771 if (engine) {
772 // It is a bit unfortunate that embedder requires OnVSync call on
773 // platform thread just to immediately redispatch it to UI thread.
774 // We are already on UI thread right now, but have to do the
775 // extra hop to main thread.
776 [engine->_threadSynchronizer performOnPlatformThread:^{
777 engine->_embedderAPI.OnVsync(_engine, baton, timeNanos, targetTimeNanos);
778 }];
779 }
780 }];
781 FML_DCHECK([_vsyncWaiters objectForKey:@(viewController.viewIdentifier)] == nil);
782 @synchronized(_vsyncWaiters) {
783 [_vsyncWaiters setObject:waiter forKey:@(viewController.viewIdentifier)];
784 }
785 }
786
787 - (void)deregisterViewControllerForIdentifier:(FlutterViewIdentifier)viewIdentifier {
788 FlutterViewController* controller = [self viewControllerForIdentifier:viewIdentifier];
789 // The controller can be nil. The engine stores only a weak ref, and this
790 // method could have been called from the controller's dealloc.
791 if (controller != nil) {
792 [controller detachFromEngine];
793 NSAssert(!controller.attached,
794 @"The FlutterViewController unexpectedly stays attached after being removed. "
795 @"In unit tests, this is likely because either the FlutterViewController or "
796 @"the FlutterEngine is mocked. Please subclass these classes instead.");
797 }
798 [_viewControllers removeObjectForKey:@(viewIdentifier)];
799 @synchronized(_vsyncWaiters) {
800 [_vsyncWaiters removeObjectForKey:@(viewIdentifier)];
801 }
802 }
803
804 - (void)shutDownIfNeeded {
805 if ([_viewControllers count] == 0 && !_allowHeadlessExecution) {
806 [self shutDownEngine];
807 }
808 }
809
810 - (FlutterViewController*)viewControllerForIdentifier:(FlutterViewIdentifier)viewIdentifier {
811 FlutterViewController* controller = [_viewControllers objectForKey:@(viewIdentifier)];
812 NSAssert(controller == nil || controller.viewIdentifier == viewIdentifier,
813 @"The stored controller has unexpected view ID.");
814 return controller;
815 }
816
817 - (void)setViewController:(FlutterViewController*)controller {
818 FlutterViewController* currentController =
819 [_viewControllers objectForKey:@(kFlutterImplicitViewId)];
820 if (currentController == controller) {
821 // From nil to nil, or from non-nil to the same controller.
822 return;
823 }
824 if (currentController == nil && controller != nil) {
825 // From nil to non-nil.
826 NSAssert(controller.engine == nil,
827 @"Failed to set view controller to the engine: "
828 @"The given FlutterViewController is already attached to an engine %@. "
829 @"If you wanted to create an FlutterViewController and set it to an existing engine, "
830 @"you should use FlutterViewController#init(engine:, nibName, bundle:) instead.",
831 controller.engine);
832 [self registerViewController:controller forIdentifier:kFlutterImplicitViewId];
833 } else if (currentController != nil && controller == nil) {
834 NSAssert(currentController.viewIdentifier == kFlutterImplicitViewId,
835 @"The default controller has an unexpected ID %llu", currentController.viewIdentifier);
836 // From non-nil to nil.
837 [self deregisterViewControllerForIdentifier:kFlutterImplicitViewId];
838 [self shutDownIfNeeded];
839 } else {
840 // From non-nil to a different non-nil view controller.
841 NSAssert(NO,
842 @"Failed to set view controller to the engine: "
843 @"The engine already has an implicit view controller %@. "
844 @"If you wanted to make the implicit view render in a different window, "
845 @"you should attach the current view controller to the window instead.",
846 [_viewControllers objectForKey:@(kFlutterImplicitViewId)]);
847 }
848 }
849
850 - (FlutterViewController*)viewController {
851 return [self viewControllerForIdentifier:kFlutterImplicitViewId];
852 }
853
854 - (FlutterCompositor*)createFlutterCompositor {
855 _macOSCompositor = std::make_unique<flutter::FlutterCompositor>(
856 [[FlutterViewEngineProvider alloc] initWithEngine:self],
857 [[FlutterTimeConverter alloc] initWithEngine:self], _platformViewController);
858
859 _compositor = {};
860 _compositor.struct_size = sizeof(FlutterCompositor);
861 _compositor.user_data = _macOSCompositor.get();
862
863 _compositor.create_backing_store_callback = [](const FlutterBackingStoreConfig* config, //
864 FlutterBackingStore* backing_store_out, //
865 void* user_data //
866 ) {
867 return reinterpret_cast<flutter::FlutterCompositor*>(user_data)->CreateBackingStore(
868 config, backing_store_out);
869 };
870
871 _compositor.collect_backing_store_callback = [](const FlutterBackingStore* backing_store, //
872 void* user_data //
873 ) { return true; };
874
875 _compositor.present_view_callback = [](const FlutterPresentViewInfo* info) {
876 return reinterpret_cast<flutter::FlutterCompositor*>(info->user_data)
877 ->Present(info->view_id, info->layers, info->layers_count);
878 };
879
880 _compositor.avoid_backing_store_cache = true;
881
882 return &_compositor;
883 }
884
885 - (id<FlutterBinaryMessenger>)binaryMessenger {
886 return _binaryMessenger;
887 }
888
889 #pragma mark - Framework-internal methods
890
891 - (void)addViewController:(FlutterViewController*)controller {
892 // FlutterEngine can only handle the implicit view for now. Adding more views
893 // throws an assertion.
894 NSAssert(self.viewController == nil,
895 @"The engine already has a view controller for the implicit view.");
896 self.viewController = controller;
897 }
898
899 - (void)removeViewController:(nonnull FlutterViewController*)viewController {
900 [self deregisterViewControllerForIdentifier:viewController.viewIdentifier];
901 [self shutDownIfNeeded];
902 }
903
904 - (BOOL)running {
905 return _engine != nullptr;
906 }
907
908 - (void)updateDisplayConfig:(NSNotification*)notification {
909 [self updateDisplayConfig];
910 }
911
912 - (NSArray<NSScreen*>*)screens {
913 return [NSScreen screens];
914 }
915
916 - (void)updateDisplayConfig {
917 if (!_engine) {
918 return;
919 }
920
921 std::vector<FlutterEngineDisplay> displays;
922 for (NSScreen* screen : [self screens]) {
923 CGDirectDisplayID displayID =
924 static_cast<CGDirectDisplayID>([screen.deviceDescription[@"NSScreenNumber"] integerValue]);
925
926 double devicePixelRatio = screen.backingScaleFactor;
927 FlutterEngineDisplay display;
928 display.struct_size = sizeof(display);
929 display.display_id = displayID;
930 display.single_display = false;
931 display.width = static_cast<size_t>(screen.frame.size.width) * devicePixelRatio;
932 display.height = static_cast<size_t>(screen.frame.size.height) * devicePixelRatio;
933 display.device_pixel_ratio = devicePixelRatio;
934
935 CVDisplayLinkRef displayLinkRef = nil;
936 CVReturn error = CVDisplayLinkCreateWithCGDisplay(displayID, &displayLinkRef);
937
938 if (error == 0) {
939 CVTime nominal = CVDisplayLinkGetNominalOutputVideoRefreshPeriod(displayLinkRef);
940 if (!(nominal.flags & kCVTimeIsIndefinite)) {
941 double refreshRate = static_cast<double>(nominal.timeScale) / nominal.timeValue;
942 display.refresh_rate = round(refreshRate);
943 }
944 CVDisplayLinkRelease(displayLinkRef);
945 } else {
946 display.refresh_rate = 0;
947 }
948
949 displays.push_back(display);
950 }
951 _embedderAPI.NotifyDisplayUpdate(_engine, kFlutterEngineDisplaysUpdateTypeStartup,
952 displays.data(), displays.size());
953 }
954
955 - (void)onSettingsChanged:(NSNotification*)notification {
956 // TODO(jonahwilliams): https://github.com/flutter/flutter/issues/32015.
957 NSString* brightness =
958 [[NSUserDefaults standardUserDefaults] stringForKey:@"AppleInterfaceStyle"];
959 [_settingsChannel sendMessage:@{
960 @"platformBrightness" : [brightness isEqualToString:@"Dark"] ? @"dark" : @"light",
961 // TODO(jonahwilliams): https://github.com/flutter/flutter/issues/32006.
962 @"textScaleFactor" : @1.0,
963 @"alwaysUse24HourFormat" : @false
964 }];
965 }
966
967 - (void)sendInitialSettings {
968 // TODO(jonahwilliams): https://github.com/flutter/flutter/issues/32015.
969 [[NSDistributedNotificationCenter defaultCenter]
970 addObserver:self
971 selector:@selector(onSettingsChanged:)
972 name:@"AppleInterfaceThemeChangedNotification"
973 object:nil];
974 [self onSettingsChanged:nil];
975 }
976
977 - (FlutterEngineProcTable&)embedderAPI {
978 return _embedderAPI;
979 }
980
981 - (nonnull NSString*)executableName {
982 return [[[NSProcessInfo processInfo] arguments] firstObject] ?: @"Flutter";
983 }
984
985 - (void)updateWindowMetricsForViewController:(FlutterViewController*)viewController {
986 if (!_engine || !viewController || !viewController.viewLoaded) {
987 return;
988 }
989 NSAssert([self viewControllerForIdentifier:viewController.viewIdentifier] == viewController,
990 @"The provided view controller is not attached to this engine.");
991 NSView* view = viewController.flutterView;
992 CGRect scaledBounds = [view convertRectToBacking:view.bounds];
993 CGSize scaledSize = scaledBounds.size;
994 double pixelRatio = view.bounds.size.width == 0 ? 1 : scaledSize.width / view.bounds.size.width;
995 auto displayId = [view.window.screen.deviceDescription[@"NSScreenNumber"] integerValue];
996 const FlutterWindowMetricsEvent windowMetricsEvent = {
997 .struct_size = sizeof(windowMetricsEvent),
998 .width = static_cast<size_t>(scaledSize.width),
999 .height = static_cast<size_t>(scaledSize.height),
1000 .pixel_ratio = pixelRatio,
1001 .left = static_cast<size_t>(scaledBounds.origin.x),
1002 .top = static_cast<size_t>(scaledBounds.origin.y),
1003 .display_id = static_cast<uint64_t>(displayId),
1004 .view_id = viewController.viewIdentifier,
1005 };
1006 _embedderAPI.SendWindowMetricsEvent(_engine, &windowMetricsEvent);
1007 }
1008
1009 - (void)sendPointerEvent:(const FlutterPointerEvent&)event {
1010 _embedderAPI.SendPointerEvent(_engine, &event, 1);
1011 _lastViewWithPointerEvent = [self viewControllerForIdentifier:kFlutterImplicitViewId].flutterView;
1012 }
1013
1014 - (void)sendKeyEvent:(const FlutterKeyEvent&)event
1015 callback:(FlutterKeyEventCallback)callback
1016 userData:(void*)userData {
1017 _embedderAPI.SendKeyEvent(_engine, &event, callback, userData);
1018 }
1019
1020 - (void)setSemanticsEnabled:(BOOL)enabled {
1021 if (_semanticsEnabled == enabled) {
1022 return;
1023 }
1024 _semanticsEnabled = enabled;
1025
1026 // Update all view controllers' bridges.
1027 NSEnumerator* viewControllerEnumerator = [_viewControllers objectEnumerator];
1028 FlutterViewController* nextViewController;
1029 while ((nextViewController = [viewControllerEnumerator nextObject])) {
1030 [nextViewController notifySemanticsEnabledChanged];
1031 }
1032
1033 _embedderAPI.UpdateSemanticsEnabled(_engine, _semanticsEnabled);
1034 }
1035
1036 - (void)dispatchSemanticsAction:(FlutterSemanticsAction)action
1037 toTarget:(uint16_t)target
1038 withData:(fml::MallocMapping)data {
1039 _embedderAPI.DispatchSemanticsAction(_engine, target, action, data.GetMapping(), data.GetSize());
1040 }
1041
1042 - (FlutterPlatformViewController*)platformViewController {
1043 return _platformViewController;
1044 }
1045
1046 #pragma mark - Private methods
1047
1048 - (void)sendUserLocales {
1049 if (!self.running) {
1050 return;
1051 }
1052
1053 // Create a list of FlutterLocales corresponding to the preferred languages.
1054 NSMutableArray<NSLocale*>* locales = [NSMutableArray array];
1055 std::vector<FlutterLocale> flutterLocales;
1056 flutterLocales.reserve(locales.count);
1057 for (NSString* localeID in [NSLocale preferredLanguages]) {
1058 NSLocale* locale = [[NSLocale alloc] initWithLocaleIdentifier:localeID];
1059 [locales addObject:locale];
1060 flutterLocales.push_back(FlutterLocaleFromNSLocale(locale));
1061 }
1062 // Convert to a list of pointers, and send to the engine.
1063 std::vector<const FlutterLocale*> flutterLocaleList;
1064 flutterLocaleList.reserve(flutterLocales.size());
1065 std::transform(flutterLocales.begin(), flutterLocales.end(),
1066 std::back_inserter(flutterLocaleList),
1067 [](const auto& arg) -> const auto* { return &arg; });
1068 _embedderAPI.UpdateLocales(_engine, flutterLocaleList.data(), flutterLocaleList.size());
1069 }
1070
1071 - (void)engineCallbackOnPlatformMessage:(const FlutterPlatformMessage*)message {
1072 NSData* messageData = nil;
1073 if (message->message_size > 0) {
1074 messageData = [NSData dataWithBytesNoCopy:(void*)message->message
1075 length:message->message_size
1076 freeWhenDone:NO];
1077 }
1078 NSString* channel = @(message->channel);
1079 __block const FlutterPlatformMessageResponseHandle* responseHandle = message->response_handle;
1080 __block FlutterEngine* weakSelf = self;
1081 NSMutableArray* isResponseValid = self.isResponseValid;
1082 FlutterEngineSendPlatformMessageResponseFnPtr sendPlatformMessageResponse =
1083 _embedderAPI.SendPlatformMessageResponse;
1084 FlutterBinaryReply binaryResponseHandler = ^(NSData* response) {
1085 @synchronized(isResponseValid) {
1086 if (![isResponseValid[0] boolValue]) {
1087 // Ignore, engine was killed.
1088 return;
1089 }
1090 if (responseHandle) {
1091 sendPlatformMessageResponse(weakSelf->_engine, responseHandle,
1092 static_cast<const uint8_t*>(response.bytes), response.length);
1093 responseHandle = NULL;
1094 } else {
1095 NSLog(@"Error: Message responses can be sent only once. Ignoring duplicate response "
1096 "on channel '%@'.",
1097 channel);
1098 }
1099 }
1100 };
1101
1102 FlutterEngineHandlerInfo* handlerInfo = _messengerHandlers[channel];
1103 if (handlerInfo) {
1104 handlerInfo.handler(messageData, binaryResponseHandler);
1105 } else {
1106 binaryResponseHandler(nil);
1107 }
1108 }
1109
1110 - (void)engineCallbackOnPreEngineRestart {
1111 NSEnumerator* viewControllerEnumerator = [_viewControllers objectEnumerator];
1112 FlutterViewController* nextViewController;
1113 while ((nextViewController = [viewControllerEnumerator nextObject])) {
1114 [nextViewController onPreEngineRestart];
1115 }
1116 }
1117
1118 - (void)onVSync:(uintptr_t)baton {
1119 @synchronized(_vsyncWaiters) {
1120 // TODO(knopp): Use vsync waiter for correct view.
1121 // https://github.com/flutter/flutter/issues/142845
1122 FlutterVSyncWaiter* waiter = [_vsyncWaiters objectForKey:@(kFlutterImplicitViewId)];
1123 [waiter waitForVSync:baton];
1124 }
1125 }
1126
1127 /**
1128 * Note: Called from dealloc. Should not use accessors or other methods.
1129 */
1130 - (void)shutDownEngine {
1131 if (_engine == nullptr) {
1132 return;
1133 }
1134
1135 [_threadSynchronizer shutdown];
1136 _threadSynchronizer = nil;
1137
1138 FlutterEngineResult result = _embedderAPI.Deinitialize(_engine);
1139 if (result != kSuccess) {
1140 NSLog(@"Could not de-initialize the Flutter engine: error %d", result);
1141 }
1142
1143 // Balancing release for the retain in the task runner dispatch table.
1144 CFRelease((CFTypeRef)self);
1145
1146 result = _embedderAPI.Shutdown(_engine);
1147 if (result != kSuccess) {
1148 NSLog(@"Failed to shut down Flutter engine: error %d", result);
1149 }
1150 _engine = nullptr;
1151 }
1152
1153 - (void)setUpPlatformViewChannel {
1154 _platformViewsChannel =
1155 [FlutterMethodChannel methodChannelWithName:@"flutter/platform_views"
1156 binaryMessenger:self.binaryMessenger
1157 codec:[FlutterStandardMethodCodec sharedInstance]];
1158
1159 __weak FlutterEngine* weakSelf = self;
1160 [_platformViewsChannel setMethodCallHandler:^(FlutterMethodCall* call, FlutterResult result) {
1161 [[weakSelf platformViewController] handleMethodCall:call result:result];
1162 }];
1163 }
1164
1165 - (void)setUpAccessibilityChannel {
1166 _accessibilityChannel = [FlutterBasicMessageChannel
1167 messageChannelWithName:@"flutter/accessibility"
1168 binaryMessenger:self.binaryMessenger
1169 codec:[FlutterStandardMessageCodec sharedInstance]];
1170 __weak FlutterEngine* weakSelf = self;
1171 [_accessibilityChannel setMessageHandler:^(id message, FlutterReply reply) {
1172 [weakSelf handleAccessibilityEvent:message];
1173 }];
1174 }
1175 - (void)setUpNotificationCenterListeners {
1176 NSNotificationCenter* center = [NSNotificationCenter defaultCenter];
1177 // macOS fires this private message when VoiceOver turns on or off.
1178 [center addObserver:self
1179 selector:@selector(onAccessibilityStatusChanged:)
1180 name:kEnhancedUserInterfaceNotification
1181 object:nil];
1182 [center addObserver:self
1183 selector:@selector(applicationWillTerminate:)
1184 name:NSApplicationWillTerminateNotification
1185 object:nil];
1186 [center addObserver:self
1187 selector:@selector(windowDidChangeScreen:)
1188 name:NSWindowDidChangeScreenNotification
1189 object:nil];
1190 [center addObserver:self
1191 selector:@selector(updateDisplayConfig:)
1192 name:NSApplicationDidChangeScreenParametersNotification
1193 object:nil];
1194 }
1195
1196 - (void)addInternalPlugins {
1197 __weak FlutterEngine* weakSelf = self;
1198 [FlutterMouseCursorPlugin registerWithRegistrar:[self registrarForPlugin:@"mousecursor"]
1199 delegate:self];
1200 [FlutterMenuPlugin registerWithRegistrar:[self registrarForPlugin:@"menu"]];
1201 _settingsChannel =
1202 [FlutterBasicMessageChannel messageChannelWithName:kFlutterSettingsChannel
1203 binaryMessenger:self.binaryMessenger
1204 codec:[FlutterJSONMessageCodec sharedInstance]];
1205 _platformChannel =
1206 [FlutterMethodChannel methodChannelWithName:kFlutterPlatformChannel
1207 binaryMessenger:self.binaryMessenger
1208 codec:[FlutterJSONMethodCodec sharedInstance]];
1209 [_platformChannel setMethodCallHandler:^(FlutterMethodCall* call, FlutterResult result) {
1210 [weakSelf handleMethodCall:call result:result];
1211 }];
1212 }
1213
1214 - (void)didUpdateMouseCursor:(NSCursor*)cursor {
1215 // Mouse cursor plugin does not specify which view is responsible for changing the cursor,
1216 // so the reasonable assumption here is that cursor change is a result of a mouse movement
1217 // and thus the cursor will be paired with last Flutter view that reveived mouse event.
1218 [_lastViewWithPointerEvent didUpdateMouseCursor:cursor];
1219 }
1220
1221 - (void)applicationWillTerminate:(NSNotification*)notification {
1222 [self shutDownEngine];
1223 }
1224
1225 - (void)windowDidChangeScreen:(NSNotification*)notification {
1226 // Update window metric for all view controllers since the display_id has
1227 // changed.
1228 NSEnumerator* viewControllerEnumerator = [_viewControllers objectEnumerator];
1229 FlutterViewController* nextViewController;
1230 while ((nextViewController = [viewControllerEnumerator nextObject])) {
1231 [self updateWindowMetricsForViewController:nextViewController];
1232 }
1233 }
1234
1235 - (void)onAccessibilityStatusChanged:(NSNotification*)notification {
1236 BOOL enabled = [notification.userInfo[kEnhancedUserInterfaceKey] boolValue];
1237 NSEnumerator* viewControllerEnumerator = [_viewControllers objectEnumerator];
1238 FlutterViewController* nextViewController;
1239 while ((nextViewController = [viewControllerEnumerator nextObject])) {
1240 [nextViewController onAccessibilityStatusChanged:enabled];
1241 }
1242
1243 self.semanticsEnabled = enabled;
1244 }
1245 - (void)handleAccessibilityEvent:(NSDictionary<NSString*, id>*)annotatedEvent {
1246 NSString* type = annotatedEvent[@"type"];
1247 if ([type isEqualToString:@"announce"]) {
1248 NSString* message = annotatedEvent[@"data"][@"message"];
1249 NSNumber* assertiveness = annotatedEvent[@"data"][@"assertiveness"];
1250 if (message == nil) {
1251 return;
1252 }
1253
1254 NSAccessibilityPriorityLevel priority = [assertiveness isEqualToNumber:@1]
1255 ? NSAccessibilityPriorityHigh
1256 : NSAccessibilityPriorityMedium;
1257
1258 [self announceAccessibilityMessage:message withPriority:priority];
1259 }
1260 }
1261
1262 - (void)announceAccessibilityMessage:(NSString*)message
1263 withPriority:(NSAccessibilityPriorityLevel)priority {
1264 NSAccessibilityPostNotificationWithUserInfo(
1265 [self viewControllerForIdentifier:kFlutterImplicitViewId].flutterView,
1266 NSAccessibilityAnnouncementRequestedNotification,
1267 @{NSAccessibilityAnnouncementKey : message, NSAccessibilityPriorityKey : @(priority)});
1268 }
1269 - (void)handleMethodCall:(FlutterMethodCall*)call result:(FlutterResult)result {
1270 if ([call.method isEqualToString:@"SystemNavigator.pop"]) {
1271 [[NSApplication sharedApplication] terminate:self];
1272 result(nil);
1273 } else if ([call.method isEqualToString:@"SystemSound.play"]) {
1274 [self playSystemSound:call.arguments];
1275 result(nil);
1276 } else if ([call.method isEqualToString:@"Clipboard.getData"]) {
1277 result([self getClipboardData:call.arguments]);
1278 } else if ([call.method isEqualToString:@"Clipboard.setData"]) {
1279 [self setClipboardData:call.arguments];
1280 result(nil);
1281 } else if ([call.method isEqualToString:@"Clipboard.hasStrings"]) {
1282 result(@{@"value" : @([self clipboardHasStrings])});
1283 } else if ([call.method isEqualToString:@"System.exitApplication"]) {
1284 if ([self terminationHandler] == nil) {
1285 // If the termination handler isn't set, then either we haven't
1286 // initialized it yet, or (more likely) the NSApp delegate isn't a
1287 // FlutterAppDelegate, so it can't cancel requests to exit. So, in that
1288 // case, just terminate when requested.
1289 [NSApp terminate:self];
1290 result(nil);
1291 } else {
1292 [[self terminationHandler] handleRequestAppExitMethodCall:call.arguments result:result];
1293 }
1294 } else if ([call.method isEqualToString:@"System.initializationComplete"]) {
1295 if ([self terminationHandler] != nil) {
1296 [self terminationHandler].acceptingRequests = YES;
1297 }
1298 result(nil);
1299 } else {
1300 result(FlutterMethodNotImplemented);
1301 }
1302 }
1303
1304 - (void)playSystemSound:(NSString*)soundType {
1305 if ([soundType isEqualToString:@"SystemSoundType.alert"]) {
1306 NSBeep();
1307 }
1308 }
1309
1310 - (NSDictionary*)getClipboardData:(NSString*)format {
1311 if ([format isEqualToString:@(kTextPlainFormat)]) {
1312 NSString* stringInPasteboard = [self.pasteboard stringForType:NSPasteboardTypeString];
1313 return stringInPasteboard == nil ? nil : @{@"text" : stringInPasteboard};
1314 }
1315 return nil;
1316 }
1317
1318 - (void)setClipboardData:(NSDictionary*)data {
1319 NSString* text = data[@"text"];
1320 [self.pasteboard clearContents];
1321 if (text && ![text isEqual:[NSNull null]]) {
1322 [self.pasteboard setString:text forType:NSPasteboardTypeString];
1323 }
1324 }
1325
1326 - (BOOL)clipboardHasStrings {
1327 return [self.pasteboard stringForType:NSPasteboardTypeString].length > 0;
1328 }
1329
1330 - (std::vector<std::string>)switches {
1331 return flutter::GetSwitchesFromEnvironment();
1332 }
1333
1334 - (FlutterThreadSynchronizer*)testThreadSynchronizer {
1335 return _threadSynchronizer;
1336 }
1337
1338 #pragma mark - FlutterAppLifecycleDelegate
1339
1340 - (void)setApplicationState:(flutter::AppLifecycleState)state {
1341 NSString* nextState =
1342 [[NSString alloc] initWithCString:flutter::AppLifecycleStateToString(state)];
1343 [self sendOnChannel:kFlutterLifecycleChannel
1344 message:[nextState dataUsingEncoding:NSUTF8StringEncoding]];
1345 }
1346
1347 /**
1348 * Called when the |FlutterAppDelegate| gets the applicationWillBecomeActive
1349 * notification.
1350 */
1351 - (void)handleWillBecomeActive:(NSNotification*)notification {
1352 _active = YES;
1353 if (!_visible) {
1354 [self setApplicationState:flutter::AppLifecycleState::kHidden];
1355 } else {
1356 [self setApplicationState:flutter::AppLifecycleState::kResumed];
1357 }
1358 }
1359
1360 /**
1361 * Called when the |FlutterAppDelegate| gets the applicationWillResignActive
1362 * notification.
1363 */
1364 - (void)handleWillResignActive:(NSNotification*)notification {
1365 _active = NO;
1366 if (!_visible) {
1367 [self setApplicationState:flutter::AppLifecycleState::kHidden];
1368 } else {
1369 [self setApplicationState:flutter::AppLifecycleState::kInactive];
1370 }
1371 }
1372
1373 /**
1374 * Called when the |FlutterAppDelegate| gets the applicationDidUnhide
1375 * notification.
1376 */
1377 - (void)handleDidChangeOcclusionState:(NSNotification*)notification {
1378 NSApplicationOcclusionState occlusionState = [[NSApplication sharedApplication] occlusionState];
1379 if (occlusionState & NSApplicationOcclusionStateVisible) {
1380 _visible = YES;
1381 if (_active) {
1382 [self setApplicationState:flutter::AppLifecycleState::kResumed];
1383 } else {
1384 [self setApplicationState:flutter::AppLifecycleState::kInactive];
1385 }
1386 } else {
1387 _visible = NO;
1388 [self setApplicationState:flutter::AppLifecycleState::kHidden];
1389 }
1390 }
1391
1392 #pragma mark - FlutterBinaryMessenger
1393
1394 - (void)sendOnChannel:(nonnull NSString*)channel message:(nullable NSData*)message {
1395 [self sendOnChannel:channel message:message binaryReply:nil];
1396 }
1397
1398 - (void)sendOnChannel:(NSString*)channel
1399 message:(NSData* _Nullable)message
1400 binaryReply:(FlutterBinaryReply _Nullable)callback {
1401 FlutterPlatformMessageResponseHandle* response_handle = nullptr;
1402 if (callback) {
1403 struct Captures {
1404 FlutterBinaryReply reply;
1405 };
1406 auto captures = std::make_unique<Captures>();
1407 captures->reply = callback;
1408 auto message_reply = [](const uint8_t* data, size_t data_size, void* user_data) {
1409 auto captures = reinterpret_cast<Captures*>(user_data);
1410 NSData* reply_data = nil;
1411 if (data != nullptr && data_size > 0) {
1412 reply_data = [NSData dataWithBytes:static_cast<const void*>(data) length:data_size];
1413 }
1414 captures->reply(reply_data);
1415 delete captures;
1416 };
1417
1418 FlutterEngineResult create_result = _embedderAPI.PlatformMessageCreateResponseHandle(
1419 _engine, message_reply, captures.get(), &response_handle);
1420 if (create_result != kSuccess) {
1421 NSLog(@"Failed to create a FlutterPlatformMessageResponseHandle (%d)", create_result);
1422 return;
1423 }
1424 captures.release();
1425 }
1426
1427 FlutterPlatformMessage platformMessage = {
1428 .struct_size = sizeof(FlutterPlatformMessage),
1429 .channel = [channel UTF8String],
1430 .message = static_cast<const uint8_t*>(message.bytes),
1431 .message_size = message.length,
1432 .response_handle = response_handle,
1433 };
1434
1435 FlutterEngineResult message_result = _embedderAPI.SendPlatformMessage(_engine, &platformMessage);
1436 if (message_result != kSuccess) {
1437 NSLog(@"Failed to send message to Flutter engine on channel '%@' (%d).", channel,
1438 message_result);
1439 }
1440
1441 if (response_handle != nullptr) {
1442 FlutterEngineResult release_result =
1443 _embedderAPI.PlatformMessageReleaseResponseHandle(_engine, response_handle);
1444 if (release_result != kSuccess) {
1445 NSLog(@"Failed to release the response handle (%d).", release_result);
1446 };
1447 }
1448 }
1449
1450 - (FlutterBinaryMessengerConnection)setMessageHandlerOnChannel:(nonnull NSString*)channel
1451 binaryMessageHandler:
1452 (nullable FlutterBinaryMessageHandler)handler {
1453 _currentMessengerConnection += 1;
1454 _messengerHandlers[channel] =
1455 [[FlutterEngineHandlerInfo alloc] initWithConnection:@(_currentMessengerConnection)
1456 handler:[handler copy]];
1457 return _currentMessengerConnection;
1458 }
1459
1460 - (void)cleanUpConnection:(FlutterBinaryMessengerConnection)connection {
1461 // Find the _messengerHandlers that has the required connection, and record its
1462 // channel.
1463 NSString* foundChannel = nil;
1464 for (NSString* key in [_messengerHandlers allKeys]) {
1465 FlutterEngineHandlerInfo* handlerInfo = [_messengerHandlers objectForKey:key];
1466 if ([handlerInfo.connection isEqual:@(connection)]) {
1467 foundChannel = key;
1468 break;
1469 }
1470 }
1471 if (foundChannel) {
1472 [_messengerHandlers removeObjectForKey:foundChannel];
1473 }
1474 }
1475
1476 #pragma mark - FlutterPluginRegistry
1477
1478 - (id<FlutterPluginRegistrar>)registrarForPlugin:(NSString*)pluginName {
1479 id<FlutterPluginRegistrar> registrar = self.pluginRegistrars[pluginName];
1480 if (!registrar) {
1481 FlutterEngineRegistrar* registrarImpl =
1482 [[FlutterEngineRegistrar alloc] initWithPlugin:pluginName flutterEngine:self];
1483 self.pluginRegistrars[pluginName] = registrarImpl;
1484 registrar = registrarImpl;
1485 }
1486 return registrar;
1487 }
1488
1489 - (nullable NSObject*)valuePublishedByPlugin:(NSString*)pluginName {
1490 return self.pluginRegistrars[pluginName].publishedValue;
1491 }
1492
1493 #pragma mark - FlutterTextureRegistrar
1494
1495 - (int64_t)registerTexture:(id<FlutterTexture>)texture {
1496 return [_renderer registerTexture:texture];
1497 }
1498
1499 - (BOOL)registerTextureWithID:(int64_t)textureId {
1500 return _embedderAPI.RegisterExternalTexture(_engine, textureId) == kSuccess;
1501 }
1502
1503 - (void)textureFrameAvailable:(int64_t)textureID {
1504 [_renderer textureFrameAvailable:textureID];
1505 }
1506
1507 - (BOOL)markTextureFrameAvailable:(int64_t)textureID {
1508 return _embedderAPI.MarkExternalTextureFrameAvailable(_engine, textureID) == kSuccess;
1509 }
1510
1511 - (void)unregisterTexture:(int64_t)textureID {
1512 [_renderer unregisterTexture:textureID];
1513 }
1514
1515 - (BOOL)unregisterTextureWithID:(int64_t)textureID {
1516 return _embedderAPI.UnregisterExternalTexture(_engine, textureID) == kSuccess;
1517 }
1518
1519 #pragma mark - Task runner integration
1520
1521 - (void)runTaskOnEmbedder:(FlutterTask)task {
1522 if (_engine) {
1523 auto result = _embedderAPI.RunTask(_engine, &task);
1524 if (result != kSuccess) {
1525 NSLog(@"Could not post a task to the Flutter engine.");
1526 }
1527 }
1528 }
1529
1530 - (void)postMainThreadTask:(FlutterTask)task targetTimeInNanoseconds:(uint64_t)targetTime {
1531 __weak FlutterEngine* weakSelf = self;
1532 auto worker = ^{
1533 [weakSelf runTaskOnEmbedder:task];
1534 };
1535
1536 const auto engine_time = _embedderAPI.GetCurrentTime();
1537 if (targetTime <= engine_time) {
1538 dispatch_async(dispatch_get_main_queue(), worker);
1539
1540 } else {
1541 dispatch_after(dispatch_time(DISPATCH_TIME_NOW, targetTime - engine_time),
1542 dispatch_get_main_queue(), worker);
1543 }
1544 }
1545
1546 // Getter used by test harness, only exposed through the FlutterEngine(Test) category
1547 - (flutter::FlutterCompositor*)macOSCompositor {
1548 return _macOSCompositor.get();
1549 }
1550
1551 @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:517
FlutterAppDelegate_Internal.h
_platformChannel
FlutterMethodChannel * _platformChannel
Definition: FlutterEngine.mm:456
FlutterEngine
Definition: FlutterEngine.h:30
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:91
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:476
FlutterMethodCall
Definition: FlutterCodecs.h:220
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
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)