Android Tutorial
Iniziare con Android

Osservazioni

Versioni

Configurazione di Android Studio

Android Studio è l'IDE di sviluppo Android ufficialmente supportato e consigliato da Google. Android Studio viene fornito in bundle con Android SDK Manager , uno strumento per scaricare i componenti di Android SDK necessari per avviare lo sviluppo di app.

Installazione degli strumenti Android Studio e Android SDK :

1. Scarica e installa Android Studio .
2. Scarica gli ultimi strumenti SDK e gli strumenti della piattaforma SDK aprendo Android Studio e seguendo le istruzioni degli aggiornamenti degli strumenti di Android SDK . Dovresti installare gli ultimi pacchetti stabili disponibili.

Se è necessario lavorare su vecchi progetti che sono stati creati utilizzando versioni precedenti di SDK, potrebbe essere necessario scaricare anche queste versioni

Dal momento che Android Studio 2.2, una copia dell'ultimo OpenJDK viene fornito in bundle con l'installazione ed è il JDK consigliato (Java Development Kit) per tutti i progetti di Android Studio. Ciò elimina la necessità di installare il pacchetto JDK di Oracle. Per utilizzare l'SDK in dotazione, procedere come segue;

1. Apri il tuo progetto in Android Studio e seleziona File> Struttura del progetto nella barra dei menu.
2. Nella pagina Ubicazione SDK e nella posizione JDK , selezionare la casella di controllo Usa JDK incorporato .
3. Clicca OK .

Configura Android Studio

Android Studio fornisce l'accesso a due file di configurazione tramite il menu Guida :

• studio.vmoptions : personalizza le opzioni per la Java Virtual Machine (JVM) di Studio, come la dimensione dell'heap e la dimensione della cache. Nota che su macchine Linux questo file potrebbe essere chiamato studio64.vmoptions , a seconda della versione di Android Studio.
• idea.properties : personalizza le proprietà di Android Studio, come il percorso della cartella dei plug-in o la dimensione massima del file supportato.

Cambia / aggiungi tema

Puoi cambiarlo come preferisci. File->Settings->Editor->Colors & Fonts-> e seleziona un tema. Puoi anche scaricare nuovi temi da http://color-themes.com/ Dopo aver scaricato il file .jar.zip , vai su File -> Import Settings... e scegli il file scaricato.

Compilare le app

Crea un nuovo progetto o apri un progetto esistente in Android Studio e premi il pulsante verde Riproduci sulla barra degli strumenti in alto per eseguirlo. Se è grigio, devi attendere un secondo per consentire ad Android Studio di indicizzare correttamente alcuni file, i cui progressi possono essere visualizzati nella barra di stato in basso.

Se vuoi creare un progetto dalla shell assicurati di avere un file local.properties , che viene creato automaticamente da Android Studio. Se hai bisogno di creare il progetto senza Android Studio hai bisogno di una riga che inizi con sdk.dir= seguita dal percorso dell'installazione dell'SDK.

Apri una shell e vai nella directory del progetto. Immettere ./gradlew aR e premere ./gradlew aR . aR è una scorciatoia per assembleRelease , che scaricherà tutte le dipendenze per te e costruirà l'app. Il file APK finale sarà in ProjectName/ModuleName/build/outputs/apk e sarà chiamato ModuleName-release.apk .

Creare un nuovo progetto

Configura Android Studio

Inizia configurando Android Studio e quindi aprilo. Ora sei pronto per creare la tua prima app per Android!

Nota: questa guida è basata su Android Studio 2.2, ma il processo su altre versioni è principalmente lo stesso.

Configura il tuo progetto

Configurazione di base

Puoi iniziare un nuovo progetto in due modi:

• Fai clic su Start a New Android Studio Project dalla schermata di benvenuto.
• Passa a File → New Project se hai già un progetto aperto.

Successivamente, è necessario descrivere la domanda compilando alcuni campi:

1. Nome applicazione : questo nome verrà mostrato all'utente.

   Esempio: Hello World . Puoi sempre modificarlo in un secondo momento nel file AndroidManifest.xml .

2. Dominio aziendale : è il qualificatore per il nome del pacchetto del progetto.

   Esempio: stackoverflow.com .

3. Nome pacchetto (aka applicationId ): questo è il nome completo del pacchetto di progetto.

   Dovrebbe seguire Reverse Domain Name Notation (aka DNS inverso ): dominio di primo livello . Dominio dell'azienda . [ Segmento aziendale . ] Nome dell'applicazione .

   Esempio: com.stackoverflow.android.helloworld o com.stackoverflow.helloworld . Puoi sempre modificare il tuo ID applicazione sovrascrivendolo nel file gradle .

Non utilizzare il prefisso predefinito "com.example" a meno che tu non intenda inviare la tua richiesta al Google Play Store. Il nome del pacchetto sarà la tua applicazione unica in Google Play.

4. Posizione del progetto : questa è la directory in cui verrà archiviato il progetto.

Selezionare Fattori di forma e Livello API

La finestra successiva ti consente di selezionare i fattori di forma supportati dalla tua app, come telefono, tablet, TV, Wear e Google Glass. I fattori di forma selezionati diventano i moduli di app all'interno del progetto. Per ogni fattore di forma, puoi anche selezionare il livello API per quell'app. Per ottenere ulteriori informazioni, fare clic su Aiuto, scegliere

Grafico delle attuali distribuzioni della versione Android, mostrate quando si fa clic su Aiuto me scegliere.

La finestra Distribuzione piattaforma Android mostra la distribuzione dei dispositivi mobili su cui è in esecuzione ciascuna versione di Android, come illustrato nella Figura 2. Fare clic su un livello API per visualizzare un elenco di funzionalità introdotte nella corrispondente versione di Android. Questo ti aiuta a scegliere il livello API minimo che ha tutte le funzionalità necessarie alle tue app, in modo da poter raggiungere il maggior numero di dispositivi possibile. Quindi fare clic su OK .

Ora, scegli quali piattaforme e versioni di Android SDK supportano l'applicazione.

Per ora, seleziona solo Telefono e Tablet .

L' SDK minimo è il limite inferiore per la tua app. È uno dei segnali che Google Play Store utilizza per determinare su quali dispositivi è possibile installare un'app. Ad esempio, l'app di Stack Exchange supporta Android 4.1+.

Android Studio indicherà (approssimativamente) la percentuale di dispositivi supportati in base all'SDK minimo specificato.

Livelli di API inferiori mirano a più dispositivi ma hanno meno funzioni disponibili.

Al momento di decidere l' SDK minimo , dovresti prendere in considerazione le statistiche di Dashboard , che ti forniranno informazioni sulla versione dei dispositivi che hanno visitato il Google Play Store a livello globale nell'ultima settimana.

Da: Dashboard sul sito web degli sviluppatori Android.

Aggiungi un'attività

Ora selezioneremo un'attività predefinita per la nostra applicazione. In Android, un Activity è un unico schermo che sarà presentato per l'utente. Un'applicazione può ospitare più attività e navigare tra di loro. Per questo esempio, selezionare Empty Activity e fare clic su next.

Qui, se lo desideri, puoi cambiare il nome dell'attività e il layout. Una buona pratica è mantenere l' Activity come suffisso per il nome activity_ e activity_ come prefisso per il nome del layout. Se li lasciamo come predefiniti, Android Studio genererà un'attività per noi chiamata MainActivity e un file di layout chiamato activity_main . Ora fai clic su Finish .

Android Studio creerà e configurerà il nostro progetto, che può richiedere del tempo a seconda del sistema.

Ispezionando il progetto

Per capire come funziona Android, diamo un'occhiata ad alcuni dei file che sono stati creati per noi.

Nel riquadro sinistro di Android Studio, possiamo vedere la struttura della nostra applicazione Android .

Per prima cosa, apriamo AndroidManifest.xml facendo doppio clic su di esso. Il file manifest di Android descrive alcune delle informazioni di base su un'applicazione Android. Contiene la dichiarazione delle nostre attività e alcuni componenti più avanzati.

Se un'applicazione richiede l'accesso a una funzione protetta da un'autorizzazione, deve dichiarare che richiede tale autorizzazione con un elemento <uses-permission> nel manifest. Quindi, quando l'applicazione è installata sul dispositivo, il programma di installazione determina se concedere o meno l'autorizzazione richiesta controllando le autorità che hanno firmato i certificati dell'applicazione e, in alcuni casi, chiedendo all'utente. Un'applicazione può inoltre proteggere i propri componenti (attività, servizi, ricevitori di trasmissione e fornitori di contenuti) con autorizzazioni. Può utilizzare qualsiasi autorizzazione definita da Android (elencata in android.Manifest.permission) o dichiarata da altre applicazioni. O può definire il suo.

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="com.stackoverflow.helloworld">

    <application
        android:allowBackup="true"
        android:icon="@mipmap/ic_launcher"
        android:label="@string/app_name"
        android:supportsRtl="true"
        android:theme="@style/AppTheme">
        <activity android:name=".MainActivity">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />

                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
    </application>
</manifest>

Quindi, apriamo activity_main.xml che si trova in app/src/main/res/layout/ . Questo file contiene dichiarazioni per i componenti visivi della nostra MainActivity. Vedrai visual designer. Ciò consente di trascinare e rilasciare elementi sul layout selezionato.

Puoi anche passare al designer di layout xml facendo clic su "Testo" nella parte inferiore di Android Studio, come mostrato qui:

<?xml version="1.0" encoding="utf-8"?>
<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="com.stackexchange.docs.helloworld.MainActivity">

    <TextView
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Hello World!" />
</RelativeLayout>

Vedrai un widget chiamato TextView all'interno di questo layout, con la proprietà android:text impostata su "Hello World!". Questo è un blocco di testo che verrà mostrato all'utente quando esegue l'applicazione.

Puoi leggere di più su Layout e attributi .

Quindi, diamo un'occhiata a MainActivity . Questo è il codice Java che è stato generato per MainActivity .

public class MainActivity extends AppCompatActivity {

    // The onCreate method is called when an Activity starts
    // This is where we will set up our layout
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        // setContentView sets the Activity's layout to a specified XML layout
        // In our case we are using the activity_main layout
        setContentView(R.layout.activity_main);
    }
}

Come definito nel nostro manifest Android, MainActivity verrà avviato di default quando un utente avvia l'app HelloWorld .

Infine, apri il file denominato build.gradle situato in app/ .
Android Studio utilizza il sistema di generazione Gradle per compilare e creare applicazioni e librerie Android.

apply plugin: 'com.android.application'

android {
signingConfigs {
         applicationName {
             keyAlias 'applicationName'
             keyPassword 'password'
             storeFile file('../key/applicationName.jks')
             storePassword 'anotherPassword'
         }
     }
    compileSdkVersion 26
    buildToolsVersion "26.0.0"

    defaultConfig {
        applicationId "com.stackexchange.docs.helloworld"
        minSdkVersion 16
        targetSdkVersion 26
        versionCode 1
        versionName "1.0"
        signingConfig signingConfigs.applicationName
    }
    buildTypes {
        release {
            minifyEnabled false
            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
        }
    }
}

dependencies {
    compile fileTree(dir: 'libs', include: ['*.jar'])
    testCompile 'junit:junit:4.12'
    compile 'com.android.support:appcompat-v7:26.0.0'
}

Questo file contiene informazioni sulla build e sulla versione dell'app e puoi anche utilizzarlo per aggiungere dipendenze a librerie esterne. Per ora, non apportare modifiche.

Si consiglia di selezionare sempre l'ultima versione disponibile per le dipendenze:

• buildToolsVersion : 26.0.0
• com.android.support:appcompat-v7 : 26.0.0 (luglio 2017)
• Firebase : 11.0.4 (agosto 2017)

compileSdkVersion

compileSdkVersion è il modo per dire a Gradle quale versione dell'SDK di Android compilare la tua app. L'utilizzo del nuovo SDK Android è un requisito per l'utilizzo di una qualsiasi delle nuove API aggiunte in tale livello.

Va sottolineato che la modifica di compileSdkVersion non modifica il comportamento di runtime. Mentre possono essere presenti nuovi avvisi / errori del compilatore quando si modifica compileSdkVersion , compileSdkVersion non è incluso nel tuo APK: è puramente utilizzato in fase di compilazione.

Pertanto, si consiglia vivamente di compilare sempre l'ultimo SDK. Otterrai tutti i vantaggi dei nuovi controlli di compilazione sul codice esistente, eviterà le API appena deprecate e sarai pronto a utilizzare le nuove API.

minSdkVersion

Se compileSdkVersion imposta le nuove API disponibili, minSdkVersion è il limite inferiore per la tua app. minSdkVersion è uno dei segnali che Google Play Store utilizza per determinare su quale dispositivo di un utente può essere installata un'app.

Svolge anche un ruolo importante durante lo sviluppo: per impostazione predefinita, lint viene eseguito contro il tuo progetto, avvisandoti quando usi qualsiasi API sopra la tua minSdkVersion , aiutandoti ad evitare il problema del runtime di tentare di chiamare un'API che non esiste. Il controllo della versione del sistema in fase di esecuzione è una tecnica comune quando si utilizzano le API solo su versioni di piattaforme più recenti.

targetSdkVersion

targetSdkVersion è il modo principale in cui Android offre la compatibilità targetSdkVersion non applicando le modifiche al comportamento a meno che la versione targetSdkVersion venga aggiornata. Ciò consente di utilizzare nuove API prima di utilizzare le modifiche al comportamento. L'aggiornamento a target dell'ultimo SDK dovrebbe essere una priorità elevata per ogni app. Ciò non significa che devi usare ogni nuova funzionalità introdotta, né dovresti aggiornare ciecamente la tua versione di targetSdkVersion senza test.

targetSDKVersion è la versione di Android che è il limite superiore per gli strumenti disponibili. Se targetSDKVersion è inferiore a 23, l'app non deve richiedere autorizzazioni in fase di esecuzione per un'istanza, anche se l'app viene eseguita su API 23+. TargetSDKVersion non impedisce alle versioni Android sopra la versione Android selezionata di eseguire l'app.

Puoi trovare maggiori informazioni sul plugin Gradle:

• Un esempio di base
• Introduzione al plugin Gradle per Android e il wrapper
• Introduzione alla configurazione di build.gradle e dei metodi DSL

Esecuzione dell'applicazione

Ora, eseguiamo la nostra applicazione HelloWorld. È possibile eseguire un dispositivo virtuale Android (che è possibile impostare utilizzando AVD Manager in Android Studio, come descritto nell'esempio seguente) o collegare il proprio dispositivo Android tramite un cavo USB.

Configurazione di un dispositivo Android

Per eseguire un'applicazione da Android Studio sul tuo dispositivo Android, devi abilitare USB Debugging nelle Developer Options nelle impostazioni del tuo dispositivo.

Settings > Developer options > USB debugging

Se le Developer Options non sono visibili nelle impostazioni, vai a About Phone e tocca il Build Number sette volte. Ciò consentirà alle Developer Options di apparire nelle tue impostazioni.

Settings > About phone > Build number

Potrebbe anche essere necessario modificare la configurazione di build.gradle per creare una versione del dispositivo.

Esecuzione da Android Studio

Fai clic sul pulsante verde Run dalla barra degli strumenti nella parte superiore di Android Studio. Nella finestra visualizzata, seleziona il dispositivo su cui desideri eseguire l'applicazione (avvia un dispositivo virtuale Android, se necessario, oppure consulta Impostazione di un dispositivo virtuale Android (Android Device) se è necessario configurarne uno) e fai OK su OK .

Sui dispositivi con Android 4.4 (KitKat) e possibilmente più in alto, verrà mostrato un pop-up per autorizzare il debug USB. Fare OK su OK per accettare.

L'applicazione ora verrà installata ed eseguita sul tuo dispositivo o emulatore Android.

Posizione del file APK

Quando si prepara la domanda per la versione, si configura, si crea e si verifica una versione di rilascio dell'applicazione. Le attività di configurazione sono semplici e comportano operazioni di pulizia del codice di base e di modifica del codice che consentono di ottimizzare l'applicazione. Il processo di compilazione è simile al processo di compilazione di debug e può essere eseguito utilizzando gli strumenti JDK e Android SDK. Le attività di test servono come controllo finale, assicurando che l'applicazione funzioni come previsto in condizioni reali. Quando hai finito di preparare la tua domanda di rilascio, hai un file APK firmato, che puoi distribuire direttamente agli utenti o distribuire attraverso un marketplace di applicazioni come Google Play.

Studio Android

Poiché negli esempi precedenti viene utilizzato Gradle, la posizione del file APK generato è: <Your Project Location>/app/build/outputs/apk/app-debug.apk

IntelliJ

Se sei un utente di IntelliJ prima di passare a Studio e stai importando direttamente il tuo progetto IntelliJ, non è cambiato nulla. La posizione dell'output sarà la stessa sotto:

out/production/...

Nota: questo è diventato deprecato a volte intorno a 1.0

Eclisse

Se stai importando direttamente il progetto Android Eclipse, non farlo! Non appena avrai delle dipendenze nel tuo progetto (vasi o progetti di biblioteca), questo non funzionerà e il tuo progetto non sarà configurato correttamente. Se non hai dipendenze, l'apk si trova nella stessa posizione in cui lo troverai in Eclipse:

bin/...

Programmazione Android senza IDE

Questo è un esempio di Hello World minimalista che utilizza solo gli strumenti Android più basilari.

Requisiti e ipotesi

• Oracle JDK 1.7 o successivo
• Strumenti Android SDK (solo gli strumenti da riga di comando )

Questo esempio presuppone Linux. Potrebbe essere necessario regolare la sintassi per la propria piattaforma.

Impostazione dell'SDK Android

Dopo aver disimballato la versione dell'SDK:

1. Installa pacchetti aggiuntivi usando il gestore SDK. Non utilizzare android update sdk --no-ui come indicato nel file Readme.txt; scarica circa 30 GB di file non necessari. Usa invece il gestore SDK interattivo di android sdk per ottenere il minimo raccomandato di pacchetti.

2. Aggiungi le seguenti directory JDK e SDK al tuo PATH di esecuzione. Questo è opzionale, ma le istruzioni seguenti lo assumono.

   • JDK / bin
   • SDK / platform-tools
   • SDK / strumenti
   • SDK / build-tools / LATEST (come installato nel passaggio 1)

3. Crea un dispositivo virtuale Android. Utilizzare l'AVD Manager interattivo ( android avd ). Dovresti giocherellare un po 'e cercare consigli; le istruzioni in loco non sono sempre utili.

   (Puoi anche usare il tuo dispositivo)

4. Esegui il dispositivo:

   emulator -avd DEVICE
   

5. Se la schermata del dispositivo sembra bloccata, fai scorrere per sbloccarla.

   Lasciarlo in esecuzione mentre codifichi l'app.

Codifica l'app

6. Passare a una directory di lavoro vuota.

7. Crea il file sorgente:

   mkdir --parents src/dom/domain
   touch src/dom/domain/SayingHello.java
   

   Soddisfare:

   package dom.domain;
   import android.widget.TextView;
   
   public final class SayingHello extends android.app.Activity
   {
       protected @Override void onCreate( final android.os.Bundle activityState )
       {
           super.onCreate( activityState );
           final TextView textV = new TextView( SayingHello.this );
           textV.setText( "Hello world" );
           setContentView( textV );
       }
   }
   

8. Aggiungi un manifest:

   touch AndroidManifest.xml
   

   Soddisfare:

   <?xml version='1.0'?>
   <manifest xmlns:a='http://schemas.android.com/apk/res/android'
    package='dom.domain' a:versionCode='0' a:versionName='0'>
       <application a:label='Saying hello'>
           <activity a:name='dom.domain.SayingHello'>
                <intent-filter>
                   <category a:name='android.intent.category.LAUNCHER'/>
                   <action a:name='android.intent.action.MAIN'/>
                   </intent-filter>
               </activity>
           </application>
       </manifest>
   

9. Crea una sottodirectory per le risorse dichiarate:

   mkdir res
   

   Lascialo vuoto per ora.

Costruire il codice

10. Genera l'origine per le dichiarazioni di risorse. Sostituisci qui il percorso corretto per il tuo SDK e l' API installata da costruire contro (ad esempio "android-23"):

    aapt package -f \
      -I SDK/platforms/android-API/android.jar \
      -J src -m \
      -M AndroidManifest.xml -S res -v
    

    Le dichiarazioni delle risorse (descritte più avanti di seguito) sono in realtà facoltative. Nel frattempo la chiamata sopra non fa nulla se res / è ancora vuoto.

11. Compilare il codice sorgente in bytecode Java (.java → .class):

    javac \
      -bootclasspath SDK/platforms/android-API/android.jar \
      -classpath src -source 1.7 -target 1.7 \
      src/dom/domain/*.java
    

12. Tradurre il bytecode da Java ad Android (.class → .dex):

    Innanzitutto usando Jill (.class → .jayce):

    java -jar SDK/build-tools/LATEST/jill.jar \
      --output classes.jayce src
    

    Quindi Jack (.jayce → .dex):

    java -jar SDK/build-tools/LATEST/jack.jar \
      --import classes.jayce --output-dex .
    

    Il bytecode di Android era chiamato "codice eseguibile Dalvik" e quindi "dex".

    Puoi sostituire i passaggi 11 e 12 con una sola chiamata a Jack, se lo desideri; può compilare direttamente dal sorgente Java (.java → .dex). Ma ci sono dei vantaggi nella compilazione con javac . È uno strumento più conosciuto, meglio documentato e più ampiamente applicabile.

13. Imballare i file di risorse, incluso il manifest:

    aapt package -f \
      -F app.apkPart \
      -I SDK/platforms/android-API/android.jar \
      -M AndroidManifest.xml -S res -v
    

    Ciò si traduce in un file APK parziale (pacchetto di applicazioni Android).

14. Crea l'APK completo utilizzando lo strumento ApkBuilder :

    java -classpath SDK/tools/lib/sdklib.jar \
      com.android.sdklib.build.ApkBuilderMain \
      app.apkUnalign \
      -d -f classes.dex -v -z app.apkPart
    

    Si avvisa, "QUESTO STRUMENTO È DEPRECATO. Vedi --help per ulteriori informazioni." Se --help fallisce con una ArrayIndexOutOfBoundsException , allora non passa alcun argomento:

    java -classpath SDK/tools/lib/sdklib.jar \
      com.android.sdklib.build.ApkBuilderMain
    

    Spiega che la CLI ( ApkBuilderMain ) è deprecata a favore di chiamare direttamente l'API Java ( ApkBuilder ). (Se sai come farlo dalla riga di comando, ti preghiamo di aggiornare questo esempio.)

15. Ottimizza l'allineamento dei dati dell'APK ( pratica consigliata ):

    zipalign -f -v 4 app.apkUnalign app.apk
    

Installazione e funzionamento

16. Installa l'app sul dispositivo Android:

    adb install -r app.apk
    

17. Avvia l'app:

    adb shell am start -n dom.domain/.SayingHello
    

    Dovrebbe correre e salutare.

È tutto. Questo è quello che serve per dire ciao usando gli strumenti base di Android.

Dichiarare una risorsa

Questa sezione è facoltativa. Le dichiarazioni delle risorse non sono richieste per una semplice app "ciao mondo". Se non sono necessari nemmeno per la tua app, puoi semplificare la compilazione della versione omettendo il punto 10 e rimuovendo il riferimento alla directory res / dal punto 13.

Altrimenti, ecco un breve esempio di come dichiarare una risorsa e come farla riferimento.

18. Aggiungi un file di risorse:

    mkdir res/values
    touch res/values/values.xml
    

    Soddisfare:

    <?xml version='1.0'?>
    <resources>
        <string name='appLabel'>Saying hello</string>
    </resources>
    

19. Fare riferimento alla risorsa dal manifest XML. Questo è uno stile di riferimento dichiarativo:

    <!-- <application a:label='Saying hello'> -->
         <application a:label='@string/appLabel'>
    

20. Fare riferimento alla stessa risorsa dal codice sorgente Java. Questo è un riferimento imperativo:

    // v.setText( "Hello world" );
       v.setText( "This app is called "
         + getResources().getString( R.string.appLabel ));
    

21. Provare le modifiche precedenti ricostruendo, reinstallando e rieseguendo l'applicazione (passaggi 10-17).

    Dovrebbe riavviare e dire "Questa app si chiama Dire ciao".

Disinstallare l'app

adb uninstall dom.domain

Guarda anche

• domanda originale - La domanda originale che ha richiesto questo esempio
• esempio di lavoro : uno script di compilazione funzionante che utilizza i comandi precedenti

Fondamenti applicativi

Le app Android sono scritte in Java. Gli strumenti di Android SDK compilano il codice, i dati e i file di risorse in un APK (pacchetto Android). Generalmente, un file APK contiene tutto il contenuto dell'app.

Ogni app viene eseguita sulla propria macchina virtuale (VM) in modo che l'app possa essere isolata da altre app. Il sistema Android funziona con il principio del minimo privilegio. Ogni app ha solo accesso ai componenti necessari per svolgere il proprio lavoro, e non di più. Tuttavia, ci sono modi per un'app di condividere dati con altre app, ad esempio condividendo l'ID utente di Linux tra le app, oppure le app possono richiedere l'autorizzazione per accedere ai dati del dispositivo come scheda SD, contatti ecc.

Componenti dell'app

I componenti dell'app sono gli elementi costitutivi di un'app Android. Ogni componente svolge un ruolo specifico in un'app Android che ha uno scopo ben preciso e ha cicli di vita distinti (il flusso di come e quando il componente viene creato e distrutto). Ecco i quattro tipi di componenti dell'app:

1. Attività: un'attività rappresenta una singola schermata con un'interfaccia utente (UI). Un'app Android può avere più di un'attività. (ad esempio un'app di posta elettronica potrebbe avere un'attività per elencare tutte le e-mail, un'altra per mostrare il contenuto di ciascuna e-mail e un'altra per comporre una nuova e-mail.) Tutte le attività in un'app interagiscono per creare un utente eXperience (UX).
2. Servizi: un servizio viene eseguito in background per eseguire operazioni di lunga durata o per eseguire lavori per processi remoti. Un servizio non fornisce alcuna interfaccia utente, viene eseguito solo in background con l'input dell'utente. (ad esempio un servizio può riprodurre musica in sottofondo mentre l'utente si trova in un'altra App, o potrebbe scaricare dati da Internet senza bloccare l'interazione dell'utente con il dispositivo Android.)
3. Content Provider: un fornitore di contenuti gestisce i dati delle app condivise. Esistono quattro modi per archiviare i dati in un'app: possono essere scritti su un file e memorizzati nel file system, inseriti o aggiornati in un database SQLite, pubblicati sul Web o salvati in qualsiasi altra posizione di archiviazione permanente a cui l'app può accedere . Attraverso i fornitori di contenuti, altre app possono interrogare o persino modificare i dati. (ad esempio, il sistema Android fornisce un fornitore di contenuti che gestisce le informazioni di contatto dell'utente in modo che qualsiasi app che disponga dell'autorizzazione possa interrogare i contatti.) I provider di contenuti possono anche essere utilizzati per salvare i dati privati ​​dell'applicazione per una migliore integrità dei dati.
4. Ricevitori di trasmissione: un ricevitore di trasmissione risponde alle trasmissioni di annunci a livello di sistema (ad esempio una trasmissione che annuncia lo spegnimento dello schermo, la batteria è scarica, ecc.) O dalle app (ad esempio per far sapere alle altre app che alcuni dati sono stati scaricato sul dispositivo ed è disponibile per l'uso). I ricevitori broadcast non dispongono di interfacce utente ma possono mostrare notifiche nella barra di stato per avvisare l'utente. Solitamente i ricevitori di trasmissione vengono utilizzati come gateway per altri componenti dell'app, costituiti principalmente da attività e servizi.

Un aspetto unico del sistema Android è che ogni app può avviare un componente di un'altra app (ad esempio, se si desidera effettuare chiamate, inviare SMS, aprire una pagina Web o visualizzare una foto, c'è un'app che già lo fa e l'app può farne uso, invece di sviluppare una nuova attività per lo stesso compito).

Quando il sistema avvia un componente, avvia il processo per quell'app (se non è già in esecuzione, ovvero solo un processo foreground per app può essere eseguito in un dato momento su un sistema Android) e crea un'istanza delle classi necessarie per quel componente. Pertanto il componente viene eseguito sul processo di quell'app a cui appartiene. Pertanto, a differenza delle app su altri sistemi, le app Android non hanno un singolo punto di ingresso (non esiste un metodo main() ).

Poiché il sistema esegue ciascuna app in un processo separato, un'app non può attivare direttamente i componenti di un'altra app, tuttavia il sistema Android può. Pertanto, per avviare un componente di un'altra app, un'app deve inviare un messaggio al sistema che specifica l'intenzione di avviare quel componente, quindi il sistema avvierà quel componente.

Contesto

Le istanze della classe android.content.Context forniscono la connessione al sistema Android che esegue l'applicazione. È necessaria l'istanza del contesto per ottenere l'accesso alle risorse del progetto e alle informazioni globali sull'ambiente dell'app.

Facciamo un esempio facile da digerire: considera di essere in un hotel e vuoi mangiare qualcosa. Chiami il servizio in camera e chiedi loro di portarti qualcosa o ripulire le cose per te. Ora pensa a questo hotel come a un'app per Android, a te stesso come a un'attività, e la persona del servizio in camera è quindi il tuo contesto, che ti consente di accedere alle risorse dell'hotel come servizio in camera, cibo, ecc.

Ancora un altro esempio: sei in un ristorante seduto su un tavolo, ogni tavolo ha un accompagnatore, quando mai vuoi ordinare prodotti alimentari chiedi all'addetto di farlo. L'addetto quindi effettua l'ordine e i prodotti alimentari vengono serviti sul tavolo. Anche in questo esempio, il ristorante è un'app per Android, i tavoli o i clienti sono componenti App, gli articoli di cibo sono le tue risorse App e l'addetto è il tuo contesto, dandoti così un modo per accedere alle risorse come gli alimenti.

L'attivazione di uno dei componenti sopra richiede l'istanza del contesto. Non solo solo sopra, ma quasi tutte le risorse di sistema: creazione dell'interfaccia utente che utilizza le viste (discusse in seguito), creazione di istanze di servizi di sistema, avvio di nuove attività o servizi: tutto richiede un contesto.

Una descrizione più dettagliata è scritta qui .

Configurazione di un AVD (dispositivo virtuale Android)

TL; DR Fondamentalmente ci consente di simulare dispositivi reali e testare le nostre app senza un dispositivo reale.

Secondo la documentazione per gli sviluppatori Android ,

una definizione di dispositivo virtuale Android (AVD) consente di definire le caratteristiche di un dispositivo Android Phone, Tablet, Android Wear o Android TV che si desidera simulare nell'emulatore Android. AVD Manager ti aiuta a creare e gestire facilmente gli AVD.

Per configurare un AVD, attenersi alla seguente procedura:

1. Fare clic su questo pulsante per visualizzare AVD Manager:

2. Dovresti vedere una finestra di dialogo come questa:

3. Ora fai clic sul pulsante + Create Virtual Device... Questo farà apparire la finestra di dialogo di configurazione del dispositivo virtuale:

4. Selezionare qualsiasi dispositivo desiderato, quindi fare clic su Next :

5. Qui devi scegliere una versione per Android per il tuo emulatore. Potrebbe anche essere necessario scaricarlo prima facendo clic su Download . Dopo aver scelto una versione, fare clic su Next .

6. Qui, inserisci un nome per il tuo emulatore, l'orientamento iniziale e se vuoi visualizzare una cornice attorno ad esso. Dopo aver scelto tutti questi, fare clic su Finish .

7. Ora hai un nuovo AVD pronto per lanciare le tue app su di esso.