Communiceren met native processen in AIR

Adobe AIR 2 of hoger

Vanaf Adobe AIR 2 kunnen AIR-toepassingen via de opdrachtregel andere native processen uitvoeren en hiermee communiceren. Een AIR-toepassing kan bijvoorbeeld via de standaardinvoer- en uitvoerstreams een proces uitvoeren en hiermee communiceren.

Voor communicatie met een native proces moet u van een AIR-toepassing een pakket maken dat via een native installatieprogramma kan worden geïnstalleerd. Het bestandstype van het native installatieprogramma is speciaal ontworpen voor het besturingssysteem waarvoor het is gemaakt:

  • Bij Mac OS-systemen is dit een DMG-bestand.

  • Bij Windows-systemen is dit een EXE-bestand.

  • Bij Linux-systemen is dit een RPM- of DEB-pakket.

Deze toepassingen zijn ook wel bekend als toepassingen in het uitgebreide bureaubladprofiel. U kunt een native installatiebestand maken door de optie -target native op te geven, wanneer u met ADT de opdracht -package aanroept.

Overzicht van communicatie met native processen

Een AIR-toepassing in het uitgebreide bureaubladprofiel kan een bestand uitvoeren, net alsof het uitvoerbare bestand wordt aangeroepen door de opdrachtregel. De toepassing kan communiceren met de standaardstreams van het native proces. Standaardstreams zijn onder meer de standaardinvoerstream (stdin), de standaarduitvoerstream (stdout) en de standaardfoutenstream (stderr).

Opmerking: Toepassingen in het uitgebreide bureaubladprofiel kunnen ook bestanden en toepassingen starten met de methode File.openWithDefaultApplication() . Door het gebruik van deze methode heeft de AIR-toepassing echter geen toegang tot de standaardstreams. Zie Bestanden openen met de standaardsysteemtoepassing voor meer informatie.

Het volgende codevoorbeeld laat zien hoe de toepassing test.exe in de toepassingsmap moet worden gestart: De toepassing geeft het argument "hello" door als een opdrachtregelargument en er wordt een gebeurtenislistener toegevoegd aan de standaarduitvoerstream van het proces:

var nativeProcessStartupInfo:NativeProcessStartupInfo = new NativeProcessStartupInfo(); 
var file:File = File.applicationDirectory.resolvePath("test.exe"); 
nativeProcessStartupInfo.executable = file; 
var processArgs:Vector.<String> = new Vector.<String>(); 
processArgs.push("hello"); 
nativeProcessStartupInfo.arguments = processArgs; 
process = new NativeProcess(); 
process.addEventListener(ProgressEvent.STANDARD_OUTPUT_DATA, onOutputData); 
process.start(nativeProcessStartupInfo); 
public function onOutputData(event:ProgressEvent):void 
{ 
    var stdOut:ByteArray = process.standardOutput; 
    var data:String = stdOut.readUTFBytes(process.standardOutput.bytesAvailable); 
    trace("Got: ", data); 
}

Een native proces starten en sluiten

Als u een native proces wilt starten, stelt u een NativeProcessInfo-object als volgt in:

  • Maak een verwijzing naar het bestand dat u wilt starten.

  • Sla opdrachtregelargumenten op die moeten worden doorgegeven aan het proces wanneer dit wordt gestart. (optioneel)

  • Stel de werkmap van het proces in (optioneel)

Start het native proces door het NativeProcessInfo-object door te geven als de parameter van de methode start() van een NativeProcess-object.

De volgende code laat bijvoorbeeld zien hoe de toepassing test.exe in de toepassingsmap moet worden gestart: De toepassing geeft het argument "hello" door en stelt de documentenmap van de gebruiker in als de werkmap:

var nativeProcessStartupInfo:NativeProcessStartupInfo = new NativeProcessStartupInfo(); 
var file:File = File.applicationDirectory.resolvePath("test.exe"); 
nativeProcessStartupInfo.executable = file; 
var processArgs:Vector.<String> = new Vector.<String>(); 
processArgs[0] = "hello"; 
nativeProcessStartupInfo.arguments = processArgs; 
nativeProcessStartupInfo.workingDirectory = File.documentsDirectory; 
process = new NativeProcess(); 
process.start(nativeProcessStartupInfo); 

Als u het proces wilt beëindigen, roept u de methode exit() van het NativeProcess-object aan.

Als u een uitvoerbaar bestand wilt opnemen in de geïnstalleerde toepassing, dient u in het bestandsysteem te controleren of het bestand uitvoerbaar is wanneer u een pakket maakt van de toepassing. (Indien noodzakelijk, kunt u op Mac en Linux chmod gebruiken om de uitvoerbare markering in te stellen.)

Communiceren met een native proces

Als een AIR-toepassing eenmaal een native proces heeft gestart, kan de toepassing communiceren met de standaardinvoerstreams, de standaarduitvoerstreams en de standaardfoutenstreams van het proces.

Met de volgende eigenschappen van het object NativeProcess kunt u streams lezen en gegevens naar streams schrijven:

  • standardInput - Toegang tot de gegevens van de standaardinvoerstream.

  • standardOutput - Toegang tot de gegevens van de standaarduitvoerstream.

  • standardError - Toegang tot de gegevens van de standaardfoutenstream.

Schrijven naar de standaardinvoerstream

U kunt gegevens naar de standaardinvoerstream schrijven met de schrijfmethoden van de standardInput -eigenschap van het NativeProcess-object. Als de AIR-toepassing gegevens naar het proces schrijft, verzendt het NativeProcess-object standardInputProgress -gebeurtenissen.

Als er zich bij het schrijven naar de standaardinvoerstream een fout voordoet, verzendt het object NativeProcess een ioErrorStandardInput -gebeurtenis.

U kunt de invoerstream sluiten door de methode closeInput() van het object NativeProcess aan te roepen. Bij het sluiten van de invoerstream verzendt het NativeProcess-object een standardInputClose -gebeurtenis.

var nativeProcessStartupInfo:NativeProcessStartupInfo = new NativeProcessStartupInfo(); 
var file:File = File.applicationDirectory.resolvePath("test.exe"); 
nativeProcessStartupInfo.executable = file; 
process = new NativeProcess(); 
process.start(nativeProcessStartupInfo); 
process.standardInput.writeUTF("foo"); 
if(process.running) 
{ 
    process.closeInput(); 
}

De standaarduitvoerstream lezen

U kunt gegevens in de standaarduitvoerstream lezen met de leesmethoden van deze eigenschap. Wanneer de AIR-toepassing uitvoerstreamgegevens uit het proces ophaalt, verzendt het NativeProcess-object standardOutputData -gebeurtenissen.

Als er zich bij het schrijven naar de standaarduitvoerstream een fout voordoet, verzendt het object NativeProcess een standardOutputError -gebeurtenis.

Als de uitvoerstream door het proces wordt gesloten, verzendt het object NativeProcess een standardOutputClose -gebeurtenis.

Bij het lezen van gegevens van de standaardinvoerstream moeten de gegevens worden gelezen op het moment dat ze worden gegenereerd. Met andere woorden: u kunt het beste een gebeurtenislistener toevoegen voor de standardOutputData -gebeurtenis. In de standardOutputData -gebeurtenislistener leest u dan de gegevens van de standardOutput -eigenschap van het NativeProcess-object. Wacht niet op de standardOutputClose -gebeurtenis of de exit -gebeurtenis voordat u alle gegevens gaat lezen. Als u de gegevens niet leest op het moment dat ze door het native proces worden gegenereerd, kan de buffer vol raken, en kunnen er gegevens verdwijnen. Door een volle buffer kan het native proces stagneren bij het schrijven van meer gegevens. Als u geen gebeurtenislistener registreert voor de standardOutputData -gebeurtenis, raakt de buffer niet vol en stagneert het proces niet. In dit geval hebt u geen toegang tot de gegevens.

var nativeProcessStartupInfo:NativeProcessStartupInfo = new NativeProcessStartupInfo(); 
var file:File = File.applicationDirectory.resolvePath("test.exe"); 
nativeProcessStartupInfo.executable = file; 
process = new NativeProcess(); 
process.addEventListener(ProgressEvent.STANDARD_OUTPUT_DATA, dataHandler); 
process.start(nativeProcessStartupInfo); 
var bytes:ByteArray = new ByteArray(); 
function dataHandler(event:ProgressEvent):void 
{ 
    bytes.writeBytes(process.standardOutput.readBytes(process.standardOutput.bytesAvailable); 
}

De standaardfoutenstream lezen

U kunt gegevens in de standaardfoutenstream lezen met de leesmethoden van deze eigenschap. Wanneer de AIR-toepassing gegevens in de foutenstream leest, verzendt het NativeProcess-object standardErrorData -gebeurtenissen.

Als er zich bij het schrijven naar de standaardfoutenstream een fout voordoet, verzendt het object NativeProcess een standardErrorIoError -gebeurtenis.

Als de foutenstream door het proces wordt gesloten, verzendt het object NativeProcess een standardErrorClose -gebeurtenis.

Bij het lezen van gegevens van de standaardfoutstream moeten de gegevens worden gelezen op het moment dat ze worden gegenereerd. Met andere woorden: u kunt het beste een gebeurtenislistener toevoegen voor de standardErrorData -gebeurtenis. In de standardErrorData -gebeurtenislistener leest u dan de gegevens van de standardError -eigenschap van het NativeProcess-object. Wacht niet op de standardErrorClose -gebeurtenis of de exit -gebeurtenis voordat u alle gegevens gaat lezen. Als u de gegevens niet leest op het moment dat ze door het native proces worden gegenereerd, kan de buffer vol raken, en kunnen er gegevens verdwijnen. Door een volle buffer kan het native proces stagneren bij het schrijven van meer gegevens. Als u geen gebeurtenislistener registreert voor de standardErrorData -gebeurtenis, raakt de buffer niet vol en stagneert het proces niet. In dit geval hebt u geen toegang tot de gegevens.

var nativeProcessStartupInfo:NativeProcessStartupInfo = new NativeProcessStartupInfo(); 
var file:File = File.applicationDirectory.resolvePath("test.exe"); 
nativeProcessStartupInfo.executable = file; 
process = new NativeProcess(); 
process.addEventListener(ProgressEvent.STANDARD_ERROR_DATA, errorDataHandler); 
process.start(nativeProcessStartupInfo); 
var errorBytes:ByteArray = new ByteArray(); 
function errorDataHandler(event:ProgressEvent):void 
{ 
    bytes.writeBytes(process.standardError.readBytes(process.standardError.bytesAvailable); 
}

Veiligheidsoverwegingen voor communicatie met native processen

De API van het native proces kan elk uitvoerbaar bestand op het systeem van de gebruiker uitvoeren. Wees zeer voorzichtig bij het opstellen en uitvoeren van opdrachten. Als een deel van een uit te voeren opdracht van een externe bron komt, moet u zorgvuldig controleren of de opdracht veilig is om uit te voeren. Ook dient de AIR-toepassing alle gegevens die worden doorgegeven aan een uitvoerend proces te valideren.

Het valideren van invoer kan echter moeilijk zijn. Om zulke moeilijkheden te vermijden, kunt u het best een native toepassing (zoals een EXE-bestand in Windows) met specifieke API's te schrijven. Deze API's verwerken dan alleen de opdrachten die zijn gedefinieerd door de toepassing. De toepassing accepteert dan bijvoorbeeld slechts een beperkt aantal instructies via de standaardinvoerstream.

AIR op Windows staat u niet toe om .bat-bestanden rechtstreeks uit te voeren. BAT-bestanden in Windows worden uitgevoerd door het CMD.EXE, een toepassing waarmee opdrachten worden geïnterpreteerd. Wanneer u dit .bat-bestand oproept, kan deze opdrachttoepassing argumenten verwerken die aan de opdracht doorgeeft om aanvullende toepassingen te starten. Een schadelijke invoeging van extra tekens in de argumenttekenreeks kan ertoe leiden dat cmd.exe een schadelijke of onveilige toepassing uitvoert. Zonder de juiste gegevensvalidatie kan uw AIR-toepassing bijvoorbeeld myBat.bat myArguments c:/evil.exe misschien oproepen. De opdrachttoepassing start de evil.exe-toepassing naast het uitvoeren van uw batchbestand.