Struttura cartelle progetto

src
–  file sorgenti
•  gen
–  file generati automaticamente
• Librerie Android
•  assets
–  Assets, es. assets/fonts/…
•  bin
–  file da istallare sul target device
•  libs
–  librerie esterne
•  res
–  resources (file di layout, immagini, suoni,ecc.)
•  AndroidManifest.xml
– informazioni sull’app :   permessi ,  amvità, icona
•  proguard-project.text
– per il tool ProGuard: compatta, ommizza e offusca il codice sorgente (protezione)
•  project.properUes
– specifica alcune proprietà dell’app

Il file manifest.xml contiene molte informazioni riguardante l app come :

il nome dell activity
il path dell'icona
il codice della versione
la versione minima del sdk
la main activity
i nomi delle altre atctivity che possono essere lanciate
i permessi richiesti

EMULATORE

Real device :
veloce, facile gestie l’input (es. rotazioni display)
l’esecuzione è reale

Emulatore :
 lento (a volte molto), alcune operazioni sono difficoltose
 ci sono dei bug
 Facile creare situazioni particolari: (batteria scarica,arrivo di un messaggio )"

UNITA MISURA

-PX corrisponde ai pixel ‘’reali’’ presenti sullo schermo del dispositivo

-DP (dip) acronimo per density indipendet pixel, dimensione calcolata su una densita di 160 dpi un
dp ha le dimensioni di un px a 160 dpi
-PT, acronimo per ‘’Points’’ , corrisponde a 1/72 di pollice (1 pollice = 2,54 cm)
-SP, acronimo di Scale Independent Pixels, è simile ad DP ma viene anche adattato in base
alle preferenze espresse dall’utente relativamente alla dimensione dei font.
MULTI LINGUA

Il primo passo è quello di creare nella sotto res/value il file string.xml qui andremo a mettere tutte le
stringhe che verrano utilizzate di default oppure se non abbiamo creato una traduzione per una
lingua del dispositivo del dispositivo es:

<resources>
<string name="hello">Hello World, ExampleActivity!</string>
<string name="app_name">Example</string>
</resources>

successivamente creamo un file string in una directory diversa per ogni lingua di cui vogliamo
fornire una traduzione ad esempio

res/values-it/strings.xml: lingua italiana

res/values-fr/strings.xml: lingua francese
res/values-xx/strings.xml: la lingua corrispondente al suffisso xx

Bundle life cycle

public void onSaveInstanceState(Bundle savedInstanceState) {
savedInstanceState.putString(”NOME", nome);
savedInstanceState.putInt(”NUMERO", numero);
super.onSaveInstanceState(savedInstanceState);
}

void onCreate(Bundel b){

if(b!=null){
c = b.getString("nome");
a = b.getInt("numero");

back stack
In genre un app è formata da più activity ed ogni activity può lanciare un altra activity tramite gli
intent.

Più attvità possono coesistere, vengono organizzate in un backstack

•  Solitamente un task parte dall’Home screen

– l’utente clicca un’icona e lancia un’attvità che viene mostrata sullo schermo (foregruound)

•  Se vengono lanciate nuove attvità

– l’attvità corrente viene messa nel backstack (backgruond)
– l’utente ci può tornare con il pulsante Back
ADAPTER

Un adapter ,viene utilizzato insieme alle listView ,ed è un componente che si occupa della
rappresentazione grafica di una fonte dati,generalmente un arrey, e dell'interazione con essi, per
ogni elemento della ListView.

Un classico esempio potrebbe essere quello di vole mostrare una lista di nomi nella nostra app.Il
primo passo è quello di creare un arrey di nomi , poi creamo un oggetto array adatapter a cui
passimo il contesto , l'id della text view che deve contenere il nome , un file di layout in cui viene
descritto come deve essere visualizzato l elemento e infine la nostra fonte di dati coiè l'array. Poi
utilizziamo il metodo ListView.setAdapter(Adapter) per assegnare l'adapter alla list view.

INTENT
La classe Intent è una classe che specifica un'operazione astratta da svolgere.

La risoluzione è esplicita quando nella creazione dell'intent viene specificata l'activity da

lanciare. Questo tipo di risoluzione è utilizzata quando vogliamo lanciare un'activity all'interno di
un'altra activity e conosciamo l'activity da lanciare.

Ad esempio, dall'activityA vogliamo lanciare l'activityB:

Intet intet= new Intent(getApplicationContext(), ActivityB.class);
startActivity(intent);

La risoluzione implicita invece avviene quando conosciamo l'azione da effettuare e i dati su

cui effettuare l'azione, ma non conosciamo quale componente deve essere lanciata.
La componente viene scelta in maniera implicita in base a category, type, action, data, URI ed
altre informazioni aggiuntive.
Esempio:
Intent intent= new Intent(Action.PICK, "Contacts/contacts/people");
startActivity(intent);

intent filter
il nodo intent filter ha il preciso compito di informare android che la nostra activity è in grado di
svegliarsi in seguito al verificarsi di particolari eventi generati dal dispositivo o da un altra app.

il tag action indica il nome dell azione che la nostra app deve intercettare e gestire
il tag category è un informazione aggiuntiva che identifica il tipo di azione
il tag data fornisce informazioni sulla tipologia dei dati che è in grado di gestire

Nell'esempio l'activity ShareActivity risponde a una richiesta di invio dati perchè ha come action la
costante sand ed è in grado di gestire i dati nel formato text/plain
PERMESSI
Android protegge risorse e dati con un meccanismo di permessi di accesso

•  Servono a limitare l’accesso a :

– informazioni dell’utente (e.g. i contatti della rubrica)
– servizi con costi (e.g., invio SMS, chiamate tel.,accesso a Internet)
– Risorse di sistema (e.g., fotocamera, GPS)

Vengono rappresentati da stringhe

•  Ogni app deve dichiarare nel manifesto i “permessi” che intende utilizzare
•  L’utente deve accettare i permessi al momento dell’istallazione

<uses-permission android:name = “android.permission.CAMERA”/>

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

L' utente deve accettare i permessi al momento dell' installazione.

Ma nelle versioni più recenti è chiesto di dare il permesso al momento dell utilizzo della risorsa

Asynk TASk

La classe AsynkTask facilita l'interazione tra il mani thread e altri thread in esecuzione in back
gruond
La classe asynk task è una classe generica AsynkTask<Param,Pogress,Result>:

Param è il tipo dei paramtri che si vuole utilizzare;

Progress tipo utilizzato per segnalare lo stato di avanzamento;
Result è il tipo per il risultato del task;

Una classe che estende SynckTAsk deve implementare 4 metodi :

-onPreExecute() : viene esegutio nel main thred prima di doInBackground (per settare variabili o
rendere visibile la progres bar);
-doInBackground() : viene eseguti nel thred secondario , retituisce una variabile di tipo result, e
prendo come argomento una variabile dk tipo Param; puo richiamere il metodo publishProgress();
-onProgressUpdate(): viene eseguito nel mainthred in risposta a publishProgress() prende come
argomento Progress;
-onPostExecute() : viene eseguito nel main thred dopo doInBackgrond e prende come parametro
un istanza di tipo Result che sarebbe il valore restituito di doInBackground();

FRAMMENTI

Un frammento rappresenta una porzione dell interfaccia grafica , un activity puo ospitare diversi
frammenti che possono essere inseriti e eliminati durante l esecuzione per creare effetti diversi in
base,ad esempio, alle dimensioni del display.
Un frammento puo essere visto come una sorta di sub-activty in quanto ha un proprio ciclo di vita e
un proprio layout che è strettamente legato a quello dell activity che lo ospita.
Nell Activity ospitante si possono controllare i frammenti tramite la classe FragmentManager
che è responsabile che è responsabile della gestione dei frammenti dell della aggiunta della view dei
frammenti all albero della view dell app
ALARM

Permettono di eseguire intent in funzione di specifici eventi

•  Un’applicazione che usa un alarm riesce ad eseguire porzioni di codice anche se

l’applicazione è terminata
•  Un alarm è attivo anche se il telefono va in modalità di sleep
- l’alarm può causare la ripresa dell’attività
– oppure potrà essere gestito quando l’utente rimette il telefono in modalità normale

MEMORIZZAZIONE

Ci sono 3 metodi per salvare infromazione di un app android:

- SharedPreferences :
sono dati privati salvati come coppia chiave-valore

SharedPreferences obj = getSharedPreferences("filename"):

SharedPreferences.Editor editor= obj.edit();

editor.putBoolean("KEY", bool_value);
editor.commit();

- File (publici o privati):

esistono due tipi di storage internal storege , che è uno spazio riservata all app a cui solo essa puo
accedere per accedere in lettura si una openFileInput(filename) mentre per accedere in srittura si usa
openFileOutput(filename , mode) ,
e esternal storage sono file generalmente salvati su sd del dispositivo , bisogna richiedere il
premesso

- DatabaseSql
Dati strutturati in database privati a cui si puo accedere con normali query sql.

dbHelper = new MYDatabaseOpenHelper(this);

SQLiteDatabase db =dbHelper.getWritableDatabase(); db.delete();db.insert();db.update();

DATABESE

Android fornisce suport per databse sql all interno dell app. Bisogna crare un classe che estenda la
classe SQLiteOpenHelper e sovrascrivere il mtodo on create(dove in genere viene creato il db) e il
metodo on update (utilizzato per fare aggiornamenti al db ).

la classe cursor rappresenta un puntatore ad un set di risultati, permette di navigare tra i dati del
risultato della query (move nest,move first,muove last, getString(int columnIndex) )
ALBERO DELLE VIEW
L’albero delle view è un Albero n-ario che contiene tutti gli elementi del Layout, contenitori e
widget, mettendoli in un ordine gerarchico, partendo dalla radice che rappresenta il MainLayout
fino ad arrivare ad ogni singolo widget.
Il meccanismo di layout inizia quando viene chiamato il metodo requestLayout su una view
dell'albero. Tale metodo viene chiamato quando una view ha bisogno di altro spazio.
requestLayout mette un evento nella coda degli eventi della UI. Quando l'evento viene
processato ogni container view può interagire con i figli
•  Il processo ha due fasi
1.  misura delle views contenute nel container
2.  posizionamento delle views all’interno del container
•  Tutte le view devono implementare la fase 1
•  Sole le view container devono avere anche la fase 2

La fase di misura offre la possibilità alle views di chiedere lo spazio di cui hanno bisogno
•  Android inizia il processo chiamando il metodo measure sulla radice dell’albero
– a partire dalla radice ogni container view chiede ai figli lo spazio di cui hanno bisogno
– la richiesta si propaga ricorsivamente

•  Mesaure è un metodo “ final” che non può essere riscritto

– onMeasure invece sì, viene chiamato da measure

•  Nella fase di Layout i view container comunicano la posizione effettia ad ogni view
figlio tramite il medoto onLayout

CANVAS

oggetto canvas viene utilizzato per disegnare immagini complesse che subiscono di numerosi
aggiornamenti,come ad esempio in un giochino, oppure se deve subire delle animazioni

Drawable
rappresenta un oggetto che puo essere disegnato in una view

Animazioni
android permette di definire animazioni da adare alle immagini tramite un file xml
Per caricare un animazione si dever chiamare il metodo loadAnimation(Context c, int id)
Per avviare un animazione bisogna richiamre il metodo startAnimation(Animation anim)

<rotate <translate <scale

android:startOffset="0"
android:duration="2000"
android:fromDegrees="0"
android:toDegrees="720"
android:pivotX="50%"
android:pivotY="50%" />
android:startOffset="3000"
android:duration="1000"
android:fromXDelta="0"
android:fromYDelta="0"
android:toXDelta="300"
android:toYDelta="0"/>
android:startOffset=«1500"
android:duration="3000"
android:fromXScale="1"
android:fromYScale="1"
android:toXScale="0.1"
android:toYScale="0.1"
android:pivotX="50%"
android:pivotY="50%" />
 MOTION EVENT
reppresenta un movimento registrato da una periferica esterna .
Il moviemento è rappresentato con
-Action_code :cambiamento avvenuto
-Action values : proprieta del movimento

Nela caso del muti tach il pointer è il singolo evento, e il pointer ha un id univoco per tutto il tempo della sua
esistenza.
Un motion event rappresenta:
-un singolo pointer
-a volte piu di un pointer a cui si puo accedere tramite un indice che puo cambiare per eventi successivi

GESTURE DETECTOR

permette di riconoscere gesture eseguite sul dislpay.

• Bisogna creare un GestureDetector
che implementa l’interfaccia GestureDetector.OnGestureListener
• Riscrivere il metodo onTouchEvent
–che viene chiamato in risposta ad un gesto
–questo metodo delega il riconoscimento del gesto al metodo GestureDetector.OnGestureListener

SENSORI
i dispositivi android sono dotati di senzori che permettono di reperire e gestire dati esterni
grezzi.
Un activity che vuole utilizzare i sensori deve implementare la classe SensorListener.
Poi tramite il sensor manager dobbiamo povvedere a verificare se il sensore che vorremo
utilizzare esiste

public class MyClass extend Activity implement SensorListener{

}

private SensorManager sm;

sm = (SensorManager))getSystemService(Context.SENSOR_SERVICE);
if(sm.getDefaultSesnor(Sensor.TYPE_LIGHT)!=null)
// il sensore è disponibile
else
// il sensore non è disponibile

E' buona prassi, prerisparmiare batteria, disabilitare il sensore quando viene richiamato il
metodo onPause dell activity , e riabilitarmo quando viene richiamato il metodo onResume

sm.registerListener(this,mLight,SensorManager.SENSOR_DELAY_NORMAL);
mSensorManager.unregisterListener(this);

In oltre bisogna sovrascrivere i metodi :

onSensorChange : che viene richiamato quando avviene un nuovo evento sul sensore
onAccuracyChange : che viene richiamato quando cambia l'accuratenzza del sensore
NOTIFICATION

Ci sono 3 modi per notificare delle informazioni all utente al di fuori nella normale
interfaccia dell app:

Toast : avvisa l'utente di un'operazione in un piccolo pop up. Prende solo lo spazio di cui ha
bisogno per il messaggio e l'activity resta visibile e interattiva. Eventualmento è possibile
anche personalizzare il toast modificando alcuni parametri e facendo poi l'inflate del file
xml che descrive l'aspetto del toast che deve essere visualizzato

Toast.makeText(this,"ciao sono un toast",Toast.LenghtLong);

Toast toast = new Toast(getApplicationContext());

toast.setGravity(Gravity.CENTER_VERTICAL, 0, 0);
toast.setDuration(Toast.LENGTH_LONG);
toast.setView(getLayoutInflater().inflate(R.layout.custom_toast,null));
toast.show();

Dialog : sono notifiche pop up che permette all utente di fare una scelta oppure inserire
infromazioni aggiuntive

DialogInterface.OnClickListener dialogClickListener = new DialogInterface.OnClickListener() {

public void onClick(DialogInterface dialog, int which) {
switch (which) {
case DialogInterface.BUTTON_POSITIVE:
Toast.makeText(getApplicationContext(), "Ok!", Toast.LENGTH_LONG).show();
break;
case DialogInterface.BUTTON_NEGATIVE:
Toast.makeText(getApplicationContext(), "Azione annullata",Toast.LENGTH_LONG).show();
break;
case DialogInterface.BUTTON_NEUTRAL:
Toast.makeText(getApplicationContext(), "Azione neutrale",Toast.LENGTH_LONG).show();
break;
}
}
};

AlertDialog.Builder builder = new AlertDialog.Builder(this);

builder.setMessage("Stai per ripartire da capo. Sei sicuro?")
.setPositiveButton("Si", dialogClickListener)
.setNeutralButton("forse",dialogClickListener)
.setNegativeButton("No", dialogClickListener).show();

Notification : Una notifica è un messaggio che viene mostrato nella barra delle notifiche.
L'utente può vedere i dettagli della notifica aprendo il pannello delle notifiche.
Sia la barra che il pannello delle notifiche sono gestite dal sistema, quindi sono sempre
accessibili
public void showNotification(View v) {
Notification.Builder notificationBuilder = new Notification.Builder(
getApplicationContext()) .setTicker("Messaggio breve").setSmallIcon(R.mipmap.pacman_ghost)
.setAutoCancel(true).setContentTitle("Titolo notifica") .setContentText("Testo della notifica");

NotificationManager mNotificationManager =
(NotificationManager)getSystemService(Context.NOTIFICATION_SERVICE);
mNotificationManager.notify(1,notificationBuilder.build()); }