Introduzione
Nel precedente articolo abbiamo analizzato come integrare nella nostra applicazione Android l’autenticazione attraverso Google Sign-In. In questo nuovo articolo invece prenderemo in considerazione l’autenticazione con un altro social molto popolare: Twitter.
Non intendo dilungarmi e ripetermi nel valutare vantaggi e svantaggi in quanto, social a parte, è valido tutto quello discusso nell’articolo riguardante l’autenticazione con Google Sign-In.
Creazione applicazione twitter
Il primo passo da fare è quello di creare un’applicazione per ottenere le chiavi che ci serviranno per eseguire il login seguendo questi semplici passi:
- Eseguiamo l’accesso su https://apps.twitter.com
- Clicchiamo “Create New App”.
- Nel form di richiesta dati compiliamo il nome dell’app, la sua descrizione e l’url del sito. Quest’ultimo dato è obbligatorio ma se non si dispone di un sito è sufficiente dare un segnaposto da cambiare eventualmente più avanti.
- Diamo il consenso al developer agreement.
- Terminiamo il processo cliccando su “Create your Twitter application”.
Terminato il processo di creazione verremo reindirizzati alla pagina contenente tutte le informazioni dell’applicazione. Nella scheda “Key and Access Tokens” troveremo le informazioni di cui avremo bisogno per eseguire il login: Consumer Key e Consumer Secret.
In questo momento abbiamo a disposizione tutto quello che ci serve per creare la nostra applicazione. Ricordo che come per quanto fatto con l’articolo di Google è possibile sul mio account di GitHub trovare l’applicazione di esempio che verrà utilizzata per spiegare i vari passaggi.
LET’S CODE!
Configurazione della libreria
Assicuriamoci che il file build.gradle del progetto includa il repository jcenter, in caso contrario sarà sufficiente aggiungerlo in questo modo
repositories {
jcenter()
}
mentre nel file build.gradle della nostra applicazione dovremo aggiungere la libreria fornita da Twitter
dependencies {
implementation 'com.twitter.sdk.android:twitter-core:3.2.0'
}
Twitter fornisce anche la libreria twitter che rappresenta una sorta di “contenitore” che raggruppa tutte le altre librerie dei moduli. Sarà compito del programmatore, a seconda delle funzionalità dell’applicazione scegliere se includere tutte le API in questo modo
dependencies {
implementation 'com.twitter.sdk.android:twitter:3.2.0'
}
oppure includere solo quelle di cui si ha realmente bisogno alleggerendo conseguentemente l’applicazione. Le librerie disponibili sono:
- twitter-core: per eseguire il login con Twitter.
- tweet-ui: per visualizzare tweets e timelines.
- tweet-composer: per create twees.
- twitter-mopub: per la monetizzazione delle timelines con MoPub
Per approfondire è possibile trovare una descrizione più dettagliata a questo indirizzo.
Configurazione Consumer Key e Secret
Analogalmente a quanto abbiamo visto per l’esempio dell’autenticazione con Google, per definire le chiavi create precedentemente, possiamo creare un file chiamato ad esempio strings_key.xml nella risorsa values con il seguente contenuto
<?xml version="1.0" encoding="utf-8"?>
<resources>
<string name="twitter_consumer_key" translatable="false">YOUR_CONSUMER_KEY</string>
<string name="twitter_consumer_secret" translatable="false">YOUR_CONSUMER_SECRET</string>
</resources>
sostituendo i due segnaposto con i valori forniti da Twitter per la nostra applicazione.
Application
Come prima cosa dovremo inizializzare la libreria creandoci una classe Application e configurandola con consumer key e secret.
class MyApplication : Application() {
override fun onCreate() {
super.onCreate()
val authConfig = TwitterAuthConfig(
resources.getString(R.string.twitter_consumer_key),
resources.getString(R.string.twitter_consumer_secret))
val config = TwitterConfig.Builder(this)
.logger(DefaultLogger(Log.DEBUG))
.twitterAuthConfig(authConfig)
.debug(true)
.build()
Twitter.initialize(config)
}
}
ricordandoci di inserirla nel Manifest.xml
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
package="com.gmail.fattazzo.twitterlogin.example">
...
<application
android:name=".MyApplication"
android:allowBackup="true"
android:icon="@mipmap/ic_launcher"
android:label="@string/app_name"
android:roundIcon="@mipmap/ic_launcher_round"
android:supportsRtl="true"
android:theme="@style/AppTheme">
...
</application>
</manifest>
Main Activity e layout
Per quanto riguarda il login, Twitter fornisce un proprio button che dovrà essere utilizzato mentre per il logout sarà sufficiente usare un button standard. Ecco la sezione di layout che configura i due pulsanti
...
<com.twitter.sdk.android.core.identity.TwitterLoginButton
android:id="@+id/twitterLoginButton"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_marginBottom="8dp"
android:layout_marginEnd="8dp"
android:layout_marginStart="8dp"
android:layout_marginTop="8dp"
app:layout_constraintBottom_toBottomOf="parent"
app:layout_constraintEnd_toEndOf="parent"
app:layout_constraintStart_toStartOf="parent"
app:layout_constraintTop_toTopOf="parent" />
<Button
android:id="@+id/disconnectButton"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_marginBottom="8dp"
android:layout_marginEnd="8dp"
android:layout_marginStart="8dp"
android:layout_marginTop="8dp"
android:drawablePadding="8dp"
android:drawableStart="@drawable/exit"
android:text="@string/disconnect"
android:visibility="gone"
app:layout_constraintBottom_toBottomOf="parent"
app:layout_constraintEnd_toEndOf="parent"
app:layout_constraintStart_toStartOf="parent"
app:layout_constraintTop_toTopOf="parent" />
...
Implementare il codice nella nostra activity risulterà molto semplice e con pochi passaggi chiave.
Autenticazione
Il processo viene gestito impostando una CallBack sul button di login e successivamente implementando il metodoonActivityResult() per gestire il risultato dell’autenticazione.
twitterLoginButton.callback = object : Callback<TwitterSession>() {
override fun success(result: Result<TwitterSession>) {
// Login effettuato con successo
}
override fun failure(e: TwitterException) {
// Autenticazione non riuscita
}
}
override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) {
super.onActivityResult(requestCode, resultCode, data)
twitterLoginButton.onActivityResult(requestCode, resultCode, data)
}
Caricamento dati dell’utente
Una volta che il processo di autenticazione è andato a buon fine potremo caricare i dettagli dell’utente come segue
val twitterApiClient = TwitterCore.getInstance().apiClient
val call = twitterApiClient.accountService.verifyCredentials(true, false, true)
call.enqueue(object : Callback<User>() {
override fun success(result: Result<User>) {
val user = result.data
idTv.text = getString(R.string.user_id,user.id.toString())
userNameTV.text = getString(R.string.user_name,user.name)
emailTV.text = getString(R.string.user_email,user.email)
screenNameTV.text = getString(R.string.user_screen_name,user.screenName)
Picasso.get()
.load(user.profileImageUrl.replace("_normal", ""))
.placeholder(R.drawable.twitter)
.into(userImageView)
}
override fun failure(exception: TwitterException) {
// Autenticazione non riuscita
}
})
Logout
@Click
fun disconnectButtonClicked() {
TwitterCore.getInstance().sessionManager.clearActiveSession()
}
Verificare se l’utente è loggato
/**
* Check if user is authenticated.
*
* @return true if authenticated
*/
private fun isUserAuthenticated(): Boolean {
return TwitterCore.getInstance().sessionManager.activeSession != null
}
Giunti a questo punto abbiamo a disposizione tutti i metodi necessari per gestire l’autenticazione dell’utente tramite Twitter. Il codice integrale dell’activity è disponibile a questo indirizzo.
Email dell’utente
Come è possibile notare dall’ultimo screenshot a fine articolo, il valore della mail utente è nullo. Nel caso in cui risulti necessario acquisirlo sarà sufficiente, nella sezione Permission nella pagina dell’app di twitter, abilitare la voce Request email addresses from users. Come indicato dal paragrafo di spiegazione, per poter abilitare la voce serve obbligatoriamente indicare l’url della privacy policy e terms of service presenti nella sezione Settings.
Nel caso in cui la voce venga attivata l’utente sarà informato del fatto che la sua mail sarà visibile all’applicazione quando verrà visualizzata la scheda per l’accettazione o rifiuto dell’autentitazione ( screenshot numero 2 ).
Token
Possiamo ottenere il token, una volta che l’utente risulta autenticato, dalla sessione attiva in questo modo
val session = TwitterCore.getInstance().sessionManager.activeSession val authToken = session.getAuthToken(); val token = authToken.token val secret = authToken.secret
Screenshots
Riferimenti
Potere trovare tutti punti analizzati nell’app di esempio da me realizzata sul mio account di GitHub.
L’applicazione di esempio utilizza Android Annotations, per approfondire consultare l’articolo Android annotations: Meno codice, più leggibilità
