MagiCum S.r.l. Progetto Inno-School

Transcript

1 MagiCum S.r.l. Progetto Inno-School

2 Area applicazioni Autore: Matteo Salvador Revisione: 2.0 Data: 13/06/2013 Titolo: Documentazione tecnica tab Diario e tab Registro File: Documentazione tecnica.pdf Sito:

3 Indice pagina Introduzione al progetto...1 1) Vantaggi ) Specifiche tecniche IDE Le attività Gli intent Il manifesto R.Java...6 3) GUI Autenticazione Docente Alunno Calendario...8 4) Infrastruttura di rete & comunicazione alunno-docente Interfacciamento PHP-DB MySQL Interfacciamento Java-PHP La funzione PHPScriptExecute ) Programmazione three-tier

4 Indice figure pagina Figura Figura Figura Figura Figura Figura

5 Introduzione al progetto All'interno del contesto scolastico ci sono due supporti fisici di fondamentale importanza: per i docenti è il registro ad essere il fulcro di molte attività, mentre invece per gli alunni, soprattutto per quelli delle scuole primarie, il diario risulta essere un elemento essenziale. Per questo motivo i programmatori dell'area applicazioni si sono occupati dello sviluppo di due app Android: la prima è un registro per i docenti, mentre la seconda risulta essere un diario per gli alunni. Il target è costituito dagli studenti delle scuole elementari. I tablet su cui si ottiene una corretta visualizzazione dei due programmi specificati sono da 7 pollici. L'insegnante, una volta essersi autenticato con la propria utenza, può assegnare compiti, note, voti e comunicazioni alla famiglia nelle classi in cui insegna, a uno o più alunni di tali classi e per la/le propria/e materia/e. Gli studenti invece, dopo aver effettuato il login all'applicazione diario, possono consultare sia a scuola sia all'esterno dell'istituto comprensivo (con una connessione alla rete dati) i compiti, i voti, gli avvisi e le eventuali note che gli sono stati attribuiti. 1

6 1. Vantaggi I vantaggi legati all uso di queste due applicazioni rispetto al supporto cartaceo sono numerosi. In primo luogo è possibile garantire una certa interazione tra il mondo tecnologico, l innovazione ed il contesto scolastico. Questo perché non è ormai più possibile ignorare o non considerare ciò che l Informatica ci mette a disposizione per semplificare, rendere più efficienti e anche più piacevoli certe mansioni che vanno svolte quotidianamente in ambito lavorativo o didattico. Inoltre queste due applicazioni, data la semplicità dell interfaccia grafica e del loro ruolo predominante, sono di facile comprensione, e adatte all uso da parte di professori o professoresse che non possiedono conoscenze di Informatica approfondite e addirittura da alunni piccoli, che appunto frequentano la scuola primaria. I genitori o le famiglie degli allievi non rimangono di certo fuori dalla categoria dei potenziali utenti, in quanto devono supervisionare il/la loro figlio/a circa il corretto uso del software e possono in prima persona usufruire del servizio, essendo inoltre consapevoli che le informazioni (avvisi, compiti, ecc,) con cui verranno a contatto sono state scritte direttamente dagli insegnanti. Ciò garantisce l eliminazione di ogni dubbio sulla fedeltà e la correttezza di ciò che il/la proprio/a figlio/a svolge a scuola e dei doveri a cui è sottoposto/a. Risulta anche importante sottolineare l importanza di questo progetto nell aiutare bambini dislessici o soggetti a discalculia. Essi infatti non possono ad esempio sbagliare a scrivere i compiti da fare a casa, in quanto è il docente ad occuparsi di questa operazione. Apparentemente l eliminazione del supporto cartaceo nell ambito scolastico in cui Inno-School Applicazioni si vuole proporre può essere vista negativamente, soprattutto perchè interessa alunni molto giovani. Il progetto in questione però non impedisce di scrivere agli alunni, in quanto questa possibilità viene meno solamente in una piccola parte del contesto scolastico, e rimane sempre e comunque una componente essenziale da sviluppare per qualsiasi alunno/a. Inoltre sono previsti due diari differenti: per gli studenti fino alla seconda elementare viene negata l'opportunità di scrivere dei compiti, in quanto si vuole instaurare il rapporto di fiducia tra alunni e genitori, mentre per gli studenti dalla terza alla quinta è prevista una versione dove è possibile aggiungere informazioni, permettendo così di sviluppare un certo senso di indipendenza. 2

7 2. Specifiche tecniche Le applicazioni Registro e Diario sono state sviluppate per la versione Android 4.2 (Jelly Bean), che richiede le API (Application Programming Interface) di livello 17, ma possono comunque funzionare correttamente sui dispositivi con una versione Android superiore alla 3.0 (Honeycomb). La corretta visualizzazione grafica delle app è garantita su tablet con 7.0 pollici, ma ciò non vieta, agendo in modo opportuno sui file della cartella res/layout, di adattare l'interfaccia anche a dimensioni differenti. 2.1 IDE L'ambiente di sviluppo usato coincide con la versione 3.8 di Eclipse, dove è possibile sviluppare in parallelo la parte grafica, scritta in XML, e le funzionalità reali, scritte in Java (supporto delle librerie Android). 2.2 Le attività Uno dei concetti chiave del contesto Android, il quale ritornerà più volte in questa documentazione, è sicuramente l'activity. Un'attività risulta sostanzialmente essere una singola finestra, che occupa l'intero schermo del tablet considerato, con la quale l'utente può interagire. Nel nostro caso sono presenti quattro activity: autenticazione lato Docente, autenticazione lato Alunno, sezione Docente, area Alunno e il Calendario di sistema. Di seguito è appunto riportato il frammento di sorgente che individua lo scheletro dell attività Calendario: import public class Calendar extends Activity protected void oncreate(bundle savedinstancestate) super.oncreate(savedinstancestate); setcontentview(r.layout.calendario); 3

8 2.3 Gli intent Si tratta di una classe, appositamente scritta da Google per il sistema operativo Android, garantisce l'interazione tra due attività differenti. Per definizione un intent manifesta appunto l'intenzione di perseguire una determinata azione, intesa come il passaggio fra due activity differenti (a quella corrente si sostituisce in primo piano quella chiamata). Esistono due tipologie di intent: Espliciti: in essi si dichiara l'intenzione di chiamare una determinata classe, della quale sono note a priori le caratteristiche. Tutti gli intent richiamati nelle nostre app sono di questo tipo. Impliciti: dove si esprime la necessità di usare un particolare servizio (es. mandare un messaggio). Android, in base alle utility installate, gestire la richiesta espressa fornendo una lista delle possibili app capaci di soddisfarla. Nello sviluppo delle due app considerate in questa documentazione sono stati usati solamente degli intent espliciti. Per capire meglio come questa struttura venga usata è stata riportata una parte di codice che permette il passaggio dalla sezione Docente/Alunno al calendario: Intent calendarintent = new Intent(v.getContext(),Calendar.class); startactivityforresult(calendarintent, PICK_DATE_REQUEST); Da quanto è stato riportato si deduce che è necessario dichiarare un oggetto di tipo Intent contenente come riferimento la classe (Calendar) che deve essere creata e attraverso l istruzione startactivityforresult, viene fatto partire l intent interessato e, in questo caso particolare, l attività docente/alunno rimane in attesa di un risultato generato dal calendario e ritornato all attività da cui l intent è partito. Arrivati a questo punto si possono esplicitare le istruzioni che permettono il passaggio inverso, dal calendario alla sezione Docente/Alunno: date = Integer.toString(year) + "-" + Integer.toString(month) + "-" + Integer.toString(dayOfMonth); Intent i = new Intent(); // Return chosen date as string format i.putextra("date", date); setresult(result_ok, i); finish(); Una volta prelevata la data selezionata dal docente o dall alunno, si crea un nuovo intent nel quale, attraverso il metodo putextra, si ingloba nella richiesta una variabile di tipo stringa identificata dalla chiave date. Con finish() si procede alla chiusura del calendario. Inoltre ci sono varie modalità di trasmissione di un intenzione: una delle più diffuse, considerata largamente in questo contesto, interessa l uso del metodo putextra della classe Intent, che permette di passare variabili semplici oppure array ad un altra activity. 4

9 2.4 Il manifesto Il manifesto è un file xml che contiene tutte le informazioni di base che descrivono un progetto Android. Di seguito è riportato il manifesto dell applicazione docenti: <?xml version="1.0" encoding="utf-8"?> <manifest xmlns:android=" package="com.example.register" android:versioncode="1" android:versionname="1.0" > <uses-sdk android:minsdkversion="11" android:targetsdkversion="17" /> <application android:allowbackup="true" > <activity android:name="com.example.register.autentication" > <intent-filter> <action android:name="android.intent.action.main" /> <category android:name="android.intent.category.launcher" /> </intent-filter> </activity> <activity android:name=".calendar" android:screenorientation="landscape"> </activity> <activity android:name="com.example.register.register" > </activity> </application> <uses-permission android:name="android.permission.internet" /> </manifest> Nel tag uses-sdk si vanno a specificare le versioni Android minime, massime e target dell app interessata. Nella sezione application si vanno ad esplicitare l icona, il titolo e il tema dell app. Come aree annidate a quest ultima si inseriscono le attività con i vari riferimenti, la loro etichetta e, mediante l apposizione di un filtro, la tipologia di intent che sono in grado di gestire. Infine dopo la regola application è fondamentale specificare i permessi che l applicazione deve avere per funzionare correttamente (es. uso Bluetooth e Internet). 5

10 2.5 R.Java Questo sorgente Java si genera e si aggiorna automaticamente in fase di progettazione e scrittura del codice, e contiene un indirizzo esadecimale di tutti gli identificatori degli oggetti dichiarati, sorgenti XML (es. style, font, color, string)/java, immagini e cartelle del progetto (es, drawable, layout). Questo file non deve essere assolutamente modificato dall utente, in quanto un solo indirizzo scorretto è in grado di compromettere l intero funzionamento del programma. Qui sotto è riportata una porzione della classe che gestisce gli id dei vari oggetti ancorati nei layout XML: public static final class id public static final int CheckBox01=0x7f080024; public static final int SubjectsLayout=0x7f080019; public static final int calendarview1=0x7f080021; 3. GUI Dopo aver spiegato in modo generico le strutture/sorgenti di fondamentale importanza durante lo sviluppo di un applicazione Android si possono proporre le interfacce grafiche delle activity costituenti il progetto, con riferimenti alle strutture/oggetti usate/i (layout, edittext, button, ecc) e alla loro disposizione nella form. Le caratteristiche e le prestazioni grafiche sono legate all'emulatore (AVD) o all' HW in uso. 3.1 Autenticazione Figura 1 6

11 3.2 Docente Figura Alunno Figura 3 7

12 3.4 Calendario Figura 4 4. Infrastruttura di rete & comunicazione alunno-docente All'inizio dello sviluppo delle suddette applicazioni si era pensato di gestire la comunicazione tra ciò che assegnava il docente e le informazioni visibili ai vari studenti sfruttando i socket e SQLite. Sostanzialmente sia il tablet del professore sia quello dei vari studenti dovevano possedere un database in locale molto leggero ed efficiente, organizzato secondo la logica dei file ed elaborato attraverso un oggetto della classe SQLite e i metodi corrispondenti. Quando l'insegnante inseriva dei nuovi dati nel suo DB, si creava un canale di comunicazione (socket) fra il tablet del docente e quello degli alunni dell'aula, e si compiva l'aggiornamento delle varie basi di dati secondo i criteri specificati dal professore. Questa soluzione presenta due problematiche rilevanti: I socket corrispondono a gestori di risorse scritti per garantire la comunicazione a livello 3 e 4 della pila ISO/OSI tra due interlocutori. In Android le classi che gestiscono i socket non sono stati implementati correttamente nelle API superiori alla 11 (Android 3.0) e sono quindi inutilizzabili sia per la trasmissione TCP sia per quella UDP. Gli studenti che per motivi differenti non sono a scuola nel momento dell'aggiornamento del DB non potranno consultate le informazioni "dell'ultimo minuto" Per i motivi sopra citati si è pensato di introdurre un'architettura client-server dove è presente un unico database centralizzato condiviso tra gli studenti e i professori, i quali costituiscono i client del modello proposto. Inoltre, visto che i minorenni non possono avere per questioni di sicurezza un accesso ad Internet nell'istituto comprensivo, è stato necessario configurare due server 8

13 ridondanti, il primo privato e di proprietà della scuola, e il secondo accessibile pubblicamente al di fuori del contesto scolastico. I docenti potranno inserire le informazioni solamente nel server privato. L'aggiornamento del database server pubblico avverrà mediante la rete dati ogni volta che si presenterà una modifica al server privato. La fase di dump sarà portata a termine da un apposito script PHP. Di seguito è collocato uno schema di rete ipotetico estremamente semplificato, capace di realizzare l'infrastruttura di rete descritta: Figura 5 Il firewall scolastico rappresentato permetterà il trasferimento in uscita dei pacchetti che effettuano l'aggiornamento della base dei dati del server pubblico, mentre eventuali richieste provenienti dai tablet interni degli alunni verranno bloccate prima di raggiungere la WAN (Wide Area Network). Sarà invece permesso l'accesso online ai docenti, usufruendo della tecnologia 3G di cui sono dotati i loro dispositivi. 9

14 4.1 Interfacciamento PHP-DB MySQL Arrivati a questo punto è opportuno individuare un esempio pratico, con esplicitazione del sorgente, che permetta di realizzare un'interrogazione al server privato/pubblico di riferimento. In questa circostanza viene trattata la richiesta di autenticazione all'interfaccia Docente. Lo script PHP che esegue questa operazione è specificato qui sotto: <?php $name = trim($_request['name']); $surname = trim($_request['surname']); $hash_password = trim($_request['password']); $conn = mysql_connect("indirizzoip", "UTENTE", "PASSWORD") or die ( mysql_error() ); $db = mysql_select_db("database") or die ( mysql_error() ); $result = mysql_query("select * FROM Docenti WHERE Nome='$name' AND Cognome='$surname' AND Hash_password='$hash_password'") or die ( mysql_error() ); if ($result) while($e = mysql_fetch_assoc($result)) $output[] = $e; print(json_encode($output)); else echo "Nessun risultato\n"; mysql_close($conn);?> L'array superglobale $_REQUEST contiene i valori inseriti dall'utente nelle EditText nome, cognome, password, ed essi vengono assegnati a tre variabili differenti. Una volta fatto ciò viene eseguita una connessione al DBMS Mysql posto sul server interessato e si seleziona la base dei dati. Si interroga il database attraverso una query che richiede una selezione (taglio orizzontale) in rispondenza della tupla che individua i dati del professore che desidera autenticarsi. Nel caso in cui il booleano $result sia TRUE allora si stampa a video in formato json l'ennupla di riferimento. Nel caso in cui mysql_query restituisca FALSE, allora viene scritto nella pagina dinamica "Nessun risultato". Il JSON, acronimo di JavaScript Object Notation, è un formato, basato sul linguaggio JavaScript, adatto per lo scambio dei dati in applicazioni client-server. Un json si presenta generalmente sottoforma di array associativo con coppia chiave-valore. 10

15 4.2 Interfacciamento Java-PHP La chiamata dello script PHP citato nel paragrafo precedente deve avvenire dall'app Android e deve quindi essere gestito da Java attraverso delle classi opportunamente importate nel progetto. Di seguito è riportata la porzione di codice Java che effettua la chiamata allo script appena spiegato: private void logintoregister (View v) professorname = (EditText) findviewbyid(r.id.professornameedit); professorsurname = (EditText) findviewbyid(r.id.professorsurnameedit); professorpassword = (EditText) findviewbyid(r.id.professorpasswordedit); /*************************PHP*****************************/ new AsyncTask<Void, Void, String>() protected String doinbackground(void... params) // List of parameters of the PHP script ArrayList<NameValuePair> Values = new ArrayList<NameValuePair>(); Values.add(new BasicNameValuePair("name", professorname.gettext().tostring())); Values.add(new BasicNameValuePair("surname", professorsurname.gettext().tostring())); Values.add(new BasicNameValuePair("password", sha1hash(professorpassword.gettext().tostring()))); // Select the professor String results = PHPScriptExecute("INDIRIZZOSCRIPT1", Values); try // Split of the json file and start the Register activity JSONArray jarray = new JSONArray(results); String selectresults = ""; JSONObject json_data = jarray.getjsonobject(0); // List of parameters of the PHP script ArrayList<NameValuePair> Values2 = new ArrayList<NameValuePair>(); Values2.add(new BasicNameValuePair("IdDocPk", json_data.getstring("iddocpk").tostring())); // Select the professors' classes results = PHPScriptExecute("INDIRIZZOSCRIPT2", Values2); // Start the register activity Intent registerintent = new Intent(context, Register.class); String[] classrooms = results.split(" "); 11

16 registerintent.putextra("classrooms", classrooms); startactivity(registerintent); selectresults = selectresults + json_data.getstring("iddocpk").tostring() + " " + json_data.getstring("nome").tostring() + " " + json_data.getstring("cognome").tostring() + "\n"; return selectresults; catch (JSONException e) return protected void onpostexecute(string result) EditText professornameedit = (EditText) findviewbyid(r.id.professornameedit); //Print results of the parsing operation if (result == null) Toast.makeText(getApplicationContext(), "Credenziali non valide", Toast.LENGTH_LONG).show(); else // Delete the strings of the three edittext professorname.settext(""); professorsurname.settext(""); professorpassword.settext(""); Toast.makeText(getApplicationContext(), "Autenticazione effettuata con successo", Toast.LENGTH_LONG).show();.execute(); Partendo dalla versione 3.0 di Android, l'uso dell'asynctask è fondamentale quando si vogliono eseguire delle operazioni in background dissociate dall' UI thread, cioè dall'attività principale. In questo caso è stata implementato per chiamare, come già detto, lo script PHP che esegue l'autenticazione. Nell'ArrayList values vengono inseriti i tre parametri necessari allo script per funzionare correttamente, i quali sono stati prelevati dalle rispettive EditText. Mediante la chiamata alla funzione PHPScriptExecute, che presenta come parametri attuali l'url dello script e i valori da mettere in $_REQUEST, viene eseguita una HTTPRequest che appunto richiede l'apertura di una pagina web statica o dinamica, attua il parsing della pagina stessa e ritorna una variabile di tipo stringa con l'intero contenuto scandito. In questa circostanza si ottiene un json in results, il 12

17 quale viene scompattato considerandone le singole celle, attraverso le classi messe a disposizione da Java per svolgere questo compito (es. JSONArray, JSONObject). Nel caso in cui il json sia vuoto, il metodo doinbackground restituisce un valore nullo e quindi nella procedura onpostexecute, il cui codice viene considerato una volta che è stato eseguita l'operazione in secondo piano e si desidera trattare i risultati prodotti da quella operazione, viene stampato un messaggio (detto Toast in Android) "Credenziali non valide". Se invece il json contiene la tupla interessata si esegue un intent esplicito che fa partire l'attività registro e nella transizione di activity compare a video "Autenticazione effettuata con successo". In questa istanza dell'asynctask viene anche messa in atto la chiamata ad un secondo script PHP, che serve per prelevare dal DB la/e classe/i in cui insegna il docente, in modo tale che quest'ultimo possa aggiungere informazioni alla base dei dati solo ed esclusivamente ai suoi alunni. La lista della/e classe/i valide viene trasmessa all'attività Registro attraverso il metodo putextra(chiave, valore/i) della classe intent. 4.3 La funzione PHPScriptExecute In questa sezione viene solamente riportato il codice relativo alla funzione PHPScriptExecute: private String PHPScriptExecute(String url, ArrayList<NameValuePair> namevaluepairs) InputStream is = null; // Creating HTTP client HttpClient httpclient = new DefaultHttpClient(); // Creating HTTP Post HttpPost httppost = new HttpPost(url); // Making HTTP Request try // Send parameters specified httppost.setentity(new UrlEncodedFormEntity(nameValuePairs)); HttpResponse response = httpclient.execute(httppost); // Take the HTML response HttpEntity entity = response.getentity(); is = entity.getcontent(); // Parsing of the response BufferedReader reader = new BufferedReader(new InputStreamReader(is,"iso "),8); StringBuilder sb = new StringBuilder(); String line = null; while ((line = reader.readline())!= null) sb.append(line + "\n"); is.close(); return sb.tostring(); catch (ClientProtocolException e) 13

18 Toast.makeText(getApplicationContext(), "Errore nella connessione http", Toast.LENGTH_LONG).show(); catch (IOException e) Toast.makeText(getApplicationContext(), "Errore nella connessione http", Toast.LENGTH_LONG).show(); return null; 5. Programmazione three-tier La diffusione di tecnologie multicanale ha portato, negli anni, allo sviluppo di un nuovo concetto di programmazione, detto three-tier. Questo progetto rappresenta un tipico esempio di evoluzione, non solo tecnica e tecnologica, ma anche "filosofica", in quanto emerge la variabilità degli strumenti (PC, tablet, smartphone) e dei contenuti da consultare e con cui interagire. L architettura sviluppata per il diario e il registro non si limita quindi ad una struttura client-server, ma è anche composta da alcuni elementi della programmazione three-tier: Figura 6 14

19 Essa si basa appunto su tre livelli: Data (store) layer, dove sono collocati i dati dell applicazione, i quali risiedono fisicamente sul server (es. DBMS, DB, file XML) Business/Application layer, dove sono posizionate le business logic. Esse si occupano del processamento dei dati e garantiscono un interazione tra gli strumenti che il client usa per connettersi ad un server (es. Web browser) e ciò che il server è in grado di fornire Presentation layer, che corrisponde al livello dove avviene la visualizzazione, generalmente mediante GUI, degli aspetti dell applicazione e dove si verifica la fornitura dei servizi. Inoltre, attraverso lo strato presentazione, è possibile inviare le HTTP request alle business logic, le quali, dopo aver interagito con il server, risponderanno con quelle che vengono definite HTTP reply. Ciò è realizzabile, come già detto, introducendo lo strato citato nel secondo punto, sul quale si presenta un dislocamento del carico che dovrebbe gravare sul lato server, lasciando in questa sezione solamente le informazioni (basi di dati, pagine web, ecc). Il ruolo fondamentale è quindi esercitato dalle business logic, intese come l insieme dei programmi che eseguono le azioni richieste (es. query, report) ma che sono allo stesso tempo indipendenti anche per quanto riguarda l aggiornamento, sia dal client, sia dal server. I due componenti di maggior rilievo in questa struttura sono: J2EE (Java 2 Platform Enterprise Edition), linguaggio cross-platform che permette di scrivere sorgenti Java compilati nel bytecode e messi in esecuzione in seguito all interpretazione.net, piattaforma che permette di sviluppare applicazioni usando una serie di linguaggi di programmazione supportati (VB.NET, C#, ecc) 15