Corso su Android – Lavorare con le Activity

articleImage

Nell'articolo precedente abbiamo creato il nostro primo programma, HelloWorld ed abbiamo analizzato le parti fondamentali di cui è composto. Abbiamo visto quanto è semplice creare un progetto grazie all'utilizzo dell' IDE e dell'SDK messo a disposizione da Google. Ma un'applicazione è costituita da più "pagine" (Activity) e in questo articolo getteremo le basi per comprendere come funzionano quelle che vengono chiamate Activity ed andremo a vedere come è semplice crearne nuove e navigare tra queste.

Iniziamo questo secondo articolo con un po' di teoria necessaria per capire come sviluppare applicazioni efficienti. Di seguito andremo ad analizzare alcuni componenti fondamentali partendo da un file molto importante in un progetto Android: il manifest.

Ogni applicazione Android deve avere un file chiamato AndroidManifest.xml nella directory principale; questo contiene informazioni essenziali che servono al sistema prima di caricare l'applicazione. Di seguito riportiamo il manifest del progetto HelloWorld ed andremo a vedere i tag fondamentali.

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="com.example.helloworld"
    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="com.example.helloworld.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>

</manifest>

Il file AndroidManifest.xml deve iniziare con il tag univoco <manifest> che include tutti gli altri tag. Al suo interno vi sono alcuni attributi importanti :

  • package: usato come identificativo univoco dell'applicazione
  • android:versionCode: è un numero intero che serve per vedere se una versione è più recente di un'altra
  • android:versionName: versione visualizzata all'utente

Tag <uses-sdk> permette di discriminare sulla compatibilità con una o più versioni di Android. Infatti i valori vengono confrontati con quelli del sistema operativo sui singoli dispositivi. Gli attributi che contiene sono:

  • android:minSdkVersion: il livello minimo di API richiesto per far girare l'applicazione
  • android:targetSdkVersion: il livello di API per cui l'applicazione è stata sviluppata, se nullo assume lo stesso valore di minSdkVersion
  • android:maxSdkVersion: il livello massimo di API richiesto per far girare l'applicazione

Tag <uses-feature>: dichiara quale caratteristica hardware deve avere il dispositivo per far girare l'applicazione. Gli attributi che contiene sono:

  • android:name: specifica una caratteristica hardware o software che il device deve avere per far girare l'applicazione
  • android:require: valore booleano che indica se l'applicazione richiede la caratteristica specificata in android:name. Se android:require="true" allora l'applicazione è stata disegnata per usare quella specifica caratteristica e quindi l'applicazione si potrà installare solamente su dispositivi aventi tale caratteristica. Se invece android:name="false" allora l'applicazione può comunque essere installata sul telefono, anche se la feature non è presente.
  • android:glEsVersion: richiede una specifica versione delle OpenGL

Tag <uses-permission>: permessi che l'applicazione necessita per accedere ad alcune funzionalità (per esempio la fotocamera). L'utente acconsente ad utilizzare questi permessi nel momento dell’istallazione, ha un unico attributo:

  • android:name: nome del permesso (es: <uses-permission android:name="android.permission.INTERNET" />)

Tag <application> è la dichiarazione dell'applicazione e contiene le dichiarazioni dei componenti utilizzati nell'applicazione.
All'interno del tag <application> troviamo il tag <activity> che dichiara le activity utilizzate nell'applicazione.

Importante: Tutte le activity utilizzate devono essere dichiarate nel manifest.

Gli attributi che possono essere presenti nel tag <application> sono molti, vediamo quelli più comunemente utilizzati:

  • android:name:nome della classe che implementa l'activity
  • android:label: label dell'applicazione che viene visualizzata insieme all'icona
  • android:screenOrientation: rende fisso l'orientamento dell’activity (portrait, landscape)

Come ultimo tag vediamo <intent-filter> che aggiunge un action al filtro. Ogni tag deve contenere almeno una <action>. Quando viene lanciato un intent (definito più avanti) se è definito un intent filter apposito, l’intent viene intercettato e viene lanciata l'activity associata.
Prendendo come esempio sempre il manifest del progetto HelloWorld vediamo che nella nostra activity vi è un unico intent filter (se ne possono aggiungere altri a seconda delle esigenze):

<intent-filter>
  <action android:name="android.intent.action.MAIN"/>
  <category android:name="android.intent.category.LAUNCHER"/>
</intent-filter>

Come si vede vi è un tag action e un tag category che indicano che questa è l'activty principale che verrà visualizzata quando verrà lanciata l'applicazione.

Come abbiamo visto con i tag <uses-sdk>, <uses-feature> e <uses-permission>, si definisce su quale SDK deve girare l'applicazione, che caratteristiche fisiche deve avere il telefono e i permessi di cui l'applicazione ha bisogno per funzionare. Possiamo aggiungere che tramite la uses-sdk e uses feature viene anche discriminato su quale telefono è possibile installare l'applicazione, per esempio se  abbiamo

<uses-sdk android:minSdkVersion    = "10" />
<uses-feature android:name="android.hardware.bluetooth" />

I due valori ci dicono che la versione minima di Android su cui può essere installata l'applicazione è la 2.3.3 e che il dispositivo deve avere il bluetooth; se una delle due condizioni non è verificata, l'applicazione non viene installata sul dispositivo. Questo è il motivo per cui alcune volte dal PlayStore alcuni telefoni vedono le applicazioni e altri no.

Di seguito una tabella che associa ad ogni Platform il relativo API level

Activity e Ciclo di vita dell'Applicazione

L'Activity è un componente applicativo che fornisce una parte visuale all'utente, grazie al quale può interagire con le funzionalità del telefono come: mandare sms, telefonare, guardare le foto,etc. Un'applicazione è formata da una o più Activity, una principale che viene visualizzata all'apertura dell'applicazione e le altre visualizzate a seconda della scelta dell'utente. E' possibile visualizzare un'Activity alla volta, infatti ogni volta che un'Activity viene visualizzata quella precedente viene messa in background dal SO. Questa logica viene gestita dal SO in modo trasparente all'utente tramite uno stack (pila LIFO Last In First Out). Quando si naviga nell'applicazione e si sceglie di visualizzare una nuova Activity quella precedente viene messa nello stack e recuperata quando viene premuto il tasto back e mostrata a video.
Nel corso della sua vita un'activity può trovarsi essenzialmente in 3 stati:

  • resumed: l'Activity è in foreground e l'utente può interagire con questa (in questo stato l'Activity è in stato running)
  • paused : Un'altra Activity è in foreground ed ha il focus anche se quella precedente è ancora visibile.
  • stopped: L'Activity è oscurata completamente da un'altra Activity.

Quando un'Activity si trova negli stati paused e stopped il SO può decidere di distruggerla se in quel momento ha bisogno di risorse. Di seguito viene mostato uno schema del ciclo di vita di un'activity:

Come si vede dalla figura, l'Activity vive tra i metodi di callback onCreate ed onDestroy, tra questi due ci sono tutti quelli in cui l'activity può trovarsi nel corso della sua vita:

  • onCreate(): Chiamato quando l'Activity è creata per la prima volta
  • onStart(): Chiamata quando l'Activity diventa visibile per la prima volta
  • onResume(): Chiamata quando l'Activity inizia l’interazione con l'utente
  • onPause(): Chiamata quando l'applicazione viene messa in pausa
  • onStop(): Chiamata quando l'applicazione non è più visibile dall'utente
  • onDestroy(): Chiamata quando l'Activity viene distrutta dal sistema
  • onRestart(): Chiamata quando l'Activity è stata stoppata e poi riavviata

Come visto nel Progetto HelloWorld l'activity deve estendere la classe android.app.Activity e implementare il metodo onCreate in più nel manifest deve essere dichiarata all'interno del tag <application>.

 <activity
     android:name="com.example.helloworld.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>

La classe java che estende Activity deve poi visualizzare l'xml associato. Come vedremo Android separa la parte grafica dalla parte logica utilizzando per la parte visuale dei file in formato xml cosi da rendere più gestibile e comprensibile il codice. Come si vede dall'estratto di codice il file xml si chiama main e viene caricato con l'istruzione setContentView(R.layout.main);

public class MainActivity extends Activity {
  /** Called when the activity is first created. */
  @Override
  public void onCreate(Bundle savedInstanceState) {
     super.onCreate(savedInstanceState);
     setContentView(R.layout.main);
  }
}

Intent, creare un'Activity e navigare tra Activity

Nel progetto HelloWorld è stata creata un'unica Activity principale che viene visualizzata nel momento in cui viene lanciata l'applicazione. Ma un'applicazione è formata da più Activity ed ora vedremo come è possibile passare da una activity all'altra. Per ottenere questo risultato vengono utilizzati gli intent. Questi non sono altro che dei messaggi grazie ai quali si possono attivare i componenti di base come le Activity, i service e i broadcast receiver.
Creiamo un nuovo progetto NavigationFromActivity seguendo i passi effettuati per HelloWord creando come activity principale MainActivity come in figura:

Creiamo ora la seconda Activity: espandiamo la root del progetto e la cartella con i sorgenti (src), posizioniamoci sul package com.example.navigatefromactivity e premiamo il tasto dx del mouse, si aprirà un menu a tendina in cui andremo a scegliere new-->class

Inserire come nome dell'Activity SecondActivity e nella sezione Superclass inserire android.app.Activity;  alla fine premere Finish

Verrà così creata un'Activity vuota a cui andremo ad aggiungere il metodo onCreate:

package com.example.navigatefromactivity;

import android.app.Activity;

public class SecondActivity extends Activity {
@Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_second);
    }
}

Andiamo ora a creare un file activity_second.xml da associare all'activity appena creata:

  • espandere la cartella res
  • premere il tasto dx sulla cartella layout
  • dal menu scegliere new-->Other
  • selezionare Android xml file e premere Next
  • Inserire nella sezione nome activity_second e premere Finish

Nel file appena creato aggiungiamo una label, per fare questo inseriamo una TextView come indicato di seguito:

<TextView
      android:layout_width=" match_parent"
      android:layout_height="wrap_content"
      android:text="seconda activity"
/>

Vedremo in dettaglio gli attributi nella parte in cui spiegheremo i componenti visuali.

Per ora scriviamo direttamente il testo nel tag android:text, vedremo che è consigliato definirlo nel file string.xml.

Passiamo ora all'Activity principale che come abbiamo visto è formata solamente da una label, per dare la possibilità di  passare alla seconda activity inseriamo un bottone. Quindi nel file activity_main inseriamo il codice seguente:

<Button
        android:id="@+id/idButon"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Vai alla seconda Activity"
/>

Notare l'attributo android:id="@+id/idButon" che ci servirà per recuperare il bottone ed utilizzarlo nel codice java.
Nella classe MainActivity andiamo a recuperare il riferimento al bottone ed associare un listener per intercettare la pressione da parte dell'utente.

Button btnGoToSecond = (Button)findViewById(R.id.idButton);
        btnGoToSecond.setOnClickListener(new OnClickListener() {
            @Override
            public void onClick(View v) {
                Intent intent = new Intent(MainActivity.this, SecondActivity.class);
                startActivity(intent);
            }
        });

Grazie al metodo findViewById possiamo recuperare il componente utilizzato nel file xml, così da poterlo utilizzare. Subito dopo associamo un listener con setOnClickListener per intercettare la pressione del bottone da parte dell'utente. Nell'implementazione del metodo inseriamo le istruzioni

  • Intent intent = new Intent(context, SecondActivity.class);
  • startActivity(intent);

grazie alle quali viene creato un nuovo intent e con il metodo startActivity viene detto al SO di voler passere all'Activity definita nell'intent (SecondActivity).
A questo punto compiliamo il progetto e facciamo il run. Verrà visualizzata l'activity principale con il bottone. Premendo su questo verrà visualizzata la seconda Activity.

In questo modo abbiamo creato e visualizzato una seconda activity, ma se volessimo tornare indietro?

Per tornare all'Actvity precedente Android mette a disposizione il tasto back grazie al quale il SO distrugge l'Activity corrente e recupera dallo stack quella precedente. È possibile terminarla anche intervenendo direttamente sul codice utilizzando il metodo finish(). Per provare questo metodo, aggiungiamo un bottone nella seconda Activity che ci permetterà di tornare a quella precedente. Quindi inseriamo nel file activity_second.xml il codice:

<Button
        android:id="@+id/idFinishButton"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Chiudi"
    />

Come visto per la prima Activity, nel codice java dobbiamo recuperare il bottone e settare un listener per intercettare il click fatto dall'utente e quindi richiamare il metodo finish();
Nella classe SecondActivity.java inseriamo il codice:

Button btnGoToSecond = (Button)findViewById(R.id.idFinishButton);
        btnGoToSecond.setOnClickListener(new OnClickListener() {
            @Override
            public void onClick(View v) {
                finish();
            }
        });

Lanciando l'applicazione si vede che la prima Activity non è cambiata, mentre nella seconda è comparso il bottone con la scritta Chiudi, premendolo viene invocato il metodo finish() richiamato nell'onClick e l'Activity corrente viene distrutta e la prima viene recuperata dallo stack e mostrata a video.

Event Listeners & Event Handlers

Come abbiamo visto in questi semplici esempi è stato intercettato l'evento di onClick sull'oggetto Button. Gli eventi sono un modo utile per recuperare dati mentre l'utente interagisce con i componenti visuali dell'applicazione. Vedremo più in dettaglio come interagire con ognuno di questi quando parleremo dei componenti visuali. Per ora vediamo brevemente cosa sono gli event listener e gli event Handler.
Un event listener è un'interfaccia che riceve le notifiche di eventi e quando un evento accade viene pasato all'event handler che gestisce l'evento tramite degli appositi metodi.

Event Handler Event Listener & Description
onClick() Implementato dall'interfaccia OnClickListener, viene invocato quando l'utente tocca un componente.
onLongClick() Implementato dall'interfaccia OnLongClickListener, viene invocato quando l'utente preme per qualche secondo su un componente.
onFocusChange() Implementato dall'interfaccia OnFocusChangeListener viene invocato quando cambia il focus su una view
onKey() Implementato dall'interfaccia OnKeyListener, viene richiamato quando l'utente ha il focus su un componente e preme o rilascia un tasto della tastiera hardware
onTouch() Implementato dall'interfaccia OnTouchListener, viene richiamato quando l'utente effettua una pressione sullo schermo.
onCreateContextMenu() OnCreateContextMenuListener, viene chiamato quando il menu viene creato

Per definire questi metodi all'interno della propria Activity bisogna implementare il listener ed agganciarlo al componente tramite il metodo setOnClickListener come abbiamo visto nell'esempio precedente con l'istruzione: btnGoToSecond.setOnClickListener(new OnClickListener() …

Passaggio di parametri tra activity

Abbiamo visto come aprire una nuova Activity ora verrà illustrato come poter passare dei valori tra le Activity, per far questo vengono utilizzati gli intent passandogli un parametro, utilizzando la seguente istruzione:

intent.putExtra(EXTRA_PARAMETER, “valore del parametro”);

Per recuperare il parametro dalla seconda activity si utilizza sempre l'intent:

getIntent().getStringExtra(EXTRA_PARAMETER);

Per esempio nella prima Activty possiamo sostituire il codice che implementa il bottone con il seguente:

Button btnGoToSecond = (Button)findViewById(R.id.idButton);
btnGoToSecond.setOnClickListener(new OnClickListener() {
            
   @Override
   public void onClick(View v) {
     Intent intent = new Intent(MainActivity.this, SecondActivity.class);
     intent.putExtra("com.example.navigatefromactivity.PARAMETER", "test parametro");
     startActivity(intent);
   }
});

e nella seconda nel metodo onCreate aggiungiamo:

Log.d("Test",getIntent().getStringExtra("com.example.navigatefromactivity.PARAMETER"));

Dove Log è la classe che si occupa di scrivere i log e possono essere controllati comodamente nella view LogCat di eclipse:

 

Abbiamo visto come è possibile passare ad un’Activity a quella successiva passandole dei parametri e tornare indietro, ma se una volta che si ritorna all’Activity chiamante si volesse sfruttare il risultato della seconda, come potremmo fare?
Per vedere come funziona il passaggio in entrambi i versi possiamo impostare un progetto con due activity in modo da passare dalla prima activity un valore intero alla seconda che lo incrementa di un valore e lo restituisce in risposta all’Activity chiamante. Definiamo due file xml, il primo contenente un bottone, che fa passare alla seconda Activity, e due label, una che contiene una stringa fissa e l’altra che visualizza il valore di partenza e poi modificato.
Creiamo il progetto come quello precedente e modifichiamo il file activity_main.xml come segue:

<LinearLayout 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"
    android:orientation="vertical">
    
    <Button
        android:id="@+id/idButton"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Vai alla seconda Activity"
    />
 
    <LinearLayout
                android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:orientation="horizontal"
    >
        <TextView
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:text="@string/labelValue"
            android:layout_marginRight="10dp"
        />
        
        <TextView
            android:id = "@+id/idTxtResult"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
        />
    </LinearLayout>
</LinearLayout>

Il file è costituito da un LinearLayout verticale (ha come attributo android:orientation="vertical") questo indica che ogni componente che segue verrà aggiunto sotto quello precedente. Quindi avremo un bottone sotto il quale viene messo un altro LinearLayout contenente due TextView, che in questo caso è orizzontale, il che significa che le due label saranno affiancate (vedremo più in dettaglio quando parleremo dei layout); per ora concentriamoci sul passaggio dei parametri.
Andiamo ora a vedere come deve essere la classe java.
Definiamo le variablili di classe:

private final int REQUEST_CODE  = 0;
private int initValue           = 1;
private TextView txtResult      = null;

Nel metodo onCreate dobbiamo recuperare la TextView nella quale settare il valore iniziale e poi modificato, quindi

txtResult = (TextView)findViewById(R.id.idTxtResult);
txtResult.setText("" + initValue);

Notare che abbiamo trasformato in String il valore initValue, perché il metodo setText prende come pramatro una stringa, esiste un metodo che prende un intero che però rappresenta l'id di una risorsa, quindi se gli passassimo un intero il SO andrebbe a cercare questo valore nella classe R (che contiene tutti gli id) e non trovandolo genererebbe un errore.
Definiamo il bottone come fatto nel progetto precedente ma cambiando il modo di invocare l'activity:

Button btnGoToSecond = (Button)findViewById(R.id.idButton);
btnGoToSecond.setOnClickListener(new OnClickListener() {
            
  @Override
  public void onClick(View v) {
    Intent intent = new Intent(MainActivity.this, SecondActivity.class);
    intent.putExtra("com.example.navigatefromactivity.PARAMETER", initValue);
    startActivityForResult(intent, REQUEST_CODE);
  }
});

Si vede che viene passato un parametro intent.putExtra("com.example.navigatefromactivity.PARAMETER", initValue), che verrà recuperato nella seconda Activity. Possiamo notare che il parametro intero viene passato nello stesso modo come quello di tipo stringa (visto nel progetto precedente) quello che cambia è la chiamata all'Activity dove viene usato il metodo startActivityForResult(intent, REQUEST_CODE);
dove REQUEST_CODE è un argomento che identifica univocamente la richiesta.

Il risultato viene catturato nel metodo di callback onActivityResult (int requestCode, int resultCode, Intent data):
questo include 3 argomenti:

  • requestcode: passato con la con startActivityForResult;
  • resultCode: codice del risultato passato dalla seconda Activity. Può assumere RESULT_OK se l’operazione è avvenuta con successo o RESULT_CANCELED se l’operazione è fallita per qualche motivo.
  • data: l’intent che porta i dati

Aggiungiamo il metodo di callback:

  • posizionarsi nel punto del codice dove si vuole inserire il metodo
  • premere il tasto dx del mouse --> source-->Override/Implement methods
  • selezionare onActivityResult(int,int,Intent) e premere ok

Il metodo verrà inserito nel punto del codice scelto.
Il plugin genera un metodo vuoto con la sola chiamata al super, modifichiamo il codice come segue:

@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
  super.onActivityResult(requestCode, resultCode, data);
  if (requestCode == REQUEST_CODE) {
     if (resultCode == RESULT_OK) {
       int result = data.getIntExtra("com.example.navigatefromactivity.PARAMETER_RESULT",
                                       -1);
       txtResult.setText("" + result);
     }
   }
}

Il resultCode viene confrontato con il codice di richiesta chiamante, perché la seconda activity potrebbe essere chiamata in più punti e si vorrebbe avere un comportamento diverso per ognuno.
Subito dopo si controlla se il risultato è corretto, se è corretto allora viene recuperato il parametro inviato dalla seconda Activity  data.getIntExtra("com.example.navigatefromactivity.PARAMETER_RESULT", -1); e poi viene assegnato alla TextView.
Passiamo alla seconda activity.
Il file activity_second.xml risulta essere con un solo bottone:

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical" >
    
<TextView
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="@string/labelSecondActivity"
        
    />
    
    <Button
        android:id="@+id/idFinishButton"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="@string/labelClose"
    />    
</LinearLayout>

La classe della seconda activity si presenta come:

public class SecondActivity extends Activity {
 @Override
 protected void onCreate(Bundle savedInstanceState) {
  super.onCreate(savedInstanceState);
  setContentView(R.layout.activity_second);
       
  Button btnGoToSecond = (Button)findViewById(R.id.idFinishButton);
  btnGoToSecond.setOnClickListener(new OnClickListener() {
            
   @Override
   public void onClick(View v) {
     int parameter = getIntent().getIntExtra("com.example.navigatefromactivity.PARAMETER",
                                                 -1);
     parameter += 1 ;
     Intent intent = new Intent();
     intent.putExtra("com.example.navigatefromactivity.PARAMETER_RESULT",
     parameter);
     setResult(RESULT_OK, intent);
     finish();
    }
   });
 }
}

Da cui si vede che sul click del bottone viene:

  • recuperato il parametro passato dalla prima activity int parameter = getIntent().getIntExtra("com.example.navigatefromactivity.PARAMETER", -1);
  • incrementato parameter += 1 ;
  • instanziato un nuovo intent Intent intent = new Intent();
  • aggiunto il parametro da restituire: "com.example.navigatefromactivity.PARAMETER_RESULT"
  • settato il risultato da ritornare al chiamante setResult(RESULT_OK, intent);
  • fatto il finish dell'activity tramite il metodo finish();

Naturalmente vanno aggiunte le activity nel manifest

<activity
   android:name="com.example.navigatefromactivity.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>
        
<activity android:name=".SecondActivity" />

A questo punto se si fa il run del progetto possiamo vedere le activity:

Activity appena creata Seconda Activity incrementail valore Prima Activity con parametroincrementato

Si vede che premendo su chiudi della seconda Activity si ritorna sulla prima ed il valore numerico è aumentato.

 

Riassumendo possiamo dire che in questo articolo abbiamo analizzato le Activity ed il loro ciclo di vita ed abbiamo visto che giocano un ruolo molto importante nello sviluppo delle applicazioni. Abbiamo visto anche come il sistema operativo le gestisce e gli stati in cui si possono trovare. E' importante capire il funzionamento delle Activity perché grazie a queste siamo in grado di implementare applicazioni complesse. Le Activity che abbiamo realizzato sono molto semplici e per crearle abbiamo utilizzato dei Layout che vedremo più in dettaglio nel prossimo articolo.

Allegato

Scarica codice sorgente

 

Quello che hai appena letto è un Articolo Premium reso disponibile affinché potessi valutare la qualità dei nostri contenuti!

 

Gli Articoli Tecnici Premium sono infatti riservati agli abbonati e vengono raccolti mensilmente nella nostra rivista digitale EOS-Book in PDF, ePub e mobi.
volantino eos-book1
Vorresti accedere a tutti gli altri Articoli Premium e fare il download degli EOS-Book? Allora valuta la possibilità di sottoscrivere un abbonamento a partire da € 2,95!
Scopri di più

4 Comments

  1. Marven 19 novembre 2013
  2. Piero Boccadoro Piero Boccadoro 20 novembre 2013
  3. paolo.barbuti 21 novembre 2013
  4. fuzzzy 21 dicembre 2013

Leave a Reply

Raspberry Pi 3 GRATIS! (Win10 compatibile)

Fai un abbonamento Platinum (EOS-Book + Firmware), ricevi in OMAGGIO la RASPBERRY 3, inviaci il tuo progetto e OTTIENI IL RIMBORSO