Porting JVoiceXML su Android

UNIVERSITÀ POLITECNICA DELLE MARCHE
FACOLTA’ DI INGEGNERIA
Corso di Laurea in Ingegneria Informatica e dell’Automazione
Porting JVoiceXML su Android
Tesi di Laurea di:
Matteo Brunetti
Relatore:
Prof. Aldo Franco Dragoni
Anno Accademico 2011/2012
1
alla mia famiglia….
2
Indice Generale
Ringraziamenti…………………………………………………………………………………..4
Introduzione……………………………………………………………………………………...5
1. Android…………………………………………………………………………
1.1 Panoramica………………………………………………………………………………6
1.2 Architettura Android……………………………………………………………………..8
1.3 Software necessari……………………………………………………………………….9
1.4 Principi di programmazione……………………………………………………………13
2. JVoiceXML…………………………………………………………………….
2.1 Panoramica……………………………………………………………………………..24
2.2 Architettura JVoiceXML……………………………………………………………….25
2.3 Architettura VoiceXML…………………………………………………………………26
2.4 Software utilizzati per JVoiceXML……………………………………………………..29
3. Realizzazione del progetto…………………………………………………….
3.1 Applicazione finale……………………………………………………………………...31
3.2 Codice del progetto……………………………………………………………………..37
3.3 Config progetto…………………………………………………………………………39
4. Conclusioni………………………………………………………………………………44
5. Bibliografia………………………………………………………………………………47
3
Ringraziamenti
Finalmente ho raggiunto il primo traguardo per la strada verso l’essere Ingegnere, un sogno
coltivato fin da bambino.
Desidero ringraziare il prof. Aldo Franco Dragoni per la sua disponibilità e Luca Palazzo, Gianluca
Dolcini per le risposte ai miei dubbi, e gli aiuti, senza i quali la tesi non avrebbe prodotto alcun
risultato.
Le persone che vorrei ringraziare di più sono i miei genitori, che mi hanno sostenuto moralmente,
sia soffrendo insieme per un esame andato male e sia gioendo per un esame superato, e poi
economicamente. Li vorrei ringraziare anche perché mi hanno permesso di studiare,anche in tempi
di crisi, e raggiungere questo traguardo, per affrontare al meglio il mio futuro. “Vi voglio un mondo
di bene mamma e papà”.
Ringrazio mia sorella Claudia, alla quale voglio un bene dell’anima, per i consigli e i messaggi di
consolazione nei momenti di sconforto.
Inoltre vorrei ringraziare i miei fantastici nonni, nonna Anita, nonno Nadino, nonna Maria, e nonno
Guido che mi guarda dal cielo e so che è felice per me. Poi ringrazio i miei zii, zia Francesca, o
meglio zia “Checca”, e zio Giggi per le loro parole di conforto e incoraggiamento.
Grazie ai miei cugini Guido e Marco, con i quali ho condiviso tutti i momenti della mia vita e poi
Fabio e tutti i cugini.
Un ringraziamento va anche ai miei amici Marco Scaramucci, oltre che grande amico anche
compagno di università con il quale ho affrontato molti esami, Eleonora, Alessia P., Mattia, Davide,
insomma tutti quelli che mi sono stati vicino. Grazie a tutti.
Vorrei concludere con una frase che ripetono i miei genitori:
“se insisti, raggiungi e conquisti”
Matteo Brunetti
4
Introduzione
Negli ultimi anni abbiamo assistito a una vera e propria rivoluzione tecnologica incentrata
principalmente sulla mobilità che ha portato alla nascita e allo sviluppo di nuovi settori di mercato
in fortissima crescita. Il settore alla testa di questa rivoluzione è sicuramente quello dei telefoni
cellulari, e in particolare quello dei dispositivi conosciuti come smartphone.
È un periodo incredibile e interessante per chi si occupa di sviluppo mobile. I telefoni cellulari non
sono più semplici dispositivi per parlare, ma anzi sono dotati delle tecnologie più avanzate, come ad
esempio accelerometro, schermi touch, GPS. Tecnologie che, combinate insieme, creano a dei
prodotti così potenti da far pensare di essere destinati a diventare i prossimi PC.
Grazie all’hardware di cui sono attualmente dotati si possono creare delle applicazioni mobile
innovative e con finalità che rientrano praticamente in qualsiasi ambito della vita quotidiana: lavoro,
divertimento, tempo libero, e molto altro ancora.
I primi due capitoli di questa tesi si concentrano quindi sull’esplorare e spiegare i due grandi temi
che la caratterizzano, da una parte il sistema Android, e dall’altra l’interprete JVoiceXml.
Il tirocinio, svoltosi presso il Dipartimento di Ingegneria dell’Informazione dell’Università
Politecnica delle Marche, ha avuto come obiettivo finale la realizzazione di un sistema di
interazione vocale su robot, dotato di smartphone, attraverso lo standard VoiceXml. Nel tirocinio ha
lavorato con me un altro studente del corso di Ingegneria Informatica e dell’Automazione, Marco
Brunetti.
Pur affrontando insieme tutti i problemi, ognuno di noi si è dedicato maggiormente ad aree diverse
del progetto, inoltre, durante lo sviluppo per gestire la logica dei dialoghi, abbiamo deciso di
utilizzare un particolare linguaggio di markup che si propone come standard per le applicazioni
vocali: VoiceXML. Per utilizzare il linguaggio VoiceXml si rende necessario disporre di un
interprete, JVoiceXML, nel quale abbiamo trovato delle difficoltà ad utilizzarlo nello smartphone.
Nel terzo capitolo si descrivono le varie fasi dello sviluppo del progetto, con spiegazione di alcuni
dei meccanismi di funzionamento e descrizione dei file di configurazione.
5
1.Android
1.1 Panoramica
Creata da Google in collaborazione con l’Open Handset Alliance, il gruppo di 79 aziende che
lavorano insieme per accelerare lo sviluppo e le innovazioni nel settore mobile, Android è la prima
piattaforma completa per lo sviluppo di applicazioni mobile.
Android fu sviluppato inizialmente nel 2003 da una startup californiana di nome Android, Inc.,
fondata da Andy Rubin, Rich Miner, Nick Sears e Chris White. Siamo agli inizi del nuovo
millennio, ogni telefonino ha il proprio sistema operativo chiuso e gli smartphone più evoluti sono
quelli prodotti da Palm e quelli con a bordo Windows Mobile.
In questo scenario, la visione di Andy Rubin era di creare un sistema operativo aperto, basato su
Linux, conforme agli standard, con un'interfaccia semplice e funzionale che mettesse a disposizione
degli sviluppatori strumenti efficaci per la creazione di applicazioni. E soprattutto, a differenza di
tutti gli altri sistemi operativi sul mercato, la sua adozione doveva essere gratuita.
La svolta arriva nel luglio del 2005 quando Google acquista Android, Inc. trasformandola nella
Google Mobile Division con a capo sempre Andy Rubin. L'acquisizione fornì a Rubin i fondi e gli
strumenti per portare avanti il suo progetto. Il passo successivo fu la fondazione nel novembre dello
stesso anno della Open Handset Alliance (OHA).
Il 5 novembre 2007 L'Open Handset Alliance viene istituita ufficialmente e presenta il sistema
operativo Android. Qualche giorno dopo verrà rilasciato anche il primo Software Development Kit
(SDK) per gli sviluppatori che include: gli strumenti di sviluppo, le librerie, un emulatore del
6
dispositivo,
la
documentazione,
alcuni
progetti
di
esempio,
tutorial
e
altro.
Nel giugno del 2007 è arrivato sul mercato il primo iPhone di Apple che ha rivoluzionato il modo
concepire gli smartphone. In molti si aspettavano che Google rispondesse con un proprio
smartphone per cui la sorpresa fu grande quando presentò un intero ecosistema, un sistema
operativo capace di funzionare su molti dispositivi diversi tra loro.
Al momento del lancio Android presentava un numero molto ridotto di applicazioni: un browser
basato su webkit, una rubrica e un calendario sincronizzati con gmail e poco altro. Per invogliare i
programmatori a cimentarsi con questa nuova piattaforma, Google istituì nel gennaio del 2008 un
concorso con un montepremi di 10 milioni di dollari per le migliori 50 applicazioni. Questa strategia
si rivela però vincente in quanto al momento del lancio commerciale di Android 1.0 nel Settembre del
2008 con il primo dispositivo Android, l’HTC Dream, si è già formata un’ampia e attiva comunità di
sviluppatori pronti ad offrire le loro applicazioni sull’Android Market.
Da questo momento si susseguono una serie di versioni a distanza di pochi mesi l’una dall’altra,
Android 1.1(Febbraio 2009), Android 1.5Cupcake (Aprile 2009), Android 1.6 Donut (Settembre
2009), Android 2.0 Éclair (Ottobre 2009),
Android 2.2 Froyo (Maggio 2010),
Android 2.3
Gingerbread (Dicembre 2010), tutte basate su linux kernel 2.6.
Vengono introdotte sempre nuove funzionalità e miglioramenti a quelle esistenti, di particolare
interesse per questo lavoro risultano le funzionalità di Voice Input e Text-to-Speech dalla versione
1.6 in avanti.
Nel Febbraio 2011 esce Android 3.0 Honeycomb, versione dedicata esclusivamente ai tablet.
Infine nell’Ottobre 2011 viene rilasciata pubblicamente l’ultima versione, Android 4.0 Ice Cream
Sandwich, basata su kernel Linux 3.0.
Per dare un’idea delle dimensioni raggiunte, nell’Ottobre del 2011 erano presenti più di 500,000
applicazioni disponibili per Android con un numero stimato di download totali superiore ai10
miliardi dall’Android Market.
Già dalla fine del 2010 Android è diventata la piattaforma più usata per gli smartphones, nel primo
quadrimestre del 2012 ha una quota di mercato del 59% con una base di 331 milioni di dispositivi.
Attualmente sono disponibili diverse piattaforme mobile, come ad esempio Windows Phone 7, iOS,
Symbian, Linux Mobile(LiMO). Le peculiarità che rendono speciale Android sono:
Completamente open source.
Altissima diffusione.
Costi ridotti di accesso e di sviluppo.
Gestione automatica del ciclo di vita dell’applicazione.
7
Estremamente portabile: può essere implementata per una grande varietà di hardware
differente (non solo smartphone, ma anche internet tablet, ebook reader, netbook).
Gestione della grafica e del suono di altissima qualità.
1.2 Architettura Android
Android, essendo un sistema operativo di moderna fattura, è abbastanza complesso. Anche se il suo
target sono i dispositivi mobili, l’architettura di Android ha poco da invidiare a quelle dei comuni
sistemi per desktop o laptop. Tale architettura è presentata schematicamente in Fig.1.
Fig. 1: L’architettura di Google Android
Come si evince dalla figura, Google ha attinto a piene mani dal mondo Open Source. Il cuore di
ogni sistema Android, tanto per cominciare, è un kernel Linux, versione 2.6. Direttamente nel
kernel sono inseriti i driver per il controllo dell’hardware del dispositivo: driver per la tastiera, lo
schermo, il touchpad, il Wi-Fi, il Bluetooth, il controllo dell’audio e così via. Sopra il kernel
poggiano le librerie fondamentali, anche queste tutte mutuate dal mondo Open Source. Da citare
8
sono senz’altro OpenGL, per la grafica, SQLite, per la gestione dei dati, e WebKit, per la
visualizzazione delle pagine Web.
L’architettura prevede poi una macchina virtuale e una libreria fondamentale che, insieme
costituiscono la piattaforma di sviluppo per le applicazioni Android. Questa macchina virtuale si
chiama Dalvik, e sostanzialmente è una Java Virtual Machine. Alcune delle caratteristiche di Dalvik
e della sua libreria non premettono di identificare immediatamente la piattaforma Java disponibile
in Android con una di quelle di riferimento (Java SE, Java ME).
Nel penultimo strato dell’architettura è possibile rintracciare i gestori e le applicazioni di base del
sistema. Ci sono gestori per le risorse, per le applicazioni installate, per le telefonate, il file system e
altro ancora. Infine, sullo strato più alto dell’architettura, poggiano gli applicativi destinati all’utente
finale. Molti, naturalmente, sono già inclusi con l’installazione di base: il browser ed il player
multimediale sono dei facili esempi.
1.3 Software Necessari
Android SDK
Per sviluppare applicazioni in grado di girare su sistemi Android, è necessario installare sul proprio
PC un apposito kit di sviluppo (SDK), che sia completo di emulatore, librerie e documentazione.
La prima buona notizia è che l’Android SDK è disponibile gratuitamente e senza discriminazioni
per sistemi Windows, Linux e MacOS X. Come inizio, non c’è male. È possibile scaricarlo
collegandosi all’indirizzo: http://developer.android.com/sdk/. In particolare, è richiesto che il
sistema disponga già di un Java SDK (JDK) versione 5 o successiva. È strettamente indispensabile
soddisfare questo requisito, poiché Android si programma in Java, e senza un JDK non è possibile
compilare il codice.
9
ADT per Eclipse
Benché Android SDK disponga di script che automatizzano l’installazione delle applicazioni, il
lancio dell’emulatore e il debug del codice, lavorare in un ambiente integrato, con ogni opzione a
portata di clic, è sicuramente più facile. Specie quando l’ambiente integrato si chiama Eclipse.
Nel sito di Android è disponibile anche un plug-in per la celebre piattaforma di sviluppo Open
Source. Questo add-on si chiama Android Development Tools for Eclipse, che abbreviato diventa
ADT.
Il modulo funziona con le più recenti versioni di Eclipse, che sono la 3.3, la 3.4 e anche la nuova
3.5. Può essere installato direttamente dall’interno della piattaforma di sviluppo. Avviate Eclipse ed
eseguite il wizard per l’installazione di nuovi componenti. In Eclipse 3.5 lo si fa con la voce di
menu “Help » Install New Software”. Nella 3.4 la voce di menu è “Help » Software Updates”, e poi
si deve selezionare la scheda “Available software”. In Eclipse 3.3, infine, la voce di menu da
richiamare è “Help » Software Updates » Find and install”, scegliendo poi “Search for new features
to install”. Giunti a destinazione, scegliete l’opzione per aggiungere un nuovo sito remoto alla lista
delle
fonti
presentate
dal
wizard
(pulsante
“Add”).
L’indirizzo
da
specificare
è:
https://dl-ssl.google.com/android/eclipse/r. A questo punto selezionate la voce corrispondente alla
nuova fonte e procedete attraverso i singoli passi del wizard. Il plug-in per lo sviluppo del software
Android sarà automaticamente scaricato e installato.
10
Dopo il riavvio di Eclipse, recatevi immediatamente nella schermata delle preferenze dell’ambiente
(voce di menu “Window » Preferences”). Qui troverete disponibile la nuova categoria “Android”,
nell’elenco sulla sinistra. Selezionatela e impostate il percorso del vostro Android SDK: è
necessario affinché Eclipse possa agganciare il kit di sviluppo.
11
AVD - Android Virtual Device
Il kit di sviluppo comprende un emulatore che ci consentirà di provare le nostre creazioni sul PC,
prima di installarle su un reale dispositivo equipaggiato con Android. Il primo concetto che si deve
assimilare è quello che ha nome Android Virtual Device (AVD), cioè dispositivo virtuale Android.
Nel nostro PC possiamo creare e configurare quanti dispositivi virtuali vogliamo. È come avere
tanti differenti smartphone da utilizzare per i propri test, solo che invece di dispositivi di plastica e
silicio si tratta di macchine virtuali, fatte cioè di puro software, da eseguire attraverso l’emulatore.
In questo modo è anche possibile avviare contemporaneamente sullo stesso PC due o più dispositivi
virtuali, ad esempio per testare un’applicazione che fa interagire più smartphone, come una chat o
un gioco multiplayer. Ogni AVD è configurato almeno con un nome, una versione di SDK
supportata, un valore che indica la quantità di memoria da riservare per la scheda SD e una
risoluzione per lo schermo.
12
Una volta impostata, è possibile avviare la macchina emulata, ottenendo una finestra simile a
quanto si vede nell’immagine sottostante. Questa ci permette di interagire con il device virtuale,
anche se ovviamente ci sono delle limitazioni, trattandosi di un emulatore.
1.4 Principi di Programmazione
Le applicazioni Android sono distribuite sotto forma di file APK (Android Package). Al loro interno
vengono raccolti gli eseguibili in formato DEX, le eventuali risorse associate e una serie di
descrittori che delineano il contenuto del pacchetto. In particolare, nel cosiddetto manifesto,
vengono dichiarate le attività, i servizi, i provider e i receiver compresi nel pacchetto, in modo che il
sistema possa agganciarli e azionarli correttamente.
Android fornisce una collezione di controlli studiati e progettati appositamente per i device mobili:
il
cuore
di
questi
controlli
è
rappresentato
da
due
classi,
android.view.View
e
android.view.ViewGroup. Una View è sostanzialmente un’area rettangolare nello schermo
responsabile del disegno degli elementi grafici e della cattura e gestione degli eventi generati
dall’utente. Un oggetto ViewGroup è anch’esso una View, ma contiene altre View. Nella
piattaforma Android si utilizza il concetto di “layout” per gestire l’impaginazione dei controlli
all’interno di un contenitore di oggetti View.
13
I componenti grafici sono per lo più quelli tradizionali che siamo abituati a vedere in quasi tutti i
programmi,cioè pulsanti, checkbox, caselle di testo editabili, etichette.
Le applicazioni Android si compongono di quattro mattoni fondamentali: le attività (activity), i
servizi (service), i broadcast receiver e i content provider. Ogni applicazione è formata da uno o più
di questi mattoni. Non è detto che li contenga tutti: ad esempio potrebbe essere costituita da due
attività e da un servizio, senza avere broadcast receiver né content provider. Nella stragrande
maggioranza dei casi, comunque, le applicazioni comprendono almeno un’attività. Un’attività è
“una singola e precisa cosa che l’utente può fare”. L’Activity è un concetto legato allo sviluppo
delle interfacce grafiche: normalmente una Activity rappresenta una singola schermata della nostra
applicazione. Le applicazioni possono definire una o più Activity per trattare diverse fasi del
software: ogni Activity è responsabile del salvataggio del proprio stato in modo da poterlo
ristabilire successivamente come parte del ciclo di vita dell’applicazione. È possibile mandare
in esecuzione più attività simultaneamente, ma soltanto un’attività alla volta può occupare il
display. L’attività che occupa il display è in esecuzione e interagisce direttamente con l’utente. Le
altre, invece, sono ibernate e tenute nascoste in sottofondo, in modo da ridurre al minimo il
consumo delle risorse di calcolo. L’utente, naturalmente, può ripristinare un’attività ibernata e
riprenderla da dove l’aveva interrotta, riportandola in primo piano. L’attività dalla quale si sta
allontanando, invece, sarà ibernata e mandata in sottofondo al posto di quella ripristinata. Per prima
cosa le attività possono morire spontaneamente, perché hanno terminato i loro compiti. I casi in cui
un’attività può terminare sono due:
• L’attività è ibernata e il sistema, arbitrariamente, decide che non è più utile e perciò la distrugge.
• Il sistema è a corto di memoria, e per recuperare spazio inizia a “uccidere” bruscamente le attività
in sottofondo. La Fig.1 illustra la sequenza di chiamate ai metodi di Activity eseguite durante i
passaggi di stato dell’attività.
14
Dopo che si è creata un’attività, la si deve registrare all’interno del descrittore dell’applicazione (il
file AndroidManifest.xml), questo affinché il sistema sappia della sua esistenza. Per farlo si usa un
tag <activity> all’interno del tag <application>:
<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.
android.com/apk/res/android"
package=" mypackage.mysubpackage " . . . >
<application . . . >
<activity android:name=".MyActivity" . . . >. . .
</activity>
...
</application>
</manifest>
Al lancio l’Activity transita per tre differenti stati, creazione, avvio e ripristino, prima di iniziare la
vera e propria esecuzione. Questi eventi possono essere intercettati con gli appositi metodi che
appaiono nella figura. Quando una nuova Activity passa in primo piano, quella corrente viene
messa in pausa, se, ad esempio,arriva una telefonata mentre stiamo usando il browser. In questo
15
caso è possibile riprendere rapidamente l’attività precedente. Se invece l’utente passa ad una nuova
attività che rende la precedente non più visibile, dopo essere messa in pausa viene anche sospesa.
Possiamo lanciare nuove attività da quella attualmente in esecuzione tramite il metodo
startActivity() che è fornito dalla classe Activity. L’oggetto principale per lanciare una nuova
attività è il tipo Intent. Esso è un meccanismo che descrive un’azione specifica.
Questo oggetto Intent può individuare una specifica Activity se lo creiamo riferendoci direttamente
alla classe (Intent esplicito), oppure possiamo soltanto indicare l’azione che vogliamo eseguire, ad
esempio Intent.ACTION_SEND per l’invio di una mail (Intent implicito). Un Intent può essere
utilizzato per: trasmettere l’informazione per cui un particolare evento si è verificato; supportare
l’interazione tra qualsiasi applicazione installata sul dispositivo Android.
Un’ altro aspetto importante della programmazione Android è il Content Provider, cioè un
contenitore di dati e rappresenta uno dei modi migliori per condividere informazioni “globali” tra
applicazioni. Dato che Android è un sistema Linux-based in cui ogni applicativo ha il suo userid
Linux, la sua directory “data” e il suo spazio di memoria dedicato e protetto, gli applicativiAndroid
necessitano dei Content Provider per comunicare tra loro. Alcuni Content Provider forniscono
l’accesso ai dati solo in lettura, mentre altri permettono alle applicazioni di creare, aggiornare,
modificare o cancellare record. Un database SQLite in un device Android è un esempio di sorgente
di dati che possiamo incapsulare all’interno di un Content Provider. Android è provvisto di un
insieme di Content Provider contenuti nel package “android.provider” dell’SDK. Per accedere alle
risorse fornite da un Content Provider utilizziamo un insieme di URL caratterizzati dallo schema
“content://”.
Un argomento importante della programmazione Android riguarda il Service, un processo che gira
in background senza la diretta interazione con l’utente. La classe Service viene utilizzata per creare
componenti software che possono svolgere attività in modo “invisibile”, senza interfaccia utente.
Un esempio di Service lo vediamo nel player di musica, che continua a riprodurre canzoni anche
quando non è in primo piano e stiamo utilizzando altri programmi. Utilizzando i Service possiamo
far girare applicazioni e farle reagire ad eventi anche quando non sono in primo piano.
Un Service avviato ha una priorità più alta rispetto ad Activity in stato di inattività, in questo modo
vi è minore probabilità per un Service di essere terminato dal gestore delle risorse di runtime.
L’AndroidManifest.xml è il file che definisce i contenuti e il comportamento della nostra
applicazione. All’interno di questo file sono elencate le Activity e i Service dell’applicazione, con i
permessi che necessita per funzionare correttamente.
Ogni progetto Android include un AndroidManifest.xml memorizzato nella directory principale del
progetto. In questo file XML si possono inserire nodi per ogni elemento (Activity, Service, Content
16
Provider e così via) che compone la nostra applicazione, impostando i permessi per determinare
come questi interagiscono l’un l’altro e con le altre applicazioni.
Tra i principali permessi che possiamo richiedere sono:
READ_CONTACTS: leggere i dati dei contatti dell’utente.
WRITE_CONTACTS: scrivere i dati dei contatti dell’utente.
RECEIVE_SMS: monitorare l’arrivo di SMS.
INTERNET: accedere ed utlizzare la connessione Internet.
ACCESS_FINE_LOCATION: utilizzare un accurato sistema di localizzazione come il GPS.
La radice di ogni AndroidManifest.xml è il tag <manifest>. Questo tag include i nodi che
definiscono i componenti dell’applicazione, l’ambiente di sicurezza.
Il layout grafico delle activity viene definito in un file XML all’interno della cartella res/layout.
Questo particolare è molto importante, in quanto la gestione dei file aggiuntivi delle nostro progetto
deve seguire una specifica organizzazione, ogni elemento trova il suo posto, ad esempio le
immagini devono essere inserite nelle cartelle res/drawable. Il compilatore delle risorse comprime e
impacchetta le risorse delle nostre applicazioni e successivamente genera una classe “R” che
contiene tutti gli identificatori che possiamo utilizzare per riferirci alle risorse del programma.
A questo punto tramite degli appositi metodi possiamo ottenere un riferimento all’oggetto passando
come argomento l’ID, per fare un esempio findViewById(R.id.salva)può essere utilizzato per trovare
un ipotetico pulsante per il salvataggio. Ecco la struttura di un’applicazione Android a pag.18
17
18
Ora che abbiamo imparato i fondamenti dello sviluppo di applicativi Android rimane un ultimo
passaggio per chiudere il cerchio: il rilascio e la pubblicazione dell'app. Preparare ed eseguire il
packaging di un'applicazione per la pubblicazione è un processo conosciuto come il nome di
release process. Il release process è il processo attraverso il quale passa la nostra app per diventare
la release build, ovvero la versione ufficiale pronta per essere pubblicata. Prima di diventare la
release build, e quindi di essere disponibile per l'utente finale, l'applicazione è la release candidate
build. Solo dopo attente e rigorose verifiche e test l'applicazione diventa la release build.
Il processo per la pubblicazione di una applicazione Android si divide in 5 passi:
1.
2.
3.
4.
5.
Preparare una release candidate build della nostra applicazione.
Testare attentamente e minuziosamente la release candidate.
Generare un package Android e ufficializzarlo con una firma digitale.
Testare attentamente e minuziosamente il package pronto per il rilascio.
Pubblicare l'applicazione.
Per avere una release candidate ufficiale dobbiamo anche effettuare qualche modifica al file di
configurazione AndroidManifest.xml . Alcune modifiche sono imposte dai marketplace come
l'Android Market mentre altre sono dettate dal buon senso e da linee guida comunemente accettate.
Vediamo dunque come dobbiamo preparare l'AndroidManifest.xml per un’ applicazione che
vogliamo ufficializzare a release candidate:
Innanzitutto verifichiamo che l'icona dell'applicazione sia impostata correttamente: questa
icona sarà visualizzata agli utenti e verrà utilizzata dai marketplace per presentare
l'applicazione, quindi è importante che sia d'impatto e perfettamente configurata;
Verificare che il nome dell'applicazione sia appropriato e correttamente impostato: questo
sarà il nome con cui l'applicazione si presenterà agli utenti finali;
Verificare la corretta impostazione del testo indicante la versione dell'applicazione;
Controllare che il codice della versione dell'applicazione sia impostato correttamente:
questo è un codice che la piattaforma Android utilizza per gestire gli aggiornamenti della
nostra applicazione;
Verificare l'impostazione dell’ uses-sdk dell'applicazione: possiamo impostare il massimo,
il minimo e il consigliato SDK Android supportato dall'applicazione. L'Android Market
filtra le applicazioni disponibili per uno specifico utente in base alle informazioni fornite da
ogni file di configurazione AndroidManifest.xml, comprese quelle relative all'Android
SDK;
Verificare di aver disabilitato l'opzione debuggable;
19
Verificare che tutti i permessi richiesti dall'applicazione siano appropriati per un corretto
funzionamento della app: richiediamo solo i permessi davvero necessari e assicuriamoci di aver
richiesto tutto il necessario indipendentemente da come si potrebbe comportare il device senza di
essi. A questo punto possiamo passare alla fase di testing. Se durante i test dovessimo riscontrare
dei bug o delle problematiche di qualche genere, si dovrà valutare la possibilità di interrompere il
processo di rilascio per iniziarlo nuovamente una volta sistemate le problematiche riscontrate.
Se la nostra applicazione ha superato la fase di testing, allora abbiamo ufficialmente la nostra
release canditate build. A questo punto dobbiamo generare il package Android, nella pratica un file
con estensione .apk, e ufficializzarlo con la firma digitale. Per completare facilmente questi
passaggi il plugin di Android per Eclipse mette a disposizione un wizard che semplifica
notevolmente il nostro lavoro. Per lanciare il wizard è sufficiente cliccare con il tasto destro del
mouse sul nostro progetto e selezionare la voce Export. Nella finestra che compare selezioniamo
l'opzione Android e poi Export Android Application come mostrato nella seguente figura:
20
Clicchiamo su Next e arriviamo alla schermata per la selezione della Keystore:
Scegliamo l'opzione Create new keystore e nel campo Location inseriamo il percorso del file in cui
vogliamo memorizzare la chiave. Inseriamo anche la password per la gestione della chiave, la
confermiamo, e clicchiamo su Next.
Accediamo dunque alla schermata Key Creation in cui dobbiamo inserire alcune informazioni
dettagliate sulla chiave, come mostrato dalla seguente figura:
21
Il team di Android suggerisce per il campo Validity di inserire un valore almeno uguale a 25:
l'Android Market infatti rifiuta qualsiasi applicazione che non sia dichiarata valida fino alla data del
22 ottobre 2033. Clicchiamo su Next per accedere alla schermata Destination and key/certificate
checks, selezioniamo la destinazione per il file .apk ed infine clicchiamo su Finish. Abbiamo così
creato un application package file pronto per la pubblicazione: prima però di renderlo disponibile
all'utente finale attraverso i market come l'Android Market è consigliabile eseguire ancora qualche
test sull'installazione del pacchetto .apk che abbiamo appena creato. Proviamo dunque ad installarlo
e disinstallarlo sia nell'emulatore sia su uno o più device reali, in modo da verificare che il processo
di installazione dell'.apk che vogliamo pubblicare sia completo e vada a buon fine. Conclusi anche
questi test sul file .apk possiamo iniziare il procedimento per pubblicare la nostra applicazione
nell'Android Market. Per pubblicare applicazioni nell'Android Market dobbiamo essere registrati
come sviluppatori. Per registrarci è necessario accedere al link
https://play.google.com/apps/publish/signup:
22
Una volta entrati la prima cosa che dobbiamo fare è completare il profilo dello sviluppatore con le
informazioni richieste (Developer name, Email Address, ecc.). Compilato il form con i dati dello
sviluppatore possiamo andare avanti cliccando sul link Continue: a questo punto ci viene richiesto
di pagare una piccola somma per la registrazione (25 dollari) e di fornire le informazioni per
l'account Google Checkout Merchant. L'ultimo passaggio per concludere la registrazione è dare
l'assenso per collegare la nostra carta di credito e il nostro account di registrazione all'Android
Market Developer Distribution Agreement. accediamo da loggati alla pagina principale dell'Android
Market, clicchiamo sul pulsante Upload Application e compiliamo il form che ci viene presentato
con le informazioni richieste. Dovremo ad esempio caricare il file .apk creato durante la procedura
di release, due screenshot dell'applicazione ed eventualmente un'immagine promozionale, e ancora
dovremo specificare il tipo e la categoria dell'applicazione, eventualmente il prezzo, e dare il
consenso ai termini delle correnti Android Content Guidelines. opo aver compilato correttamente il
form per la pubblicazione e aver cliccato sul pulsante Publish, l'applicazione comparirà
immediatamente nell'Android Market: da questo momento potremo vedere le statistiche relative alla
applicazione, come ad esempio quante volte è stata visitata, scaricata ed installata, ed anche i
punteggi ricevuti dagli utenti.
23
2.JVoiceXML
2.1 Panoramica
JvoiceXML è un’implementazione del VoiceXML scritta nel linguaggio di programmazione Java
con un architettura aperta ad estensioni personalizzate. Esso offre librerie e un interprete, per la
facile creazione e processamento di documenti VoiceXML e questo tipo di implementazione è uno
dei tanti che stà supportando gli standard Java API come :
JSAPI:Questa implementazione può essere utilizzata su piattaforme di riconoscimento
vocale e sintetizzatori. JVoiceXML offre due moduli di sintesi vocale per questa
piattaforma:
o Sphinx4: è un sistema di riconoscimento vocale scritto interamente in un linguaggio
Java. È stato creato per mezzo di una collaborazione tra il gruppo Sphinx presso la
Carnegie
Mellon
University,SunMicrosystemsLaboratories,MitsubishiElectricResearchLabs
(MERL),and HewlettPackard (HP), con il contributo dell’Università della California
a Santa Cruz e la Massachusetts Institute of Technology(MIT).
o FreeTTS: è un sistema di sintesi vocale scritto interamente in Java. Esso si basa su
un piccolo motore di sintesi vocale Flite sviluppato presso la Carnegie Mellon
University. Flite deriva dal sistema di sintesi vocale “Festival” presso l’Università di
Edimburgo e dal progetto FestVox presso la Carnegie Mellon University. FreeTTS è
stato costruito dal Speech Integration Group of Sun Microsystems Laboratories:



Willie Walker, Manager and Principal Investigator
Paul Lamere, Staff Engineer
Philip Kwok, Member of Technical Staff
JTAPI:Questa piattaforma può essere utilizzata in aggiunta a qualsiasi altra piattaforma di
implementazione per abilitare il supporto di telefonia. Attualmente ci sono alcuni test
effettuati sulla piattaforma JSAPI, ma questi test hanno ancora bisogno di tempo per essere
ottimizzati.
VoiceXML è solo uno, anche se il principale, dei linguaggi di programmazione usati per creare
interfacce vocali. Ogni qualvolta ci si appresti ad imparare un nuovo linguaggio ci si trova
immediatamente di fronte a due tipologie di problemi:
24
il primo è quello che riguarda la sintassi, ovvero come scrivere una determinata istruzione
per ottenere un certo effetto.
il secondo riguarda la natura del linguaggio: su cosa si basa, quando si usa, come si usa e
quali siano i suoi limiti.
Per quanto riguarda il primo problema, trattandosi di un "dialetto" o più precisamente di una
applicazione di XML, esso è composto da un numero di tag ridotti e la struttura dei documenti
risulta piuttosto semplice. Il secondo punto, al contrario, rappresenta la principale problematica che
possiamo avere nel comprendere quale sia lo scenario di riferimento e quali siano le difficoltà ed i
limiti di in una programmazione di questo tipo.
Prima di entrare nel dettaglio di come è stato strutturato il progetto,è bene fornire un illustrazione
delle varie architetture che sono state utilizzate per realizzarlo.
2.2 Architettura JVoiceXML
Figura 1: Architettura di base del JVoiceXML
Vi sono principalmente due modi, di come i client possono interagire con JVoiceXML, ovvero
utilizzando JNDI o utilizzando il CallMananger. La maggior parte dei client utilizzano il demo Java
Naming Directory Interface per accedere al JVoiceXML. Attraverso il CallManager si possono
effettuare chiamate per una applicazione con questa tecnologia. Attualmente c'è solo il supporto
telefonia di base,ma gli utenti possono anche chiamare applicazioni dai propri programmi in Java.
Concettualmente JNDI consente di connettersi a un JVoice-Server XML. JVoiceXML permette
25
anche di avere tutto ciò sul lato server, con l'aiuto di un CallManager. Questa architettura tipica di
un browser vocale è mostrato in figura 2.
Figura 2: Architettura JVoiceXML utilizzando un CallManager
Qui JVoiceXML attende le chiamate in arrivo e una volta che il CallManager rileva una chiamata
dal PBX(sistema telefonico), chiama l'applicazione configurata JVoiceXML che attraverso il
protocollo http accede al Container servlet per interpretare il documento VoiceXML in questione.
2.3 ArchitetturaVoiceXML
VoiceXML è uno standard basato su XML, sviluppato per creare dialoghi che prevedono sintesi vocale,
riconoscimento vocale e di input telefonici, registrazione di parlato e conversazioni ad iniziativa mista.
Al fine di comprendere il funzionamento di una applicazione vocale ci aiuteremo facendo dei
paragoni con le note pagine internet: possiamo dire che l'architettura tipica di una applicazione Web
comprende il server che ospita il sito e un application server che gestisca i database e il core della
nostra applicazione.
26
Figura 2: Architettura di una applicazione vocale
Questa architettura, rappresenta un grado di complessità
medio-alta e nel momento in cui
decidiamo di rendere attiva la nostra applicazione vocale, si creerà un nuovo layer di presentazione
dei dati chiamato:interfaccia vocale. Una delle principali peculiarità del linguaggio VoiceXML è
quella di essere costruito per sviluppare applicazioni voice-enabled orientate al Web: ciò significa
essere in grado di produrre pagine VoiceXML anche attraverso linguaggi server side (ASP,
ASP.NET, JSP, PHP, ecc.).Per capire come questo sia possibile,possiamo vedere la parte bassa
della figura 1 dove l'utente si connette tramite il telefono al Voice Gateway senza dover ricorrere ad
un particolare browser o plugin. Il Voice Gateway è , fondamentalmente, un server con i seguenti
requisiti:
Ha un interprete VoiceXML, in grado di testare documenti Voice XML.
Uno o più motori di riconoscimento vocale (ASR: Automatic Speech Recognition) che
servono per ascoltare gli input degli utenti. Tecnologia alla base del riconoscimento del
linguaggio orale umano da parte di un computer. Il software ASR utilizzato in questo
progetto prevede 3 modelli differenti che sono utilizzati nel processo di riconoscimento del
parlato:
o un modello acustico, che contiene le rappresentazioni dei suoni che
compongono una parola
27
o un dizionario fonetico, che contiene le parole disponibili in un certo
linguaggio e la pronuncia espressa nei fonemi definiti nel modello acustico
o un modello del linguaggio, utilizzato per restringere la ricerca delle parole,
definendo quale parola potrebbe seguire quella precedentemente riconosciuta
Uno o più motori di sintesi vocale (TTS: Text-to-speech) che vengono utilizzati per produrre
un output vocale da un testo sintetizzato. I sistemi TTS, anche detti sistemi di sintesi vocale,
o sintetizzatori vocali, sono quei sistemi che si occupano della riproduzione artificiale della
voce umana. Esistono diverse tecnologie di sintesi vocale, ma i sistemi di sintesi vocale
utilizzati in questo progetto utilizzano tutti la sintesi concatenativa che risulta superiore alle
altre tecnologie: meno pesante computazionalmente o offrono un parlato non naturale. La
sintesi concatenativa si basa sulla combinazione di frammenti di voce registrati di vario tipo:
ad esempio nella sintesi concatenativa per campioni unitari si possono utilizzare come
frammenti suoni isolati, sillabe, parole, frasi o addirittura periodi, mentre nella sintesi
concatenativa per difoni (utilizzata nella voce default nel sistema TTS utilizzato in questo
progetto) si utilizzano i difoni, ovvero le transizioni da suoni diversi.
Una scheda telefonica ,nel caso di sintetizzatore telefonico,per accettare flussi telefonici in
ingresso. Ovviamente al posto della scheda telefonica si può veicolare la telefonata
attraverso VOIP o SIP.
Quando un utente si connette ad una applicazione vocale in generale:
L'utente avvia l’ applicazione JvoiceXML collegata al nostro Voice Gateway.
Il Gateway interpreta le istruzioni contenute nel file VoiceXML, producendo un messaggio
vocale attraverso la sintesi (TTS), e ricevendo ed interpretando gli input dell'utente (ASR).
Inoltre, il Voice Gateway dialoga con il Web Server attraverso il protocollo HTTP e invia
dati all' "applicationlayer". Quindi possiamo affermare che il Voice Gateway si preoccupa
soltanto di leggere il contenuto dei file VoiceXML inviati dal server Web e di raccogliere gli
input dell'utente.
Il server Web riceve le richieste e rende disponibili i file VoiceXML che arrivano dal Voice
Gateway per la loro interpretazione.
Dopo tutto ciò,possiamo quindi mostrare la vera struttura del VoiceXML:
28
Il Document Server si occupa di fornire i dialoghi all’interprete che esegue il suo lavoro all’interno
di un “contesto”. L’interprete e il suo Context comunicano direttamente con la Implementation
Platform che ha il compito di gestire l’interazione con l’utente. Va ricordato che questo linguaggio
nasce inizialmente per sviluppare applicazioni vocali a cui si accede via telefono e,con la seguente
cura da parte del W3C,si apre a portali vocali con l’aiuto della tecnologia VoIP (Voice over Internet
Protocol). Le richieste e l’invio dei dati delle form, secondo la specifica del W3C, dovrebbero
avvenire attraverso metodi http.
Fondamentalmente il modello di interazione è di tipo client-server, in cui gli utilizzatori delle
applicazioni vocali si collegano al fornitore di servizi attraverso il telefono o programmi specifici di
tipo Voice Browser. In alcuni casi l’interprete si trova sul lato server, per ovvi motivi nel caso di
accesso da telefono, ma anche per ridurre lo sforzo computazionale a carico dei client nelle altre
situazioni. Vediamo infine i principali vantaggi dell’utilizzo di VoiceXML:
Facilità di scrittura e lettura dei dialoghi essendo un derivato del linguaggio XML.
Possibilità di creazione grafica con appositi tools.
Separazione della logica del dialogo dal codice dell’applicazione, questo permette una più
facile manutenzione e possibilità di cambiare i dialoghi senza riscrivere tutto il codice.
2.4 Software necessari per JVoiceXML
Nella realizzazione di questo progetto abbiamo utilizzato 2 tipi si software,ed in questo paragrafo
illustreremo in modo generale cosa sono e su cosa si basano.
29
Eclipse : è un linguaggio di programmazione orientato agli oggetti. I documenti scritti sotto
questa piattaforma utilizzano il linguaggio Java, che poi saranno lanciati su una Java Virtual
Machine e, a tempo di esecuzione, avranno accesso alle API della libreria standard. Ciò
fornisce un livello di astrazione che permette alle applicazioni di essere interamente
indipendenti dal sistema su cui esse saranno eseguite. Parti del codice di JVoiceXML
utilizzano funzioni del JAVA 7 API, necessari e almeno per compilare il codice.
Tomcat :Tomcat è un prodotto free e open source sviluppato in Java all’interno della
fondazione Apache. Tomcat realizza le funzioni di:
o Web server
o Container per le web application conforme alle specifiche Java 2 Enteprise Edition
(J2EE).Il che significa che Tomcat funziona da motore per Servlet e Java Server Pages
(JSP).
Il fatto che Tomcat funga da web server fa sì che una volta connessi ad Internet, il nostro computer
pubblica le informazioni (risponde alle richieste http) esattamente come un qualsiasi altro nodo
della rete e quindi il nostro sito potrebbe essere visitato da un browser su un computer remoto. Nel
nostro caso,i documenti VoiceXML risiederanno all’interno del Container di Tomcat nel quale
JvoiceXML avrà accesso attraverso il protocollo http per selezionare il documento ed eseguirlo.
30
3.Realizzazione del progetto
La prima fase di tirocinio è stata quella di acquisire le basi della programmazione Android e
studiare lo standard VoiceXml, sviluppando degli esempi per prendere praticità con gli strumenti.
In un primo momento avevamo deciso, insieme al prof. Dragoni, di implementare un dialogo su
Android con un robot. Ma a fronte di una moltitudine di problemi, incompatibilità dell’interprete
JVoiceXML e soprattutto della scarsa documentazione al caso, abbiamo deciso di sviluppare il
sistema su desktop.
3.1 Applicazione finale
Prima di tutto abbiamo sviluppato un client che interagisce in remoto con il JVoiceXML e
inizializza le chiamate. Il dialogo è stato realizzato in vxml (per maggiori dettagli leggere la tesi del
mio collaboratore Marco Brunetti).
Dopo aver creato la classe Prova con all’interno il metodo main abbiamo bisogno di connetterci al
browser vocale JVoiceXML.
Ecco l’aspetto del nostro interprete JVoiceXML:
31
JVoiceXML usa le JNDI su RMI (Remote Method Invocation) per tale scopo.
Apriamo una parentesi sul sistema RMI.
Le applicazioni RMI sono generalmente costituite da due parti:
la parte server crea gli oggetti remoti ed i riferimenti a questi e quindi attende l’invocazione
dei metodi da parte di un client
la parte client recupera i riferimenti a questi oggetti e ne invoca i metodi
Le applicazioni RMI necessitano di:
poter recuperare oggetti remoti
comunicare con oggetti remoti
caricare classi per oggetti che sono passati come parametri o restituiti come valore
L’invocazione di metodi remoti è totalmente trasparente al programmatore: i livelli Remote
Reference Layer e Transport Layer si occupano di fatto della gestione a basso livello della
comunicazione:
Il Remote Reference Layer (RRL) ha il compito di instaurare la connessione fra il client e il
server eseguendo operazioni di codifica e decodifica dei dati
Il Transport Layer esegue la connessione vera e propria tra le macchine utilizzando quindi i socket
con il protocollo TCP/IP.
Per ottenere un riferimento, in remoto, al JVoiceXML occorre inserire le seguenti librerie:
import javax.naming.Context;
import javax.naming.InitialContext;
import org.jvoicexml.JVoiceXml;
Poi abbiamo creato e inizializzato un oggetto Context, per accedere alle risorse JNDI attraverso il
seguente codice: Context context = null; context = new InitialContext();
32
Le impostazioni che regolano tutto questo sono contenute in un file denominato jndi.properties, il
quale deve essere inserito nel CLASSPATH del progetto. Il file jndi.properties contiene il seguente
codice:
java.naming.factory. initial =\
com.sun.jndi.rmi. registry .RegistryContextFactory
java.naming.provider.url=rmi://localhost:1099
java.naming.rmi.security.manager=true
La location del JVoiceXML è memorizzata nella proprietà java.naming.provider.url. Se si desidera
accedere a JVoiceXML su un altro computer, devi sostituire il localhost con un indirizzo IP oppure
con il nome del computer.
Le classi che sono necessarie per accedere al JVoiceXML, come org.jvoicexml.JVoiceXML, fanno
parte del jvxml-client.jar e jvxml-xml.jar, file che si trovano all’interno della cartella lib di
installazione del JVoiceXML. Questi file contengono tutte le classi che tu hai bisogno per scrivere
un’applicazione client. Se si utilizza un implementation platform diverso, potrebbe essere
necessario aggiungere altre jar alle librerie del client.
Non ci resta che chiamare il browser per elaborare la richiesta. Questo viene eseguito dall’oggetto
org.jvoicexml.Session (import org.jvoicexml.Session).
L’argomento del metodo createSession() è un oggetto ConnectionInformation. Questo object è
responsabile della selezione dell’implementation platform che abbiamo intenzione di utilizzare.
Un implementation platform dispone di tre tipi di risorse:
telephony,
system output
user input.
Le risorse sono identificate da stringhe. Noi abbiamo usato un dummy telephony implementation e
system output e user input del JSAPI 1.0 implementation platform. Questa combinazione fa uso di
microfono e altoparlante del PC. Utilizziamo la risorsa dummy in modo da non toccare la telefonia.
Con la chiamata jvxml.createSession(info), si crea una sessione che è legata ai tipi di risorse in
questione.
L’argomento del metodo session.call(URI) deve puntare all’URI della radice del documento
dell’applicazione.
Abbiamo visto che l’implementazione delle JNDI si basa su RMI e l’implementazione per l’uso
delle interfacce è ottenuto dal codice RMI dinamico. Questo significa che è necessario fornire la
posizione delle librerie con l’implementazione delle interfacce e un file di sicurezza chiamato
jvoicexml.policy. Questo file riguarda tutti i permessi dell’utente remoto. In generale contiene:
33
grant {
permission java. security .AllPermission;
3 };
Nel caso restrittivo ha il seguente contenuto:
grant {
2 permission java. util .PropertyPermission
”jvoicexml.vxml.version”, ”read”;
permission java. util .PropertyPermission
”jvoicexml.xml.encoding”, ”read”;
permission java.net.SocketPermission
7 ”127.0.0.1:1024−”, ”connect,resolve”;
permission java. io .FilePermission
”${JVOICEXML HOME}/lib/−”, ”read”;
};
La posizione del file è data dalla seguente proprietà:
−Djava.security.policy=jvoicexml.policy
Queste immagini descrivono la posizione del file:
Primo passo è andare sulla cartella del progetto, posizionarsi sul nome della classe Demo.class e poi
andare sul menu Run. Dal menu cliccare Run Configuration.
34
Dal menu Run configuration, cercare il nome della classe sotto Java Application e cliccare su
(x)=Arguments.
Ultimo passo, nella sezione VM arguments inserire −Djava.security.policy=jvoicexml.policy
35
36
3.2Codice del progetto
import java.net.URI;
import java.net.URISyntaxException
import javax.naming.Context;
import javax.naming.InitialContext;
import org.jvoicexml.ConnectionInformation;
import org.jvoicexml.JVoiceXml;
import org.jvoicexml.Session;
import org.jvoicexml.client.BasicConnectionInformation;
import org.jvoicexml.event.ErrorEvent;
public class Prova {
/**
* @param args
*/
public static void main(String[] args) {
//inizializza il servizio di naming definito nel file
jndi.properties
Context context = null;
try {
context = new InitialContext();
} catch (javax.naming.NamingException ne) {
ne.printStackTrace();
System.exit(0);
}
37
//comunica con l'interprete attraverso jndi
JVoiceXml jvxml = null;
try {
jvxml = (JVoiceXml)
context.lookup("JVoiceXml");
} catch (javax.naming.NamingException ne) {
ne.printStackTrace();
System.exit(0);
}
//l'interprete utilizza le jsapi 1.0
final ConnectionInformation info =
new BasicConnectionInformation(
"dummy", "jsapi10", "jsapi10");
//i file voicexml risiedono
su un document server
Tomcat
try {
final Session session =
jvxml.createSession(info);
final URI uri = new
URI("http://localhost:8080/demo1/hello.vxml");
session.call(uri);
session.waitSessionEnd();
session.hangup();
} catch (ErrorEvent | URISyntaxException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}}
38
3.3.Config progetto
-Ecco le jar utilizzate:
D:\Programmi\Java\jre7\lib\resources.jar
D:\Programmi\Java\jre7\lib\rt.jar
D:\Programmi\Java\jre7\lib\jsse.jar
D:\Programmi\Java\jre7\lib\jce.jar
D:\Programmi\Java\jre7\lib\charsets.jar
D:\Programmi\Java\jre7\lib\jfr.jar
D:\Programmi\Java\jre7\lib\ext\access-bridge.jar
D:\Programmi\Java\jre7\lib\ext\dnsns.jar
D:\Programmi\Java\jre7\lib\ext\jaccess.jar
D:\Programmi\Java\jre7\lib\ext\localedata.jar
D:\Programmi\Java\jre7\lib\ext\sunec.jar
D:\Programmi\Java\jre7\lib\ext\sunjce_provider.jar
D:\Programmi\Java\jre7\lib\ext\sunmscapi.jar
D:\Programmi\Java\jre7\lib\ext\sunpkcs11.jar
D:\Programmi\Java\jre7\lib\ext\zipfs.jar
-Referenced Libraries:
D:\Programmi\JVoiceXML\lib\chardet.jar
D:\Programmi\JVoiceXML\lib\commons-codec-1.4.jar
D:\Programmi\JVoiceXML\lib\commons-lang-2.3.jar
D:\Programmi\JVoiceXML\lib\commons-logging-1.1.1.jar
D:\Programmi\JVoiceXML\lib\commons-pool-1.5.5.jar
D:\Programmi\JVoiceXML\lib\httpclient-4.0.3.jar
D:\Programmi\JVoiceXML\lib\httpcore-4.1.jar
D:\Programmi\JVoiceXML\lib\httpcore-nio-4.1.jar
D:\Programmi\JVoiceXML\lib\httpmime-4.0.3.jar
D:\Programmi\JVoiceXML\lib\jlibrtp.jar
D:\Programmi\JVoiceXML\lib\jmf.jar
D:\Programmi\JVoiceXML\lib\js.jar
39
D:\Programmi\JVoiceXML\lib\jsapi.jar
D:\Programmi\JVoiceXML\lib\jsr113.jar
D:\Programmi\JVoiceXML\lib\jvxml-client.jar
D:\Programmi\JVoiceXML\lib\log4j-1.2.16.jar
D:\Programmi\JVoiceXML\lib\org.jvoicexml.jar
D:\Programmi\JVoiceXML\lib\org.jvoicexml.config.jar
D:\Programmi\JVoiceXML\lib\org.jvoicexml.implementation.jsapi10.jar
D:\Programmi\JVoiceXML\lib\org.jvoicexml.implementation.jsapi20.jar
D:\Programmi\JVoiceXML\lib\org.jvoicexml.jndi.jar
D:\Programmi\JVoiceXML\lib\org.jvoicexml.jsapi2.jar
D:\Programmi\JVoiceXML\lib\org.jvoicexml.jsapi2.jse.jar
D:\Programmi\JVoiceXML\lib\org.jvoicexml.processor.srgs.jar
D:\Programmi\JVoiceXML\lib\org.jvoicexml.xml.jar
D:\Programmi\JVoiceXML\lib\org.springframework.beans3.0.5.RELEASE.jar
D:\Programmi\JVoiceXML\lib\org.springframework.core3.0.5.RELEASE.jar
I passi per inserire le .jar riferite al JVoiceXML sono i seguenti:
1-Andare sul nome del progetto. Cliccare su file e poi properties.
40
2-Dal menu a sinistra cliccare su Java build Path e andare sulla voce Libraries.
41
3-Cliccare su Add External JARs.. e aggiungere tutte le jar che si trovano nella cartella lib contenuta
nella cartella di installazione JVoiceXML.
42
43
4.Conclusioni
Perché sviluppare applicazioni vocali?
I benefici ottenibili da applicazioni vocali sono individuabili in:
Accesso ai nostri dati in modo naturale:
la voce è il metodo più semplice e naturale per accedere ai nostri dati, fare domande e
ricevere risposte è una attività che non ha alcun bisogno di addestramento, a differenza
dell'uso di un personal computer. Alla luce dello stato dell'arte delle tecnologie di sintesi e di
riconoscimento, creare interfacce vocali in grado di permettere all'utente di esprimersi in
linguaggio naturale, oggi, è possibile.
Aumentare il bacino di utenti:
un altro dato che non bisogna sottovalutare è la diffusione della telefonia cellulare: il
rapporto tra utenti di telefonia mobile e di computer è di dieci a uno. Se ai primi
aggiungiamo coloro che hanno un telefono fisso, il divario aumenta ulteriormente. Rendere
la nostra applicazione fruibile attraverso il telefono significherebbe perciò conquistare nuove
fasce di utenti.
Accessibilità 24/24 ore:
la maggior parte dei servizi di help desk sono limitati nell'arco della giornata. Se fosse il
nostro server a rispondere alle domande degli utenti potremmo rendere disponibile il
servizio 24 ore al giorno per 7 giorni alla settimana e 365 giorni all' anno, senza nessun
costo aggiuntivo. La nostra applicazione sarà in grado di filtrare le chiamate, fornendo
risposte a quelle più frequenti in modo automatico lasciando libero l'operatore di gestire solo
i casi più difficoltosi o particolari. Questo si tradurrebbe in una maggiore fluidità delle
evasioni delle chiamate ed eviterebbe all'utente lunghe e snervanti attese.
44
Accesso indipendente dalla locazione e dal tempo:
possibilità di accedere ad informazioni importanti da qualsiasi posto ed a qualsiasi ora. Si
pensi al vantaggio di poter sfogliare i documenti su un server attraverso il telefono cellulare
ed ascoltare le informazioni desiderate. Prendiamo ad esempio il caso di un agente di
commercio che necessita di sapere un prezzo o la disponibilità di un particolare prodotto in
tempo reale: potrebbe farlo senza doversi preoccupare di dover raggiungere l'ufficio,
l'albergo o in luogo in cui sia disponibile una connessione Internet. E ovviamente possiamo
applicare lo stesso principio a informazioni come orari di musei, prenotazioni a teatro,
viabilità, previsioni metereologiche, orari dei treni, risultati sportivi, etc.
Portatori di handicap:
aumento delle possibilità d'impiego per portatori di handicap come ipovedenti o persone
con difficoltà di movimento. Rendere disponibili le nostre applicazioni ed i nostri siti
all'interazione vocale permetterà non solo un ampliamento del bacino di utenza, ma,
soprattutto, renderà fruibili le risorse in modo completo ed efficiente da parte di quelle
categorie di utenti disabili che normalmente hanno grosse difficoltà ad accedervi.
Maggiore accessibilità:
l'utilizzo da parte di utenti le cui mani sono impegnate o che comunque non possono
utilizzare una interfaccia grafica. Basti pensare ai navigatori satellitari e ai più moderni
computer di bordo installati sulle automobili, oppure ad un operatore di un particolare
strumento meccanico che ha le mani impegnate nel manovrarlo. In ognuno di questi casi il
nostro utente potrà accedere alle informazioni di suo interesse senza dover distogliere
l'attenzione e lo sguardo e soprattutto senza utilizzare le mani.
Tastiere piccole o assenti:
molti supporti hanno una tastiera limitata, piccola o assente. Per esempio i nuovi cellulari UMTS
che sono in grado di navigare perfettamente all'interno di una pagina XHTML presentano grosse
difficoltà quando si deve accedere ad alcuni menu a tendina o peggio ancora a moduli in cui in
inserire dati. Stesso discorso è valido per palmari o altri dispositivi simili.
45
La piattaforma Android permette di entrare nel mondo dello sviluppo mobile in una delle realtà
attualmente più interessanti ed in continua evoluzione, quella degli applicativi Android, appunto.
Gli strumenti e le possibilità offerte da questa piattaforma ci permettono di lavorare in uno dei
contesti più tecnologicamente avanzati del momento. Lo sviluppo di applicativi mobile non è solo
divertimento, ma rappresenta anche un'interessante occasione di guadagno e offre la possibilità di
entrare in un mercato ancora tutto da scoprire e formare. I market offrono l'occasione di distribuire i
nostri lavori a milioni di utenze a costi decisamente contenuti.
46
5.Bibliografia
Android API Guides -http://developer.android.com/guide/components/activities.html
Redazione Io Programmo-“Android Programming” -Edizioni Masters
Android API Guides -http://developer.android.com/guide/components/fundamentals.html
Guida Android –
http://www.html.it/guide/guida-android
http://punto-informatico.it/PILibri/Dettaglio.aspx?id=238
http://sourceforge.net/projects/jvoicexml/files/userguide/0.7.5.GA/jvxml-userguide0.7.5.GA.pdf
W3C
-Voice
Extensible
Markup
http://www.w3.org/TR/voicexml20/
Language
(VoiceXML)
Version
2.0-
47