Sviluppare la tua prima applicazione Android

Sviluppare la tua prima applicazione Android

Perché ci interessa Android? Ci preoccupiamo per la piattaforma Android perché è la piattaforma mobile più diffusa del pianeta ed è accessibile ai consumatori di tutto il mondo. Nelle economie in cui la proprietà di un personal computer è un lusso, l’utilizzo dei dispositivi mobili è la norma–e Android sta giocando un ruolo importante nel collegare le persone tra loro. Come si impara in questo tutorial, Android ha un approccio distinto alle applicazioni. L’architettura di Android permette un ambiente software altamente personalizzabile grazie al suo runtime vincolante delle azioni richieste e il codice per soddisfare tali richieste. Che si tratti di considerazioni di mercato o gli aspetti tecnici di Android, si tratta di una piattaforma vale la pena di esame. Inoltre, se stai prendendo in seria considerazione un’esperienza mobile per la tua piattaforma, non puoi ignorare Android.

Prerequisiti

Questo tutorial richiede diverse tecnologie che funzionano insieme. Hai bisogno di tutti loro per questo tutorial.

• Android Studio – Android Studio è il punto di partenza principale per la costruzione di applicazioni Android
• dispositivo Android o emulatore – Si vuole sia un dispositivo Android fisico, o l’emulatore Android. In entrambi i casi, la lettura di questo tutorial vi aiuterà a comprendere i punti di connessione di base di un’applicazione Android.

• Codice sorgente-Frammenti di codice sorgente in questo tutorial includono:

  • AndroidManifest.snippet xml-Questo file è il descrittore di distribuzione dell’applicazione per le applicazioni Android.
  • Attività principale.java-Questo implementa un’attività Android, il punto di ingresso principale per l’applicazione di esempio di questo tutorial.
  • Activity_main.xml-Contiene le definizioni per gli elementi visivi, o risorse, per l’utilizzo da parte delle attività Android.
  • AndroidManifest.xml complete-Questo elenca un AndroidManfest completo.file xml, insieme a una descrizione di ciascuno degli elementi importanti.

Introducendo l’architettura Android

Prima di tuffarsi a destra nei pro ei contro di Android Studio e lo sviluppo di applicazioni Android, diamo uno sguardo all’architettura di Android e alcuni dei termini chiave che saranno utili nel tutorial e oltre, come si inizia a costruire applicazioni Android per te.

Terminologia Android

Una comprensione dei termini di seguito è utile nello sviluppo di applicazioni Android con Android Studio.

• Android è un ambiente operativo open source mirato per i dispositivi mobili. Sempre più spesso, Android si trova in applicazioni al di là di”smartphone”. Questi includono tecnologia indossabile, elettrodomestici come proiettori, altoparlanti e televisori e persino automobili.
• Emulator è uno strumento software rappresentativo di un altro sistema. Spesso, un emulatore è un ambiente che gira su un personal computer (PC, Mac, macchina Linux) che emula un altro ambiente, come un dispositivo mobile-computing.
• Linux è un kernel di sistema operativo open source al centro di molte piattaforme informatiche, inclusi server, computer desktop, appliance di rete e dispositivi di calcolo mobile. Android funziona su un kernel Linux.
• Android Runtime (ART) è un ambiente operativo presente nello stack Android, che esegue il codice dell’applicazione in fase di esecuzione. Il tempo di esecuzione di Android sostituisce la “legacy” Dalvik Virtual Machine (VM) dalle versioni precedenti di Android che operavano in modo simile a una VM Java compatibile.

L’intento

Fin dalla sua nascita, Android è diventato una forza dominante nello spazio del telefono cellulare. Il suo modello di applicazione è unico in quanto le applicazioni non sono monolitiche, applicazioni di menu carichi che richiedono una grande quantità di clic e toccando per operare. Certo, ci sono menu e pulsanti da sfruttare, ma Android ha un elemento di design innovativo per la sua architettura noto come un intento.

Un intent è un costrutto che consente a un’applicazione di emettere una richiesta, che è un po ‘ come un segno di aiuto. Potrebbe assomigliare a questi:

• “Ricercato: Un’applicazione per aiutarmi a cercare un contatto”
• “Wanted: Un’applicazione per aiutarmi a visualizzare questa immagine”
• ” Wanted: Un’applicazione per eseguire questa ricerca geografica.”

In modo simile e complementare, le applicazioni possono registrarsi come capaci e interessati a soddisfare le varie richieste o intenti. Per seguire il paradigma della pubblicità classificata, questi potrebbero assomigliare a questo:

• “Disponibile: Applicazione pronta e disposta a presentare i record di contatto in modo chiaro e conciso”
• ” Disponibile: Applicazione pronta e disposta a eseguire una ricerca geografica.”

Questi sono esempi di IntentFilters, che vengono discussi di seguito.

Le applicazioni IntentFilter

annunciano la loro disponibilità a eseguire questi tipi di operazioni tramite un costrutto noto comeIntentFilter . IntentFilter è registrato in fase di esecuzione o è enumerato in AndroidManifest.file xml. Il seguente frammento proviene da un’applicazione Android che risponde ai messaggi SMS (testo) in arrivo:

<receiver android:name=".MySMSMailBox" android:exported="true"> <intent-filter> <action android:name="android.provider.Telephony.SMS_RECEIVED" /> </intent-filter> </receiver>

IntentFilter, la sezione successiva introduce i quattro tipi principali di applicazioni Android.

Tipi di applicazioni Android

prendiamo un momento per esaminare i quattro principali tipi di applicazioni Android:

• Attività di
• Servizio
• Ricevitore
• ContentProvider

Ci sarà anche uno sguardo alla vista per visualizzare l’interfaccia utente (UI) di elementi.

Activity apps

L’attività è la forma più visibile e prominente di un’applicazione Android. Un’attività presenta l’interfaccia utente a un’applicazione, insieme all’assistenza di una classe nota come vista. La classe view è implementata come vari elementi dell’interfaccia utente, come caselle di testo, etichette, pulsanti e altre interfacce utente tipiche delle piattaforme informatiche, mobili o otherwise.An l’applicazione può contenere una o più attività. Un’attività viene in genere definita in una relazione uno a uno con le schermate presenti in un’applicazione.

Un’applicazione si sposta da un’attività all’altra chiamando un metodo noto come startActivity()o startSubActivity(). Il metodo precedente viene utilizzato quando l’applicazione desidera semplicemente “passare” alla nuova attività. Quest’ultimo viene utilizzato quando si desidera un paradigma di chiamata/risposta sincrona. In entrambi i casi, un intento viene passato come argomento al metodo chiamato.

È responsabilità del sistema operativo determinare l’attività più qualificata per soddisfare l’intento specificato.

Servizio e ricevitore apps

Come altri ambienti di calcolo multi-tasked, ci sono applicazioni in esecuzione “in background” che svolgono varie funzioni. Android chiama questi tipi di servizi di applicazioni. Il servizio è un’applicazione Android che non ha interfaccia utente.

Il ricevitore è un componente dell’applicazione che riceve richieste per elaborare gli intenti. Come il servizio, un ricevitore non ha, nella pratica normale, un elemento UI. I ricevitori sono in genere registrati nel AndroidManifest.file xml.

Il seguente frammento (che è lo stesso di quello mostrato per IntentFilter) è un esempio di un’applicazione ricevente in fase di definizione. Si noti che l’attributo name del ricevitore è la classe Java responsabile dell’implementazione del ricevitore.

<receiver android:name=".MySMSMailBox" android:exported="true"> <intent-filter> <action android:name="android.provider.Telephony.SMS_RECEIVED" /> </intent-filter> </receiver>

Il ContentProvider è il meccanismo Android per l’astrazione del data store. Diamo un’occhiata a un tipo specifico di dati trovati su un dispositivo mobile: la rubrica o il database dei contatti. La rubrica contiene tutti i contatti e i numeri di telefono che una persona potrebbe richiedere quando utilizza un telefono cellulare.

Il ContentProvider è un meccanismo per astrarre l’accesso a un particolare archivio dati. In molti modi, ContentProvider agisce nel ruolo di un server di database. Le operazioni per leggere e scrivere contenuti in un particolare archivio dati devono essere passate attraverso un ContentProvider appropriato, anziché accedere direttamente a un file o database. Potrebbero esserci sia “client” che “implementazioni” di ContentProvider.

Visualizzazioni Android

Le visualizzazioni Android sono il meccanismo dell’interfaccia utente per mettere le cose sullo schermo di un dispositivo Android. L’attività Android utilizza le viste per visualizzare gli elementi dell’interfaccia utente. Alcuni dei disegni di layout più popolari includono:

• LinearVertical-Ogni elemento successivo segue il suo predecessore scorrendo sotto di esso in una singola colonna.
• Lineariorizzontal – Ogni elemento successivo segue il suo predecessore scorrendo a destra in una singola riga.
• Tabella-Una serie di righe e colonne, simile a una tabella HTML. Ogni cella può contenere un elemento di visualizzazione.
• Vincolo-Ogni elemento è “vincolato” a un aspetto del display come la parte superiore o laterale dello schermo o un altro elemento. Questo layout aiuta nella costruzione di applicazioni “reattive” ed è l’erede apparente del layout relativo legacy introdotto nelle versioni precedenti della piattaforma Android.

Dopo aver selezionato un particolare layout (o una combinazione di layout), le singole viste vengono utilizzate per definire l’interfaccia utente.

Visualizza elementi consistono di familiarità elementi dell’interfaccia utente, tra cui:

• Pulsante
• ImageView
• EditText per raccogliere l’input con vari filtri, come la Data o Numerico
• TextView (simile ad una etichetta, visualizza il testo statico)
• Casella di controllo
• Radio Pulsante
• Spinner (simile a una “discesa” della casella combinata)
• completamento automatico (EditText con auto di testo-completo di funzionalità)

le Viste sono definiti in un file XML. Ad esempio, questo mostra una semplice vista LinearVertical, con pulsanti e textviews definiti:

<?xml version="1.0" encoding="utf-8"?><LinearLayout xmlns:android="http://schemas.android.com/apk/res/android" android:orientation="vertical" android:layout_width="match_parent" android:layout_height="match_parent" ><TextView android:layout_width="match_parent" android:layout_height="wrap_content" android:text="Activity 1!" /><TextView android:layout_width="match_parent" android:layout_height="wrap_content" android:text="Activity 1, second text view!" /><Button android:layout_width="wrap_content" android:layout_height="wrap_content" android:text="Switch To Activity 2" /></LinearLayout>

https://developer.android.com/, e scorrere verso il basso per scaricare Android Studio. Android Studio è disponibile per Windows, Mac e Linux.

Android Studio è basato sulla piattaforma IntelliJ IDE. Se sei il tipo di sviluppatore che è interessante nel sfruttare le scorciatoie da tastiera, potresti considerare di saperne di più su IntelliJ dal sito Web di jetbrains.

Per iniziare con Android SDK

Ora che abbiamo Android Studio installato, è il momento di ottenere il Software Developer Kit (SDK) per Android.

Ma, prima di andare oltre, abbiamo bisogno di avere una discussione sulle versioni di Android.

Versioni di Android

Sin dal suo inizio, Android è stato rilasciato sotto un percorso un po ‘ parallelo di revisioni di rilascio numeriche, livelli API e anche nomi “dolci” tra cui Jelly Bean, KitKat, Oreo e altri preferiti dolciari.

È facile essere sopraffatti dalle scelte disponibili. Per ora è necessario solo un po ‘ di comprensione di questo “paesaggio versione” per iniziare come uno sviluppatore Android.

Ci sono molte versioni, o revisioni, di Android in natura. Se avete intenzione di scrivere un’applicazione per il rilascio commerciale, è necessario sapere quali dispositivi si stanno prendendo di mira. Wikipedia ha un bel riassunto delle versioni di Android, i nomi, le date di rilascio, nonché una grafica raffigurante il numero approssimativo di ciascun dispositivo sul mercato.

I dispositivi più recenti eseguono il codice più recente e i dispositivi più vecchi possono essere in qualche modo limitati nella loro capacità di eseguire l’aggiornamento a una versione più recente di Android. A volte le versioni più recenti supportano funzionalità che i vecchi telefoni non sono in grado di supportare (si pensi seconda fotocamera, Near Field Communications, e così via). Un altro motivo non banale che i telefoni più vecchi potrebbero non essere in grado di eseguire l’ultima versione di Android è che sia il produttore che il vettore di telecomunicazioni (Verizon, AT&T e così via) devono supportare il software in esecuzione all’interno del loro ecosistema. Il supporto di un nuovo sistema operativo richiede risorse da parte del produttore del dispositivo e del vettore. Le forze di mercato suggeriscono che questi partecipanti al mercato sono più interessati alle vendite future che a sostenere le vendite precedenti e investono di conseguenza il loro capitale umano.

Come sviluppatore di software, cosa importa che ci siano nuove versioni del sistema operativo? Questo si suddivide in due grandi categorie quando si tratta di applicazioni di programmazione:

• Una nuova versione del sistema operativo introduce spesso nuove funzionalità che possiamo sfruttare e/o la nostra base di utenti si aspetta che le nostre applicazioni supportino.
• Le funzionalità più vecchie (o legacy) dell’ambiente potrebbero effettivamente ostacolare le funzionalità più recenti e/o rappresentare un approccio inferiore alla fornitura di un set specifico di funzionalità. A volte il codice deve essere effettivamente rimosso dalle definizioni API. C’è un termine speciale per questa “rimozione” del codice precedentemente funzionante – lo chiamiamo “deprecazione del codice”. Quando un’API è stata contrassegnata per la rimozione, diciamo che questa è un’API deprecata. Questo è essenzialmente un messaggio allo sviluppatore che va in questo modo: “Attenzione” questo codice verrà rimosso in futuro, si prega di pianificare di conseguenza.”

La piattaforma Android è stata abbastanza liberale (cioè favorevole allo sviluppatore) con il suo approccio al codice deprecato consentendo alle applicazioni di continuare a utilizzare le API più vecchie per un po ‘ di tempo dopo essere state contrassegnate come deprecate. (Questo approccio contrasta con l’approccio di Apple con il codice deprecato in iOS in cui il codice precedente può semplicemente smettere di funzionare sulla prossima versione del sistema operativo. Con iOS, anche il linguaggio di programmazione sembra cambiare mentre non stiamo cercando!)

Mentre Android potrebbe essere un po ‘ più indulgente con la sua lunga sofferenza del codice deprecato, dobbiamo tenere d’occhio il tag della documentazione che dice che una particolare API è deprecata. Se un codice che stiamo utilizzando è contrassegnato come deprecato, dovremo eventualmente cambiare il nostro approccio in una versione futura della nostra applicazione perché qualsiasi API contrassegnata come deprecata può essere rimossa in una versione futura. I marcatori di deprecazione nell’SDK sono la nostra tabella di marcia verso future opportunità di miglioramento e potenziali mal di testa. A volte il” nuovo ” modo di fare le cose è semplice e diretto, ma non in ogni caso!

Essere uno sviluppatore di applicazioni mobili di successo richiede un investimento continuo per tutta la durata di un’applicazione in cui il tempo tende a passare come anni di cani very molto rapidamente!

Con questa introduzione di base alle versioni di Android, è il momento di ottenere l’SDK Android.

Ottenere e installare Android SDK

Avviare Android Studio. Nel menu Strumenti, selezionare SDK Manager. Questa opzione di menu carica la finestra di dialogo Preferenze di Android Studio e preseleziona il sottomenu Android SDK. Questo menu è il nostro mezzo principale per interagire con i vari SDK disponibili per le molte versioni di Android.

Ad ogni versione del sistema operativo, il livello API aumenta. Si noti che la revisione aumenta più lentamente del livello API. Puoi pensare alla revisione come a una ” generazione “della piattaforma o come a un numero di versione” Principale”. Quando si sfoglia la documentazione di Android, assicurarsi di notare quale livello API è stata introdotta una particolare funzionalità. Ogni API è disponibile al livello di API indicato e superiore, a meno che l’API non sia stata deprecata e successivamente rimossa. Ad esempio, l’API ContactsContract è stata introdotta al livello 5, che è abbastanza “vecchio” a questo punto.

Selezionare uno o due livelli SDK con cui lavorare per ora. Il Gestore SDK scaricherà successivamente i file correlati e li renderà disponibili per l’uso all’interno di Android Studio.

Anche sotto il menu Strumenti c’è un’opzione per AVD Manager. AVD sta per Dispositivo virtuale Android. Questo è l’emulatore. L’emulatore è utile perché ci permette di testare le applicazioni su vari tipi di dispositivi, dimensioni e versioni. Le schermate in questo tutorial sono prese dall’emulatore. Più su questo più tardi.

Costruisci la tua prima applicazione Android

Questo tutorial ti guida attraverso la creazione di un’applicazione Android di base, chiamataSaySomething , utilizzando Android Studio e dimostrandolo sull’emulatore Android.

Ottieni il codice

Passaggio 1: Crea un nuovo progetto

1. Seleziona File > Nuovo progetto.

2. Compila la finestra di dialogo Crea progetto Android e fai clic su Avanti.

   

   I requisiti per il nuovo progetto includono:

   • Nome dell’applicazione
   • Dominio aziendale (questo viene invertito in com.dominio) per mantenere le applicazioni partizionate anche se hanno lo stesso nome dell’applicazione.
   • Posizione del progetto – dove archiviare i file
   • Il nome del pacchetto è suggerito dal nome dell’applicazione e dal dominio aziendale
   • Per impostazione predefinita, le applicazioni Android sono scritte in Java. Se si desidera supportare linguaggi alternativi, come C++ (per il codice nativo) o Kotlin, selezionare le caselle di controllo appropriate.

3. Nella finestra di dialogo Dispositivi Android di destinazione, specificare il livello API e le piattaforme di destinazione. Come accennato in precedenza, Android è per più di semplici telefoni, anche se per i nostri scopi ci sarà semplicemente selezionare il fattore di forma del telefono e Tablet per questo tutorial. Quindi, fare clic su Avanti.

   

4. Nella finestra di dialogo Aggiungi un’attività a Mobile, selezionare il tipo di attività vuoto. Quindi, fare clic su Avanti.

   

   Questo creerà un’applicazione predefinita pronta per essere costruita ed eseguita direttamente da Android Studio.

5. Nella finestra di dialogo Configura attività, assegnare un nome ai file per l’applicazione.

   

Passo 2: Esaminare il codice

La figura seguente mostra i componenti del nostro nuovo progetto:

Ci sono due cartelle: app e Gradle Script.

• La cartellaapp contiene tutto il codice della nostra applicazione.
• La cartella manifesta nella cartella app contiene AndroidManifest.xml che è il descrittore di distribuzione per questa applicazione. Questo file indica al dispositivo Android come interagire con l’applicazione, quale attività mostrare quando l’applicazione viene avviata, quali sono i servizi dell’applicazione, quali icone visualizzare e molto altro.
• La cartella java contiene il codice sorgente dell’applicazione. In questo caso, il file che implementa la nostra attività più un paio di file di classe per l’esecuzione di test automatici (che ignoreremo per questo tutorial).
• La cartella res contiene le risorse per l’applicazione, incluse icone, file di layout, stringhe, menu e così via.
• La cartella Gradle Scripts contiene tutti gli elementi scrivibili per la creazione dell’applicazione. Il sistema di compilazione Gradle è un argomento a sé stante. Per ora, capire che questi script governano il processo di costruzione dell’applicazione – e soprattutto per i progetti più maturi e team, ciascuno di questi passaggi è in grado di essere eseguito dalla riga di comando. Questo è importante perché questo approccio supporta l’automazione e rientrano nella categoria di integrazione continua.

Ora, esaminiamo il codice sorgente in dettaglio.

Attività primaria per l’applicazione

La nostra applicazione di esempio consiste in una singola attività, denominata MainActivity.

package com.navitend.saysomething;import android.content.Intent;import android.net.Uri;import android.os.Bundle;import android.support.v7.app.AppCompatActivity;import android.view.View;import android.util.Log;import android.widget.Button;import android.widget.TextView;import android.widget.EditText;public class MainActivity extends AppCompatActivity { @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); Log.i("IBM","Hello there logcat!"); setContentView(R.layout.activity_main); final Button btnHitMe = (Button) findViewById(R.id.hitme); final Button btnMapMe = (Button) findViewById(R.id.mapme); final TextView tvLabel = (TextView) findViewById(R.id.thelabel); final EditText etLatitude = (EditText) findViewById(R.id.etLatitude); final EditText etLongitude = (EditText) findViewById(R.id.etLongitude); btnHitMe.setOnClickListener(new View.OnClickListener() { @Override public void onClick(View view) { tvLabel.setText("Ouch!"); } } ); btnMapMe.setOnClickListener(new View.OnClickListener() { @Override public void onClick(View view) { String coords = etLatitude.getText()+","+etLongitude.getText(); Log.i("IBM",coords); Uri mapsIntentUri = Uri.parse("geo:" + coords); Intent mapIntent = new Intent(Intent.ACTION_VIEW, mapsIntentUri); startActivity(mapIntent); } } ); }}

MainActivity è una normale classe Java, con un pacchetto e importazioni, come previsto.

Le risorse per l’applicazione

Le risorse in Android sono organizzate in una sottodirectory del progetto denominata res, come descritto in precedenza. Le risorse rientrano in una serie di categorie. Tre di queste categorie sono:

• Drawables
• Layout – Questa cartella contiene file XML che rappresentano i layout e le viste dell'applicazione. Questi saranno esaminati in dettaglio di seguito.
• Valori – Questa cartella contiene un file denominato strings.xml. Questo è il mezzo principale per la localizzazione delle stringhe per l'applicazione. I colori del file.xml è utile per definire i codici colore utilizzati dall'applicazione. Questo file è analogo a un foglio di stile css per chi ha familiarità con le tecniche di programmazione web.

Risorse UI primarie in main_activity.file xml

L’applicazione di esempio contiene una singola attività e una singola vista. L’applicazione contiene un file denominato main_activity.xml che rappresenta gli aspetti visivi dell’interfaccia utente principale dell’attività. Si noti che non vi è alcun riferimento nel main_activity.xml dove viene utilizzato il layout. Ciò significa che può essere utilizzato in più di un’attività, se lo si desidera. Vedere il seguente elenco di codici

<?xml version="1.0" encoding="utf-8"?><LinearLayout xmlns:android="http://schemas.android.com/apk/res/android" xmlns:app="http://schemas.android.com/apk/res-auto" xmlns:tools="http://schemas.android.com/tools" android:layout_width="match_parent" android:layout_height="match_parent" android:orientation="vertical" android:gravity="center_vertical"> <LinearLayout android:layout_width="match_parent" android:layout_height="wrap_content" android:orientation="horizontal" android:gravity="center" tools:layout_editor_absoluteX="8dp" tools:layout_editor_absoluteY="301dp"> <Button android:id="@+id/hitme" android:layout_width="wrap_content" android:layout_height="wrap_content" android:text="Hit Me!" app:layout_constraintEnd_toEndOf="parent" app:layout_constraintStart_toStartOf="parent" tools:layout_editor_absoluteY="383dp" /> <Button android:id="@+id/mapme" android:layout_width="wrap_content" android:layout_height="wrap_content" android:text="Map Me!" app:layout_constraintEnd_toEndOf="parent" app:layout_constraintStart_toStartOf="parent" tools:layout_editor_absoluteY="460dp" /> </LinearLayout> <TextView android:id="@+id/thelabel" android:layout_width="match_parent" android:layout_height="wrap_content" android:gravity="center" android:text="Hello World, Say Something!!!!!" app:layout_constraintBottom_toBottomOf="parent" app:layout_constraintLeft_toLeftOf="parent" app:layout_constraintRight_toRightOf="parent" app:layout_constraintTop_toTopOf="parent" /> <EditText android:id="@+id/etLatitude" android:layout_width="match_parent" android:layout_height="wrap_content" android:ems="10" android:hint="Latitude" android:inputType="numberDecimal" android:text="40.9241164" /> <EditText android:id="@+id/etLongitude" android:layout_width="match_parent" android:layout_height="wrap_content" android:ems="10" android:hint="Longitude" android:inputType="numberDecimal" android:text="-74.7213913" /></LinearLayout>

LinearLayout, c’è un secondo LinearLayout organizzato come layout orizzontale. Questo layout interno contiene una coppia di widget pulsante. Sotto l’orizzontale LinearLayout c’è un singolo elemento TextView, che può essere paragonato a un’etichetta in altri ambienti di sviluppo. A TextView rappresenta il testo statico che non è modificabile. Sotto il TextView , ci sono due EditText widget, configurati per prendere input numerici. Questi elementi di input vengono utilizzati per acquisire un valore di Latitudine e Longitudine che verrà successivamente passato a un’applicazione di mappatura, come illustrato di seguito.

Si noti che ogni elemento della vista ha attributi nello spazio nome Android. Alcuni attributi sono comuni a tutte le viste, ad esempio gli attributi android:layout_width e android:layout_height . I valori disponibili per questi attributi sono:

• Match Parent-Questo estende l’elemento della vista per occupare il massimo spazio disponibile. Questo può anche essere pensato come significato ” allungare.”
• Wrap Content – Questa opzione fa sì che l’elemento si espanda quanto basta per contenere le sue viste o attributi figlio come testo o immagine.

Descrittore di distribuzione per un’applicazione Android (AndroidManifest.xml)

Il AndroidManifest.file xml rappresenta il descrittore di distribuzione per un’applicazione Android. Il file elenca qualsiasi attività, servizio, fornitore di contenuti o ricevitore contenuto nell’applicazione, insieme agli IntentFilters appropriati supportati dall’applicazione. Ecco il AndroidManifest completo.file xml per l’applicazione di esempio:

<?xml version="1.0" encoding="utf-8"?><manifest xmlns:android="http://schemas.android.com/apk/res/android" package="com.navitend.saysomething"> <application android:allowBackup="true" android:icon="@mipmap/ic_launcher" android:label="@string/app_name" android:roundIcon="@mipmap/ic_launcher_round" android:supportsRtl="true" android:theme="@style/AppTheme"> <activity android:name=".MainActivity" android:label="@string/app_name" android:theme="@style/AppTheme.NoActionBar"> <intent-filter> <action android:name="android.intent.action.MAIN" /> <category android:name="android.intent.category.LAUNCHER" /> </intent-filter> </activity> </application></manifest>

< manifest > sta essenzialmente importando classi da questo pacchetto. Tutte le classi non completamente qualificate in questo file si trovano nel pacchetto identificato nell’attributo package.

Fase 3: Costruire l’applicazione

Per costruire l’applicazione, selezionare l’icona della chiave inglese (sembra più come un martello per me) nel menu di Android Studio.

Il processo di compilazione, come introdotto in precedenza, è un processo multi-step che può essere personalizzato per qualsiasi applicazione particolare. Per questo tutorial, non modifichiamo il processo di compilazione. L’output del processo di compilazione dovrebbe essere simile a questo:

Per dimostrare il processo di build, abbiamo introdotto un errore nel codice sorgente; abbiamo aggiunto uno spazio aggiuntivo nel nome del metodo findViewById, mostrato nella figura seguente:

Questo crea un errore di sintassi o di analisi che viene rilevato dal processo di compilazione e visualizzato nei dettagli della finestra dei risultati di compilazione in Android Studio. Dopo aver risolto l’errore nel codice sorgente, l’applicazione viene compilata correttamente e gli errori vengono rimossi dall’elenco dei problemi.

Fase 4: Eseguire l’applicazione

Ora che l’applicazione è stata compilata correttamente, è il momento di eseguire l’applicazione di esempio.

In precedenza in questo tutorial AVD Manager è stato introdotto come mezzo per configurare l’emulatore per testare le applicazioni senza la necessità di un dispositivo reale. L’esecuzione di un’applicazione utilizzando l’emulatore è particolarmente utile perché consente il test senza la necessità di acquistare numerosi dispositivi costosi.

Per configurare un emulatore o, più correttamente, un dispositivo virtuale Android (AVD), selezionare Strumenti > AVD Manager. Oppure, fai semplicemente clic sull’icona Play (Esegui).

Viene avviata una finestra che consente di selezionare un dispositivo reale collegato tramite un cavo USB o un’istanza AVD disponibile, come mostrato nella figura seguente:

Se sono presenti dispositivi collegati, ciascuna viene visualizzata nel menu a discesa sotto Dispositivi collegati. In alternativa, selezionare uno dei dispositivi virtuali disponibili. Nella figura precedente, c’è un singolo AVD definito dal titolo Nexus One API P. Per creare un nuovo AVD, selezionare il pulsante Crea nuovo dispositivo virtuale.

Infine, fare clic su OK per avviare l’applicazione sulla destinazione di distribuzione selezionata. L’AVD o emulatore si avvia con la nostra applicazione di esempio in esecuzione su di esso.

Passo 5: Testare l’applicazione nell’emulatore

Ora che l’applicazione è in esecuzione sull’emulatore, diamo un’occhiata a ciò che sta accadendo dietro le quinte. All’interno di Android Studio, selezionare Visualizza > Finestre degli strumenti. Metteremo in evidenza solo un paio di queste opzioni di strumento, anche se ognuno di loro è un argomento a sé.

Android Studio Tools

Per prima cosa, guarda il Profiler Android che descrive un grafico in esecuzione di CPU, Memoria e traffico di rete. Il Profiler Android ci permette di passare da diversi dispositivi / istanze emulatore e rispettivi processi in esecuzione. La figura seguente mostra le metriche per la nostra applicazione di esempio in esecuzione su un’istanza emulatore.

La registrazione è uno strumento utile per qualsiasi sviluppatore su qualsiasi piattaforma. Per gli sviluppatori Android, il nome dello strumento è LogCat.

Il LogCat è un file di log in esecuzione di attività che si svolgono nella VM. Le applicazioni possono inserire le proprie voci in questo elenco con una semplice riga di codice come segue: Log.i (tag, message); 1, dove tag e message sono entrambe stringhe Java. La classe Log fa parte di Android.util.Log pacchetto.

Un altro strumento utile è il file explorer, che consente l’accesso al file system dell’emulatore. La figura seguente mostra dove l’applicazione di esempio del tutorial viene distribuita sull’emulatore.

Le applicazioni utente vengono distribuite in/data/app mentre le applicazioni integrate Android si trovano nella directory/system/app .

Il debug su larga scala di un’applicazione Android va oltre lo scopo di questo tutorial, anche se ti assicuro che Android Studio supporta tutti i moderni strumenti di debug delle applicazioni che possiamo sperare con cose come Entrare e scavalcare le chiamate di funzione.

Testare l’applicazione di esempio

Toccare il Hit Me! pulsante, e il contenuto dell’etichetta cambia in ” Ahi!”

Tocca sulla mappa Me! viene avviata un’applicazione di mappatura con la latitudine e la longitudine specificate contenute nei widget EditText.

Il cablaggio dei pulsanti è nel MainActivity.codice xml. In particolare, si noti come i valori di latitudine e longitudine vengono estratti e impacchettati in un Intento, che viene successivamente utilizzato per avviare l’applicazione di mappatura.

Questo tutorial ha introdotto la piattaforma Android, Android Studio e gli elementi chiave dello sviluppo di Android. Ora si dovrebbe essere pronti a creare le proprie applicazioni Android.

Sei pronto per qualcosa di più? Prova questo tutorial in cui usi le API Bluetooth Low Energy (BLE) per creare dispositivi connessi IoT.