Android 6: Guida per lo sviluppatore

Lo scorso 28 gennaio è uscito il mio ultimo libro sulla programmazione Android dedicato ad Android 6 ovvero Marshmallows. Si tratta di una versione del testo quasi completamente nuova nella quale ho sviluppato, da zero, una applicazione per la visualizzazione degli orari di arrivo dei Bus. Questa applicazione è stata il pretesto per scrivere ben 13 capitoli con i seguenti titoli:

  1. Android e Java
  2. Creazione ambiente con Android Studio
  3. Le Activity ed il flusso di navigazione
  4. Fragment e primi componenti Material Design
  5. ActionBar e Toolbar
  6. View e Layout
  7. ListView e RecyclerView
  8. Data Binding Library
  9. Gestione della persistenza
  10. Multithreading e servizi
  11. Sicurezza e Networking
  12. Gestione delle animazioni
  13. Location e Mappe

Sviluppare applicazioni Android con Google Play Services

La frammentazione è sempre stato uno dei principali problemi della piattaforma Android se non forse il maggiore. Ci è infatti capitato spesso di acquistare uno smartphone con una versione della piattaforma per vederlo diventare subito vecchio a causa del rilascio di una nuova release di Android che il particolare costruttore non si è preoccupato di implementare. Un importante passo verso una migliore gestione degli aggiornamenti è stata fatta attraverso l’introduzione dei Google Play Services. Si tratta sostanzialmente di quella parte della piattaforma di Android che non dipende fortemente dall’hardware e che quindi può essere aggiornata da remoto senza alcun intervento da parte dell’utente. Piano piano tutte le principali API sono state spostate da quella che possiamo chiamare piattaforma base ai Google Play Services. Stiamo parlando delle Location API, delle librerie per la gestione delle Google Map fino alle attuali API per la gestione dei dispositivi weareable. A questo argomento ho quindi dedicato il mio ultimo libro che, come quello relativo ad Android 4, segue un approccio molto pratico attraverso la realizzazione di alcuni prototipi di semplici applicazioni. Al momento si tratta dell’unico testo al mondo dedicato completamente a questo argomento. In particolare vengono trattati i seguenti argomenti:

  • Location API
  • Google Maps, Geofence e StreetView API
  • Google Drive
  • Google Plus
  • Google Cloud Messaging
  • Notification and Weareable API
  • MediaRouter e ChromeCast
  • Google Fit
  • Google Game
  • InApp Billing
  • Google Analytics
  • Google Ads

E’ importante sottolineare come gli esempi utilizzino Android Studio nella ultima versione 1.1 e soprattutto come questi siano contenuti nel seguente repository su github che cercherò, per quanto possibile, di mantenere aggiornarti con le modifiche che, visto quanto accaduto in precedenza, Google farà sicuramente. A tale proposito cercherò di creare anche un documento di errata corrige.

 

 

Update ad Android Studio 0.4.0

In questo giorni vi è stato l’ennesimo update di Android Studio ora alla versione 0.4.0. Importando il progetto come descritto in precedenza porta alla generazione di un insieme di warning ed errori che possiamo comunque risolvere velocemente. Si ha infatti la visualizzazione del seguente messaggio di errore:

Screen Shot 2014-01-02 at 09.11.56

Il primo passo consiste nell’aggiornamento delle varie librerie attraverso l’utilizzo del tool SDK Manager. Facendo un update notiamo la presenza di una nuova versione di platform tools e della support library (19.0.1). Oltre a questo abbiamo la necessità della seguente modifica nel file di gradle del progetto

buildscript {
    repositories {
        mavenCentral()
    }
    dependencies {
        classpath 'com.android.tools.build:gradle:0.7.+'
    }
}

dove la versione del tools e’ ora la 0.7.x. Questo dovrebbe risolvere il precedente problema. A questo punto riproviamo il build ottenendo il seguente messaggio di warning

Screen Shot 2014-01-02 at 09.12.38

che si risolve in modo abbastanza veloce semplicemente selezionando il primo link “Fix Gradle wrapper and re-import project”.

Ora il progetto dovrebbe essere a posto… almeno fino al prossimo aggiornamento di Android Studio.

Nota: Il progetto e’ stato aggiornato anche sul branch capitolo2 in GitHub

 

Capitolo 2 Refactoring

Github: https://github.com/massimocarli/new_ugho_application    on branch: capitolo2

Iniziamo quindi con la creazione del progetto UGHO selezionando la corrispondenza opzione nel menu File di Android Studio. Rispetto a quanto descritto nel libro ora AS ci permette di aggiungere automaticamente al progetto delle librerie aggiuntive inserendo la corrispondente definizione del file di configurazione di Gradle. Nel nostro caso (Figura 2.1) non utilizziamo questa feature utilizzando solamente il wizard per la creazione della icona e quello per la creazione della Activity principale. Notiamo poi come la versione minima di Android per la nostra applicazione sia Gingerbread ovvero la 2.3.3.

Screen Shot 2013-12-11 at 09.59.46

Figura 2.1 – Nuova Form di creazione di un Progetto con AS 0.3.7

A questo punto proseguiamo con le varie schermate attraverso la selezione del pulsante next come descritto nel testo. Una importante modifica rispetto a quanto riportato nel libro riguarda la schermata in Figura 2.2 equivalente alla figura 2.5 del testo.

Screen Shot 2013-12-11 at 10.03.49

Figura 2.2 – Creazione della Activity Principale

Qui infatti compare un nuovo campo relativo al nome del layout del Fragment che l’Activity andrà ad utilizzare. Quello di Fragment e’ un concetto molto importante che nel libro viene affrontato nel capitolo 3. Ora siamo costretti ad anticiparlo. Niente paura, vedremo quello che serve riservandoci di approfondire poi le cose più’ avanti.

Nota: Alla prima visualizzazione della preview il tool mi ha visualizzato un errore dovuto alla mancanza di un tema. E’ stato comunque sufficiente fare un refresh (passando ad altro file e tornando indietro) per risolvere automaticamente il problema.

Una volta confermata la creazione del progetto tutto quanto creato e’ analogo a quanto riportato nel testo. La struttura dei file che ottengo e’ praticamente la stessa. Degno di nota e’ invece il nuovo file di configurazione Gradle che ovviamente utilizza librerie e versioni successive a quelle del libro. Nello specifico quella da me ottenuta e’ la seguente:

buildscript {
    repositories {
        mavenCentral()
    }
    dependencies {
        classpath 'com.android.tools.build:gradle:0.6.+'
    }
}
apply plugin: 'android'

repositories {
    mavenCentral()
}

android {
    compileSdkVersion 19
    buildToolsVersion "19.0.0"

    defaultConfig {
        minSdkVersion 10
        targetSdkVersion 19
    }
    buildTypes {
        release {
            runProguard false
            proguardFile getDefaultProguardFile('proguard-android.txt')
        }
    }
    productFlavors {
        defaultFlavor {
            proguardFile 'proguard-rules.txt'
        }
    }
}

dependencies {
    compile 'com.android.support:appcompat-v7:+'
}

Come detto, a parte alcune versioni delle librerie utilizzate, notiamo la presenza delle configurazioni relative a Proguard ovvero al tool che permette allo stesso tempo di offuscare il codice (renderlo non leggibile dopo eventuale decompilazione) e di eliminare codice inutile come potrebbe essere quello relativo ai messaggi di Log nella versione di produzione della nostra applicazione.

Un’altra differenza che noto rispetto a quanto riportato nel testo e’ la mancanza di alcuni qualificatori nella definizione delle risorse. Mancano infatti le seguenti cartelle:

/res/values-v11
/res/values-v14

mentre quelle relative alle dimensioni del display sono state sostituita da una sola. A tale proposito e’ sufficiente leggere quanto riportato nella parte di descrizione delle risorse nel testo.

Quanto detto prima relativamente all’utilizzo dei Fragment ha portato alla generazione di due file di layout a differenza di quanto avvenuto con la versione relativa al testo. Si tratta di un layout per l’Activity ed uno per il Fragment che la stessa contiene. In particolare quello relativo alla Activity e’ il seguente:

<FrameLayout xmlns:android=”http://schemas.android.com/apk/res/android”
xmlns:tools=”http://schemas.android.com/tools”
android:id=”@+id/container”
android:layout_width=”match_parent”
android:layout_height=”match_parent”
tools:context=”uk.co.massimocarli.android.ugho.MainActivity”
tools:ignore=”MergeRootFrame” />

mentre quello del Fragment contenuto in essa e’ il seguente:

<RelativeLayout xmlns:android=”http://schemas.android.com/apk/res/android”
xmlns:tools=”http://schemas.android.com/tools”
android:layout_width=”match_parent”
android:layout_height=”match_parent”
android:paddingLeft=”@dimen/activity_horizontal_margin”
android:paddingRight=”@dimen/activity_horizontal_margin”
android:paddingTop=”@dimen/activity_vertical_margin”
android:paddingBottom=”@dimen/activity_vertical_margin”
tools:context=”uk.co.massimocarli.android.ugho.MainActivity$PlaceholderFragment”>

<TextView
android:text=”@string/hello_world”
android:layout_width=”wrap_content”
android:layout_height=”wrap_content” />

</RelativeLayout>

Si tratta di layout che hanno la sola particolarità di contenere alcuni elementi relativi al namespace tools. Si tratta di informazioni che vengono utilizzate da Android Studio per capire come renderizzare le preview. Ad esempio, gli attributi android:context permettono di specificare quello che e’ il componente corrispondente in modo da prendere le eventuali configurazioni relative al tema utilizzato all’interno del file di configurazione AndroidManifest.xml.

L’utilizzo dei Fragment porta anche ad una modifica del codice sorgente della Activity creata in modo automatico la quale e’ la seguente:

public class MainActivity extends ActionBarActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        if (savedInstanceState == null) {
            getSupportFragmentManager().beginTransaction()
                    .add(R.id.container, new PlaceholderFragment())
                    .commit();
        }
    }

    @Override
    public boolean onCreateOptionsMenu(Menu menu) {

        // Inflate the menu; this adds items to the action bar if it is present.
        getMenuInflater().inflate(R.menu.main, menu);
        return true;
    }

    @Override
    public boolean onOptionsItemSelected(MenuItem item) {
        // Handle action bar item clicks here. The action bar will
        // automatically handle clicks on the Home/Up button, so long
        // as you specify a parent activity in AndroidManifest.xml.
        int id = item.getItemId();
        if (id == R.id.action_settings) {
            return true;
        }
        return super.onOptionsItemSelected(item);
    }

    /**
     * A placeholder fragment containing a simple view.
     */
    public static class PlaceholderFragment extends Fragment {

        public PlaceholderFragment() {
        }

        @Override
        public View onCreateView(LayoutInflater inflater, ViewGroup container,
                Bundle savedInstanceState) {
            View rootView = inflater.inflate(R.layout.fragment_main, container, false);
            return rootView;
        }
    }

}

Per capire bene che cosa sia un Fragment rimandiamo al relativo capitolo del testo. Per il momento qui possiamo notare come ne venga definito uno attraverso la classe statica interna di nome PlaceholderFragment e di come questa venga associata all’attività che la contiene nel metodo onCreate() attraverso quello che vedremo essere il FragmentManager.

Quanto descritto nel resto del capitolo va bene anche per questa versione di AS.

Come ottenere il progetto da GitHub

Il primo passo consiste nell’eseguire il comando di clone

git clone git@github.com:massimocarli/new_ugho_application.git

Il quale crea il folder

/new_ugho_application

Per verificare il branch corrente e’ sufficiente eseguire il comando

git branch

In questo caso dovrebbe essere il branch capitolo2. Nel caso non fosse cosi’ e’ sufficiente eseguire il comando

git checkout capitolo2

A questo punto il progetto e’ presente nel vostro file system ed e’ pronto per essere importato da Android Studio. Per fare questo si utilizza l’opzione

File > Import Project

e quindi selezionare la cartella del progetto che in questo caso e’ new_ugho_application e confermare i settings di default. A questo punto il progetto e’ importato in AS.

Per non interferire con le prossime aggiunte del progetto e’ consigliabile che il lettora lavori in un proprio branch.

 

New MailOnLine Android Application Released

ic_launcherToday we released the new version of MailOnLine Android application that completely replaces the previous one. From a technical point of view this is the result of the application of many Android Development Patterns related to several aspects of a mobile application that needs to manage a huge quantity of data and in particular texts and images. For that reason we have taken care of:

  • Memory management. The huge quantity of data needed a perfect memory management in order to prevent the classical OutOfMemoryError
  • Asynchronous synchronisation of data. All the information are synchronised using the Android SyncAdapter and an our implementation of the Command Pattern based on optimized Android Services and queues. Here we had the chance to apply some of the main Concurrent Patterns.
  • Optimised persistence and Parsing. MailOnLine releases an article every 8 minutes and for that reason we needed a way to access, parse and persist a huge quantity of information in the best way possible. Algo a very good obsolete files deletion policy is in place.
  • UI Optimisation. When the data are available we needed a way to present them in the most responsive way possible. We used for that the main UI Patterns and optimisation tools available for Android

Furthermore, “don’t judge a book by its cover”. A newspaper application has not only to deal with text and images but need to manage many aspects about ADs and Tracking that get things even more complicated. For that reason we’re proud about this first version of our MailOnLine application that we’ll continue to improve.

 

Android 4 – Guida per lo Sviluppatore

Android 4 - Guida per lo sviluppatore

Android 4 – Guida per lo sviluppatore

E’ finalmente disponibile l’ultima edizione del mio libro sulla programmazione Android giunto ormai alla versione 4 della piattaforma. Al momento è disponibile in versione Kindle ma presto sarà disponibile anche in versione cartacea nelle principali librerie. A differenza della edizione dedicata ad Android 3, non si tratta di un semplice aggiornamento ma ho colto l’occasione per riscrivere il tutto quasi da zero utilizzando un approccio puramente pratico. Attraverso la realizzazione di due prototipi, ho provato a descrivere quelli che sono in concetti principali relativi allo sviluppo della maggior parte delle applicazioni Android. Si parte dal primo capitolo nel quale ho dedicato solo pochissime pagine nella descrizione di cosa sia Android (immaginando infatti che chi compra il libro già lo sapesse…) descrivendo poi tutto ciò che è necessario conoscere sul linguaggio Java che sappiamo essere il linguaggio di riferimento (anche se ora non l’unico) per lo sviluppo Android. Nel secondo capitolo si inizia quindi a parlare Android attraverso la descrizione del nuovo ambiente di sviluppo che si chiama Android Studio e che è stato presentato all’ultima Google I/O a Giugno. Tenere il passo degli strumenti che Google mette a disposizione per lo sviluppo di Android è cosa quasi impossibile; nella prima versione del libro ricordo di aver ripreso tutti gli screen shot del plugin di eclipse per 6 volte!!! Ho quindi saltato la parte di pura installazione (che si può trovare sul sito ufficiale di Android) per descrivere gli strumenti principali tra cui Gradle che è il nuovo sistema di build. In Android Studio, basato ora su IntelliJ, si è iniziato a dividere la parte di scrittura del codice da quella di build e creazione delle versioni dell’applicazione per diverse tipologie di dispositivo. Ora, a dire il vero, la definizione degli script di build rappresentano un vero e proprio lavoro 🙂 Il terzo capitolo è quindi dedicato alla descrizione della prima applicazione che si chiama UGHO (User Generate HOroscope). Si tratta di una applicazione nata da una semplice idea ovvero quella di generare un oroscopo in base a come le persone si sentono e non in base alla posizione dei vari pianeti; una specie di oroscopo al contrario. Per chi crede e per chi è dubbioso si tratta ovviamente di un esempio di applicazione che descriviamo inizialmente in quello che è il flusso di navigazione. Da qui i concetti di Activity e gestione delle varie risorse. Nel capitolo 4 iniziamo invece a parlare di Fragment per l’adattamento della nostra applicazione ai dispositivi tablet o comunque caratterizzati da display di dimensioni diverse da quelle di uno smartphone. Nel capitolo 5 descriviamo le View ovvero quei componenti che utilizziamo per riempire le varie schermate ed interagire con l’applicazione. Nel capitolo 6 vediamo delle View particolari ovvero le ListView ed il fondamentale concetto di Adapter. In questi capitoli trattiamo le basi ma ci spingiamo anche un po’ oltre attraverso la realizzazione di alcune interessanti specializzazioni di Adapter attraverso l’applicazione del famoso Design Pattern Decorator. In particolare descrivo nel dettaglio come sia possible decorare un Adapter per l’aggiunta delle sezioni che sono magari di più semplice implementazione in iOs. Il capitolo 7 è dedicato a componenti come la ActionBar ed i Menu che caratterizzano la maggior parte delle applicazioni. Con questo capitolo possiamo dire che si conclude la prima parte con la quale è possibile già realizzare alcune interessanti applicazioni. La seconda parte è comunque di fondamentale importanza in quanto tratta argomenti come quello della persistenza (capitolo 8), multithreading e servizi (capitolo 9) e sicurezza (capitolo 10). Anche in questi capitoli si da grande spazio non solo alle basi ma anche ad un utilizzo un po’ avanzato dell’ambiente. I capitoli 11 e 12 sono dedicati rispettivamente alla gestione delle animazioni e dei widget. A dire il vero non era mia intenzione inserirli ma mi sono stati espressamente richiesti dai vari lettori delle precedenti lezioni. Il capitolo 13 è dedicato alla gestione degli account e delle corrispondenti operazioni di sincronizzazione. Si tratta di aspetti molto importante nella maggior parte delle applicazioni professionali. In questa fase descrivo infatti anche come si utilizzano le API di Facebook per la registrazione ed utilizzo delle informazioni corrispondenti. Infine il capitolo 14 è dedicato alla gestione della location e delle mappe. Si tratta sicuramente del capitolo che presenta il maggior numero di novità rispetto alle versioni precedenti in quanto descrive API presentate all’ultimo Google I/O e gestite attraverso le Google Play Service.

Come detto più volte si tratta comunque di un testo dedicato a chi vuole cominciare a sviluppare applicazioni per Android ma che contiene alcuni spunti che sono sicuro essere utili anche per i più esperti. Il tutto è supportato ad moltissimi esempi oltre al codice relativo ai diversi step di creazione di UGHO che verrà presto pubblicata come applicazione sul Play Market e di cui metterò a disposizione il sorgente attraverso repository pubblico di GitHub. Il codice disponibile attraverso il testo è infatti ricco di diverse possibilità di implementazione che invece vogliamo in un certo senso “pulire” per fornirne una versione ufficiale. Quando disponibile ne darò notizia su questo sito.

A chi deciderà di acquistare il mio libro auguro buona lettura. Agli altri ricordo comunque che è possibile scaricare tutti gli esempi e sorgenti al seguente link di apogeo.

Ultima considerazione riguarda la descrizione di argomenti più specifici ed in modo più avanzato. Per questo non perdete i diversi Sushi tra cui quello dedicato a RoboGuice di prossima uscita.

Massimo Carli

 

Sushi – Creare la prima applicazione Android

Sushi – Creare la prima applicazione Android

E’ appena uscito il primo libro della serie Sushi dedicato alla programmazione Android. Si tratta del primo libretto di una serie che permette di condurre il lettore, passo dopo passo, alla realizzazione di applicazioni Android sempre piu’ complesse. L’approccio e’ molto pratico ed il codice disponibile su github. Sul sito ufficiale della serie sara’ inoltre possibile comunicare con il sottoscritto e gli altri lettori attraverso il seguente forum.

 

UI “Cast Away”

How it works

http://code.google.com/p/android-ui-inference/

Activity and Fragment implementation is one of the most important part of an Android Project. In these components we manage Views getting their reference with code like this:

TextView mTextView = (TextView)findViewById(R.id.my_testview);
Button mButton = (Button)findViewById(R.id.my_button);
EditText mEditText = (EditTExt)findViewById(R.id.my_edittext);

and so on. I found the usage of the (cast) operation so boring so I decided to create this super simple (but not obvious for non Java expert) utility class that eliminate that key-typing overhead.

So far the library contains only two methods. In the case we already have the reference to the root View, that we call containerView, the previous lines of code become:

TextView mTextView = UI.findViewById(rootView ,R.id.my_testview);
Button mButton = UI.findViewById(rootView ,R.id.my_button);
EditText mEditText = UI.findViewById(rootView ,R.id.my_edittext);

The code for this method uses Java generics:

@SuppressWarnings("unchecked")
public static <T extends View> T findViewById(View containerView, int viewId){
    // We find the view with the given Id
    View foundView = containerView.findViewById(viewId);
    // We return the View with the given cast
    return (T) foundView;
}

The process that permits us to do that is called Type Inference and is implemented with the

<T extends View> T

declaration. In this way the type of the returned object is inferred but the type of the variable we assign the result to.

The second method is:

public static <T extends View> T findViewById(Activity act, int viewId) {
    // We get the VuewGroup of the Activity
    View containerView = act.getWindow().getDecorView();
    return findViewById(containerView, viewId);
}

This overload just get the containerView from the Activity.

Other considerations

An alternative should be the usage of Roboguice that uses annotations to get View references with code like this:

public MyActivity extends RoboActivity{

    @InjectView(R.id.my_textview) private TextView mTextView;

    @InjectView(R.id.my_button) private Button mButton;

    @InjectView(R.id.my_edittext) private EditText mEditText;

    - - -

}

This is a good solution if you want to use Roboguice framework but your Activity should extend RoboActivity that can be a problem if you use other framework that do the same (ActionBarSherlock for instance).

Both Roboguice and my code have no compile type checking. If you write this code

TextView mTextView = UI.findViewById(rootView ,R.id.my_button);

and R.id.my_button is a Button, no compile error is generated but a runtime exception instead. By the way, the same happens when you write this code:

TextView mTextView = (TextView)findViewById(R.id.my_my_button);

or this:

@InjectView(R.id.my_button) private TextView mTextView;

Sito nuovo e… vita nuova

Come avrete potuto osservare ho deciso di azzerare completamente il vecchio sito attraverso una nuova installazione di WordPress. Questo non solo per un problema di sicurezza dovuto alla introduzione di codice JS dannoso da parte di qualcuno che non aveva altro di meglio da fare, ma per una vera e propria scelta di vita. Da ormai 4 mesi mi sono infatti trasferito a Londra dove gestisco un team di sviluppo di O2/Telefonica la cui responsabilità è quella di trasformare in prodotti alcuni prototipi che la divisione di R&D (che prendo il nome di The Lab) crea di continuo. Si tratta di un lavoro molto interessante che mi permette di rimanere sempre aggiornato sull’ultima tecnologia oltre che essere a contatto con persone di indubbia capacità. Ma perché questa decisione. Beh sembrerà strano ma sono venuto a Londra per stare di più con la mia famiglia. Fino a marzo la mia vita era un continuo viaggiare per tutta Europa per tenere corsi o per seguire progetti e fare consulenze. Nonostante il periodo di crisi, il lavoro era troppo oltre che troppo stressate per cui ho deciso di accettare l’offerta di O2 e di trasferirmi in UK. Dopo 3 mesi da pendolare tra Rovigo e Slough, finalmente la mia famiglia, finite ormai le scuole, mi raggiungerà a Wimbledon per iniziare una nuova vita insieme. Sicuramente non sarà facile ma le sfide non mi hanno mai spaventato. D’ora in poi utilizzerò questo sito per scrivere le mie considerazioni tecniche sui linguaggi e sistemi che, al momento, utilizzo maggiormente ovvero iOs ed Android, senza dimenticare ovviamente Java. Uno dei miei nuovi obiettivi sarà quello di perfezionare il mio inglese per cui d’ora in poi utilizzerò l’italiano principalmente nei miei libri o nelle mie osservazioni sulla Webzine di ApogeOnline. A parte il lavoro in O2, ora mi aspetta la scrittura del testo dedicato a Jelly Bean appena presentato alla Google I/O.  Ci sono novità molto interessanti per cui mettiamoci al lavoro….