Premiers pas avec Android

Création d’un nouveau projet

Configurer Android Studio

Commencez par [configurer Android Studio](https://www.wikiod.com/fr/android/premiers-pas-avec-android#Configuration d’Android Studio), puis ouvrez-le. Vous êtes maintenant prêt à créer votre première application Android !

Remarque : ce guide est basé sur Android Studio 2.2, mais le processus sur les autres versions est essentiellement le même.

Configurez votre projet

Configuration de base

Vous pouvez démarrer un nouveau projet de deux manières :

Cliquez sur “Démarrer un nouveau projet Android Studio” dans l’écran d’accueil.
Accédez à Fichier → Nouveau projet si vous avez déjà un projet ouvert.

Ensuite, vous devez décrire votre candidature en remplissant quelques champs :

Nom de l’application - Ce nom sera affiché à l’utilisateur.

Example: Hello World. You can always change it later in AndroidManifest.xml file.
Domaine de l’entreprise - Il s’agit du qualificatif du nom du package de votre projet.

Example: stackoverflow.com.
Nom du package (alias applicationId) - Il s’agit du nom complet du package du projet.

It should follow Reverse Domain Name Notation (aka Reverse DNS): Top Level Domain . Company Domain . [Company Segment .] Application Name.

Example: com.stackoverflow.android.helloworld or com.stackoverflow.helloworld. You can always change your applicationId by overriding it in your [gradle file][1].

N’utilisez pas le préfixe par défaut “com.example” sauf si vous n’avez pas l’intention de soumettre votre application au Google Play Store. Le nom du package sera votre applicationId unique dans Google Play.

Emplacement du projet - Il s’agit du répertoire dans lequel votre projet sera stocké.

[![Boîte de dialogue Nouveau projet][2]][2]

Sélectionnez les facteurs de forme et le niveau d’API

La fenêtre suivante vous permet de sélectionner les facteurs de forme pris en charge par votre application, tels que téléphone, tablette, TV, Wear et Google Glass. Les facteurs de forme sélectionnés deviennent les modules d’application au sein du projet. Pour chaque facteur de forme, vous pouvez également sélectionner le niveau d’API pour cette application. Pour obtenir plus d’informations, cliquez sur Aidez-moi à choisir

[![entrez la description de l’image ici][3]][3] * Tableau des versions actuelles d’Android, affiché lorsque vous cliquez sur Aidez-moi à choisir.*

La fenêtre de distribution de la plate-forme Android affiche la distribution des appareils mobiles exécutant chaque version d’Android, comme illustré à la figure 2. Cliquez sur un niveau d’API pour afficher une liste des fonctionnalités introduites dans la version correspondante d’Android. Cela vous aide à choisir le niveau d’API minimum qui possède toutes les fonctionnalités dont vos applications ont besoin, afin que vous puissiez atteindre autant d’appareils que possible. Cliquez ensuite sur OK.

Maintenant, choisissez les plates-formes et la [version d’Android SDK][4] que l’application prendra en charge.

[![Boîte de dialogue de version du SDK][5]][5]

Pour l’instant, sélectionnez uniquement Téléphone et tablette.

Le SDK minimum est la limite inférieure pour votre application. C’est l’un des signaux que le “Google Play Store” utilise pour déterminer sur quels appareils une application peut être installée. Par exemple, [l’application de Stack Exchange][6] prend en charge Android 4.1+.

[![Application de Stack Exchange][7]][7] Android Studio vous indiquera (approximativement) quel pourcentage d’appareils sera pris en charge compte tenu du SDK minimum spécifié.

Les niveaux d’API inférieurs ciblent plus d’appareils mais ont moins de fonctionnalités disponibles.

Lorsque vous choisissez le SDK minimum, vous devez tenir compte des [statistiques des tableaux de bord][8], qui vous donneront des informations sur la version des appareils qui ont visité le Google Play Store dans le monde au cours de la semaine dernière.

[![Capture d’écran de la distribution Android actuelle][9]][9]

De : Dashboards sur le site Web des développeurs Android.

Ajouter une activité

Nous allons maintenant sélectionner une activité par défaut pour notre application. Dans Android, une [Activité][10] est un écran unique qui sera présenté à l’utilisateur. Une application peut héberger plusieurs activités et naviguer entre elles. Pour cet exemple, choisissez “Activité vide” et cliquez sur Suivant.

Ici, si vous le souhaitez, vous pouvez modifier le nom de l’activité et la mise en page. Une bonne pratique consiste à conserver Activity comme suffixe pour le nom de l’activité et activity_ comme préfixe pour le nom de la mise en page. Si nous les laissons par défaut, Android Studio générera pour nous une activité appelée MainActivity et un fichier de mise en page appelé activity_main. Cliquez maintenant sur “Terminer”.

Android Studio créera et configurera notre projet, ce qui peut prendre un certain temps selon le système.

Inspecter le projet

Pour comprendre comment fonctionne Android, examinons quelques-uns des fichiers qui ont été créés pour nous.

Dans le volet de gauche d’Android Studio, nous pouvons voir la [structure de notre application Android][11].

[![Structure de base de l’application][12]][12]

Tout d’abord, ouvrons AndroidManifest.xml en double-cliquant dessus. Le fichier manifeste Android décrit certaines des informations de base sur une application Android. Il contient la déclaration de nos activités, ainsi que quelques composants plus avancés.

Si une application a besoin d’accéder à une fonctionnalité protégée par une autorisation, elle doit déclarer qu’elle requiert cette autorisation avec un élément <uses-permission> dans le manifeste. Ensuite, lorsque l’application est installée sur l’appareil, l’installateur détermine s’il accorde ou non l’autorisation demandée en vérifiant les autorités qui ont signé les certificats de l’application et, dans certains cas, en demandant à l’utilisateur. Une application peut également protéger ses propres composants (activités, services, récepteurs de diffusion et fournisseurs de contenu) avec des autorisations. Il peut utiliser n’importe laquelle des autorisations définies par Android (répertoriées dans android.Manifest.permission) ou déclarées par d’autres applications. Ou il peut définir le sien.

<?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>

Ensuite, ouvrons activity_main.xml qui se trouve dans app/src/main/res/layout/. Ce fichier contient des déclarations pour les composants visuels de notre MainActivity. Vous verrez le concepteur visuel. Cela vous permet de faire glisser et déposer des éléments sur la mise en page sélectionnée.

Vous pouvez également basculer vers le concepteur de mise en page xml en cliquant sur “Texte” en bas d’Android Studio, comme illustré ici :

[![Conception de mise en page / Onglets de texte][13]][13]

<?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>

Vous verrez un widget appelé TextView à l’intérieur de cette mise en page, avec la propriété android:text définie sur “Hello World!”. Il s’agit d’un bloc de texte qui sera affiché à l’utilisateur lors de l’exécution de l’application.

Vous pouvez en savoir plus sur [Dispositions et attributs] [14].

Ensuite, regardons MainActivity. Il s’agit du code Java qui a été généré pour 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);
    }
}

Comme défini dans notre manifeste Android, MainActivity se lancera par défaut lorsqu’un utilisateur démarre l’application HelloWorld.

Enfin, ouvrez le fichier nommé build.gradle situé dans app/. Android Studio utilise le système de compilation Gradle pour compiler et créer des applications et des bibliothèques 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'
}

Ce fichier contient des informations sur la version et la version de votre application, et vous pouvez également l’utiliser pour ajouter des dépendances à des bibliothèques externes. Pour l’instant, n’apportons aucune modification.

Il est conseillé de toujours sélectionner la dernière version disponible pour les dépendances :

buildToolsVersion : 26.0.0
com.android.support:appcompat-v7 : 26.0.0 (juillet 2017)
firebase : 11.0.4 (août 2017)

compileSdkVersion

compileSdkVersion est votre façon de dire * Gradle * avec quelle version du SDK Android compiler votre application. L’utilisation du nouveau SDK Android est obligatoire pour utiliser l’une des nouvelles API ajoutées à ce niveau.

Il convient de souligner que la modification de votre compileSdkVersion ne modifie pas le comportement d’exécution. Alors que de nouveaux avertissements/erreurs du compilateur peuvent être présents lors de la modification de votre compileSdkVersion, votre compileSdkVersion n’est pas inclus dans votre APK : il est uniquement utilisé au moment de la compilation.

Par conséquent, il est fortement recommandé de toujours compiler avec le dernier SDK. Vous bénéficierez de tous les avantages des nouvelles vérifications de compilation sur le code existant, éviterez les API nouvellement obsolètes et serez prêt à utiliser de nouvelles API.

minSdkVersion

Si compileSdkVersion définit les API les plus récentes à votre disposition, minSdkVersion est la limite inférieure pour votre application. La minSdkVersion est l’un des signaux que Google Play Store utilise pour déterminer sur quels appareils d’un utilisateur une application peut être installée.

Il joue également un rôle important pendant le développement : par défaut, lint s’exécute sur votre projet, vous avertissant lorsque vous utilisez des API au-dessus de votre minSdkVersion, vous aidant à éviter le problème d’exécution d’essayer d’appeler une API qui n’existe pas. La vérification de la version du système au moment de l’exécution est une technique courante lors de l’utilisation des API uniquement sur les versions de plateforme les plus récentes.

targetSdkVersion

targetSdkVersion est le principal moyen par lequel Android fournit une compatibilité ascendante en n’appliquant pas de changements de comportement à moins que targetSdkVersion ne soit mis à jour. Cela vous permet d’utiliser de nouvelles API avant de travailler sur les changements de comportement. La mise à jour pour cibler le dernier SDK doit être une priorité pour chaque application. Cela ne signifie pas que vous devez utiliser chaque nouvelle fonctionnalité introduite ni mettre à jour aveuglément votre targetSdkVersion sans test.

targetSDKVersion est la version d’Android qui est la limite supérieure pour les outils disponibles. Si targetSDKVersion est inférieur à 23, l’application n’a pas besoin de demander des autorisations au moment de l’exécution pour une instance, même si l’application est exécutée sur l’API 23+. TargetSDKVersion n’empêche pas les versions Android supérieures à la version Android choisie d’exécuter l’application.

Vous pouvez trouver plus d’informations sur le plugin Gradle :

[Un exemple basique][15]
[Introduction au plugin Gradle pour Android et le wrapper][16]
[Introduction à la configuration des méthodes build.gradle et DSL][17]

Lancer l’application

Maintenant, lançons notre application HelloWorld. Vous pouvez soit exécuter un appareil virtuel Android (que vous pouvez configurer à l’aide du gestionnaire AVD dans Android Studio, comme décrit dans l’exemple ci-dessous) ou connecter votre propre appareil Android via un câble USB.

Configuration d’un appareil Android

Pour exécuter une application à partir d’Android Studio sur votre appareil Android, vous devez activer le “débogage USB” dans les “options de développement” des paramètres de votre appareil.

Paramètres > Options pour les développeurs > Débogage USB

Si Options pour les développeurs n’est pas visible dans les paramètres, accédez à À propos du téléphone et appuyez sept fois sur le Numéro de build. Cela permettra aux “Options pour les développeurs” d’apparaître dans vos paramètres.

Paramètres > À propos du téléphone > Numéro de build

Vous devrez peut-être également modifier la configuration de build.gradle pour créer une version de votre appareil.

Exécution depuis Android Studio

Cliquez sur le bouton vert “Exécuter” dans la barre d’outils en haut d’Android Studio. Dans la fenêtre qui apparaît, sélectionnez l’appareil sur lequel vous souhaitez exécuter l’application (démarrez un appareil virtuel Android si nécessaire, ou consultez https://www.wikiod.com/fr/android/premiers-pas-avec-android 29572/setting-up-an-avd-android-virtual-device si vous avez besoin d’en configurer un) et cliquez sur “OK”.

[![Bouton Exécuter][18]][18]

Sur les appareils fonctionnant sous Android 4.4 (KitKat) et éventuellement supérieur, une fenêtre contextuelle s’affichera pour autoriser le débogage USB. Cliquez sur “OK” pour accepter.

L’application va maintenant s’installer et s’exécuter sur votre appareil ou émulateur Android.

Emplacement du fichier APK

Lorsque vous préparez votre application pour la publication, vous configurez, générez et testez une version publiée de votre application. Les tâches de configuration sont simples et impliquent des tâches de base de nettoyage et de modification du code qui aident à optimiser votre application. Le processus de génération est similaire au processus de génération de débogage et peut être effectué à l’aide des outils JDK et Android SDK. Les tâches de test servent de vérification finale, garantissant que votre application fonctionne comme prévu dans des conditions réelles. Lorsque vous avez terminé de préparer votre application pour la publication, vous disposez d’un fichier APK signé, que vous pouvez distribuer directement aux utilisateurs ou via un marché d’applications tel que Google Play.

Studio Android

Étant donné que Gradle est utilisé dans les exemples ci-dessus, l’emplacement du fichier APK généré est : <Your Project Location>/app/build/outputs/apk/app-debug.apk

IntelliJ

Si vous êtes un utilisateur d’IntelliJ avant de passer à Studio et que vous importez directement votre projet IntelliJ, rien n’a changé. L’emplacement de la sortie sera le même sous :

out/production/...

Remarque : cela deviendra obsolète parfois autour de la version 1.0

Éclipse

Si vous importez directement le projet Android Eclipse, ne le faites pas ! Dès que vous avez des dépendances dans votre projet (jars ou projets de bibliothèque), cela ne fonctionnera pas et votre projet ne sera pas correctement configuré. Si vous n’avez aucune dépendance, l’apk se trouverait au même emplacement que vous le trouveriez dans Eclipse :

bin/...

[1] : https://www.wikiod.com/fr/android/gradle-pour-android#Un fichier build.gradle de base [2] : http://i.stack.imgur.com/GuxhP.png [3] : https://i.stack.imgur.com/jT1Gl.png [4] : https://www.wikiod.com/fr/android/versions-android [5] : http://i.stack.imgur.com/WjYSV.png [6] : https://play.google.com/store/apps/details?id=com.stackexchange.marvin&hl=fr [7] : https://i.stack.imgur.com/YYIjb.png [8] : https://developer.android.com/about/dashboards/index.html [9] : https://i.stack.imgur.com/N1YzZm.png [10] : https://developer.android.com/reference/android/app/Activity.html [11] : https://developer.android.com/studio/projects/index.html [12] : http://i.stack.imgur.com/NL9VZ.png [13] : http://i.stack.imgur.com/acYOg.png [14] : https://developer.android.com/guide/topics/ui/declaring-layout.html [15] : https://www.wikiod.com/fr/android/gradle-pour-android#Un fichier build.gradle de base#t=201609132029568551397 [16] : https://www.wikiod.com/fr/android-gradle/premiers-pas-avec-android-gradle [17] : https://www.wikiod.com/fr/android-gradle/configurez-votre-build-avec-gradle [18] : https://i.stack.imgur.com/XOe2s.png

Configurer Android Studio

[Android Studio][as] est l’IDE de développement Android officiellement pris en charge et recommandé par Google. Android Studio est livré avec le [Android SDK Manager][asdk], qui est un outil permettant de télécharger les composants “Android SDK” nécessaires pour commencer à développer des applications.

Installation d’Android Studio et des outils “Android SDK” :

Téléchargez et installez [Android Studio][asdl].
Téléchargez les derniers outils SDK et SDK Platform-tools en ouvrant Android Studio, puis en suivant les instructions [Android SDK Tool Updates][sdkmanager]. Vous devez installer les derniers packages stables disponibles.

* Si vous devez travailler sur d’anciens projets créés à l’aide d’anciennes versions du SDK, vous devrez peut-être également télécharger ces versions*

Depuis Android Studio 2.2, une copie du dernier OpenJDK est fournie avec l’installation et constitue le [JDK recommandé] [jdk] (Kit de développement Java) pour tous les projets Android Studio. Cela supprime la nécessité d’installer le package JDK d’Oracle. Pour utiliser le SDK fourni, procédez comme suit ;

Ouvrez votre projet dans Android Studio et sélectionnez Fichier > Structure du projet dans la barre de menus.
Sur la page Emplacement du SDK et sous Emplacement du JDK, cochez la case Utiliser le JDK intégré.
Cliquez sur OK.

Configurer Android Studio

Android Studio permet d’accéder à deux fichiers de configuration via le menu Aide :

[studio.vmoptions][2] : personnalisez les options de la machine virtuelle Java (JVM) de Studio, telles que la taille du tas et la taille du cache. Notez que sur les machines Linux, ce fichier peut être nommé studio64.vmoptions, selon votre version d’Android Studio.
[idea.properties][3] : personnalisez les propriétés d’Android Studio, telles que le chemin du dossier des plugins ou la taille de fichier maximale prise en charge.

Modifier/ajouter un thème

Vous pouvez le modifier selon vos préférences.Fichier->Paramètres->Éditeur->Couleurs et polices-> et sélectionner un thème.Vous pouvez également télécharger de nouveaux thèmes à partir de http://color-themes.com/ Une fois que vous avez téléchargé le fichier .jar.zip, allez dans Fichier -> Paramètres d'importation... et choisissez le fichier téléchargé.

Compilation d’applications

Créez un nouveau projet ou ouvrez un projet existant dans Android Studio et appuyez sur le bouton de lecture vert [![enter image description here][4]][4] sur la barre d’outils supérieure pour l’exécuter. S’il est gris, vous devez attendre une seconde pour permettre à Android Studio d’indexer correctement certains fichiers, dont la progression peut être vue dans la barre d’état inférieure.

Si vous souhaitez créer un projet à partir du shell, assurez-vous que vous disposez d’un fichier “local.properties”, qui est créé automatiquement par Android Studio. Si vous devez créer le projet sans Android Studio, vous avez besoin d’une ligne commençant par sdk.dir= suivi du chemin d’accès à votre installation SDK.

Ouvrez un shell et allez dans le répertoire du projet. Entrez ./gradlew aR et appuyez sur Entrée. aR est un raccourci pour assembleRelease, qui téléchargera toutes les dépendances pour vous et créera l’application. Le fichier APK final sera dans ProjectName/ModuleName/build/outputs/apk et s’appellera ModuleName-release.apk.

[en tant que] : https://developer.android.com/develop/index.html [asdk] : https://developer.android.com/tools/help/sdk-manager.html [asdl] : http://developer.android.com/sdk/installing/studio.html [jdk] : https://developer.android.com/studio/intro/studio-config.html#jdk [sdkmanager] : https://developer.android.com/studio/intro/update.html#sdk-manager

[1] : http://tools.android.com/tech-docs/configuration/osx-jdk [2] : https://developer.android.com/studio/intro/studio-config.html#customize_vm [3] : https://developer.android.com/studio/intro/studio-config.html#customize_ide [4] : http://i.stack.imgur.com/d3Y1Z.png

Programmation Android sans IDE

Il s’agit d’un [exemple de Hello World][helloWorld] minimaliste qui n’utilise que les outils Android les plus élémentaires.

Exigences et hypothèses

Oracle JDK 1.7 ou version ultérieure
Outils SDK Android (uniquement les [outils de ligne de commande][sdkDownload])

Cet exemple suppose Linux. Vous devrez peut-être ajuster la syntaxe pour votre propre plate-forme.

Configuration du SDK Android

Après avoir décompressé la version du SDK :

Installez des packages supplémentaires à l’aide du gestionnaire de SDK. Don’t use android update sdk --no-ui as instructed in the bundled Readme.txt; it downloads some 30 GB of unnecessary files. Instead use the interactive SDK manager android sdk to get the recommended minimum of packages.
Ajoutez les répertoires JDK et SDK suivants à votre PATH d’exécution. This is optional, but the instructions below assume it.
- JDK/bin
- SDK/platform-tools
- SDK/tools
- SDK/build-tools/LATEST (as installed in step 1)
Créez un appareil virtuel Android. Use the interactive AVD Manager (android avd). You might have to fiddle a bit and search for advice; the [on-site instructions][createAVD] aren’t always helpful.

(You can also use your own device)
Exécutez l’appareil :
```
 emulator -avd DEVICE
```
Si l’écran de l’appareil semble verrouillé, balayez pour le déverrouiller.

Leave it running while you code the app.

Coder l’application

Accédez à un répertoire de travail vide.

Créez le fichier source :

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

Content:

 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 );
     }
 }

Ajoutez un manifeste :

 touch AndroidManifest.xml

Content:

 <?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>

Créez un sous-répertoire pour les ressources déclarées :
```
 mkdir res
```
Leave it empty for now.

Construire le code

Générez la source des déclarations de ressources. Substitute here the correct path to your SDK, and the installed API to build against (e.g. “android-23”):
```
aapt package -f \
  -I SDK/platforms/android-API/android.jar \
  -J src -m \
  -M AndroidManifest.xml -S res -v
```
Resource declarations (described further below) are actually optional. Meantime the above call does nothing if res/ is still empty.

Compilez le code source en bytecode Java (.java → .class) :

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

Traduisez le bytecode de Java vers Android (.class → .dex) :

First using Jill (.class → .jayce):
```
java -jar SDK/build-tools/LATEST/jill.jar \
  --output classes.jayce src
```
Then Jack (.jayce → .dex):
```
java -jar SDK/build-tools/LATEST/jack.jar \
  --import classes.jayce --output-dex .
```
Android bytecode used to be called “Dalvik executable code”, and so “dex”.

You could replace steps 11 and 12 with a single call to Jack if you like; it can compile directly from Java source (.java → .dex). But there are advantages to compiling with javac. It’s a better known, better documented and more widely applicable tool.
Regroupez les fichiers de ressources, y compris le manifeste :
```
aapt package -f \
  -F app.apkPart \
  -I SDK/platforms/android-API/android.jar \
  -M AndroidManifest.xml -S res -v
```
That results in a partial APK file (Android application package).
Créez l’APK complet à l’aide de l’outil “ApkBuilder”:
```
java -classpath SDK/tools/lib/sdklib.jar \
  com.android.sdklib.build.ApkBuilderMain \
  app.apkUnalign \
  -d -f classes.dex -v -z app.apkPart
```
It warns, “THIS TOOL IS DEPRECATED. See –help for more information.” If --help fails with an ArrayIndexOutOfBoundsException, then instead pass no arguments:
```
java -classpath SDK/tools/lib/sdklib.jar \
  com.android.sdklib.build.ApkBuilderMain
```
It explains that the CLI (ApkBuilderMain) is deprecated in favour of directly calling the Java API (ApkBuilder). (If you know how to do that from the command line, please update this example.)
Optimisez l’alignement des données de l’APK ([pratique recommandée][zipalign]) :
```
zipalign -f -v 4 app.apkUnalign app.apk
```

Installation et exécution

Installez l’application sur l’appareil Android :
```
adb install -r app.apk
```
Démarrez l’application :
```
adb shell am start -n dom.domain/.SayingHello
```
It should run and say hello.

C’est tout. C’est ce qu’il faut pour dire bonjour en utilisant les outils Android de base.

Déclarer une ressource

Cette rubrique est facultative. Les déclarations de ressources ne sont pas requises pour une simple application “hello world”. S’ils ne sont pas non plus requis pour votre application, alors vous pouvez rationaliser quelque peu la construction en omettant l’étape 10, et supprimer la référence au répertoire res/ de l’étape 13.

Sinon, voici un bref exemple de la façon de déclarer une ressource, et comment le référencer.

Ajoutez un fichier de ressources :

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

Content:

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

Référencez la ressource à partir du manifeste XML. This is a declarative style of reference:
```

     <application a:label='@string/appLabel'>
```

Référencez la même ressource à partir de la source Java. This is an imperative reference:

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

Testez les modifications ci-dessus en reconstruisant, réinstallant and re-running the app (steps 10-17).

It should restart and say, “This app is called Saying hello”.

Désinstallation de l’application

adb uninstall dom.domain

Voir également

[original question][originalQ] - La question d’origine à l’origine de cet exemple
[working example][relukExample] - Un script de construction fonctionnel qui utilise les commandes ci-dessus

[createAVD] : https://developer.android.com/training/basics/firstapp/running-app.html#Emulator [helloWorld] : https://www.wikiod.com/fr/258 [originalQ] : http://stackoverflow.com/questions/29178552 [relukExemple] : http://reluk.ca/project/waymaker/spec/build/android/ [sdkDownload] : https://developer.android.com/studio/index.html#downloads [zipalign] : https://developer.android.com/studio/command-line/zipalign.html

Fondamentaux des applications

Les applications Android sont écrites en Java. Les outils Android SDK compilent le code, les données et les fichiers de ressources dans un APK (package Android). Généralement, un fichier APK contient tout le contenu de l’application.

Chaque application s’exécute sur sa propre machine virtuelle (VM) afin que l’application puisse s’exécuter indépendamment des autres applications. Le système Android fonctionne avec le principe du moindre privilège. Chaque application n’a accès qu’aux composants dont elle a besoin pour faire son travail, et pas plus. Cependant, il existe des moyens pour une application de partager des données avec d’autres applications, par exemple en partageant l’identifiant d’utilisateur Linux entre les applications, ou les applications peuvent demander l’autorisation d’accéder aux données de l’appareil telles que la carte SD, les contacts, etc.

Composants d’application

Les composants d’application sont les blocs de construction d’une application Android. Chaque composant joue un rôle spécifique dans une application Android qui sert un objectif distinct et a des cycles de vie distincts (le flux de comment et quand le composant est créé et détruit). Voici les quatre types de composants d’application :

Activités : Une activité représente un écran unique avec une interface utilisateur (UI). Une application Android peut avoir plusieurs activités. (par exemple, une application de messagerie peut avoir une activité pour répertorier tous les e-mails, une autre pour afficher le contenu de chaque e-mail et une autre pour composer un nouvel e-mail.) Toutes les activités d’une application fonctionnent ensemble pour créer une expérience utilisateur (UX). 2. Services : Un service s’exécute en arrière-plan pour effectuer des opérations de longue durée ou pour exécuter des tâches pour des processus distants. Un service ne fournit aucune interface utilisateur, il s’exécute uniquement en arrière-plan avec l’entrée de l’utilisateur. (par exemple, un service peut jouer de la musique en arrière-plan pendant que l’utilisateur est dans une autre application, ou il peut télécharger des données depuis Internet sans bloquer l’interaction de l’utilisateur avec l’appareil Android.) 3. Fournisseurs de contenu : Un fournisseur de contenu gère les données d’application partagées. Il existe quatre façons de stocker des données dans une application : elles peuvent être écrites dans un fichier et stockées dans le système de fichiers, insérées ou mises à jour dans une base de données SQLite, publiées sur le Web ou enregistrées dans tout autre emplacement de stockage persistant auquel l’application peut accéder. . Par le biais de fournisseurs de contenu, d’autres applications peuvent interroger ou même modifier les données. (par exemple, le système Android fournit un fournisseur de contenu qui gère les informations de contact de l’utilisateur afin que toute application autorisée puisse interroger les contacts.) Les fournisseurs de contenu peuvent également être utilisés pour enregistrer les données privées de l’application pour une meilleure intégrité des données.
Récepteurs de diffusion : Un récepteur de diffusion répond aux diffusions d’annonces à l’échelle du système (par exemple, une diffusion annonçant que l’écran s’est éteint, que la batterie est faible, etc.) ou à partir d’applications (par exemple, pour laisser d’autres applications savoir que certaines données ont été téléchargées sur l’appareil et qu’elles peuvent les utiliser). Les récepteurs de diffusion n’ont pas d’interface utilisateur, mais ils peuvent afficher une notification dans la barre d’état pour alerter l’utilisateur. Habituellement, les récepteurs de diffusion sont utilisés comme passerelle vers d’autres composants de l’application, constitués principalement d’activités et de services.

Un aspect unique du système Android est que n’importe quelle application peut démarrer le composant d’une autre application (par exemple, si vous souhaitez passer un appel, envoyer des SMS, ouvrir une page Web ou afficher une photo, il existe une application qui le fait déjà et votre application peut s’en servir, au lieu de développer une nouvelle activité pour la même tâche).

Lorsque le système démarre un composant, il démarre le processus pour cette application (si elle n’est pas déjà en cours d’exécution, c’est-à-dire qu’un seul processus de premier plan par application peut s’exécuter à un moment donné sur un système Android) et instancie les classes nécessaires pour ce composant. Ainsi, le composant s’exécute sur le processus de cette application à laquelle il appartient. Par conséquent, contrairement aux applications sur d’autres systèmes, les applications Android n’ont pas de point d’entrée unique (il n’y a pas de méthode main()).

Étant donné que le système exécute chaque application dans un processus distinct, une application ne peut pas activer directement les composants d’une autre application, contrairement au système Android. Ainsi, pour démarrer le composant d’une autre application, une application doit envoyer un message au système qui spécifie une intention de démarrer ce composant, puis le système démarrera ce composant.

Le contexte

Les instances de la classe android.content.Context fournissent la connexion au système Android qui exécute l’application. Une instance de contexte est nécessaire pour accéder aux ressources du projet et aux informations globales sur l’environnement de l’application.

Prenons un exemple facile à digérer : considérez que vous êtes dans un hôtel et que vous voulez manger quelque chose. Vous appelez le service de chambre et leur demandez de vous apporter des choses ou de nettoyer des choses pour vous. Considérez maintenant cet hôtel comme une application Android, vous-même comme une activité, et la personne du room-service est alors votre contexte, qui vous donne accès aux ressources de l’hôtel comme le room-service, les produits alimentaires, etc.

Encore un autre exemple, vous êtes dans un restaurant assis sur une table, chaque table a un préposé, chaque fois que vous souhaitez commander des produits alimentaires, vous demandez au préposé de le faire. Le préposé passe ensuite votre commande et vos produits alimentaires sont servis sur votre table. Encore une fois dans cet exemple, le restaurant est une application Android, les tables ou les clients sont des composants de l’application, les produits alimentaires sont vos ressources d’application et le préposé est votre contexte, vous donnant ainsi un moyen d’accéder aux ressources comme les produits alimentaires.

L’activation de l’un des composants ci-dessus nécessite l’instance du contexte. Non seulement ce qui précède, mais presque toutes les ressources système : création de l’interface utilisateur à l’aide de vues (voir plus loin), création d’une instance de services système, démarrage de nouvelles activités ou services - tout cela nécessite un contexte.

Une description plus détaillée est écrite [ici][1].

[1] : http://apoorvparmar.com/2016/11/15/android-app-development-intro/

Configuration d’un AVD (Android Virtual Device)

TL; DR Cela nous permet essentiellement de simuler de vrais appareils et de tester nos applications sans appareil réel.

Selon [Android Developer Documentation] [1],

une définition Android Virtual Device (AVD) permet de définir caractéristiques d’un Android Phone, Tablet, Android Wear ou Android Appareil TV que vous souhaitez simuler dans l’émulateur Android. L’AVD Manager vous aide à créer et à gérer facilement des AVD.

Pour configurer un AVD, procédez comme suit :

1. Cliquez sur ce bouton pour afficher le gestionnaire AVD :

[![Icône AVD Manager][2]][2]

2. Vous devriez voir une boîte de dialogue comme celle-ci :

[![Boîte de dialogue Gestionnaire AVD][3]][3]

3. Cliquez maintenant sur le bouton + Créer un périphérique virtuel.... Cela fera apparaître la boîte de dialogue de configuration de périphérique virtuel :

[![Boîte de dialogue de configuration de périphérique virtuel][4]][4]

4. Sélectionnez l’appareil de votre choix, puis cliquez sur “Suivant” :

[![Choisir l’image système][5]][5]

5. Ici, vous devez choisir une version Android pour votre émulateur. Vous devrez peut-être également le télécharger en premier en cliquant sur “Télécharger”. Après avoir choisi une version, cliquez sur “Suivant”.

[![Paramètres avancés][6]][6]

6. Ici, entrez un nom pour votre émulateur, l’orientation initiale et si vous souhaitez afficher un cadre autour de lui. Après avoir choisi tout cela, cliquez sur “Terminer”.

7. Vous avez maintenant un nouvel AVD prêt à lancer vos applications dessus.

[![AVD][7]][7]

[1] : https://developer.android.com/studio/run/managing-avds.html [2] : https://i.stack.imgur.com/zLpI4.png [3] : https://i.stack.imgur.com/zsMEK.png [4] : https://i.stack.imgur.com/NtPZ2.png [5] : https://i.stack.imgur.com/iVu0r.png [6] : https://i.stack.imgur.com/ABcQA.png [7] : https://i.stack.imgur.com/zVesN.png

Premiers pas avec Android

Création d’un nouveau projet #

Configurer Android Studio #

Configurez votre projet #

Configuration de base #

Sélectionnez les facteurs de forme et le niveau d’API #

Ajouter une activité #

Inspecter le projet #

Lancer l’application #

Configuration d’un appareil Android #

Exécution depuis Android Studio #

Emplacement du fichier APK #

Configurer Android Studio #

Configurer Android Studio #

Modifier/ajouter un thème #

Compilation d’applications #

Programmation Android sans IDE #

Exigences et hypothèses #

Configuration du SDK Android #

Coder l’application #

Construire le code #

Installation et exécution #

Déclarer une ressource #

Désinstallation de l’application #

Voir également #

Fondamentaux des applications #

Composants d’application #

Le contexte #

Configuration d’un AVD (Android Virtual Device) #

Création d’un nouveau projet

Configurer Android Studio

Configurez votre projet

Configuration de base

Sélectionnez les facteurs de forme et le niveau d’API

Ajouter une activité

Inspecter le projet

Lancer l’application

Configuration d’un appareil Android

Exécution depuis Android Studio

Emplacement du fichier APK

Configurer Android Studio

Configurer Android Studio

Modifier/ajouter un thème

Compilation d’applications

Programmation Android sans IDE

Exigences et hypothèses

Configuration du SDK Android

Coder l’application

Construire le code

Installation et exécution

Déclarer une ressource

Désinstallation de l’application

Voir également

Fondamentaux des applications

Composants d’application

Le contexte

Configuration d’un AVD (Android Virtual Device)