1. Il riavvio di Windows in modalità provvisoria (tenere premuto il tasto F8 durante il boot e avrete la possibilità di avviare il sistema in modalità provvisoria) e quindi:
2. Aperto Registro di sistema (Regedit.exe) e cercate la cartella e wgalogon eliminarlo. You should backup up the registry beforehand, in case somethiong goes wrong. Si dovrebbe di backup del Registro di sistema in precedenza, nel caso in cui somethiong vada storto.
3. Nella vostra directory di Windows di ricerca per i file wga * e cancellarli.

Adesso riavviare nuovamente normalmente e continuare il vostro lavoro. Windows Genuine Advantage will not bother you anymore. Windows Genuine Advantage non preoccuparsi di lei più.

Nota: avevo precedentemente pubblicato un suggerimento che richiede da parte di terzi eseguibile. Now it is not required anymore. Ora non è più necessaria. Potete fare voi stessi di seguito attentamente la guida di cui sopra.

Avvertenza: usare a proprio rischio e pericolo.

SQLite è un motore SQL molto diffuso in rete, scelto da molte tecnologie web come base per la gestione dei propri dati. Questo motore SQL, a differenza di molti altri, non richiede applicativi particolari per accedere ai dati.
Ogni database è completamente contenuto in un singolo file senza nessun tipo di dipendenze esterne. Questa peculiarità offre numerosi vantaggi che hanno reso SQLite uno dei motori SQL più usati per applicazioni sviluppate per essere distribuite su dispositivi mobili, quali cellulari e palmari.
Essendo completamente contenuti in un unico file database SQLite permettono con estrema facilità il backup, la distribuzione via web e l’uso anche su memorie volatili come le chiavi USB.
Tutti questi vantaggi hanno reso SQLite la scelta più ovvia per un runtime che aspira, nel prossimo futuro, ad essere fruibile oltre che dai sistemi operativi tradizionali anche dai sistemi operativi per dispositivi mobili. Inoltre la nativa predisposizione multipiattaforma di questo motore SQL si sposa perfettamente con la filosofia delle applicazioni Adobe AIR, che cercano di permettere agli sviluppatori di creare applicazioni distribuibili su divesi sistemi operativi senza necessità di scrivere codice vincolato alle funzionalità di un dato sistema.

Adobe AIR ci permette di utilizzare quanti database riteniamo necessari per la nostra applicazione; possiamo accedere separatamente a diversi database oppure unire temporaneamente strutture di dati indipendenti tra loro per permetterci elaborazioni, anche molto complesse, di dati. Come anche per altre funzionalità offerte da Adobe AIR, per esempio l’accesso al file system, anche le connessioni SQL possono avvenire in due diverse modalità:

• connessioni sincrone
• connessioni asincrone

Database relazionali
Un database relazionale offre la possibilità di memorizzare e attingere a strutture di dati.
I dati presenti nel database sono organizzati in tabelle dove ogni riga corrisponde ad un oggetto o ad un gruppo d’informazioni e ogni colonna corrisponde ad una proprietà o singola informazione relativa alla riga di appartenenza.
In questo modo è possibile organizzare dati omogenei in strutture ben organizzate e facilmente accessibili.
Un’altra importante caratteristica dei database relazionali è la capacità di creare relazioni tra i dati presenti, In queste relazioni è necessario definire un valore, che deve essere presente in tutte le tabelle interessate, come chiave di relazione. Come chiave di relazione si deve utilizzare un dato univoco per ogni riga già presente nella tabella, se questo dato univoco non è disponibile se ne crea uno ad-hoc che per consuetudine viene chiamato ‘ID’ e servirà anche per poter accedere correttamente ai dati di una specifica riga della tabella. La maggior parte dei database relazionali permette di definire dei vincoli tra dati relazionati chiamati ‘chiavi esterne’. Queste chiavi permettono di aggiornare o eventualmente rimuovere automaticamente dati collegati tra di loro.
L’attuale implementazione SQL di Adobe AIR non permette la definizione di chiavi esterne, quindi sarà compito del programmatore rimuovere o aggiornare tutti gli eventuali dati collegati quando necessario.

Comunicare con un database SQL
Il dialetti SQL permettono di interagire con delle strutture di dati relazionali. Questi linguaggi non definiscono procedure o sequenze di operazioni da eseguire ma offrono invece al programmatore la possibilità di definire quali sono i dati da aggiungere al database. L’implementazione reale della ricerca è lasciata al motore SQL in utilizzo.
Adobe AIR supporta gran parte delle funzionalità offerte da SQLite direttamente nel codice SQL. Alcune funzionalità specifiche del linguaggio SQL come gestione di transazioni e accesso agli schemi di definizione delle tabelle del database non sono supportate direttamente dall’implementazione Actionscript 3 di Adobe AIR.
Per ovviare a questo le classi Actionscript SQL espongono delle funzioni predisposte per compensare a queste incompatibilità e permettere allo sviluppatore di non perdere la possibilità di utilizzare queste funzionalità.

Actionscript 3 definisce il namespace flash.data al cui interno sono contenute le classi offerte per lavorare con funzionalità SQL. Tra queste classi troviamo la classe SQLConnection per connettersi ad database locali, la classe SQLStatement per eseguire interrogazioni a database relazionali, la classe SQLResult per gestire i dati restituiti dal database in seguito alle nostre interrogazioni e molte altre di ausilio a quelle appena elencate.

La classe SQLConnection offre le funzionalità necessarie per connettersi ad un database sulla macchina locale. Quando ci connettiamo ad un database viene richiesto in quale file esso risiede; se questo file non esiste la classe SQLConnection può crearlo per noi se richiesto esplicitamente in fase di creazione della connessione.
Tramite questa classe possiamo monitorare le attività in corso sul database, cancellare eventuali operazioni in corso di esecuzione e gestire la cache che Adobe AIR rende disponibile per la connessione al database.
Come già detto alcune funzionalità SQL standard quali accesso agli schemi di definizione delle tabelle e la gestione delle transazioni SQL non sono supportati in Adobe AIR tramite il linguaggio SQL; la classe SQLConnection implementa queste funzionalità mancanti e le espone tramite la propria interfaccia di programmazione.

Connessioni SQL Sincrone
Adobe AIR permette di connettersi in modalità sincrona al database SQL della nostra applicazione. Quando ci connettiamo con un approccio sincrono richiediamo al runtime ed al motore SQL che tutte le operazioni effettuate sul database, siano di lettura, scrittura, modifica o rimozione, vengano eseguite appena richieste. Durante l’esecuzione di operazioni sincrone la nostra applicazione resta in attesa del loro completamento, per così dire congelata. Questo significa che tutte le animazioni in esecuzione, siano state create manualmente in Flash o siano generate da codice Actionscript, si fermeranno fino al completamento dell’operazione SQL avviata. Anche l’interazione dell’utente verso i componenti della nostra interfaccia sarà inibita durante le operazioni SQL.
Questi sono i principali svantaggi di una connessione SQL sincrona, che diventano realmente limitanti se la nostra applicazione deve processare con una frequenza elevata grandi moli di dati in lettura e scrittura; in questi casi è preferibile valutare approcci differenti altrimenti gli utenti della nostra applicazione potrebbero rimanere bloccati per diversi secondi ad ogni operazione effettuata sul database.
Il vantaggio di connessioni SQL sincrone, soprattutto se dobbiamo lavorare su piccoli volumi di dati, è che le operazioni richieste vengono eseguite in tempo reale e che siamo subito informati del loro esito. Inoltre la quantità di codice Actionscript necessario per predisporre e gestire operazioni su database SQL è decisamente minore rispetto a connessioni SQL che utilizzano approcci SLQ asincroni. Il codice SQL sincrono deve essere eseguito all’interno di costrutti try..catch per poter intercettare e gestire correttamente eventuali errori di esecuzione. Se non utilizziamo un costrutto try..catch e l’operazione SQL eseguita fallisce il runtime genererà un messaggio d’errore per un’eccezione no gestita, situazione che normalmente è preferibile evitare.

Per connettersi ad un database attraverso una connessione sincrona si procede come segue:

1. // istanza connessione SQL
2. var SQLconn:SQLConnection = new SQLConnection();
3.
4. // istanza della classe File che indica il nostro database
5. var dbFile:File = File.desktopDirectory.resolvePath( “nomeDatabase.db” );
6.
7. try {
8.  // avviamo la connessione
9. SQLconn.open( dbFile );
10.
11. } catch( error:SQLError )
12. {
13.  // gestiamo l’errore14.
}

Connessioni SQL asincrone
Adobe AIR offre un’alternativa alle connessioni SQL sincrone: le connessioni SQL asincrone. Quando ci si connette in modalità asincrona tutte le operazioni SQL vengono eseguite in parallelo all’esecuzione della nostra applicazione, permettendo così all’utente di continuare ad utilizzare il nostro prodotto senza dover attendere che l’applicazione riprenda a funzionare. Questa tecnica è indifferente al volume di dati processati dall’applicazione e ci permette di utilizzare animazioni, barre di caricamento o altro per intrattenere l’utente mentre la ci occupiamo di gestire i dati necessari.
Quando eseguiamo operazioni SQL asincrone dobbiamo registrare due funzioni da richiamare in caso di completamento o di fallimento. Queste funzioni si preoccuperanno di far proseguire il funzionamento dell’applicazione in base al risultato ottenuto. Questo approccio è sicuramente più flessibile e mantenibile di quello sincrono ma richiede più codice SQL anche per eseguire operazioni semplici.

Per connettersi ad un database attraverso una connessione sincrona si procede come segue:

1. // istanza connessione SQL
2. var SQLconn:SQLConnection = new SQLConnection();
3.
4. // funzioni da chiamare a operazione completata o fallita
5. SQLconn.addEventListener( SQLEvent.OPEN, dbConnected );
6. SQLconn.addEventListener( SQLErrorEvent.ERROR, dbConnectionError );
7.
8. // istanza della classe File che indica il nostro database
9. var dbFile:File = File.desktopDirectory.resolvePath( “nomeDatabase.db” );
10.
11. // avviamo la connessione
12. SQLconn.openAsync( dbFile );
13.
14. function dbConnected( evt:SQLEvent ):void
15. {
16.  // connessione avvenuta correttamente
17. }
18.
19. function dbConnectionError( evt:SQLErrorEvent ):void
20. {
21.  // gestiamo l’errore
22. }

Creiamo un’applicazione Adobe AIR con Flex Builder 3 che ci permetta di provare ad aprire connessioni con entrambi i possibili approcci. Apriamo Flex Builder e creiamo un nuovo progetto Flex, indicando che dovrà essere compilato per eseguire in Adobe AIR e non in ambito web, lasciamo le altre impostazioni con i valori standard offerti da Flex Builder. (Immagine 1)

Una volta creato il progetto verrà aperto in automatico il documento mxml generato per l’applicazione appena creata.
Per rendere operativa la nostra applicazione dobbiamo:

1. creare il layout dell’applicazione
2. predisporre il codice Actionscript necessario per avviare le connessioni SQL necessarie

Creiamo il layout mxml per l’applicazione
Per sperimentare l’accesso ad un database in modalità sincrona ed asincrona è necessario predisporre dei controlli grafici che ci permettano di aprire e chiudere la connessione SQL desiderata.
Definiamo quindi 4 pulsanti ed una textarea che useremo per tenere traccia delle operazioni SQL in corso.

I componenti mxml inseriti avranno il seguente aspetto:
Ad ognuno dei 4 pulsanti è stata associata una funzione event listener per l’azione di click del mouse. Andiamo a creare le funzioni predisposte per i pulsanti più alcune altre.

Aggiungiamo il codice Actionscript all’applicazione
Creiamo un tag script nel quale inseriremo il codice necessario per consentire un corretto funzionamento dell’applicazione.
La prima funzione da creare è la funzione init() associata all’evento applicationComplete, generato dall’applicazione quando il layout mxml è stato completamente disegnato ed è pronto all’uso.
La funzione crea un’istanza della classe File che accede al file del database della nostra applicazione. La prima volta che l’applicazione viene eseguita questo file non esiste e sarà creato per noi dalla classe SQLConnection all’apertura della prima connessione.

1. protected function init():void
2. {
3. var folder:File = File.applicationStorageDirectory.resolvePath( “data” );folder.createDirectory();dbFile = folder.resolvePath( “lodalDataBase.db” );}

E’ necessario definire ora le funzioni associate ai pulsanti dell’applicazione. Iniziamo a definire le due funzioni collegate ai pulsanti di apertura e chiusura di connessione asincrona.
La funzione connectAsyncToDb() crea un’istanza della classe SQLConnection e la associa alle funzioni da richiamare in caso d’apertura, chiusura o errori di connessione; infine avvia l’apertura della connessione SQL chiamando la funzione openAsync().
La funzione closeAsyncDB() richiede la chiusura della connessione asincrona.

1. protected function connectAsyncToDb():void
2. {
3. sqlConnection = new SQLConnection();
4. sqlConnection.addEventListener( SQLEvent.OPEN, sqlConnectionOpenHandler );
5. sqlConnection.addEventListener( SQLEvent.CLOSE, sqlConnectionCloseHandler );
6. sqlConnection.addEventListener( SQLErrorEvent.ERROR, sqlConnectionErrorHandler );
7. sqlConnection.openAsync( dbFile );
8. output.text += “Opening async connection…\n”;
9. }
10.
11. protected function closeAsyncDB():void
12. {
13. output.text += “Closing async connection…\n”;
14. sqlConnection.close();
15. }

Le funzioni indicate come event listeners per gli eventi asincroni che potrebbero occorrere sono le seguenti:

1. protected function sqlConnectionOpenHandler( evt:SQLEvent ):void
2. {
3. output.text += “Connected to async local db…\n”;
4. }
5.
6. protected function sqlConnectionCloseHandler( evt:SQLEvent ):void
7. {
8. output.text += “closed async db connection\n”;
9. }
10.
11. protected function sqlConnectionErrorHandler( evt:SQLErrorEvent ):void
12. {
13. output.text += “You have problems in sql operations [ “
14. + evt.error.operation + “ ]… “
15. + evt.error.message + “\n”;
16. }

Restano da definire le funzioni da utilizzare per il tentativo di connessione sincrona. L’approccio sincrono non necessità di funzioni event listener in quanto ogni operazione è eseguita istantaneamente quindi le due funzioni associate ai due pulsanti gestiscono completamente le operazioni di apertura e chiusura sincrona.

1. protected function connectSyncToDb():void
2. {
3. sqlConnection = new SQLConnection();
4. output.text += “Opening sync connection…\n”;
5.
6. try
7. {
8.  sqlConnection.open( dbFile );
9.  }catch( e:SQLError )
10. {
11.  output.text += “Sync connection error: “
12.  + e.message + “ operation type: “
13.  + e.operation + “\n”;
14.  return;
15.  }
16.
17.  output.text += “Sync connection opened!\n”;
18. }
19.
20. protected function closeSyncDB():void
21. {
22. output.text += “Closing sync connection…\n”;
23.
24. try
25. {
26.  sqlConnection.close();
27.  output.text += “closed sync db connection\n”;
28.
29. } catch( e:SQLError )
30. {
31.  output.text += “Errors closing sync db connection: “
32.  + e.message + “\n”;
33. }
34. }

Ognuna delle due funzioni esegue le proprie istruzioni SQL all’interno di un costrutto try..catch in modo da poter intercettare le eventuali eccezioni generate direttamente, a differenza dell’approccio asincrono dove gli eventuali eccezioni d’esecuzione vengono gestite dalla funzione event listener registrata per gestire gli errori.

La nostra applicazione è ora completa e ci permette di aprire e chiudere connessioni SQL sia sincrone che asincrone. Eseguendola e provando ad aprire e chiudere una connessione asincrona otterremo il risultato presentato nell’immagine seguente.(Immagine 4)

Questo ovviamente non è che un piccolo esempio di ciò che è possibile fare con Adobe AIR ed SQLite. Un buon punto di partenza per trovare maggiori informazioni, oltre a continuare a leggere UserMatter, è il portale di Adobe dedicato agli sviluppatori AIR: http://www.adobe.com/devnet/air/