Android Programmation Android sans IDE


Exemple

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

Exigences et hypothèses

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

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

  2. 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 );
        }
    }
    
  3. 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>
    
  4. Créez un sous-répertoire pour les ressources déclarées:

    mkdir res
    

    Laissez le vide pour le moment.

Construire le code

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

  2. 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
    
  3. 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.

  4. 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).

  5. 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.)

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

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

Installation et exécution

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

    adb install -r app.apk
    
  2. 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.

  1. 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>
    
  2. 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'>
    
  3. 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 ));
    
  4. 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