io.flutter.embedding.engine.loader.FlutterLoader Class Reference

Classes
class	Settings

Public Member Functions
	FlutterLoader ()
	FlutterLoader (@NonNull FlutterJNI flutterJNI)
	FlutterLoader (@NonNull FlutterJNI flutterJNI, @NonNull ExecutorService executorService)
void	startInitialization (@NonNull Context applicationContext)
void	startInitialization (@NonNull Context applicationContext, @NonNull Settings settings)
void	ensureInitializationComplete ( @NonNull Context applicationContext, @Nullable String[] args)
void	ensureInitializationCompleteAsync ( @NonNull Context applicationContext, @Nullable String[] args, @NonNull Handler callbackHandler, @NonNull Runnable callback)
boolean	initialized ()
String	findAppBundlePath ()
String	getLookupKeyForAsset (@NonNull String asset)
String	getLookupKeyForAsset (@NonNull String asset, @NonNull String packageName)
boolean	automaticallyRegisterPlugins ()

Package Attributes
Future< InitResult >	initResultFuture

Static Package Attributes
static final String	AOT_SHARED_LIBRARY_NAME = "aot-shared-library-name"
static final String	AOT_VMSERVICE_SHARED_LIBRARY_NAME = "aot-vmservice-shared-library-name"
static final String	SNAPSHOT_ASSET_PATH_KEY = "snapshot-asset-path"
static final String	VM_SNAPSHOT_DATA_KEY = "vm-snapshot-data"
static final String	ISOLATE_SNAPSHOT_DATA_KEY = "isolate-snapshot-data"
static final String	FLUTTER_ASSETS_DIR_KEY = "flutter-assets-dir"
static final String	AUTOMATICALLY_REGISTER_PLUGINS_KEY = "automatically-register-plugins"

Detailed Description

Finds Flutter resources in an application APK and also loads Flutter's native library.

Definition at line 35 of file FlutterLoader.java.

Constructor & Destructor Documentation

FlutterLoader() [1/3]

io.flutter.embedding.engine.loader.FlutterLoader.FlutterLoader ( )

inline

Creates a FlutterLoader that uses a default constructed FlutterJNI and ExecutorService.

Definition at line 84 of file FlutterLoader.java.

                         {
    this(FlutterInjector.instance().getFlutterJNIFactory().provideFlutterJNI());
  }

FlutterLoader() [2/3]

io.flutter.embedding.engine.loader.FlutterLoader.FlutterLoader ( @NonNull FlutterJNI  flutterJNI )

inline

Creates a FlutterLoader that uses a default constructed ExecutorService.

Parameters

flutterJNI

The FlutterJNI instance to use for loading the libflutter.so C++ library, setting up the font manager, and calling into C++ initialization.

Definition at line 94 of file FlutterLoader.java.

                                                       {
    this(flutterJNI, FlutterInjector.instance().executorService());
  }

FlutterLoader() [3/3]

io.flutter.embedding.engine.loader.FlutterLoader.FlutterLoader ( @NonNull FlutterJNI  flutterJNI, @NonNull ExecutorService  executorService  )

inline

Creates a FlutterLoader with the specified FlutterJNI.

Parameters

flutterJNI	The FlutterJNI instance to use for loading the libflutter.so C++ library, setting up the font manager, and calling into C++ initialization.
executorService	The ExecutorService to use when creating new threads.

Definition at line 105 of file FlutterLoader.java.

                                                                                                 {
    this.flutterJNI = flutterJNI;
    this.executorService = executorService;
  }

Member Function Documentation

automaticallyRegisterPlugins()

boolean io.flutter.embedding.engine.loader.FlutterLoader.automaticallyRegisterPlugins ( )

inline

Returns the configuration on whether flutter engine should automatically register plugins.

Definition at line 489 of file FlutterLoader.java.

                                                {
    return flutterApplicationInfo.automaticallyRegisterPlugins;
  }

ensureInitializationComplete()

void io.flutter.embedding.engine.loader.FlutterLoader.ensureInitializationComplete ( @NonNull Context  applicationContext, @Nullable String[]  args  )

inline

Blocks until initialization of the native system has completed.

Calling this method multiple times has no effect.

Parameters

applicationContext	The Android application context.
args	Flags sent to the Flutter runtime.

Definition at line 245 of file FlutterLoader.java.

                                                                    {
    if (initialized) {
      return;
    }
    if (Looper.myLooper() != Looper.getMainLooper()) {
      throw new IllegalStateException(
          "ensureInitializationComplete must be called on the main thread");
    }
    if (settings == null) {
      throw new IllegalStateException(
          "ensureInitializationComplete must be called after startInitialization");
    }
 
    try (TraceSection e = TraceSection.scoped("FlutterLoader#ensureInitializationComplete")) {
      InitResult result = initResultFuture.get();
 
      List<String> shellArgs = new ArrayList<>();
      shellArgs.add("--icu-symbol-prefix=_binary_icudtl_dat");
 
      shellArgs.add(
          "--icu-native-lib-path="
              + flutterApplicationInfo.nativeLibraryDir
              + File.separator
              + DEFAULT_LIBRARY);
      if (args != null) {
        Collections.addAll(shellArgs, args);
      }
 
      String kernelPath = null;
      if (BuildConfig.DEBUG || BuildConfig.JIT_RELEASE) {
        String snapshotAssetPath =
            result.dataDirPath + File.separator + flutterApplicationInfo.flutterAssetsDir;
        kernelPath = snapshotAssetPath + File.separator + DEFAULT_KERNEL_BLOB;
        shellArgs.add("--" + SNAPSHOT_ASSET_PATH_KEY + "=" + snapshotAssetPath);
        shellArgs.add("--" + VM_SNAPSHOT_DATA_KEY + "=" + flutterApplicationInfo.vmSnapshotData);
        shellArgs.add(
            "--" + ISOLATE_SNAPSHOT_DATA_KEY + "=" + flutterApplicationInfo.isolateSnapshotData);
      } else {
        shellArgs.add(
            "--" + AOT_SHARED_LIBRARY_NAME + "=" + flutterApplicationInfo.aotSharedLibraryName);
 
        // Most devices can load the AOT shared library based on the library name
        // with no directory path.  Provide a fully qualified path to the library
        // as a workaround for devices where that fails.
        shellArgs.add(
            "--"
                + AOT_SHARED_LIBRARY_NAME
                + "="
                + flutterApplicationInfo.nativeLibraryDir
                + File.separator
                + flutterApplicationInfo.aotSharedLibraryName);
 
        // In profile mode, provide a separate library containing a snapshot for
        // launching the Dart VM service isolate.
        if (BuildConfig.PROFILE) {
          shellArgs.add(
              "--" + AOT_VMSERVICE_SHARED_LIBRARY_NAME + "=" + VMSERVICE_SNAPSHOT_LIBRARY);
        }
      }
 
      shellArgs.add("--cache-dir-path=" + result.engineCachesPath);
      if (flutterApplicationInfo.domainNetworkPolicy != null) {
        shellArgs.add("--domain-network-policy=" + flutterApplicationInfo.domainNetworkPolicy);
      }
      if (settings.getLogTag() != null) {
        shellArgs.add("--log-tag=" + settings.getLogTag());
      }
 
      ApplicationInfo applicationInfo =
          applicationContext
              .getPackageManager()
              .getApplicationInfo(
                  applicationContext.getPackageName(), PackageManager.GET_META_DATA);
      Bundle metaData = applicationInfo.metaData;
      int oldGenHeapSizeMegaBytes =
          metaData != null ? metaData.getInt(OLD_GEN_HEAP_SIZE_META_DATA_KEY) : 0;
      if (oldGenHeapSizeMegaBytes == 0) {
        // default to half of total memory.
        ActivityManager activityManager =
            (ActivityManager) applicationContext.getSystemService(Context.ACTIVITY_SERVICE);
        ActivityManager.MemoryInfo memInfo = new ActivityManager.MemoryInfo();
        activityManager.getMemoryInfo(memInfo);
        oldGenHeapSizeMegaBytes = (int) (memInfo.totalMem / 1e6 / 2);
      }
      shellArgs.add("--old-gen-heap-size=" + oldGenHeapSizeMegaBytes);
 
      DisplayMetrics displayMetrics = applicationContext.getResources().getDisplayMetrics();
      int screenWidth = displayMetrics.widthPixels;
      int screenHeight = displayMetrics.heightPixels;
      // This is the formula Android uses.
      // https://android.googlesource.com/platform/frameworks/base/+/39ae5bac216757bc201490f4c7b8c0f63006c6cd/libs/hwui/renderthread/CacheManager.cpp#45
      int resourceCacheMaxBytesThreshold = screenWidth * screenHeight * 12 * 4;
      shellArgs.add("--resource-cache-max-bytes-threshold=" + resourceCacheMaxBytesThreshold);
 
      shellArgs.add("--prefetched-default-font-manager");
 
      if (metaData != null) {
        if (metaData.getBoolean(ENABLE_IMPELLER_META_DATA_KEY, false)) {
          shellArgs.add("--enable-impeller");
        }
        if (metaData.getBoolean(ENABLE_VULKAN_VALIDATION_META_DATA_KEY, false)) {
          shellArgs.add("--enable-vulkan-validation");
        }
        if (metaData.getBoolean(IMPELLER_OPENGL_GPU_TRACING_DATA_KEY, false)) {
          shellArgs.add("--enable-opengl-gpu-tracing");
        }
        if (metaData.getBoolean(IMPELLER_VULKAN_GPU_TRACING_DATA_KEY, false)) {
          shellArgs.add("--enable-vulkan-gpu-tracing");
        }
        String backend = metaData.getString(IMPELLER_BACKEND_META_DATA_KEY);
        if (backend != null) {
          shellArgs.add("--impeller-backend=" + backend);
        }
      }
 
      final String leakVM = isLeakVM(metaData) ? "true" : "false";
      shellArgs.add("--leak-vm=" + leakVM);
 
      long initTimeMillis = SystemClock.uptimeMillis() - initStartTimestampMillis;
 
      flutterJNI.init(
          applicationContext,
          shellArgs.toArray(new String[0]),
          kernelPath,
          result.appStoragePath,
          result.engineCachesPath,
          initTimeMillis);
 
      initialized = true;
    } catch (Exception e) {
      Log.e(TAG, "Flutter initialization failed.", e);
      throw new RuntimeException(e);
    }
  }

ensureInitializationCompleteAsync()

void io.flutter.embedding.engine.loader.FlutterLoader.ensureInitializationCompleteAsync ( @NonNull Context  applicationContext, @Nullable String[]  args, @NonNull Handler  callbackHandler, @NonNull Runnable  callback  )

inline

Same as ensureInitializationComplete(Context, String[]) but waiting on a background thread, then invoking callback on the callbackHandler.

Definition at line 393 of file FlutterLoader.java.

                                  {
    if (Looper.myLooper() != Looper.getMainLooper()) {
      throw new IllegalStateException(
          "ensureInitializationComplete must be called on the main thread");
    }
    if (settings == null) {
      throw new IllegalStateException(
          "ensureInitializationComplete must be called after startInitialization");
    }
    if (initialized) {
      callbackHandler.post(callback);
      return;
    }
    executorService.execute(
        () -> {
          InitResult result;
          try {
            result = initResultFuture.get();
          } catch (Exception e) {
            Log.e(TAG, "Flutter initialization failed.", e);
            throw new RuntimeException(e);
          }
          HandlerCompat.createAsyncHandler(Looper.getMainLooper())
              .post(
                  () -> {
                    ensureInitializationComplete(applicationContext.getApplicationContext(), args);
                    callbackHandler.post(callback);
                  });
        });
  }

findAppBundlePath()

String io.flutter.embedding.engine.loader.FlutterLoader.findAppBundlePath ( )

inline

Definition at line 457 of file FlutterLoader.java.

                                    {
    return flutterApplicationInfo.flutterAssetsDir;
  }

getLookupKeyForAsset() [1/2]

String io.flutter.embedding.engine.loader.FlutterLoader.getLookupKeyForAsset ( @NonNull String  asset )

inline

Returns the file name for the given asset. The returned file name can be used to access the asset in the APK through the android.content.res.AssetManager API.

Parameters

asset

the name of the asset. The name can be hierarchical

Returns

the filename to be used with android.content.res.AssetManager

Definition at line 469 of file FlutterLoader.java.

                                                            {
    return fullAssetPathFrom(asset);
  }

getLookupKeyForAsset() [2/2]

String io.flutter.embedding.engine.loader.FlutterLoader.getLookupKeyForAsset ( @NonNull String  asset, @NonNull String  packageName  )

inline

Returns the file name for the given asset which originates from the specified packageName. The returned file name can be used to access the asset in the APK through the android.content.res.AssetManager API.

Parameters

asset	the name of the asset. The name can be hierarchical
packageName	the name of the package from which the asset originates

Returns

the file name to be used with android.content.res.AssetManager

Definition at line 483 of file FlutterLoader.java.

                                                                                         {
    return getLookupKeyForAsset("packages" + File.separator + packageName + File.separator + asset);
  }

initialized()

boolean io.flutter.embedding.engine.loader.FlutterLoader.initialized ( )

inline

Returns whether the FlutterLoader has finished loading the native library.

Definition at line 429 of file FlutterLoader.java.

                               {
    return initialized;
  }

startInitialization() [1/2]

void io.flutter.embedding.engine.loader.FlutterLoader.startInitialization ( @NonNull Context  applicationContext )

inline

Starts initialization of the native system.

Parameters

applicationContext

The Android application context.

Definition at line 136 of file FlutterLoader.java.

                                                                       {
    startInitialization(applicationContext, new Settings());
  }

startInitialization() [2/2]

void io.flutter.embedding.engine.loader.FlutterLoader.startInitialization ( @NonNull Context  applicationContext, @NonNull Settings  settings  )

inline

Starts initialization of the native system.

This loads the Flutter engine's native library to enable subsequent JNI calls. This also starts locating and unpacking Dart resources packaged in the app's APK.

Calling this method multiple times has no effect.

Parameters

applicationContext	The Android application context.
settings	Configuration settings.

Definition at line 151 of file FlutterLoader.java.

                                                                                                   {
    // Do not run startInitialization more than once.
    if (this.settings != null) {
      return;
    }
    if (Looper.myLooper() != Looper.getMainLooper()) {
      throw new IllegalStateException("startInitialization must be called on the main thread");
    }
 
    try (TraceSection e = TraceSection.scoped("FlutterLoader#startInitialization")) {
      // Ensure that the context is actually the application context.
      final Context appContext = applicationContext.getApplicationContext();
 
      this.settings = settings;
 
      initStartTimestampMillis = SystemClock.uptimeMillis();
      flutterApplicationInfo = ApplicationInfoLoader.load(appContext);
 
      final DisplayManager dm =
          (DisplayManager) appContext.getSystemService(Context.DISPLAY_SERVICE);
      VsyncWaiter waiter = VsyncWaiter.getInstance(dm, flutterJNI);
      waiter.init();
 
      // Use a background thread for initialization tasks that require disk access.
      Callable<InitResult> initTask =
          new Callable<InitResult>() {
            @Override
            public InitResult call() {
              try (TraceSection e = TraceSection.scoped("FlutterLoader initTask")) {
                ResourceExtractor resourceExtractor = initResources(appContext);
 
                try {
                  flutterJNI.loadLibrary();
                } catch (UnsatisfiedLinkError unsatisfiedLinkError) {
                  String couldntFindVersion = "couldn't find \"libflutter.so\"";
                  String notFoundVersion = "dlopen failed: library \"libflutter.so\" not found";
 
                  if (unsatisfiedLinkError.toString().contains(couldntFindVersion)
                      || unsatisfiedLinkError.toString().contains(notFoundVersion)) {
                    // To gather more information for
                    // https://github.com/flutter/flutter/issues/144291,
                    // log the contents of the native libraries directory as well as the
                    // cpu architecture.
 
                    String cpuArch = System.getProperty("os.arch");
                    File nativeLibsDir = new File(flutterApplicationInfo.nativeLibraryDir);
                    String[] nativeLibsContents = nativeLibsDir.list();
 
                    throw new UnsupportedOperationException(
                        "Could not load libflutter.so this is possibly because the application"
                            + " is running on an architecture that Flutter Android does not support (e.g. x86)"
                            + " see https://docs.flutter.dev/deployment/android#what-are-the-supported-target-architectures"
                            + " for more detail.\n"
                            + "App is using cpu architecture: "
                            + cpuArch
                            + ", and the native libraries directory (with path "
                            + nativeLibsDir.getAbsolutePath()
                            + ") contains the following files: "
                            + Arrays.toString(nativeLibsContents),
                        unsatisfiedLinkError);
                  }
 
                  throw unsatisfiedLinkError;
                }
 
                flutterJNI.updateRefreshRate();
 
                // Prefetch the default font manager as soon as possible on a background thread.
                // It helps to reduce time cost of engine setup that blocks the platform thread.
                executorService.execute(() -> flutterJNI.prefetchDefaultFontManager());
 
                if (resourceExtractor != null) {
                  resourceExtractor.waitForCompletion();
                }
 
                return new InitResult(
                    PathUtils.getFilesDir(appContext),
                    PathUtils.getCacheDirectory(appContext),
                    PathUtils.getDataDirectory(appContext));
              }
            }
          };
      initResultFuture = executorService.submit(initTask);
    }
  }

Member Data Documentation

AOT_SHARED_LIBRARY_NAME

final String io.flutter.embedding.engine.loader.FlutterLoader.AOT_SHARED_LIBRARY_NAME = "aot-shared-library-name"

staticpackage

Definition at line 65 of file FlutterLoader.java.

AOT_VMSERVICE_SHARED_LIBRARY_NAME

final String io.flutter.embedding.engine.loader.FlutterLoader.AOT_VMSERVICE_SHARED_LIBRARY_NAME = "aot-vmservice-shared-library-name"

staticpackage

Definition at line 66 of file FlutterLoader.java.

AUTOMATICALLY_REGISTER_PLUGINS_KEY

final String io.flutter.embedding.engine.loader.FlutterLoader.AUTOMATICALLY_REGISTER_PLUGINS_KEY = "automatically-register-plugins"

staticpackage

Definition at line 71 of file FlutterLoader.java.

FLUTTER_ASSETS_DIR_KEY

final String io.flutter.embedding.engine.loader.FlutterLoader.FLUTTER_ASSETS_DIR_KEY = "flutter-assets-dir"

staticpackage

Definition at line 70 of file FlutterLoader.java.

initResultFuture

Future<InitResult> io.flutter.embedding.engine.loader.FlutterLoader.initResultFuture

package

Definition at line 129 of file FlutterLoader.java.

ISOLATE_SNAPSHOT_DATA_KEY

final String io.flutter.embedding.engine.loader.FlutterLoader.ISOLATE_SNAPSHOT_DATA_KEY = "isolate-snapshot-data"

staticpackage

Definition at line 69 of file FlutterLoader.java.

SNAPSHOT_ASSET_PATH_KEY

final String io.flutter.embedding.engine.loader.FlutterLoader.SNAPSHOT_ASSET_PATH_KEY = "snapshot-asset-path"

staticpackage

Definition at line 67 of file FlutterLoader.java.

VM_SNAPSHOT_DATA_KEY

final String io.flutter.embedding.engine.loader.FlutterLoader.VM_SNAPSHOT_DATA_KEY = "vm-snapshot-data"

staticpackage

Definition at line 68 of file FlutterLoader.java.

---

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

• shell/platform/android/io/flutter/embedding/engine/loader/FlutterLoader.java