Una delle maggiori novità di Flash Lite 2 è il supporto per Actionscript 2 (introdotto con il Flash Player 7), un grande passo in avanti rispetto a Flash Lite 1.1, che supportava solamente Actionscript 1 con una sintassi piuttosto vecchia (Flash 4) e molte limitazioni. Questa innovazione introduce molti elementi utili, tra cui gli shared object (oggetti condivisi).
Gli shared object sono il rimedio ad una delle mancanze più gravi della precedente versione di Flash Lite, ovvero l'impossibilità di salvare dei dati sul cellulare senza utilizzare applicazioni esterne; con gli shared object non abbiamo più bisogno di programmi di terze parti, ma possiamo salvare direttamente dati persistenti sul cellulare, così da personalizzare le applicazioni, creare classifiche per i giochi e molto altro!
Precisiamo che Flash Lite 2 non supporta totalmente gli shared object come il "cugino" Flash player 7, ma ha essenzialmente due limitazioni
- Non supporta gli shared object remoti
- Uno shared object non può essere utilizzato da più SWF
Infine, alcuni modelli di cellulare potrebbero non supportare gli shared object.
Il principio di funzionamento
Vediamo ora in maniera più approfondita il funzionamento degli shared object e come vengono illustrati dallo stesso manuale di Flash Lite 2:
«Uno shared object in Flash Lite, implementato come classe SharedObject, consente a Flash Lite di salvare dei contenuti sulla periferica quando l'applicazione viene chiusa e di caricare gli stessi data quando l'applicazione sarà aperta nuovamente»
Ovviamente mentre l'applicazione è in esecuzione e prima che venga chiusa non abbiamo bisogno degli shared object, in quanto i dati possono essere memorizzati in array, variabili e altro, rimanendo sempre disponibili nell'applicazione.
Gli shared object servono quindi a conservare i dati nel tempo, in modo che possano essere utilizzati anche in successive sessioni di utilizzo di un'applicazione.
Nota: Alcuni modelli di cellulare potrebbero eliminare i dati più vecchi memorizzati negli shared object, nel caso in cui lo spazio riservato al salvataggio di dati sia limitato e la quantità di informazioni che tentiamo di salvare sia superiore a questo limite. Come accennato infatti, non tutti i cellulari supportano gli shared object, ed alcuni modelli li supportano ma limitandone lo spazio a disposizione: consideriamo infatti che i cellulari solitamente non hanno grandi quantità di memoria, per cui dobbiamo usare gli shared object con parsimonia e buon senso.
Metodi ed eventi
Andiamo ora ad analizzare quali siano i metodi e gli eventi disponibili per la classe SharedObject. Non sono moltissimi, in quanto le operazioni che dobbiamo eseguire sono essenzialmente tre:
- scrittura di dati
- lettura di dati
- cancellazione di dati
Per queste operazioni abbiamo i seguenti metodi
flush()Scrive i dati nello Shared ObjectgetLocal()Legge lo shared object dalla memoriaclear()
In aggiunta, abbiamo alcuni metodi e proprietà utili ad ottimizzare il funzionamento degli shared object e ad avere una miglior gestione dei possibili errori. Vediamo quali sono
addListener (oggetto, funzione)
Crea un listener (ascoltatore), un oggetto che rileva la fine del caricamento dello shared Object dal cellulare. Il parametro oggetto indica lo shared object da caricare, funzione indica la funzione che gestisce l'evento e che viene richiamata una volta caricato l'oggetto.
getMaxSize()
Restituisce un valore numerico che indica la quantità massima di memoria che possiamo occupare con gli shared object. Ad esempio se il valore restituito è 1024 bytes (1 KiloByte) possiamo salvare o uno o più shared object fino al raggiungimento della capacità massima di 1024 bytes.
getSize()
Restituisce le dimensioni (in byte) di uno shared object. Può essere
utile per sapere se rischiamo di occupare troppa memoria in base al
valore restituito dal metodo getMaxSize()
onStatus
È un evento sollevato ogni volta che un errore, un'informazione o un avvertimento vengono inviati dalla classe sharedObject durante qualche operazione.
removeListener()
Come facilmente intuibile, viene utilizzato per rimuovere un listener una volta che non è più necessario.
Un elemento importante è la proprietà data, che contiene i valori memorizzati nello shared object; tale proprietà va usata sia in fase di lettura che in fase di scrittura per la memorizzazione e il recupero dei dati, come vedremo negli esempi.
Un altro comando da conoscere è System.capabilities.hasSharedObjects utile a verificare che un dispositivo supporti gli shared object. Appartiene alla classe System e consente di poter "adattare" la nostra applicazione alle diverse situazioni di compatibilità.
Come abbiamo visto i metodi esposti dalla classe sharedObject sono relativamente pochi e semplici. All'interno di un progetto è abbastanza frequente usarli praticamente tutti, poichè per ottenere efficienza e controllo sugli errori, vanno sfruttati in simbiosi.
In particolare è molto importante il metodo addListener(), in quanto la scrittura degli shared object è asincrona, per cui i dati solitamente non sono disponibili in un istante di tempo noto a priori ed è necessario un evento per gestire il flusso.
Esempi
Vediamo ora alcuni esempi, partendo da uno script piuttosto "grezzo" e migliorandolo mano a mano con l'utilizzo dei diversi metodi analizzati.
Per la semplice scrittura di uno shared object è sufficiente il metodo flush(). Questo metodo più restituire tre valori:
truese i dati sono scritti correttamentependingse viene mostrata all'utente la richiesta di consentire il salvataggio dei datifalsese i dati non possono essere salvati (in caso, ad esempio, di memoria insufficiente)
Abbiamo preso spunto e modificato l'esempio riportato dal manuale di Flash Lite:
Listato 1. Memorizzare una stringa
// carica l'oggetto di nome "large"
my_so = SharedObject.getLocal("large");
// crea il dato da memorizzare
my_so.data.name = "Stringa di testo da memorizzare";
// scrive lo shared object
my_so.flush();
// associa alla variabile flushResult il risultato
// dell'operazione (questa parte è a solo scopo di debug)
var flushResult = my_so.flush();
// Utilizza uno switch per controllare il risultato
// dell'operazione ed in base ad esso traccia un
// messaggio (sempre a solo scopo di debug)
switch (flushResult) {
case 'pending' :
trace("pending");
break;
case true :
trace("Dati scritti con successo.");
break;
case false :
trace("Fallito. Dati non scritti.");
break;
}
Viene stabilito il nome dello shared object (large), e viene valorizzato viene inserito in esso un valore ("Stringa di testo da memorizzare"), quindi con il metodo flush viene scritto lo shared object. L'operazione
viene ri-eseguita associando però il valore restituito alla variabile flushResult. Come abbiamo detto prima, ci sono 3 alternative per questo valore: esse vengono analizzate dal comando switch ed in base al valore viene mostrato un messaggio diverso.
NOTA:È consigliabile fare i test sul cellulare e non con l'emulatore. In questo caso però per avere riscontro di possibili messaggi utilizziamo dei campi di testo sullo stage, in quanto l'azione trace non ha effetto nel cellulare. Se invece dobbiamo utilizzare per forza di cose solo l'emulatore, ricordiamoci di inserire nelle impostazioni del progetto "Actionscript 2" come linguaggio, poichè anche se il manuale dichiara che gli Shared Object siano supportati anche da Actionscript 1, con tali settaggi l'emulatore sembra non supportarli correttamente.
Abbiamo visto come scrivere uno shared object e rilevare eventuali errori. Potremmo però voler prevenire eventuali errori, e questo è possibile utilizzando ad esempio i metodi getMaxSize e getSize. Vediamo un esempio pratico.
Listato 2. Verificare la memoria disponibile
my_so = SharedObject.getLocal("large");
my_so.data.name = "Stringa di testo da memorizzare";
// Controlliamo che la dimensione dello shared object non superi quella consentita
if(my_so.getSize() > SharedObject.getMaxSize()){
// Se la supera mostriamo un messaggio di errore (a scopo di debug)
trace("Spazio disponibile non sufficiente");
} else {
// Altrimenti eseguiamo le operazioni come visto in precedenza
my_so.flush();
var flushResult = my_so.flush();
switch (flushResult) {
case 'pending' :
trace("pending");
break;
case true :
trace("Dati scritti con successo.");
break;
case false :
trace("Fallito. Dati non scritti.");
break;
}
}
Aggiungendo poche righe facciamo eseguire un controllo preventivo sullo spazio disponibile. Se lo shared object risulta troppo grande verrà restituito un messaggio di errore.
Vediamo anche un esempio di lettura di uno shared object, utilizzando insieme i metodi e proprietà getLocal, addListener e data.
Listato 3. Gestire il caricamento dei dati
// Creiamo la funzione che verrà eseguita al caricamento
// dello Shared Object
function loadCompletePrefs (SharedObject:mySO) {
if (mySO.getSize() == 0) {
// Se la dimensione è zero, quindi lo SharedObject
// non esiste, dobbiamo inizializzare i dati,
// utilizzando la proprietà data
mySO.data.name = "Sigismund";
mySO.data.email = "siggy@macromedia.com";
} else {
// mostra i dati contenuti nello shared object
// utilizzando un ciclo FOR all'interno della
// proprietà data
for (var idx in mySO.data) {
trace( " " + idx +": " + mySO.data[idx] );
}
}
}
// Aggiungiamo un listener associandolo alla funzione
SharedObject.addListener( "Prefs", loadCompletePrefs );
// Carichiamo lo shared object
var Prefs:SharedObject = SharedObject.getLocal("Prefs");
Abbiamo creato una funzione da eseguire una volta avvenuto il caricamento dello shared object "Prefs". Il listener contiene il nome dello shared object che verrà caricato e il nome della funzione da eseguire.
All'interno della funzione abbiamo poi inserito i comandi relativi alla lettura dello shared object (il ciclo for da eseguire sui contenuti della proprietà data contenente i valori), inserendo anche un controllo in modo che se la dimensione fosse zero (quindi lo shared object fosse vuoto), creeremo i dati in quel momento.
L'ultimo comando che possiamo analizzare è quello relativo alla rimozione dei dati di uno shared object e dello shared object stesso, ovvero clear:
Listato 4. Rimuovere i dati
// Creiamo lo shared Object chiamato "superfoo"
var my_so:SharedObject = SharedObject.getLocal("superfoo");
// Inseriamo un valore fittizio nello shared object, a puro scopo di test
my_so.data.name = "Hector";
// Visualizziamo lo shared object PRIMA dell'uso del metodo clear
trace("before my_so.clear():");
for (var prop in my_so.data) {
trace("t"+prop);
}
trace("");
// Eseguiamo il metodo clear
my_so.clear();
// Visualizziamo lo shared object DOPO l'uso del metodo clear
trace("after my_so.clear():");
for (var prop in my_so.data) {
trace("t"+prop);
}
In questo modo creiamo un oggetto shared object (superfoo), vi inseriamo un dato fittizio (Hector) e poi tramite due cicli visualizziamo la differenza tra il prima e il dopo l'esecuzione del metodo clear.
Conclusione
Abbiamo come creare degli shared object, scriverli, leggerli ed eliminarli con pochi passaggi e controllare i possibili errori grazie i metodi a esposti dalla classe SharedObject. Ora possiamo aggiungere un alto livello di personalizzazione alle nostre applicazioni e ai nostri giochi, e soprattutto possiamo dare all'utente la possibilità di conservare dati tra diverse sessioni di un programma, potendo creare così applicazioni come rubriche, datari, agende e molto altro. Una nuova frontiera nello sviluppo con Flash Lite!
