Développer votre première application Android

Développer votre première application Android

Pourquoi nous soucions-nous d’Android? Nous nous soucions de la plate-forme Android car c’est la plate-forme mobile la plus distribuée de la planète et est accessible aux consommateurs du monde entier. Dans les économies où la possession d’un ordinateur personnel est un luxe, l’utilisation des appareils mobiles est la norme – et Android joue un rôle majeur dans la connexion des gens entre eux. Comme vous l’apprendrez dans ce tutoriel, Android adopte une approche distincte des applications. L’architecture d’Android permet un environnement logiciel hautement personnalisable grâce à sa liaison d’exécution des actions demandées et au code pour satisfaire ces demandes. Qu’il s’agisse de considérations axées sur le marché ou des aspects techniques d’Android, c’est une plate-forme qui mérite d’être examinée. De plus, si vous envisagez sérieusement d’avoir une expérience mobile pour votre plate-forme, vous ne pouvez pas ignorer Android.

Prérequis

Ce tutoriel nécessite plusieurs technologies qui fonctionnent ensemble. Vous avez besoin de tous pour ce tutoriel.

• Android Studio – Android Studio est le principal point de départ pour la construction d’applications Android
• Appareil ou émulateur Android – Vous voudrez soit un appareil Android physique, soit l’émulateur Android. Quoi qu’il en soit, la lecture de ce tutoriel vous aidera à comprendre les points de connexion de base d’une application Android.

• Code source – Les extraits de code source de ce tutoriel incluent:

  • Androidmanifeste.extrait xml — Ce fichier est le descripteur de déploiement d’applications pour les applications Android.
  • Activité principale.java – Cela implémente une activité Android, le point d’entrée principal de l’exemple d’application de ce tutoriel.
  • Activity_main.xml – Contient des définitions pour les éléments visuels, ou ressources, à utiliser par les activités Android.
  • Manifestation androide.xml complete – Cela répertorie un AndroidManfest complet.fichier xml, avec une description de chacun des éléments importants.

Présentation de l’architecture Android

Avant de plonger dans les tenants et les aboutissants du Studio Android et de développer des applications Android, jetons un coup d’œil à l’architecture d’Android et à certains des termes clés qui vous seront utiles dans le tutoriel et au-delà, lorsque vous commencerez à créer des applications Android pour vous-même.

Terminologie Android

Une compréhension des termes ci-dessous est utile dans le développement d’applications Android avec Android Studio.

• Android est un environnement d’exploitation open source destiné aux appareils mobiles. De plus en plus, Android se trouve dans des applications au-delà des « smartphones ». Ceux-ci incluent la technologie portable, les appareils tels que les projecteurs, les haut-parleurs et les téléviseurs, et même les automobiles.
• L’émulateur est un outil logiciel représentatif d’un autre système. Souvent, un émulateur est un environnement qui s’exécute sur un ordinateur personnel (PC, Mac, machine Linux) qui émule un autre environnement, tel qu’un appareil informatique mobile.
• Linux est un noyau de système d’exploitation open source au cœur de nombreuses plates-formes informatiques, y compris les serveurs, les ordinateurs de bureau, les appareils réseau et les appareils informatiques mobiles. Android fonctionne au-dessus d’un noyau Linux.
• Android Run Time (ART) est un environnement d’exploitation présent dans la pile Android, qui exécute le code de l’application au moment de l’exécution. Le temps d’exécution d’Android remplace la machine virtuelle (VM) Dalvik « héritée » des versions antérieures d’Android qui fonctionnaient de manière similaire à une machine virtuelle Java conforme.

L’intention

Depuis sa création, Android est devenu une force dominante dans l’espace de la téléphonie mobile. Son modèle d’application est unique en ce sens que les applications ne sont pas des applications monolithiques chargées de menus qui nécessitent beaucoup de clics et de tapotements pour fonctionner. Bien sûr, il y a des menus et des boutons à exploiter, mais Android a un élément de conception innovant à son architecture connu sous le nom d’intention.

Une intention est une construction qui permet à une application d’émettre une demande, ce qui ressemble un peu à un signe d’aide. Cela pourrait ressembler à ceci:

•  » Recherché: Une application pour m’aider à rechercher un contact « 
•  » Wanted: Une application pour m’aider à afficher cette image « 
•  » Wanted: Une application pour effectuer cette recherche géographique. »

De manière similaire et complémentaire, les applications peuvent s’inscrire comme capables et intéressées à satisfaire diverses demandes ou intentions. Pour suivre le paradigme des petites annonces, celles-ci pourraient ressembler à ceci:

•  » Disponible: Application prête et prête à présenter les enregistrements de contact de manière claire et concise « 
•  » Disponible: Application prête et prête à effectuer une recherche géographique. »

Ce sont des exemples d’IntentFilters, qui sont discutés ensuite.

Les applications IntentFilter

annoncent leur disponibilité pour effectuer ces types d’opérations via une construction appelée IntentFilter . Le IntentFilter est enregistré à l’exécution ou est énuméré dans AndroidManifest.fichier xml. L’extrait suivant provient d’une application Android qui répond aux messages SMS (TEXTE) entrants:

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

IntentFilter , la section suivante présente les quatre principaux types d’applications Android.

Types d’applications Android

Prenons un moment pour examiner les quatre principaux types d’applications Android:

• Activité
• Service
• Récepteur
• Fournisseur de contenu

Nous examinerons également les vues pour afficher les éléments de l’interface utilisateur (UI).

Applications d’activité

L’activité est la forme la plus visible et la plus visible d’une application Android. Une activité présente l’interface utilisateur à une application, avec l’aide d’une classe appelée vue. La classe view est implémentée sous la forme de divers éléments d’interface utilisateur, tels que des zones de texte, des étiquettes, des boutons et d’autres interfaces utilisateur typiques des plates-formes informatiques, mobiles ou otherwise.An l’application peut contenir une ou plusieurs activités. Une activité est généralement définie sur une relation individuelle avec les écrans trouvés dans une application.

Une application passe d’une activité à une autre en appelant une méthode appelée startActivity() ou startSubActivity(). La première méthode est utilisée lorsque l’application souhaite simplement « passer » à la nouvelle activité. Ce dernier est utilisé lorsqu’un paradigme d’appel/ réponse synchrone est souhaité. Dans les deux cas, une intention est passée en argument à la méthode appelée.

Il incombe au système d’exploitation de déterminer l’activité la mieux qualifiée pour satisfaire l’intention spécifiée.

Applications de service et de réception

Comme d’autres environnements informatiques polyvalents, il existe des applications exécutées « en arrière-plan » qui effectuent diverses tâches. Android appelle ces types de services d’applications. Le service est une application Android qui n’a pas d’interface utilisateur.

Le récepteur est un composant d’application qui reçoit des demandes de traitement des intentions. Comme le service, un récepteur n’a pas, en pratique normale, d’élément d’interface utilisateur. Les récepteurs sont généralement enregistrés dans AndroidManifest.fichier xml.

L’extrait de code suivant (qui est le même que celui affiché pour IntentFilter) est un exemple d’application récepteur en cours de définition. Notez que l’attribut name du récepteur est la classe Java responsable de l’implémentation du récepteur.

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

Le ContentProvider est le mécanisme Android pour l’abstraction du stockage de données. Regardons un type spécifique de données trouvées sur un appareil mobile: le carnet d’adresses ou la base de données de contacts. Le carnet d’adresses contient tous les contacts et numéros de téléphone dont une personne peut avoir besoin lors de l’utilisation d’un téléphone mobile.

Le ContentProvider est un mécanisme permettant d’abstraire l’accès à un magasin de données particulier. À bien des égards, le ContentProvider joue le rôle d’un serveur de base de données. Les opérations de lecture et d’écriture de contenu dans un magasin de données particulier doivent être passées par un fournisseur de contenu approprié, plutôt que d’accéder directement à un fichier ou à une base de données. Il peut y avoir à la fois des « clients » et des « implémentations » du fournisseur de contenu .

Vues Android

Les vues Android sont le mécanisme d’interface utilisateur permettant de mettre des choses sur l’écran d’un appareil Android. L’activité Android utilise des vues pour afficher les éléments de l’interface utilisateur. Certains des modèles de mise en page les plus populaires incluent:

• LinéarVertical – Chaque élément suivant suit son prédécesseur en s’écoulant sous lui dans une seule colonne.
• Linéairehorizontal – Chaque élément suivant suit son prédécesseur en s’écoulant vers la droite dans une seule rangée.
• Table – Une série de lignes et de colonnes, similaire à une table HTML. Chaque cellule peut contenir un élément de vue.Contrainte
• – Chaque élément est « contraint » à un aspect de l’affichage tel que le haut ou le côté de l’écran ou un autre élément. Cette mise en page aide à la construction d’applications « réactives » et est l’héritière de la mise en page relative héritée introduite dans les versions antérieures de la plate-forme Android.

Une fois qu’une disposition particulière (ou une combinaison de dispositions) a été sélectionnée, des vues individuelles sont utilisées pour définir l’interface utilisateur.

Les éléments de vue sont constitués d’éléments d’interface utilisateur familiers, notamment:

• Bouton
• ImageView
• EditText pour rassembler les entrées avec divers filtres tels que la date ou numérique
• TextView (similaire à une étiquette, affiche du texte statique)
• Case à cocher
• Bouton radio
• Spinner (similaire à une liste déroulante)
• Saisie semi-automatique (EditText avec fonction de saisie automatique du texte)

Les vues sont définies dans un fichier XML. Par exemple, cela montre une vue verticale linéaire simple, avec des boutons et des vues de texte définies:

<?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/, et faites défiler vers le bas pour télécharger Android Studio. Android Studio est disponible pour Windows, Mac et Linux.

Android Studio est basé sur la plate-forme IntelliJ ID. Si vous êtes le genre de développeur qui est intéressant pour tirer parti des raccourcis clavier, vous pourriez envisager d’en apprendre davantage sur IntelliJ sur le site Web de jetbrains.

Mise en route avec le SDK Android

Maintenant que nous avons installé Android Studio, il est temps d’obtenir le Kit de développement logiciel (SDK) pour Android.

Mais, avant d’aller plus loin, nous devons avoir une discussion sur les versions d’Android.

Versions Android

Depuis sa création, Android a été publié sous un chemin quelque peu parallèle de révisions de versions numériques, de niveaux d’API et de noms « sucrés », y compris Jelly Bean, KitKat, Oreo et d’autres favoris de confiserie.

Il est facile d’être submergé par les choix disponibles. Pour l’instant, vous avez juste besoin d’un peu de compréhension de ce « paysage de versions » pour commencer en tant que développeur Android.

Il existe de nombreuses versions ou révisions d’Android dans la nature. Si vous allez écrire une demande de sortie commerciale, vous devrez savoir quels appareils vous ciblez. Wikipedia a un joli résumé des versions Android, les noms, les dates de sortie ainsi qu’un graphique représentant le nombre approximatif de chaque appareil sur le marché.

Les appareils plus récents exécutent le dernier code, et les appareils plus anciens peuvent être quelque peu limités dans leur capacité à passer à une version plus récente d’Android. Parfois, les nouvelles versions prennent en charge des fonctionnalités que les anciens combinés ne sont pas capables de prendre en charge (pensez à la deuxième caméra, aux communications en champ proche, etc.). Une autre raison non triviale pour laquelle les anciens combinés peuvent ne pas pouvoir exécuter la dernière version d’Android est que le fabricant et l’opérateur de télécommunications (Verizon, AT & T, etc.) doivent prendre en charge le logiciel fonctionnant dans leur écosystème. La prise en charge d’un nouveau système d’exploitation nécessite des ressources de la part du fabricant de l’appareil et de l’opérateur. Les forces du marché suggèrent que ces acteurs du marché sont plus préoccupés par les ventes futures que par le soutien des ventes antérieures et investissent leur capital humain en conséquence.

En tant que développeur de logiciels, qu’importe qu’il existe de nouvelles versions du système d’exploitation? Cela se décompose en deux grandes catégories lorsqu’il s’agit d’applications de programmation:

• Une nouvelle version du système d’exploitation introduit souvent de nouvelles fonctionnalités dont nous pouvons tirer parti et/ou que notre base d’utilisateurs attend de nos applications qu’elles prennent en charge.
• Les fonctionnalités plus anciennes (ou héritées) de l’environnement peuvent en fait entraver les fonctionnalités plus récentes et/ ou représenter une approche inférieure pour fournir un ensemble spécifique de fonctionnalités. Parfois, le code doit être supprimé des définitions de l’API. Il existe un terme spécial pour cette « suppression » du code qui fonctionnait auparavant – nous l’appelons « dépréciation du code ». Lorsqu’une API a été marquée pour suppression, nous disons qu’il s’agit d’une API obsolète. Il s’agit essentiellement d’un message au développeur qui va quelque chose comme ceci: « Avertissement » ce code sera supprimé à l’avenir, veuillez planifier en conséquence. »

La plate-forme Android a été assez libérale (c’est-à-dire favorable au développeur) avec son approche du code obsolète en permettant aux applications de continuer à utiliser des API plus anciennes pendant un certain temps après avoir été marquées comme obsolètes. (Cette approche contraste avec l’approche d’Apple avec le code obsolète dans iOS où le code plus ancien peut simplement cesser de fonctionner sur la prochaine version du système d’exploitation. Avec iOS, même le langage de programmation semble changer alors que nous ne cherchons pas!)

Bien qu’Android puisse être un peu plus indulgent avec sa longue souffrance de code obsolète, nous devons garder un œil sur la balise de documentation qui indique qu’une API particulière est obsolète. Si un code que nous utilisons est marqué comme obsolète, nous devrons éventuellement changer notre approche dans une future version de notre application car toute API marquée comme obsolète peut être supprimée dans une future version. Les marqueurs de dépréciation dans le SDK sont notre feuille de route pour les futures opportunités d’amélioration et pour les maux de tête potentiels. Parfois, la « nouvelle » façon de faire est simple et directe, mais pas dans tous les cas!

Être un développeur d’applications mobiles à succès nécessite un investissement continu sur la durée de vie d’une application où le temps a tendance à passer comme des années de chienvery très rapidement !

Avec cette introduction de base aux versions d’Android, il est temps d’obtenir le SDK Android.

Obtention et installation du SDK Android

Démarrez Android Studio. Dans le menu Outils, sélectionnez Gestionnaire de SDK. Cette option de menu charge la boîte de dialogue Préférences Android Studio et présélectionne le sous-menu Android SDK. Ce menu est notre principal moyen d’interagir avec les différents SDK disponibles pour les nombreuses versions d’Android.

À chaque version du système d’exploitation, le niveau de l’API s’incrémente. Notez que la révision augmente plus lentement que le niveau de l’API. Vous pouvez considérer la révision comme une « génération » de la plate-forme ou comme un numéro de version « majeur ». Lorsque vous parcourez la documentation Android, assurez-vous de noter le niveau d’API pour lequel une fonctionnalité particulière a été introduite. Chaque API est disponible au niveau d’API indiqué et supérieur, à moins que l’API n’ait été obsolète puis supprimée. Par exemple, l’API ContactsContract a été introduite au niveau 5, qui est assez « ancienne » à ce stade.

Sélectionnez un ou deux niveaux SDK avec lesquels travailler pour le moment. Le gestionnaire de SDK téléchargera ensuite les fichiers associés et les rendra disponibles pour une utilisation dans Android Studio.

Également sous le menu Outils se trouve une option pour le gestionnaire AVD. AVD signifie Appareil virtuel Android. C’est l’émulateur. L’émulateur est utile car il nous permet de tester des applications sur différents types, tailles et versions d’appareils. Les captures d’écran de ce tutoriel sont extraites de l’émulateur. Plus à ce sujet plus tard.

Création de votre première application Android

Ce tutoriel vous aide à créer une application Android de base, appelée SaySomething , en utilisant Android Studio et en la démontrant sur l’émulateur Android.

Obtenir le code

Étape 1: Créez un nouveau projet

1. Sélectionnez le fichier > Nouveau projet.

2. Remplissez la boîte de dialogue Créer un projet Android et cliquez sur Suivant.

   

   Les exigences pour le nouveau projet incluent:

   • Nom de l’application
   • Domaine de l’entreprise (cela est inversé en com.domaine) pour garder les applications partitionnées même si elles ont le même nom d’application.
   • Emplacement du projet – où stocker les fichiers
   • Le nom du package est suggéré à partir du Nom de l’application et du domaine de l’entreprise
   • Par défaut, les applications Android sont écrites en Java. Si vous souhaitez prendre en charge d’autres langages, tels que C++ (pour le code natif) ou Kotlin, cochez les cases appropriées.

3. Dans la boîte de dialogue Appareils Android cibles, spécifiez le niveau de l’API et les plates-formes cibles. Comme mentionné précédemment, Android est destiné à plus que les téléphones, bien que pour nos besoins, nous sélectionnerons simplement le facteur de forme du téléphone et de la tablette pour ce tutoriel. Ensuite, cliquez sur Suivant.

   

4. Dans la boîte de dialogue Ajouter une activité au mobile, sélectionnez le type d’activité vide. Ensuite, cliquez sur Suivant.

   

   Cela créera une application par défaut prête à être créée et exécutée directement à partir d’Android Studio.

5. Dans la boîte de dialogue Configurer l’activité, nommez les fichiers de l’application.

   

Étape 2: Passez en revue le code

La figure suivante montre les composants de notre nouveau projet:

Il y a deux dossiers: app et Scripts Gradle .

• Le dossier app contient tout le code de notre application.
• Le dossier manifestes dans le dossier app contient AndroidManifest.xml qui est le descripteur de déploiement de cette application. Ce fichier indique à l’appareil Android comment interagir avec l’application, quelle activité afficher au démarrage de l’application, quelles sont les intentions des services d’application, quelles icônes afficher et bien plus encore.
• Le dossier java contient le code source de l’application. Dans ce cas, le fichier qui implémente notre activité plus quelques fichiers de classe pour effectuer des tests automatisés (que nous ignorerons pour ce tutoriel).
• Le dossier res contient les ressources de l’application, y compris les icônes, les fichiers de mise en page, les chaînes, les menus, etc.
• Le dossier Gradle Scripts contient tous les éléments scriptables pour la construction de l’application. Le système de construction Gradle est un sujet en soi. Pour l’instant, comprenez que ces scripts régissent le processus de création de l’application – et surtout pour les projets et les équipes plus matures, chacune de ces étapes peut être exécutée à partir de la ligne de commande. Ceci est important car cette approche prend en charge l’automatisation et entre dans la catégorie de l’intégration continue.

Maintenant, examinons le code source plus en détail.

Activité principale pour l’application

Notre exemple d’application se compose d’une seule activité, nommée 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 est une classe Java normale, avec un package et des importations, comme prévu.

Ressources pour l’application

Les ressources dans Android sont organisées dans un sous-répertoire du projet nommé res, comme décrit précédemment. Les ressources se répartissent en plusieurs catégories. Trois de ces catégories sont:

• Drawables
• Layouts – Ce dossier contient des fichiers XML qui représentent les layouts et les vues de l'application. Ceux-ci seront examinés en détail ci-dessous.
• Values – Ce dossier contient un fichier nommé strings.xml . Il s'agit du principal moyen de localisation de chaîne pour l'application. Les couleurs du fichier.xml est utile pour définir les codes de couleur utilisés par l'application. Ce fichier est analogue à une feuille de style css pour ceux qui connaissent les techniques de programmation Web.

Ressources principales de l’interface utilisateur dans main_activity.fichier xml

L’exemple d’application contient une seule activité et une seule vue. L’application contient un fichier nommé main_activity.xml qui représente les aspects visuels de l’interface utilisateur principale de l’activité. Notez qu’il n’y a pas de référence dans la main_activity.xml où la mise en page est utilisée. Cela signifie qu’il peut être utilisé dans plus d’une activité, si vous le souhaitez. Voir la liste de codes suivante

<?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 , il existe un second LinearLayout organisé comme une disposition horizontale. Cette disposition interne contient une paire de widgets de boutons. Sous l’horizontale LinearLayout se trouve un seul élément TextView, qui peut être comparé à une étiquette dans d’autres environnements de développement. A TextView représente un texte statique qui n’est pas modifiable. Sous le TextView , il y a deux widgets EditText , configurés pour prendre des entrées numériques. Ces éléments d’entrée sont utilisés pour capturer une valeur de Latitude et de longitude qui sera ensuite transmise à une application de cartographie, comme illustré ci-dessous.

Notez que chaque élément de vue a des attributs dans l’espace de noms Android. Certains attributs sont communs à toutes les vues — les attributs android:layout_width et android:layout_height , par exemple. Les valeurs disponibles pour ces attributs sont:

• Parent de correspondance – Cela étend l’élément de vue pour prendre le maximum d’espace disponible. Cela peut également être considéré comme signifiant « étirement. »
• Contenu d’enveloppe – Cette option permet à l’élément de se développer juste assez pour contenir ses vues ou attributs enfants tels que du texte ou une image.

Descripteur de déploiement pour une application Android (AndroidManifest.xml)

Le manifeste Androidmanifeste.le fichier xml représente le descripteur de déploiement d’une application Android. Le fichier répertorie toute activité, service, fournisseur de contenu ou récepteur contenu dans l’application, ainsi que les IntentFilters appropriés pris en charge par l’application. Voici le manifeste AndroidManifest complet.fichier xml pour l’exemple d’application:

<?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 > importe essentiellement des classes de ce package. Toutes les classes non qualifiées de ce fichier se trouvent dans le package identifié dans l’attribut package.

Étape 3: Construire l’application

Pour construire l’application, sélectionnez l’icône de la clé (ressemble plus à un marteau pour moi) dans le menu d’Android Studio.

Le processus de construction, tel qu’introduit précédemment, est un processus en plusieurs étapes qui peut être personnalisé pour n’importe quelle application particulière. Pour ce tutoriel, nous ne modifions pas le processus de construction. La sortie du processus de construction devrait ressembler à ceci:

Pour démontrer le processus de génération, nous avons introduit une erreur dans le code source; nous avons ajouté un espace supplémentaire dans le nom de la méthode findViewById , illustré dans la figure suivante:

Cela crée une erreur de syntaxe ou d’analyse qui est captée par le processus de génération et affichée dans les détails de la fenêtre de résultats de génération dans Android Studio. Une fois l’erreur corrigée dans le code source, l’application se construit correctement et les erreurs sont supprimées de la liste des problèmes.

Étape 4: Exécutez l’application

Maintenant que l’application a été compilée avec succès, il est temps d’exécuter l’exemple d’application.

Plus tôt dans ce tutoriel, le gestionnaire AVD a été introduit comme moyen de configurer l’émulateur pour tester des applications sans avoir besoin d’un véritable périphérique. L’exécution d’une application à l’aide de l’émulateur est particulièrement utile car elle permet de tester sans avoir à acheter de nombreux appareils coûteux.

Pour configurer un émulateur, ou plus correctement, un périphérique virtuel Android (AVD), sélectionnez Outils > Gestionnaire AVD. Ou, cliquez simplement sur l’icône de lecture (Exécuter).

Cela ouvre une fenêtre qui vous permet de sélectionner un périphérique réel connecté par un câble USB ou une instance AVD disponible, comme indiqué dans la figure suivante:

S’il existe des périphériques connectés, chacune s’affiche dans la liste déroulante ci-dessous Périphériques connectés. Vous pouvez également choisir parmi l’un des périphériques virtuels disponibles. Dans la figure précédente, il existe un seul AVD défini intitulé Nexus One API P . Pour créer un nouvel AVD, sélectionnez le bouton Créer un nouvel appareil virtuel.

Enfin, cliquez sur OK pour lancer l’application sur la cible de déploiement sélectionnée. L’AVD ou l’émulateur se lance avec notre exemple d’application qui s’exécute dessus.

Étape 5: Testez l’application dans l’émulateur

Maintenant que l’application s’exécute sur l’émulateur, regardons ce qui se passe dans les coulisses. Dans Android Studio, sélectionnez Afficher les fenêtres d’outils >. Nous allons mettre en évidence quelques-unes de ces options d’outils, bien que chacune d’elles soit un sujet en soi.

Outils Android Studio

Tout d’abord, regardez le Profileur Android qui représente un graphique en cours d’exécution du CPU, de la mémoire et du trafic réseau. Le profileur Android nous permet de basculer entre différents appareils / instances d’émulateur et les processus en cours d’exécution respectifs. La figure suivante affiche les métriques de notre exemple d’application s’exécutant sur une instance d’émulateur.

La journalisation est un outil utile pour tout développeur sur n’importe quelle plate-forme. Pour les développeurs Android, le nom de l’outil est LogCat.

Le LogCat est un fichier journal en cours d’exécution de l’activité se déroulant dans la machine virtuelle. Les applications peuvent faire leurs propres entrées dans cette liste avec une simple ligne de code comme suit: Log.i(tag, message); 1 , où tag et message sont toutes deux des chaînes Java. La classe Log fait partie de l’android .util.Paquet Log .

Un autre outil utile est l’explorateur de fichiers, qui permet l’accès au système de fichiers de l’émulateur. La figure suivante montre où l’exemple d’application du tutoriel est déployé sur l’émulateur.

Les applications utilisateur sont déployées dans /data/app tandis que les applications intégrées Android se trouvent dans le répertoire /system/app .

Le débogage à grande échelle d’une application Android dépasse le cadre de ce tutoriel, mais soyez assuré qu’Android Studio prend en charge tous les outils de débogage d’applications modernes que nous pouvons espérer avec des choses comme Intervenir et Passer au-dessus des appels de fonction.

Tester l’exemple d’application

Appuyez sur le Hit Me! bouton, et le contenu de l’étiquette devient « Aïe! »

Appuyez sur la carte Moi! bouton, et une application de cartographie est lancée avec la latitude et la longitude spécifiées contenues dans les widgets EditText.

Le câblage des boutons est dans le Principalactivité.code xml. En particulier, notez comment les valeurs de latitude et de longitude sont extraites et regroupées dans une Intention, qui est ensuite utilisée pour lancer l’application de cartographie.

Ce tutoriel a présenté la plate-forme Android, le Studio Android et les éléments clés du développement Android. Vous devriez maintenant être prêt à créer vos propres applications Android.

Êtes-vous prêt pour quelque chose de plus? Essayez ce tutoriel où vous utilisez les API Bluetooth Low Energy (BLE) pour créer des appareils connectés à l’IoT.