JavaFX…installa e via !!!

Come argomento del periodo, oltre a Symbian, mi piace trattare quello di JavaFX…il nuovo linguaggio che permette di creare applicazioni in modo rapido..prendendo spunto da un articolo trovato in rete, ho voluto testare alcuni componenti che permettono lo sviluppo di applicazioni JavaFX. In particolare, mi riferisco all’installazione del plugin di JavaFX per eclipse e il test di un semplicissimo programmino. La versione di eclipse è la 3.2.2 -attualmente esiste una versione più recente che è Europa-, e il JDK è 1.5. Si parte. Dal menù Help->Software Updates->Manage Configurations aggiungete una nuova entry per il download del plugin, e come indirizzo usate questo:

http://download.java.net/general/openjfx/plugins/eclipse/site.xml

eclipse1

 

Selezionato il nodo JavaFx e procedete con l’installazione.

 

eclipse2

 

Al termine del download installate tutto e terminate.

 

eclipse4

 

Benissimo, a questo punto cominciamo il lavoro divertente. Creiamo un nuovo progetto Java (Java Project) che non ha niente a che fare con JavaFX, almeno per ora. Anche perchè, se guardate bene, non riuscirete a trovare alcun progetto JavaFX nel menù di creazione dei nuovi progetti. Fatto questo, tasto destro sul nome del progetto, New->Others e selezionato JavaFX File.

 

eclipse6

 

Scegliamo il nome del file, ad esempio devme.fx, e notiamo che il file appena creato ci viene aperto in edit-mode. Da qui possiamo scrivere il nostro codice, io ad esempio, ho costruito un piccolo programmino che crea un Frame dentro il quale compare un messaggio, come segue:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
import javafx.ui.*;
    Frame {
        title: "Hello World - DevME - "
        width: 300
        height: 100
        content: Box {
            content:
            [Label {
                text: "Hello World - DevMe"
                toolTipText: "Tool tip"
                font: Font {
                    size: 18
                }
                border: EmptyBorder {
                    top: 10
                    left: 10
                }
                background: Color {
                    blue: 255
                    green: 255
                    red: 255
                }
            }]
        }
        visible: true
    }

Dopo di che, possiamo eseguire la nostra applicazione per vedere se fa quello che desideriamo. Per eseguire un’applicazione JavaFX dovremmo creare una nuova Launch Configuration dal menù Run di eclipse, in particolare sarà un nuovo RUN JavaFX Application.

 

eclipse7

 

Nella dialog specifichiamo il nome del progetto nel tab Main e non dimentichiamoci di aggiungere nel tab Argument, il nome del file contenente il codice FX, nel nostro caso devme (senza estensione).

 

eclipse11

 

L’aggiunta dell’argomento da passare al programma è necessaria dal momento che la configurazione creata possiede come Main Class la shell di FX e questo implica che per ogni file da eseguire si dovrà creare una configurazione di run ad-hoc. Ed infine ecco quello che otteniamo se lanciamo il programma.

 

eclipse10

 

Il plugin che ho testato non fa una piega, funziona perfettamente. L’unica cosa che il context-assist non è così performante come funziona in Java classic, e magari il fatto di dover creare una run configruation per ogni file del progetto potrebbe essere una seccatura. L’articolo che ho letto parlava di NetBeans come IDE di riferimento, e apparentemente si riusciva a fare tutto quello che abbiamo fatto noi nel nostro esempio.

Cleanup Stack

stackCome si dice: "prima il piacere e poi il dovere…", o una cosa del genere. Dopo il concerto meraviglioso, torniamo sulle pagine di devme, a parlare di cose informatiche spero interessanti. L’argomento di questo post parla di un concetto fondamentale del sistema operativo Symbian, il Cleanup Stack che ha a che fare con la gestione della memoria. Provate a immaginare quanto sia importante poter gestire al meglio una risorsa limitata come la memoria su di un cellulare, non appena la si comincia ad occupare per intero, le prestazioni decadono. Per questo motivo, esiste il Cleanup Stack, ovvero uno stack utilizzato per gestire quegli oggetti che potenzialmente possono generare delle eccezioni (Leave) e che quindi devono liberare la memoria occupata. Consideriamo ad esempio, una variabile locale puntatore ad un oggetto sullo heap, quando accade un eccezione (Leave) il puntatore viene distrutto senza liberare la memoria da esso referenziata, che diventa quindi non più utilizzabile, causando così un memory leak (perdita di memoria). Gli oggetti che non sono leave-safe, dovrebbero -o meglio devono- essere sempre inseriti all’interno del Cleanup Stack in modo da assicurare la loro effettiva distruzione in caso di eccezione. Ad esempio, gli oggetti symbian del tipo di dato C (C object type), sono sempre creati nello heap, non sono leave-safe e quindi vanno sempre inseriti all’interno dello stack. L’esempio seguente mostra alcuni casi di gestione della memoria:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
void DevMeUnsafeL() {
    CCDevme* cdevme = new (ELeave) CCDevme;
    /* Metodo InitializaL() potenzialmente pericoloso, può generare.
    * eccezione L'oggetto non è leave-safe, dopo la creazione, in
    * caso di eccezione, né la memoria occupata sullo heap,
    * né eventuali altri oggetti da lui referenziati verranno
    *  distrutti. */
    cdevme->InitializeL();
    delete cdevme;
}
void DevMeSafeButInefficientL() {
    CCDevme* cdevme = new (ELeave) CCDevme;
    /* Per evitare l'eventuale memory leak si può usare
    * la macro TRAPD, ma che per motivi di performance
    * dovrebbe essere evitata. L'uso eccessivo di TRAPD
    * attorno ai metodi non ottimizza la dimensione e la
    * velocità del programma a run-time. */
    TRAPD(cdevme->InitializeL());
    delete cdevme;
}
void DevMeSafeL() {
    CCDevme* cdevme = new (ELeave) CCDevme;
    /* Inserisci all'interno del Cleanup Stack il referimento
    * all'oggetto creato così da poter recuperare la memoria
    * in caso di eccezione. */
    CleanupStack::PushL(cdevme);
    cdevme->InitializeL();
    ......
    ......
    /* Rimuovi dallo stackquando non è più necessario
    *  il riferimento.*/
    CleanupStack::Pop(cdevme);
    delete cdevme;
}

Gli esempi di sopra mostrano alcune possibili gestioni della memoria su Symbian OS e i commenti all’interno degli esempio ne illustrano il funzionamento. E’ chiaro che l’ultimo esempio è il più efficiente dal momento che viene aggiunto nello stack il riferimento dell’oggetto creato e rimosso in caso di eccezione senza creare memory leak e quindi ottimizzando la gestione della memoria. In generale tutti gli oggetti all’interno dello stack vengono correttamente deallocati all’occorrenza, liberando la memoria occupata. La gestione della deallocazione viene fatta dal sistema operativo. Essendo il Cleanup Stack uno stack a tutti gli effetti, la sua gestione segue quella di uno stack normale, e cioè ad ogni Push corrisponde un Pop e l’ordine dei Pop è inverso all’ordine dei Push…..ma questo è già noto vero ?! :P Esistono altri metodi statici che possono essere usati della classe CleanupStack, si rimanda al file di include e32base.h presente all’interno delle SDK di symbian per la descrizione precisa della classe, oppure qui per dare un occhiata alla classe della versione 7.0 di symbian, forse un pò vecchiotta.

WordPress Themes