[JAVA]: Inviare comando al prompt

[andbin]

Originariamente inviato da perzem

public static void Esegui(String command){
	    Runtime r = Runtime.getRuntime();
	        try{
	           
	            Process pr = Runtime.getRuntime().exec(command);
	            int exitVal = pr.waitFor();
	            System.out.println("Process exitValue: " + exitVal);
	        }catch(Throwable e){
	            e.printStackTrace();
	         }
	        
	}

ho aggiunto queste due righe di codice, ma il processo se prima girava tranquillamente ora si pianta e devo chiuderlo dal task manager e poi mi stampa 1... ma in questo modo non posso metter una progress bar perchè verrebbe eseguita solo dopo la fine del processo...

Beh, certo!!
Dipende da come vuoi gestire la cosa. Se vuoi lanciare il nuovo processo e attendere la sua terminazione ma nel frattempo fare altre cose, allora devi fare in modo diverso. Dovresti creare un secondo thread in cui fare eseguire la exec e la waitFor. Quando il processo termina fai in modo da segnalare la cosa in modo asincrono alla tua interfaccia grafica tramite un qualche tipo di evento (usando magari una interface apposita).

[perzem]

Non sono tanto prarico con i thread mi postresti postare una possibile soluzione?? tipo se vorrei stampare lo stato del waitfor finchè nn diventa 0. grazie

[LeleFT]

Una progressbar per monitorare il processo non è possibile a meno che il tuo processo non invii degli output che possono essere raccolti dal programma Java.
Infatti non puoi sapere a priori a che punto è l'esecuzione di un processo esterno (può impiegarci 20 secondi come 20 minuti a seconda del carico della CPU e questo l'applicazione Java non lo saprà mai: essa puo solo sapere quando è terminato).


Ciao.

[andbin]

Originariamente inviato da perzem
Non sono tanto prarico con i thread mi postresti postare una possibile soluzione?? tipo se vorrei stampare lo stato del waitfor finchè nn diventa 0. grazie

Ecco un esempio completo:

import java.awt.*;
import java.awt.event.*;
import javax.swing.*;

public class ExecTestFrame extends JFrame implements ActionListener, ExecProcessEvent
{
    private JButton button;
    private boolean busy;

    public ExecTestFrame ()
    {
        super ("Esempio avvio processo");

        setDefaultCloseOperation (JFrame.DO_NOTHING_ON_CLOSE);
        setSize (200, 100);

        button = new JButton ("Avvia processo");
        button.addActionListener (this);

        add (button);

        addWindowListener (new CloseCheck ());
    }

    public static void main (String[] args)
    {
        ExecTestFrame f = new ExecTestFrame ();
        f.setVisible (true);
    }

    public void actionPerformed (ActionEvent e)
    {
        if (busy)
            JOptionPane.showMessageDialog (ExecTestFrame.this, "hai già avviato un processo!");
        else
        {
            ExecProcessThread ept = new ExecProcessThread ("notepad.exe", this);

            Thread t = new Thread (ept);
            t.start ();
        }
    }

    public void execStarted (String command)
    {
        busy = true;
    }

    public void execTerminated (String command, int status)
    {
        busy = false;
        JOptionPane.showMessageDialog (ExecTestFrame.this, "processo terminato con status = " + status);
    }

    public void execException (String command, Exception e)
    {
        busy = false;
        JOptionPane.showMessageDialog (ExecTestFrame.this, "eccezione " + e);
    }

    private class CloseCheck extends WindowAdapter
    {
        public void windowClosing (WindowEvent e)
        {
            if (ExecTestFrame.this.busy)
                JOptionPane.showMessageDialog (ExecTestFrame.this, "processo in esecuzione, non puoi chiudere");
            else
                System.exit (0);
        }
    }
}


interface ExecProcessEvent
{
    void execStarted (String command);
    void execTerminated (String command, int status);
    void execException (String command, Exception e);
}

class ExecProcessThread implements Runnable
{
    private String command;
    private String[] cmdarray;
    private ExecProcessEvent epe;

    public ExecProcessThread (String command, ExecProcessEvent epe)
    {
        this.command = command;
        this.epe = epe;
    }

    public ExecProcessThread (String[] cmdarray, ExecProcessEvent epe)
    {
        this.cmdarray = cmdarray;
        this.epe = epe;
    }

    public void run ()
    {
        try
        {
            Runtime r = Runtime.getRuntime ();

            Process p = null;

            if (command != null)
                p = r.exec (command);
            else if (cmdarray != null)
                p = r.exec (cmdarray);

            epe.execStarted (command);

            int status = p.waitFor ();

            epe.execTerminated (command, status);
        }
        catch (Exception e)
        {
            epe.execException (command, e);
        }
    }
}

Questa applicazione ha un semplice frame che contiene un pulsante. Premendo il pulsante viene avviato Notepad (il blocco note di Windows). Prova ad esempio ad avviare il processo e poi chiuderlo e prova anche a ripremere il pulsante o chiudere il frame se il processo è stato avviato.

Se c'è qualcosa che non ti è chiaro, chiedi pure. Il codice l'ho buttato giù un po' velocemente e magari gli identificativi che ho usato non sono il massimo! E comunque è sicuramente migliorabile!

[perzem]

peccato per la progressbar, sarebbe stata una cosa carina...

Il codice che mi hai postato e tutto chiaro, ma il problema nn si risolve. Ho semplicemente sostituito il comando del notepad con il mio (esegue una conversione da avi a mp4), l'applicazione parte e anche l'esecuzione del comando, ma poi si ferma e nn va più avanti... killo l'applicazione dal task manager mi visualizza che esce con stato 1 e la conversione riprende e finisce correttamente... moooolto strano...

[maurizio2]

Ciao andbin, il tuo programmino e' un ottimo esempio, complimenti!
Pero' quando lo compilo (inserendo -Xlint come argomento al compilatore per i warning)
mi da il seguente avviso:

ExecTestFrame.java:20: warning: [serial] serializable class ExecTestFrame has no definition of serialVersionUID

Cosa mi sta chiedendo esattamente??
Ciao

[Alex'87]

Originariamente inviato da maurizio2
Pero' quando lo compilo (inserendo -Xlint come argomento al compilatore per i warning)
mi da il seguente avviso:


Cosa mi sta chiedendo esattamente??
Ciao

una cosa di cui puoi non curarti (almeno credo...) lo fa anche a me spesso ma ho visto che non ci sono problemi durante l'esecuzione...

[maurizio2]

si, in effetti si puo' ignorare...
Ma penso sia dovuto al processo di serializzazione, ovvero nel caso la classe
venisse serializzata chiederebbe ancora qualche particolare per una serializzazione
sicura.
Almeno credo!!

[Alex'87]

da quel che ne so io, bisognerebbe inserire in ogni classe creata una costante (serialID o qualcosa di simile) univoca ma non so pwrche' ne sono sicuro di quello che ho scritto

[maurizio2]

Sbirciando tra la libreria Java ho trovato in molte classi la seguente costante:

private static final long serialVersionUID = 8028237497568985504L;

Naturalmente con numeri diversi.
Ho inserito una costante simile nell'esempio e il warning non c'e' piu'!!
Cmq e' di sicuro un identificativo univoco che viene salvato in fase di serializzazione.
Indaghero'....
Ciao