io.flutter.embedding.engine.deferredcomponents.PlayStoreDeferredComponentManager Class Reference

Inheritance diagram for io.flutter.embedding.engine.deferredcomponents.PlayStoreDeferredComponentManager:

Public Member Functions
	PlayStoreDeferredComponentManager ( @NonNull Context context, @Nullable FlutterJNI flutterJNI)
void	setJNI (@NonNull FlutterJNI flutterJNI)
void	setDeferredComponentChannel (@NonNull DeferredComponentChannel channel)
void	installDeferredComponent (int loadingUnitId, @Nullable String componentName)
String	getDeferredComponentInstallState (int loadingUnitId, @Nullable String componentName)
void	loadAssets (int loadingUnitId, @NonNull String componentName)
void	loadDartLibrary (int loadingUnitId, @NonNull String componentName)
boolean	uninstallDeferredComponent (int loadingUnitId, @Nullable String componentName)
void	destroy ()
Public Member Functions inherited from io.flutter.embedding.engine.deferredcomponents.DeferredComponentManager
abstract void	setJNI (FlutterJNI flutterJNI)
abstract void	setDeferredComponentChannel (DeferredComponentChannel channel)
abstract void	installDeferredComponent (int loadingUnitId, String componentName)
abstract String	getDeferredComponentInstallState (int loadingUnitId, String componentName)
abstract void	loadAssets (int loadingUnitId, String componentName)
abstract void	loadDartLibrary (int loadingUnitId, String componentName)
abstract boolean	uninstallDeferredComponent (int loadingUnitId, String componentName)

Static Public Attributes
static final String	MAPPING_KEY

Protected Attributes
SparseArray< String >	loadingUnitIdToComponentNames
SparseArray< String >	loadingUnitIdToSharedLibraryNames

Detailed Description

Flutter default implementation of DeferredComponentManager that downloads deferred component from the Google Play store as a dynamic feature module.

Definition at line 44 of file PlayStoreDeferredComponentManager.java.

Constructor & Destructor Documentation

PlayStoreDeferredComponentManager()

io.flutter.embedding.engine.deferredcomponents.PlayStoreDeferredComponentManager.PlayStoreDeferredComponentManager ( @NonNull Context  context, @Nullable FlutterJNI  flutterJNI  )

inline

Definition at line 202 of file PlayStoreDeferredComponentManager.java.

                                                                 {
    this.context = context;
    this.flutterJNI = flutterJNI;
    this.flutterApplicationInfo = ApplicationInfoLoader.load(context);
    splitInstallManager = SplitInstallManagerFactory.create(context);
    listener = new FeatureInstallStateUpdatedListener();
    splitInstallManager.registerListener(listener);
    sessionIdToName = new SparseArray<>();
    sessionIdToLoadingUnitId = new SparseIntArray();
    sessionIdToState = new SparseArray<>();
    nameToSessionId = new HashMap<>();
 
    loadingUnitIdToComponentNames = new SparseArray<>();
    loadingUnitIdToSharedLibraryNames = new SparseArray<>();
    initLoadingUnitMappingToComponentNames();
  }

Member Function Documentation

destroy()

void io.flutter.embedding.engine.deferredcomponents.PlayStoreDeferredComponentManager.destroy ( )

inline

Cleans up and releases resources. This object is no longer usable after calling this method.

Implements io.flutter.embedding.engine.deferredcomponents.DeferredComponentManager.

Definition at line 493 of file PlayStoreDeferredComponentManager.java.

                        {
    splitInstallManager.unregisterListener(listener);
    channel = null;
    flutterJNI = null;
  }

getDeferredComponentInstallState()

String io.flutter.embedding.engine.deferredcomponents.PlayStoreDeferredComponentManager.getDeferredComponentInstallState ( int  loadingUnitId, @Nullable String  componentName  )

inline

Definition at line 361 of file PlayStoreDeferredComponentManager.java.

                                                         {
    String resolvedComponentName =
        componentName != null ? componentName : loadingUnitIdToComponentNames.get(loadingUnitId);
    if (resolvedComponentName == null) {
      Log.e(
          TAG, "Deferred component name was null and could not be resolved from loading unit id.");
      return "unknown";
    }
    if (!nameToSessionId.containsKey(resolvedComponentName)) {
      if (splitInstallManager.getInstalledModules().contains(resolvedComponentName)) {
        return "installedPendingLoad";
      }
      return "unknown";
    }
    int sessionId = nameToSessionId.get(resolvedComponentName);
    return sessionIdToState.get(sessionId);
  }

installDeferredComponent()

void io.flutter.embedding.engine.deferredcomponents.PlayStoreDeferredComponentManager.installDeferredComponent ( int  loadingUnitId, @Nullable String  componentName  )

inline

Definition at line 291 of file PlayStoreDeferredComponentManager.java.

                                                                                          {
    String resolvedComponentName =
        componentName != null ? componentName : loadingUnitIdToComponentNames.get(loadingUnitId);
    if (resolvedComponentName == null) {
      Log.e(
          TAG, "Deferred component name was null and could not be resolved from loading unit id.");
      return;
    }
 
    // Handle a loading unit that is included in the base module that does not need download.
    if (resolvedComponentName.equals("") && loadingUnitId > 0) {
      // No need to load assets as base assets are already loaded.
      loadDartLibrary(loadingUnitId, resolvedComponentName);
      return;
    }
 
    SplitInstallRequest request =
        SplitInstallRequest.newBuilder().addModule(resolvedComponentName).build();
 
    splitInstallManager
        // Submits the request to install the module through the
        // asynchronous startInstall() task. Your app needs to be
        // in the foreground to submit the request.
        .startInstall(request)
        // Called when the install request is sent successfully. This is different than a successful
        // install which is handled in FeatureInstallStateUpdatedListener.
        .addOnSuccessListener(
            sessionId -> {
              sessionIdToName.put(sessionId, resolvedComponentName);
              sessionIdToLoadingUnitId.put(sessionId, loadingUnitId);
              if (nameToSessionId.containsKey(resolvedComponentName)) {
                sessionIdToState.remove(nameToSessionId.get(resolvedComponentName));
              }
              nameToSessionId.put(resolvedComponentName, sessionId);
              sessionIdToState.put(sessionId, "Requested");
            })
        .addOnFailureListener(
            exception -> {
              switch (((SplitInstallException) exception).getErrorCode()) {
                case SplitInstallErrorCode.NETWORK_ERROR:
                  flutterJNI.deferredComponentInstallFailure(
                      loadingUnitId,
                      "Install of deferred component module \""
                          + componentName
                          + "\" failed with a network error",
                      true);
                  break;
                case SplitInstallErrorCode.MODULE_UNAVAILABLE:
                  flutterJNI.deferredComponentInstallFailure(
                      loadingUnitId,
                      "Install of deferred component module \""
                          + componentName
                          + "\" failed as it is unavailable",
                      false);
                  break;
                default:
                  flutterJNI.deferredComponentInstallFailure(
                      loadingUnitId,
                      String.format(
                          "Install of deferred component module \"%s\" failed with error %d: %s",
                          componentName,
                          ((SplitInstallException) exception).getErrorCode(),
                          ((SplitInstallException) exception).getMessage()),
                      false);
                  break;
              }
            });
  }

loadAssets()

void io.flutter.embedding.engine.deferredcomponents.PlayStoreDeferredComponentManager.loadAssets ( int  loadingUnitId, @NonNull String  componentName  )

inline

Definition at line 380 of file PlayStoreDeferredComponentManager.java.

                                                                           {
    if (!verifyJNI()) {
      return;
    }
    // Since android deferred component asset manager is handled through
    // context, neither parameter is used here. Assets are stored in
    // the apk's `assets` directory allowing them to be accessed by
    // Android's AssetManager directly.
    try {
      context = context.createPackageContext(context.getPackageName(), 0);
 
      AssetManager assetManager = context.getAssets();
      flutterJNI.updateJavaAssetManager(assetManager, flutterApplicationInfo.flutterAssetsDir);
    } catch (NameNotFoundException e) {
      throw new RuntimeException(e);
    }
  }

loadDartLibrary()

void io.flutter.embedding.engine.deferredcomponents.PlayStoreDeferredComponentManager.loadDartLibrary ( int  loadingUnitId, @NonNull String  componentName  )

inline

Definition at line 398 of file PlayStoreDeferredComponentManager.java.

                                                                                {
    if (!verifyJNI()) {
      return;
    }
    // Loading unit must be specified and valid to load a dart library.
    if (loadingUnitId < 0) {
      return;
    }
 
    String aotSharedLibraryName = loadingUnitIdToSharedLibraryNames.get(loadingUnitId);
    if (aotSharedLibraryName == null) {
      // If the filename is not specified, we use dart's loading unit naming convention.
      aotSharedLibraryName =
          flutterApplicationInfo.aotSharedLibraryName + "-" + loadingUnitId + ".part.so";
    }
 
    // Possible values: armeabi, armeabi-v7a, arm64-v8a, x86, x86_64, mips, mips64
    String abi = Build.SUPPORTED_ABIS[0];
    String pathAbi = abi.replace("-", "_"); // abis are represented with underscores in paths.
 
    // TODO(garyq): Optimize this apk/file discovery process to use less i/o and be more
    // performant and robust.
 
    // Search directly in APKs first
    List<String> apkPaths = new ArrayList<>();
    // If not found in APKs, we check in extracted native libs for the lib directly.
    List<String> soPaths = new ArrayList<>();
 
    Queue<File> searchFiles = new LinkedList<>();
    // Downloaded modules are stored here
    searchFiles.add(context.getFilesDir());
    // The initial installed apks are provided by `sourceDirs` in ApplicationInfo.
    // The jniLibs we want are in the splits not the baseDir. These
    // APKs are only searched as a fallback, as base libs generally do not need
    // to be fully path referenced.
    for (String path : context.getApplicationInfo().splitSourceDirs) {
      searchFiles.add(new File(path));
    }
 
    while (!searchFiles.isEmpty()) {
      File file = searchFiles.remove();
      if (file != null && file.isDirectory() && file.listFiles() != null) {
        for (File f : file.listFiles()) {
          searchFiles.add(f);
        }
        continue;
      }
      String name = file.getName();
      // Special case for "split_config" since android base module non-master apks are
      // initially installed with the "split_config" prefix/name.
      if (name.endsWith(".apk")
          && (name.startsWith(componentName) || name.startsWith("split_config"))
          && name.contains(pathAbi)) {
        apkPaths.add(file.getAbsolutePath());
        continue;
      }
      if (name.equals(aotSharedLibraryName)) {
        soPaths.add(file.getAbsolutePath());
      }
    }
 
    List<String> searchPaths = new ArrayList<>();
 
    // Add the bare filename as the first search path. In some devices, the so
    // file can be dlopen-ed with just the file name.
    searchPaths.add(aotSharedLibraryName);
 
    for (String path : apkPaths) {
      searchPaths.add(path + "!lib/" + abi + "/" + aotSharedLibraryName);
    }
    for (String path : soPaths) {
      searchPaths.add(path);
    }
 
    flutterJNI.loadDartDeferredLibrary(
        loadingUnitId, searchPaths.toArray(new String[searchPaths.size()]));
  }

setDeferredComponentChannel()

void io.flutter.embedding.engine.deferredcomponents.PlayStoreDeferredComponentManager.setDeferredComponentChannel ( @NonNull DeferredComponentChannel  channel )

inline

Definition at line 234 of file PlayStoreDeferredComponentManager.java.

                                                                                     {
    this.channel = channel;
  }

setJNI()

void io.flutter.embedding.engine.deferredcomponents.PlayStoreDeferredComponentManager.setJNI ( @NonNull FlutterJNI  flutterJNI )

inline

Definition at line 220 of file PlayStoreDeferredComponentManager.java.

                                                     {
    this.flutterJNI = flutterJNI;
  }

uninstallDeferredComponent()

boolean io.flutter.embedding.engine.deferredcomponents.PlayStoreDeferredComponentManager.uninstallDeferredComponent ( int  loadingUnitId, @Nullable String  componentName  )

inline

Definition at line 476 of file PlayStoreDeferredComponentManager.java.

                                                                                               {
    String resolvedComponentName =
        componentName != null ? componentName : loadingUnitIdToComponentNames.get(loadingUnitId);
    if (resolvedComponentName == null) {
      Log.e(
          TAG, "Deferred component name was null and could not be resolved from loading unit id.");
      return false;
    }
    List<String> modulesToUninstall = new ArrayList<>();
    modulesToUninstall.add(resolvedComponentName);
    splitInstallManager.deferredUninstall(modulesToUninstall);
    if (nameToSessionId.get(resolvedComponentName) != null) {
      sessionIdToState.delete(nameToSessionId.get(resolvedComponentName));
    }
    return true;
  }

Member Data Documentation

loadingUnitIdToComponentNames

SparseArray<String> io.flutter.embedding.engine.deferredcomponents.PlayStoreDeferredComponentManager.loadingUnitIdToComponentNames

protected

Definition at line 62 of file PlayStoreDeferredComponentManager.java.

loadingUnitIdToSharedLibraryNames

SparseArray<String> io.flutter.embedding.engine.deferredcomponents.PlayStoreDeferredComponentManager.loadingUnitIdToSharedLibraryNames

protected

Definition at line 63 of file PlayStoreDeferredComponentManager.java.

MAPPING_KEY

final String io.flutter.embedding.engine.deferredcomponents.PlayStoreDeferredComponentManager.MAPPING_KEY

static

Initial value:

=
      DeferredComponentManager.class.getName() + ".loadingUnitMapping"

Definition at line 47 of file PlayStoreDeferredComponentManager.java.

---

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

• shell/platform/android/io/flutter/embedding/engine/deferredcomponents/PlayStoreDeferredComponentManager.java