universitÀ degli studi di parma...2015/04/28 · 1.4 amuse api la piattaforma amuse è così...

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: Candidato:

Prof. Federico Bergenti Alessandro Bertoletti

Anno Accademico 2013/2014

Indice

1 AMUSE 4

1.1 Introduzione . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41.1.1 JADE . . . . . . . . . . . . . . . . . . . . . . . . . . . 41.1.2 WADE . . . . . . . . . . . . . . . . . . . . . . . . . . . 5

1.2 Architettura . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51.3 Funzionalità . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61.4 AMUSE API . . . . . . . . . . . . . . . . . . . . . . . . . . . 8

1.4.1 Client API . . . . . . . . . . . . . . . . . . . . . . . . . 81.4.2 Server API . . . . . . . . . . . . . . . . . . . . . . . . 9

2 Social Network 10

2.1 Introduzione . . . . . . . . . . . . . . . . . . . . . . . . . . . . 102.2 Facebook . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11

2.2.1 Graph API . . . . . . . . . . . . . . . . . . . . . . . . 112.2.2 Facebook App . . . . . . . . . . . . . . . . . . . . . . . 132.2.3 Access Token . . . . . . . . . . . . . . . . . . . . . . . 132.2.4 Permission . . . . . . . . . . . . . . . . . . . . . . . . . 142.2.5 Facebook SDK per Android . . . . . . . . . . . . . . . 14

3 Studio del problema 16

3.1 Introduzione . . . . . . . . . . . . . . . . . . . . . . . . . . . . 163.2 Studio della piattaforma AMUSE . . . . . . . . . . . . . . . . 16

3.2.1 Autenticazione e Registrazione . . . . . . . . . . . . . . 163.2.2 Gestione degli Amici . . . . . . . . . . . . . . . . . . . 18

3.3 Possibili Soluzioni . . . . . . . . . . . . . . . . . . . . . . . . . 193.3.1 Login . . . . . . . . . . . . . . . . . . . . . . . . . . . . 193.3.2 Gestione degli Amici . . . . . . . . . . . . . . . . . . . 20

4 Implementazione e Funzionamento 24

4.1 Implementazione . . . . . . . . . . . . . . . . . . . . . . . . . 244.1.1 Implementazione login tramite social network . . . . . 24

1

INDICE INDICE

4.1.2 Implementazione di �Trova Amici� . . . . . . . . . . . . 374.2 Funzionamento . . . . . . . . . . . . . . . . . . . . . . . . . . 39

Riferimenti bibliogra�ci 44

A Login with Social Network in AMUSE 45

A.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45A.1.1 Prerequisites . . . . . . . . . . . . . . . . . . . . . . . . 45

A.2 Necessary Material . . . . . . . . . . . . . . . . . . . . . . . . 45A.2.1 Create a Facebook App . . . . . . . . . . . . . . . . . . 45A.2.2 Add Facebook SDK to Your Project . . . . . . . . . . 46

A.3 Add Facebook Features . . . . . . . . . . . . . . . . . . . . . . 46A.3.1 Add Login with Facebook . . . . . . . . . . . . . . . . 48A.3.2 Play with Facebook Friends . . . . . . . . . . . . . . . 53

2

Introduzione

L'obiettivo di questa tesi è indagare sulla possibilità di integrazione dei servizidi Social Network e AMUSE.

L'idea di base è quella di a�ancare ai servizi già esistenti di AMUSE, qualilogin e ricerca di amici, quelli di un social network permettendo così all'utente�nale un utilizzo più semplice e immediato dell'applicazione AMUSE-basedsviluppata.

Il lavoro è stato svolto nel modo più trasparente possibile, studiando afondo la piattaforma AMUSE e cercando le varie soluzioni possibili: una voltatrovata la migliore si è passati alla fase di sviluppo, cercando di modi�careil meno possibile le funzionalità già implementate in AMUSE.

Il social network scelto per testare la piattaforma è Facebook, questoperché, ad oggi, è il social network più utilizzato in Europa e in Italia e o�reuna 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 ilfunzionamento.Il capitolo 2 introduce i servizi di Facebook integrati con AMUSE.Il capitolo 3 fa una panoramica sui social network, per poi spiegare Facebooke i suoi servizi.Il capitolo 4 spiega le modi�che apportate al sistema AMUSE per integrarei servizi di Social Network.Nel capitolo 5 vi è spazio per conclusioni e sviluppi futuri.In�ne, nell' appendice è possibile trovare un tutorial, scritto in lingua inglese,il quale spiega come inserire all'interno della propria applicazione le featureintrodotte.

3

Capitolo 1

AMUSE

1.1 Introduzione

AMUSE (Agent-based Multi-User Social Environment) è una piattaformasoftware che facilita lo sviluppo di applicazioni social distribuite, le qualiportano gli utenti a cooperare o a competere per la realizzazione di obiettivicomuni o privati. Per questo motivo, lo scopo principale di AMUSE è larealizzazione di giochi multiplayer on-line.

La piattaforma AMUSE è un sistema JADE-based e, per la gestionedei componenti e delle comunicazioni, adopera le soluzioni già implementateWADE e JADE.

1.1.1 JADE

JADE (Java Agent DEvelopment Framework) è un Framwork implementatocompletamente in Java. Il suo scopo è quello di sempli�care l'implementa-zione di sistemi multi-agente attraverso un middle-ware che compila il codicesecondo le speci�che FIPA e che aiuta le fasi di debug e di sviluppo graziea un set di tools gra�ci. Un sistema JADE può essere distribuito tra variemacchine (le quali non hanno bisogno di avere lo stesso sistema operativo) ela loro con�gurazione può essere controllata attraverso una GUI remota.

Insieme all'astrazione degli agenti, JADE fornisce una semplice ma po-tente task execution, un compositore di modelli, comunicazione peer-to-peertra agenti basata sullo scambio di messaggi asincroni, un servizio di paginegialle e molte altre caratteristiche avanzate che facilitano lo sviluppo di unsistema distribuito.

JADE è un software gratuito ed è distribuito da Telecom Italia, detentoredel copyright, in open source secondo i termini e le condizioni della licenzaLGPL.

4

1.2 Architettura AMUSE

1.1.2 WADE

WADE (Work�ows and Agents Development Environment) è una piattafor-ma software basata su JADE, la quale fornisce supporto per l'esecuzione ditask de�niti secondo la metafora del work�ow. La componente chiave diWADE è la classe Work�owEngineAgent che estende la classe Agent dellalibreria JADE incorporando un piccolo e leggero motore di work�ow.

Oltre ai normali behaviours di JADE, un Work�owEngineAgent è capa-ce di eseguire work�ow in accordo a speci�ci formalismi di WADE. Questiformalismi sono scritti in linguaggio JAVA.

Uno dei principali vantaggi dell'approccio a work�ow è la possibilità dirappresentare i processi in forma gra�ca, WADE o�re un servizio di svilup-po, 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à o�erte da WADE.

WADE è un software gratuito ed è distribuito da Telecom Italia, detentoredel copyright, in open source secondo i termini e le condizioni della licenzaLGPL.

1.2 Architettura

La seguente �gura mostra una panoramica dell'architettura di AMUSE: tuttele applicazioni AMUSE-based comprendono la logica necessaria per il latoclient insieme a un'eventuale interfaccia gra�ca. Le applicazioni client fannouso della libreria AMUSE client library per interagire con altri client e conil server.

Nella versione corrente (AMUSE 1.0 rilasciata il 10/12/2014) sono sup-portati solo le applicazione Android-based.

Nella maggior parte dei casi le applicazioni AMUSE-based hanno biso-gno di una speci�ca logica che deve essere eseguita nel lato server. Queste

5

1.3 Funzionalità AMUSE

applicazioni, nel terminologia di AMUSE, sono chiamate applicazioni server-based. Per l'esecuzioni di queste logiche la piattaforma AMUSE fornisce unambiente PaaS (Platform as a Service): le applicazioni non sono a conoscen-za dei dettagli relativi all'hardware, sistemi operativi e altro riguardanti ilserver. D'altra parte il sistema è distribuito su un ambiente cloud e AMUSEha il compito di assicurarsi che ogni lavoro abbia le risorse necessarie per ilsuo corretto funzionamento.

AMUSE mette a disposizione la AMUSE Application Administration In-terface, con la quale è possibile registrare, installare, con�gurare e avviare lespeci�che logiche server-side delle varie applicazioni sviluppate. Una voltalanciate, 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 avviarequesto tipo di applicazioni, basta una registrazione sulla AMUSE ApplicationAdministration Interface.

1.3 Funzionalità

Le funzionalità di AMUSE si dividono in Core e in Gaming. Le Core, alcontrario delle Gaming, non sono solo orientate allo sviluppo di giochi epossono essere usate in generiche applicazioni multi utente. Le funzioni Corele 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 o�re la possibilità di registrare,installare, con�gurare e attivare le applicazioni sviluppate, le quali so-no disponibili presso la AMUSE Application Administration Interfaceaccessibile via Web.

• Gestione Utenti: questa funzione si occupa della registrazione e dellaautenticazione degli utenti e supporta in parte minimale la gestione deipro�li utenti. Le API client che si occupano di questo sono contenutenella classe com.amuse.client.features.core.UserManagementFeature.

• Sincronizzazione del Clock: questa funzione si incarica della sincroniz-zazione degli eventi, in modo tale che la stessa applicazione su termi-nali di�erenti esegua contemporaneamente un'azione (questa funzioneha una particolare importanza per i giochi real-time, dove un matchinizia, gestisce eventi e �nisce allo stesso tempo per tutti i giocatori).

6

1.3 Funzionalità AMUSE

• Scambio di messaggi di testo: questa funzione o�re la possibilità dimandare e ricevere messaggi di testo da o verso altri utenti con la stessaapplicazione. Questo servizio è accessibile attraverso le API contenu-te nella classe com.amuse.client.features.core.TextMessageFeature. Nelcaso in cui il ricevente non sia connesso nel momento in cui il messaggioè stato inviato, il messaggio sarà automaticamente salvato nel lato ser-ver dell'applicazione e sarà consegnato non appena il ricevente si saràconnesso.

• Gestione delle pipe Peer-to-peer: questa funzione o�re la possibilità distabilire una connessione diretta tra i client, i quali potranno in seguitoscambiarsi speci�ci oggetti. Le API sono accessibili tramite l'interfacciacom.amuse.client.features.core.PipeManagementFeature.

• Coordinazione match Peer-to-peer: questa funzione o�re la possibili-tà di organizzare match one-to-one in modo persistente: se un utentesi disconnette durante il match, potrà riconnettersi in un momentosuccessivo. La partecipazione al match utilizza la metafora dell'invi-to: l'organizzatore manda una richiesta all'avversario in modo esplicitospeci�cando il suo nome o chiede alla piattaforma AMUSE di trovar-gli un avversario casuale. Una volta accettato l'invito da parte del-l'avversario, il match ha inizio. Le applicazioni basate su questo ap-proccio non richiedono nessuna logica da parte del server, e possonoessere sviluppate come applicazioni client-only. Le API contenute nel-la classe com.amuse.client.features.gaming.MatchCoordinationFeatureo�rono questo servizio.

• Coordinamento centralizzato del match: questo servizio si occupa del-l'organizzazione di match che comprendono due o più giocatori, i qualipossono entrare o uscire dalla partita, mentre è ancora in svolgimento.La partecipazione al match utilizza la metafora dei tavoli: l'organizza-tore del match crea un tavolo vuoto, dove gli avversari possono sedersiper 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 tavo-lo. Le applicazioni basate su questo approccio richiedono una speci�calogica che governi il lato server, infatti queste applicazioni vengonochiamate server-based. La logica deve essere implementata estendendola classe com.amuse.agents.gra.GamesRoomAgent la quale contiene imeccanismi base per la gestione dei tavoli all'interno delle stanze e perla coordinazione dei match giocati sui vari tavoli.

7

1.4 AMUSE API AMUSE

1.4 AMUSE API

La piattaforma AMUSE è così composta:

• una piattaforma sulla quale viene gestita la logica di AMUSE, insiemea quella speci�ca per ogni gioco che ne necessita.

• un set di client API per lo sviluppo di applicazioni sul sistema operativoAndroid per implementare tutti gli aspetti di gioco prima menzionati

• un set di server API che servono, quando necessario, a gestire la logicadi gioco tra i vari client connessi.

1.4.1 Client API

Le client API di AMUSE sono contenute nel package com.amuse.client eorganizzate nei suoi vari sub-package. La classe AmuseClient, facente partedel package com.amuse.client.android, è il punto di ingresso per accedere atutte le funzionalità client AMUSE, in particolare il suo metodo connect(),ci permette la connessione e l'autenticazione nella piattaforma AMUSE. Unavolta autenticato l'account con successo, il metodo getFeature() ci permettedi recuperare le classi che implementano le feature contenute nei packagescritti sopra.

Tutte le API di AMUSE che richiedono l'iterazione con la piattaformaAMUSE lavorano in modo asincrono: infatti come argomento richiedonosempre una Callback la quale contiene il metodo onSuccess(), che viene in-vocato quando l'operazione è stata completata con successo, e il metodoonFailure(), invocato nel caso contrario.

La logica di gioco in una applicazione AMUSE si descrive implementandol'interfaccia Table.Listener, la quale mette a disposizione i seguenti metodi:

• handleMatchStarting(), invocato quando si è raggiunto il numero mi-nimo di giocatori in un tavolo e il match può iniziare;

• handlePlayerJoined(), invocato quando un giocatore entra nel tavolo incui il giocatore corrente risiede;

• handlePlayerLeft(), invocato quando un giocatore lascia il tavolo in cuiil giocatore corrente risiede, questo può succedere sia prima che dopol'inizio del match;

• handlePlayerMoved(), invocato quando un altro giocatore compie unamossa del gioco;

8

1.4 AMUSE API AMUSE

• handleMatchEvent(), invocato quando occorre un evento speci�co nondirettamente correlato alla mossa di un giocatore;

• handleMatchFinished(), invocato quando il match �nisce.

Per noti�care al lato server dell'applicazione che il giocatore corrente haeseguito una mossa, bisogna chiamare il metodo move() della classe Tablecontenuta nel package com.AMUSE.client.features.gaming.

1.4.2 Server API

La logica a lato server di un'applicazione AMUSE-based è necessaria soltantoquando l'applicazione ha implementato la classe GamesRoomFeature. Essaviene descritta implementando uno o più istanze di un agente estendendola classe GamesRoomAgent. Il nome dell'agente corrisponde al nome dellastanza.

Ogni GamesRoomAgent contiene al suo interno un numero di oggettiTableManager, ognuno dei quali, gestisce un tavolo all'interno della stanza.Inoltre, la classe GamesRoomAgent, mette a disposizione una serie di metodiche verranno invocati solo in occasione di eventi rilevanti per la sessione digioco, i quali devono essere ride�niti per implementare la logica di gioco.

I metodi più rilevanti da ride�nire sono:

• handleTableCreate(), invocato quando il server riceve l'ordine di creareun tavolo;

• handleMatchStartup(), invocato appena il numero minimo di giocatoriper 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 meto-do createTable() della classe GamesRoomAgent o come conseguenza di unarichiesta da parte di un utente, così da poter creare un tavolo privato al qua-le solo gli invitati possano accedere; in tutti e due i casi viene chiamato ilmetodo handleTableCreated().

Durante la fase di creazione di un tavolo è possibile speci�care un mini-mo numero di giocatori sopra il quale il match inizierà e un numero massimodi giocatori partecipanti alla partita. Quando il match è giunto al termi-ne, si utilizza il metodo setMatchFinished() della classe TableManager pernoti�care la terminazione del match al GamesRoomAgent.

9

Capitolo 2

Social Network

2.1 Introduzione

Con l'espressione social network si identi�ca un servizio informatico on lineche permette la realizzazione di reti sociali virtuali. Si tratta di siti Web checonsentono agli utenti di condividere contenuti testuali, immagini, video eaudio e di interagire tra loro.

Secondo la de�nizione, data dagli studiosi Boyd-Ellison [3], si possonode�nire siti di social network i servizi web che permettono:

• la creazione di un pro�lo pubblico o privato all'interno di un sistemavincolato,

• 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 unpro�lo personale protetto da password partendo da informazioni come il pro-prio nome, cognome, indirizzo email �no ad arrivare agli interessi e alle passio-ne che abbiamo. Inoltre si ha la possibilità di e�ettuare ricerche nel databasedella struttura informatica per localizzare altri utenti e organizzarli in gruppie liste di contatti.

Un importante sviluppo delle reti sociali è rappresentato dalla possibilitàdi creare da parte di chiunque ne abbia le competenze (sviluppatori conlinguaggi solitamente proprietari) applicazioni orientate alla comunità degliiscritti. Tale famiglia di applicazioni, bene�ciano della rete di contatti edelle informazioni individuali degli iscritti (es. Facebook, Google+, Twitter)per facilitare operazioni quali registrazioni e accessi a servizi esterni al socialnetwork.

10

2.2 Facebook Social Network

2.2 Facebook

Facebook è un servizio di rete sociale lanciato nel febbraio del 2004, posse-duto e gestito dalla corporazione Facebook Inc., basato su una piattaformasoftware scritta in vari linguaggi di programmazione. Fondato a Harvard ne-gli Stati Uniti da Mark Zuckerberg e dai suoi compagni di università EduardoSaverin, Dustin Moskovitz e Chris Hughes, era originariamente stato proget-tato esclusivamente per gli studenti dell'Università di Harvard, ma fu prestoaperto anche agli studenti di altre scuole della zona di Boston, della IvyLeague e della Stanford University.

Successivamente fu aperto anche agli studenti delle scuole superiori e poia chiunque dichiarasse di avere più di 13 anni di età. Da allora Facebookraggiunse un enorme successo: secondo Alexa dal giugno 2013 è diventato ilsito Web più visitato al mondo, superando Google; ha cambiato profonda-mente 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 mi-liardo di utenti attivi che e�ettuano l'accesso almeno una volta al mese,classi�candosi come primo servizio di rete sociale per numero di utenti attivi.

Gli utenti possono accedere al sito previa una registrazione gratuita, du-rante la quale vengono richiesti dati personali come nome, cognome, datadi nascita e indirizzo email. Completata la registrazione, gli utenti possonocreare un pro�lo personale, includere altri utenti nella propria rete socia-le, aggiungendoli come amici, scambiare messaggi tramite una chat inte-grata oppure condividere uno stato, una foto o un qualsivoglia contenutomultimediale.

2.2.1 Graph API

Le Graph API sono API pensate dagli sviluppatori Facebook per scambiareinformazioni con la piattaforma di Facebook. Sono delle richieste HTTP dibasso livello e possono essere usate per richiedere dati relativi a un utente,postare uno stato sulla propria pagina di Facebook, caricare foto e tutti glialtri compiti di cui abbiamo bisogno.

Le Graph API essendo HTTP based possono essere usate insieme a qual-siasi linguaggio di programmazione. Facebook ha adottato la metafora �socialgraph� per la rappresentazione delle informazioni sulla sua piattaforma, daqui deriva il nome di queste API.

Il grafo è composto da:

• nodi: che rappresentano informazioni come per esempio un utente, unafoto o un commento;

11


• archi: che rappresentano le connessioni tra i nodi, come per esempioun commento a una foto;

• campi: sono i campi che i nodi possono avere, come la data di com-pleanno di un utente.

Ogni nodo del grafo ha un ID unico, il quale permette di raggiungerne ilcontenuto. Questo è un esempio per richiedere un nodo:

GET graph.facebook.com

/{id-nodo}

Ad esempio, se volessimo ottenere le informazioni del nostro pro�lo per-sonale basterà richiedere

GET graph.facebook.com

/v2.3/me

La risposta da parte di Facebook, ci comunica le informazioni base delpro�lo utente, quali ID, nome cognome, il link al pro�lo e altre informazioni,il tutto formattato in stile JSON.

{

"id": "10203943788139143",

"birthday": "10/08/1991",

"first_name": "Alessandro",

"gender": "male",

"last_name": "Bertoletti",

"link": "https://www.facebook.com/10203943788139143/",

"locale": "it_IT",

"name": "Alessandro Bertoletti",

"timezone": 2,

"updated_time": "2013-10-29T22:34:34+0000",

"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 AccessToken con cui autenticarci. Inoltre alcuni dati sono disponibili solo dopo ilconsenso delle Permission da parte dell'utente.

12


2.2.2 Facebook App

Le Facebook App sono applicazioni Web che permettono l'interazione tra lanostra applicazione e i server di Facebook.

Per creare una Facebook App, è necessario per prima cosa collegarsi alsito web https://developers.facebook.com/, cliccare su �Add a new app�e scegliere la piattaforma con la quale andremo a interrogare i server diFacebook: possiamo scegliere tra una vasta tipologia di piattaforme tra lequali le più famose sono iOS, Android, sito Web e Facebook Canvas. Pos-sono convivere più piattaforme alla volta, ognuna di esse sarà identi�cabilesingolarmente tramite un ID.

L'applicazione sarà reperibile grazie a due codici che identi�cheranno lacoppia Facebook App e piattaforma scelta: l'App ID e l'App Secret. Ilprimo è un codice numerico che rappresenta la nostra applicazione, il secondoè un codice segreto che non dovrà mai essere pubblicato e ha la funzionedi autenticare le richieste fatte dall'applicazione verso i server di Facebook.Inoltre sarà ora possibile autenticare un utente Facebook tramite il FacebookLogin.

2.2.3 Access Token

Un Access Token è una stringa che identi�ca un utente, un'applicazione o unapagina e può essere usato da quest'ultimi per eseguire una richiesta ai serverGraph API. Gli Access Token sono ottenibili eseguendo il login su Facebooke contengono le informazioni sulla data di scadenza del token, da chi è statogenerato e a che tipo di dati abbiamo accesso.

Esistono vari tipi di Access Token di�erenziati dai vari tipi di utilizzo:

• User Access Token � Sono i token utilizzati più spesso. Questo tipo ditoken è sempre necessario quando l'applicazione chiama un API per leg-gere, modi�care o scrivere i dati di utente Facebook. Generalmente ven-gono ottenuti tramite una �nestra di login e richiedono l'autorizzazionedi una persona �sica per portare a termine la creazione.

• App Access Token � Questo tipo di token è necessario per modi�care eleggere le impostazioni di una applicazione Facebook. Viene generatoa partire da un codice segreto, chiamato App Secret, utilizzato durantele chiamate che cambiano le impostazioni a livello di Facebook App.

• Page Access Token � Questo Access Token è molto simile allo UserAccess Token con la di�erenza che permette gli accessi di lettura, mo-di�ca e scrittura a una pagina Facebook. Si ottiene solo dopo aver

13

https://developers.facebook.com/


validato uno User Access Token richiedendo il permesso �manages pagepermission� tramite apposita chiamata Graph API.

• Client Token - Il Client Token è un identi�catore che può essere abbi-nato a una applicazione nativa mobile o desktop il quale identi�ca laapplicazione Facebook a cui fa riferimento. Questo token non è pensa-to per essere segreto, per questo ha accesso a ristrette chiamate GraphAPI.

Gli User Access Token si dividono in due tipi: short-lived token e long-lived token. I primi, solitamente, hanno una durata di circa una o due oreal massimo, mentre i secondi hanno una vita di 60 giorni. Le applicazionimobile che usano la SDK di Facebook generano degli long-lived token.

Una delle caratteristiche più importanti degli Access Token è che essi sonoportabili: una volta ottenuto può essere usato per fare richieste da un clientmobile, da un Web browser o dal nostro server. Infatti, se abbiamo ottenutoil Token tramite un'applicazione mobile, possiamo inviarlo al nostro serverper poi eseguire delle chiamate direttamente da quest'ultimo.

2.2.4 Permission

Come accennato nel paragrafo precedente, gli Access Token ci garantisconol'accesso ai dati dell'utente.

Le Permission sono il metodo per richiedere accesso alle risorse che nonsono reperibili liberamente: l'utente può infatti selezionare le informazionialle quali l'applicazione può avere o non avere accesso.

Le Permission sono stringhe che vengono passate insieme a una richiestadi login o a una chiamata Graph API. Questo è un esempio di Permission:

• email - garantisce l'accesso all'email dell'utente

• friends - garantisce l'accesso agli amici che hanno utilizzato la stessaapplicazione Facebook

• publish_actions - permette all'applicazione di pubblicare contenuti sul-la propria pagina Facebook

2.2.5 Facebook SDK per Android

La Facebook SDK per Android permette di integrare i servizi o�erti dal SocialNetwork nel sistema operativo Android, alcune di queste feature richiedonoche l'utente abbia installata sul proprio telefono la Facebook per Androidapp. Grazie alla SDK di Facebook sarà possibile:

14


• il Login tramite Facebook: permette agli utenti di accedere all'applica-zione con la loro identità Facebook senza che ci sia bisogno di reinserirele proprie credenziali Facebook;

• la condivisione di risultati o contenuti: consente alle persone di pubbli-care su Facebook direttamente dall'applicazione;

• l'accesso alle Graph API: l'accesso alle Graph API consente di ottenereo inviare dati ai social graph di Facebook. É possibile interrogare idati, aprire nuove storie, caricare foto e altro ancora.

• l'invio di richieste: permette agli utenti di inviare le richieste ai loroamici per provare l'applicazione.

15

Capitolo 3

Studio del problema

3.1 Introduzione

Il problema datomi da risolvere è cercare la possibilità di sfruttare i servizio�erti dai social network nella piattaforma AMUSE. Il tutto deve esseresvolto nel modo più trasparente possibile: la logica della piattaforma AMUSEnon 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 amicicontro 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 dellaregistrazione e dell'autenticazione degli utenti, della logica del sistema e ditutti gli altri servizi o�erti dalla piattaforma, mentre il lato client fornisceallo sviluppatore le chiamate per interagire con quest'ultima.

Per uno studio più approfondito è stato necessario installare la piattafor-ma AMUSE in locale. Questa operazione è risultata particolarmente com-plessa causa la mancanza di documentazione o di una guida che spiegassecome fare. Dopo vari tentativi, si è riusciti a risolvere tutte le problematichee ad avviare un server AMUSE locale.

3.2 Studio della piattaforma AMUSE

3.2.1 Autenticazione e Registrazione

A lato server la responsabile delle autenticazioni e delle registrazioni è la clas-se AuthenticationService contenuta nel package com.amuse.admin.services.

16

3.2 Studio della piattaforma AMUSE Studio del problema

Al suo interno, infatti, sono presenti due metodi: il metodo authenticate() eil metodo manageNewAccount().

Il primo viene invocato quando al server riceve una richiesta di autentica-zione, i parametri che richiede sono una stringa, che contiene lo username ela password dell'utente separate dal carattere �:� e un oggetto di tipo Logger.

Al suo interno la stringa viene spezzata per il carattere �:� attraverso ilmetodo extractCredentialsInfo() contenuto nella classe AmuseUtils la qua-le ritorna un array di stringhe. Così facendo si ricavano lo username e lapassword, che occupano rispettivamente le posizioni zero e uno dell'arraydi stringhe ritornato. Successivamente viene controllata la corrispondenzatra lo username e la password, prima controllando l'esistenza dello usernameall'interno del database e, in caso a�ermativo, se username e password appar-tengono allo stesso utente. Nel caso in cui l'autenticazione sia andata a buon�ne, il metodo authenticate() ritorna una stringa contenente lo username, incaso contrario lancia un'eccezione contenente la descrizione dell'errore.

Il secondo, invece, viene invocato quando il server riceve una richiesta diregistrazione, il parametro richiesto è una stringa contenente lo username e lapassword dell'utente da registrare separati dal carattere �:�. La stringa vienespezzata per il carattere �:� attraverso il metodo, già menzionato preceden-temente, extractCredentialsInfo(). Ricavati username e password, si richiedeal database l'esistenza o meno di un account avente lo stesso username: seesiste viene lanciata un'eccezione, in caso contrario viene registrato un nuovoaccount con le credenziali uguali allo username e alla password ricevute.

Nel package com.amuse.client.android è presente la classe AmuseClient, laquale è responsabile della connessione con la piattaforma AMUSE. Come pri-ma cosa, deve essere invocato il metodo getInstance() per ricevere un'istanzaAmuseClient inizializzata correttamente. Il metodo getInstance() vuole treparametri: il nome dell'applicazione, il context dell'applicazione e una call-back contente i metodi onSuccess() e onFailure(). Questa operazione vieneeseguita in modo asincrono e quindi l'oggetto AmuseClient recuperato è resodisponibile nel metodo onSuccess() della callback. Successivamente, speci�-chiamo le variabili di connessione come l'indirizzo dell'host, il numero dellaporta e il protocollo da utilizzare con il metodo setConnectionProperties() diAmuseClient.

In�ne con il metodo setLoginManager() della classe AmuseClient settiamoun oggetto LoginManager e invochiamo il metodo connect(), il quale richiedea sua volta una callback come parametro.

Il metodo connect() si occupa di stabilire una connessione con l'host uti-lizzando le impostazioni precedentemente settate. A seconda del contenutodella risposta invocherà il metodo onSuccess() o il metodo onFailure() dellacallback passatogli come parametro.

17

3.2 Studio della piattaforma AMUSE Studio del problema

L'oggetto LoginManager è responsabile della cattura delle credenziali: ve-ri�ca se le credenziali dell'utente sono già disponibili all'interno del client, incaso a�ermativo le invia al server AMUSE all'atto della connessione, in casocontrario le richiede all'utente. L'utente può scegliere di inserire le credenzialidi un account AMUSE esistente oppure di creare un nuovo account.

In ogni caso tali informazioni vengono fornite al client sotto forma di unoggetto LoginInfo, un oggetto che contiene username, password e un'informa-zione booleana, che indica se si tratta di un account nuovo o di un account esi-stente, chiamando il metodo loginDone() della classe DefaultLoginManagercontenuta nel modulo Android-client.

3.2.2 Gestione degli Amici

L'interfaccia ContactsManagementFeature si occupa della gestione degli ami-ci: grazie ad essa è possibile aggiungere, ricercare e rimuovere altri accountAMUSE, i quali risulteranno nostri amici. Per prima cosa deve essere ini-zializzato un oggetto ContactsManagementFerature, chiamando il metodogetFeature() della classe AmuseClient.

In seguito con il metodo initialize(), che necessita di un oggetto callbackcome parametro, sincronizziamo con il server la lista degli amici aggiuntiin passato, in modo tale da poter subito visualizzare a schermo gli amicicorrenti. Aiutandoci con un'interfaccia gra�ca, come per esempio un campodi inserimento testo e un bottone, possiamo richiedere all'utente lo usernamedell'amico da aggiungere.

Inserito lo username da ricercare e premuto il bottone, la ricerca del sud-detto viene eseguita con il metodo addContanct(). Questo metodo comeparametri richiede una stringa, che sarà lo username da ricercare, e una call-back: se la ricerca ha un esito positivo l'amico viene aggiunto in automaticonella lista amici del utente e viene invocato il metodo onSuccess() della call-back; in caso contrario viene segnalato l'errore che l'operazione non è giuntaa compimento.

Completata la fase di ricerca degli amici, è possibile ora invitarli pergiocare un match insieme: con il metodo createTable(), contenuto nellaclasse GamesRoomFeature, passandogli come parametro una lista di stringacontenente lo username degli amici sarà possibile creare un tavolo con loro.

18

3.3 Possibili Soluzioni Studio del problema

3.3 Possibili Soluzioni

3.3.1 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 tramiteFacebook� visualizzato sul client Android;

2. I server Facebook, dopo aver autenticato l'account, rispondono gene-rando un Access Token univoco associato alla sessione;

3. Il client, utilizzando l'Access Token, richiede l'ID dell'account Facebookai server Facebook;

4. I server Facebook rispondono inviando le informazioni richieste;

5. Il client esegue l'accesso sulla piattaforma AMUSE con le informazio-ni ottenute da Facebook: username uguale all'ID e password ugualeall'Access Token;

6. Il server AMUSE utilizza l'Access Token per eseguire una richiesta aiserver 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 quelliappena ricevuti dal server Facebook: nel caso coincidessero l'utente èautenticato con la sua identità Facebook, in caso contrario il tentativodi Login viene ri�utato.

19


Figura 3.1: Architettura di Login

3.3.2 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 degliamici relativi all'account richiesto;

20


3. Il Client visualizza la lista amici ricevuta;

• Aggiornamento della lista amici

1. Il server AMUSE richiede la lista amici di un utente direttamenteai server Facebook;

2. Il server Facebook invia la lista degli amici relativi all'accountFacebook;

3. Il server AMUSE elabora gli amici mantenendo soltanto quel-li aventi un account AMUSE associato e li salva all'interno delproprio database;

Figura 3.2: Soluzione interna

Questa architettura ha il vantaggio di portare un completo controllo sul-la gestione degli amici, tuttavia gli svantaggi sono parecchi. Gli amici diFacebook di un utente possono cambiare anche più volte al giorno: sareb-be, quindi, necessario implementare una procedura di aggiornamento dellalista presente sul database interno del server AMUSE, da eseguire più volteal giorno e per ogni utente registrato, un carico di lavoro notevole che po-trebbe rallentare tutta la piattaforma. Inoltre questa modi�ca è contrariaall'obiettivo della trasparenza.

21


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 al-l'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 soloquando l'utente richiede gli amici di Facebook. Il vantaggio di quest'ultimaarchitettura, rispetto alla soluzione interna è quello di avere un carico dilavoro solo su richiesta, quindi in generale minore. Lo svantaggio rispetto allasoluzione 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


Figura 3.4: Soluzione diretta

3. Il Client visualizza la lista amici ricevuta.

Nella soluzione diretta il server AMUSE non viene interrogato: il clientAndroid si occupa di richiedere le informazioni degli amici direttamente aiServer Facebook. Il vantaggio rispetto alle altre soluzioni è la velocità conla 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 dialcuna modi�ca a lato server AMUSE.

23

Capitolo 4

Implementazione e

Funzionamento

In questo capitolo sarà fatta un'analisi più approfondita sulla soluzione im-plementata facendone vedere anche il funzionamento con un'applicazioneAndroid sviluppata per questo motivo.

4.1 Implementazione

4.1.1 Implementazione login tramite social network

Per implementare l'architettura scelta per il login tramite social network èstato necessario modi�care i metodi e le classi che gestiscono l'autenticazionee la registrazione degli utenti nella piattaforma AMUSE a lato server.

Come già accennato nei capitoli precedenti, la classe responsabile di que-sti servizi, a lato server, è la classe AuthenticationService, la quale con-tiene i metodi authenticate() e manageNewAccount(): il primo serve perl'autenticazione mentre il secondo per la creazione di un nuovo account.

Per permettere che l'architettura funzioni è stato necessario creare de-gli standard di comunicazione tra il client e il server: innanzitutto è stataintrodotta la nozione �dominio�.

Con dominio si indica la provenienza di un account: per esempio, seun account è nativo AMUSE il suo dominio sarà �AMUSE�, nel caso sia unaccount Facebook sarà �FACEBOOK� eccetera. Il dominio viene gestito comeuna stringa, e sarà posto dopo lo username separato dal carattere speciale�$�, per esempio <username>$<dominio>.

Per implementare questa nuova caratteristica sono stati creati nella classiAmuseUtils due metodi: registerDomain() e getDomain(). RegisterDomain()

24

4.1 Implementazione Implementazione e Funzionamento

è un metodo che deve essere invocato a lato client: passandogli come para-metro una stringa contenente il nome del dominio, ne permette la gestioneall'interno dell'applicazione, salvandola in una lista di stringhe. Questo con-sentirà di superare i controlli che si occupano della giusta formattazione dellousername prima di essere inviato al server: se ad esempio è stato registratoil dominio �FACEBOOK� uno username del tipo <username>$FACEBOOKverrà 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 questometodo, dopo aver ottenuto una stringa contenente uno username come pa-rametro, ritornerà il dominio associato. Può essere utilizzato sia a lato serverche 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 adAMUSE, è stato quello di inviare le informazioni relative all'account come sefosse un nuovo account, in modo tale, da gestirlo a lato server con il metodomanageNewAccount().Quest'ultimo, quindi prevederà una porzione di codice che sarà responsabiledell'autenticazione di account con dominio diverso da AMUSE: per primacosa dovrà essere veri�cata l'esistenza dell'account all'interno del dominio diappartenenza. In caso a�ermativo verrà interrogato il database interno delsistema: se l'account non è presente, verrà registrato come nuovo accounte autorizzato, nel caso in cui lo username sia già all'interno del database

25


l'account verrà autorizzato con l'identità del dominio di provenienza. Eccoin seguito, la porzione di codice che gestisce questo meccanismo per il socialnetwork 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


}

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)){





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


have the expected form <username>:<password>");

}

finally {

HibernateUtils.commitTransaction();

}

}

Come si può vedere, il metodo manageNewAccount richiede come parametrouna stringa: quest'ultima contiene le credenziali necessarie per la registra-zione di un nuovo account. Nel caso in cui l'utente stesse tentando l'accessotramite Facebook, la stringa prevista sarà formattata nel seguente modo:<IDFacebook>$FACEBOOK:<AccessToken>, dove l'ID di Facebook, è unastringa numerica unica che rappresenta un account Facebook, mentre l'AccessToken è il Token di accesso rilasciato da Facebook.

La stringa in ingresso viene spezzata attraverso il metodo, della classeAmuseUtils, extractCredentialsInfo(), il risultato viene poi assegnato allevariabile username; username quindi conterrà <IDFacebook>$FACEBOOK,mentre la password sarà <AccessToken>.

Successivamente, con il metodo getDomain(), viene estratto il dominioall'interno dello username. A questo punto uno statement if controlla il con-tenuto della stringa domain, e di conseguenza sceglie la porzione di codiceadatta al dominio. Nel caso di un account Facebook, per prima cosa vienecreato un oggetto AccountDAOFacebook: con il suo metodo verifyAccount()è responsabile della veri�ca delle credenziali Facebook. Questo metodo ri-chiede come parametri due stringhe: la prima è l'ID di Facebook, la secondaè l'Access Token associato.

public boolean verifyAccount(String username, String accessToken)


String id = username.replace("$FACEBOOK", "");

String urlS =

"https://graph.facebook.com/v2.3/me?fields=id&access_token="

+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


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) {


} catch (IOException e) {


} catch (JSONException e) {


}

return false;

}

Nel codice si può notare che in questo caso non è stata usata nessunaFacebook SDK, questo perchè ancora non è stata rilasciata per il linguaggiodi programmazione Java.

Come prima cosa viene estratto l'ID dell'account Facebook dalla stringausername, quindi si costruisce l'URL necessario alla richiesta HTTP ai ser-ver Facebook per richiedere le informazioni necessarie alla convalida, ovverol'ID della'account Facebook associato all'Access Token ricevuto. La rispo-sta è formattata in stile JSON, è quindi necessario un parser apposito perl'interpretazione.

In�ne, estratto l'ID dalla risposta, lo si confronta con l'ID estratto dallastringa username: se i due risultassero uguali ritornerà il valore booleanotrue, in caso contrario false.

Successivamente, il controllo ritorna alla funzione manageNewAccount, ilquale inizia una transazione con il database: se esiste già un account con

29


lo stesso username il login viene autorizzato, se non esiste viene creato unrecord all'interno della tabella User contenente lo username e una sottostrin-ga dell'Access Token. Quest'ultima modi�ca non è rilevante, in quanto lapassword in un account Facebook non verrà mai richiesta.

Oltre al metodo manageNewAccount() è stato necessario apportare lestesse modi�che al metodo authenticate(): il lato client di AMUSE salvaall'interno del device le credenziali che hanno portato al successo una proce-dura di login. All'apertura dell'applicazione la classe LoginManager controllala presenza o meno di queste credenziali e nel caso vengano trovate, eseguedirettamente l'accesso senza richiederle all'utente: questa operazione esegueun login e non più una registrazione, per questo motivo a lato server vienechiamato il metodo authenticate().

public static String authenticate(String accountStr, Logger logger)


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





if (acnt != null) {

if (acnt.getPassword().equals(password)) {

return username;

}

else {

30


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


Il comportamento è identico al metodo manageNewAccount(), manca soltan-to il controllo e la scrittura sul database.

A lato client le classi principali che gestiscono la procedura di auten-ticazione e di registrazione dell'attuale versione di AMUSE, sono le classiAmuseClient e LoginManager: la prima si occupa della connessione con ilserver, mentre la seconda è responsabile della cattura delle credenziali inseritedall'utente.

É stato dunque necessario implementare un meccanismo in grado di ot-tenere le giuste informazioni da Facebook e di inviare quest'ultime al serverAMUSE. Di seguito, una porzione di codice presa dall'activity principaledell'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 funzio-namento dell'architettura in quanto permette di superare i controlli eseguitinel 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 �$�, ein caso a�ermativo, lancia un'eccezione e termina la procedura di login; incaso contrario ritorna una stringa formattata secondo gli standard AMUSEpronta per essere inviata al server.É stata, dunque, necessaria una modi�ca a quest'ultimo metodo.

public static String createCredentials(String username, String

password) throws IllegalArgumentException {

if (username == null || username.length() == 0) {

32


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 unaclausula nel caso venga trovato all'interno della stringa username il carattere�$�: se la sottostringa a destra del carattere speciale è una stringa uguale aun dominio registrato con il metodo registerDomain() il metodo ritorna unastringa formattata nello standard AMUSE contenente le credenziali, in casocontrario lancia un'eccezione.

Da notare che la password, ovvero l'Access Token, in questo caso nonviene o�uscato, questo perché il server ha bisogno che l'Access Token sia inchiaro per poter autenticare l'accesso.

All'interno della classe principale dell'applicazione, sarà presente il meto-do facebookLogin():

33


public void facebookLogin(String username, String password) {

loginManager.loginDone(new LoginInfo(username, password, true));

}

Questo metodo, sarà invocato una volta ricevute le credenziali dai serverFacebook, e permetterà l'accesso al sever AMUSE con il metodo loginDone().

Per ottenere le informazioni relative all'account Facebook, è necessarioimplementare il �Login tramite Facebook� usando la Facebook SDK. Que-st'ultima mette a disposizione una serie di classi e di metodi che aiutano losviluppatore a sfruttare i diversi servizi Facebook.

Prima di poterla utilizzare, l'SDK deve essere inizializzata all'interno del-l'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 laclasse LoginButton, contenuto nel package com.facebook.login.widget.

LoginButton è una view di Android che estende la classe Button e chedisegna a schermo il classico bottone di Login di Facebook. Per aggiungere laview LoginButton a un'applicazione Android, è necessario scrivere all'internodel �le XML dell'interfaccia gra�ca 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 gra�ca, è pos-sibile settare le Permissions e la callback da eseguire non appena il Logintramite Facebook è stato eseguito. Con i metodi setReadPermissions() esetPublishPermissions() è possibile aggiungere delle Permission al Login, in

34


modo tale da poter accedere alle informazioni necessarie contenute sul pro�loFacebook.

Per registrare la callback si utilizza il metodo registerCallback(), il qualerichiede in input un oggetto CallbackManager() e una FacebookCallback. Laclasse CallbackManager si occupa di gestire e registrare le callback all'internodell'SDK, mentre FacebookCallback è un oggetto callback che contiene alsuo interno tre metodi: onSuccess(), invocato nel caso il login su Facebooksia andato a buon �ne, onCancel(), invocato nel caso l'utente ri�uti tuttele Permissions richieste, e onError(), invocato quando succede qualcosa diinaspettato 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>() {

@Override

public void onSuccess(LoginResult loginResult) {

GraphRequest request =

GraphRequest.newMeRequest(loginResult.getAccessToken(),

new GraphRequest.GraphJSONObjectCallback() {

@Override

public void onCompleted(JSONObject object,

GraphResponse response) {

if (object != null) {

try {

String id = object.getString("id")+"$FACEBOOK";

facebookLogin(id,

AccessToken.getCurrentAccessToken().getToken());



}

}

}

});

Bundle parameters = new Bundle();

parameters.putString("fields", "id");

request.setParameters(parameters);

35


request.executeAsync();

}

@Override

public void onCancel() {

// App code

}

@Override

public void onError(FacebookException exception) {

//App code

}

});

Nel caso il login abbia avuto successo, l'oggetto LoginResult contiene al suointerno il nuovo Access Token generato.

Nella chiamata onSuccess della FacebookCallback, viene e�ettuta unarichiesta tramite la classe GraphRequest. Questa classe, è messa a disposi-zione dalla Facebook SDK per Android e permette di interagire con le GraphAPI. In particolare, con il metodo newMeRequest() è possibile richiedere leinformazioni relative all'account associato all'Access Token appena generato.

La costruzione della richiesta è semplice: come parametri di input richie-de un Access Token e una callback GraphJSONObjectCallback, nella qualesarà necessario fare l'override del metodo onComplete(). Il metodo callbackonComplete() riceve come parametri due oggetti: un JSONobject, che con-tiene la risposta del server formattata in stile JSON, e un GraphResponseche contiene, oltre alla risposta, altre informazioni relative ad essa. Settatala callback, è possibile richiedere speci�che informazioni alla richiesta aggiun-gendo parametri con il metodo setParameters() della class GrapRequest. Pereseguire la richiesta, è necessario invocare il metodo executeAsync(), il qualepermette l'esecuzione della richiesta su un thread secondario in modo tale danon bloccare l'esecuzione dell'applicazione.

Per completare l'implementazione, è indispensabile e�ettuare l'overridedel metodo onActivityResult() dell'activity e richiamare al suo interno ilmetodo onActivityResult() dell'oggetto CallbackManager.

@Override

public void onActivityResult(int requestCode, int resultCode,

Intent data) {

super.onActivityResult(requestCode, resultCode, data);

callbackManager.onActivityResult(requestCode, resultCode, data);

36


}

Questo metodo permetterà all'applicazione di raccogliere i risultati del Login.

4.1.2 Implementazione di �Trova Amici�

Per implementare la funzione �Trova Amici�, è stato scelta la �soluzione di-retta� descritta nel capitolo precedente, per questo motivo non sono statenecessarie modi�che al server AMUSE: per la ricerca degli amici vengonocontattati direttamente i server di Facebook.

Grazie alle Graph API di Facebook è possibile ricevere gli amici dell'u-tente 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 accet-tare la Permission user_friends, che da accesso alla lista amici dell'utente.

La Facebook SDK per Android permette di eseguire la richiesta tramiteil metodo newMyFriendsRequest() della classe GraphRequest, già descrittaprecedentemente.

Un esempio di implementazione è il seguente:

GraphRequest.newMyFriendsRequest(AccessToken.getCurrentAccessToken(),

new GraphJSONArrayCallback() {

@Override

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);



}

}

friendsAdapter.notifyDataSetChanged();

}

37


}).executeAsync();

Il metodo newMyFriendsRequest() richiede come input due parametri: unAccess Token e una callback di tipo GraphJSONArrayCallback contenente unmetodo onComplete(), il quale verrà invocato una volta ricevuto il risultato.Il risultato è contenuto in un oggetto JSONArray che ha al suo interno l'IDFacebook e il nome degli amici. In questo caso, per ogni amico viene creatoun oggetto Pro�le.

La classe Pro�le, messa a disposizione dalla Facebook SDK per Android, èun oggetto in grado di rappresentare un pro�lo Facebook. In seguito l'oggettoPro�le è aggiunto alla lista degli amici di Facebook, la quale è usata dacontenitore nell'adapter friendsAdapter. Questo meccanismo ha lo scopo didisegnare a schermo la lista degli amici, ra�gurata da una ListView.

Per selezionare uno o più amici con cui giocare basterà toccare lo schermosu uno o più di essi: il tocco sarà gestito dal metodo setOnItemClickListener()della classe ListView, il quale aggiungerà o toglierà, a una lista rappresentantegli amici invitati, l'amico selezionato.

facebookFriendsListView.setOnItemClickListener(new

OnItemClickListener() {

@Override

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 post�sso, questo permette al server di riconoscere gli account Facebook,

38

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 nuovoaccount.

Una volta scelti gli amici con cui giocare, basterà chiamare il metodocreateTable()della classe GamesRoomFeature, passandogli la lista degli amiciselezionati come parametro, il quale richiederà al server di creare un tavoloinsieme suddetti.

4.2 Funzionamento

Per mostrare il funzionamento del lavoro di tesi, queste feature sono stateimplementate in un'applicazione AMUSE-based da me creata: Wadoku.

Wadoku è un gioco multi-player online il cui scopo è quello di far com-petere i giocatori per completare, inserendo più numeri possibile, una grigliaSudoku. Si gioca tutti contro tutti: per ogni numero inserito correttamentesaranno assegnati tre punti e comparirà anche nelle tabelle degli altri giocato-ri; per ogni numero errato varrà tolto un punto. Il gioco prevede al massimoquattro giocatori e il giocatore con il punteggio più alto vince il match.

La schermata di accesso dell'applicazione prevede due campi testo con irelativi bottoni di �Login� o �Register� insieme al bottone di colore blu conla scritta �Login with Facebook�.

Figura 4.1: Schermata di Login

39


Premendo sul tasto �Login with Facebook� verrà aperta una dialog perl'accettazione delle Permission, in questa applicazione saranno richieste lePermission user_friends e public_pro�le.

Figura 4.2: Schermata richiesta Permission

Accettate le Permission, avremo eseguito l'accesso all'interno di AMUSEcon la nostra identità Facebook.

La schermata principale dell'applicazione prevede quattro bottoni. Pre-mendo su �Start a new Match� l'applicazione si metterà in ricerca di altri

40


giocatori contro cui giocare, una volta raggiunto il numero minimo di gioca-tori il match inizia. Il bottone �Completed Matches� mostra i risultati deimatch precedentemente completati. Il terzo bottone, �Friends�, apre la scher-mata degli amici e in�ne il bottone �About Amuse� mostra le informazioniprincipali della versione di AMUSE.

Figura 4.3: Schermata Amici

La schermata degli amici è divisa in tre sliding tab: AMUSE, Facebooke Google. É possibile passare da una all'altra attraverso uno swipe nella di-rezione desiderata. Muovendosi nella schermata di Facebook, avendo fatto illogin tramite quest'ultimo, troveremo la lista degli amici del social networkcon cui abbiamo in comune l'utilizzo di questa applicazione: sarà, quindi,possibile selezionare uno o più amici con cui giocare. La selezione o la dese-lezione avviene tramite il tocco sullo schermo: l'immagine a destra del nomedell'amico compare o scompare a seconda della sua presenza o meno nellaselezione.

Il gioco prevede un minimo di due �no a un massimo di quattro giocatori,quindi sarà possibile selezionare �no a tre giocatori. La tab di Google, èstata inserita per predisporre l'applicazione all'aggiunta dell'accesso tramiteil social network Google+ e per mettere in risalto la possibilità di avere unoo più domini dal quale selezionare gli amici con cui giocare.

Nel caso in cui l'accesso nella piattaforma sia stato eseguito con un ac-count AMUSE, al posto della lista degli amici, sarà visualizzato il bottone�Login with Facebook�, il quale ci permetterà di avere accesso alla lista amiciFacebook anche da un account AMUSE.

41


Figura 4.4: Schermata Amici Facebook con account AMUSE

42

Conclusioni

Come conclusione di questa tesi è possibile dire che l'integrazione dei servizidi social network all'interno della piattaforma AMUSE è possibile, e il lavorosvolto con il social network Facebook ne è la prova.Gi sviluppi futuri possibili su questi tesi sono:

• Sempli�cazione chiamate della Facebook SDK : con questa sempli�-cazione intendo una serie di chiamate all'interno della piattaforma lequali aiuteranno lo sviluppatore a inserire nella propria applicazioneAMUSE-based i servizi citati in questa tesi. Per esempio la proceduradi login potrebbe essere gestita interamente da un metodo all'internodella classe LoginManager di AMUSE.

• Aggiunta di altri Social Network: in questa tesi sono stati de�niti deglistandard di comunicazione utilizzabili anche da altri social network,infatti nella piattaforma AMUSE sarà possibile aggiungere un suppor-to ad essi, modi�cando solamente i metodi manageNewAccount() eauthenticate() della classe AuthenticationService.

• Implementazione di altri servizi o�erti da Facebook: il social networkFacebook o�re molti altri servizi per le applicazioni mobile, tra i qualila possibilità di usare la sua chat integrata Messenger per lo scambiodi messaggi, oppure l'inserimento di ads pubblicitarie, e molto altroancora.

• Miglioramenti sulla gestione degli amici: in�ne si potrebbe migliorarela gestione degli amici: in questa versione l'account AMUSE e l'accountFacebook di un utente sono scollegati, sarebbe gradito che le identitàcon domini diversi, ma riferite alla stessa persona, siano unite sotto ununico account.

43

Bibliogra�a

[1] Giovanni CaireAMUSE Tutorial

http://jade.tilab.com/amuseproject/amuse-tutorial/

[2] Giovanni CaireAMUSE Startup Guide

http://jade.tilab.com/amuse/doc/Amuse-Startup-Guide.doc

[3] WikipediaServizio di rete sociale

http://it.wikipedia.org/wiki/Servizio_di_rete_sociale

44

http://jade.tilab.com/amuseproject/amuse-tutorial/

http://jade.tilab.com/amuse/doc/Amuse-Startup-Guide.doc

http://it.wikipedia.org/wiki/Servizio_di_rete_sociale

Appendice A

Login with Social Network in

AMUSE

A.1 Introduction

This Tutorial aims to show how to implement the Login with Facebook inthe AMUSE platform. More information on the AMUSE framework can befound in the AMUSE Startup Guide or in the Amuse Tutorial.

A.1.1 Prerequisites

AMUSE is fully written in Java, so a good knowledge of the Java languageand the Java API is mandatory to understand the content of this tutorial.In this version AMUSE client API are available for the Android environmentonly, the reader is assumed to be already familiar with Android programming.At last, this tutorial provides knowledge of Facebook and of its mechanisms.

A.2 Necessary Material

A.2.1 Create a Facebook App

First of all, it is required to create a Facebook App. To do this, open yourbrowser web, visit https://developers.facebook.com/, and login with a validFacebook Account.

If you are a Facebook Developer you can skip this, else move the cursoron �My Apps� and click on �Register as a Developer�, accept the policies, andcomplete the registration.

45

A.3 Add Facebook Features Login with Social Network in AMUSE

Figura A.1: Create a Facebook App

Now move the cursor on �My Apps� and click on �Add a new App�, selectAndroid, type the name of your app and click on �Create new Facebook appID�.

Fill in the form that Facebook required with the information on your applike package and key hashes.For the key hashes, if your app is not published, use the command

keytool -exportcert -alias androiddebugkey -keystore

<HOMEPATH>\.android\debug.keystore | openssl sha1 -binary |

openssl base64

and for password use �android� (without quote marks).The next step is download the Facebook SDK for Android, it can be do-

wnloaded here https://developers.facebook.com/docs/android; this tutorialreferences at vesion 4.0.0. Once downloaded, extract it in a folder.

A.2.2 Add Facebook SDK to Your Project

If you are using Eclipse, you have to import the Facebook as a project: clickon File -> New -> Android Project From Existing Code, move into the folderwhere extracted the Facebook SDK and select the folder facebook.

Now, right click on your project, select Android and add the projectfacebook as a library.

A.3 Add Facebook Features

In order to explain how to add Facebook Features in your Project, this tuto-rial makes reference to pieces of code taken from the tutorial Facebook App

46


Figura A.2: Import Facebook SDK

whose complete source code is available for download from the AMUSE SVNrepository.

This App contains more features than this tutorial, but the necessarysteps to implement the Facebook features are below.The project is structured like this:

• MainActivity -> It is the activity launched at the beginning of theapplication, it contains the form for the AMUSE login and the FacebookLoginButton Fragment

• MyApp -> This class extends Application and contains the necessarymethods to login in the AMUSE platform.

• FacebookLoginFragment -> This Fragment contains the necessary me-thods to login with Facebook.

• WelcomeActivity -> This Activity shows the informations of the userand Play with Friends button.

• FriendsActivity -> This Activity contains three Fragment: Amuse-FriendsFragment, FacebookFriendsFragment and GoogleFriendsFrag-ment.

• AmuseFriendsFragment -> This fragment shows the AMUSE friendsas a list, is possible to add friends and play with them.

47


• FacebookFriendsFragment -> This fragment shows the Facebook friendswho logged in this app with Facebook.

• GoogleFriendsFragment -> not yet implemented.

A.3.1 Add Login with Facebook

Setup Project

To use Facebook SDK in a project, is necessary select API 9: Android 2.3 orhigher.

First of all, open the resource �le string.xml and add a new string namedfacebook_app_id that contains your Facebook App ID. This ID, can benfound in the dashboard of your App.

Then open Manifest �le, and insert into the tag application:

..

<meta-data android:name="com.facebook.sdk.ApplicationId"

android:value="@string/facebook_app_id"/>

..

The next step is add the FacebookActivity to the manifest:

..

<activity android:name="com.facebook.FacebookActivity"

android:theme="@android:style/Theme.Translucent.NoTitleBar"

android:label="@string/app_name" />

..

Here below, the Manifest of the tutorial Facebook App

<?xml version="1.0" encoding="utf-8"?>

<manifest xmlns:android="http://schemas.android.com/apk/res/android"

package="com.amuse.facebooktutorial"

android:versionCode="1"

android:versionName="1.0" >

<uses-sdk

android:minSdkVersion="14"

android:targetSdkVersion="21" />

48


<uses-permission android:name="android.permission.INTERNET"/>

<uses-permission

android:name="android.permission.WRITE_EXTERNAL_STORAGE" />

<application

android:name=".MyApp"

android:allowBackup="true"

android:icon="@drawable/ic_launcher"

android:label="@string/app_name"

android:theme="@style/AppTheme" >

<service android:name="com.amuse.client.android.AmuseService"

/>

<service android:name="jade.android.MicroRuntimeService" />

<activity

android:name=".MainActivity"

android:label="@string/title_activity_main" >

<intent-filter>

<action android:name="android.intent.action.MAIN" />

<category

android:name="android.intent.category.LAUNCHER" />

</intent-filter>

</activity>

<activity

android:name=".WelcomeActivity"

android:label="@string/title_activity_welcome" >

</activity>

<activity android:name="com.facebook.FacebookActivity"

android:theme="@android:style/Theme.Translucent.NoTitleBar"

android:label="@string/app_name" />

<meta-data

android:name="com.facebook.sdk.ApplicationId"

android:value="@string/facebook_app_id"/>

</application>

</manifest>

49


Create the Login Button

To add the Login Button, open the layout �le and type with the full classname, com.facebook.widget.LoginButton:

<com.facebook.login.widget.LoginButton

android:id="@+id/facebook_login_button"

android:layout_width="match_parent"

android:layout_height="wrap_content"

android:layout_gravity="center_horizontal"

android:padding="15dp"/>

Now, create a new class that extends the Fragment class.You then need to call FacebookSdk.initialize to initialize the SDK, and

then call CallbackManager.Factory.create to create a callback manager tohandle login responses. Here is an example of adding the callback in afragment:


@Override





}

Then set up the button in your UI by adding it to a fragment and updateyour activity to use your fragment. You can customize the properties ofLogin button and register a callback in your onCreateView() method.

public View onCreateView(

LayoutInflater inflater,

ViewGroup container,

Bundle savedInstanceState) {

View view = inflater.inflate(R.layout.splash, container, false);

loginButton = (LoginButton)

view.findViewById(R.id.facebook_login_button);

50


loginButton.setReadPermissions("user_friends");

loginButton.setFragment(this);

// Other app specific specialization

// Callback registration

loginButton.registerCallback(callbackManager,

new FacebookCallback<LoginResult>() {

@Override

public void onSuccess(LoginResult loginResult) {

GraphRequest request = GraphRequest.newMeRequest(

loginResult.getAccessToken(),

new GraphRequest.GraphJSONObjectCallback() {

@Override

public void onCompleted(JSONObject object,

GraphResponse response) {

String id = object.getString("id")+"$FACEBOOK";

((MainActivity)getActivity()).facebookLogin(id,

AccessToken.getCurrentAccessToken().getToken());

}

}

});

Bundle parameters = new Bundle();

parameters.putString("fields", "id");

request.setParameters(parameters);

request.executeAsync();

}

@Override

public void onCancel() {

// App code

}

@Override

public void onError(FacebookException exception) {

// App code

}

});

}

If login succeeds, the method onSuccess will called and the LoginResultparameter has the new AccessToken, and the most recently granted or decli-

51


ned permissions. In this method, is made a new request to fetch the ID ofthe User who just logged with Facebook. At this ID, is appended the string�$FACEBOOK�, that rapresent the domain of this ID.

At last, is invoked a MainActivity method called facebookLogin that asparameters it takes the string id and the Access Token, this method will takecare of the login in AMUSE. Then in onActivityResult() forward the loginresults to the object callbackManager created in onCreate():

@Override

protected void onActivityResult(int requestCode, int resultCode,

Intent data) {

super.onActivityResult(requestCode, resultCode, data);

callbackManager.onActivityResult(requestCode, resultCode, data);

}

Add the Login Button in an Activity

Now, this fragment can be added in an Activity: create the activity whereyou want add the Facebook Login Button and open the Android layout �leof that and type

<fragment

android:name="com.amuse.facebooktutorial.FacebookLoginFragment"

android:id="@+id/facebook_fragment"


android:layout_height="wrap_content" />

First of all, the Facebook domain must be registred in AMUSE, so insidethe method onCreate() add this code

private DefaultLoginManager loginManager;


..

setContentView(R.layout.main_activity_layout);

AmuseUtils.registerDomain("FACEBOOK");

loginManager = new DefaultLoginManager(this);

..

}

52


Then, create the method facebookLogin, like below

public void facebookLogin(String username, String password) {

loginManager.loginDone(new LoginInfo(username, password, true));

}

A Facebook account must always login in AMUSE like a new Account.

A.3.2 Play with Facebook Friends

Once the Facebook Login is ready, it is possible to �nd the Facebook friendswho logged in the same application.

Create the FriendsActivity

First of all, is necessary create the layout �le: it must contains a ListView,that will show the friends, and a button, will be used to invite one or morefriends.


<LinearLayout

xmlns:android="http://schemas.android.com/apk/res/android"


android:layout_height="match_parent"

android:orientation="vertical" >

<ListView

android:id="@+id/facebook_friends_listview"


android:layout_height="wrap_content"/>

<Button

android:id="@+id/friends_invite_button"



android:padding="10dp"

android:text="Invite" >

</Button>

53


</LinearLayout>

Now, create a new Activity. Inside the method onCreate(), must beinitialize all necessary:

• The FacebookSDK and the CallbackManager to manage the FacebookRequest

• A Pro�le list where the Facebook friends will be stored

• A String list where the invited friends will be stored

private ListView facebookFriendsListView;

private FacebookFriendsAdapter friendsAdapter;

private Button inviteButton;

private List<Profile> facebookFriendsList;

private ArrayList<String> invitedFriends;


@Override



setContentView(R.layout.friends_activity_layout);



facebookFriendsList = new ArrayList<Profile>();

invitedFriends = new ArrayList<String>();

}

The next step is to implement the list adapter. First is necessary typethe layout to in�ate in a list row, to do this create a new layout. The layoutwill contain the pro�le image and the name of the friend.


<LinearLayout

xmlns:android="http://schemas.android.com/apk/res/android"

android:orientation="horizontal"



android:padding="5dp">

54


<com.facebook.login.widget.ProfilePictureView

android:id="@+id/facebook_friend_image"

android:layout_width="30dp"

android:layout_height="30dp" />

<TextView

android:id="@+id/facebook_friend_name"

android:layout_width="wrap_content"

android:layout_height="match_parent"

android:layout_gravity="center_vertical"

android:layout_marginRight="56dp"

android:paddingLeft="5dp"

android:textSize="24sp"

android:textColor="@android:color/black">

</TextView>

</LinearLayout>

The Pro�lePictureView is a widget contained in the Facebook SDK thatdisplays the pro�le photo of a supplied pro�le ID.

Now, create inside the Activity a new class that extends BaseAdapterclass.

public class FacebookFriendsAdapter extends BaseAdapter {

@Override

public View getView(int position, View convertView, ViewGroup

parent) {

LayoutInflater inflater = (LayoutInflater) getActivity()

.getSystemService(Context.LAYOUT_INFLATER_SERVICE);

convertView = inflater.inflate(R.layout.facebook_friends_row,

null);

TextView name = (TextView)

convertView.findViewById(R.id.facebook_friend_name);

ProfilePictureView pictureView =

(ProfilePictureView)

convertView.findViewById(R.id.facebook_friend_image);

pictureView

.setProfileId(facebookFriendsList.get(position).getId());

name.setText(facebookFriendsList.get(position).getName());

return convertView;

}

55


@Override

public long getItemId(int position) {

return position;

}

@Override

public Object getItem(int position) {

return facebookFriendsList.get(position);

}

@Override

public int getCount() {

return facebookFriendsList.size();

}

}

With the in�ater, in�ate in a row the layout previously created and setevery view: set the text of the TextView with the name of the user, and toobtain the pro�le image it's possible invoke the method setPro�leId() of thePro�lePictureView.

The next step is initialize the view and set the adapter inside the methodonResume() of the Activity.

public void onResume() {

super.onResume();

facebookFriendsListView =

(ListView) view.findViewById(R.id.facebook_friends_listview);

inviteButton = (Button)

view.findViewById(R.id.friends_invite_button);

friendsAdapter = new FacebookFriendsAdapter();

facebookFriendsListView.setAdapter(friendsAdapter);

...

updateFriendsList();

}

The method updateFriendsList() is made a new request to fetch the userFacebook friends.

public void updateFriendsList() {

GraphRequest.newMyFriendsRequest(

56


AccessToken.getCurrentAccessToken(),

new GraphJSONArrayCallback() {

@Override

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);

friendsAdapter.notifyDataSetChanged();


// TODO Auto-generated catch block


}

}

}

}).executeAsync();

}

The request requires a valid Access Token and a function callback. Ifthe request is successful, the method onComplete() will be called. Inside theJSONArray there is the information about the friends, formatted in JSONstyle: it contains only the name and the id.

A new object Pro�le will be created with this information and will beadded in the list facebookFriendsList. At last, the data change will be noti�edwith the method notifyDataSetChanged.

57

universitÀ degli studi di parma...2015/04/28 · 1.4 amuse api la piattaforma amuse è così...

Documents