Prima lezione del corso android tenuto presso il TuLug (Tuscia Lug) A Viterbo. Le slides sono completamente in italiano (Slides are in italian! Sorry!)

1. Programmazione Android
Corso Introduttivo
By IvanGualandri@Tulug

2. Cosa vedremo oggi...
● Presentazione corso, lug, e di me... :) )
● Breve introduzione su Android
● Installazione dell'ambiente di sviluppo
● Da cosa é composto l'SDK android
● Le componenti di un applicazione android
(manifest, activity, layout)

3. System requirements...
● Per fruire al meglio di questo corso conviene
avere almeno qualche competenza base di
java.
● Un portatile (spero ve lo siate portato...)
● Un device android, se ce l'avete! Altrimenti si
usa l'emulatore

4. Presentazione
● Il TuLug é un associazione nata su base
volontaria, con l'intento di diffondere linux e
l'open source nella tuscia
● Se siete appassionati di linux probabilmente ci
avrete gia visto ai vari Linux Day che oramai si
tengono annualmente presso la provincia di
Viterbo (si li organizziamo noi :D)
● In quanto associazione volontaria non ci
finanzia nessuno, ci autofinanziamo...
● In quanto a me, beh sono un nerd full time, e
nel tempo libero faccio il programmatore!

5. About me
● Ovvero... un pò di spam :)
● beh sono un nerd full time, e nel tempo libero
faccio il programmatore!
● In generale amo la programmazione (C,C++,
Java un pò meno :P), linux e l'osdev :D
● Gestisco un blog sul mondo linux: http://www.
italialinux.com
● Su twitter mi trovate come @IvanGualandri
oppure come @Italialinux
● Anche su facebook trovate la pagina del sito
Italialinux

6. Iniziamo...
● Android è un SO per smartphone (e non
solo) nato nel 2003.
● Il primo smartphone android è stato
commercializzato solo nel 2008
● È un sistema operativo che si poggia sul
kernel linux
● all'interno del quale gira una macchina
virtuale java: la dalvikVm

7. Giusto per curiositá...

8. Ambiente di sviluppo
● Le applicazioni android si scrivono
principalmente in java (tranne alcuni
rarissimi casi in cui potrebbe servirvi di usare
componenti native in c++)
● L'ide di riferimento ad oggi è Eclipse (anche
se nel futuro passeranno ad Intellij),
● L'SDK android si può installare o come
plugin di eclipse, oppure scaricare il
pacchetto bundle che contiene una versione
di eclipse configurata appositamente per lo
scopo.

9. Ambiente di sviluppo
● Noi per comoditá useremo il pacchetto
bundle disponibile sul sito:
http://developer.android.com/sdk/index.html
● L'installazione è estremamente semplice,
una volta scaricato il pacchetto vi basta
scompattarlo in una cartella a vostro
piacimento...

10. L'SDK Android - Cosa fornisce
L'Ambiente di sviluppo android oltre all'sdk,
fornisce le seguenti componenti:
1. L'ADB che è l'interfaccia fra la nostra
macchina e il sistema operativo android
2. L'SDK Manager, una specie di gestore
pacchetti per i vari compnenti del sdk
3. L'AVD manager, ovvero
crazione/gestione/avvio degli emulatori...

11. L'SDK Manager
Si tratta di uno strumento che consenete di
gestire l'installazione delle varie versioni
dell'sdk, e alcune componenti aggiuntive (come
per esempio l'inapp billing, le librerie di
compatibilitá, etc).
Permette inoltre di installare diverse tipologie di
emulatori

12. L'SDK Manager

13. L'AVD Manager
Con questo strumento possiamo creare,
modificare, e gestire i vari emulatori per testare
le nostre applicazioni, senza dover utilizzare
continuamente un device fisico.

14. L'AVD Manager

15. L'ADB
ADB sta Android Debug Bridge, ed è lo
strumento che ci consente di effettuare il debug
delle nostre applicazioni e non solo. È anche
una interfaccia per gestire alcune componenti
del sistema da linea di comando...
Alcuni comandi:
adb devices
adb shell

16. L'ADB
Ecco alcuni esempi di comandi emessi con ADB

17. La prima applicazione android

18. Creazione del progetto...

19. Qualche modulo da compilare... :)
Application Name:
Il nome che vogliamo
dare all'applicazione
Project Name:
Il nome del progetto
Package Name: il package
che conterrá l'applicazione
continua...

20. Qualche modulo da compilare/2
Minimum required SDK: La versione minima
del sdk necessaria per far girare l'applicazione
(ogni versione android ha la sua versione di
SDK)
Target SDK: Versione di riferimento del SDK
per il quale compilare l'applicazione (attenzione
alla differenza)
Compile with: Versione del SDK con il quale
effettivamente compilare l'app (uff che
confusione)
Theme: il tema decorativo dell'app.

21. Qualche modulo da compilare/3
Le schermate successive richiedono
informazioni principalmente di carattere grafico,
per esempio cosa mettere nell'activity di che
viene creata automaticamente, se creare o
meno un seti di icone per l'applicazione, se
marcare questo progetto come libreria, etc..., il
nome dell'activity che viene creata e il nome del
layout che utilizzerá.

22. Piacere, sono una app android!
Cerchiamo di capire come è
strutturato un progetto android e
cosa contengono le cartelle:
● /src - Contiene i sorgenti
dell'applicazione
● /gen - Contiene alcuni file
generati automaticamente dal
sdk.
● /res - Contiene le risorse
dell'applicazione immagini,
layout, stringhe, etc.
● /assets per altri tipi di files, non
direttamente legati all'app.

23. E finalmente l'hello world, o quasi...
● Se espandiamo la cartella src, questa
contiene il package che abbiamo dichiarato
in fase di creazione del progetto, ora
espandete tutti i livelli, e vi troverete un file
java, che se non gli avete cambiato nome si
chiamerá MainActivity.java

24. E finalmente l'hello world, o quasi...
public class MainActivity extends Activity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
TextView label = (TextView) findViewById(R.id.label);
label.setText(R.string.app_name);
}
@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;
}
}

25. Oddio ma che roba è?
Probabilmente a guardare quel pezzo di codice
vi sará sorta qualche domanda del tipo:
● Ma dove é il main?
● Cosa è un Activity?
● Ma dove sta l'hello world?
● onCreate? onCreateOptionsmenu? cosa
fanno?
● Chi decide che questa classe è quella che
viene lanciata?

26. Passi di bimbo - L'activity
● Si tratta di uno dei componenti fondamentali
di un applicazione.
● Possiamo immaginare un activity come una
singola finestra di un applicazione, con
anche la logica di controllo
● Un applicazione può avere più Activity
● Possono avere diversi stati

27. Gli stati di un Activity
Gli stati che può assumere un activity sono:
1. active/running
2. paused - l'activity è passata in secondo
piano, ma è ancora attiva
3. stopped - passa in secondo piano, e viene
oscurata da un altra activity (mantiene
ancora le informazioni di stato)
4. destroyed - Un activity in questo stato
potrebbe venir terminata dal sistema, in
questo caso bisogna ricrearla, e ripristinarla.

28. Il ciclo di vita dell'activity

29. Il ciclo di vita dell'Activity/2
La figura nella slide precedente mostra la
sequenza di stati che può avere un activity, e i
metodi che vengono chiamati dal sistema
durante le fasi di transizione.
Nella slide successiva ne spiegheremo alcuni.

30. Il ciclo di vita dell'Activity/3
● onCreate() - Il primo metodo ad essere
chiamato, diciamo il main del mondo android
● onStart() - Viene chiamato quando l'activity
diventa visibile all'utente
● onPause() - Viene chiamata quando il
sistema sta per avviare o riprendere un altra
activity,
● onDestroy() - L'ultima chiamata che viene
effettuata prima che l'Activity venga
definitivamente distrutta. Se resta qualcosa
da fare, fatela ora o è troppo tardi!

31. Il metodo onCreate()
É il primo metodo che viene chiamato dal
sistema quando lancia un activity.
Normalmente si occupa di caricare l'interfaccia
grafica contenuta nei files del layout,
inizializzare eventuali risorse per l'applicazione,
associare azioni alle componenti dell'interfaccia
grafica, etc.

32. Il metodo onCreate()/2
Vediamo il metodo onCreate del nostro
esempio:
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
...
}
L'oggetto Bundle contiene eventuali valori
salvati precedentemente (per esempio nei
metodi onPause,onStop etc).

33. Il metodo onCreate()/3
● Il metodo
setContentView(int resourceId)
serve ad indicare al sistema quale risorsa del
layout caricare. Nel nostro esempio si tratta di:
R.layout.activity_main
● Tutti i file del layout vengono messi
all'interno della cartella /res/layout* del
nostro progetto.
● I layout sono specificati mediante file xml
oppure direttamente via codice.

34. Il metodo onCreate()/4
● Per poter interagire con i componenti
dell'interfaccia grafica definiti nel layout, la
chiamata setContentView è fondamentale, in
quanto così carica tutti i riferimenti alle
risorse utilizzate nell'interfaccia grafica.
Altrimenti riceveremo tante
NullPointerException.

35. Una parolina su R.layout.
● Per accedere al layout abbiamo identificato
la risorsa con R.layout.activity_main
Spieghiamo di cosa si tratta
● R è una delle classi generate dal sdk
android e inserita in gen
● Contiene i riferimenti a tutte le risorse
dell'applicazione (layout, stringhe,
componenti della gui, immagini, etc.)
● activity_main in questo caso è il nome del
file xml che contiene il layout.

36. Il metodo onCreate()/5
● Dopo aver settato il layout, possiamo
accedere anche ai suoi componenti.
● Il metodo findViewById, ci torna l'oggetto
definito nel layout a partire dal suo id
(reprebile tramite la classe R.id...)
● Tutti i componenti grafici estendono la
classe View, da qui il nome.
● É importante castare la View tornata da
questo metodo.

37. Il metodo onCreate()/6
● Nel nostro caso abbiamo usato findViewById per
accedere a una TextView, che identifica un oggetto
simile a un etichetta di testo.
TextView label = (TextView) findViewById(R.id.label);
● Ovviamente ogni componente dell'interfaccia
grafica avrá i suoi metodi specializzati per il loro
scopo. Per esempio una TextView avrá
sicuramente un metodo setText, usiamolo per
aggiornarne il testo:
label.setText(R.string.app_name);
● Le stringhe si trovano nel file strings.xml in
/res/values.

38. Ma come è definito il layout?
<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:paddingBottom="@dimen/activity_vertical_margin"
android:paddingLeft="@dimen/activity_horizontal_margin"
android:paddingRight="@dimen/activity_horizontal_margin"
android:paddingTop="@dimen/activity_vertical_margin"
tools:context=".MainActivity" >
<TextView
android:id="@+id/label"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="@string/hello_world" />
</RelativeLayout>

39. Ma come è definito il layout?/2
● Nel nostro caso si tratta di un layout estremamente
semplice.
● Partiamo subito da quello che forse potremo aver
gia riconosciuto, la TextView.
<TextView
android:id="@+id/label"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="@string/hello_world" />
● Con questo pezzo di codice abbiamo inserito nel
nostro layout un oggetto di tipo TextView,
identificato come label (l'attributo android:id, viene
usato dalla classe R)

40. Ma come è definito il layout?/2
● Gli oggetti che definiamo per essere utilizzati con la
findViewById devono avere un attributo id
specificato.
● L'attributo android:text invece contiene il testo che
verrá mostrato dalla TextView (possiamo usare sia
una stringa, che una risorsa).
● La TextView come potete vedere è definita
all'interno del tag <RelativeLayout ...
></RelativeLayout>
● Questi indicano il tipo di struttura del layout che
vogliamo per la nostra gui (ce ne sono diversi:
AbsoluteLayout,LinearLayout,TableLayout, etc...)

41. Un aiuto da android per i layout

42. Ed infine: il Manifest
● É il manuale di istruzioni per il sistema della nostra
applicazione
● Contiene le informazioni necessarie al sistema per
identificare, lanciare, gestire l'applicazione.
● Per esempio all'interno del manifest vengono
dichiarati i permessi di cui l'applicazione ha bisogno
per girare.
● Specifichiamo quali sono le Activity che la
compongono.
● Su quali versioni di android deve girare...
● Ci sono informazioni di versione, nome, e molto
altro

43. Ed infine: il Manifest<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
package="org.tulug.androidtulugapp"
android:versionCode="1"
android:versionName="1.0" >
<uses-sdk
android:minSdkVersion="8"
android:targetSdkVersion="17" />
<application
android:allowBackup="true"
android:icon="@drawable/ic_launcher"
android:label="@string/app_name"
android:theme="@style/AppTheme" >
<activity
android:name="org.tulug.androidtulugapp.MainActivity"
android:label="@string/app_name" >
<intent-filter>
<action android:name="android.intent.action.MAIN" />
<category android:name="android.intent.category.LAUNCHER" />
</intent-filter>
</activity>
</application>

44. Fine prima lezione
● Grazie per l'attenzione!
Ivan Gualandri!