Flutter iOS Embedder
FlutterDartProject.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 #define FML_USED_ON_EMBEDDER
6 
8 
9 #import <Metal/Metal.h>
10 #import <UIKit/UIKit.h>
11 
12 #include <sstream>
13 
14 #include "flutter/common/constants.h"
15 #include "flutter/fml/build_config.h"
16 #include "flutter/shell/common/switches.h"
17 #import "flutter/shell/platform/darwin/common/InternalFlutterSwiftCommon/InternalFlutterSwiftCommon.h"
19 
21 
22 extern "C" {
23 #if FLUTTER_RUNTIME_MODE == FLUTTER_RUNTIME_MODE_DEBUG
24 // Used for debugging dart:* sources.
25 extern const uint8_t kPlatformStrongDill[];
26 extern const intptr_t kPlatformStrongDillSize;
27 #endif
28 }
29 
30 static const char* kApplicationKernelSnapshotFileName = "kernel_blob.bin";
31 
33  static BOOL result = NO;
34  static dispatch_once_t once_token = 0;
35  dispatch_once(&once_token, ^{
36  id<MTLDevice> device = MTLCreateSystemDefaultDevice();
37  result = [device supportsFamily:MTLGPUFamilyApple2];
38  });
39  return result;
40 }
41 
42 flutter::Settings FLTDefaultSettingsForBundle(NSBundle* bundle, NSProcessInfo* processInfoOrNil) {
43  auto command_line = flutter::CommandLineFromNSProcessInfo(processInfoOrNil);
44 
45  // Precedence:
46  // 1. Settings from the specified NSBundle.
47  // 2. Settings passed explicitly via command-line arguments.
48  // 3. Settings from the NSBundle with the default bundle ID.
49  // 4. Settings from the main NSBundle and default values.
50 
51  NSBundle* mainBundle = FLTGetApplicationBundle();
52  NSBundle* engineBundle = [NSBundle bundleForClass:[FlutterDartProject class]];
53 
54  bool hasExplicitBundle = bundle != nil;
55  if (bundle == nil) {
56  bundle = FLTFrameworkBundleWithIdentifier([FlutterDartProject defaultBundleIdentifier]);
57  }
58 
59  auto settings = flutter::SettingsFromCommandLine(command_line);
60 
61  settings.task_observer_add = [](intptr_t key, const fml::closure& callback) {
62  fml::TaskQueueId queue_id = fml::MessageLoop::GetCurrentTaskQueueId();
63  fml::MessageLoopTaskQueues::GetInstance()->AddTaskObserver(queue_id, key, callback);
64  return queue_id;
65  };
66 
67  settings.task_observer_remove = [](fml::TaskQueueId queue_id, intptr_t key) {
68  fml::MessageLoopTaskQueues::GetInstance()->RemoveTaskObserver(queue_id, key);
69  };
70 
71  settings.log_message_callback = [](const std::string& tag, const std::string& message) {
72  std::stringstream stream;
73  if (!tag.empty()) {
74  stream << tag << ": ";
75  }
76  stream << message;
77  std::string log = stream.str();
78  [FlutterLogger logDirect:[NSString stringWithUTF8String:log.c_str()]];
79  };
80 
81  settings.enable_platform_isolates = true;
82 
83  // The command line arguments may not always be complete. If they aren't, attempt to fill in
84  // defaults.
85 
86  // Flutter ships the ICU data file in the bundle of the engine. Look for it there.
87  if (settings.icu_data_path.empty()) {
88  NSString* icuDataPath = [engineBundle pathForResource:@"icudtl" ofType:@"dat"];
89  if (icuDataPath.length > 0) {
90  settings.icu_data_path = icuDataPath.UTF8String;
91  }
92  }
93 
94  if (flutter::DartVM::IsRunningPrecompiledCode()) {
95  if (hasExplicitBundle) {
96  NSString* executablePath = bundle.executablePath;
97  if ([[NSFileManager defaultManager] fileExistsAtPath:executablePath]) {
98  settings.application_library_path.push_back(executablePath.UTF8String);
99  }
100  }
101 
102  // No application bundle specified. Try a known location from the main bundle's Info.plist.
103  if (settings.application_library_path.empty()) {
104  NSString* libraryName = [mainBundle objectForInfoDictionaryKey:@"FLTLibraryPath"];
105  NSString* libraryPath = [mainBundle pathForResource:libraryName ofType:@""];
106  if (libraryPath.length > 0) {
107  NSString* executablePath = [NSBundle bundleWithPath:libraryPath].executablePath;
108  if (executablePath.length > 0) {
109  settings.application_library_path.push_back(executablePath.UTF8String);
110  }
111  }
112  }
113 
114  // In case the application bundle is still not specified, look for the App.framework in the
115  // Frameworks directory.
116  if (settings.application_library_path.empty()) {
117  NSString* applicationFrameworkPath = [mainBundle pathForResource:@"Frameworks/App.framework"
118  ofType:@""];
119  if (applicationFrameworkPath.length > 0) {
120  NSString* executablePath =
121  [NSBundle bundleWithPath:applicationFrameworkPath].executablePath;
122  if (executablePath.length > 0) {
123  settings.application_library_path.push_back(executablePath.UTF8String);
124  }
125  }
126  }
127  }
128 
129  // Checks to see if the flutter assets directory is already present.
130  if (settings.assets_path.empty()) {
131  NSString* assetsPath = FLTAssetsPathFromBundle(bundle);
132 
133  if (assetsPath.length == 0) {
134  NSLog(@"Failed to find assets path for \"%@\"", bundle);
135  } else {
136  settings.assets_path = assetsPath.UTF8String;
137 
138  // Check if there is an application kernel snapshot in the assets directory we could
139  // potentially use. Looking for the snapshot makes sense only if we have a VM that can use
140  // it.
141  if (!flutter::DartVM::IsRunningPrecompiledCode()) {
142  NSURL* applicationKernelSnapshotURL =
143  [NSURL URLWithString:@(kApplicationKernelSnapshotFileName)
144  relativeToURL:[NSURL fileURLWithPath:assetsPath]];
145  NSError* error;
146  if ([applicationKernelSnapshotURL checkResourceIsReachableAndReturnError:&error]) {
147  settings.application_kernel_asset = applicationKernelSnapshotURL.path.UTF8String;
148  } else {
149  NSLog(@"Failed to find snapshot at %@: %@", applicationKernelSnapshotURL.path, error);
150  }
151  }
152  }
153  }
154 
155  // Domain network configuration
156  // Disabled in https://github.com/flutter/flutter/issues/72723.
157  // Re-enable in https://github.com/flutter/flutter/issues/54448.
158  settings.may_insecurely_connect_to_all_domains = true;
159  settings.domain_network_policy = "";
160 
161  // Whether to enable wide gamut colors.
162 #if TARGET_OS_SIMULATOR
163  // As of Xcode 14.1, the wide gamut surface pixel formats are not supported by
164  // the simulator.
165  settings.enable_wide_gamut = false;
166  // Removes unused function warning.
168 #else
169  NSNumber* nsEnableWideGamut = [mainBundle objectForInfoDictionaryKey:@"FLTEnableWideGamut"];
170  BOOL enableWideGamut =
171  (nsEnableWideGamut ? nsEnableWideGamut.boolValue : YES) && DoesHardwareSupportWideGamut();
172  settings.enable_wide_gamut = enableWideGamut;
173 #endif
174 
175  NSNumber* nsAntialiasLines = [mainBundle objectForInfoDictionaryKey:@"FLTAntialiasLines"];
176  settings.impeller_antialiased_lines = (nsAntialiasLines ? nsAntialiasLines.boolValue : NO);
177 
178  settings.warn_on_impeller_opt_out = true;
179 
180  NSNumber* enableTraceSystrace = [mainBundle objectForInfoDictionaryKey:@"FLTTraceSystrace"];
181  // Change the default only if the option is present.
182  if (enableTraceSystrace != nil) {
183  settings.trace_systrace = enableTraceSystrace.boolValue;
184  }
185 
186  NSNumber* profileMicrotasks = [mainBundle objectForInfoDictionaryKey:@"FLTProfileMicrotasks"];
187  // Change the default only if the option is present.
188  if (profileMicrotasks != nil) {
189  settings.profile_microtasks = profileMicrotasks.boolValue;
190  }
191 
192  NSNumber* enableDartAsserts = [mainBundle objectForInfoDictionaryKey:@"FLTEnableDartAsserts"];
193  if (enableDartAsserts != nil) {
194  settings.dart_flags.push_back("--enable-asserts");
195  }
196 
197  NSNumber* enableDartProfiling = [mainBundle objectForInfoDictionaryKey:@"FLTEnableDartProfiling"];
198  // Change the default only if the option is present.
199  if (enableDartProfiling != nil) {
200  settings.enable_dart_profiling = enableDartProfiling.boolValue;
201  }
202 
203  // Leak Dart VM settings, set whether leave or clean up the VM after the last shell shuts down.
204  NSNumber* leakDartVM = [mainBundle objectForInfoDictionaryKey:@"FLTLeakDartVM"];
205  // It will change the default leak_vm value in settings only if the key exists.
206  if (leakDartVM != nil) {
207  settings.leak_vm = leakDartVM.boolValue;
208  }
209 
210  NSNumber* enableMergedPlatformUIThread =
211  [mainBundle objectForInfoDictionaryKey:@"FLTEnableMergedPlatformUIThread"];
212  if (enableMergedPlatformUIThread != nil) {
213  settings.merged_platform_ui_thread = enableMergedPlatformUIThread.boolValue
214  ? flutter::Settings::MergedPlatformUIThread::kEnabled
215  : flutter::Settings::MergedPlatformUIThread::kDisabled;
216  }
217 
218  NSNumber* enableFlutterGPU = [mainBundle objectForInfoDictionaryKey:@"FLTEnableFlutterGPU"];
219  if (enableFlutterGPU != nil) {
220  settings.enable_flutter_gpu = enableFlutterGPU.boolValue;
221  }
222 
223 #if FLUTTER_RUNTIME_MODE == FLUTTER_RUNTIME_MODE_DEBUG
224  // There are no ownership concerns here as all mappings are owned by the
225  // embedder and not the engine.
226  auto make_mapping_callback = [](const uint8_t* mapping, size_t size) {
227  return [mapping, size]() { return std::make_unique<fml::NonOwnedMapping>(mapping, size); };
228  };
229 
230  settings.dart_library_sources_kernel =
231  make_mapping_callback(kPlatformStrongDill, kPlatformStrongDillSize);
232 #endif // FLUTTER_RUNTIME_MODE == FLUTTER_RUNTIME_MODE_DEBUG
233 
234  // If we even support setting this e.g. from the command line or the plist,
235  // we should let the user override it.
236  // Otherwise, we want to set this to a value that will avoid having the OS
237  // kill us. On most iOS devices, that happens somewhere near half
238  // the available memory.
239  // The VM expects this value to be in megabytes.
240  if (settings.old_gen_heap_size <= 0) {
241  settings.old_gen_heap_size = std::round([NSProcessInfo processInfo].physicalMemory * .48 /
242  flutter::kMegaByteSizeInBytes);
243  }
244 
245  // This is the formula Android uses.
246  // https://android.googlesource.com/platform/frameworks/base/+/39ae5bac216757bc201490f4c7b8c0f63006c6cd/libs/hwui/renderthread/CacheManager.cpp#45
247  CGFloat scale = [UIScreen mainScreen].scale;
248  CGFloat screenWidth = [UIScreen mainScreen].bounds.size.width * scale;
249  CGFloat screenHeight = [UIScreen mainScreen].bounds.size.height * scale;
250  settings.resource_cache_max_bytes_threshold = screenWidth * screenHeight * 12 * 4;
251 
252  // Whether to enable ios embedder api.
253  NSNumber* enable_embedder_api =
254  [mainBundle objectForInfoDictionaryKey:@"FLTEnableIOSEmbedderAPI"];
255  // Change the default only if the option is present.
256  if (enable_embedder_api) {
257  settings.enable_embedder_api = enable_embedder_api.boolValue;
258  }
259 
260  return settings;
261 }
262 
263 @implementation FlutterDartProject {
264  flutter::Settings _settings;
265 }
266 
267 // This property is marked unavailable on iOS in the common header.
268 // That doesn't seem to be enough to prevent this property from being synthesized.
269 // Mark dynamic to avoid warnings.
270 @dynamic dartEntrypointArguments;
271 
272 #pragma mark - Override base class designated initializers
273 
274 - (instancetype)init {
275  return [self initWithPrecompiledDartBundle:nil];
276 }
277 
278 #pragma mark - Designated initializers
279 
280 - (instancetype)initWithPrecompiledDartBundle:(nullable NSBundle*)bundle {
281  self = [super init];
282 
283  if (self) {
284  _settings = FLTDefaultSettingsForBundle(bundle);
285  }
286 
287  return self;
288 }
289 
290 - (instancetype)initWithSettings:(const flutter::Settings&)settings {
291  self = [self initWithPrecompiledDartBundle:nil];
292 
293  if (self) {
294  _settings = settings;
295  }
296 
297  return self;
298 }
299 
300 #pragma mark - PlatformData accessors
301 
302 - (const flutter::PlatformData)defaultPlatformData {
303  flutter::PlatformData PlatformData;
304  PlatformData.lifecycle_state = std::string("AppLifecycleState.detached");
305  return PlatformData;
306 }
307 
308 #pragma mark - Settings accessors
309 
310 - (const flutter::Settings&)settings {
311  return _settings;
312 }
313 
314 - (flutter::RunConfiguration)runConfiguration {
315  return [self runConfigurationForEntrypoint:nil];
316 }
317 
318 - (flutter::RunConfiguration)runConfigurationForEntrypoint:(nullable NSString*)entrypointOrNil {
319  return [self runConfigurationForEntrypoint:entrypointOrNil libraryOrNil:nil];
320 }
321 
322 - (flutter::RunConfiguration)runConfigurationForEntrypoint:(nullable NSString*)entrypointOrNil
323  libraryOrNil:(nullable NSString*)dartLibraryOrNil {
324  return [self runConfigurationForEntrypoint:entrypointOrNil
325  libraryOrNil:dartLibraryOrNil
326  entrypointArgs:nil];
327 }
328 
329 - (flutter::RunConfiguration)runConfigurationForEntrypoint:(nullable NSString*)entrypointOrNil
330  libraryOrNil:(nullable NSString*)dartLibraryOrNil
331  entrypointArgs:
332  (nullable NSArray<NSString*>*)entrypointArgs {
333  auto config = flutter::RunConfiguration::InferFromSettings(_settings);
334  if (dartLibraryOrNil && entrypointOrNil) {
335  config.SetEntrypointAndLibrary(std::string([entrypointOrNil UTF8String]),
336  std::string([dartLibraryOrNil UTF8String]));
337 
338  } else if (entrypointOrNil) {
339  config.SetEntrypoint(std::string([entrypointOrNil UTF8String]));
340  }
341 
342  if (entrypointArgs.count) {
343  std::vector<std::string> cppEntrypointArgs;
344  for (NSString* arg in entrypointArgs) {
345  cppEntrypointArgs.push_back(std::string([arg UTF8String]));
346  }
347  config.SetEntrypointArgs(std::move(cppEntrypointArgs));
348  }
349 
350  return config;
351 }
352 
353 #pragma mark - Assets-related utilities
354 
355 + (NSString*)flutterAssetsName:(NSBundle*)bundle {
356  if (bundle == nil) {
357  bundle = FLTFrameworkBundleWithIdentifier([FlutterDartProject defaultBundleIdentifier]);
358  }
359  return FLTAssetPath(bundle);
360 }
361 
362 + (NSString*)domainNetworkPolicy:(NSDictionary*)appTransportSecurity {
363  // https://developer.apple.com/documentation/bundleresources/information_property_list/nsapptransportsecurity/nsexceptiondomains
364  NSDictionary* exceptionDomains = appTransportSecurity[@"NSExceptionDomains"];
365  if (exceptionDomains == nil) {
366  return @"";
367  }
368  NSMutableArray* networkConfigArray = [[NSMutableArray alloc] init];
369  for (NSString* domain in exceptionDomains) {
370  NSDictionary* domainConfiguration = exceptionDomains[domain];
371  // Default value is false.
372  bool includesSubDomains = [domainConfiguration[@"NSIncludesSubdomains"] boolValue];
373  bool allowsCleartextCommunication =
374  [domainConfiguration[@"NSExceptionAllowsInsecureHTTPLoads"] boolValue];
375  [networkConfigArray addObject:@[
376  domain, includesSubDomains ? @YES : @NO, allowsCleartextCommunication ? @YES : @NO
377  ]];
378  }
379  NSData* jsonData = [NSJSONSerialization dataWithJSONObject:networkConfigArray
380  options:0
381  error:NULL];
382  return [[NSString alloc] initWithData:jsonData encoding:NSUTF8StringEncoding];
383 }
384 
385 + (bool)allowsArbitraryLoads:(NSDictionary*)appTransportSecurity {
386  return [appTransportSecurity[@"NSAllowsArbitraryLoads"] boolValue];
387 }
388 
389 + (NSString*)lookupKeyForAsset:(NSString*)asset {
390  return [self lookupKeyForAsset:asset fromBundle:nil];
391 }
392 
393 + (NSString*)lookupKeyForAsset:(NSString*)asset fromBundle:(nullable NSBundle*)bundle {
394  NSString* flutterAssetsName = [FlutterDartProject flutterAssetsName:bundle];
395  return [NSString stringWithFormat:@"%@/%@", flutterAssetsName, asset];
396 }
397 
398 + (NSString*)lookupKeyForAsset:(NSString*)asset fromPackage:(NSString*)package {
399  return [self lookupKeyForAsset:asset fromPackage:package fromBundle:nil];
400 }
401 
402 + (NSString*)lookupKeyForAsset:(NSString*)asset
403  fromPackage:(NSString*)package
404  fromBundle:(nullable NSBundle*)bundle {
405  return [self lookupKeyForAsset:[NSString stringWithFormat:@"packages/%@/%@", package, asset]
406  fromBundle:bundle];
407 }
408 
409 + (NSString*)defaultBundleIdentifier {
410  return @"io.flutter.flutter.app";
411 }
412 
413 - (BOOL)isWideGamutEnabled {
414  return _settings.enable_wide_gamut;
415 }
416 
417 @end
static const char * kApplicationKernelSnapshotFileName
const intptr_t kPlatformStrongDillSize
FLUTTER_ASSERT_ARC const uint8_t kPlatformStrongDill[]
flutter::Settings FLTDefaultSettingsForBundle(NSBundle *bundle, NSProcessInfo *processInfoOrNil)
static BOOL DoesHardwareSupportWideGamut()
NSString * FLTAssetPath(NSBundle *bundle)
NSBundle * FLTGetApplicationBundle()
NSBundle * FLTFrameworkBundleWithIdentifier(NSString *flutterFrameworkBundleID)
NSString * FLTAssetsPathFromBundle(NSBundle *bundle)
NSString * flutterAssetsName:(NSBundle *bundle)
fml::CommandLine CommandLineFromNSProcessInfo(NSProcessInfo *processInfoOrNil=nil)
Definition: command_line.mm:13