Autore Topic: Esecuzione di comandi esterni  (Letto 2807 volte)

Offline GuglielmoS

  • Nuovo arrivato
  • *
  • Post: 3
  • Respect: +1
    • Mostra profilo
  • Dispositivo Android:
    huawei IDEOS U8150
  • Sistema operativo:
    Mac OS X 10.6.7
Esecuzione di comandi esterni
« il: 08 Giugno 2011, 17:14:07 CEST »
+1
Ciao a tutti, volevo postarvi questa piccola classe che ho scritto per eseguire comandi dalle nostre app.
Praticamente si crea l'oggetto di tipo CommandExecutor, e tramite il metodo exec si esegue il comando di cui si ha bisogno.
Il metodo ritorna una stringa contenente l'output del comando.
Nel caso in cui si abbia bisogna di utilizzare comandi che necessitano dei privilegi di root, basta chiamare il metodo getRoot() oppure, in alternativa, si istanzia l'oggetto CommandExecutor tramite il costruttore che riceve la stringa come parametro.
Quindi nel caso in cui ci sia bisogno dei privilegi di superuser si può andare a creare l'oggetto in questo modo:
Codice (Java): [Seleziona]
CommandExecutor cmdExecutor = new CommandExecutor("su");Spero vi possa tornare utile, ma soprattutto se avete consigli/critiche fatevi sentire che ne ho molto bisogno (in particolare non penso di aver fatto la scelta giusta per quanto riguarda le eccezioni).
Ciao GuglielmoS  ;-)

Codice Classe:
Codice (Java): [Seleziona]
import java.io.IOException;
import java.io.DataInputStream;
import java.io.DataOutputStream;

/**
 * This is a class that permits to perform every valid command that can you
 * execute in your android phone.
 * If you have a rooted phone, you can get root privileges by
 * calling the getRoot method, or by using the constructor with
 * 'su' as parameter.
 * For executing a command you can use the exec method with the command to perform
 * as parameter.
 * @author Guglielmo Fachini a.k.a. GuglielmoS
 *
 */

public class CommandExecutor {
        private Process mainProcess;
        private String runtimeEnvironment;
        private DataInputStream resultStream;
        private DataOutputStream commandStream;
       
        public static final String DEFAULT_ENVIRONMENT = "/system/xbin/sh";
       
        /**
         * Initialize the object with the default environment 'DEFAULT_ENVIRONMENT'.
         */

        public CommandExecutor() {
                this(DEFAULT_ENVIRONMENT);
        }
       
        /**
         * Set the runtime environment chosen.
         * @param runtimeEnvironment the runtime environment to use
         */

        public CommandExecutor(String runtimeEnvironment) {
                setRuntimeEnvironment(runtimeEnvironment);
        }
       
        /**
         * Set a new runtime environment.
         * @param runtimeEnvironment the runtime environment chosen
         */

        public void setRuntimeEnvironment(String runtimeEnvironment) {
                this.runtimeEnvironment = runtimeEnvironment;
        }
       
        /**
         * Initialize the object with the specified environment.
         * For example if you pass 'su' as environment you can use this object
         * for executing commands that need root privileges.
         */

        public void initAll() {
                try {
                        mainProcess = Runtime.getRuntime().exec(runtimeEnvironment);
                        resultStream = new DataInputStream(mainProcess.getInputStream());
                        commandStream = new DataOutputStream(mainProcess.getOutputStream());
                }
                catch (IOException e) {}
        }
       
        /**
         * Call initAll for getting root privileges.
         */

        public void getRoot() {
                setRuntimeEnvironment("su");
        }
       
        /**
         * Execute the specified command and return the output of it.
         * @param command the command to perform
         * @return the command's result
         */

        public String exec(String command) {
                // initialize the runtime environment
                initAll();
               
                // perform the command
                StringBuffer commandOutput = new StringBuffer();
                try {
                        commandStream.writeBytes(command + "\n");
                        commandStream.writeBytes("exit\n");
                        commandStream.flush();
                       
                        int readChars;
                        byte[] buffer = new byte[4096];
                        readChars = resultStream.read(buffer);
               
                        if (readChars > 0) {
                                for (int i = 0; i < (readChars-1); i++) {
                                        commandOutput.append((char)buffer[i]);
                                }
                        }
                       
                        // close all streams
                        resultStream.close();
                        commandStream.close();
                       
                        // waiting for the process
                        mainProcess.waitFor();
                }
                catch (IOException e) {}
                catch (InterruptedException e) {}
                finally {
                        mainProcess.destroy();
                }
               
                return commandOutput.toString();
        }
}
« Ultima modifica: 08 Giugno 2011, 21:31:20 CEST da JD, Reason: Usate i bbcode java e xml!! xD »

Offline Semola

  • Utente junior
  • **
  • Post: 55
  • Respect: 0
    • Mostra profilo
  • Dispositivo Android:
    Huawei Nexus 6P
  • Sistema operativo:
    Ubuntu 13.04 on Dell XPS 14
Re:Esecuzione di comandi esterni
« Risposta #1 il: 29 Giugno 2013, 17:37:52 CEST »
0
Ciao,
ho letto il tuo topic, vorrei sapere se c'è una lista di quali sono i tipi di comandi che posso impartire tramite questa classe, per esempio, se voglio attivare il gps? o il wifi? che stringa gli devo passare come parametro?
Inoltre non ho capito una cosa, ho visto che nel metodo exec c'è scritto
Citazione
commandStream.writeBytes("exit\n");
queto vuol dire che se voglio inviare subito dopo un altro comando mi basta invocare nuovamente exec oppure istnziare un nuovo oggetto sempre di tipo CommandExecutor?
grazie