Android Tutoriel
Démarrer avec Android

Remarques

Versions

Configurer Android Studio

Android Studio est l'IDE de développement Android officiellement pris en charge et recommandé par Google. Android Studio est fourni avec Android SDK Manager , un outil permettant de télécharger les composants du Android SDK requis pour commencer à développer des applications.

Installation des outils Android Studio et Android SDK :

1. Téléchargez et installez Android Studio .
2. Téléchargez les outils SDK et les outils de plate-forme SDK les plus récents en ouvrant Android Studio, puis en suivant les instructions de mise à jour de l'outil SDK Android . Vous devez installer les derniers packages stables disponibles.

Si vous avez besoin de travailler sur d'anciens projets construits à l'aide d'anciennes versions de SDK, vous devrez peut-être également télécharger ces versions

Depuis Android Studio 2.2, une copie de la dernière OpenJDK est fournie avec l’installation et est le JDK (Java Development Kit) recommandé 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:

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

Configurer Android Studio

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

• studio.vmoptions : 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 : personnalise les propriétés d'Android Studio, telles que le chemin du dossier des plug-ins ou la taille de fichier maximale prise en charge.

Changer / ajouter un thème

Vous pouvez le changer selon vos préférences. File->Settings->Editor->Colors & Fonts-> et sélectionnez 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 File -> Import Settings... et choisissez le fichier téléchargé.

Compiler les applications

Créez un nouveau projet ou ouvrez un projet existant dans Android Studio et appuyez sur le bouton de lecture vert dans 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 est visible dans la barre d'état inférieure.

Si vous souhaitez créer un projet à partir du shell, vérifiez que vous disposez d'un fichier local.properties 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 accédez au répertoire du projet. Entrez ./gradlew aR et appuyez sur Entrée. aR est un raccourci pour assembleRelease , qui télécharge toutes les dépendances pour vous et construit l'application. Le fichier APK final sera dans ProjectName/ModuleName/build/outputs/apk et s'appellera ModuleName-release.apk .

Créer un nouveau projet

Configurer Android Studio

Commencez par configurer Android Studio , puis ouvrez-le. Maintenant, vous êtes 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 Start a New Android Studio Project partir de l'écran d'accueil.
• Accédez à File → New Project si un projet est déjà ouvert.

Ensuite, vous devez décrire votre application en remplissant certains champs:

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

   Exemple: Hello World . Vous pouvez toujours le modifier ultérieurement dans le fichier AndroidManifest.xml .

2. Domaine de la société - Il s'agit du qualificatif correspondant au nom du package de votre projet.

   Exemple: stackoverflow.com .

3. Nom du package (aka applicationId ) - Ceci est le nom du package de projet complet.

   Il doit suivre la notation inversée des noms de domaine ( DNS inversé ): domaine de premier niveau . Compagnie Domaine. [ Segment de la société . ] Nom de l'application .

   Exemple: com.stackoverflow.android.helloworld ou com.stackoverflow.helloworld . Vous pouvez toujours modifier votre application en la remplaçant dans votre fichier de graduation .

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 application unique dans Google Play.

4. Emplacement du projet - C'est le répertoire dans lequel votre projet sera stocké.

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 le téléphone, la tablette, la télévision, Wear et Google Glass. Les facteurs de forme sélectionnés deviennent les modules d’application du projet. Pour chaque facteur de forme, vous pouvez également sélectionner le niveau API pour cette application. Pour plus d'informations, cliquez sur Aidez-moi à choisir

Graphique des distributions de versions Android actuelles, affichées lorsque vous cliquez sur Aidez-moi à choisir.

La fenêtre Distribution de 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 la liste des fonctionnalités introduites dans la version correspondante d'Android. Cela vous aide à choisir le niveau minimum d'API doté de toutes les fonctionnalités dont vos applications ont besoin pour pouvoir accéder à autant de périphériques que possible. Puis cliquez sur OK .

Maintenant, choisissez les plates-formes et la version du SDK Android que l'application prendra en charge.

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

Le minimum SDK est la limite inférieure de votre application. C'est l'un des signaux utilisés par Google Play Store pour déterminer les périphériques sur lesquels une application peut être installée. Par exemple, l'application Stack Exchange prend en charge Android 4.1+.

Android Studio vous indiquera (approximativement) quel pourcentage d'appareils sera pris en charge, compte tenu du SDK minimum spécifié.

Les niveaux inférieurs de l'API ciblent davantage de périphériques mais disposent de moins de fonctionnalités.

Lorsque vous décidez du kit SDK minimum , vous devez tenir compte des statistiques de Dashboards , qui vous donneront des informations sur la version des appareils ayant visité le Google Play Store au cours de la dernière semaine.

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 Activity 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 Empty Activity et cliquez sur Suivant.

Ici, si vous le souhaitez, vous pouvez changer le nom de l'activité et de la mise en page. Une bonne pratique consiste à conserver l' 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 . Maintenant, cliquez sur Finish .

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

Inspection du projet

Pour comprendre comment fonctionne Android, jetons un coup d’œil à certains fichiers créés pour nous.

Sur le volet gauche d'Android Studio, nous pouvons voir la structure de notre application Android .

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 des 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 le périphérique, le programme d'installation détermine s'il convient ou non d'accorder l'autorisation demandée en vérifiant les autorités ayant 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 l'une 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 les siens.

<?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 de 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 de Android Studio, comme illustré ici:

<?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 dans cette présentation, avec la propriété android:text définie sur "Hello World!". Ceci est un bloc de texte qui sera affiché à l'utilisateur lors de l'exécution de l'application.

Vous pouvez en savoir plus sur les mises en page et les attributs .

Ensuite, regardons MainActivity . C'est le 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 sera lancé par défaut lorsqu'un utilisateur lance l'application HelloWorld .

Enfin, ouvrez le fichier nommé build.gradle situé dans app/ .
Android Studio utilise le système de génération 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. 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)
• base de feu : 11.0.4 (août 2017)

compileSdkVersion

compileSdkVersion est votre façon de dire à Gradle quelle version du SDK Android compiler votre application. L'utilisation du nouveau SDK Android est une exigence 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 à l'exécution. Bien que de nouveaux avertissements / erreurs du compilateur puissent être présents lors du changement de votre compileSdkVersion , votre compileSdkVersion n'est pas inclus dans votre APK: il est purement utilisé au moment de la compilation.

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

minSdkVersion

Si compileSdkVersion définit les dernières API disponibles, minSdkVersion est la limite inférieure de votre application. minSdkVersion est l'un des signaux utilisés par Google Play Store pour déterminer sur quel périphérique d'un utilisateur une application peut être installée.

Il joue également un rôle important pendant le développement: par défaut, les linteaux contre votre projet vous avertissent lorsque vous utilisez des API au-dessus de votre minSdkVersion , vous aidant ainsi à éviter le problème d'exécution d'une API inexistante. La vérification de la version du système à l'exécution est une technique courante lors de l'utilisation des API uniquement sur les versions de plate-forme plus récentes.

targetSdkVersion

targetSdkVersion est la méthode principale targetSdkVersion Android pour targetSdkVersion la targetSdkVersion la targetSdkVersion n'appliquant pas les changements de comportement à moins que targetSdkVersion soit mis à jour. Cela vous permet d'utiliser de nouvelles API avant de modifier les comportements. La mise à jour pour cibler le dernier SDK devrait être une priorité élevée pour chaque application. Cela ne signifie pas que vous devez utiliser chaque nouvelle fonctionnalité introduite, ni mettre à jour aveuglément votre targetSdkVersion sans le tester.

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

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

• Un exemple de base
• Introduction au plugin Gradle pour Android et au wrapper
• Introduction à la configuration des méthodes build.gradle et DSL

Exécution de l'application

Maintenant, exécutons notre application HelloWorld. Vous pouvez soit exécuter un appareil virtuel Android (que vous pouvez configurer en utilisant le Gestionnaire AVD dans Android Studio, comme décrit dans l'exemple ci-dessous) ou connecter votre propre appareil Android via un câble USB.

Configurer un appareil Android

Pour exécuter une application à partir d'Android Studio sur votre appareil Android, vous devez activer le USB Debugging dans les Developer Options du Developer Options dans les paramètres de votre appareil.

Settings > Developer options > USB debugging

Si les Developer Options ne sont pas visibles dans les paramètres, accédez à About Phone et appuyez sur le Build Number sept fois. Cela permettra aux Developer Options de s'afficher dans vos paramètres.

Settings > About phone > Build number

Vous devrez peut-être également modifier la configuration de build.gradle pour build.gradle une version de votre périphérique.

Exécution depuis Android Studio

Cliquez sur le bouton vert Run dans la barre d'outils située en haut de Android Studio. Dans la fenêtre qui apparaît, sélectionnez le périphérique sur lequel vous souhaitez exécuter l'application (démarrez un périphérique virtuel Android si nécessaire ou reportez-vous à la section Configuration d'un périphérique virtuel Android si vous devez en configurer un), puis cliquez sur OK .

Sur les appareils fonctionnant sous Android 4.4 (KitKat) et éventuellement plus haut, une fenêtre contextuelle apparaîtra pour autoriser le débogage USB. Cliquez sur OK pour accepter.

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

Emplacement du fichier APK

Lorsque vous préparez votre application pour la publication, vous configurez, créez et testez une version finale de votre application. Les tâches de configuration sont simples et impliquent des tâches de base de nettoyage du code et de modification du code qui permettent d'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 demande de publication, vous disposez d'un fichier APK signé, que vous pouvez distribuer directement aux utilisateurs ou distribuer via un marché d'applications tel que Google Play.

Studio Android

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

IntelliJ

Si vous utilisez IntelliJ avant de passer à Studio et importez directement votre projet IntelliJ, rien n'a changé. L'emplacement de la sortie sera le même sous:

out/production/...

Note: ceci deviendra parfois obsolète autour de 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 pas de dépendances, l'apk se trouverait au même endroit que vous le trouveriez dans Eclipse:

bin/...

Programmation Android sans IDE

Voici un exemple minimaliste de Hello World qui utilise uniquement les outils Android les plus élémentaires.

Exigences et hypothèses

• Oracle JDK 1.7 ou version ultérieure
• Android SDK Tools (juste les outils de ligne de commande )

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

Configuration du SDK Android

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

1. Installez des packages supplémentaires à l'aide du gestionnaire du SDK. N'utilisez pas la android update sdk --no-ui comme indiqué dans le fichier Readme.txt fourni; Il télécharge environ 30 Go de fichiers inutiles. Au lieu de cela, utilisez le gestionnaire de SDK interactif android sdk pour obtenir le minimum recommandé de paquets.

2. Ajoutez les répertoires JDK et SDK suivants à votre exécution PATH. Ceci est facultatif, mais les instructions ci-dessous l'assument.

   • JDK / bin
   • SDK / platform-tools
   • SDK / outils
   • SDK / build-tools / LATEST (tel qu'installé à l'étape 1)

3. Créez un périphérique virtuel Android. Utilisez le gestionnaire AVD interactif ( android avd ). Vous devrez peut-être bricoler un peu et chercher des conseils; les instructions sur site ne sont pas toujours utiles.

   (Vous pouvez également utiliser votre propre appareil)

4. Exécutez le périphérique:

   emulator -avd DEVICE
   

5. Si l'écran de l'appareil semble être verrouillé, faites-le glisser pour le déverrouiller.

   Laissez-le fonctionner pendant que vous codez l'application.

Coder l'application

6. Passez à un répertoire de travail vide.

7. Faites le fichier source:

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

   Contenu:

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

8. Ajouter un manifeste:

   touch AndroidManifest.xml
   

   Contenu:

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

9. Créez un sous-répertoire pour les ressources déclarées:

   mkdir res
   

   Laissez le vide pour le moment.

Construire le code

10. Générez la source pour les déclarations de ressources. Remplacez ici le chemin d'accès correct à votre SDK et l' API installée pour la construire (par exemple "android-23"):

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

    Les déclarations de ressources (décrites ci-dessous) sont facultatives. Pendant ce temps, l'appel ci-dessus ne fait rien si res / est toujours vide.

11. 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
    

12. Traduire le bytecode de Java en Android (.class → .dex):

    En utilisant d'abord Jill (.class → .jayce):

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

    Puis Jack (.jayce → .dex):

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

    Android bytecode s'appelait auparavant "Dalvik executable code", et donc "dex".

    Vous pouvez remplacer les étapes 11 et 12 par un seul appel à Jack si vous le souhaitez; il peut compiler directement depuis le source Java (.java → .dex). Mais la compilation avec javac présente des avantages. C'est un outil mieux connu, mieux documenté et plus largement applicable.

13. Emballez 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
    

    Cela se traduit par un fichier APK partiel (package d'application Android).

14. Créez le fichier 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
    

    Il avertit, "CET OUTIL EST PÉRIMÉ. Voir --help pour plus d'informations." Si --help échoue avec une ArrayIndexOutOfBoundsException , ne transmettez pas les arguments à la place:

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

    Il explique que l'interface de ligne de commande ( ApkBuilderMain ) est déconseillée au lieu d'appeler directement l'API Java ( ApkBuilder ). (Si vous savez comment faire cela depuis la ligne de commande, veuillez mettre à jour cet exemple.)

15. Optimiser l'alignement des données de l'APK ( pratique recommandée ):

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

Installation et exécution

16. Installez l'application sur l'appareil Android:

    adb install -r app.apk
    

17. Démarrez l'application:

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

    Il devrait courir et dire bonjour.

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

Déclaration d'une ressource

Cette section est facultative. Les déclarations de ressources ne sont pas nécessaires pour une application simple "bonjour monde". Si elles ne sont pas nécessaires pour votre application, vous pouvez simplifier quelque peu la construction en omettant l'étape 10 et en supprimant 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 de la référencer.

18. Ajoutez un fichier de ressources:

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

    Contenu:

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

19. Référencez la ressource à partir du manifeste XML. Ceci est un style de référence déclaratif:

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

20. Référencez la même ressource de la source Java. Ceci est une référence impérative:

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

21. Testez les modifications ci-dessus en reconstruisant, en réinstallant et en réexécutant l'application (étapes 10 à 17).

    Il devrait redémarrer et dire: "Cette application s'appelle Dire bonjour".

Désinstallation de l'application

adb uninstall dom.domain

Voir également

• question originale - La question originale qui a incité cet exemple
• Exemple de travail - Un script de construction qui utilise les commandes ci-dessus

Principes de base de l'application

Les applications Android sont écrites en Java. Les outils du SDK Android compilent les fichiers de code, de données et de ressources dans un fichier 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 isolée 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, pas plus. Cependant, une application peut partager des données avec d'autres applications, par exemple en partageant l'ID utilisateur Linux entre les applications, ou les applications peuvent demander l'autorisation d'accéder aux données du périphérique telles que la carte SD, les contacts, etc.

Composants de l'application

Les composants de l'application sont les éléments constitutifs 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:

1. Activités: Une activité représente un seul écran avec une interface utilisateur. Une application Android peut avoir plusieurs activités. (Par exemple, une application de messagerie peut avoir une activité pour répertorier tous les emails, une autre pour afficher le contenu de chaque email et une autre pour composer un nouvel email). Toutes les activités d'une application fonctionnent ensemble pour créer une expérience utilisateur.
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 lire de la musique en arrière-plan lorsque l'utilisateur se trouve dans une autre application ou il peut télécharger des données sur 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ée. Il existe quatre manières 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. . Grâce à des 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 enregistrer les données privées de l'application pour une meilleure intégrité des données.
4. Récepteurs de diffusion: un récepteur de diffusion répond aux diffusions d’annonces diffusées à l’échelle du système (par exemple, une émission annonçant que l’écran est éteint, que la batterie est faible, etc.) ou d’applications (par exemple, téléchargé sur l'appareil et est disponible pour qu'ils puissent l'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. Les récepteurs de diffusion sont généralement utilisés comme passerelles vers d'autres composants de l'application, principalement des activités et des services.

Un aspect unique du système Android est que toute application peut démarrer le composant d'une autre application (par exemple, si vous souhaitez faire un appel, envoyer des SMS, ouvrir une page Web ou afficher une photo, il existe déjà une application l'utiliser, au lieu de développer une nouvelle activité pour la même tâche).

Lorsque le système démarre un composant, il lance le processus pour cette application (s'il n'est pas déjà lancé, c'est-à-dire qu'un seul processus par application peut s'exécuter à tout moment 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() ).

Comme le système exécute chaque application dans un processus distinct, une application ne peut pas activer directement les composants d'une autre application, quel que soit le système Android. Ainsi, pour démarrer le composant d'une autre application, une application doit envoyer un message au système spécifiant l'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. L'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 à comprendre: Considérez que vous êtes dans un hôtel et que vous voulez manger quelque chose. Vous appelez le room-service et demandez-leur de vous apporter des choses ou de nettoyer des choses pour vous. Maintenant, pensez à cet hôtel comme une application Android, vous-même en tant qu’activité et le room-service est alors votre contexte, ce qui vous permet d’accéder 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 accompagnateur, chaque fois que vous voulez commander des produits alimentaires, vous demandez au préposé de le faire. Le préposé place 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 App, les produits alimentaires sont les ressources de votre application et le standardiste est votre contexte, ce qui vous permet d'accéder aux ressources comme des 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: la création de l'interface utilisateur à l'aide de vues (abordées plus loin), la création d'une instance de services système, le démarrage de nouvelles activités ou services nécessitent tous un contexte.

Une description plus détaillée est écrite ici .

Configuration d'un AVD (Android Virtual Device)

TL; DR Il nous permet essentiellement de simuler des appareils réels et de tester nos applications sans appareil réel.

Selon Android Developer Documentation ,

une définition de périphérique virtuel Android (AVD) vous permet de définir les caractéristiques d’un appareil Android Phone, Tablet, Android Wear ou Android TV que vous souhaitez simuler dans l’émulateur Android. Le gestionnaire AVD 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:

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

3. Cliquez maintenant sur le bouton + Create Virtual Device... Cela fera apparaître la boîte de dialogue Virtual Device Configuration:

4. Sélectionnez n'importe quel périphérique de votre choix, puis cliquez sur Next :

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

6. Entrez ici un nom pour votre émulateur, l'orientation initiale et si vous souhaitez afficher un cadre autour de lui. Après avoir choisi tous ces éléments, cliquez sur Finish .

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