UNIVERSITÀ DEGLI STUDI DI PARMA

Transcript

1 UNIVERSITÀ DEGLI STUDI DI PARMA DIPARTIMENTO DI MATEMATICA E INFORMATICA Corso di Laurea in Informatica Tesi di Laurea SUPPORTO ALL'UTILIZZO DI SERVIZI DI SOCIAL NETWORK NELLA PIATTAFORMA AMUSE Relatore: Prof. Federico Bergenti Candidato: Alessandro Bertoletti Anno Accademico 2013/2014

2 Indice 1 AMUSE Introduzione JADE WADE Architettura Funzionalità AMUSE API Client API Server API Social Network Introduzione Facebook Graph API Facebook App Access Token Permission Facebook SDK per Android Studio del problema Introduzione Studio della piattaforma AMUSE Autenticazione e Registrazione Gestione degli Amici Possibili Soluzioni Login Gestione degli Amici Implementazione e Funzionamento Implementazione Implementazione login tramite social network

3 INDICE INDICE Implementazione di Trova Amici Funzionamento Riferimenti bibliograci 44 A Login with Social Network in AMUSE 45 A.1 Introduction A.1.1 Prerequisites A.2 Necessary Material A.2.1 Create a Facebook App A.2.2 Add Facebook SDK to Your Project A.3 Add Facebook Features A.3.1 Add Login with Facebook A.3.2 Play with Facebook Friends

4 Introduzione L'obiettivo di questa tesi è indagare sulla possibilità di integrazione dei servizi di Social Network e AMUSE. L'idea di base è quella di aancare ai servizi già esistenti di AMUSE, quali login e ricerca di amici, quelli di un social network permettendo così all'utente nale un utilizzo più semplice e immediato dell'applicazione AMUSE-based sviluppata. Il lavoro è stato svolto nel modo più trasparente possibile, studiando a fondo la piattaforma AMUSE e cercando le varie soluzioni possibili: una volta trovata la migliore si è passati alla fase di sviluppo, cercando di modicare il meno possibile le funzionalità già implementate in AMUSE. Il social network scelto per testare la piattaforma è Facebook, questo perché, ad oggi, è il social network più utilizzato in Europa e in Italia e ore una SDK migliore delle altre. Lo sviluppo della tesi è organizzato nel modo seguente: Il capitolo 1 introduce più in dettaglio la piattaforma AMUSE e ne spiega il funzionamento. Il capitolo 2 introduce i servizi di Facebook integrati con AMUSE. Il capitolo 3 fa una panoramica sui social network, per poi spiegare Facebook e i suoi servizi. Il capitolo 4 spiega le modiche apportate al sistema AMUSE per integrare i servizi di Social Network. Nel capitolo 5 vi è spazio per conclusioni e sviluppi futuri. Inne, nell' appendice è possibile trovare un tutorial, scritto in lingua inglese, il quale spiega come inserire all'interno della propria applicazione le feature introdotte. 3

5 Capitolo 1 AMUSE 1.1 Introduzione AMUSE (Agent-based Multi-User Social Environment) è una piattaforma software che facilita lo sviluppo di applicazioni social distribuite, le quali portano gli utenti a cooperare o a competere per la realizzazione di obiettivi comuni o privati. Per questo motivo, lo scopo principale di AMUSE è la realizzazione di giochi multiplayer on-line. La piattaforma AMUSE è un sistema JADE-based e, per la gestione dei componenti e delle comunicazioni, adopera le soluzioni già implementate WADE e JADE JADE JADE (Java Agent DEvelopment Framework) è un Framwork implementato completamente in Java. Il suo scopo è quello di semplicare l'implementazione di sistemi multi-agente attraverso un middle-ware che compila il codice secondo le speciche FIPA e che aiuta le fasi di debug e di sviluppo grazie a un set di tools graci. Un sistema JADE può essere distribuito tra varie macchine (le quali non hanno bisogno di avere lo stesso sistema operativo) e la loro congurazione può essere controllata attraverso una GUI remota. Insieme all'astrazione degli agenti, JADE fornisce una semplice ma potente task execution, un compositore di modelli, comunicazione peer-to-peer tra agenti basata sullo scambio di messaggi asincroni, un servizio di pagine gialle e molte altre caratteristiche avanzate che facilitano lo sviluppo di un sistema distribuito. JADE è un software gratuito ed è distribuito da Telecom Italia, detentore del copyright, in open source secondo i termini e le condizioni della licenza LGPL. 4

6 1.2 Architettura AMUSE WADE WADE (Workows and Agents Development Environment) è una piattaforma software basata su JADE, la quale fornisce supporto per l'esecuzione di task deniti secondo la metafora del workow. La componente chiave di WADE è la classe WorkowEngineAgent che estende la classe Agent della libreria JADE incorporando un piccolo e leggero motore di workow. Oltre ai normali behaviours di JADE, un WorkowEngineAgent è capace di eseguire workow in accordo a specici formalismi di WADE. Questi formalismi sono scritti in linguaggio JAVA. Uno dei principali vantaggi dell'approccio a workow è la possibilità di rappresentare i processi in forma graca, WADE ore un servizio di sviluppo, chiamato WOLF, che facilita la creazione di applicazioni WADE-based. WOLF è un plug-in di Eclipse che permette di sfruttare tutte le funzionalità dell'ide Eclipse in aggiunta alle potenzialità oerte da WADE. WADE è un software gratuito ed è distribuito da Telecom Italia, detentore del copyright, in open source secondo i termini e le condizioni della licenza LGPL. 1.2 Architettura La seguente gura mostra una panoramica dell'architettura di AMUSE: tutte le applicazioni AMUSE-based comprendono la logica necessaria per il lato client insieme a un'eventuale interfaccia graca. Le applicazioni client fanno uso della libreria AMUSE client library per interagire con altri client e con il server. Nella versione corrente (AMUSE 1.0 rilasciata il 10/12/2014) sono supportati solo le applicazione Android-based. Nella maggior parte dei casi le applicazioni AMUSE-based hanno bisogno di una specica logica che deve essere eseguita nel lato server. Queste 5

7 1.3 Funzionalità AMUSE applicazioni, nel terminologia di AMUSE, sono chiamate applicazioni serverbased. Per l'esecuzioni di queste logiche la piattaforma AMUSE fornisce un ambiente PaaS (Platform as a Service): le applicazioni non sono a conoscenza dei dettagli relativi all'hardware, sistemi operativi e altro riguardanti il server. D'altra parte il sistema è distribuito su un ambiente cloud e AMUSE ha il compito di assicurarsi che ogni lavoro abbia le risorse necessarie per il suo corretto funzionamento. AMUSE mette a disposizione la AMUSE Application Administration Interface, con la quale è possibile registrare, installare, congurare e avviare le speciche logiche server-side delle varie applicazioni sviluppate. Una volta lanciate, i client possono connettersi e sfruttare i servizi messi a disposizione. Nei casi in cui le applicazioni non necessitano di una logica a lato server, in AMUSE ci riferiamo ad esse come applicazioni client-only. Per avviare questo tipo di applicazioni, basta una registrazione sulla AMUSE Application Administration Interface. 1.3 Funzionalità Le funzionalità di AMUSE si dividono in Core e in Gaming. Le Core, al contrario delle Gaming, non sono solo orientate allo sviluppo di giochi e possono essere usate in generiche applicazioni multi utente. Le funzioni Core le troviamo nel package com.amuse.client.features.core, mentre le Gaming, nel package com.amuse.client.features.gaming. Le principali sono: Gestione Applicazioni: questa funzione ore la possibilità di registrare, installare, congurare e attivare le applicazioni sviluppate, le quali sono disponibili presso la AMUSE Application Administration Interface accessibile via Web. Gestione Utenti: questa funzione si occupa della registrazione e della autenticazione degli utenti e supporta in parte minimale la gestione dei proli utenti. Le API client che si occupano di questo sono contenute nella classe com.amuse.client.features.core.usermanagementfeature. Sincronizzazione del Clock: questa funzione si incarica della sincronizzazione degli eventi, in modo tale che la stessa applicazione su terminali dierenti esegua contemporaneamente un'azione (questa funzione ha una particolare importanza per i giochi real-time, dove un match inizia, gestisce eventi e nisce allo stesso tempo per tutti i giocatori). 6

8 1.3 Funzionalità AMUSE Scambio di messaggi di testo: questa funzione ore la possibilità di mandare e ricevere messaggi di testo da o verso altri utenti con la stessa applicazione. Questo servizio è accessibile attraverso le API contenute nella classe com.amuse.client.features.core.textmessagefeature. Nel caso in cui il ricevente non sia connesso nel momento in cui il messaggio è stato inviato, il messaggio sarà automaticamente salvato nel lato server dell'applicazione e sarà consegnato non appena il ricevente si sarà connesso. Gestione delle pipe Peer-to-peer: questa funzione ore la possibilità di stabilire una connessione diretta tra i client, i quali potranno in seguito scambiarsi specici oggetti. Le API sono accessibili tramite l'interfaccia com.amuse.client.features.core.pipemanagementfeature. Coordinazione match Peer-to-peer: questa funzione ore la possibilità di organizzare match one-to-one in modo persistente: se un utente si disconnette durante il match, potrà riconnettersi in un momento successivo. La partecipazione al match utilizza la metafora dell'invito: l'organizzatore manda una richiesta all'avversario in modo esplicito specicando il suo nome o chiede alla piattaforma AMUSE di trovargli un avversario casuale. Una volta accettato l'invito da parte dell'avversario, il match ha inizio. Le applicazioni basate su questo approccio non richiedono nessuna logica da parte del server, e possono essere sviluppate come applicazioni client-only. Le API contenute nella classe com.amuse.client.features.gaming.matchcoordinationfeature orono questo servizio. Coordinamento centralizzato del match: questo servizio si occupa dell'organizzazione di match che comprendono due o più giocatori, i quali possono entrare o uscire dalla partita, mentre è ancora in svolgimento. La partecipazione al match utilizza la metafora dei tavoli: l'organizzatore del match crea un tavolo vuoto, dove gli avversari possono sedersi per unirsi alla partita. Non appena il numero minimo di giocatori è stato raggiunto il match ha inizio. I tavoli sono disposti in stanze, dove un giocatore deve accedere prima di sedersi in un qualsiasi tavolo. Le applicazioni basate su questo approccio richiedono una specica logica che governi il lato server, infatti queste applicazioni vengono chiamate server-based. La logica deve essere implementata estendendo la classe com.amuse.agents.gra.gamesroomagent la quale contiene i meccanismi base per la gestione dei tavoli all'interno delle stanze e per la coordinazione dei match giocati sui vari tavoli. 7

9 1.4 AMUSE API AMUSE 1.4 AMUSE API La piattaforma AMUSE è così composta: una piattaforma sulla quale viene gestita la logica di AMUSE, insieme a quella specica per ogni gioco che ne necessita. un set di client API per lo sviluppo di applicazioni sul sistema operativo Android per implementare tutti gli aspetti di gioco prima menzionati un set di server API che servono, quando necessario, a gestire la logica di gioco tra i vari client connessi Client API Le client API di AMUSE sono contenute nel package com.amuse.client e organizzate nei suoi vari sub-package. La classe AmuseClient, facente parte del package com.amuse.client.android, è il punto di ingresso per accedere a tutte le funzionalità client AMUSE, in particolare il suo metodo connect(), ci permette la connessione e l'autenticazione nella piattaforma AMUSE. Una volta autenticato l'account con successo, il metodo getfeature() ci permette di recuperare le classi che implementano le feature contenute nei package scritti sopra. Tutte le API di AMUSE che richiedono l'iterazione con la piattaforma AMUSE lavorano in modo asincrono: infatti come argomento richiedono sempre una Callback la quale contiene il metodo onsuccess(), che viene invocato quando l'operazione è stata completata con successo, e il metodo onfailure(), invocato nel caso contrario. La logica di gioco in una applicazione AMUSE si descrive implementando l'interfaccia Table.Listener, la quale mette a disposizione i seguenti metodi: handlematchstarting(), invocato quando si è raggiunto il numero minimo di giocatori in un tavolo e il match può iniziare; handleplayerjoined(), invocato quando un giocatore entra nel tavolo in cui il giocatore corrente risiede; handleplayerleft(), invocato quando un giocatore lascia il tavolo in cui il giocatore corrente risiede, questo può succedere sia prima che dopo l'inizio del match; handleplayermoved(), invocato quando un altro giocatore compie una mossa del gioco; 8

10 1.4 AMUSE API AMUSE handlematchevent(), invocato quando occorre un evento specico non direttamente correlato alla mossa di un giocatore; handlematchfinished(), invocato quando il match nisce. Per noticare al lato server dell'applicazione che il giocatore corrente ha eseguito una mossa, bisogna chiamare il metodo move() della classe Table contenuta nel package com.amuse.client.features.gaming Server API La logica a lato server di un'applicazione AMUSE-based è necessaria soltanto quando l'applicazione ha implementato la classe GamesRoomFeature. Essa viene descritta implementando uno o più istanze di un agente estendendo la classe GamesRoomAgent. Il nome dell'agente corrisponde al nome della stanza. Ogni GamesRoomAgent contiene al suo interno un numero di oggetti TableManager, ognuno dei quali, gestisce un tavolo all'interno della stanza. Inoltre, la classe GamesRoomAgent, mette a disposizione una serie di metodi che verranno invocati solo in occasione di eventi rilevanti per la sessione di gioco, i quali devono essere rideniti per implementare la logica di gioco. I metodi più rilevanti da ridenire sono: handletablecreate(), invocato quando il server riceve l'ordine di creare un tavolo; handlematchstartup(), invocato appena il numero minimo di giocatori per l'inizio del match è stato raggiunto; handlemove(), invocato quando un giocatore ha eseguito una mossa; handleplayerjoined(), invocato quando un giocatore entra in un tavolo; handleplayerleft(), invocato quando un giocatore esce da tavolo. I tavoli di gioco possono essere creati in due modi: attraverso il metodo createtable() della classe GamesRoomAgent o come conseguenza di una richiesta da parte di un utente, così da poter creare un tavolo privato al quale solo gli invitati possano accedere; in tutti e due i casi viene chiamato il metodo handletablecreated(). Durante la fase di creazione di un tavolo è possibile specicare un minimo numero di giocatori sopra il quale il match inizierà e un numero massimo di giocatori partecipanti alla partita. Quando il match è giunto al termine, si utilizza il metodo setmatchfinished() della classe TableManager per noticare la terminazione del match al GamesRoomAgent. 9

11 Capitolo 2 Social Network 2.1 Introduzione Con l'espressione social network si identica un servizio informatico on line che permette la realizzazione di reti sociali virtuali. Si tratta di siti Web che consentono agli utenti di condividere contenuti testuali, immagini, video e audio e di interagire tra loro. Secondo la denizione, data dagli studiosi Boyd-Ellison [3], si possono denire siti di social network i servizi web che permettono: la creazione di un prolo pubblico o privato all'interno di un sistema vincolato, l'articolazione di una lista di contatti, la possibilità di scorrere la lista di amici dei propri contatti. Generalmente, prevedono una registrazione mediante la creazione di un prolo personale protetto da password partendo da informazioni come il proprio nome, cognome, indirizzo no ad arrivare agli interessi e alle passione che abbiamo. Inoltre si ha la possibilità di eettuare ricerche nel database della struttura informatica per localizzare altri utenti e organizzarli in gruppi e liste di contatti. Un importante sviluppo delle reti sociali è rappresentato dalla possibilità di creare da parte di chiunque ne abbia le competenze (sviluppatori con linguaggi solitamente proprietari) applicazioni orientate alla comunità degli iscritti. Tale famiglia di applicazioni, beneciano della rete di contatti e delle informazioni individuali degli iscritti (es. Facebook, Google+, Twitter) per facilitare operazioni quali registrazioni e accessi a servizi esterni al social network. 10

12 2.2 Facebook Social Network 2.2 Facebook Facebook è un servizio di rete sociale lanciato nel febbraio del 2004, posseduto e gestito dalla corporazione Facebook Inc., basato su una piattaforma software scritta in vari linguaggi di programmazione. Fondato a Harvard negli Stati Uniti da Mark Zuckerberg e dai suoi compagni di università Eduardo Saverin, Dustin Moskovitz e Chris Hughes, era originariamente stato progettato esclusivamente per gli studenti dell'università di Harvard, ma fu presto aperto anche agli studenti di altre scuole della zona di Boston, della Ivy League e della Stanford University. Successivamente fu aperto anche agli studenti delle scuole superiori e poi a chiunque dichiarasse di avere più di 13 anni di età. Da allora Facebook raggiunse un enorme successo: secondo Alexa dal giugno 2013 è diventato il sito Web più visitato al mondo, superando Google; ha cambiato profondamente molti aspetti legati alla socializzazione e all'interazione tra individui, sia sul piano privato che quello economico e commerciale. È disponibile in oltre 70 lingue e nell'ottobre 2012 conta circa un miliardo di utenti attivi che eettuano l'accesso almeno una volta al mese, classicandosi come primo servizio di rete sociale per numero di utenti attivi. Gli utenti possono accedere al sito previa una registrazione gratuita, durante la quale vengono richiesti dati personali come nome, cognome, data di nascita e indirizzo . Completata la registrazione, gli utenti possono creare un prolo personale, includere altri utenti nella propria rete sociale, aggiungendoli come amici, scambiare messaggi tramite una chat integrata oppure condividere uno stato, una foto o un qualsivoglia contenuto multimediale Graph API Le Graph API sono API pensate dagli sviluppatori Facebook per scambiare informazioni con la piattaforma di Facebook. Sono delle richieste HTTP di basso livello e possono essere usate per richiedere dati relativi a un utente, postare uno stato sulla propria pagina di Facebook, caricare foto e tutti gli altri compiti di cui abbiamo bisogno. Le Graph API essendo HTTP based possono essere usate insieme a qualsiasi linguaggio di programmazione. Facebook ha adottato la metafora social graph per la rappresentazione delle informazioni sulla sua piattaforma, da qui deriva il nome di queste API. Il grafo è composto da: nodi: che rappresentano informazioni come per esempio un utente, una foto o un commento; 11

13 2.2 Facebook Social Network archi: che rappresentano le connessioni tra i nodi, come per esempio un commento a una foto; campi: sono i campi che i nodi possono avere, come la data di compleanno di un utente. Ogni nodo del grafo ha un ID unico, il quale permette di raggiungerne il contenuto. Questo è un esempio per richiedere un nodo: GET graph.facebook.com /{id-nodo Ad esempio, se volessimo ottenere le informazioni del nostro prolo personale basterà richiedere GET graph.facebook.com /v2.3/me La risposta da parte di Facebook, ci comunica le informazioni base del prolo utente, quali ID, nome cognome, il link al prolo e altre informazioni, il tutto formattato in stile JSON. { "id": " ", "birthday": "10/08/1991", "first_name": "Alessandro", "gender": "male", "last_name": "Bertoletti", "link": " "locale": "it_it", "name": "Alessandro Bertoletti", "timezone": 2, "updated_time": " T22:34: ", "verified": true Per questioni di sicurezza e di privacy, per eseguire richieste Graph API è necessario disporre di una Facebook App alla quale riferirci e di un Access Token con cui autenticarci. Inoltre alcuni dati sono disponibili solo dopo il consenso delle Permission da parte dell'utente. 12

14 2.2 Facebook Social Network Facebook App Le Facebook App sono applicazioni Web che permettono l'interazione tra la nostra applicazione e i server di Facebook. Per creare una Facebook App, è necessario per prima cosa collegarsi al sito web cliccare su Add a new app e scegliere la piattaforma con la quale andremo a interrogare i server di Facebook: possiamo scegliere tra una vasta tipologia di piattaforme tra le quali le più famose sono ios, Android, sito Web e Facebook Canvas. Possono convivere più piattaforme alla volta, ognuna di esse sarà identicabile singolarmente tramite un ID. L'applicazione sarà reperibile grazie a due codici che identicheranno la coppia Facebook App e piattaforma scelta: l'app ID e l'app Secret. Il primo è un codice numerico che rappresenta la nostra applicazione, il secondo è un codice segreto che non dovrà mai essere pubblicato e ha la funzione di autenticare le richieste fatte dall'applicazione verso i server di Facebook. Inoltre sarà ora possibile autenticare un utente Facebook tramite il Facebook Login Access Token Un Access Token è una stringa che identica un utente, un'applicazione o una pagina e può essere usato da quest'ultimi per eseguire una richiesta ai server Graph API. Gli Access Token sono ottenibili eseguendo il login su Facebook e contengono le informazioni sulla data di scadenza del token, da chi è stato generato e a che tipo di dati abbiamo accesso. Esistono vari tipi di Access Token dierenziati dai vari tipi di utilizzo: User Access Token Sono i token utilizzati più spesso. Questo tipo di token è sempre necessario quando l'applicazione chiama un API per leggere, modicare o scrivere i dati di utente Facebook. Generalmente vengono ottenuti tramite una nestra di login e richiedono l'autorizzazione di una persona sica per portare a termine la creazione. App Access Token Questo tipo di token è necessario per modicare e leggere le impostazioni di una applicazione Facebook. Viene generato a partire da un codice segreto, chiamato App Secret, utilizzato durante le chiamate che cambiano le impostazioni a livello di Facebook App. Page Access Token Questo Access Token è molto simile allo User Access Token con la dierenza che permette gli accessi di lettura, modica e scrittura a una pagina Facebook. Si ottiene solo dopo aver 13

15 2.2 Facebook Social Network validato uno User Access Token richiedendo il permesso manages page permission tramite apposita chiamata Graph API. Client Token - Il Client Token è un identicatore che può essere abbinato a una applicazione nativa mobile o desktop il quale identica la applicazione Facebook a cui fa riferimento. Questo token non è pensato per essere segreto, per questo ha accesso a ristrette chiamate Graph API. Gli User Access Token si dividono in due tipi: short-lived token e longlived token. I primi, solitamente, hanno una durata di circa una o due ore al massimo, mentre i secondi hanno una vita di 60 giorni. Le applicazioni mobile che usano la SDK di Facebook generano degli long-lived token. Una delle caratteristiche più importanti degli Access Token è che essi sono portabili: una volta ottenuto può essere usato per fare richieste da un client mobile, da un Web browser o dal nostro server. Infatti, se abbiamo ottenuto il Token tramite un'applicazione mobile, possiamo inviarlo al nostro server per poi eseguire delle chiamate direttamente da quest'ultimo Permission Come accennato nel paragrafo precedente, gli Access Token ci garantiscono l'accesso ai dati dell'utente. Le Permission sono il metodo per richiedere accesso alle risorse che non sono reperibili liberamente: l'utente può infatti selezionare le informazioni alle quali l'applicazione può avere o non avere accesso. Le Permission sono stringhe che vengono passate insieme a una richiesta di login o a una chiamata Graph API. Questo è un esempio di Permission: - garantisce l'accesso all' dell'utente friends - garantisce l'accesso agli amici che hanno utilizzato la stessa applicazione Facebook publish_actions - permette all'applicazione di pubblicare contenuti sulla propria pagina Facebook Facebook SDK per Android La Facebook SDK per Android permette di integrare i servizi oerti dal Social Network nel sistema operativo Android, alcune di queste feature richiedono che l'utente abbia installata sul proprio telefono la Facebook per Android app. Grazie alla SDK di Facebook sarà possibile: 14

16 2.2 Facebook Social Network il Login tramite Facebook: permette agli utenti di accedere all'applicazione con la loro identità Facebook senza che ci sia bisogno di reinserire le proprie credenziali Facebook; la condivisione di risultati o contenuti: consente alle persone di pubblicare su Facebook direttamente dall'applicazione; l'accesso alle Graph API: l'accesso alle Graph API consente di ottenere o inviare dati ai social graph di Facebook. É possibile interrogare i dati, aprire nuove storie, caricare foto e altro ancora. l'invio di richieste: permette agli utenti di inviare le richieste ai loro amici per provare l'applicazione. 15

17 Capitolo 3 Studio del problema 3.1 Introduzione Il problema datomi da risolvere è cercare la possibilità di sfruttare i servizi oerti dai social network nella piattaforma AMUSE. Il tutto deve essere svolto nel modo più trasparente possibile: la logica della piattaforma AMUSE non deve cambiare, ne subire cambiamenti drastici. In questo capitolo verrà spiegato lo studio fatto sulla piattaforma AMUSE elencando le funzionalità e le classi coinvolte. I servizi da integrare in AMUSE sono l'autenticazione e la ricerca di amici contro o con cui giocare tramite Social Network. AMUSE, come già descritto, è composto da un lato server e da un lato client. Il lato server si occupa della registrazione e dell'autenticazione degli utenti, della logica del sistema e di tutti gli altri servizi oerti dalla piattaforma, mentre il lato client fornisce allo sviluppatore le chiamate per interagire con quest'ultima. Per uno studio più approfondito è stato necessario installare la piattaforma AMUSE in locale. Questa operazione è risultata particolarmente complessa causa la mancanza di documentazione o di una guida che spiegasse come fare. Dopo vari tentativi, si è riusciti a risolvere tutte le problematiche e ad avviare un server AMUSE locale. 3.2 Studio della piattaforma AMUSE Autenticazione e Registrazione A lato server la responsabile delle autenticazioni e delle registrazioni è la classe AuthenticationService contenuta nel package com.amuse.admin.services. 16

18 3.2 Studio della piattaforma AMUSE Studio del problema Al suo interno, infatti, sono presenti due metodi: il metodo authenticate() e il metodo managenewaccount(). Il primo viene invocato quando al server riceve una richiesta di autenticazione, i parametri che richiede sono una stringa, che contiene lo username e la password dell'utente separate dal carattere : e un oggetto di tipo Logger. Al suo interno la stringa viene spezzata per il carattere : attraverso il metodo extractcredentialsinfo() contenuto nella classe AmuseUtils la quale ritorna un array di stringhe. Così facendo si ricavano lo username e la password, che occupano rispettivamente le posizioni zero e uno dell'array di stringhe ritornato. Successivamente viene controllata la corrispondenza tra lo username e la password, prima controllando l'esistenza dello username all'interno del database e, in caso aermativo, se username e password appartengono allo stesso utente. Nel caso in cui l'autenticazione sia andata a buon ne, il metodo authenticate() ritorna una stringa contenente lo username, in caso contrario lancia un'eccezione contenente la descrizione dell'errore. Il secondo, invece, viene invocato quando il server riceve una richiesta di registrazione, il parametro richiesto è una stringa contenente lo username e la password dell'utente da registrare separati dal carattere :. La stringa viene spezzata per il carattere : attraverso il metodo, già menzionato precedentemente, extractcredentialsinfo(). Ricavati username e password, si richiede al database l'esistenza o meno di un account avente lo stesso username: se esiste viene lanciata un'eccezione, in caso contrario viene registrato un nuovo account con le credenziali uguali allo username e alla password ricevute. Nel package com.amuse.client.android è presente la classe AmuseClient, la quale è responsabile della connessione con la piattaforma AMUSE. Come prima cosa, deve essere invocato il metodo getinstance() per ricevere un'istanza AmuseClient inizializzata correttamente. Il metodo getinstance() vuole tre parametri: il nome dell'applicazione, il context dell'applicazione e una callback contente i metodi onsuccess() e onfailure(). Questa operazione viene eseguita in modo asincrono e quindi l'oggetto AmuseClient recuperato è reso disponibile nel metodo onsuccess() della callback. Successivamente, specichiamo le variabili di connessione come l'indirizzo dell'host, il numero della porta e il protocollo da utilizzare con il metodo setconnectionproperties() di AmuseClient. Inne con il metodo setloginmanager() della classe AmuseClient settiamo un oggetto LoginManager e invochiamo il metodo connect(), il quale richiede a sua volta una callback come parametro. Il metodo connect() si occupa di stabilire una connessione con l'host utilizzando le impostazioni precedentemente settate. A seconda del contenuto della risposta invocherà il metodo onsuccess() o il metodo onfailure() della callback passatogli come parametro. 17

19 3.2 Studio della piattaforma AMUSE Studio del problema L'oggetto LoginManager è responsabile della cattura delle credenziali: verica se le credenziali dell'utente sono già disponibili all'interno del client, in caso aermativo le invia al server AMUSE all'atto della connessione, in caso contrario le richiede all'utente. L'utente può scegliere di inserire le credenziali di un account AMUSE esistente oppure di creare un nuovo account. In ogni caso tali informazioni vengono fornite al client sotto forma di un oggetto LoginInfo, un oggetto che contiene username, password e un'informazione booleana, che indica se si tratta di un account nuovo o di un account esistente, chiamando il metodo logindone() della classe DefaultLoginManager contenuta nel modulo Android-client Gestione degli Amici L'interfaccia ContactsManagementFeature si occupa della gestione degli amici: grazie ad essa è possibile aggiungere, ricercare e rimuovere altri account AMUSE, i quali risulteranno nostri amici. Per prima cosa deve essere inizializzato un oggetto ContactsManagementFerature, chiamando il metodo getfeature() della classe AmuseClient. In seguito con il metodo initialize(), che necessita di un oggetto callback come parametro, sincronizziamo con il server la lista degli amici aggiunti in passato, in modo tale da poter subito visualizzare a schermo gli amici correnti. Aiutandoci con un'interfaccia graca, come per esempio un campo di inserimento testo e un bottone, possiamo richiedere all'utente lo username dell'amico da aggiungere. Inserito lo username da ricercare e premuto il bottone, la ricerca del suddetto viene eseguita con il metodo addcontanct(). Questo metodo come parametri richiede una stringa, che sarà lo username da ricercare, e una callback: se la ricerca ha un esito positivo l'amico viene aggiunto in automatico nella lista amici del utente e viene invocato il metodo onsuccess() della callback; in caso contrario viene segnalato l'errore che l'operazione non è giunta a compimento. Completata la fase di ricerca degli amici, è possibile ora invitarli per giocare un match insieme: con il metodo createtable(), contenuto nella classe GamesRoomFeature, passandogli come parametro una lista di stringa contenente lo username degli amici sarà possibile creare un tavolo con loro. 18

20 3.3 Possibili Soluzioni Studio del problema 3.3 Possibili Soluzioni Login L'architettura pensata per l'implementazione del Login tramite Facebook è suddivisa in vari passi. 1. L'utente nale esegue l'accesso premendo il bottone Accedi tramite Facebook visualizzato sul client Android; 2. I server Facebook, dopo aver autenticato l'account, rispondono generando un Access Token univoco associato alla sessione; 3. Il client, utilizzando l'access Token, richiede l'id dell'account Facebook ai server Facebook; 4. I server Facebook rispondono inviando le informazioni richieste; 5. Il client esegue l'accesso sulla piattaforma AMUSE con le informazioni ottenute da Facebook: username uguale all'id e password uguale all'access Token; 6. Il server AMUSE utilizza l'access Token per eseguire una richiesta ai server Facebook richiedendo l'id al quale l'access Token è legato; 7. Facebook risponde con i dati richiesti; 8. La piattaforma AMUSE confronta i dati ricevuti dal client con quelli appena ricevuti dal server Facebook: nel caso coincidessero l'utente è autenticato con la sua identità Facebook, in caso contrario il tentativo di Login viene riutato. 19

21 3.3 Possibili Soluzioni Studio del problema Figura 3.1: Architettura di Login Gestione degli Amici Per il problema Trova Amici sono state pensate varie architetture: 1. Soluzione interna; 2. Soluzione esterna; 3. Soluzione diretta. 1. Soluzione interna Questa soluzione prevede due azioni separate: Richiesta della lista amici 1. Il Client richiede la lista amici al server AMUSE; 2. Il Server AMUSE accede al database interno e ritorna la lista degli amici relativi all'account richiesto; 20

22 3.3 Possibili Soluzioni Studio del problema 3. Il Client visualizza la lista amici ricevuta; Aggiornamento della lista amici 1. Il server AMUSE richiede la lista amici di un utente direttamente ai server Facebook; 2. Il server Facebook invia la lista degli amici relativi all'account Facebook; 3. Il server AMUSE elabora gli amici mantenendo soltanto quelli aventi un account AMUSE associato e li salva all'interno del proprio database; Figura 3.2: Soluzione interna Questa architettura ha il vantaggio di portare un completo controllo sulla gestione degli amici, tuttavia gli svantaggi sono parecchi. Gli amici di Facebook di un utente possono cambiare anche più volte al giorno: sarebbe, quindi, necessario implementare una procedura di aggiornamento della lista presente sul database interno del server AMUSE, da eseguire più volte al giorno e per ogni utente registrato, un carico di lavoro notevole che potrebbe rallentare tutta la piattaforma. Inoltre questa modica è contraria all'obiettivo della trasparenza. 21

23 3.3 Possibili Soluzioni Studio del problema 2. Soluzione Esterna Questa architettura prevede cinque passi: 1. Richiesta della lista amici da parte del Client; 2. Il server AMUSE inoltra la richiesta al server Facebook; 3. Il server Facebook restituisce la lista completa degli amici relativi all'account Facebook; 4. Il server AMUSE elabora gli amici e li invia come risposta al client; 5. Il Client visualizza la lista amici ricevuta. Figura 3.3: Soluzione esterna In questa soluzione la lista all'interno del database viene aggiornata solo quando l'utente richiede gli amici di Facebook. Il vantaggio di quest'ultima architettura, rispetto alla soluzione interna è quello di avere un carico di lavoro solo su richiesta, quindi in generale minore. Lo svantaggio rispetto alla soluzione interna è la velocità con cui l'utente riceverà gli amici su terminale. 3. Soluzione Diretta Questa soluzione è composta da soli tre passi: 1. Richiesta ai server Facebook della lista amici da parte del Client; 2. Risposta da parte Facebook; 22

24 3.3 Possibili Soluzioni Studio del problema Figura 3.4: Soluzione diretta 3. Il Client visualizza la lista amici ricevuta. Nella soluzione diretta il server AMUSE non viene interrogato: il client Android si occupa di richiedere le informazioni degli amici direttamente ai Server Facebook. Il vantaggio rispetto alle altre soluzioni è la velocità con la quale si ottengono i dati, a discapito di un controllo minore su di essi. Un altro vantaggio importante è che con questa soluzione non c'è bisogno di alcuna modica a lato server AMUSE. 23

25 Capitolo 4 Implementazione e Funzionamento In questo capitolo sarà fatta un'analisi più approfondita sulla soluzione implementata facendone vedere anche il funzionamento con un'applicazione Android sviluppata per questo motivo. 4.1 Implementazione Implementazione login tramite social network Per implementare l'architettura scelta per il login tramite social network è stato necessario modicare i metodi e le classi che gestiscono l'autenticazione e la registrazione degli utenti nella piattaforma AMUSE a lato server. Come già accennato nei capitoli precedenti, la classe responsabile di questi servizi, a lato server, è la classe AuthenticationService, la quale contiene i metodi authenticate() e managenewaccount(): il primo serve per l'autenticazione mentre il secondo per la creazione di un nuovo account. Per permettere che l'architettura funzioni è stato necessario creare degli standard di comunicazione tra il client e il server: innanzitutto è stata introdotta la nozione dominio. Con dominio si indica la provenienza di un account: per esempio, se un account è nativo AMUSE il suo dominio sarà AMUSE, nel caso sia un account Facebook sarà FACEBOOK eccetera. Il dominio viene gestito come una stringa, e sarà posto dopo lo username separato dal carattere speciale $, per esempio <username>$<dominio>. Per implementare questa nuova caratteristica sono stati creati nella classi AmuseUtils due metodi: registerdomain() e getdomain(). RegisterDomain() 24

26 4.1 Implementazione Implementazione e Funzionamento è un metodo che deve essere invocato a lato client: passandogli come parametro una stringa contenente il nome del dominio, ne permette la gestione all'interno dell'applicazione, salvandola in una lista di stringhe. Questo consentirà di superare i controlli che si occupano della giusta formattazione dello username prima di essere inviato al server: se ad esempio è stato registrato il dominio FACEBOOK uno username del tipo <username>$facebook verrà considerato valido. private static List<String> domains = new ArrayList<String>(); public static void registerdomain(string domain) { domains.add(domain); Il metodo getdomain() è utilizzato per estrarre i domini: infatti questo metodo, dopo aver ottenuto una stringa contenente uno username come parametro, ritornerà il dominio associato. Può essere utilizzato sia a lato server che client. public static String getdomain(string username) { int k = username.indexof(domain_separator_string); if (k > 0) { return username.substring(k+1, username.length()); else { return AMUSE_DOMAIN; Un altro standard scelto per la gestione di account con dominio esterno ad AMUSE, è stato quello di inviare le informazioni relative all'account come se fosse un nuovo account, in modo tale, da gestirlo a lato server con il metodo managenewaccount(). Quest'ultimo, quindi prevederà una porzione di codice che sarà responsabile dell'autenticazione di account con dominio diverso da AMUSE: per prima cosa dovrà essere vericata l'esistenza dell'account all'interno del dominio di appartenenza. In caso aermativo verrà interrogato il database interno del sistema: se l'account non è presente, verrà registrato come nuovo account e autorizzato, nel caso in cui lo username sia già all'interno del database 25

27 4.1 Implementazione Implementazione e Funzionamento l'account verrà autorizzato con l'identità del dominio di provenienza. Ecco in seguito, la porzione di codice che gestisce questo meccanismo per il social network Facebook: private synchronized String managenewaccount(string accountstr) throws JADESecurityException { try { String[] ss = AMUSEUtils.extractCredentialsInfo(accountStr); String username = ss[0]; String password = ss[1]; String domain = AMUSEUtils.getDomain(username); // Check that the username does not contain the '_' special character used in agent names if (username.indexof(utils.agent_name_separator_string) > 0) { throw new JADESecurityException("Username cannot contain the '_' special character"); // Check that the username contain a domain if (domain.compareto("amuse") == 0){ // Check that the username does not exist yet. If not register the new account HibernateUtils.beginTransaction(); AccountDAO dao = new AccountDAOHibernate(HibernateUtils.getSession()); AccountPojo acnt = dao.getaccount(username); if (acnt == null) { acnt = new AccountPojo(); acnt.setusername(username); acnt.setpassword(password); dao.makepersistent(acnt); // Account creation OK mylogger.log(logger.info, "AuthenticationService - NEW Account successfully created. Username = "+username); return username; else { // Username already exist throw new JADESecurityException("Username "+username+" already in use"); 26

28 4.1 Implementazione Implementazione e Funzionamento else if (domain.compareto("facebook") == 0) { AccountDAOFacebook daofacebook = new AccountDAOFacebook(); //Check if the id coincide with the id associated at the access token if (daofacebook.verifyaccount(username, password)){ HibernateUtils.beginTransaction(); AccountDAO dao = new AccountDAOHibernate(HibernateUtils.getSession()); AccountPojo acnt = dao.getaccount(username); if (acnt == null) { acnt = new AccountPojo(); acnt.setusername(username); acnt.setpassword(password.substring(0, 30)); dao.makepersistent(acnt); // Account creation OK mylogger.log(logger.info, "AuthenticationService - NEW Account successfully created. Username = "+username); return username; else { return username; else { throw new JADESecurityException("Invalid facebook account"); else { throw new JADESecurityException("Username "+username+" does not contain a registered domain"); catch (JADESecurityException jse) { throw jse; catch (HibernateException he) { throw new JADESecurityException("Error creating account. "+he.getmessage()); catch (Exception e) { throw new JADESecurityException("Account "+accountstr+" does not 27

29 4.1 Implementazione Implementazione e Funzionamento have the expected form <username>:<password>"); finally { HibernateUtils.commitTransaction(); Come si può vedere, il metodo managenewaccount richiede come parametro una stringa: quest'ultima contiene le credenziali necessarie per la registrazione di un nuovo account. Nel caso in cui l'utente stesse tentando l'accesso tramite Facebook, la stringa prevista sarà formattata nel seguente modo: <IDFacebook>$FACEBOOK:<AccessToken>, dove l'id di Facebook, è una stringa numerica unica che rappresenta un account Facebook, mentre l'access Token è il Token di accesso rilasciato da Facebook. La stringa in ingresso viene spezzata attraverso il metodo, della classe AmuseUtils, extractcredentialsinfo(), il risultato viene poi assegnato alle variabile username; username quindi conterrà <IDFacebook>$FACEBOOK, mentre la password sarà <AccessToken>. Successivamente, con il metodo getdomain(), viene estratto il dominio all'interno dello username. A questo punto uno statement if controlla il contenuto della stringa domain, e di conseguenza sceglie la porzione di codice adatta al dominio. Nel caso di un account Facebook, per prima cosa viene creato un oggetto AccountDAOFacebook: con il suo metodo verifyaccount() è responsabile della verica delle credenziali Facebook. Questo metodo richiede come parametri due stringhe: la prima è l'id di Facebook, la seconda è l'access Token associato. public boolean verifyaccount(string username, String accesstoken) throws JADESecurityException { String id = username.replace("$facebook", ""); String urls = " +accesstoken; try { URL url = new URL(urlS); HttpURLConnection con = (HttpURLConnection) url.openconnection(); con.setrequestmethod("get"); int responsecode = con.getresponsecode(); if (responsecode!= 200) throw new JADESecurityException("Connection problem with 28

30 4.1 Implementazione Implementazione e Funzionamento Facebook Server"); else{ BufferedReader in = new BufferedReader( new InputStreamReader(con.getInputStream())); StringBuffer response = new StringBuffer(); String inputline; while ((inputline = in.readline())!= null) { response.append(inputline); in.close(); JSONObject object = new JSONObject(response.toString()); String idrequest = object.getstring("id"); if (id.compareto(idrequest) == 0) return true; catch (MalformedURLException e) { e.printstacktrace(); catch (ProtocolException e) { e.printstacktrace(); catch (IOException e) { e.printstacktrace(); catch (JSONException e) { e.printstacktrace(); return false; Nel codice si può notare che in questo caso non è stata usata nessuna Facebook SDK, questo perchè ancora non è stata rilasciata per il linguaggio di programmazione Java. Come prima cosa viene estratto l'id dell'account Facebook dalla stringa username, quindi si costruisce l'url necessario alla richiesta HTTP ai server Facebook per richiedere le informazioni necessarie alla convalida, ovvero l'id della'account Facebook associato all'access Token ricevuto. La risposta è formattata in stile JSON, è quindi necessario un parser apposito per l'interpretazione. Inne, estratto l'id dalla risposta, lo si confronta con l'id estratto dalla stringa username: se i due risultassero uguali ritornerà il valore booleano true, in caso contrario false. Successivamente, il controllo ritorna alla funzione managenewaccount, il quale inizia una transazione con il database: se esiste già un account con 29

31 4.1 Implementazione Implementazione e Funzionamento lo stesso username il login viene autorizzato, se non esiste viene creato un record all'interno della tabella User contenente lo username e una sottostringa dell'access Token. Quest'ultima modica non è rilevante, in quanto la password in un account Facebook non verrà mai richiesta. Oltre al metodo managenewaccount() è stato necessario apportare le stesse modiche al metodo authenticate(): il lato client di AMUSE salva all'interno del device le credenziali che hanno portato al successo una procedura di login. All'apertura dell'applicazione la classe LoginManager controlla la presenza o meno di queste credenziali e nel caso vengano trovate, esegue direttamente l'accesso senza richiederle all'utente: questa operazione esegue un login e non più una registrazione, per questo motivo a lato server viene chiamato il metodo authenticate(). public static String authenticate(string accountstr, Logger logger) throws JADESecurityException { try { String[] ss = AmuseUtils.extractCredentialsInfo(accountStr); String username = ss[0]; String password = ss[1]; String domain = AmuseUtils.getDomain(username); // Check that the username does not contain the '_' special character used in agent names if (username.indexof(amuseutils.agent_name_separator_string) > 0) { throw new JADESecurityException("Username cannot contain the '_' special character"); // Check that the username contain a domain if (domain.compareto("amuse") == 0){ // Check that the specified username and password corresponds to a valid account HibernateUtils.beginTransaction(); AccountDAO dao = new AccountDAOHibernate(HibernateUtils.getSession()); AccountPojo acnt = dao.getaccount(username); if (acnt!= null) { if (acnt.getpassword().equals(password)) { return username; else { 30

32 4.1 Implementazione Implementazione e Funzionamento throw new JADESecurityException("Incorrect password"); else { throw new JADESecurityException("Unknown username "+username); else if (domain.compareto("facebook") == 0) { AccountDAOFacebook daofacebook = new AccountDAOFacebook(); //Check if the id coincide with the id associated at the access token if (daofacebook.verifyaccount(username, password)){ return username; else { throw new JADESecurityException("Invalid facebook account"); else { throw new JADESecurityException("Username "+username+" does not contain a registered domain"); catch (JADESecurityException jse) { throw jse; catch (HibernateException he) { logger.log(logger.warning, "Error checking account "+accountstr, he); throw new JADESecurityException("Error checking account. "+he.getmessage()); catch (Exception e) { throw new JADESecurityException("Account "+accountstr+" does not have the expected form <username>:<password>"); finally { HibernateUtils.commitTransaction(); 31

33 4.1 Implementazione Implementazione e Funzionamento Il comportamento è identico al metodo managenewaccount(), manca soltanto il controllo e la scrittura sul database. A lato client le classi principali che gestiscono la procedura di autenticazione e di registrazione dell'attuale versione di AMUSE, sono le classi AmuseClient e LoginManager: la prima si occupa della connessione con il server, mentre la seconda è responsabile della cattura delle credenziali inserite dall'utente. É stato dunque necessario implementare un meccanismo in grado di ottenere le giuste informazioni da Facebook e di inviare quest'ultime al server AMUSE. Di seguito, una porzione di codice presa dall'activity principale dell'applicazione. public void oncreate(bundle savedinstancestate) { super.oncreate(savedinstancestate); setcontentview(r.layout.main_activity_layout); AvatarManager.initialize(R.drawable.ic_launcher, null, -1, -1); AmuseUtils.registerDomain("FACEBOOK"); loginmanager = new DefaultLoginManager(this); loginmanager.setvisibleloginfields(new int[]{r.id.loginform); // Connect to the Amuse server ((MyApp) getapplication()).connect(loginmanager, new Callback<Void>() {... Come si può vedere, una delle prime chiamate è al metodo registerdomain() della classe AmuseUtils. Questo metodo è essenziale per il corretto funzionamento dell'architettura in quanto permette di superare i controlli eseguiti nel metodo createcredentials() della classe AmuseUtils. Infatti, createcredentials(), dati in input uno username e una password, controlla la presenza di eventuali caratteri speciali, tra i quali anche il $, e in caso aermativo, lancia un'eccezione e termina la procedura di login; in caso contrario ritorna una stringa formattata secondo gli standard AMUSE pronta per essere inviata al server. É stata, dunque, necessaria una modica a quest'ultimo metodo. public static String createcredentials(string username, String password) throws IllegalArgumentException { if (username == null username.length() == 0) { 32

34 4.1 Implementazione Implementazione e Funzionamento throw new IllegalArgumentException("Username non specificato"); if (username.contains(":") username.contains(agent_name_separator_string) username.contains(" ") username.contains("#")) { throw new IllegalArgumentException("Username invalido: lo username puo' contenere solo caratteri alfanumerici"); // If the username contains the domain-separator check that the substring following it is one of the registered domains int k = username.indexof(domain_separator_string); if (k > 0) { String d = username.substring(k+1); if (!domains.contains(d)) { throw new IllegalArgumentException("Username invalido: lo username puo' contenere solo caratteri alfanumerici"); // Password is not checked or obfuscated in case the user belongs to a registered domain return username+":"+password; else { if (password == null password.length() == 0) { throw new IllegalArgumentException("Password non specificata"); String encodedpassword = Obfuscator.obfuscate(password); return username+":"+encodedpassword; Al controllo sulla presenza dei caratteri speciali è stata aggiunta una clausula nel caso venga trovato all'interno della stringa username il carattere $: se la sottostringa a destra del carattere speciale è una stringa uguale a un dominio registrato con il metodo registerdomain() il metodo ritorna una stringa formattata nello standard AMUSE contenente le credenziali, in caso contrario lancia un'eccezione. Da notare che la password, ovvero l'access Token, in questo caso non viene ouscato, questo perché il server ha bisogno che l'access Token sia in chiaro per poter autenticare l'accesso. All'interno della classe principale dell'applicazione, sarà presente il metodo facebooklogin(): 33

35 4.1 Implementazione Implementazione e Funzionamento public void facebooklogin(string username, String password) { loginmanager.logindone(new LoginInfo(username, password, true)); Questo metodo, sarà invocato una volta ricevute le credenziali dai server Facebook, e permetterà l'accesso al sever AMUSE con il metodo logindone(). Per ottenere le informazioni relative all'account Facebook, è necessario implementare il Login tramite Facebook usando la Facebook SDK. Quest'ultima mette a disposizione una serie di classi e di metodi che aiutano lo sviluppatore a sfruttare i diversi servizi Facebook. Prima di poterla utilizzare, l'sdk deve essere inizializzata all'interno dell'applicazione: questo passo è possibile farlo con il metodo sdkinitialize(): private CallbackManager callbackmanager; public void oncreate(){ super.oncreate() FacebookSdk.sdkInitialize(getActivity()); callbackmanager = CallbackManager.Factory.create();... Per implementare il Login tramite Facebook può essere utilizzata la classe LoginButton, contenuto nel package com.facebook.login.widget. LoginButton è una view di Android che estende la classe Button e che disegna a schermo il classico bottone di Login di Facebook. Per aggiungere la view LoginButton a un'applicazione Android, è necessario scrivere all'interno del le XML dell'interfaccia graca dell'activity il tag: <com.facebook.login.widget.loginbutton android:id="@+id/facebook_login_button" android:layout_width="wrap_content" android:layout_height="wrap_content" /> Una volta stabilita la posizione all'interno dell'interfaccia graca, è possibile settare le Permissions e la callback da eseguire non appena il Login tramite Facebook è stato eseguito. Con i metodi setreadpermissions() e setpublishpermissions() è possibile aggiungere delle Permission al Login, in 34

36 4.1 Implementazione Implementazione e Funzionamento modo tale da poter accedere alle informazioni necessarie contenute sul prolo Facebook. Per registrare la callback si utilizza il metodo registercallback(), il quale richiede in input un oggetto CallbackManager() e una FacebookCallback. La classe CallbackManager si occupa di gestire e registrare le callback all'interno dell'sdk, mentre FacebookCallback è un oggetto callback che contiene al suo interno tre metodi: onsuccess(), invocato nel caso il login su Facebook sia andato a buon ne, oncancel(), invocato nel caso l'utente riuti tutte le Permissions richieste, e onerror(), invocato quando succede qualcosa di inaspettato durante la procedura di login. Di seguito un esempio di come è stato implementato questo meccanismo: loginbutton = (LoginButton) view.findviewbyid(r.id.facebook_login_button); loginbutton.setreadpermissions("user_friends"); // Callback registration loginbutton.registercallback(callbackmanager, new FacebookCallback<LoginResult>() public void onsuccess(loginresult loginresult) { GraphRequest request = GraphRequest.newMeRequest(loginResult.getAccessToken(), new GraphRequest.GraphJSONObjectCallback() public void oncompleted(jsonobject object, GraphResponse response) { if (object!= null) { try { String id = object.getstring("id")+"$facebook"; facebooklogin(id, AccessToken.getCurrentAccessToken().getToken()); catch (JSONException e) { e.printstacktrace(); ); Bundle parameters = new Bundle(); parameters.putstring("fields", "id"); request.setparameters(parameters); 35

37 4.1 Implementazione Implementazione e Funzionamento public void oncancel() { // App public void onerror(facebookexception exception) { //App code ); Nel caso il login abbia avuto successo, l'oggetto LoginResult contiene al suo interno il nuovo Access Token generato. Nella chiamata onsuccess della FacebookCallback, viene eettuta una richiesta tramite la classe GraphRequest. Questa classe, è messa a disposizione dalla Facebook SDK per Android e permette di interagire con le Graph API. In particolare, con il metodo newmerequest() è possibile richiedere le informazioni relative all'account associato all'access Token appena generato. La costruzione della richiesta è semplice: come parametri di input richiede un Access Token e una callback GraphJSONObjectCallback, nella quale sarà necessario fare l'override del metodo oncomplete(). Il metodo callback oncomplete() riceve come parametri due oggetti: un JSONobject, che contiene la risposta del server formattata in stile JSON, e un GraphResponse che contiene, oltre alla risposta, altre informazioni relative ad essa. Settata la callback, è possibile richiedere speciche informazioni alla richiesta aggiungendo parametri con il metodo setparameters() della class GrapRequest. Per eseguire la richiesta, è necessario invocare il metodo executeasync(), il quale permette l'esecuzione della richiesta su un thread secondario in modo tale da non bloccare l'esecuzione dell'applicazione. Per completare l'implementazione, è indispensabile eettuare l'override del metodo onactivityresult() dell'activity e richiamare al suo interno il metodo onactivityresult() dell'oggetto public void onactivityresult(int requestcode, int resultcode, Intent data) { super.onactivityresult(requestcode, resultcode, data); callbackmanager.onactivityresult(requestcode, resultcode, data); 36

38 4.1 Implementazione Implementazione e Funzionamento Questo metodo permetterà all'applicazione di raccogliere i risultati del Login Implementazione di Trova Amici Per implementare la funzione Trova Amici, è stato scelta la soluzione diretta descritta nel capitolo precedente, per questo motivo non sono state necessarie modiche al server AMUSE: per la ricerca degli amici vengono contattati direttamente i server di Facebook. Grazie alle Graph API di Facebook è possibile ricevere gli amici dell'utente che hanno eseguito il login tramite la Facebook App creata. La richiesta HTTP da eseguire è la seguente: GET /v2.3/me/friends HTTP/1.1 Host: graph.facebook.com Per l'esecuzione di questa richiesta, l'utente al momento del login deve accettare la Permission user_friends, che da accesso alla lista amici dell'utente. La Facebook SDK per Android permette di eseguire la richiesta tramite il metodo newmyfriendsrequest() della classe GraphRequest, già descritta precedentemente. Un esempio di implementazione è il seguente: GraphRequest.newMyFriendsRequest(AccessToken.getCurrentAccessToken(), new GraphJSONArrayCallback() public void oncompleted(jsonarray objects, GraphResponse response) { for (int i=0; i<objects.length(); i++){ try { JSONObject friend = objects.getjsonobject(i); String name = friend.getstring("name"); String id = friend.getstring("id"); Profile p = new Profile(id, null, null, null, name, null); facebookfriendslist.add(p); catch (JSONException e) { e.printstacktrace(); friendsadapter.notifydatasetchanged(); 37

39 4.1 Implementazione Implementazione e Funzionamento ).executeasync(); Il metodo newmyfriendsrequest() richiede come input due parametri: un Access Token e una callback di tipo GraphJSONArrayCallback contenente un metodo oncomplete(), il quale verrà invocato una volta ricevuto il risultato. Il risultato è contenuto in un oggetto JSONArray che ha al suo interno l'id Facebook e il nome degli amici. In questo caso, per ogni amico viene creato un oggetto Prole. La classe Prole, messa a disposizione dalla Facebook SDK per Android, è un oggetto in grado di rappresentare un prolo Facebook. In seguito l'oggetto Prole è aggiunto alla lista degli amici di Facebook, la quale è usata da contenitore nell'adapter friendsadapter. Questo meccanismo ha lo scopo di disegnare a schermo la lista degli amici, ragurata da una ListView. Per selezionare uno o più amici con cui giocare basterà toccare lo schermo su uno o più di essi: il tocco sarà gestito dal metodo setonitemclicklistener() della classe ListView, il quale aggiungerà o toglierà, a una lista rappresentante gli amici invitati, l'amico selezionato. facebookfriendslistview.setonitemclicklistener(new OnItemClickListener() public void onitemclick(adapterview<?> parent, View view, int position, long id) { ImageView friendfacebookselect = (ImageView) view.findviewbyid(r.id.facebook_friend_selected); String usernamefriend = facebookfriendslist.get(position).getid()+"$facebook"; if (friendfacebookselect.getvisibility() == View.VISIBLE) { friendfacebookselect.setvisibility(view.invisible); invitedfriends.remove(usernamefriend); else { friendfacebookselect.setvisibility(view.visible); invitedfriends.add(usernamefriend); ); Ad ogni ID Facebook della lista viene aggiunta la stringa $FACEBOOK come postsso, questo permette al server di riconoscere gli account Facebook, 38

40 4.2 Funzionamento Implementazione e Funzionamento i quali sono salvati, all'interno del database del server AMUSE, nella forma <IDFacebook>$FACEBOOK dalla procedura di registrazione di un nuovo account. Una volta scelti gli amici con cui giocare, basterà chiamare il metodo createtable()della classe GamesRoomFeature, passandogli la lista degli amici selezionati come parametro, il quale richiederà al server di creare un tavolo insieme suddetti. 4.2 Funzionamento Per mostrare il funzionamento del lavoro di tesi, queste feature sono state implementate in un'applicazione AMUSE-based da me creata: Wadoku. Wadoku è un gioco multi-player online il cui scopo è quello di far competere i giocatori per completare, inserendo più numeri possibile, una griglia Sudoku. Si gioca tutti contro tutti: per ogni numero inserito correttamente saranno assegnati tre punti e comparirà anche nelle tabelle degli altri giocatori; per ogni numero errato varrà tolto un punto. Il gioco prevede al massimo quattro giocatori e il giocatore con il punteggio più alto vince il match. La schermata di accesso dell'applicazione prevede due campi testo con i relativi bottoni di Login o Register insieme al bottone di colore blu con la scritta Login with Facebook. Figura 4.1: Schermata di Login 39

41 4.2 Funzionamento Implementazione e Funzionamento Premendo sul tasto Login with Facebook verrà aperta una dialog per l'accettazione delle Permission, in questa applicazione saranno richieste le Permission user_friends e public_prole. Figura 4.2: Schermata richiesta Permission Accettate le Permission, avremo eseguito l'accesso all'interno di AMUSE con la nostra identità Facebook. La schermata principale dell'applicazione prevede quattro bottoni. Premendo su Start a new Match l'applicazione si metterà in ricerca di altri 40