Nessun risultato. Prova con un altro termine.
Guide
Notizie
Software
Tutorial

Flerry: un bridge tra AIR e Java

Invocare metodi di classi Java tramite applicazioni AIR grazie a questo interessante progetto open source
Invocare metodi di classi Java tramite applicazioni AIR grazie a questo interessante progetto open source
Link copiato negli appunti

Con il rilascio di AIR 2.0 è ora possibile comunicare direttamente dalle nostre applicazioni AIR con processi in esecuzione nel sistema operativo. Tutto questo è reso possibile grazie alla classe NativeProcess: l'applicazione AIR sarà in grado di monitorare lo standard input (stdin) e lo standard output (stdout), nonché lo standard error (stderr), dei processi in esecuzione sul sistema operativo.

NativeProcess, come specificato da Adobe, sarà disponibile solo per quelle applicazioni AIR rilasciate come "native installer" e, in ogni caso, lo sviluppatore ha a disposizione il metodo NativeProcess.isSupported per controllare, a tempo di esecuzione, se è possibile utilizzare la classe NativeProcess.

Le applicazioni AIR 2 introducono il concetto di profilo: un profilo definisce un insieme di funzionalità supportate. Tutte le operazioni AIR sviluppate prima del rilascio dell'SDK 2.0 sono considerate appartenenti al profilo "desktop profile". Le applicazioni AIR 2, invece, garantiscono un più ampio spettro di funzionalità e sono considerate appartenenti all'"extended desktop profile". NativeProcess è una delle funzionalità specifiche dell' "extended desktop profile".

Veniamo, ora, allo scopo dell'articolo: illustrare un progetto open source che sfrutta le potenzialità di NativeProcess per invocare metodi di classi Java presenti sulla stessa macchina sulla quale è in esecuzione l'applicazione AIR.

Flerry

Flerry è un progetto open source, creato da Piotr Walczyszyn, platform evangelist di Adobe. La caratteristica principale di Flerry è quella di poter invocare "direttamente" metodi di classi Java tramite applicazioni AIR.

È possibile scaricare Flerry dal sito del progetto su Google Code.

Per invocare i metodi Java, Flerry effettua la serializzazione e la deserializzazione degli oggetti con protocollo AMF. Queste operazioni sono trasparenti al programmatore e sono effettuate tramite le librerie flex-messaging-core.jar e flex-messaging-common.jar distribuite con Adobe BlazeDS.

Installare la SDK di AIR 2

Chiaramente, per poter utilizzare le funzionalità che Air 2 ci mette a disposizione, dobbiamo installare l'SDK scaricabile direttamente dal sito di Adobe. Scarichiamo la versione 4.1 del Flex Framework, che garantisce il supporto sia per il Flash Player 10.1 che per AIR 2 runtimes.

Una volta scaricato il file compresso che contiene l'SDK dobbiamo procedere all'installazione, che è un'operazione delicata, in quanto dovremmo sostituire l'SDK di Flex 4 che attualmente utilizziamo per sviluppare le nostre applicazioni.

Per gli utenti Windows, solitamente, la SDK si trova nella directory c:Program FilesAdobeFlash Builder 4sdks, mentre per gli utenti Mac OSX la directory dove si trovano le SDK è /Applications/Adobe Flash Builder 4/sdks/ (/Applications/Adobe Flash Builder 4 Plug-in/sdks/ per chi ha installato il plugin per Eclipse).

Raggiungiamo la cartella che contiene le SDKs e scompattiamo il file che abbiamo scaricato, in modo da avere la cartella "4.1" tra le nostre SDKs.

Figura 1
screenshot

A questo punto, si può procedere con l'installazione dell'SDK all'interno di Flash Builder, in modo da poter utilizzare le classi di AIR2 all'interno dell'editor, con i vantaggi derivanti dall'autocompletamento, dal controllo sintattico e dalla funzionalità di compilazione automatica integrate nell'ambiente di sviluppo.

Per installare l'SDK dobbiamo compiere alcuni semplici passi:

  1. Apriamo la finestra delle preferenze dell'editor e poi selezioniamo la voce "Installed Flex SDKs". Clicchiamo sul pulsante "Add":
  2. Figura 2
    screenshot
  3. Selezioniamo la cartella 4.1 all'interno della cartella delle sdks che abbiamo scompattato prima e impostiamo il nome della Sdk a "Flex 4.1":
  4. Figura 3
    screenshot
  5. Una volta aggiunta la sdk la selezioniamo e la impostiamo come quella di default:
  6. Figura 4
    screenshot
  7. Ora non ci resta che utilizzare Flex 4.1 come sdk del nostro progetto.

Creiamo il progetto Java/Flex

Flerry premette di far interagire un'applicazione AIR con un'applicazione Java in esecuzione sulla nostra macchina e, quindi, dobbiamo sviluppare un'applicazione Java/Flex. Eclipse (con installato il plugin Adobe Flash Builder) ci viene in aiuto poiché ci permette di aggiungere ad un progetto Java anche le caratteristiche di un progetto Flex.

Innanzitutto, creiamo un progetto Java, come mostrato in figura:

Figura 5
screenshot

A questo punto, come detto prima, è necessario aggiungere al progetto Java le caratteristiche di progetto Flex. Cliccando sul progetto con il tasto destro del mouse si aprirà un menu da cui dobbiamo selezionare la voce "Add/Change Project Type" > "Add Flex Project Type...", come mostrato di seguito:

Figura 6
screenshot

Durante la configurazione del progetto Flex dobbiamo stare attenti a selezionare la sdk Flex 4.1 che abbiamo installato in precedenza:

Figura 7
screenshot

Siccome dobbiamo sviluppare un'applicazione AIR, non ci basta che il progetto sia "solo" di tipo Flex, ma deve essere un Flex Desktop Project. Quindi dobbiamo cambiare di nuovo la tipologia di progetto cliccando sulla voce "Add/Change Project Type" > "Convert to Flex Desktop Project":

Figura 8
screenshot

Confermiamo di voler eseguire l'operazione di conversione del progetto:

Figura 9
screenshot

Come ultima operazione di configurazione dobbiamo impostare la directory di compilazione delle classe Java. La directory in cui il compilatore Java deve posizionare le classi compilate è bin-debug/classes.

Nella preferenze del progetto, alla voce Java Build Path è necessario impostare l'output folder come mostrato in figura:

Figura 10
screenshot

Fine prima parte.

La prima applicazione

Come primo esperimento, creiamo un'applicazione in grado di invocare i metodi di una classe Java che svolge semplici operazioni matematiche (addizione e sottrazione).

Creiamo la classe MathOp e la salviamo nel package it.html.flash.nativeprocess della source-folder Java del progetto. Dalla nostra applicazione AIR invocheremo i metodi della classe MathOp attraverso l'oggetto NativeObject di Flerry.

Di seguito è riportato il codice della classe MathOp:

package it.html.flash.nativeprocess;
public class MathOp {
	public MathOp() {
	}
	
	public Integer add(Integer a, Integer b) {
		return a + b;
	}
	
	public Integer sub(Integer a, Integer b) {
		return a - b;
	}
}

Per utilizzare Flerry è necessario aggiungere la libreria flerry-1.2.0.swc al build path del progetto (copiandola nella cartella libs del progetto o tramite la finestra di gestione delle proprietà del progetto):

Figura 11
screenshot

Inoltre è necessario creare la cartella "libs" all'interno della source-folder di Flex, che deve contenere le librerie flerry-1.2.0.jar, flex-messaging-common.jar, flex-messaging-core.jar e FindJava.exe come mostrato in figura (le librerie sono contenute nel file che abbiamo scaricato in precedenza):

Figura 12
screenshot

NB: All'interno del file XML in cui sono definite le caratteristiche dell'applicazione AIR è necessario definire il profilo che la nostra applicazione deve avere. Dobbiamo scegliere il profilo extendedDesktop per poter utilizzare le funzionalità di NativeProcess. Dopo la chiusura del tag </initialWindow> dobbiamo aggiungere la seguente riga:

<supportedProfiles>extendedDesktop</supportedProfiles>

Passiamo, ora, all'applicazione vera e propria. Tra i tag <fx:Declarations> </fx:Declarations> dobbiamo definire il component NativeObject di Flerry ed "elencare" i metodi della classe java che possono essere invocati da Flex.

<fx:Declarations>
	<flerry:NativeObject id="nativeMathOp" singleton="true" source="it.html.flash.nativeprocess.MathOp" fault="faultHandler(event)">
		<flerry:NativeMethod id="addMethod" name="add" result="add_resultHandler(event)" />
		<flerry:NativeMethod id="subMethod" name="sub" result="sub_resultHandler(event)" />
	</flerry:NativeObject>
</fx:Declarations>

È necessario definire gli handler per il fault e il result delle richieste Flerry. Di seguito è riportato il codice per la definizione del faultHandler e del resultHandler per il metodo add:

protected function faultHandler(event:FaultEvent) : void {
		Alert.show(event.fault.faultDetail);
}
			
protected function add_resultHandler(event:ResultEvent) : void {
	resVal.text = event.result as String;
}

Per poter testare facilmente le invocazioni dei metodi Java costruiamo una semplice interfaccia grafica, come mostrato dalla figura:

Figura 13
screenshot

Gli event handler per il click sui pulsanti Add e Sub invocheranno i metodi Java tramite Flerry:

protected function btnAdd_clickHandler(event:MouseEvent) : void {
	nativeMathOp.add(parseInt(xVal.text), parseInt(yVal.text));
}

Comunicazione da Java ad Air

Flerry offre la possibilità di instaurare una comunicazione bidirezionale tra Java e Flex. Per ricevere messaggi da una classe Java, Flex deve registrarsi come ascoltatore di un canale sul quale l'applicazione Java è registrata come produttore.

Nell'esempio che implementiamo, creiamo un metodo nella classe Java che fa partire un thread per la generazione di numeri casuali che verranno inviati all'applicazione Flex. L'applicazione Flex dovrà registrarsi al canale di comunicazione (chiamato, nello specifico, "identificatore di correlazione") sul quale la classe Java invierà i messaggi.

Per utilizzare questa funzionalità, dobbiamo aggiungere la libreria flerry-1.2.0.jar al Java build path del progetto.

Iniziamo con la modifica della classe MathOp. È necessario aggiungere un metodo startGenerator() che avvia il thread di generazione di numeri casuali. Inoltre definiamo una classe interna MyGenerator che estende Thread e si preoccupa di preparare il messaggio (a intervalli di 3 secondi) e di inviarlo all'applicazione AIR.

public boolean startGenerator() {
		new MyGenerator().start();
		return true;
}
	
public class MyGenerator extends Thread {
	public void run() {
		while (true) {
			NativeObject.sendMessage(Math.random(), "randomNum");
			try {
				Thread.sleep(3000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}
}

Dobbiamo aggiungere all'elenco dei metodi invocabili da Flex il metodo startGenerator():

<flerry:NativeMethod id="startRandom" name="startGenerator" result="generator_resultHandler(event)" />

Quando si verifica l'evento di completamento della creazione dell'applicazione Flex, dobbiamo registrarci al canale di comunicazione Java-Flex. Il metodo messageHandler() verrà invocato ogni volta che sarà inviato un messaggio da Java a Flex.

protected function init(event:FlexEvent) : void {
	nativeMathOp.subscribe("randomNum", messageHandler);
}

protected function messageHandler(event:MessageEvent) : void {
	randomVal.text = ObjectUtil.toString(event.message.body);
}

Di seguito è riportato il codice completo dell'applicazione AIR:

<?xml version="1.0" encoding="utf-8"?>
<s:WindowedApplication xmlns:fx="http://ns.adobe.com/mxml/2009"
			   xmlns:s="library://ns.adobe.com/flex/spark"
			   xmlns:mx="library://ns.adobe.com/flex/mx" min min
			   xmlns:flerry="net.riaspace.flerry.*"  
			   creationComplete="init(event)">
	<fx:Script>
		<![CDATA[
			import mx.controls.Alert;
			import mx.events.FlexEvent;
			import mx.messaging.events.MessageEvent;
			import mx.rpc.events.FaultEvent;
			import mx.rpc.events.ResultEvent;
			import mx.utils.ObjectUtil;
			protected function faultHandler(event:FaultEvent) : void {
				Alert.show(event.fault.faultDetail);
			}
			protected function init(event:FlexEvent) : void {
				nativeMathOp.subscribe("randomNum", messageHandler);
			}
			protected function messageHandler(event:MessageEvent) : void {
				randomVal.text = ObjectUtil.toString(event.message.body);
			}
			protected function add_resultHandler(event:ResultEvent) : void {
				resVal.text = ObjectUtil.toString(event.result);
			}
			protected function sub_resultHandler(event:ResultEvent) : void{
				resVal.text = ObjectUtil.toString(event.result);
			}
			protected function generator_resultHandler(event:ResultEvent) : void{
			}
			protected function btnAdd_clickHandler(event:MouseEvent) : void {
				nativeMathOp.add(parseInt(xVal.text), parseInt(yVal.text));
			}
			protected function btnSub_clickHandler(event:MouseEvent) : void	{
				nativeMathOp.sub(parseInt(xVal.text), parseInt(yVal.text));
			}
			protected function btnRandom_clickHandler(event:MouseEvent) : void {
				nativeMathOp.startGenerator();
			}
		]]>
	</fx:Script>
	<fx:Declarations>
		<flerry:NativeObject id="nativeMathOp" singleton="true" source="it.html.flash.nativeprocess.MathOp" fault="faultHandler(event)">
			<flerry:NativeMethod id="addMethod" name="add" result="add_resultHandler(event)" />
			<flerry:NativeMethod id="subMethod" name="sub" result="sub_resultHandler(event)" />
			<flerry:NativeMethod id="startRandom" name="startGenerator" result="generator_resultHandler(event)" />
		</flerry:NativeObject>
	</fx:Declarations>
	<s:TextInput x="38" y="13"  id="xVal"/>
	<s:Label x="23" y="20" text="x:"/>
	<s:TextInput x="38" y="43"  id="yVal"/>
	<s:TextInput x="80" y="74"  id="resVal"/>
	<s:Label x="23" y="81" text="Risultato:"/>
	<s:Label x="23" y="50" text="y:"/>
	<s:Button x="171" y="14" label="Add" id="btnAdd" click="btnAdd_clickHandler(event)"/>
	<s:Button x="171" y="41" label="Sub" id="btnSub" click="btnSub_clickHandler(event)"/>
	<s:TextInput x="23" y="134" id="randomVal"/>
	<s:Button x="171" y="135" label="startRandom" id="btnRandom" click="btnRandom_clickHandler(event)"/>
</s:WindowedApplication>

E il codice della classe Java completa:

package it.html.flash.nativeprocess;
import net.riaspace.flerry.NativeObject;
public class MathOp {
	public MathOp() {}
	
	public Integer add(Integer a, Integer b) {
		return a + b;
	}
	
	public Integer sub(Integer a, Integer b) {
		return a - b;
	}
	
	public boolean startGenerator() {
		new MyGenerator().start();
		return true;
	}
	
	public class MyGenerator extends Thread {
		public void run() {
			while (true) {
				NativeObject.sendMessage(Math.random(), "randomNum");
				try {
					Thread.sleep(3000);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		}
	}
}

È possibile scaricare il progetto completo Flash Builder da questa pagina.

Conclusioni

Flerry è un progetto open source che si sta sviluppando molto velocemente. Al di là del particolare progetto, la funzionalità di interazione delle applicazioni AIR con processi nativi del sistema operativo è una funzionalità molto interessante. L'introduzione di questa funzionalità con AIR 2.0 testimonia, inoltre, la crescita che Adobe sta facendo nel campo dello sviluppo di applicazioni Desktop.


Ti consigliamo anche