Android Code Camp 2012 - ita

Android Code Camp, Urbino — 2012.

Benvenuti.

Android
Code Camp


Scaletta day 1.
Il mercato degli smartphone.
Il progetto Android.
L‘architettura di Android.
L‘ecosistema.
Panoramica delle applicazioni.
Struttura di un progetto Android.
Setup dell‗ambiente di sviluppo (prova pratica).
„Hello World.―


Mobile market.

Numeri e crescita.
Il mercato di Android.
Attivazioni.
Il mercato delle applicazioni.
Frammentazione.


433 milioni di unità nel 2011.
616 milioni di unità previste nel 2012.

• Crescita del mercato (contrazione del
mercato dei feature phones).
• Obsolescenza del prodotto.

Tablet: 320 milioni di unità previste, 2015.


2011
2.5 3.9

18.3

50.8

12.5

20.4

Android iOS BlackBerry Symbian Windows Phone Altri


2012
5.4 3.6
6.8
7.4

26

104.8

Android iOS BlackBerry Symbian Windows Phone Altri


Il mercato di Android.
Crescita vertiginosa (+106% previsto).

Principalmente device Samsung (33%).

2012:
500 milioni di dispositivi Android attivati.
1.3 milioni di attivazioni al giorno.


Android < iOS:
Più di 400.000 applicazioni,
contro 500.000 per iOS.

• Google Play
• Amazon AppStore for Android
• Altri: GetJar, AppBrain, etc.


Android < iOS:
Solo ¼ del guadagno in media.
Segmento di mercato diverso.

Quasi il 70% delle applicazioni sono
gratuite o seguono il modello
freemium (contro 50% iOS).

―Frammentazione‖.


Frammentazione.


Android.
Il progetto dell‘OS mobile Google.

Storia.
Versioni ed evoluzione.
Il progetto open-source.


La storia di Android.
2003: Andy Rubin fonda ―Android Inc‖.
“...smarter mobile devices that are more aware of
its owner's location and preferences.”

2004: Apple avvia ―Project Purple‖,
un progetto segreto con AT&T.

2005: Google acquisisce Android Inc e
continua lo sviluppo del sistema.


La Storia di Android.
2007, jan: Apple rilascia il primo iPhone.

2007, nov: Google, HTC, Samsung
rivelano
l‘Open Handset Alliance e Android.

2008: primo telefono Android:
HTC Dream (G1).


Versioni di Android.
Anno Versione Nome in codice
2008 1.0 n/a
2009 1.1 Petit Four
1.5 Cupcake
1.6 Donut
2.0 Eclair
2010 2.2 Froyo (Frozen Yogurt)
2.3 Gingerbread
2011 3.0 Honeycomb
4.0 Ice Cream Sandwich
2012 4.1 Jelly Bean
? 4.2 K…?



1.5
Soft keyboard, clipboard,
video…

1.6
Resolution independence

2.0
Maps,
Navigation


3.0
Stile digitale, tablet optimization

4.0
Halo theme, Project Butter
Google Now, Roboto


Android: progetto open source.
Ottobre 2010, Steve Jobs:

„Google likes to characterize
Android as open and iOS as
closed. We think this is
disingenuous. […] The real
difference is integrated
versus fragmented.”


Il codice di Android è disponibile sotto
licenze „free― e „open source―.

Linux kernel (Open Handset Alliance):
GNU GPL v2, pubblico.

Android system (Google):
Rete, telefonia, market, apps.
Apache License v2.0, privato.


Produzione di un „flagship phone― da parte
di Google (Nexus), seguito da rilascio del
codice (OEM).

Google Play disponibile solo su licenza.

„Honeycomb incident― (2011).

Licenza incompatibile con GPL (FSF).


L’architettura..
Architettura del sistema operativo.

Kernel Linux.
Librerie native.
Runtime Android.
Virtual Machine Dalvik.
Core Libraries.
Application framework.
Livello applicazioni.


L’architettura.


Kernel Linux.
Kernel 2.6+.

Utilizzato per la gestione dei processi e dei
thread, per la gestione a basso livello della
memoria, per lo stack di rete, per la
sicurezza, per il modello dei driver.


Librerie native.
Librerie C/C++ eseguite sopra al kernel
Linux ed utilizzate in diversi ambiti dal
sistema Android.

Espongono inoltre funzionalità agli
sviluppatori tramite l'application
framework.


Runtime Android.
Ciò che rende un dispositivo Android
diverso da un'implementazione mobile
Linux.

Tramite l'utilizzo combinato della Dalvik
Virtual Machine e delle Core Libraries
rende possibile il funzionamento delle
applicazioni Android.


Virtual machine.
Implementazione software di una
macchina (con un certo Instruction Set
Architecture) che esegue programmi come
una macchina reale.

Virtualization: simulazione di un ambiente
in cui Guest ISA e Host ISA sono gli stessi.

Emulation: simulazione di un ambiente in
cui Guest ISA e Host ISA sono diversi.


Java virtual machine.
Macchina virtuale che esegue programmi
scritti in byte-code: rappresentazione
intermedia tra il linguaggio macchina e il
codice sorgente Java.

JVM è una specifica di Oracle (ex Sun).

Principali implementazioni:
HotSpot – OpenJDK (GPL).
HotSpot – OracleJDK.


Dalvik virtual machine.
Macchina virtuale che esegue file .dex
(Dalvik Executable).

Sorgente Java compilato in file .class e
trasformato in formato .dex.

Ogni applicazione Android viene eseguita
in un processo separato con la propria
istanza della Dalvik virtual machine.

JIT compiler (versione 2.2).


Dalvik vs. JVM.
Dalvik < JVM.
Ma il problema è multidimensionale.

• Register-based.
• Efficiente con più VMs.
• Footprint
minimo
in memoria.
• Startup
time ridotto.


Core libraries.
Dalvik non rispetta la specifica J2SE,
né quella J2ME.

Le core libraries forniscono la maggior
parte delle funzionalità disponibili nelle
librerie Java standard, così come librerie
specifiche per Android.


Application framework.
Fornisce servizi importanti, incapsulati in
oggetti Java, alle applicazioni di livello
sovrastante.

Sono disponibili alla stessa maniera sia
per applicazioni di sistema che per
applicazioni di terze parti.


Livello applicazioni.
Applicazioni a livello utente scritte in
linguaggio Java.

App di sistema
=
App terze parti


L’ecosistema.
Ecosistema di sviluppo.

Android SDK.
Eclipse IDE.
Application Programming Interfaces.


SDK: emulatore.
Software che emula il funzionamento e
l‗aspetto di una configurazione hardware
virtuale (AVD: Android Virtual Device).


SDK: emulatore.
Interfaccia user-friendly per la
configurazione dei propri AVD.


SDK: tools.
Logcat: raccoglie log di un device Android.

Lint: analisi statica per ottimizzazione e
rilevazione errori comuni.

Proguard: riduce la dimensione, ottimizza
ed offusca il codice prodotto. Lo rende più
rapido e resistente al reverse engineering.


SDK: Dalvik Debug Monitor Serve
Strumento per il debug di dispositivi
Android, con raccolta di informazioni su
processi, thread, heap, logcat ed
emulazione di eventi.


SDK: Android Developer Tools.
Plugin per IDE Eclipse.
Semplifica creazione, compilazione e
mantenimento di progetti.
Integra tool di sviluppo.
Include editor grafici e documentazione.


Eclipse.
Ambiente di sviluppo
open-source,
multi-piattaforma e
multi-linguaggio.

È la piattaforma di
riferimento per Android.

Alternative:
ANT, NetBeans…


Android APIs.


Android 1.5, API 3.
Riproduzione e cattura audio/video.
Riconoscimento vocale.
Widget.
Notifiche.
WebView.


Android 1.6, API 4.
Gestures.

Sintesi vocale.

Supporto CDMA.

Supporto per dimensioni e densità di
schermi variabili.


Android 2.1, API 7.
Supporto Bluetooth 2.1.

Live Wallpapers.


Android 2.2, API 8.
JIT compiler.

Supporto installazione in SD card.
Miglioramento del riconoscimento vocale
ed apertura a terze parti.
Supporto alla tecnologia Flash.


Android 2.3, API 9/10.
Supporto nativo a Voip (SIP).

Supporto a NFC.

Garbage Collector concorrente.

Supporto ad altri formati multimediali.


Android 3.0, API 11.
Fragments.

ActionBar.

Nuove API per il drag and drop.

Supporto per l'accelerazione hardware 2D.

Nuovo framework 3D renderscript.

Supporto multimediale migliorato.


Android 3.1, API 12.
Supporto a periferiche USB.

Widget ridimensionabili.

Supporto multimediale migliorato.


Android 4.0.1, API 14.
Merge tra versione tablet e smartphone.
Linux kernel 3.x.
UI riprogettata per maggior coerenza ed
unificazione.
Notifiche più potenti.
Supporto per riconoscimento vocale
continuo.
API sociali.
API di basso livello per lo streaming.


Android 4.1.3, API 16.
Project Butter.
Notifiche espandibili.
Social API migliorate.
Riconoscimento vocale avanzato.
Sintesi vocale migliorata.
Google Now.
Abbandono ufficiale della tecnologia Flash.


Panoramica applicazioni.
Elementi principali di un app.

Activity.
Service.
Content provider.
Broadcast receiver.
Intent.
Widget.
Fragment.
Notification.


Activity.
Ogni activity rappresenta una schermata di
un‘applicazione.


Activity.
Ogni activity dovrebbe equivalere ad
un'attività atomica dell'utente.


Activity.
Possono avere un valore di ritorno.


Activity.

Poi ci ritorniamo…


Service.
Un‘attività dell'app o del sistema invisibile
all'utente (gira in background).

Alcuni esempi:
Raccoglie dati del sistema.
Aggiorna le informazioni di una
particolare app.
Scarica nuovi feed RSS da un server.


Service.
Non comunica direttamente con l‘utente
ma può comunicare con le activity (anche
di altre app) e con il sistema.


Service.
Se fondamentali per un‘applicazione posso
essere istanziati come foreground service.


Content provider.
• È un‘astrazione di insiemi di dati
strutturati.
• Espone metodi CRUD (create, retrieve,
update, and delete).
• Usato per condividere dati ad altre
applicazioni o per gestirli privatamente.

Android ne mette a disposizione molti già
pronti e se ne possono implementare di
personalizzati.


Content provider.
Alcuni esempi di content provider:

• Lista dei contatti.
• Lista delle immagini sul dispositivo.
• Dati che risiedono in un DB SQLite.
• Dati che risiedono su un web service.


Broadcast receiver.
Sistema per la comunicazione
intra-applicazione/intra-processo.

Un componente a cui è delegata la
ricezione di intent in broadcast…


Intent.
Costituiscono il sistema di messaggistica
fra i vari componenti del sistema.

Ogni intent è una struttura dati che
incapsula dati. Questi dati costituiscono
una astrazione di:
Un‘operazione da eseguire.
Un evento che si è appena verificato.


Intent.
Dati di esempio:
Campo Valore
Component name it.uniurb.codecamp.test
Action ACTION_CALL
Data
URI tel:07224475
Type integer
Category CATEGORY_LAUNCHER
Extras "tel_number":int
Flags FLAG_ACTIVITY_SINGLE_TOP


Intent.
Inviare un‗immagine:
Campo Valore
Action SEND
Data content://media/external/pic16

Visualizzare un punto su Google Maps:
Campo Valore
Action VIEW
Data geo:latitude,longitude?z=zoom


Intent.
Il mittente è sempre noto mentre il
ricevente può non esserlo a priori.


Intent espliciti.
Il nome (la classe) del componente
destinatario è specificato.
Solo Activity.
Solo Activity nel proprio contesto.


Intent impliciti.
Android cerca il componente per noi:
Se ne trova uno, lo attiva.

Se ne trova più di uno,
viene chiesto all‘utente quale
scegliere.

Se non ne trova nessuno,
l'avvio fallisce


Impliciti intent resolution.
In base al tipo del componente.
(Activity, Service, Broadcast receiver).

In base al campo ACTION.

In base al campo CATEGORY.

In base al campo DATA (URI e Type).


Broadcast receiver (reprise).
Un componente a cui è delegata la
ricezione di intent in broadcast.
Può essere/non essere associato ad un
altro componente.
Non possiede una interfaccia grafica.
Può istanziare notifiche.
Può avviare un altro componente.


Broadcast receiver (esempi).
Ricezione dei cambiamenti nel livello di
carica della batteria del dispositivo.

Ricezione dell‘evento download del file
completato.

Ricezione dell‘evento boot completato e
conseguente avvio di un servizio in
background.


Widget.
Inglobati in altre applicazioni. (Risiedono
all‘interno di ―App Widget Host‖.)

Periodi di aggiornamento lunghi.
(Minimo: 30 minuti.)

Ricevono input dall‘utente e aggiornamenti
tramite un Broadcast Receiver (che
devono implementare).


Esempi di widget.


Fragment.
Componenti modulari di un‘activity.

Hanno un proprio ciclo di vita.

Possono essere rimossi o aggiunti mentre
l‘activity è attiva.

Nascono come risposta all‘esigenza di
mettere un‘activity dentro un‘altra.


Esempio di fragment.

Portrait Landscape


Notification.
Servono per informare l‘utente di un
evento scatenato o avvenuto:
Nel sistema.

Nell‘activity con cui l‘utente sta
interagendo.

Nei componenti senza interfaccia.
(Come i servizi.)


Toast notification.
Per eventi avvenuti in background.
Nessun input dall‘utente.
Poco più che un output su console…


Dialog notification.
Per eventi relativi all‘activity corrente.
(Caricamento, conferma, etc…)

Supportano l‘input utente.


Status notification.
Per eventi relativi avvenuti in background.
Richiedono l‘input utente.
Sono persistenti.
Tipicamente risiedono nella barra delle
notifiche finché l‘utente non interagisce
cliccandoci o cancellandole.

Al click spesso viene
lanciata un‘activity.


Approfondimenti.
Altri dettagli sulle applicazioni.

Layout.
Il back stack di navigazione.
Ciclo di vita delle Activity.
Ciclo di vita dei Service.
Ciclo di vita dei Fragment.


Layout.
Composta genericamente da
View e ViewGroup (e Fragment).

TableLayout

EditText

TextView

Button


Layout.
Il layout è definito (normalmente) tramite
un file xml.
<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" >

<TextView
android:id="@+id/rss_title"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
… />

<ListView
android:id="@+id/rss_list"
android:layout_width="match_parent"
android:layout_height="wrap_content"
…>
</ListView>

<Button
android:id="@+id/load"
android:layout_width="wrap_content"
… />

</RelativeLayout>


Ogni activity appartiene ad un task.
Ogni task contiene una collezione di
activity nell‘ordine in cui sono state lanciate
(back stack).


Il sistema gestisce contemporaneamente
più task ma solo uno per volta è quello in
foreground.

Un nuovo task inizia ogni volta che
un‘applicazione è avviata dal launcher:
<action android:name="android.intent.action.MAIN" />
<category android:name="android.intent.category.LAUNCHER" />

oppure con le modalità di lancio.


La struttura di un task viene alterata:
• Lanciando una nuova activity (crescita).
• Tasto Back (decrescita).

Lo stato di un task (back/fore) cambia:
• C‘è un‘interruzione per eventi esterni.
• Tasto home.
• Avvio di un‘activity dal menu delle
activity recenti.


Modalità di lancio.
Normalmente:
• Quando viene avviata un‘activity per la
prima volta questa viene aggiunta al
task attuale (oppure ad un task vuoto
se MAIN/LAUNCHER).
• Anche se la stessa
activity era già stata
lanciata ne viene
creata una nuova
istanza.


Le activity posso essere lanciate con
modalità di lancio particolari.
Definite nel manifest o nell‘intent di lancio.
Modalità Conseguenze
Default Viene creata una nuova activity. Istanze diverse della stessa
possono appartenere a diversi task. Ogni task può avere più
istanze della stessa.
SingleTop Viene creata una nuova istanza solo se l‘activity non è al top dello
stack (onNewIntent()). Il resto come Default.
SingleTask Se c‘è già un‘istanza in un task viene riavviata quella altrimenti
viene avviata una nuova activity in un nuovo task. Può esserci
sempre solo un‘istanza dell‘activity nel sistema.
SingleInstance Come sopra ma l‘activity è sempre l‘unica presente nel suo task.


DEMO…


Salvataggio dello stato dell‘activity.


Un‘activity può essere distrutta dal sistema
per recuperare memoria MA l‘utente si
aspetta di ritrovare l‘activity nello stesso
stato.
onSaveInstanceState(Bundle)
onRestoreInstanceState(Bundle)
onCreate(Bundle)


Ciclo di vita (Esempi).
Rotazione dello schermo quando c‘è una
ListView caricata con dati remoti.

Quando sono chiamati?
onRestoreInstanceState() subito
dopo onStart(),
onSaveInstanceState() prima di
onStop() e forse prima di onPause().
Non ci sono garanzie che venga
effettivamente chiamato (es: back button)!


Ciclo di vita (Esempi).
Cosa salvare nel Bundle?
Lo stato transitorio dell‘activity.
Lo stato dell‘interfaccia (lo stato
grafico di ogni View viene salvato in
ogni caso).
Cosa non salvare nel Bundle?
Le informazioni non strettamente
relative a quell‘istanza dell‘activity.
Le info persistenti dovrebbero essere
registrate nel metodo onPause().


Started & bound services.
Started:
Avviato da un altro componente
invocando startService().
Viene terminato o termina da solo.

Bound:
Avviato da 1+ componenti
invocando bindService().
Sopravvive fino all‗ultimo
unbindService().


Ciclo di vita dei Service.


Ciclo di vita dei Fragment.


Un progetto Android.
Struttura del progetto in Eclipse.

Cartelle.
Gestione delle risorse.
Manifest dell‗applicazione.


Cartelle di un progetto Android.
/src: sorgenti Java (oppure .aidl o altri)
/bin: compilati (.apk, ecc…)
/libs: librerie esterne
/gen: sorgenti generati (R.java)
/assets: risorse unmanaged (nel .apk)
/res: risorse managed (processati)
/AndroidManifest.xml: metadati
.properties, .cfg, .xml: altri files


Android Asset Packaging Tool.
Ad ogni risorsa all‗interno della directory
/res viene assegnato un ID intero.
Si genera una classe R.java con:
Una classe public static final per ogni
tipo di risorsa.
Un campo intero con il nome risorsa.

La classe viene compilata nel namespace.
Mappa <nome, ID intero>.


Versioni delle risorse.
Le versioni sono caratterizzate dal nome
della directory in cui sono locate.
• layout-long
• anim-v14
• drawable-en-rUS-land-night-notouch
Lingua in inglese, in America, orientato
orizzontalmente, è notte e non si dispone
di interfaccia touch.

Risorsa scelta a runtime dal framework.


Creazione delle risorse.
Dichiarazione tramite XML:
<Button android:id=" @+id/nice_button " />
<string name=―hello_world‖> ciao mondo</string>

I file vengono creati nelle specifiche
sotto-directory di /res.


Accesso alle risorse.
Tramite XML:
@[<package_name>:]<resource_type>/<resource_name>

<Button android:text=" @string/hello_world " />

Tramite codice:
[<package_name>.]R.<resource_type>.<resource_name>

ImageView imageView = (ImageView)
findViewById(R.id.myimageview);
imageView.setImageResource(R.drawable.myimage);


Manifest dell‘applicazione.
File AndroidManifest.xml nella root.

Descrive l‗applicazione, il nome del
package, il namespace, i permessi.
Dichiara che livello di API è richiesto.

Include la specifica di ogni componente:
Activity, Service, Receiver, etc.


Tutorial.
Hello World in tutte le salse.

Preparazione dell‗ambiente di lavoro.
Creazione di un progetto.
„Hello World― sul log.
Layouts, callbacks e toast notifications.
Intent e navigazione.
Liste.
Status notifications.
Background service.


Preparazione dell‘ambiente.
Eclipse IDE.
Aggiungiamo l‗Android ADT:
https://dl-ssl.google.com/android/eclipse/

Dopodiché scarichiamo l‗SDK.

…possiamo iniziare!


Creazione di un progetto.


Android log.
Classe android.util.Log.

Livelli di logging:
ASSERT: Log.wtf()
ERROR: Log.e()
WARN: Log.w()
INFO: Log.i()
DEBUG: Log.d()
VERBOSE: Log.v()


Per ogni chiamata al logger si passano:
TAG: discriminatore.
Messaggio: contenuto.
Eccezione: opzionale.


Layout.
Permettono di strutturare l‗interfaccia
grafica di un‗applicazione.

Flessibili e dinamici.

LinearLayout.
RelativeLayout.
FrameLayout.


LinearLayout.
<LinearLayout
android:layout_width=„match_parent“
android:layout_height=„match_parent“
android:orientation=„horizontal“
>
<Item1 />
<Item2 />
<Item3 />
</LinearLayout>


RelativeLayout.
<RelativeLayout>
<Item1 />
<Item2 layout_below=„Item1“
layout_alignParentLeft=„true“ />
<Item3 layout_below=„Item1“
layout_alignParentRight=„true“ />
</RelativeLayout>


Button e callback.
<Button android:id=„@+id/buttonToast“ />

Button button = (Button)
this.findViewById(R.id.buttonToast);

button.setOnClickListener(
new OnClickListener(){

@Override
public void onClick(View arg0) {
}
});


Toast notification.
Create tramite metodo statico.

Toast.makeText(Context,
“Text”,
Toast.LENGTH_SHORT).show();

Testo visualizzato in sovraimpressione per
la durata specificata.


Intent implicito.
Intent i = new Intent(
Intent.ACTION_VIEW,
Uri.parse("http://www.google.com"));
Context.startActivity(i);

Si sfrutta l‗intent ACTION_VIEW, definito dal
sistema.

Viene gestito dal browser (in questo caso).


Intent esplicito.
Intent i = new Intent(
Context,
Class);
Context.startActivity(i);

Intent diretto in maniera specifica ad una
classe in particolare (una Activity).

Non viene intercettata, né risolta dal
sistema.


Liste.
La lista è visualizzata da una ListView.

I dati sono gestiti da un ListAdapter:
Gestisce l‗accesso ai dati.
Ne determina la rappresentazione.


Componenti di una notifica.
Icona (nella barra e nel pannello).
Ticker (messaggio nella barra).
Numero in sovraimpressione.
Flags (AUTO_CANCEL, INSISTENT, etc).
Content view (nel pannello),
può essere generato (LatestEvent).
PendingIntent che determina azione.
Identificatore univoco.


Aggiornamento notifiche.
Il pannello mostra una sola notifica per
ogni identificatore univoco.
Permette di avere una singola notifica per
ogni tipologia di avviso dell‗applicazione.

I PendingIntent possono essere
aggiornati dall‗applicazione (modifica
azione, ma non la notifica).


Background service.
Si utilizza un Intent per specificare il
maniera esplicita il servizio da avviare.

Intent serviceIntent = new Intent(
Context, Service.class);

Context.startService(serviceIntent);

Android Code Camp 2012 - ita

Empfohlen

Empfohlen

Weitere ähnliche Inhalte

Andere mochten auch

Andere mochten auch (11)

Ähnlich wie Android Code Camp 2012 - ita

Ähnlich wie Android Code Camp 2012 - ita (20)

Kürzlich hochgeladen

Kürzlich hochgeladen (18)

Android Code Camp 2012 - ita

Hinweis der Redaktion