Flutter 动态化新知识

flutter:
  deferred-components:
    - name: crane
      libraries:
        # Only one library from the loading unit is necessary.
        - package:gallery/studies/crane/app.dart
      assets:
        - packages/flutter_gallery_assets/crane/destinations/eat_1.jpg
        - packages/flutter_gallery_assets/crane/destinations/eat_2.jpg
        ......

Path(
  r'^' + crane_routes.defaultRoute,
  (context, match) => StudyWrapper(
    study: DeferredWidget(crane.loadLibrary,
        () => crane.CraneApp(), // ignore: prefer_const_constructors
        placeholder: DeferredLoadingPlaceholder(name: 'Crane')),
  ),
),

import 'package:gallery/studies/crane/app.dart' deferred as crane;
import 'package:gallery/studies/crane/routes.dart' as crane_routes;
import 'package:gallery/studies/fortnightly/app.dart' deferred as fortnightly;
import 'package:gallery/studies/fortnightly/routes.dart' as fortnightly_routes;
import 'package:gallery/studies/rally/app.dart' deferred as rally;
import 'package:gallery/studies/rally/routes.dart' as rally_routes;
import 'package:gallery/studies/reply/app.dart' as reply;
import 'package:gallery/studies/reply/routes.dart' as reply_routes;
import 'package:gallery/studies/shrine/app.dart' deferred as shrine;

<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:dist="http://schemas.android.com/apk/distribution"
    package="com.example.gallery.crane">

    <dist:module
        dist:instant="false"
        dist:title="@string/craneName">
        <dist:delivery>
            <dist:on-demand />
        </dist:delivery>
        <dist:fusing dist:include="true" />
    </dist:module>
</manifest>

<application
    android:label="Flutter Gallery"
    android:name="io.flutter.app.FlutterPlayStoreSplitApplication"
    android:icon="@mipmap/ic_launcher">
 ......
 <meta-data android:name="io.flutter.embedding.engine.deferredcomponents.DeferredComponentManager.loadingUnitMapping" android:value="2:crane,3:,4:,5:,6:,7:,8:,9:,10:,11:"/>
</application>

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

private void initLoadingUnitMappingToComponentNames() {
  String mappingKey = DeferredComponentManager.class.getName() + ".loadingUnitMapping";
  ApplicationInfo applicationInfo = getApplicationInfo();
  if (applicationInfo != null) {
    Bundle metaData = applicationInfo.metaData;
    if (metaData != null) {
      String rawMappingString = metaData.getString(MAPPING_KEY, null);
      if (rawMappingString == null) {
        Log.e(
            TAG,
            "No loading unit to dynamic feature module name found. Ensure '"
                + MAPPING_KEY
                + "' is defined in the base module's AndroidManifest.");
      } else {
        for (String entry : rawMappingString.split(",")) {
          // Split with -1 param to include empty string following trailing ":"
          String[] splitEntry = entry.split(":", -1);
          int loadingUnitId = Integer.parseInt(splitEntry[0]);
          loadingUnitIdToComponentNames.put(loadingUnitId, splitEntry[1]);
          if (splitEntry.length > 2) {
            loadingUnitIdToSharedLibraryNames.put(loadingUnitId, splitEntry[2]);
          }
        }
      }
    }
  }
}

public void installDeferredComponent(int loadingUnitId, String componentName) {
  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)
   ......

public void loadDartLibrary(int loadingUnitId, String componentName) {
 ......

  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;
  if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
    abi = Build.SUPPORTED_ABIS[0];
  } else {
    abi = Build.CPU_ABI;
  }
  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<>();
  searchFiles.add(context.getFilesDir());
  while (!searchFiles.isEmpty()) {
    File file = searchFiles.remove();
    if (file != null && file.isDirectory()) {
      for (File f : file.listFiles()) {
        searchFiles.add(f);
      }
      continue;
    }
    String name = file.getName();
    if (name.endsWith(".apk") && name.startsWith(componentName) && 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[apkPaths.size()]));
}

void _validateFlutter(YamlMap? yaml, List<String> errors) {
  if (yaml == null || yaml.entries == null) {
    return;
  }
  for (final MapEntry<Object?, Object?> kvp in yaml.entries) {
    final Object? yamlKey = kvp.key;
    final Object? yamlValue = kvp.value;
    if (yamlKey is! String) {
      errors.add('Expected YAML key to be a string, but got $yamlKey (${yamlValue.runtimeType}).');
      continue;
    }
    switch (yamlKey) {
   ......
      case 'deferred-components':
        _validateDeferredComponents(kvp, errors);
        break;

/// Returns the deferred components configuration if declared. Returns
  /// null if no deferred components are declared.
  late final List<DeferredComponent>? deferredComponents = computeDeferredComponents();
  List<DeferredComponent>? computeDeferredComponents() {
    if (!_flutterDescriptor.containsKey('deferred-components')) {
      return null;
    }
    final List<DeferredComponent> components = <DeferredComponent>[];
    final Object? deferredComponents = _flutterDescriptor['deferred-components'];
    if (deferredComponents is! YamlList) {
      return components;
    }
    for (final Object? component in deferredComponents) {
      if (component is! YamlMap) {
        _logger.printError('Expected deferred component manifest to be a map.');
        continue;
      }
      List<Uri> assetsUri = <Uri>[];
      final List<Object?>? assets = component['assets'] as List<Object?>?;
      if (assets == null) {
        assetsUri = const <Uri>[];
      } else {
        for (final Object? asset in assets) {
          if (asset is! String || asset == null || asset == '') {
            _logger.printError('Deferred component asset manifest contains a null or empty uri.');
            continue;
          }
          try {
            assetsUri.add(Uri.parse(asset));
          } on FormatException {
            _logger.printError('Asset manifest contains invalid uri: $asset.');
          }
        }
      }
      components.add(
        DeferredComponent(
          name: component['name'] as String,
          libraries: component['libraries'] == null ?
              <String>[] : component['libraries'].cast<String>() as List<String>,
          assets: assetsUri,
        )
      );
    }
    return components;
  }

//lib/src/android/gradle.dart
Future<void> buildGradleApp({
  @required FlutterProject project,
  @required AndroidBuildInfo androidBuildInfo,
  @required String target,
  @required bool isBuildingBundle,
  @required List<GradleHandledError> localGradleErrors,
  bool shouldBuildPluginAsAar = false,
  bool validateDeferredComponents = true,
  bool deferredComponentsEnabled = false,
  int retries = 1,
}) async {
  ......
  if (project.manifest.deferredComponents != null) {
      if (deferredComponentsEnabled) {
        command.add('-Pdeferred-components=true');
        androidBuildInfo.buildInfo.dartDefines.add('validate-deferred-components=$validateDeferredComponents');
      }
      // Pass in deferred components regardless of building split aot to satisfy
      // android dynamic features registry in build.gradle.
      final List<String> componentNames = <String>[];
      for (final DeferredComponent component in project.manifest.deferredComponents) {
        componentNames.add(component.name);
      }
      if (componentNames.isNotEmpty) {
        command.add('-Pdeferred-component-names=${componentNames.join(',')}');
        // Multi-apk applications cannot use shrinking. This is only relevant when using
        // android dynamic feature modules.
        _logger.printStatus(
          'Shrinking has been disabled for this build due to deferred components. Shrinking is '
          'not available for multi-apk applications. This limitation is expected to be removed '
          'when Gradle plugin 4.2+ is available in Flutter.', color: TerminalColor.yellow);
        command.add('-Pshrink=false');
      }
    }
  ......
}

//lib/src/android/gradle.dart
@override
Future<void> buildAab({
  @required FlutterProject project,
  @required AndroidBuildInfo androidBuildInfo,
  @required String target,
  bool validateDeferredComponents = true,
  bool deferredComponentsEnabled = false,
}) async {
  await buildGradleApp(
    project: project,
    androidBuildInfo: androidBuildInfo,
    target: target,
    isBuildingBundle: true,
    localGradleErrors: gradleErrors,
    validateDeferredComponents: validateDeferredComponents,
    deferredComponentsEnabled: deferredComponentsEnabled,
  );
}

//lib/src/commands/build_appbundle.dart
class BuildAppBundleCommand extends BuildSubCommand {
  BuildAppBundleCommand({bool verboseHelp = false}) {
    ......
    argParser.addFlag('deferred-components',
      negatable: true,
      defaultsTo: true,
         help: '......'
    );
    argParser.addFlag('validate-deferred-components',
      negatable: true,
      defaultsTo: true,
         help: '......'
    );

@override
Future<FlutterCommandResult> runCommand() async {

   ......

  if (FlutterProject.current().manifest.deferredComponents != null && boolArg('deferred-components') && boolArg('validate-deferred-components') && !boolArg('debug')) {
    final DeferredComponentsPrebuildValidator validator = DeferredComponentsPrebuildValidator(
      FlutterProject.current().directory,
      globals.logger,
      globals.platform,
      title: 'Deferred components prebuild validation',
      exitOnFail: true,
    );
    validator.clearOutputDir();
    await validator.checkAndroidDynamicFeature(FlutterProject.current().manifest.deferredComponents);
    validator.checkAndroidResourcesStrings(FlutterProject.current().manifest.deferredComponents);

    validator.handleResults();

    // Delete intermediates libs dir for components to resolve mismatching
    // abis supported by base and dynamic feature modules.
    for (final DeferredComponent component in FlutterProject.current().manifest.deferredComponents) {
      final Directory deferredLibsIntermediate = FlutterProject.current().directory
        .childDirectory('build')
        .childDirectory(component.name)
        .childDirectory('intermediates')
        .childDirectory('flutter')
        .childDirectory(androidBuildInfo.buildInfo.mode.name)
        .childDirectory('deferred_libs');
      if (deferredLibsIntermediate.existsSync()) {
        deferredLibsIntermediate.deleteSync(recursive: true);
      }
    }
  }

   ......

   await androidBuilder.buildAab(
      project: FlutterProject.current(),
      target: targetFile,
      androidBuildInfo: androidBuildInfo,
      validateDeferredComponents: boolArg('validate-deferred-components'),
      deferredComponentsEnabled: boolArg('deferred-components') && !boolArg('debug'),
    );
    return FlutterCommandResult.success();

@override
Future<FlutterCommandResult> runCommand() async {
  final List<Target> targets = createTargets();
  final List<Target> nonDeferredTargets = <Target>[];
  final List<Target> deferredTargets = <AndroidAotDeferredComponentsBundle>[];
  for (final Target target in targets) {
    if (deferredComponentsTargets.contains(target.name)) {
      deferredTargets.add(target);
    } else {
      nonDeferredTargets.add(target);
    }
  }

  ......

  if (FlutterProject.current().manifest.deferredComponents != null
        && decodedDefines.contains('validate-deferred-components=true')
        && deferredTargets.isNotEmpty
        && !isDebug()) {
      // Add deferred components validation target that require loading units.
      target = DeferredComponentsGenSnapshotValidatorTarget(
        deferredComponentsDependencies: deferredTargets.cast<AndroidAotDeferredComponentsBundle>(),
        nonDeferredComponentsDependencies: nonDeferredTargets,
        title: 'Deferred components gen_snapshot validation',
      );
    }
}

// lib/src/commands/assemble.dart
List<Target> _kDefaultTargets = <Target>[
  ......
  androidArmProfileDeferredComponentsBundle,
  androidArm64ProfileDeferredComponentsBundle,
  androidx64ProfileDeferredComponentsBundle,
  androidArmReleaseDeferredComponentsBundle,
  androidArm64ReleaseDeferredComponentsBundle,
  androidx64ReleaseDeferredComponentsBundle,
  ......

AndroidAotDeferredComponentsBundle -> AndroidAotBundle -> AndroidAot

@override
Future<void> build(Environment environment) async {
  final AOTSnapshotter snapshotter = AOTSnapshotter(
    reportTimings: false,
    fileSystem: environment.fileSystem,
    logger: environment.logger,
    xcode: globals.xcode,
    processManager: environment.processManager,
    artifacts: environment.artifacts,
  );
 ......
  if (environment.defines[kDeferredComponents] == 'true') {
    extraGenSnapshotOptions.add('--loading_unit_manifest=$manifestPath');
    outputs.add(environment.fileSystem.file(manifestPath));
  }
 ......

~/gallery/build/app/intermediates/flutter/release/armeabi-v7a/manifest.json

// engine/src/third_party/dart/runtime/gen_snapshot.cc
static void CreateAndWritePrecompiledSnapshot() {
 ......
 if (snapshot_kind == kAppAOTElf) {
    if (strip && (debugging_info_filename == nullptr)) {
      Syslog::PrintErr(
          "Warning: Generating ELF library without DWARF debugging"
          " information.\n");
    }
    if (loading_unit_manifest_filename == nullptr) {
      File* file = OpenFile(elf_filename);
      RefCntReleaseScope<File> rs(file);
      File* debug_file = nullptr;
      if (debugging_info_filename != nullptr) {
        debug_file = OpenFile(debugging_info_filename);
      }
      result = Dart_CreateAppAOTSnapshotAsElf(StreamingWriteCallback, file,
                                              strip, debug_file);
      if (debug_file != nullptr) debug_file->Release();
      CHECK_RESULT(result);
    } else {
      File* manifest_file = OpenLoadingUnitManifest();
      result = Dart_CreateAppAOTSnapshotAsElfs(NextElfCallback, manifest_file,
                                               strip, StreamingWriteCallback,
                                               StreamingCloseCallback);
      CHECK_RESULT(result);
      CloseLoadingUnitManifest(manifest_file);
    }
 }
 ......
}

static void NextElfCallback(void* callback_data,
                            intptr_t loading_unit_id,
                            void** write_callback_data,
                            void** write_debug_callback_data) {
  NextLoadingUnit(callback_data, loading_unit_id, write_callback_data,
                  write_debug_callback_data, elf_filename, "so");
}

static void NextLoadingUnit(void* callback_data,
                            intptr_t loading_unit_id,
                            void** write_callback_data,
                            void** write_debug_callback_data,
                            const char* main_filename,
                            const char* suffix) {
  char* filename = loading_unit_id == 1
                       ? Utils::StrDup(main_filename)
                       : Utils::SCreate("%s-%" Pd ".part.%s", main_filename,
                                        loading_unit_id, suffix);
  File* file = OpenFile(filename);
  *write_callback_data = file;

  if (debugging_info_filename != nullptr) {
    char* debug_filename =
        loading_unit_id == 1
            ? Utils::StrDup(debugging_info_filename)
            : Utils::SCreate("%s-%" Pd ".part.so", debugging_info_filename,
                             loading_unit_id);
    File* debug_file = OpenFile(debug_filename);
    *write_debug_callback_data = debug_file;
    free(debug_filename);
  }

  WriteLoadingUnitManifest(reinterpret_cast<File*>(callback_data),
                           loading_unit_id, filename);

  free(filename);
}

@override
Future<void> build(Environment environment) async {
  environment.logger.printStatus('rays, DeferredComponentsGenSnapshotValidatorTarget build');
  final DepfileService depfileService = DepfileService(
    fileSystem: environment.fileSystem,
    logger: environment.logger,
  );
  validator = DeferredComponentsGenSnapshotValidator(
    environment,
    title: title,
    exitOnFail: exitOnFail,
  );

  final List<LoadingUnit> generatedLoadingUnits = LoadingUnit.parseGeneratedLoadingUnits(
      environment.outputDir,
      environment.logger,
      abis: _abis
  );

  validator
    ..checkAppAndroidManifestComponentLoadingUnitMapping(
        FlutterProject.current().manifest.deferredComponents,
        generatedLoadingUnits,
    )
    ..checkAgainstLoadingUnitsCache(generatedLoadingUnits)
    ..writeLoadingUnitsCache(generatedLoadingUnits);

  validator.handleResults();

  depfileService.writeToFile(
    Depfile(validator.inputs, validator.outputs),
    environment.buildDir.childFile('flutter_$name.d'),
  );
}