J’ai finalement trouvé un peu de temps libre pour essayer l’une des fonctionnalités les plus intéressantes d’AIR 2: la communication inter-processus.
Pour ce premier essais je vais tenter de lancer un programme java et de communiquer avec ce dernier.

Le code java:

public class JavaTest {
	public static void main(String[] args) {
		DataOutputStream out = new DataOutputStream(System.out);
		try {
			out.writeUTF(args[0]);
			Scanner in = new Scanner(System.in);
			String mot = in.nextLine();
			out.writeUTF("vous avez envoyé le mot \" " + mot + " \"");
			out.flush();
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
}

Rien de bien sorcier: écriture sur la sortie standard de l’argument passé en paramètre du programme, puis lecture sur l’entrée standard d’une chaîne de caractère et confirmation de la réception en sortie. J’ai exporté ce programme en jar et l’ai placé dans le répertoire <application_air>/src/application/JavaTest.jar.

Le code AIR à présent. Il vous faudra bien entendu avoir installé la version beta, ainsi qu’avoir modifié le xml lié à votre application.
La balise application devra ainsi être sous cette forme:
<application xmlns= "http://ns.adobe.com/air/application/2.0beta2″>,
et vous devrez également ajouter cette balise:
<supportedProfiles>extendedDesktop</supportedProfiles>

Une fois que c’est fait, il ne vous reste qu’à écrire votre code:

private var processus:NativeProcess;
 
private function callNativeApp():void{
	// On vérifie d'abord que l'exécution de programmes tiers est permise.
	if(NativeProcess.isSupported) {
 
		// L'objet qui recueille les informations sur le programme qu'on s'apprête à exécuter.
		var lancement:NativeProcessStartupInfo = new NativeProcessStartupInfo();
 
		// La position du programme à exécuter
		lancement.executable = new File("C:/Program Files/Java/jre6/bin/java.exe");
 
		// Les arguments passés
		var args:Vector.<String> = new Vector.<String>();
		args.push("-jar");
		args.push("C:/Flex/CommInterProcessus/src/application/JavaTest.jar");
		args.push("Lancement depuis une application AIR");
		lancement.arguments = args;
 
		// On crée l'objet lié au processus à naître
		processus = new NativeProcess();
 
		// Un écouteur sur les données qui sortiront du processus
		processus.addEventListener(ProgressEvent.STANDARD_OUTPUT_DATA, onOutputData);
 
		// On lance le processus
		processus.start(lancement);
 
		// On écrit une chaîne de caractères sur l'entrée standard du processus
		processus.standardInput.writeMultiByte("test\n", "UTF-8");
	}
	else
		Alert.show("impossible à exécuter", "erreur");
}
 
public function onOutputData(event:ProgressEvent):void {
	// On affiche les données reçues
	Alert.show(processus.standardOutput.readUTF());
}

Les commentaires parlent d’eux même et l’exécution se déroule parfaitement.

Seulement il y a un hic: impossible d’envoyer autre chose que des chaînes de caractères sans générer une erreur.
Ainsi si on modifie notre programme java pour recevoir une valeur numérique codée sur un octet:

int valeur = in.nextByte();
out.writeUTF("vous avez envoyé la valeur \" " + valeur + " \"");

et qu’on modifie en conséquence notre programme AIR pour envoyer cet octet:

processus.standardInput.writeByte(10);

et bien l’octet semble ne jamais être réceptionné par notre application java puisque la sortie qui confirme la réception ne s’affiche pas. Au début j’ai pensé à un bête problème de flush, et j’ai essayé à tout hasard de fermer le flux en entrée juste après avoir envoyé l’octet:

processus.standardInput.writeByte(10);
processus.closeInput();

mais ça a eu pour unique conséquence de générer l’erreur suivante:
Error #2044: Unhandled IOErrorEvent:. text=Error #3218: Error while writing data to NativeProcess.standardInput.

J’ai eu beau chercher sur le net, je n’ai trouvé aucune information satisfaisante là dessus. Mon code est-il à l’origine du problème ou bien la beta porte t-elle bien son nom? J’aimerai bien avoir la réponse avant la Release Candidate donc si quelqu’un passe par ici et qu’il voit ce qui cloche, qu’il n’hésite pas à poster ^^