RiminiCamp 2011: un resoconto parziale

Ho avuto la fortuna di partecipare (almeno parzialmente) a questa iniziativa che vi avevo segnalato qualche giorno fa, anche se per impegni personali ho potuto assistere soltanto alla prima tavola rotonda, senza purtroppo partecipare ai barcamp del pomeriggio.
Devo dire che la mia impressione è stata ottima. Il passaggio del testimone tra il primo gruppo di relatori (i padroni di casa, Pietro Leoni, Irina Imola, Mauro Ferri, rispettivamente dirigente, assessore e web content manager  del Comune di Rimini) e il secondo (Claudio Forghieri, moderatore, Gianni Dominici, Stefano Epifani, Ernesto Belisario, Laura Sartori)  ha reso bene quella che è la transizione che sta avvenendo. I promotori dell’incontro, ancora con un approccio tradizionale al web pubblico, ai suoi linguaggi, ma perfettamente consci di essere ad un punto di svolta, hanno lasciato la parola a relatori che hanno dispiegato una visione e un linguaggio nuovo. Sia chiaro che non si intende dare all’aggettivo “tradizionale” una connotazione negativa, va ricordato che solo il 18 ottobre scorso è stato messo online il portale dati.gov.it, la prima azione concreta della PA nel campo degli open data. Con la regione Emilia Romagna che, assieme a pochi altri, può essere ben considerata uno degli early adopters.

La transizione è ben descritta dall’oggetto della tavola rotonda cui ho assistito:  “web e PA: dalle reti civiche ai social media”

Ormai tutte le amministrazioni pubbliche, a tutti i livelli, hanno un loro sito web. A causa dell’interesse crescente delle persone nei confronti dei social network, e per consentire e favorire l’esercizio della cittadinanza digitale, è necessario fare un passo in più.
I capisaldi della rivoluzione del Governo 2.0 sono due: il presidio (non la semplice presenza) nei social network, e la convinta adesione all’open data, “liberando” i dati pubblici e mettendoli a disposizione di cittadini e imprese. In breve, passare dall’informazione alla conversazione.

Non è più soltanto un problema di trasparenza, ma qualcosa che va oltre: attivare conversazioni e liberare dati possono favorire la creazione di user generated content, lo sviluppo dell’intelligenza collettiva e di reale valore pubblico. L’obiettivo delle pubbliche amministrazioni deve essere dunque quello di riconcepire il ruolo del sito web istituzionale.

Il fatto è che preseguire questo obiettivo pone sul campo una serie di problemi impegnativi, che ho provato a schematizzare ma che in realtà si sommano e si compenetrano:

I costi
I costi di accesso ai network sociali è praticamente nullo, ma gli amministratori non si devono illudere. Attivare conversazioni con i propri cittadini richiede organizzazione e preparazione. Nessuna innovazione reale si fa a costo zero, nessuna conversazione proficua può essere gestita dagli stagisti  o con gli account di SNS che restano attivi giusto per il tempo della campagna elettorale (il dato esposto da Epifani è impressionante: il 78%)

Le competenze
Le competenze (skills) vanno analizzate sui due poli della comunicazione. Da una parte, l’età media della PA rimane alta e ciò non favorisce l’adozione di nuove tecnlogie. Saper utilizzare i SNS viene ancora vista come una competenza informatica, come se per aprire un libro fossero necessarie competenze tipografiche. Il grido di battaglia dovrebbe essere “Formazione, formazione, formazione” ma la formazione costa, e nei ranghi ridotti di alcune amministrazioni il costo della perdita di un’ora di produttività per un’ora di formazione è rilevante. L’idea può essere quella dell’autoformazione, oppure la creazione di una social media policy, sul solco di altre esperienze in tal senso (Department of Justice  of Victoria, Australia).
L’altra faccia della medaglia è quella dei cittadini. Restano più che urgenti in Italia politiche di inclusione digitale, certamente sul lato delle infrastrutture ma soprattutto sul lato dell’alfabetizzazione (il digital divide, a differenza di quanto ci si aspetterebbe, non riguarda soltanto la componente più anziana della popolazione, questo quanto emerso nel corso della tavola rotonda)

Il paradigma
Il cambiamento nelle PA deve riguardare innanzitutto la forma mentis. Penso, tanto per fare un esempio, alle due ultime grosse campagne pubbliche, la PEC e il “Mettiamoci la faccia”. Trasparenza e valutazione sono elementi importanti, ma la loro applicazione è figlia di un modo “vecchio” di aprirsi ai cittadini. Lascio al lettore la ricerca delle critiche sulla PEC, dico solo che sostituire la raccomandata cartacea con quella elettronica sembra una rivoluzione a metà. Ha senso uno standard tutto italiano? E ancora: le famose faccine di Brunetta sono un tipo di feedback assolutamente limitato. Il denaro pubblico speso per i monitor touch screen che troviamo in molti sportelli pubblici non poteva essere utilizzato per progetti migliori?

La burocrazia
La P.A. non è snella, i livelli di responsabilità sono molti. L’ottica è ancora quella dell’emissione di un provvedimento (ottica importante, ma la PA moderna non può essere semplicementea una scatola nera con una istanza in ingresso e un provvedimento in uscita. Deve essere sempre più una rete di servizi, dove i cittadini contribuiscono al risultato. Sarebbe meraviglioso potenziare in senso social l’art. 11 della legge 241/1990 !

La resistenza
Molto semplicemente, davvero gli amministratori hanno voglia di mettersi in gioco? Comun-icare (mettere in comune cose) è faticoso, significa scoprire il fianco alle critiche, significa saperle gestire.

Il soggettivismo etico
Ai cittadini interessa davvero partecipare? Quanto ciò dipende dalla volontà reale di partecipazione stessa e quanto dall’usabilità della piattaforma per la comunicazione?

Insomma, di “carne al fuoco” ce n’è davvero tanta, ma spero, nell’estrema sintesi cui sono costretto, di avere dato qualche piccolissimo spunto di riflessione. Utilizzando la linkografia che vi propongo e con un bel giro per la Rete, potrete farvi un’idea della bellissima giornata di sabato. C’è una cosa che invece consiglio di fare di persona (Riminesi e non): una bella visita al Museo della Città, dove le dieci antenne wi-fi indoor (più le due esterne istallate nel 2010) assicurano una connessione stabile e veloce.

Concludo con la speranza che il Comune di Rimini, visto che il RiminiCamp del 3 dicembre ha coinciso con la Giornata Internazionale dell’open data , si adegui velocemente liberando quanti più dataset possibile. Spero inoltre che qualcun altro voglia segnalare qualche altro resoconto della giornata che copra la parte di evento che ahimè non ho potuto seguire.

Linkografia

# Il sito web del Comune di Rimini
# La pagina Facebook del Comune di Rimini
# L’account twitter del Comune di Rimini
# La timeline della discussione su twitter con hashtag #riminicamp2011
# Il vademecum per le PA sugli open data
# Le slides di Salvatore Romano (intervento della seconda tavola rotonda)

Mappa degli alberi monumentali del Comune di Rimini

Vado leggermente OT (ma solo leggermente, lo capirete più avanti) rispetto agli argomenti normalmente trattati su questo blog. Da qualche anno sono una Guardia Ecologica Volontaria (GEV), una figura istituita con la Legge Regionale Emilia-Romagna n. 23 del 1989. Le GEV, tra i compiti affidatigli, promuovono la cultura ambientale e concorrono ai compiti di protezione dell’ambiente, accertando violazioni e applicando sanzioni. All’interno delle GEV di Rimini è presente un Gruppo Censimento Arboreo. Tale Gruppo ha lo scopo di cercare, all’interno del territorio provinciale riminese, gli alberi monumentali o comunque di pregio (anche in forma di filari), censirli (laddove ci siano i requisiti, la regione applica forme particolari di tutela ai sensi dell’art. 6 della Legge Regionale Emilia Romagna n. 2 del 1977) e tenerli sotto osservazione.

Ma cosa sono esattamente gli alberi monumentali? Sono quegli esemplari arborei che presentano caratteristiche eccezionali di vetustà e di connessione al territorio, che ne esaltano l’importanza, rispetto all’insieme del patrimonio arboreo di una data zona.

Nel comune di Rimini ci sono circa 42000 alberi, di circa 190 specie, e tra questi spiccano alcuni esemplari particolari. Parliamo di esemplari tra i 100 e i 300 anni, sopravvisuti alla antropizzazione selvaggia del territorio. Si tratta di alberi riconducibili a due grossi macrogruppi: querce discendenti dalla macchia mediterranea medievale e alberi di pregio anche non autoctoni ma messi a dimora secondo il gusto estetico e botanico dell’inizio del 1800.

Nel 2010 ho contribuito a una piccola pubblicazione, “Alberi monumentali e di pregio del Comune di Rimini“, ideato e realizzato con l’Assessorato alle Politiche Ambientali ed Energetiche del Comune di Rimini.

Rientro almeno parzialmente sugli argomenti di questo blog dicendo semplicemente che, a partire dai dati raccolti per quella pubblicazione, ho creato una semplicissima Google Map sulla quale sono collocati 24 esemplari arborei del Comune di Rimini, corredati da descrizione ed una piccola immagine. Per adesso è solo un punto di partenza, visto che l’idea generale è un database, anche a partire dai dati raccolti dalle istituzioni, di tutti gli alberi sottoposti a tutela della Provincia di Rimini o comuunque meritevoli di segnalazione da parte del Corpo di cui faccio parte) .

La mia speranza è che qualcuno di voi, mentre va in giro per il territorio riminese, dopo una giornata di spiaggia o in qualsiasi periodo dell’anno, prenda in mano il proprio smartphone, si connetta a Internet e attraverso questo piccolissimo lavoro possa conoscere un ulteriore aspetto della città in cui risiedo dal 2000.

La mappa è naturalmente pubblica e si trova a quest’indirizzo. Altre informazioni sulle GEV o sui patriarchi arborei le potete trovare nella breve linkografia qui sotto. Buona gita tra gli alberi!

# Guardie Ecologiche Volontarie – Rimini
# Guida ai patriarchi arborei della provincia di Rimini
# Banca dati degli alberi monumentali della Regione Emilia-Romagna

BarCamp a Rimini

Segnalo una iniziativa piuttosto interessante che una volta tanto si svolge a due passi da casa mia. Il Comune di Rimini ha organizzato per sabato 3 dicembre un Barcamp dal titolo “La Pubblica Amministrazione in Rete”.  Si tratta, cito direttamente dal wiki, di un “un evento organizzato dal Comune di Rimini per affrontare assieme ad esperti, tecnici e cittadini temi legati alla società dell’informazione e alla cittadinanza digitale con particolare riferimento al ruolo che una pubblica amministrazione può avere per favorire la crescita della conoscenza e la partecipazione dei cittadini“.

L’appuntamento, lo ripeto, è per Sabato 3 Dicembre, al Museo di Rimini, dalle 9.30 alle 17.30.

Rimando alla pagina dedicata per la consultazione del programma completo, ma desidero segnalare che, prima del barcamp vero e proprio, si terrà una tavola rotonda alla quale parteciperanno esperti del calibro di Stefano Epifani, Gianni Dominici, Ernesto Belisario che gli assidui frequentatori dei social network credo conoscano bene.

Io farò di tutto per esserci, e voi?

Query spaziali su Google Fusion Tables

E’ stata da poco rilasciata una nuova funzionalità per l’utilizzo delle Google Fusion Tables. L’ottimo servizio di gestione dei dati by Google da questo momento supporta anche le query spaziali!
Diverse sono le possibilità, tra cui determinare i punti di interesse che si trovano all’interno di una determinata area (rettangolare o circolare) oppure determinare il numero di elementi desiderati che si trovano nelle vicinanze di una particolare coppia di coordinate.

Stavolta la mia scelta è quella di non apportare particolari modifiche al codice riportato da Google e di farvi vedere solo uno degli esempi.
Mi sono limitato dunque a prendere dei dati già presenti in Internet (più precisamente l’indirizzo degli uffici postali presenti nella Provincia di Rimini) e li ho caricati in una Google Fusion Table, registrata all’indirizzo http://tables.googlelabs.com/DataSource?dsrcid=305567 . Il caso che vi propongo è quello di selezionare gli “n” uffici postali più vicini a un determinato punto della mappa.

Quello che è davvero interessante è che, per implementare la selezione all’interno del codice javascript, viene utilizzata una notazione “SQL-like” e quindi di facile comprensione

query: “SELECT indirizzo FROM ” + tableid + ” ORDER BY ST_DISTANCE(indirizzo, LATLNG(44.03, 12.56)) LIMIT 5″

tableid è la variabile che contiene il nome della Fusion Table, per il resto si tratta di una semplice query SQL dove i parametri sono il punto da cui calcolare le distanze (44.03, 12.56) e LIMIT, cioè il numero di punti da considerare (nel nostro caso 5)

Il codice finale è questo:

<!DOCTYPE html>

<html>
<head>
<meta name=”viewport” content=”initial-scale=1.0, user-scalable=no” />
<meta http-equiv=”content-type” content=”text/html; charset=UTF-8″/>

<style>
#map_canvas { height: 300px; width:600px; }
</style>

<script type=”text/javascript” src=”http://maps.google.com/maps/api/js?sensor=false”>
<script type=”text/javascript”>

// definisce la tabella di Google Fusion da caricare

var tableid = 305567;

function initialize() {

map = new google.maps.Map(document.getElementById(‘map_canvas’), {
center: new google.maps.LatLng(44.03, 12.56),
zoom: 10,
disableDefaultUI: true,
navigationControl: true,
navigationControlOptions: {style: google.maps.NavigationControlStyle.MEDIUM},
mapTypeId: google.maps.MapTypeId.ROADMAP  });

//definisce il layer da visualizzare: la query e’ di tipo ‘Simil SQL’ e seleziona i 5 indirizzi (parametro LIMIT) più vicini al punto con coordinate 44.03 12.56
layer = new google.maps.FusionTablesLayer(tableid, {
query: “SELECT indirizzo FROM ” + tableid + ” ORDER BY ST_DISTANCE(indirizzo, LATLNG(44.03, 12.56)) LIMIT 5“  }
);
layer.setMap(map);

}
</script>
</head>
<  body onload=”initialize()”>
<div id=”map_canvas”>

</body>
</html>

mentre il risultato lo potete trovare qui.

Inutile dire che le potenzialità sono infinite. Potremmo infatti gestire come variabili sia il punto da cui calcolare le distanze (magari prendendola da un dispositivo mobile una volta impostato il parametro sensor a yes), sia il numero di markers da considerare (attraverso un FORM dal quale ricavare in input detto parametro).

Nella documentazione ufficiale Google Fusion Tables potete trovare gli altri esempi, fate qualche esperimento e… buon divertimento.

Linkografia

@ Search your geo data using spatial queries from Fusion Tables!
@ Google Fusion Table API

“Quando la Rete diventa pop”. Speranza o utopia?

Ricomincio a scrivere dopo tanto, troppo tempo, su questo blog raccontandovi di una bella serata trascorsa ieri.
Nell’ambito della manifestazione riminese Moby Cult – Incontro con l’autore, ho assistito, in compagnia di digitaladoptive, alla presentazione del libro “Network effect. Quando la rete diventa pop“, curato da Lella Mazzoli. Tra i contributi, quelli di Giovanni Boccia Artieri e di Laura Gemini, persone che ho avuto modo di conoscere durante le mie esperienze in Rete (e poi, fortunatamente, anche di persona). Il testo, a mio parere, è abbastanza complesso, non fosse altro per il fatto che la mia formazione non è di tipo sociologico. Ma è stato molto interessante apprezzare gli interventi degli autori che hanno tentato di diffondere le tematiche espresse nel libro a un audience eterogenea.

Vorrei condividere con voi le mie personali riflessioni scaturite dalla serata, riflessioni che mi hanno lasciato con una inquietudine di fondo.
E’ certamente un fatto la frequentazione dei SN da parte di strati sempre più vasti della popolazione, tanto vasti da considerare la Rete “pop” , secondo il titolo del volume. Tuttavia, a mio avviso, ci sono ancora difficoltà, o quantomeno punti non risolti. Lo stesso termine “pop”, per come è stato associato alla musica, rimanda a melodie semplici, adatte a tutti, indifferenziate, che più che creare si basano su modifiche di temi esistenti (mi sono permesso di rielaborare il lemma su Wikipedia).

Come tutte le “rivoluzioni” c’è certamente un ottimisimo di fondo, anche da parte degli studiosi di ieri sera. Le mie esperienze in Rete nascono nel 1994, ricordo bene quell’entusiasmo degli anni Novanta schiantarsi il 10 Marzo 2000, con il manifestarsi dell’Internet Bubble. Ed ecco perchè preferisco essere più cauto evidenziando le questioni ancora aperte:

1) L’effetto traino dei media tradizionali ha consentito l’accesso ai SN da parte di tantissimi utenti. Quanti di loro sfruttano davvero questi strumenti rivoluzionari? Spesso le relazioni sono superficiali, mantengono semplicemente un contatto con chi è lontano o semplicemente completa una relazione vicina con conversazioni di scarso spessore.

2) La produzione di contenuti, paradigma fondante del web 2.0, è molto limitata. Più che creare qualcosa di nuovo, ci si mette sotto una bandiera. Più facile “far parte di” che non “contribuire a“. “Diventare fan” (parlo di FB) spesso si concretizza in una semplice etichetta.

3) La scarsa partecipazione porta spesso e volentieri alla noia. I SN hanno parecchi utenti ma poi quelli effettivi sono pochi (si parla di un terzo di quel terzo di italiani che usano Internet). E quei SN dove “l’investimento partecipativo” è alto, come ad esempio Second Life, addirittura desertificano. Neanche i blog  godono di ottima salute (il mio per primo): le riflessioni costano fatica, scrivere è faticoso, ed è molto più semplice cedere alle comunicazioni superficiali sui SN).

4) Il GROSSO problema della privacy. Pur essendo d’accordo sul fatto che per le nuove generazioni il confine tra pubblico e privato è più labile, permangono problemi di consapevolezza. Le campagne come “Think before you post” o l’opuscolo “Social network: attenzione agli effetti collaterali” pubblicato dal nostro Garante per la protezione dei dati personali.

5) Privacy a parte, è ancora forte il problema complessivo del digital divide, nell’accezione squisitamente culturale e non infrastrutturale (aspetto cui comunque il nostro Paese è parecchio indietro). Chi educa all’utilizzo corretto della Rete? E’ sufficiente la pratica o, come penso io, ci vogliono strumenti culturali che gran parte della popolazione (giovani generazioni comprese) non ha? E, anticipando il punto 6, la politica ha interesse in questa educazione all’uso?

6) Il problema della politica. Da un lato ci sono forze (i frequentatori dei SN), che mettono sullo stesso piano il loro “io” pubblico e privato, che spingono alla partecipazione e alla trasparenza aziende e amministrazioni pubbliche; Dall’altro lato, ”curiosamente”, accade che in Europa, al forte sviluppo dei SN, si contrappone una produzione normativa volta ad imbrigliare l’utilizzo della Rete (la nota vicenda D’Alia, le limitazioni francesi alla net neutrality, i tentativi di equiparazione tra blog e carta stampata, solo per fare alcuni esempi). Propaganda e non partecipazione, questo è ciò che conta per chi governa (concetto ben espresso da H. Lasswell e dalla scuola di Chicago, oltre che ovviamente da quello che riesco a comprendere del concetto di “Cultura di massa”, di ”Tolleranza repressiva” e di “Concessione di libertà apparenti” di Marcuse).

Considerando tutti questi elementi, sembra che l’instaurarsi di relazioni con un minimo di creatività passi allora per le élites, gruppi ristretti di popolazione cui non interessa la massa critica. Lo stesso intervento di Laura Gemini, sull’utilizzo della Rete come stimolo alla creatività, è passato per la citazione delle avanguardie, che, mi pare, altro non siano se non élites.

Anche l’intervento di Luca Rossi mi porta alla stessa conclusione. Il videogioco è una grande metafora della società, dove chi ha la passione, la scintilla creativa, gioca, crea relazioni, tenta le via del cambiamento, e che si ritira non  appena la qualità di quella relazione decade.

Riprendo una frase di Giovanni Boccia Artieri

Cosa accade nel momento in cui milioni di persone nel mondo non sono più semplicemente pubblico di massa [...] ma possono produrre connessioni “di massa” tra loro, con e attraverso contenuti che imparano non solo a fruire ma a produrre?

A mio modo di vedere le mutazioni di cui parla Giovanni sono ancora infinitesimali, e quello che è peggio e che ci sono spinte contrarie.

La mia riflessione finale:  Internet è un fenomeno eversivo (intendiamoci, inteso come sovversione “culturale” dell’ordine costituito). L’élite che comanda la società facendo leva innanzitutto sul suo potere economico la osteggia, un’altra elite (gli “eversivi” di cui sopra) che fanno fatica a fare breccia sugli altri che, in ogni caso, utilizzano i SN con un modello che si rifà in gran parte ai media tradizionali.

Non posso far altro che concludere ringraziando gli autori per aver suscitato in me tali riflessioni, giuste o sbagliate che siano (ribadisco, non sono in grado di sostenere un approccio sociologico al problema). Ma almeno è un punto di partenza per un dibattito di cui, se vorrete, sarò felice di attenderne gli sviluppi. Nel frattempo, se volete acquistare il libro, sappiate che non ho concordato nessuna percentuale

Geocoding con Google Maps API V3: un esempio

Scopo di questo tutorial è introdurre nella maniera più semplice possibile le funzionalità geocoding offerte dalle Google Maps V3.
Supponiamo di avere una serie di indirizzi stradali dei quali non conosciamo le coordinate. Per visualizzare tali punti sulla mappa abbiamo appunto necessità di una funzione (geocoding) che, a partire da un indirizzo in formato testo, restituisce una coppia di coordinate spaziali.
Lo script che ho realizzato, ampiamente commentato, è composto da diverse parti.

La prima parte definisce e carica due array, contenenti i dati da visualizzare sulla mappa, cioè gli indirizzi stradali e le relative descrizioni

descrizioni = new Array();
indirizzi = new Array();

//popolamento vettori

indirizzi[0]=”Viale Italia 40, La Spezia, Italia”;
descrizioni[0]=”Qui sono nato e cresciuto”;
indirizzi[1]=”via pascoli 64 la spezia italia”;
descrizioni[1]=”Qui ho fatto le elementari”;
indirizzi[2]=”Via Leopardi 1 la spezia italia”;
descrizioni[2]=”Qui ho fatto le medie”;
indirizzi[3]=”via giacomo doria 2 la spezia italia”;
descrizioni[3]=”Qui ho fatto le superiori”;

Il cuore dell’applicazione è costituito dalla funzione javascipt codifica_indirizzi, che ha come parametri in ingresso un indirizzo stradale e una descrizione da visualizzare. In uscita, il risultato della funzione è un marker (ottenuto dal geocoding dell’indirizzo stradale) con la relativa descrizione. Tale funzione viene eseguita, attraverso un ciclo iterativo FOR, tante volte quanti sono gli elementi del vettore indirizzi.

function codifica_indirizzi(indirizzi, titolo)

      {
        geocoder.geocode({ ‘address’: indirizzi}, function(results, status)
           {   map.setCenter(results[0].geometry.location);
               var marker = new google.maps.Marker
                             ({ map: map,
                                 position: results[0].geometry.location,
                               title: titolo });

                                  });

             }

La funzione principale è la funzione visualizzamappa che definisce i criteri di visualizzazione della mappa (tipo ROADMAP, livello di zoom) e attiva il ciclo di scansione dei vettori indirizzi e descrizioni.

function visualizzamappa() {
                  geocoder = new google.maps.Geocoder();
                  var opzioni = {zoom: 15, mapTypeId: 
                                 google.maps.MapTypeId.ROADMAP }
                   map = new google.maps.Map(document.getElementById
                       (“map_canvas”), opzioni);

Il risultato finale lo potete trovare qui.

Piccola digressione. La funzione geocoding utilizzata si presta molto bene a codificare indirizzi inseriti dall’utente in un piccolo form come si vede in questo esempio. Ciò accade poichè la richiesta è asincrona (i dati che ci servono sono localizzati in server)

Ho avuto qualche difficoltà nella corretta visualizzazione delle descrizioni per ogni marker. Il metodo geocode() mal si accorda a soddisfare le richieste del ciclo for .  In pratica il ciclo for incrementa il contatore avanti prima che il marker potesse comparire (senza attendere cioè il risultato della richiesta fatta al server Google dalla funzione). Grazie a un suggerimento di Napolux ho focalizzato il problema e ho trovato la soluzione, “spezzando” il codice scrivendo due funzioni.

In effetti, una maniera più elegante e corretta di codificare una serie di indirizzi fissi, come quelli precaricati nel vettore, è quella di accedere al servizio di geocoding tramite una richiesta http. In questo caso avremmo però bisogno di un API Key. Magari in un altro articolo si approfondirà questo aspetto.

Visualizzazione mappe con Google Fusion Tables

Tralasciando per un attimo le nostre piccole creazioni in javascript per sfruttare le potenzialità delle Google Maps V3,  in questo post vorrei introdurre un modo estremamente semplice per visualizzare in una Google Map dati geografici che abbiamo precedentemente immagazzinato in una tabella in formato CSV,  ODS o XLS. A tale scopo possiamo sfruttare il servizio Google Fusion Tables, cui potete accedere previa identificazione con il vostro account Gmail.  
Il sistema è davvero molto semplice:

1. Cliccate su New Table
2. Prelevate il file di indirizzi che volete visualizzare dal vostro PC o direttamente da Google Spreadsheet. Cliliccate su Next
3. Selezionate l’intestazione e le colonne da includere e clicate su Next
4.  Eventualmente scrivete alcune informazioni aggiuntive sul file
5. Andate su Edit, Modify, e specificate quali dati devono essere considerati come Location (cambiandone il tipo da Text). Cliccate su Save
6. Nel menu andate in Visualize poi Map e visualizzate il risultato. Potrebbe accadere, la prima volta che visualizzate la mappa, che non venga centrata subito sui vostri punti).

Un piccolo esempio, creato per l’occasione, lo potete trovare qui.

Le potenzialità del sistema sono davvero notevoli. Diventa infatti estremamente interessante lavorare con indirizzari pubblici trovati sulla rete, oppure, per fare un altro esempio, con le collezioni di POI che vengono utilizzati dai navigatori satellitari. 

Google Fusion Tables, tra l’altro, non nasce solo per visualizzare mappe geografiche ma per elaborare graficamente esempi complessi di lavoro collaborativo tanto da prevedere un merge (unione) tra i nostri dati e quelli di altre tabelle pubbliche o private. Al di là dei nostri interessi geografici dunque, consiglio uno sguardo più che approfondito a questa nuova applicazione dei Google Labs.

Layout XML per la UI Android: primi passi

Per la costruzione della nostra prima, semplicissima, applicazione Android, ci siamo affidati a Java, linguaggio potente ma al tempo stesso complicato specie per chi non ha esperienze di programmazione (e di debugging).
Fortunatamente Android consente un’altra modalità di costruzione delle  interfacce utente (UI), basate su file XML. Scopo di questo articolo è appunto quello di ottenere lo stesso risultato del tutorial precedente utilizzando un layout XML.
Torniamo per un attimo all’applicazione dell’articolo precedente. Eclipse, o meglio un suo plugin, durante l’elaborazione ha creato automaticamente un file di layout denominato main.xml. Siccome la nostra prima applicazione ha utilizzato codice java, quel file è stato ignorato.
Ecco come eseguire le opportune modifiche alla nostra prima applicazione. Andiamo nell’Eclipse Package Explorer, poi nella cartella /res/layout/ e apriamo il file main.xml.
Per vederne la struttura, clicchiamo sulla scheda main.xml posizionato in fondo alla finestra di lavoro. Sostituiamo il contenuto col seguente codice e salviamo

<?xml version=”1.0″ encoding=”utf-8″?>
 <TextView   xmlns:android=”http://schemas.android.com/apk/res/android“
     android:layout_width=”fill_parent”
     android:layout_height=”fill_parent”
     android:text=”@string/hello”
  />

Adesso andiamo dentro la cartella res/values/ e apriamo il file strings.xml. Qui inseriremo tutte le stringhe di testo necessarie alla nostra U(ser) I(nterface).  Nell’articolo precedente abbiamo cominciato con la visualizzazione dei testi identificati dalle variabili hello and app_name. Potremmo ad esempio apportare le seguenti modifiche:

<?xml version=”1.0″ encoding=”utf-8″?>
 <resources>
  <string name=”hello”>Questo testo è contenuto nel file strings.xml</string>
  <string name=”app_name”>Viva Android, specie se uso XML</string>
</resources>

Adesso apriamo la classe java che abbiamo creato per il primo esercizio e “diciamole” di utilizzare il layout xml appena definito:

package com.example.helloandroid;
  import android.app.Activity;
  import android.os.Bundle;
  public class HelloAndroid extends Activity
     {   
         @Override    public void onCreate(Bundle  
          savedInstanceState) {  
                                                     super.onCreate(savedInstanceState);     
                                                     setContentView(R.layout.main);   
                                                  }
      } 

Invece di passare a setContentView() un oggetto View , gli abbiamo dato il riferimento al layout XML. Tale risorsa è identificata da R.layout.main, un oggetto compilato che rappresenta il layout definito in /res/layout/main.xml. Al di là delle stringhe visualizzate, il risultato è lo stesso della prima applicazione.

Tornando al file main.xml, diamo un’occhiata agli attributi (quattro) dell’elemento TextView

xmlns:android
Dichiarazione di namespace, che associa al prefisso android lo spazio dei nomi definito all’indirizzo http://schemas.android.com/apk/res/android.

android:layout_width
definisce quanto dello schermo disponibile deve essere riservato alla View.

android:layout_height
identico a android:layout_width, solo che si riferisce all’altezza dello schermo disponibile.

android:text
Definisce il testo che TextView deve visualizzare. Nell’esempio, le stringhe non sono inserite direttamente ma vengono “pescate” dal file string.xml. E’ una buona pratica perchè, in caso di modifica dei testi da visualizzare, modificheremo quest’ultimo file anzichè modificare il file di layout.

Linkografia
1) Per la realizzazione di questo piccolo post si è attinto largamente alla documentazione ufficiale di Android relativa alle UI.
2) Per la spiegazione concettuale di cosa sia un namespace si può attingere al lemma su Wikipedia , a questa risorsa di html.it o all’ottimo documento del Prof. Fabio Vitali dell’Università di Bologna.

Inserimento markers su Google Maps V3

Dopo l’articolo nel quale abbiamo imparato a visualizzare una semplice Google Map V3, tentiamo di costruire qualcosa di più utile. L’esigenza potrebbe essere quella di visualizzare su di una mappa centrata una serie di punti particolari.
Con lo scopo di facilitare la comprensione dei termini utilizzati, ricordo che secondo le specifiche di Google Maps tutto ciò che può essere identificato da coordinate geografiche é definito overlay. Un particolare tipo di overlay è il marker, cioè il singolo punto sistemato su una mappa.
Nell’esempio che vi propongo, su una Google Map vengono visualizzati i markers relativi ai luoghi dove ho abitato io e alcuni elementi della mia famiglia. Al passaggio del mouse su ogni marker viene visualizzato il tipo di scuola.
Prima  di cominciare abbiamo bisogno delle coordinate dei punti che desideriamo visualizzare. A tale scopo o annotiamo i dati forniti dal nostro gps oppure utilizziamo applicazioni di geocoding, in grado di estrarre le coordinate da un indirizzo. Possiamo far riferimento a servizi come http://mygeoposition.com/ .

Una volta ottenuti i dati, si tratta di “passarli” al nostro codice. La scelta che ho fatto è stata quella di caricare i dati in tre vettori (array), uno per le latitudini, uno per le longitudini e uno per le descrizioni dei markers.
In fase di visualizzazione, i dati dei vettori verranno letti attraverso un ciclo iterativo for.

var i = 0;
for (i=0; i<lat[1].length; i++)
{
var marker = new google.maps.Marker({
position: new google.maps.LatLng(lat[i], long[i]),
map: map, title: descr[i] });
}

Il risultato lo trovate qui mentre qui sotto potete esaminare un estratto del codice usato.

<html>
<head>
<meta name=”viewport” content=”initial-scale=1.0, user-scalable=no” />
<meta http-equiv=”content-type” content=”text/html; charset=UTF-8″/>

<script type=”text/javascript” src=”http://maps.google.com/maps/api/js?
                 sensor=false”></script>
<script type=”text/javascript”>

function carica_variabili() {

//definizione coordinate su cui centrare la mappa
var lat_centro = “44.114773″;
var long_centro = “9.8517″;

//inizializzazione vettori
var lat = new Array();
var long = new Array();
var descr = new Array();

//popolamento vettori. Per aggiungere punti è sufficiente inserire una nuova terna di
// valori:  lat[4], long[4], descr[4] e cosi’ via

lat[0] = “44.111206″;
long[0] = “9.834749″;
descr[0] = “Qui ho abitato fino al 1990″;

lat[1] = “44.117701″;
long[1] = “9.871722″;
descr[1] = “Qui ho abitato fino al 2000″;

lat[2] = “44.113025″;
long[2] = “9.843195″;
descr[2] = “Qui abita mia zia Maria”;

lat[3] = “44.118320″;
long[3] = “9.846319″;
descr[3] = “Qui abita mia sorella”;

//Opzioni della mappa: zoom livello 14, centrata su un punto particolare,
//modalità IBRIDA
var Opzioni = {
        zoom: 14, center: new google.maps.LatLng(lat_centro, long_centro),
        mapTypeId: google.maps.MapTypeId.HYBRID,
       scaleControl: false    }

var map = new google.maps.Map(document.getElementById(“map_canvas”), Opzioni);

//ciclo FOR per la lettura dei valori dei vettori e relativa visualizzazione su
//mappa
var i = 0;
for (i=0; i<lat[1].length; i++)
    {  var marker = new google.maps.Marker({
       position: new google.maps.LatLng(lat[i], long[i]),
      map: map, title: descr[i] });
    }

}
</script>
</head>

<body style=”margin:5px; padding:2px;” onload=”carica_variabili()”>

<div id=”map_canvas” style=”width: 60%; height: 60%;”></div>

</body>
</html>

Linkografia
@ Maps API V3 Overlays  (Google Code – inglese)
@ Esempio visualizzazione markers singolo (Google Code – inglese)

Installazione AVD e prima applicazione Android

In questo articolo cominceremo a familiarizzare con l’emulatore Android e scriveremo la nostra prima semplicissima applicazione.

Prima di lanciare l’emulatore, è necessario prima creare una AVD (Android Virtual Machine). Che cos’è una AVD? E’ un insieme di specifiche che ci permette di emulare un dispositivo Android anzichè un altro, diverso per configurazione hardware (la tastiera, la memoria, la presenza di una fotocamera, ecc.), la forma (skin) del dispositivo, ed altro ancora. Naturalmente possiamo creare tutti gli AVD che desideriamo, uno per ogni dispositivo da “mimare”.

Per creare un AVD usiamo uno dei tools forniti da Android SDK.

Apriamo un prompt di sistema, ed eseguiamo la riga di comando:

android create avd --target 2 --name ilmioprimoavd

Alla domanda “Do you wish to create a custom hardware profile?” premete Invio per rispondere di no.

Questo è tutto. Abbiamo il nostro AVD denominato ilmioprimoavd. Adesso siamo pronti per creare un nuovo progetto Android.

Apriamo Eclipse, selezionamo File > New > Project.
Selezioniamo “Android Project” e clicchiamo su Next.
Inseriamo i dettagli del progetto come nella figura seguente:

Nella sezione che segue qualche nota sul significato dei diversi campi. Per adesso potete anche prendere tutto per buono, saltare la parte che segue e andare avanti

---------------------------- cut here -------------------------------------------------

Project Name: il nome della directory che conterrà i file del progetto.
Application Name: il nome dell’applicazione che apparirà sul nostro dispositivo Android.
Package Name: il significato sarà certamente chiaro a chi ha familiarità con i packages del linguaggio Java. Per semplificare,  si tratta di un namespace, di un “contenitore” dove è contenuto tutto il codice. Il nome del package deve essere univoco tra tutti i packages installati sul sistema Android; per questa ragione è molto importante usare una codifica standard del tipo domain-style. L’esempio proposto utilizza il namespace ”com.tutorial“, dedicato appunto al codice che scriveremo durante i nostri tutorial. Quando saremo in grado di scrivere le nostre applicazioni, sarà opportuno utilizzare namespace appropriati (es. euripide.gps.vicinoame dove  lo sviluppatore di nome Euripide  includerà tutte le versioni dell’applicazione “Vicinoame” che sfrutta il rilevatore GPS di Android).
Create Activity: campo opzionale che identificherà la sottoclasse Activity. Per ora vi basti sapere questo.
Min SDK Version: specifica il livello minimo della versione API richiesta dalla nostra applicazione e ne definisce la compatibilità col nostro dispositivo. Se l’applicazione richiede un API Level superiore a quello supportato dal dispositivo, l’applicazione non sarà installata. La compatibilità verso il basso sarò invece assicurata.

---------------------------- cut here -------------------------------------------------

Cliccate su Finish. Il progetto è pronto ed è visibile nel Package Explorer sulla sinistra (vedi figura).

Aprite il file VivaAndroid.java, presente in src>com.tutorials.prima_applicazione.  Questo il codice creato:

package com.tutorials.prima_applicazione;
 import android.app.Activity;
 import android.os.Bundle;
 public class VivaAndroid extends Activity
  {
   /** Called when the activity is first created. */
   @Override
   public void onCreate(Bundle savedInstanceState)
    {
     super.onCreate(savedInstanceState);
     setContentView(R.layout.main);
    }
  }

Per il momento non ci preoccupiamo del significato delle istruzioni, che comunque potete cercare nell’apposita sezione reference della guida per sviluppatori Android. Limitiamoci a lavorate sul codice proposto apportando le seguenti modifiche:

package com.tutorials.prima_applicazione;
 import android.app.Activity;
 import android.os.Bundle;
 import android.widget.TextView;
 public class VivaAndroid extends Activity
 {
  /** Called when the activity is first created. */
  @Override
  public void onCreate(Bundle savedInstanceState)
   {
    super.onCreate(savedInstanceState);
    TextView tv = new TextView(this);
    tv.setText("Questa è la mia prima applicazione   
               Android!!!");
    setContentView(tv);
   }
}

Non vi resta che andare nel menu Run e selezionare “Android application“. Eclipse compilerà il file java e lo passerà all’emulatore per il risultato:

Links utili
@ Hello World (dalla guida ufficiale per sviluppatori Android)
@ Descrizione della classe TextView e del metodo setText (dalla guida ufficiale per sviluppatori)
@ Un breve tutorial video (inglese) che riprende i contenuti di questo post (nel video l’AVD non viene creato a riga di comando ma direttamente su Eclipse)