1 /*
2 * Copyright (c) 2019, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation. Oracle designates this
8 * particular file as subject to the "Classpath" exception as provided
9 * by Oracle in the LICENSE file that accompanied this code.
10 *
11 * This code is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 * version 2 for more details (a copy is included in the LICENSE file that
15 * accompanied this code).
16 *
17 * You should have received a copy of the GNU General Public License version
18 * 2 along with this work; if not, write to the Free Software Foundation,
19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20 *
21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22 * or visit www.oracle.com if you need additional information or have any
23 * questions.
24 */
25 package jdk.incubator.jpackage.internal;
26
27 import java.awt.image.BufferedImage;
28 import java.io.*;
29 import java.nio.file.Files;
30 import java.nio.file.Path;
31 import java.util.*;
32 import java.util.stream.Collectors;
33 import java.util.stream.Stream;
34 import javax.imageio.ImageIO;
35 import javax.xml.stream.XMLStreamException;
36 import javax.xml.stream.XMLStreamWriter;
37 import static jdk.incubator.jpackage.internal.LinuxAppBundler.ICON_PNG;
38 import static jdk.incubator.jpackage.internal.LinuxAppImageBuilder.DEFAULT_ICON;
39 import static jdk.incubator.jpackage.internal.OverridableResource.createResource;
40 import static jdk.incubator.jpackage.internal.StandardBundlerParam.*;
41
42 /**
43 * Helper to create files for desktop integration.
44 */
45 final class DesktopIntegration {
46
47 static final String DESKTOP_COMMANDS_INSTALL = "DESKTOP_COMMANDS_INSTALL";
48 static final String DESKTOP_COMMANDS_UNINSTALL = "DESKTOP_COMMANDS_UNINSTALL";
49 static final String UTILITY_SCRIPTS = "UTILITY_SCRIPTS";
50
51 DesktopIntegration(PlatformPackage thePackage,
52 Map<String, ? super Object> params) {
53
54 associations = FileAssociation.fetchFrom(params).stream()
55 .filter(fa -> !fa.mimeTypes.isEmpty())
56 .map(LinuxFileAssociation::new)
57 .collect(Collectors.toUnmodifiableList());
58
59 launchers = ADD_LAUNCHERS.fetchFrom(params);
60
61 this.thePackage = thePackage;
62
63 final File customIconFile = ICON_PNG.fetchFrom(params);
64
65 iconResource = createResource(DEFAULT_ICON, params)
66 .setCategory(I18N.getString("resource.menu-icon"))
67 .setExternal(customIconFile);
68 desktopFileResource = createResource("template.desktop", params)
69 .setCategory(I18N.getString("resource.menu-shortcut-descriptor"))
70 .setPublicName(APP_NAME.fetchFrom(params) + ".desktop");
71
72 // XDG recommends to use vendor prefix in desktop file names as xdg
73 // commands copy files to system directories.
74 // Package name should be a good prefix.
75 final String desktopFileName = String.format("%s-%s.desktop",
76 thePackage.name(), APP_NAME.fetchFrom(params));
77 final String mimeInfoFileName = String.format("%s-%s-MimeInfo.xml",
78 thePackage.name(), APP_NAME.fetchFrom(params));
79
80 mimeInfoFile = new DesktopFile(mimeInfoFileName);
81
82 if (!associations.isEmpty() || SHORTCUT_HINT.fetchFrom(params) || customIconFile != null) {
83 //
84 // Create primary .desktop file if one of conditions is met:
85 // - there are file associations configured
86 // - user explicitely requested to create a shortcut
87 // - custom icon specified
88 //
89 desktopFile = new DesktopFile(desktopFileName);
90 iconFile = new DesktopFile(APP_NAME.fetchFrom(params)
91 + IOUtils.getSuffix(Path.of(DEFAULT_ICON)));
92 } else {
93 desktopFile = null;
94 iconFile = null;
95 }
96
97 desktopFileData = Collections.unmodifiableMap(
98 createDataForDesktopFile(params));
99
100 nestedIntegrations = launchers.stream().map(
101 launcherParams -> new DesktopIntegration(thePackage,
102 launcherParams)).collect(Collectors.toList());
103 }
104
105 List<String> requiredPackages() {
106 return Stream.of(List.of(this), nestedIntegrations).flatMap(
107 List::stream).map(DesktopIntegration::requiredPackagesSelf).flatMap(
108 List::stream).distinct().collect(Collectors.toList());
109 }
110
111 Map<String, String> create() throws IOException {
112 associations.forEach(assoc -> assoc.data.verify());
113
114 if (iconFile != null) {
115 // Create application icon file.
116 iconResource.saveToFile(iconFile.srcPath());
117 }
118
119 Map<String, String> data = new HashMap<>(desktopFileData);
120
121 final ShellCommands shellCommands;
122 if (desktopFile != null) {
123 // Create application desktop description file.
124 createDesktopFile(data);
125
126 // Shell commands will be created only if desktop file
127 // should be installed.
128 shellCommands = new ShellCommands();
129 } else {
130 shellCommands = null;
131 }
132
133 if (!associations.isEmpty()) {
134 // Create XML file with mime types corresponding to file associations.
135 createFileAssociationsMimeInfoFile();
136
137 shellCommands.setFileAssociations();
138
139 // Create icon files corresponding to file associations
140 addFileAssociationIconFiles(shellCommands);
141 }
142
143 // Create shell commands to install/uninstall integration with desktop of the app.
144 if (shellCommands != null) {
145 shellCommands.applyTo(data);
146 }
147
148 boolean needCleanupScripts = !associations.isEmpty();
149
150 // Take care of additional launchers if there are any.
151 // Process every additional launcher as the main application launcher.
152 // Collect shell commands to install/uninstall integration with desktop
153 // of the additional launchers and append them to the corresponding
154 // commands of the main launcher.
155 List<String> installShellCmds = new ArrayList<>(Arrays.asList(
156 data.get(DESKTOP_COMMANDS_INSTALL)));
157 List<String> uninstallShellCmds = new ArrayList<>(Arrays.asList(
158 data.get(DESKTOP_COMMANDS_UNINSTALL)));
159 for (var integration: nestedIntegrations) {
160 if (!integration.associations.isEmpty()) {
161 needCleanupScripts = true;
162 }
163
164 Map<String, String> launcherData = integration.create();
165
166 installShellCmds.add(launcherData.get(DESKTOP_COMMANDS_INSTALL));
167 uninstallShellCmds.add(launcherData.get(
168 DESKTOP_COMMANDS_UNINSTALL));
169 }
170
171 data.put(DESKTOP_COMMANDS_INSTALL, stringifyShellCommands(
172 installShellCmds));
173 data.put(DESKTOP_COMMANDS_UNINSTALL, stringifyShellCommands(
174 uninstallShellCmds));
175
176 if (needCleanupScripts) {
177 // Pull in utils.sh scrips library.
178 try (InputStream is = OverridableResource.readDefault("utils.sh");
179 InputStreamReader isr = new InputStreamReader(is);
180 BufferedReader reader = new BufferedReader(isr)) {
181 data.put(UTILITY_SCRIPTS, reader.lines().collect(
182 Collectors.joining(System.lineSeparator())));
183 }
184 } else {
185 data.put(UTILITY_SCRIPTS, "");
186 }
187
188 return data;
189 }
190
191 private List<String> requiredPackagesSelf() {
192 if (desktopFile != null) {
193 return List.of("xdg-utils");
194 }
195 return Collections.emptyList();
196 }
197
198 private Map<String, String> createDataForDesktopFile(
199 Map<String, ? super Object> params) {
200 Map<String, String> data = new HashMap<>();
201 data.put("APPLICATION_NAME", APP_NAME.fetchFrom(params));
202 data.put("APPLICATION_DESCRIPTION", DESCRIPTION.fetchFrom(params));
203 data.put("APPLICATION_ICON",
204 iconFile != null ? iconFile.installPath().toString() : null);
205 data.put("DEPLOY_BUNDLE_CATEGORY", MENU_GROUP.fetchFrom(params));
206 data.put("APPLICATION_LAUNCHER",
207 thePackage.installedApplicationLayout().launchersDirectory().resolve(
208 LinuxAppImageBuilder.getLauncherName(params)).toString());
209
210 return data;
211 }
212
213 /**
214 * Shell commands to integrate something with desktop.
215 */
216 private class ShellCommands {
217
218 ShellCommands() {
219 registerIconCmds = new ArrayList<>();
220 unregisterIconCmds = new ArrayList<>();
221
222 registerDesktopFileCmd = String.join(" ", "xdg-desktop-menu",
223 "install", desktopFile.installPath().toString());
224 unregisterDesktopFileCmd = String.join(" ", "xdg-desktop-menu",
225 "uninstall", desktopFile.installPath().toString());
226 }
227
228 void setFileAssociations() {
229 registerFileAssociationsCmd = String.join(" ", "xdg-mime",
230 "install",
231 mimeInfoFile.installPath().toString());
232 unregisterFileAssociationsCmd = String.join(" ", "xdg-mime",
233 "uninstall", mimeInfoFile.installPath().toString());
234
235 //
236 // Add manual cleanup of system files to get rid of
237 // the default mime type handlers.
238 //
239 // Even after mime type is unregisterd with `xdg-mime uninstall`
240 // command and desktop file deleted with `xdg-desktop-menu uninstall`
241 // command, records in
242 // `/usr/share/applications/defaults.list` (Ubuntu 16) or
243 // `/usr/local/share/applications/defaults.list` (OracleLinux 7)
244 // files remain referencing deleted mime time and deleted
245 // desktop file which makes `xdg-mime query default` output name
246 // of non-existing desktop file.
247 //
248 String cleanUpCommand = String.join(" ",
249 "uninstall_default_mime_handler",
250 desktopFile.installPath().getFileName().toString(),
251 String.join(" ", getMimeTypeNamesFromFileAssociations()));
252
253 unregisterFileAssociationsCmd = stringifyShellCommands(
254 unregisterFileAssociationsCmd, cleanUpCommand);
255 }
256
257 void addIcon(String mimeType, Path iconFile) {
258 addIcon(mimeType, iconFile, getSquareSizeOfImage(iconFile.toFile()));
259 }
260
261 void addIcon(String mimeType, Path iconFile, int imgSize) {
262 imgSize = normalizeIconSize(imgSize);
263 final String dashMime = mimeType.replace('/', '-');
264 registerIconCmds.add(String.join(" ", "xdg-icon-resource",
265 "install", "--context", "mimetypes", "--size",
266 Integer.toString(imgSize), iconFile.toString(), dashMime));
267 unregisterIconCmds.add(String.join(" ", "xdg-icon-resource",
268 "uninstall", dashMime, "--size", Integer.toString(imgSize)));
269 }
270
271 void applyTo(Map<String, String> data) {
272 List<String> cmds = new ArrayList<>();
273
274 cmds.add(registerDesktopFileCmd);
275 cmds.add(registerFileAssociationsCmd);
276 cmds.addAll(registerIconCmds);
277 data.put(DESKTOP_COMMANDS_INSTALL, stringifyShellCommands(cmds));
278
279 cmds.clear();
280 cmds.add(unregisterDesktopFileCmd);
281 cmds.add(unregisterFileAssociationsCmd);
282 cmds.addAll(unregisterIconCmds);
283 data.put(DESKTOP_COMMANDS_UNINSTALL, stringifyShellCommands(cmds));
284 }
285
286 private String registerDesktopFileCmd;
287 private String unregisterDesktopFileCmd;
288
289 private String registerFileAssociationsCmd;
290 private String unregisterFileAssociationsCmd;
291
292 private List<String> registerIconCmds;
293 private List<String> unregisterIconCmds;
294 }
295
296 /**
297 * Desktop integration file. xml, icon, etc.
298 * Resides somewhere in application installation tree.
299 * Has two paths:
300 * - path where it should be placed at package build time;
301 * - path where it should be installed by package manager;
302 */
303 private class DesktopFile {
304
305 DesktopFile(String fileName) {
306 installPath = thePackage
307 .installedApplicationLayout()
308 .destktopIntegrationDirectory().resolve(fileName);
309 srcPath = thePackage
310 .sourceApplicationLayout()
311 .destktopIntegrationDirectory().resolve(fileName);
312 }
313
314 private final Path installPath;
315 private final Path srcPath;
316
317 Path installPath() {
318 return installPath;
319 }
320
321 Path srcPath() {
322 return srcPath;
323 }
324 }
325
326 private void appendFileAssociation(XMLStreamWriter xml,
327 FileAssociation assoc) throws XMLStreamException {
328
329 for (var mimeType : assoc.mimeTypes) {
330 xml.writeStartElement("mime-type");
331 xml.writeAttribute("type", mimeType);
332
333 final String description = assoc.description;
334 if (description != null && !description.isEmpty()) {
335 xml.writeStartElement("comment");
336 xml.writeCharacters(description);
337 xml.writeEndElement();
338 }
339
340 for (String ext : assoc.extensions) {
341 xml.writeStartElement("glob");
342 xml.writeAttribute("pattern", "*." + ext);
343 xml.writeEndElement();
344 }
345
346 xml.writeEndElement();
347 }
348 }
349
350 private void createFileAssociationsMimeInfoFile() throws IOException {
351 IOUtils.createXml(mimeInfoFile.srcPath(), xml -> {
352 xml.writeStartElement("mime-info");
353 xml.writeDefaultNamespace(
354 "http://www.freedesktop.org/standards/shared-mime-info");
355
356 for (var assoc : associations) {
357 appendFileAssociation(xml, assoc.data);
358 }
359
360 xml.writeEndElement();
361 });
362 }
363
364 private void addFileAssociationIconFiles(ShellCommands shellCommands)
365 throws IOException {
366 Set<String> processedMimeTypes = new HashSet<>();
367 for (var assoc : associations) {
368 if (assoc.iconSize <= 0) {
369 // No icon.
370 continue;
371 }
372
373 for (var mimeType : assoc.data.mimeTypes) {
374 if (processedMimeTypes.contains(mimeType)) {
375 continue;
376 }
377
378 processedMimeTypes.add(mimeType);
379
380 // Create icon name for mime type from mime type.
381 DesktopFile faIconFile = new DesktopFile(mimeType.replace(
382 File.separatorChar, '-') + IOUtils.getSuffix(
383 assoc.data.iconPath));
384
385 IOUtils.copyFile(assoc.data.iconPath.toFile(),
386 faIconFile.srcPath().toFile());
387
388 shellCommands.addIcon(mimeType, faIconFile.installPath(),
389 assoc.iconSize);
390 }
391 }
392 }
393
394 private void createDesktopFile(Map<String, String> data) throws IOException {
395 List<String> mimeTypes = getMimeTypeNamesFromFileAssociations();
396 data.put("DESKTOP_MIMES", "MimeType=" + String.join(";", mimeTypes));
397
398 // prepare desktop shortcut
399 desktopFileResource
400 .setSubstitutionData(data)
401 .saveToFile(desktopFile.srcPath());
402 }
403
404 private List<String> getMimeTypeNamesFromFileAssociations() {
405 return associations.stream()
406 .map(fa -> fa.data.mimeTypes)
407 .flatMap(List::stream)
408 .collect(Collectors.toUnmodifiableList());
409 }
410
411 private static int getSquareSizeOfImage(File f) {
412 try {
413 BufferedImage bi = ImageIO.read(f);
414 return Math.max(bi.getWidth(), bi.getHeight());
415 } catch (IOException e) {
416 Log.verbose(e);
417 }
418 return 0;
419 }
420
421 private static int normalizeIconSize(int iconSize) {
422 // If register icon with "uncommon" size, it will be ignored.
423 // So find the best matching "common" size.
424 List<Integer> commonIconSizes = List.of(16, 22, 32, 48, 64, 128);
425
426 int idx = Collections.binarySearch(commonIconSizes, iconSize);
427 if (idx < 0) {
428 // Given icon size is greater than the largest common icon size.
429 return commonIconSizes.get(commonIconSizes.size() - 1);
430 }
431
432 if (idx == 0) {
433 // Given icon size is less or equal than the smallest common icon size.
434 return commonIconSizes.get(idx);
435 }
436
437 int commonIconSize = commonIconSizes.get(idx);
438 if (iconSize < commonIconSize) {
439 // It is better to scale down original icon than to scale it up for
440 // better visual quality.
441 commonIconSize = commonIconSizes.get(idx - 1);
442 }
443
444 return commonIconSize;
445 }
446
447 private static String stringifyShellCommands(String... commands) {
448 return stringifyShellCommands(Arrays.asList(commands));
449 }
450
451 private static String stringifyShellCommands(List<String> commands) {
452 return String.join(System.lineSeparator(), commands.stream().filter(
453 s -> s != null && !s.isEmpty()).collect(Collectors.toList()));
454 }
455
456 private static class LinuxFileAssociation {
457 LinuxFileAssociation(FileAssociation fa) {
458 this.data = fa;
459 if (fa.iconPath != null && Files.isReadable(fa.iconPath)) {
460 iconSize = getSquareSizeOfImage(fa.iconPath.toFile());
461 } else {
462 iconSize = -1;
463 }
464 }
465
466 final FileAssociation data;
467 final int iconSize;
468 }
469
470 private final PlatformPackage thePackage;
471
472 private final List<LinuxFileAssociation> associations;
473
474 private final List<Map<String, ? super Object>> launchers;
475
476 private final OverridableResource iconResource;
477 private final OverridableResource desktopFileResource;
478
479 private final DesktopFile mimeInfoFile;
480 private final DesktopFile desktopFile;
481 private final DesktopFile iconFile;
482
483 private final List<DesktopIntegration> nestedIntegrations;
484
485 private final Map<String, String> desktopFileData;
486
487 private static final BundlerParamInfo<String> MENU_GROUP =
488 new StandardBundlerParam<>(
489 Arguments.CLIOptions.LINUX_MENU_GROUP.getId(),
490 String.class,
491 params -> I18N.getString("param.menu-group.default"),
492 (s, p) -> s
493 );
494
495 private static final StandardBundlerParam<Boolean> SHORTCUT_HINT =
496 new StandardBundlerParam<>(
497 Arguments.CLIOptions.LINUX_SHORTCUT_HINT.getId(),
498 Boolean.class,
499 params -> false,
500 (s, p) -> (s == null || "null".equalsIgnoreCase(s))
501 ? false : Boolean.valueOf(s)
502 );
503 }