FlutterDartProject.mm File Reference

import "flutter/shell/platform/darwin/ios/framework/Source/FlutterDartProject_Internal.h"
import <Metal/Metal.h>
import <UIKit/UIKit.h>
#include <sstream>
#include "flutter/common/constants.h"
#include "flutter/fml/build_config.h"
#include "flutter/shell/common/switches.h"
import "flutter/shell/platform/darwin/common/InternalFlutterSwiftCommon/InternalFlutterSwiftCommon.h"
#include "flutter/shell/platform/darwin/common/command_line.h"

Go to the source code of this file.

Macros
#define	FML_USED_ON_EMBEDDER

Functions
static BOOL	DoesHardwareSupportWideGamut ()
NSNumber *_Nullable	FLTEnableWideGamutFromBundle (NSBundle *_Nullable bundle, NSBundle *_Nullable mainBundle)
flutter::Settings	FLTDefaultSettingsForBundle (NSBundle *bundle, NSProcessInfo *processInfoOrNil)

Variables
FLUTTER_ASSERT_ARC const uint8_t	kPlatformStrongDill []
const intptr_t	kPlatformStrongDillSize
static const char *	kApplicationKernelSnapshotFileName = "kernel_blob.bin"

Macro Definition Documentation

FML_USED_ON_EMBEDDER

#define FML_USED_ON_EMBEDDER

Definition at line 5 of file FlutterDartProject.mm.

Function Documentation

DoesHardwareSupportWideGamut()

static BOOL DoesHardwareSupportWideGamut ( )

static

Definition at line 32 of file FlutterDartProject.mm.

                                           {
  static BOOL result = NO;
  static dispatch_once_t once_token = 0;
  dispatch_once(&once_token, ^{
    id<MTLDevice> device = MTLCreateSystemDefaultDevice();
    result = [device supportsFamily:MTLGPUFamilyApple2];
  });
  return result;
}

References device.

Referenced by FlutterDartProject::defaultBundleIdentifier.

FLTDefaultSettingsForBundle()

flutter::Settings FLTDefaultSettingsForBundle	(	NSBundle *	bundle,
		NSProcessInfo *	processInfoOrNil
	)

Definition at line 51 of file FlutterDartProject.mm.

                                                                                               {
  auto command_line = flutter::CommandLineFromNSProcessInfo(processInfoOrNil);
 
  // Precedence:
  // 1. Settings from the specified NSBundle.
  // 2. Settings passed explicitly via command-line arguments.
  // 3. Settings from the NSBundle with the default bundle ID.
  // 4. Settings from the main NSBundle and default values.
 
  NSBundle* mainBundle = FLTGetApplicationBundle();
  NSBundle* engineBundle = [NSBundle bundleForClass:[FlutterDartProject class]];
 
  bool hasExplicitBundle = bundle != nil;
  if (bundle == nil) {
    bundle = FLTFrameworkBundleWithIdentifier([FlutterDartProject defaultBundleIdentifier]);
  }
 
  auto settings = flutter::SettingsFromCommandLine(command_line, true);
 
  settings.task_observer_add = [](intptr_t key, const fml::closure& callback) {
    fml::TaskQueueId queue_id = fml::MessageLoop::GetCurrentTaskQueueId();
    fml::MessageLoopTaskQueues::GetInstance()->AddTaskObserver(queue_id, key, callback);
    return queue_id;
  };
 
  settings.task_observer_remove = [](fml::TaskQueueId queue_id, intptr_t key) {
    fml::MessageLoopTaskQueues::GetInstance()->RemoveTaskObserver(queue_id, key);
  };
 
  settings.log_message_callback = [](const std::string& tag, const std::string& message) {
    std::stringstream stream;
    if (!tag.empty()) {
      stream << tag << ": ";
    }
    stream << message;
    std::string log = stream.str();
    [FlutterLogger logDirect:[NSString stringWithUTF8String:log.c_str()]];
  };
 
  settings.enable_platform_isolates = true;
 
  // The command line arguments may not always be complete. If they aren't, attempt to fill in
  // defaults.
 
  // Flutter ships the ICU data file in the bundle of the engine. Look for it there.
  if (settings.icu_data_path.empty()) {
    NSString* icuDataPath = [engineBundle pathForResource:@"icudtl" ofType:@"dat"];
    if (icuDataPath.length > 0) {
      settings.icu_data_path = icuDataPath.UTF8String;
    }
  }
 
  if (flutter::DartVM::IsRunningPrecompiledCode()) {
    if (hasExplicitBundle) {
      NSString* executablePath = bundle.executablePath;
      if ([[NSFileManager defaultManager] fileExistsAtPath:executablePath]) {
        settings.application_library_paths.push_back(executablePath.UTF8String);
      }
    }
 
    // No application bundle specified.  Try a known location from the main bundle's Info.plist.
    if (settings.application_library_paths.empty()) {
      NSString* libraryName = [mainBundle objectForInfoDictionaryKey:@"FLTLibraryPath"];
      NSString* libraryPath = [mainBundle pathForResource:libraryName ofType:@""];
      if (libraryPath.length > 0) {
        NSString* executablePath = [NSBundle bundleWithPath:libraryPath].executablePath;
        if (executablePath.length > 0) {
          settings.application_library_paths.push_back(executablePath.UTF8String);
        }
      }
    }
 
    // In case the application bundle is still not specified, look for the App.framework in the
    // Frameworks directory.
    if (settings.application_library_paths.empty()) {
      NSString* applicationFrameworkPath = [mainBundle pathForResource:@"Frameworks/App.framework"
                                                                ofType:@""];
      if (applicationFrameworkPath.length > 0) {
        NSString* executablePath =
            [NSBundle bundleWithPath:applicationFrameworkPath].executablePath;
        if (executablePath.length > 0) {
          settings.application_library_paths.push_back(executablePath.UTF8String);
        }
      }
    }
  }
 
  // Checks to see if the flutter assets directory is already present.
  if (settings.assets_path.empty()) {
    NSString* assetsPath = FLTAssetsPathFromBundle(bundle);
 
    if (assetsPath.length == 0) {
      NSLog(@"Failed to find assets path for \"%@\"", bundle);
    } else {
      settings.assets_path = assetsPath.UTF8String;
 
      // Check if there is an application kernel snapshot in the assets directory we could
      // potentially use.  Looking for the snapshot makes sense only if we have a VM that can use
      // it.
      if (!flutter::DartVM::IsRunningPrecompiledCode()) {
        NSURL* applicationKernelSnapshotURL =
            [NSURL URLWithString:@(kApplicationKernelSnapshotFileName)
                   relativeToURL:[NSURL fileURLWithPath:assetsPath]];
        NSError* error;
        if ([applicationKernelSnapshotURL checkResourceIsReachableAndReturnError:&error]) {
          settings.application_kernel_asset = applicationKernelSnapshotURL.path.UTF8String;
        } else {
          NSLog(@"Failed to find snapshot at %@: %@", applicationKernelSnapshotURL.path, error);
        }
      }
    }
  }
 
  // Domain network configuration
  // Disabled in https://github.com/flutter/flutter/issues/72723.
  // Re-enable in https://github.com/flutter/flutter/issues/54448.
  settings.may_insecurely_connect_to_all_domains = true;
  settings.domain_network_policy = "";
 
  // Whether to enable wide gamut colors.
#if TARGET_OS_SIMULATOR
  // As of Xcode 14.1, the wide gamut surface pixel formats are not supported by
  // the simulator.
  settings.enable_wide_gamut = false;
  // Removes unused function warning.
  (void)DoesHardwareSupportWideGamut;
#else
  NSNumber* nsEnableWideGamut = FLTEnableWideGamutFromBundle(bundle, mainBundle);
  BOOL enableWideGamut =
      (nsEnableWideGamut ? nsEnableWideGamut.boolValue : YES) && DoesHardwareSupportWideGamut();
  settings.enable_wide_gamut = enableWideGamut;
#endif
 
  settings.warn_on_impeller_opt_out = true;
 
  NSNumber* nsEnableSDFs = [mainBundle objectForInfoDictionaryKey:@"FLTEnableSDFs"];
  settings.impeller_use_sdfs = (nsEnableSDFs ? nsEnableSDFs.boolValue : NO);
 
  NSNumber* enableTraceSystrace = [mainBundle objectForInfoDictionaryKey:@"FLTTraceSystrace"];
  // Change the default only if the option is present.
  if (enableTraceSystrace != nil) {
    settings.trace_systrace = enableTraceSystrace.boolValue;
  }
 
  NSNumber* profileMicrotasks = [mainBundle objectForInfoDictionaryKey:@"FLTProfileMicrotasks"];
  // Change the default only if the option is present.
  if (profileMicrotasks != nil) {
    settings.profile_microtasks = profileMicrotasks.boolValue;
  }
 
  NSNumber* enableDartAsserts = [mainBundle objectForInfoDictionaryKey:@"FLTEnableDartAsserts"];
  if (enableDartAsserts != nil) {
    settings.dart_flags.push_back("--enable-asserts");
  }
 
  NSNumber* enableDartProfiling = [mainBundle objectForInfoDictionaryKey:@"FLTEnableDartProfiling"];
  // Change the default only if the option is present.
  if (enableDartProfiling != nil) {
    settings.enable_dart_profiling = enableDartProfiling.boolValue;
  }
 
  NSNumber* profileStartup = [mainBundle objectForInfoDictionaryKey:@"FLTProfileStartup"];
  // Change the default only if the option is present.
  if (profileStartup != nil) {
    settings.profile_startup = profileStartup.boolValue;
  }
 
  // Leak Dart VM settings, set whether leave or clean up the VM after the last shell shuts down.
  NSNumber* leakDartVM = [mainBundle objectForInfoDictionaryKey:@"FLTLeakDartVM"];
  // It will change the default leak_vm value in settings only if the key exists.
  if (leakDartVM != nil) {
    settings.leak_vm = leakDartVM.boolValue;
  }
 
  NSNumber* enableMergedPlatformUIThread =
      [mainBundle objectForInfoDictionaryKey:@"FLTEnableMergedPlatformUIThread"];
  if (enableMergedPlatformUIThread != nil) {
    FML_CHECK(enableMergedPlatformUIThread.boolValue)
        << "FLTEnableMergedPlatformUIThread=false is no longer allowed.";
  }
 
  NSNumber* enableFlutterGPU = [mainBundle objectForInfoDictionaryKey:@"FLTEnableFlutterGPU"];
  if (enableFlutterGPU != nil) {
    settings.enable_flutter_gpu = enableFlutterGPU.boolValue;
  }
 
#if FLUTTER_RUNTIME_MODE == FLUTTER_RUNTIME_MODE_DEBUG
  // There are no ownership concerns here as all mappings are owned by the
  // embedder and not the engine.
  auto make_mapping_callback = [](const uint8_t* mapping, size_t size) {
    return [mapping, size]() { return std::make_unique<fml::NonOwnedMapping>(mapping, size); };
  };
 
  settings.dart_library_sources_kernel =
      make_mapping_callback(kPlatformStrongDill, kPlatformStrongDillSize);
#endif  // FLUTTER_RUNTIME_MODE == FLUTTER_RUNTIME_MODE_DEBUG
 
  // If we even support setting this e.g. from the command line or the plist,
  // we should let the user override it.
  // Otherwise, we want to set this to a value that will avoid having the OS
  // kill us. On most iOS devices, that happens somewhere near half
  // the available memory.
  // The VM expects this value to be in megabytes.
  if (settings.old_gen_heap_size <= 0) {
    settings.old_gen_heap_size = std::round([NSProcessInfo processInfo].physicalMemory * .48 /
                                            flutter::kMegaByteSizeInBytes);
  }
 
  // This is the formula Android uses.
  // https://android.googlesource.com/platform/frameworks/base/+/39ae5bac216757bc201490f4c7b8c0f63006c6cd/libs/hwui/renderthread/CacheManager.cpp#45
  CGFloat scale = [UIScreen mainScreen].scale;
  CGFloat screenWidth = [UIScreen mainScreen].bounds.size.width * scale;
  CGFloat screenHeight = [UIScreen mainScreen].bounds.size.height * scale;
  settings.resource_cache_max_bytes_threshold = screenWidth * screenHeight * 12 * 4;
 
  // Whether to enable ios embedder api.
  NSNumber* enable_embedder_api =
      [mainBundle objectForInfoDictionaryKey:@"FLTEnableIOSEmbedderAPI"];
  // Change the default only if the option is present.
  if (enable_embedder_api) {
    settings.enable_embedder_api = enable_embedder_api.boolValue;
  }
 
  return settings;
}

FLTEnableWideGamutFromBundle()

NSNumber *_Nullable FLTEnableWideGamutFromBundle	(	NSBundle *_Nullable	bundle,
		NSBundle *_Nullable	mainBundle
	)

Returns the value of the FLTEnableWideGamut key from the given bundle, falling back to the main bundle if not found in the first. If both bundles are the same object, the value is read once.

Definition at line 42 of file FlutterDartProject.mm.

                                                                                 {
  NSNumber* nsEnableWideGamut = [bundle objectForInfoDictionaryKey:@"FLTEnableWideGamut"];
  if (nsEnableWideGamut == nil && bundle != mainBundle) {
    nsEnableWideGamut = [mainBundle objectForInfoDictionaryKey:@"FLTEnableWideGamut"];
  }
  return nsEnableWideGamut;
}

Referenced by FlutterDartProject::defaultBundleIdentifier.

Variable Documentation

kApplicationKernelSnapshotFileName

const char* kApplicationKernelSnapshotFileName = "kernel_blob.bin"

static

Definition at line 30 of file FlutterDartProject.mm.

Referenced by FlutterDartProject::defaultBundleIdentifier, and FlutterEngineInitialize().

kPlatformStrongDill

FLUTTER_ASSERT_ARC const uint8_t kPlatformStrongDill[]

extern

Referenced by FlutterDartProject::defaultBundleIdentifier.

kPlatformStrongDillSize

const intptr_t kPlatformStrongDillSize

extern

Referenced by FlutterDartProject::defaultBundleIdentifier.