NativeProcess  - AS3

Indica se l'esecuzione dei processi nativi è supportata nel profilo corrente. Questa proprietà restituisce true solo quando i processi sono in esecuzione nel profilo extendedDesktop. Inoltre, NativeProcess.isSupported è sempre false per le applicazioni installate come file AIR. Dovete impacchettare un'applicazione AIR utilizzando il flag ADT -target native per utilizzare la classe NativeProcess.

Indica se questo processo nativo è attualmente in esecuzione. Il processo è in esecuzione se avete chiamato il metodo start() e l'oggetto NativeProcess non ha ancora inviato un evento exit. Un'istanza NativeProcess corrisponde a un singolo processo nel sistema operativo sottostante. Questa proprietà rimane true finché il processo del sistema operativo sottostante è in esecuzione (mentre il processo nativo è in esecuzione e finché non restituisce un codice di uscita al sistema operativo).

Fornisce l'accesso al flusso di errore standard generato da questo processo nativo. Quando i dati diventano disponibili su questo canale, l'oggetto NativeProcess invia un oggetto ProgressEvent. Se tentate di leggere dati da questo flusso quando non sono disponibili dati, l'oggetto NativeProcess genera un'eccezione EOFError.

Il tipo è IDataInput poiché i dati vengono immessi dal punto di vista del processo corrente, anche se si tratta di un flusso di output del processo secondario.

Elementi API correlati

Fornisce l'accesso all'input standard di questo processo nativo. Utilizzate questo canale per inviare dati a questo processo. Ogni volta che vengono scritti dati nella proprietà input, tali dati vengono scritti nel canale di input del processo nativo appena possibile.

Il tipo è IDataOutput poiché i dati vengono generati dal punto di vista del processo corrente, anche se si tratta di un flusso di input del processo secondario.

Elementi API correlati

Fornisce l'accesso al canale di output standard di questo processo nativo. Utilizzate questo canale per leggere i dati dall'output standard del processo nativo. Quando i dati sono disponibili su questo canale, l'oggetto NativeProcess invia un oggetto ProgressEvent. Se tentate di leggere dati da questo flusso quando non sono disponibili dati, l'oggetto NativeProcess genera un EOFError.

Il tipo è IDataInput poiché i dati vengono immessi dal punto di vista del processo corrente, anche se si tratta di un flusso di output del processo secondario.

Elementi API correlati

Costruisce un oggetto NativeProcess non inizializzato. Chiamate il metodo start() per avviare il processo.

Elementi API correlati

Chiude il flusso di input in questo processo. Alcune applicazioni della riga di comando attendono che il flusso di input sia chiuso per avviare determinate operazioni. Dopo la chiusura del flusso, non potete riaprirlo finché il processo non viene chiuso e riavviato.

Tenta di chiudere il processo nativo.

Parametri

Avvia il processo nativo identificato dalle informazioni sull'avvio specificate. Una volta avviato il processo, verranno aperti tutti i flussi di input e output. Questo metodo viene restituito immediatamente dopo l'invio al sistema operativo della richiesta di avviare il processo specificato. Se il processo è attualmente in esecuzione, l'oggetto NativeProcess genera un'eccezione IllegalOperationError. Il processo è in esecuzione se la proprietà running dell'oggetto NativeProcess restituisce true. Se il sistema operativo non è in grado di avviare il processo, viene generato un evento Error.

Un'istanza NativeProcess corrisponde a un singolo processo nel sistema operativo sottostante. Se desiderate eseguire contemporaneamente più di un'istanza del processo del sistema operativo, potete creare un'istanza NativeProcess per ogni processo secondario.

Potete chiamare questo metodo ogni volta che la proprietà running dell'oggetto NativeProcess restituisce false. Ciò significa che l'oggetto NativeProcess può essere riutilizzato. In altre parole, potete costruire un'istanza NativeProcess, chiamare il metodo start(), attendere l'evento exit e quindi chiamare di nuovo il metodo start(). Potete utilizzare un oggetto NativeProcessStartupInfo diverso come parametro info nella successiva chiamata al metodo start().

La classe NativeProcess e le relative funzionalità sono disponibili solo per le applicazioni AIR installate tramite un programma di installazione nativo. Durante il debug, potete passare l'argomento -profile extendedDesktop ad ADL per attivare la funzionalità NativeProcess. Potete controllare la proprietà NativeProcess.isSupported per determinare se è supportata la comunicazione dei processi nativi.

Considerazioni importanti sulla sicurezza:

L'API NativeProcess permette di eseguire qualunque file eseguibile sul sistema dell'utente. Usate la massima attenzione quando create ed eseguite i comandi. Se qualunque parte di un comando da eseguire ha un'origine esterna, verificate attentamente che l'esecuzione del comando non presenti rischi per la sicurezza. Analogamente, la vostra applicazione AIR dovrà convalidare i dati passati a un processo in esecuzione.

Tuttavia, la convalida dell'input può risultare difficoltosa. Per evitare tali difficoltà, è meglio scrivere un'applicazione nativa (ad esempio un file EXE in Windows) che abbia API specifiche. Tali API devono elaborare solo i comandi specificamente richiesti dall'applicazione AIR. Ad esempio, l'applicazione nativa potrebbe accettare solo una serie limitata di istruzioni tramite il flusso di input standard.

In Windows, AIR non consente l'esecuzione diretta dei file .bat. I file .bat di Windows vengono infatti eseguiti dall'applicazione interprete dei comandi (cmd.exe). Quando chiamate un file .bat, questa applicazione provvede a interpretare gli argomenti passati al comando come applicazioni aggiuntive da avviare. Un'iniezione malevola di caratteri supplementari nella stringa di argomenti potrebbe causare l'esecuzione da parte di cmd.exe di un'applicazione dannosa o non sicura. Ad esempio, senza un'adeguata convalida dei dati, l'applicazione AIR potrebbe chiamare myBat.bat myArguments c:/evil.exe. L'interprete dei comandi avvierebbe l'applicazione evil.exe in aggiunta all'elaborazione del file batch.

Se chiamate il metodo start() con un file .bat, l'oggetto NativeProcess genera un'eccezione. La proprietà message dell'oggetto Error contiene la stringa "Errore #3219: impossibile avviare NativeProcess."

Parametri

Elementi API correlati

Segnala che il processo nativo è stato chiuso. La proprietà exitCode contiene il valore che il processo restituisce al sistema operativo host all'uscita. Se l'applicazione AIR termina il processo chiamando il metodo exit() dell'oggetto NativeProcess, la proprietà exitCode viene impostata su NaN.

Segnala che NativeProcess ha chiuso il relativo flusso di errore.

Segnala che nel flusso di errore standard (stderror) sono disponibili dati da leggere per il processo nativo. L'oggetto NativeProcess invia questo evento quando il processo secondario svuota il relativo flusso di errore standard o quando il buffer interno utilizzato per la comunicazione tra i processi è pieno. Evitate di scrivere codice dipendente dalle dimensioni di questo buffer interno, in quanto variano da una versione all'altra e tra sistemi operativi.

Segnala che la lettura dal flusso di errore standard (stderror) non è riuscita. L'oggetto NativeProcess può inviare questo evento quando il runtime non è in grado di leggere i dati dal canale del flusso di errore standard del processo nativo.

Segnala che l'oggetto NativeProcess ha chiuso il relativo flusso di input chiamando il metodo closeInput(). L'oggetto NativeProcess non invia questo evento quando l'effettivo processo nativo chiude direttamente il flusso di input.

Segnala che la scrittura nel flusso di input standard (stdin) non è riuscita. L'oggetto NativeProcess invia questo evento quando il metodo closeInput() ha esito negativo o quando il runtime non è in grado di scrivere dati nel canale del flusso di input standard del processo nativo.

Segnala che NativeProcess ha scritto dei dati nel flusso di input per il processo secondario. L'oggetto NativeProcess invia questo evento al momento della scrittura dei dati nel flusso. Questo evento non indica se il processo secondario ha letto o meno dei dati.

Segnala che NativeProcess ha chiuso il relativo flusso di output.

Segnala che il processo nativo dispone di dati da leggere nel flusso di output. L'oggetto NativeProcess invia questo evento quando il processo secondario svuota il relativo flusso stdout o quando il buffer interno utilizzato per la comunicazione tra i processi è pieno. Evitate di scrivere codice dipendente dalle dimensioni di questo buffer interno, in quanto variano da una versione all'altra e tra sistemi operativi.

Segnala che la lettura dal flusso stdout non è riuscita. L'oggetto NativeProcess può inviare questo evento quando il runtime non è in grado di leggere i dati dal canale di output standard del processo nativo.

package
{
    import flash.display.Sprite;
    import flash.desktop.NativeProcess;
    import flash.desktop.NativeProcessStartupInfo;
    import flash.events.Event;
    import flash.events.ProgressEvent;
    import flash.events.IOErrorEvent;
    import flash.events.NativeProcessExitEvent;
    import flash.filesystem.File;
    
    public class NativeProcessExample extends Sprite
    {
        public var process:NativeProcess;

        public function NativeProcessExample()
        {
            if(NativeProcess.isSupported)
            {
                setupAndLaunch();
            }
            else
            {
                trace("NativeProcess not supported.");
            }
        }
        
        public function setupAndLaunch():void
        {     
            var nativeProcessStartupInfo:NativeProcessStartupInfo = new NativeProcessStartupInfo();
            var file:File = File.applicationDirectory.resolvePath("test.py");
            nativeProcessStartupInfo.executable = file;

            var processArgs:Vector.<String> = new Vector.<String>();
            processArgs[0] = "foo";
            nativeProcessStartupInfo.arguments = processArgs;

            process = new NativeProcess();
            process.start(nativeProcessStartupInfo);
            process.addEventListener(ProgressEvent.STANDARD_OUTPUT_DATA, onOutputData);
            process.addEventListener(ProgressEvent.STANDARD_ERROR_DATA, onErrorData);
            process.addEventListener(NativeProcessExitEvent.EXIT, onExit);
            process.addEventListener(IOErrorEvent.STANDARD_OUTPUT_IO_ERROR, onIOError);
            process.addEventListener(IOErrorEvent.STANDARD_ERROR_IO_ERROR, onIOError);
        }

        public function onOutputData(event:ProgressEvent):void
        {
            trace("Got: ", process.standardOutput.readUTFBytes(process.standardOutput.bytesAvailable)); 
        }
        
        public function onErrorData(event:ProgressEvent):void
        {
            trace("ERROR -", process.standardError.readUTFBytes(process.standardError.bytesAvailable)); 
        }
        
        public function onExit(event:NativeProcessExitEvent):void
        {
            trace("Process exited with ", event.exitCode);
        }
        
        public function onIOError(event:IOErrorEvent):void
        {
             trace(event.toString());
        }
    }
}

 #!/usr/bin/python
 # ------------------------------------------------------------------------------
 # Sample Python script
 # ------------------------------------------------------------------------------
 
 import sys
 
 for word in sys.argv: #echo the command line arguments
     print word
 
 print "HI FROM PYTHON"
 print "Enter user name" 
 line = sys.stdin.readline()
 
 sys.stdout.write("hello," + line)