java - La API de escritorio no es compatible con la plataforma actual

file desktop-application

Question

Me he encontrado con este error:

java.lang.UnsupportedOperationException: Desktop API is not supported on the current platform

Me gustaría abrir un archivo de mi aplicación java. Yo uso este método:

                Desktop.getDesktop().open(new File(report.html"));

¿Como puedó resolver esté problema?

Answer 1

Básicamente, el problema es que la integración de Java Desktop no funciona bien en Linux.

Fue diseñado para funcionar bien con Windows; algo funciona en otros sistemas, pero a nadie le importaba agregar el soporte adecuado para ellos. Incluso si instala las ''bibliotecas gnome'' requeridas, los resultados serán malos.

Me enfrenté al mismo problema hace un tiempo y se me ocurrió la siguiente clase.

El objetivo se logra mediante el uso de comandos específicos del sistema :

KDE:     kde-open
GNOME:   gnome-open
Any X-server system: xdg-open
MAC:     open
Windows: explorer

Si nada de eso funciona, intenta la implementación provista por Java Desktop.
Porque este suele fallar, se ha intentado como último recurso.

Clase desktopApi

Esta clase proporciona métodos estáticos de open , browse y edit .
Está probado para funcionar en Linux (Kde y Gnome), Windows y Mac.

Si lo usas, por favor dame crédito.

package net.mightypork.rpack.utils;

import java.awt.Desktop;
import java.io.File;
import java.io.IOException;
import java.net.URI;
import java.util.ArrayList;
import java.util.List;


public class DesktopApi {

    public static boolean browse(URI uri) {

        if (openSystemSpecific(uri.toString())) return true;

        if (browseDESKTOP(uri)) return true;

        return false;
    }


    public static boolean open(File file) {

        if (openSystemSpecific(file.getPath())) return true;

        if (openDESKTOP(file)) return true;

        return false;
    }


    public static boolean edit(File file) {

        // you can try something like
        // runCommand("gimp", "%s", file.getPath())
        // based on user preferences.

        if (openSystemSpecific(file.getPath())) return true;

        if (editDESKTOP(file)) return true;

        return false;
    }


    private static boolean openSystemSpecific(String what) {

        EnumOS os = getOs();

        if (os.isLinux()) {
            if (runCommand("kde-open", "%s", what)) return true;
            if (runCommand("gnome-open", "%s", what)) return true;
            if (runCommand("xdg-open", "%s", what)) return true;
        }

        if (os.isMac()) {
            if (runCommand("open", "%s", what)) return true;
        }

        if (os.isWindows()) {
            if (runCommand("explorer", "%s", what)) return true;
        }

        return false;
    }


    private static boolean browseDESKTOP(URI uri) {

        logOut("Trying to use Desktop.getDesktop().browse() with " + uri.toString());
        try {
            if (!Desktop.isDesktopSupported()) {
                logErr("Platform is not supported.");
                return false;
            }

            if (!Desktop.getDesktop().isSupported(Desktop.Action.BROWSE)) {
                logErr("BROWSE is not supported.");
                return false;
            }

            Desktop.getDesktop().browse(uri);

            return true;
        } catch (Throwable t) {
            logErr("Error using desktop browse.", t);
            return false;
        }
    }


    private static boolean openDESKTOP(File file) {

        logOut("Trying to use Desktop.getDesktop().open() with " + file.toString());
        try {
            if (!Desktop.isDesktopSupported()) {
                logErr("Platform is not supported.");
                return false;
            }

            if (!Desktop.getDesktop().isSupported(Desktop.Action.OPEN)) {
                logErr("OPEN is not supported.");
                return false;
            }

            Desktop.getDesktop().open(file);

            return true;
        } catch (Throwable t) {
            logErr("Error using desktop open.", t);
            return false;
        }
    }


    private static boolean editDESKTOP(File file) {

        logOut("Trying to use Desktop.getDesktop().edit() with " + file);
        try {
            if (!Desktop.isDesktopSupported()) {
                logErr("Platform is not supported.");
                return false;
            }

            if (!Desktop.getDesktop().isSupported(Desktop.Action.EDIT)) {
                logErr("EDIT is not supported.");
                return false;
            }

            Desktop.getDesktop().edit(file);

            return true;
        } catch (Throwable t) {
            logErr("Error using desktop edit.", t);
            return false;
        }
    }


    private static boolean runCommand(String command, String args, String file) {

        logOut("Trying to exec:/n   cmd = " + command + "/n   args = " + args + "/n   %s = " + file);

        String[] parts = prepareCommand(command, args, file);

        try {
            Process p = Runtime.getRuntime().exec(parts);
            if (p == null) return false;

            try {
                int retval = p.exitValue();
                if (retval == 0) {
                    logErr("Process ended immediately.");
                    return false;
                } else {
                    logErr("Process crashed.");
                    return false;
                }
            } catch (IllegalThreadStateException itse) {
                logErr("Process is running.");
                return true;
            }
        } catch (IOException e) {
            logErr("Error running command.", e);
            return false;
        }
    }


    private static String[] prepareCommand(String command, String args, String file) {

        List<String> parts = new ArrayList<String>();
        parts.add(command);

        if (args != null) {
            for (String s : args.split(" ")) {
                s = String.format(s, file); // put in the filename thing

                parts.add(s.trim());
            }
        }

        return parts.toArray(new String[parts.size()]);
    }

    private static void logErr(String msg, Throwable t) {
        System.err.println(msg);
        t.printStackTrace();
    }

    private static void logErr(String msg) {
        System.err.println(msg);
    }

    private static void logOut(String msg) {
        System.out.println(msg);
    }

    public static enum EnumOS {
        linux, macos, solaris, unknown, windows;

        public boolean isLinux() {

            return this == linux || this == solaris;
        }


        public boolean isMac() {

            return this == macos;
        }


        public boolean isWindows() {

            return this == windows;
        }
    }


    public static EnumOS getOs() {

        String s = System.getProperty("os.name").toLowerCase();

        if (s.contains("win")) {
            return EnumOS.windows;
        }

        if (s.contains("mac")) {
            return EnumOS.macos;
        }

        if (s.contains("solaris")) {
            return EnumOS.solaris;
        }

        if (s.contains("sunos")) {
            return EnumOS.solaris;
        }

        if (s.contains("linux")) {
            return EnumOS.linux;
        }

        if (s.contains("unix")) {
            return EnumOS.linux;
        } else {
            return EnumOS.unknown;
        }
    }
}

Answer 2

El soporte varía entre las implementaciones en los distintos JDK. Encontré la "UnsupportedOperationException" utilizando OpenJDK 1.7.0. El cambio al Oracle JDK 1.7 funcionó.

Cuando sea práctico, puede cambiar JDK o sugerir que sus usuarios cambien JDK para habilitar una determinada característica.

Answer 3

Estoy usando Ubuntu 12.04 LTS de 64 bits con Oracle jdk1.6.0_45 y estaba teniendo el mismo problema. Estoy ejecutando gnome-classic como el escritorio en lugar de Unity. Esto es lo que funcionó para mí:

sudo apt-get install libgnome2-0

Después de instalar este paquete, reinicié mi aplicación Java Swing y Desktop.getDesktop().open(new File("myfile")); funcionó bien

Answer 4

La clase de escritorio no es compatible con todos los sistemas.

Del tutorial de Java Swing Cómo integrarse con la clase de escritorio :

Use el método isDesktopSupported () para determinar si la API de escritorio está disponible. En el sistema operativo Solaris y la plataforma Linux, esta API depende de las bibliotecas Gnome. Si esas bibliotecas no están disponibles, este método devolverá false. Después de determinar que la API de Desktop es compatible, es decir, isDesktopSupported () devuelve true, la aplicación puede recuperar una instancia de Desktop utilizando el método estático getDesktop ().

En cualquier caso, sería mejor proporcionar una forma alternativa de abrir un archivo si no hay soporte para Desktop.