linux.dart 7.58 KB
Newer Older
Ian Hickson's avatar
Ian Hickson committed
1
// Copyright 2014 The Flutter Authors. All rights reserved.
2 3 4 5 6
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

import '../../artifacts.dart';
import '../../base/file_system.dart';
7
import '../../build_info.dart';
8
import '../../convert.dart';
9 10
import '../../devfs.dart';
import '../../project.dart';
11
import '../build_system.dart';
12
import '../depfile.dart';
13 14
import '../exceptions.dart';
import 'assets.dart';
15
import 'common.dart';
16
import 'desktop.dart';
17
import 'icon_tree_shaker.dart';
18
import 'shader_compiler.dart';
19

20 21
/// The only files/subdirectories we care out.
const List<String> _kLinuxArtifacts = <String>[
22
  'libflutter_linux_gtk.so',
23 24
];

25 26
const String _kLinuxDepfile = 'linux_engine_sources.d';

27
/// Copies the Linux desktop embedding files to the copy directory.
28
class UnpackLinux extends Target {
29 30 31
  const UnpackLinux(this.targetPlatform);

  final TargetPlatform targetPlatform;
32 33

  @override
34
  String get name => 'unpack_linux';
35 36 37 38 39 40 41

  @override
  List<Source> get inputs => const <Source>[
    Source.pattern('{FLUTTER_ROOT}/packages/flutter_tools/lib/src/build_system/targets/linux.dart'),
  ];

  @override
42 43 44
  List<Source> get outputs => const <Source>[];

  @override
45
  List<String> get depfiles => const <String>[_kLinuxDepfile];
46 47 48 49 50

  @override
  List<Target> get dependencies => <Target>[];

  @override
51
  Future<void> build(Environment environment) async {
52 53 54 55 56
    final String? buildModeEnvironment = environment.defines[kBuildMode];
    if (buildModeEnvironment == null) {
      throw MissingDefineException(kBuildMode, name);
    }
    final BuildMode buildMode = getBuildModeForName(buildModeEnvironment);
57 58 59 60
    final String engineSourcePath = environment.artifacts
      .getArtifactPath(
        Artifact.linuxDesktopPath,
        mode: buildMode,
61
        platform: targetPlatform,
62
      );
63 64 65 66
    final String headersPath = environment.artifacts
      .getArtifactPath(
        Artifact.linuxHeaders,
        mode: buildMode,
67
        platform: targetPlatform,
68
      );
69 70
    final Directory outputDirectory = environment.fileSystem.directory(
      environment.fileSystem.path.join(
71 72 73 74
      environment.projectDir.path,
      'linux',
      'flutter',
      'ephemeral',
75 76 77
    ));
    final Depfile depfile = unpackDesktopArtifacts(
      fileSystem: environment.fileSystem,
78
      engineSourcePath: engineSourcePath,
79 80
      outputDirectory: outputDirectory,
      artifacts: _kLinuxArtifacts,
81
      clientSourcePaths: <String>[headersPath],
82 83
      icuDataPath: environment.artifacts.getArtifactPath(
        Artifact.icuData,
84
        platform: targetPlatform,
85
      )
86
    );
87
    final DepfileService depfileService = DepfileService(
88 89
      fileSystem: environment.fileSystem,
      logger: environment.logger,
90 91 92
    );
    depfileService.writeToFile(
      depfile,
93
      environment.buildDir.childFile(_kLinuxDepfile),
94
    );
95 96
  }
}
97

98 99
/// Creates a bundle for the Linux desktop target.
abstract class BundleLinuxAssets extends Target {
100 101 102
  const BundleLinuxAssets(this.targetPlatform);

  final TargetPlatform targetPlatform;
103 104

  @override
105 106 107
  List<Target> get dependencies => <Target>[
    const KernelSnapshot(),
    UnpackLinux(targetPlatform),
108 109 110 111 112
  ];

  @override
  List<Source> get inputs => const <Source>[
    Source.pattern('{FLUTTER_ROOT}/packages/flutter_tools/lib/src/build_system/targets/linux.dart'),
113
    Source.pattern('{PROJECT_DIR}/pubspec.yaml'),
114
    ...IconTreeShaker.inputs,
115 116
  ];

117 118 119 120 121
  @override
  List<String> get depfiles => const <String>[
    'flutter_assets.d',
  ];

122 123
  @override
  Future<void> build(Environment environment) async {
124 125
    final String? buildModeEnvironment = environment.defines[kBuildMode];
    if (buildModeEnvironment == null) {
126
      throw MissingDefineException(kBuildMode, 'bundle_linux_assets');
127
    }
128
    final BuildMode buildMode = getBuildModeForName(buildModeEnvironment);
129 130 131 132 133 134 135 136 137 138 139
    final Directory outputDirectory = environment.outputDir
      .childDirectory('flutter_assets');
    if (!outputDirectory.existsSync()) {
      outputDirectory.createSync();
    }

    // Only copy the kernel blob in debug mode.
    if (buildMode == BuildMode.debug) {
      environment.buildDir.childFile('app.dill')
        .copySync(outputDirectory.childFile('kernel_blob.bin').path);
    }
140
    final String versionInfo = getVersionInfo(environment.defines);
141 142 143
    final Depfile depfile = await copyAssets(
      environment,
      outputDirectory,
144
      targetPlatform: targetPlatform,
145 146
      additionalContent: <String, DevFSContent>{
        'version.json': DevFSStringContent(versionInfo),
147 148
      },
      shaderTarget: ShaderTarget.sksl,
149
    );
150
    final DepfileService depfileService = DepfileService(
151 152
      fileSystem: environment.fileSystem,
      logger: environment.logger,
153 154 155 156 157
    );
    depfileService.writeToFile(
      depfile,
      environment.buildDir.childFile('flutter_assets.d'),
    );
158
  }
159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175

  /// Return json encoded string that contains data about version for package_info
  String getVersionInfo(Map<String, String> defines) {
    final Map<String, dynamic> versionInfo =
        jsonDecode(FlutterProject.current().getVersionInfo())
            as Map<String, dynamic>;

    if (defines.containsKey(kBuildNumber)) {
      versionInfo['build_number'] = defines[kBuildNumber];
    }

    if (defines.containsKey(kBuildName)) {
      versionInfo['version'] = defines[kBuildName];
    }

    return jsonEncode(versionInfo);
  }
176
}
177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215

/// A wrapper for AOT compilation that copies app.so into the output directory.
class LinuxAotBundle extends Target {
  /// Create a [LinuxAotBundle] wrapper for [aotTarget].
  const LinuxAotBundle(this.aotTarget);

  /// The [AotElfBase] subclass that produces the app.so.
  final AotElfBase aotTarget;

  @override
  String get name => 'linux_aot_bundle';

  @override
  List<Source> get inputs => const <Source>[
    Source.pattern('{BUILD_DIR}/app.so'),
  ];

  @override
  List<Source> get outputs => const <Source>[
    Source.pattern('{OUTPUT_DIR}/lib/libapp.so'),
  ];

  @override
  List<Target> get dependencies => <Target>[
    aotTarget,
  ];

  @override
  Future<void> build(Environment environment) async {
    final File outputFile = environment.buildDir.childFile('app.so');
    final Directory outputDirectory = environment.outputDir.childDirectory('lib');
    if (!outputDirectory.existsSync()) {
      outputDirectory.createSync(recursive: true);
    }
    outputFile.copySync(outputDirectory.childFile('libapp.so').path);
  }
}

class DebugBundleLinuxAssets extends BundleLinuxAssets {
216
  const DebugBundleLinuxAssets(super.targetPlatform);
217 218

  @override
219
  String get name => 'debug_bundle_${getNameForTargetPlatform(targetPlatform)}_assets';
220 221 222 223 224 225 226 227 228 229 230 231 232

  @override
  List<Source> get inputs => <Source>[
    const Source.pattern('{BUILD_DIR}/app.dill'),
  ];

  @override
  List<Source> get outputs => <Source>[
    const Source.pattern('{OUTPUT_DIR}/flutter_assets/kernel_blob.bin'),
  ];
}

class ProfileBundleLinuxAssets extends BundleLinuxAssets {
233
  const ProfileBundleLinuxAssets(super.targetPlatform);
234 235

  @override
236
  String get name => 'profile_bundle_${getNameForTargetPlatform(targetPlatform)}_assets';
237 238 239 240 241 242 243

  @override
  List<Source> get outputs => const <Source>[];

  @override
  List<Target> get dependencies => <Target>[
    ...super.dependencies,
244
    LinuxAotBundle(AotElfProfile(targetPlatform)),
245 246 247 248
  ];
}

class ReleaseBundleLinuxAssets extends BundleLinuxAssets {
249
  const ReleaseBundleLinuxAssets(super.targetPlatform);
250 251

  @override
252
  String get name => 'release_bundle_${getNameForTargetPlatform(targetPlatform)}_assets';
253 254 255 256 257 258 259

  @override
  List<Source> get outputs => const <Source>[];

  @override
  List<Target> get dependencies => <Target>[
    ...super.dependencies,
260
    LinuxAotBundle(AotElfRelease(targetPlatform)),
261 262
  ];
}