NativeProcess  - AS3

Indica se processos nativos em execução são suportados no perfil atual. Esta propriedade retorna true apenas quando estiver sendo executada no perfil extendedDesktop. Além disso, NativeProcess.isSupported é sempre false para aplicativos instalados como um arquivo do AIR. Você precisa empacotar um aplicativo AIR usando o sinalizador ADT -target native para usar a classe NativeProcess.

Indica se este processo nativo está sendo executado no momento. O processo está sendo executado se você tiver chamado o método start() e o objeto NativeProcess ainda não tiver despachado um evento exit. Uma instância NativeProcess equivale a um processo simples no sistema operacional subjacente. Esta propriedade permanece true enquanto o processo de sistema operacional subjacente estiver sendo executado (enquanto o processo nativo estiver iniciando e até que o processo retorne um código de saída ao sistema operacional.)

Fornece o acesso à saída de erro padrão deste processo nativo. Como o dado fica disponível neste tubo, o objeto NativeProcess emite um objeto ProgressEvent. Se você tentar ler dados desse fluxo contínuo quando nenhum dado estiver disponível, o objeto NativeProcess emite uma exceção EOFError.

O tipo é IDataInput porque os dados são introduzidos da perspectiva do processo atual, embora seja uma corrente de saída do processo-filho.

Elementos da API relacionados

Fornece o acesso à entrada padrão deste processo nativo. Use este tubo para enviar dados a este processo. Cada vez que os dados são gravados na propriedade inputestes dados são gravados no tubo de entrada do processo nativo assim que possível.

O tipo é IDataOutput porque os dados são saídas da perspectiva do processo atual, embora seja um fluxo contínuo de entrada do processo-filho.

Elementos da API relacionados

Fornece o acesso ao tubo de saída padrão deste processo nativo. Use este tubo para ler dados na saída padrão do processo nativo. Quando os dados estão presentes neste tubo, o objeto NativeProcess emite um ProgressEvent. Se você tentar ler dados neste fluxo contínup quando nenhum dado estiver disponível, o objeto de NativeProcess emite um EOFError.

O tipo é IDataInput porque os dados são introduzidos da perspectiva do processo atual embora seja um fluxo contínuo de saída do processo-filho.

Elementos da API relacionados

Constrói um objeto NativeProcess não inicializado. Chame o método start() para iniciar o processo.

Elementos da API relacionados

Fecha o fluxo contínuo de entrada neste processo. Alguns aplicativos de linha de comando esperam até que o fluxo contínuo de entrada seja fechado para iniciar algumas operações. Uma vez que o fluxo contínuo está fechado, não pode ser reaberto até que o processo saia e seja iniciado novamente.

tenta sair do processo nativo.

Parâmetros

Inicia o processo nativo identificado pelas informações de inicialização especificadas. Uma vez que o processo inicia, todos os fluxos contínuos de saída e entrada serão abertos. Este método retorna imediatamente depois que a solicitação de iniciar o processo especificado foi feita ao sistema operacional. O objeto NativeProcess lança-se uma exceção IllegalOperationError se o processo estiver sendo executado no momento. O processo está sendo executado se a propriedade execução do objeto NativeProcess retorna true. Se o sistema operacional não conseguir iniciar o processo, um Erro é emitido.

Uma instância NativeProcess equivale a um processo simples no sistema operacional subjacente. Se você quiser realizar mais de uma instância do mesmo processo de sistema operacional simultaneamente, você pode criar uma instância NativeProcess por processo-filho.

Você pode invocar este método sempre que a propriedade execução do objeto NativeProcess retorna false. Isto significa que o objeto NativeProcess pode ser reutilizado. Em outras palavras, você pode construir uma instância NativeProcess, chamar o método start(), esperar o evento exit e depois chamar o método start() novamente. Você pode usar um objeto NativeProcessStartupInfo diferente enquanto o valor de parâmetro info na chamada subsequente para o método start().

A classe NativeProcess e as suas capacidades só estão disponíveis para aplicativos AIR instalados com um instalador nativo. Ao depurar, você pode passar o argumento -profile extendedDesktop para ADL para ativar a funcionalidade NativeProcess. Verifique a propriedade NativeProcess.isSupported para determinar se a comunicação do processo nativa é suportada.

Considerações de segurança importantes:

O processo nativo da API pode executar qualquer executável no sistema do usuário. Tome muito cuidado ao criar e executar comandos. Se alguma parte de um comando a ser executado tiver uma origem externa, verifique cuidadosamente se a execução do comando é segura. De mesmo modo, o seu aplicativo de AIR deve validar dados transferidos para um processo de execução.

Contudo, a validação de entrada pode ser difícil. Para evitar tais dificuldades, é melhor gravar um aplicativo nativo (tal como um arquivo EXE no Windows) que tenha APIs específicas. Estas APIs devem processar só aqueles comandos especificamente requeridos pelo aplicativo de AIR. Por exemplo, o aplicativo nativo pode aceitar só um jogo limitado de instruções, por meio do fluxo de entrada padrão.

O AIR no Windows não lhe permite executar arquivos .bat diretamente. Os arquivos .bat do Windows são executados pelo aplicativo intérprete de comando (cmd.exe). Quando você invoca um arquivo.bat, este aplicativo de comando pode interpretar argumentos passados ao comando como aplicativos adicionais para lançar. Uma inserção maliciosa de caracteres adicionais nesta string de argumentos pode fazer com que o cmd.exe execute um aplicativo perigoso ou inseguro. Por exemplo, sem a adequada validação de dados, o seu aplicativo de AIR pode chamar myBat.bat myArguments c:/evil.exe. O aplicativo de comando lançaria o aplicativo evil.exe e executaria o seu arquivo de lote.

Se você chamar o método start() com um arquivo .bat, o objeto NativeProcess emitirá uma exceção. A propriedade message do objeto Erro contém a string "Erro #3219: o NativeProcess não pode ser iniciado.";

Parâmetros

Elementos da API relacionados

Assinala que o processo nativo saiu. A propriedade exitCode contém o valor que o processo retorna ao sistema operacional de host na saída. Se o aplicativo de AIR termina o processo chamando o método exit() do objeto NativeProcess, a propriedade exitCode é definida para NaN.

Assinala que o NativeProcess fechou o fluxo contínuo de erro.

Assinala que o processo nativo tem dados disponíveis para ler no fluxo contínuo de erro padrão (stderror). O objeto NativeProcess despacha este evento quando o processo-filho elimina seu fluxo contínuo de erro padrão ou quando o buffer interno usado para comunicar-se entre os processos estiver cheio. Não grave o código que depende do tamanho deste buffer interno; ele varia entre versões e sistemas operacionais.

Assinala que a leitura do fluxo contínuo de erro padrão (stderror) falhou. O objeto NativeProcess pode despachar este evento quando o tempo de execução não pode ler dados no tubo de erro padrão do processo nativo.

Assinala que o objeto NativeProcess fechou seu fluxo contínuo de entrada chamando o método closeInput(). O objeto NativeProcess não emite este evento quando o próprio processo nativo real fecha o fluxo contínuo de entrada.

Assinala que a gravação do fluxo contínuo da entrada padrão (stdin) falhou. O objeto NativeProcess emite este evento quando o método closeInput() falha ou quando o tempo de execução não pode gravar dados no tubo de entrada padrão do processo nativo.

Assinala que o NativeProcess gravou dados no fluxo contínuo de entrada do processo-filho. O objeto NativeProcess emite este evento quando os dados são gravados no fluxo contínuo. Este evento não indica se o processo de filho leu ou não algum dos dados.

Assinala que o NativeProcess fechou seu fluxo contínuo de saída.

Assinala que o processo nativo tem dados disponíveis para ler no fluxo contínuo de saída. O objeto NativeProcess emite este evento quando o processo-filho elimina a seu fluxo contínuo stdout ou quando o buffer interno usado para comunicar-se entre os processos estiver cheio. Não grave o código que depende do tamanho deste buffer interno; ele varia entre versões e sistemas operacionais.

Assinala que a leitura do fluxo contínuo stdout falhou. O objeto NativeProcess pode despachar este evento quando o tempo de execução não pode ler dados no tubo de saída padrão do 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)