Oggetti condivisi

Flash Player 9 e versioni successive, Adobe AIR 1.0 e versioni successive

Un oggetto condiviso, a volte chiamato “cookie Flash”, è un file di dati che può esser creato sul computer dai siti visitati. Gli oggetti condivisi vengono comunemente utilizzati per migliorare la navigazione su Internet, ad esempio consentendo la personalizzazione dell'interfaccia di un sito Web visitato di frequente.

Informazioni sugli oggetti condivisi

Gli oggetti condivisi funzionano come i cookie dei browser. Potete utilizzare la classe SharedObject per memorizzare dati sul disco rigido locale dell'utente e richiamare tali dati durante la stessa sessione o in una sessione successiva. Le applicazioni possono accedere solo ai propri dati SharedObject e solo se sono in esecuzione nello stesso dominio. I dati non vengono inviati al server e non sono accessibili per altre applicazioni in esecuzione in altri domini, ma possono essere resi accessibili per applicazioni dello stesso dominio.

Confronto tra oggetti condivisi e cookie

I cookie e gli oggetti condivisi presentano molte analogie. Poiché la maggior parte dei programmatori Web ha dimestichezza con il funzionamento dei cookie, può essere utile effettuare un confronto tra i cookie e gli oggetti SharedObject locali.

In genere, i cookie conformi allo standard RFC 2109 hanno le seguenti proprietà:

  • Possono scadere; di norma questo accade per impostazione predefinita al termine di una sessione.

  • Possono essere disattivati dal client per siti specifici.

  • Esiste un limite di 300 cookie totali e 20 cookie per sito.

  • Le dimensioni massime di un cookie sono in genere di 4 KB.

  • In alcuni casi vengono considerati una minaccia per la protezione e vengono pertanto disattivati sul client.

  • Vengono memorizzati in una posizione specificata dal browser del client.

  • Vengono trasmessi dal client al server tramite HTTP.

    Gli oggetti condivisi hanno invece le seguenti proprietà:

  • Non scadono per impostazione predefinita.

  • Per impostazione predefinita, le dimensioni massime di un oggetto condiviso sono di 100 KB.

  • Consentono di memorizzare tipi di dati semplici (ad esempio String, Array e Date).

  • Vengono memorizzati in una posizione specificata dall'applicazione (all'interno della directory principale dell'utente).

  • Non vengono mai trasmessi tra client e server.

Informazioni sulla classe SharedObject

Utilizzando la classe SharedObject potete creare ed eliminare oggetti condivisi, nonché rilevare le dimensioni correnti di un oggetto SharedObject attualmente in uso.

Creazione di un oggetto condiviso

Per creare un oggetto SharedObject, utilizzate il metodo SharedObject.getLocal(). Di seguito viene riportata la relativa sintassi:

SharedObject.getLocal("objectName" [, pathname]): SharedObject

Nell'esempio seguente viene creato un oggetto condiviso denominato mySO:

public var mySO:SharedObject; 
mySO = SharedObject.getLocal("preferences");

Nel computer client viene creato un file denominato preferences.sol.

Il termine local si riferisce alla posizione dell'oggetto condiviso. In questo caso, Adobe® Flash® Player memorizza il file SharedObject a livello locale nella directory principale del client.

Quando si crea un oggetto condiviso, Flash Player crea una nuova directory per l'applicazione e il dominio all'interno della propria sandbox. Crea inoltre un file *.sol in cui vengono memorizzati i dati SharedObject. La posizione predefinita di questo file è una sottodirectory della directory principale dell'utente. Nella tabella seguente sono indicate le posizioni predefinite di questa directory:

Sistema operativo

Location

Windows 95/98/ME/2000/XP

c:/Documents and Settings/username/Application Data/Macromedia/Flash Player/#SharedObjects

Windows Vista/Windows 7

c:/Users/username/AppData/Roaming/Macromedia/Flash Player/#SharedObjects

Macintosh OS X

/Users/username/Library/Preferences/Macromedia/Flash Player/#SharedObjects/web_domain/path_to_application/application_name/object_name.sol

Linux/Unix

/home/username/.macromedia/Flash_Player/#SharedObjects/web_domain/path_to_application/application_name/object_name.sol

Al di sotto della directory #SharedObjects è presente una directory con un nome casuale. Ancora al di sotto si trovano una directory che corrisponde al nome host, quindi il percorso dell'applicazione e infine il file *.sol.

Ad esempio, se richiedete un'applicazione denominata MyApp.swf sull'host locale, all'interno di una sottodirectory denominata /sos, Flash Player memorizza il file *.sol nella seguente posizione in Windows XP:

c:/Documents and Settings/fred/Application Data/Macromedia/Flash Player/#SharedObjects/KROKWXRK/#localhost/sos/MyApp.swf/data.sol
Nota: se non specificate un nome nel metodo SharedObject.getLocal(), Flash Player assegna al file il nome undefined.sol.

Per impostazione predefinita, Flash consente di salvare oggetti SharedObject persistenti a livello locale con dimensioni massime di 100 KB per dominio. Questo valore può essere configurato dall'utente. Se l'applicazione tenta di salvare in un oggetto condiviso una quantità di dati che determinerebbe il superamento del limite di 100 KB, Flash Player visualizza la finestra di dialogo Archiviazione locale, che vi permette di autorizzare o negare una capacità di archiviazione locale superiore per il dominio che richiede l'accesso.

Definizione di un percorso

Potete utilizzare il parametro pathname opzionale per specificare una posizione per il file SharedObject. Il file deve essere una sottodirectory della directory SharedObject del dominio. Ad esempio, se richiedete un'applicazione sull'host locale e specificate quanto segue:

mySO = SharedObject.getLocal("myObjectFile","/");

Flash Player scrive il file SharedObject nella directory /#localhost (o /localhost se l'applicazione non è in linea). Questo approccio è utile per consentire a più applicazioni del client di accedere allo stesso oggetto condiviso. In questo caso sul client possono essere eseguite due applicazioni Flex che specificano entrambe il percorso dell'oggetto condiviso che rappresenta il livello principale del dominio; il client può quindi accedere allo stesso oggetto condiviso da entrambe le applicazioni. Per condividere dati tra più applicazioni senza persistenza, potete utilizzare l'oggetto LocalConnection.

Se specificate una directory inesistente, Flash Player non crea un file SharedObject.

Aggiunta di dati a un oggetto condiviso

Potete aggiungere dati a un file *.sol di un oggetto SharedObject utilizzando la proprietà data dell'oggetto stesso. Per aggiungere nuovi dati all'oggetto condiviso, utilizzate la seguente sintassi:

sharedObject_name.data.variable = value;

Nell'esempio seguente vengono aggiunte le proprietà userName, itemNumbers e adminPrivileges e i relativi valori a un oggetto SharedObject:

public var currentUserName:String = "Reiner"; 
public var itemsArray:Array = new Array(101,346,483); 
public var currentUserIsAdmin:Boolean = true; 
mySO.data.userName = currentUserName; 
mySO.data.itemNumbers = itemsArray; 
mySO.data.adminPrivileges = currentUserIsAdmin;

Dopo aver assegnato i valori desiderati alla proprietà data, dovete indicare a Flash Player di scrivere questi valori nel file dell'oggetto SharedObject. Per fare in modo che Flash Player scriva i valori nel file dell'oggetto SharedObject, utilizzate il metodo SharedObject.flush(), come indicato di seguito:

mySO.flush();

Se non chiamate il metodo SharedObject.flush(), Flash Player scrive i valori nel file quando l'applicazione viene chiusa. In questo caso, tuttavia, non avrete la possibilità di aumentare lo spazio di archiviazione a disposizione di Flash Player se le dimensioni dei dati superano le impostazioni predefinite. È quindi consigliabile chiamare il metodo SharedObject.flush().

Quando utilizzate il metodo flush() per scrivere oggetti condivisi sul disco rigido di un utente, dovete controllare se l'utente ha disabilitato in modo esplicito l'archiviazione locale utilizzando Gestione impostazioni di Flash Player (www.macromedia.com/support/documentation/it/flashplayer/help/settings_manager07.html), come mostrato nell'esempio seguente:

var so:SharedObject = SharedObject.getLocal("test"); 
trace("Current SharedObject size is " + so.size + " bytes."); 
so.flush();

Memorizzazione di oggetti in oggetti condivisi

Potete memorizzare oggetti semplici quali array o stringhe nella proprietà data di un oggetto SharedObject.

L'esempio seguente è una classe ActionScript che definisce i metodi che controllano l'interazione con l'oggetto condiviso. Questi metodi consentono all'utente di aggiungere e rimuovere oggetti dall'oggetto condiviso. Questa classe memorizza una raccolta ArrayCollection che contiene oggetti semplici.

package { 
    import mx.collections.ArrayCollection; 
    import flash.net.SharedObject; 
 
    public class LSOHandler { 
 
        private var mySO:SharedObject; 
        private var ac:ArrayCollection; 
        private var lsoType:String; 
 
        // The parameter is "feeds" or "sites". 
        public function LSOHandler(s:String) { 
            init(s); 
        } 
 
        private function init(s:String):void { 
            ac = new ArrayCollection(); 
            lsoType = s; 
            mySO = SharedObject.getLocal(lsoType); 
            if (getObjects()) { 
                ac = getObjects(); 
            } 
        } 
 
        public function getObjects():ArrayCollection { 
            return mySO.data[lsoType]; 
        } 
 
        public function addObject(o:Object):void { 
            ac.addItem(o); 
            updateSharedObjects(); 
        } 
 
        private function updateSharedObjects():void { 
            mySO.data[lsoType] = ac; 
            mySO.flush(); 
        } 
    } 
 
}

L'applicazione Flex seguente crea un'istanza della classe ActionScript per ognuno dei tipi di oggetti condivisi necessari. Chiama quindi i metodi appropriati per la classe quando l'utente aggiunge o rimuove blog o URL del sito.

<?xml version="1.0"?> 
<!-- lsos/BlogAggregator.mxml --> 
<mx:Application 
    xmlns:local="*" 
    xmlns:mx="http://www.adobe.com/2006/mxml" 
    creationComplete="initApp()" 
    backgroundColor="#ffffff" 
> 
    <mx:Script> 
        <![CDATA[ 
        import mx.collections.ArrayCollection; 
        import mx.utils.ObjectUtil; 
        import flash.net.SharedObject; 
 
        [Bindable] 
        public var welcomeMessage:String; 
        
        [Bindable] 
        public var localFeeds:ArrayCollection = new ArrayCollection(); 
 
        [Bindable] 
        public var localSites:ArrayCollection = new ArrayCollection(); 
 
        public var lsofeeds:LSOHandler; 
        public var lsosites:LSOHandler; 
 
        private function initApp():void { 
            lsofeeds = new LSOHandler("feeds"); 
            lsosites = new LSOHandler("sites"); 
            
            if (lsofeeds.getObjects()) { 
                localFeeds = lsofeeds.getObjects(); 
            } 
            if (lsosites.getObjects()) { 
                localSites = lsosites.getObjects(); 
            } 
        } 
        
        // Adds a new feed to the feeds DataGrid. 
        private function addFeed():void { 
            // Construct an object you want to store in the 
            // LSO. This object can contain any number of fields. 
            var o:Object = {name:ti1.text, url:ti2.text, date:new Date()}; 
            lsofeeds.addObject(o); 
    
            // Because the DataGrid's dataProvider property is 
            // bound to the ArrayCollection, Flex updates the 
            // DataGrid when you call this method. 
            localFeeds = lsofeeds.getObjects(); 
            
            // Clear the text fields. 
            ti1.text = '';        
            ti2.text = ''; 
        } 
        
        // Removes feeds from the feeds DataGrid. 
        private function removeFeed():void { 
            // Use a method of ArrayCollection to remove a feed. 
            // Because the DataGrid's dataProvider property is 
            // bound to the ArrayCollection, Flex updates the 
            // DataGrid when you call this method. You do not need 
            // to update it manually. 
            if (myFeedsGrid.selectedIndex > -1) { 
            
localFeeds.removeItemAt(myFeedsGrid.selectedIndex); 
             } 
        } 
        
        private function addSite():void { 
            var o:Object = {name:ti3.text, date:new Date()}; 
            lsosites.addObject(o); 
            localSites = lsosites.getObjects(); 
            ti3.text = '';                
        } 
        
        private function removeSite():void { 
            if (mySitesGrid.selectedIndex > -1) { 
            
localSites.removeItemAt(mySitesGrid.selectedIndex); 
            }       
        } 
 
        ]]> 
    </mx:Script> 
        
    <mx:Label text="Blog aggregator" fontSize="28"/> 
    
    <mx:Panel title="Blogs"> 
        <mx:Form id="blogForm"> 
            <mx:HBox> 
                <mx:FormItem label="Name:"> 
                    <mx:TextInput id="ti1" width="100"/> 
                </mx:FormItem> 
                <mx:FormItem label="Location:"> 
                    <mx:TextInput id="ti2" width="300"/> 
                </mx:FormItem> 
                <mx:Button id="b1" label="Add Feed" click="addFeed()"/> 
            </mx:HBox> 
 
            <mx:FormItem label="Existing Feeds:"> 
                <mx:DataGrid 
                    id="myFeedsGrid" 
                    dataProvider="{localFeeds}" 
                    width="400" 
                /> 
            </mx:FormItem> 
            <mx:Button id="b2" label="Remove Feed" click="removeFeed()"/> 
        </mx:Form> 
    </mx:Panel> 
    
    <mx:Panel title="Sites"> 
        <mx:Form id="siteForm"> 
            <mx:HBox> 
                <mx:FormItem label="Site:"> 
                    <mx:TextInput id="ti3" width="400"/> 
                </mx:FormItem> 
                <mx:Button id="b3" label="Add Site" click="addSite()"/> 
            </mx:HBox> 
 
            <mx:FormItem label="Existing Sites:"> 
                <mx:DataGrid 
                    id="mySitesGrid" 
                    dataProvider="{localSites}" 
                    width="400" 
                /> 
            </mx:FormItem> 
            <mx:Button id="b4" label="Remove Site" click="removeSite()"/> 
        </mx:Form> 
    </mx:Panel> 
    
</mx:Application>

Memorizzazione di oggetti tipizzati in oggetti condivisi

Potete memorizzare istanze ActionScript tipizzate in oggetti condivisi. A questo scopo, chiamate il metodo flash.net.registerClassAlias() per registrare la classe. Se create un'istanza della classe, la memorizzate nel membro dati dell'oggetto condiviso e successivamente estraete l'oggetto, otterrete un'istanza tipizzata. Per impostazione predefinita, la proprietà objectEncoding di un oggetto SharedObject supporta la codifica AMF3 e decomprime l'istanza memorizzata dall'oggetto SharedObject; l'istanza memorizzata conserva lo stesso tipo che avete specificato quando avete chiamato il metodo registerClassAlias().

(Solo iOS) Come impedire il backup cloud di oggetti condivisi locali

È possibile impostare la proprietà SharedObject.preventBackup per verificare se per gli oggetti condivisi locali viene eseguito il backup nel servizio di backup cloud iOS. Questa procedura è richiesta da Apple per i contenuti che possono essere rigenerati o scaricati nuovamente ed è necessaria per il corretto funzionamento dell'applicazione durante l'utilizzo non in linea.

Creazione di più oggetti condivisi

Potete creare più oggetti condivisi per la stessa applicazione Flex. A questo scopo, assegnate a ognuno di essi un nome di istanza differente, come illustrato nell'esempio seguente:

public var mySO:SharedObject = SharedObject.getLocal("preferences"); 
public var mySO2:SharedObject = SharedObject.getLocal("history");

In questo modo vengono creati un file preferences.sol e un file history.sol nella directory locale dell'applicazione Flex.

Creazione di un oggetto SharedObject protetto

Quando si crea un oggetto SharedObject locale o remoto utilizzando getLocal() o getRemote(), è disponibile un parametro opzionale di nome secure che determina se l'accesso a questo oggetto condiviso è limitato ai file SWF inviati attraverso una connessione HTTPS. Se questo parametro viene impostato su true e il file SWF viene inviato tramite HTTPS, Flash Player crea un nuovo oggetto condiviso protetto oppure acquisisce un riferimento a un oggetto condiviso protetto esistente. Questo oggetto condiviso protetto può essere letto o scritto solo da/su file SWF distribuiti tramite HTTPS che chiamano SharedObject.getLocal() con il parametro secure impostato su true. Se questo parametro viene impostato su false e il file SWF viene inviato tramite HTTPS, Flash Player crea un nuovo oggetto condiviso protetto oppure acquisisce un riferimento a un oggetto condiviso esistente.

Questo oggetto condiviso può essere letto o scritto da/su file SWF distribuito tramite connessioni non HTTPS. Se il file SWF viene distribuito tramite una connessione non HTTPS e si tenta di impostare il parametro su true, la creazione del nuovo oggetto condiviso (oppure l'accesso a un oggetto condiviso protetto esistente) non riesce, viene generato un errore e l'oggetto condiviso viene impostato su null. Se tentate di eseguire lo snippet di codice seguente da una connessione non HTTPS, il metodo SharedObject.getLocal() genera un errore:

try 
{ 
    var so:SharedObject = SharedObject.getLocal("contactManager", null, true); 
} 
catch (error:Error) 
{ 
    trace("Unable to create SharedObject."); 
}

Indipendentemente dal valore di questo parametro, gli oggetti condivisi creati vengono presi in considerazione per il conteggio dello spazio totale su disco concesso al dominio.

Visualizzazione del contenuto di un oggetto condiviso

Nella proprietà data degli oggetti condivisi vengono memorizzati dei valori. Potete eseguire il loop ciclico all'interno di un'istanza di un oggetto condiviso utilizzando un ciclo for..in, come mostrato nell'esempio seguente:

var so:SharedObject = SharedObject.getLocal("test"); 
so.data.hello = "world"; 
so.data.foo = "bar"; 
so.data.timezone = new Date().timezoneOffset; 
for (var i:String in so.data) 
{ 
    trace(i + ":\t" + so.data[i]); 
}

Eliminazione di oggetti condivisi

Per eliminare un oggetto SharedObject dal client, utilizzate il metodo SharedObject.clear(). Questa operazione non elimina le directory nel percorso predefinito degli oggetti condivisi dell'applicazione.

Nell'esempio seguente il file SharedObject viene eliminato dal client:

public function destroySharedObject():void { 
    mySO.clear(); 
}

Esempio di oggetto SharedObject

L'esempio seguente mostra che potete memorizzare oggetti semplici, ad esempio un oggetto Date, in un oggetto SharedObject senza dover serializzare e deserializzare manualmente tali oggetti.

Inizialmente vi verrà dato il benvenuto come utente che accede per la prima volta. Quando fate clic su Log Out (Disconnetti), l'applicazione memorizza la data corrente in un oggetto condiviso. Quando avviate nuovamente l'applicazione o aggiornate la pagina, il messaggio di benvenuto indicherà la data e l'ora in cui vi siete disconnessi.

Per verificare in concreto il funzionamento dell'applicazione, avviate l'applicazione, fate clic su Log Out e aggiornate la pagina. Verranno visualizzate la data e l'ora in cui avete fatto clic sul pulsante Log Out durante la visita precedente. Potete eliminare le informazioni memorizzate in qualsiasi momento facendo clic sul pulsante Delete LSO (Elimina oggetti condivisi locali).

<?xml version="1.0"?> 
<!-- lsos/WelcomeMessage.mxml --> 
<mx:Application xmlns:mx="http://www.adobe.com/2006/mxml" initialize="initApp()"> 
  <mx:Script><![CDATA[ 
  public var mySO:SharedObject; 
  [Bindable] 
  public var welcomeMessage:String; 
 
  public function initApp():void { 
     mySO = SharedObject.getLocal("mydata"); 
     if (mySO.data.visitDate==null) { 
        welcomeMessage = "Hello first-timer!" 
     } else { 
        welcomeMessage = "Welcome back. You last visited on " + 
           getVisitDate(); 
     } 
  } 
 
  private function getVisitDate():Date { 
     return mySO.data.visitDate; 
  } 
 
  private function storeDate():void { 
     mySO.data.visitDate = new Date(); 
     mySO.flush(); 
  } 
  
  private function deleteLSO():void { 
     // Deletes the SharedObject from the client machine. 
     // Next time they log in, they will be a 'first-timer'. 
     mySO.clear(); 
  } 
  
  ]]></mx:Script> 
  <mx:Label id="label1" text="{welcomeMessage}"/> 
  <mx:Button label="Log Out" click="storeDate()"/> 
  <mx:Button label="Delete LSO" click="deleteLSO()"/> 
</mx:Application>