Compilez des apps natives Android avec le compilateur C++ d'Intel® dans Android Studio

Le compilateur C++ d'Intel® pour Android fait partie du projet Integrated Native Developer Experience d'Intel® (Intel® INDE). Ce tutoriel vous apprend à l'intégrer dans Android Studio, à le définir comme compilateur par défaut et à compiler vos applications natives Android avec.

N'hésitez pas à donner vos avis par rapport à ce tutoriel. Commentez Donner une note à l'article (5)

Article lu   fois.

Les deux auteur et traducteur

Traducteur : Profil Pro

Liens sociaux

Viadeo Twitter Facebook Share on Google+   

I. Introduction

À l'heure actuelle, la version d'Android Studio est bêta 0.8.6. Le compilateur C++ d'Intel® pour Android du projet Integrated Native Developer Experience d'Intel® (Intel® INDE) supporte Android Studio comme un aperçu de la fonctionnalité. Il n'y a ni de modification à faire, ni de travail supplémentaire nécessaire à condition que votre application native puisse être compilée dans Android Studio.

Le Compilateur C++ d'Intel® pour Android (ICC) est configuré comme compilateur par défaut pour les appareils x86 dans le système de compilation du NDK lors de l'installation. Android Studio utilise Gradle comme système de compilation. Gradle appelle le système de compilation du NDK comme une partie du processus de compilation. Par conséquent, le Compilateur C++ d'Intel® est également le compilateur par défaut pour les appareils x86 dans Android Studio. Il n'y a ni de configuration, ni d'installation supplémentaire requise dans Android Studio.

Les étapes ci-dessous décrivent de manière générale comment installer, compiler et exécuter une nouvelle application native dans Android Studio.

II. Logiciels requis

Pour développer des applications natives dans Android Studio, les outils suivants sont nécessaires :

  1. Le JDK 7 d'Oracle ou versions suivantes (JDK Intel®-64 natif pour les systèmes Windows x64) :

    1. Définir la variable d'environnement «  JAVA_HOME » dans le dossier racine du JDK. Exemple : JAVA_HOME=C:\Program Files\Java\jdk1.7.0_67,
    2. Modifier la variable d'environnement « PATH » dans le dossier JAVA_HOME/bin pour que « javah » soit accessible depuis la commande windows ;
  2. Android Studio :

    1. Installez Android Studio et la dernière mise à jour disponible : pour obtenir la dernière mise à jour, ouvrez Android Studio, sélectionnez [Check for update…] dans le menu [Help] et installez la mise à jour,
    2. SDK Android
      Installez le SDK Android depuis Android Studio en cliquant sur le bouton ci-dessous. Assurez-vous d'installer « Intel® x86 Atom System Image » pour « Android x.x.x ,

      Image non disponible
    3. Créez un nouvel appareil virtuel Android (Android Virtual Device) pour Intel® ATOM CPU/ABI en cliquant sur le bouton ci-dessous :
Image non disponible

Et configurez les propriétés de l'appareil virtuel comme ci-dessous :

Image non disponible
  1. NDK Android r9b ou r10b (voir les notes de version pour les prérequis) : supposons qu'il soit installé à [ndk-dir],
  2. Integrated Native Developer Experience d'Intel® : assurez-vous d'installer le compilateur C++ d'Intel® pour Android : sélectionnez le répertoire [ndk-dir] pour le NDK Android lorsqu'il est demandé.

Si vous avez plusieurs NDK Android installés, veuillez suivre les instructions de cet article : Intégrer le compilateur C++ d'Intel® pour Android avec plusieurs NDK Android.

III. Utilisation du compilateur C++ d'Intel® dans Android Studio

Après l'installation du compilateur C++ d'Intel® 15.0 pour Android, les outils suivants sont installés dans le dossier « [ndk-dir]\toolchains » :

  • x86-icc ;
  • x86-icc15.0.X.YYY.

Après installation, le compilateur C++ d'Intel® devient le compilateur natif C/C++ par défaut. Il n'y a pas d'étapes supplémentaires pour utiliser le compilateur C++ d'Intel® dans Android Studio. Si vous désirez utiliser le compilateur GCC pour compiler du code natif, veuillez vous référer à : Changer le compilateur C++ d'Intel par défaut en GCC pour les appareils x86.

Puisqu'il s'agit d'une version bêta d'Android Studio, il est possible de rencontrer quelques problèmes lorsque vous importez des exemples provenant directement du NDK. Nous allons maintenant créer un nouveau projet Android incluant une fonction native d'appel pour détailler l'utilisation du compilateur C++ d'Intel®.

III-A. Créer un nouveau projet Android avec une interface native

  1. Ouvrez Android Studio, créez un nouveau projet Android « nativeDemo » tout en conservant les paramètres par défaut.

    Image non disponible
  2. Ouvrez « app\src\main\java\MainActivity.java » et ajoutez une fonction native à la fin de la classe MainActivity comme ci-dessous :

     
    Sélectionnez
    public native String getStringFromNative();
  3. Compilez le projet « nativeDemo » : sélectionnez le menu « Build > Make Project » afin de préparer « javah » à être utilisé.

  4. Ouvrez la fenêtre du terminal depuis « View > Tools Windows > Terminal » et exécutez « javah » pour créer l'en-tête jni :

    1. Dans la fenêtre du terminal, allez dans le sous-dossier « src\main » : cd src\main ;
    2. Exécutez la commande « javah » suivante, elle crée l'en-tête « com_example_nativedemo_app_MainActivit.h » dans le dossier « src\main\jni » :

       
      Sélectionnez
      javah -d .\jni -classpath C:\Android\android-studio\sdk\platforms\android-20\android.jar;..\..\build\intermediates\classes\debug com.example.mydemo.nativedemo.MainActivity

      Exemple :

      Image non disponible
  5. Clic droit sur le dossier « src », sélectionnez « Sycnhronize 'src' » : maintenant vous pouvez voir le fichier d'en-tête « com_example_nativedemo_app_MainActivit.h » dans le dossier « src\main\jni ».

III-B. Ajoutez le code source natif : main.c, dummy.c

  1. Créez le fichier « main.c » : sélectionnez le fichier « com_example_nativedemo_app_MainActivity.h », faites du copier/coller pour créer un nouveau fichier « main.c » avec le code suivant :

     
    Sélectionnez
    1.
    2.
    3.
    4.
    5.
    6.
    7.
    8.
    9.
    10.
    #include "com_example_nativedemo_app_MainActivity.h"
         
    JNIEXPORT jstring JNICALL Java_com_example_nativedemo_app_MainActivity_getStringFromNative(JNIEnv * env, jobject obj)
    {
        #ifdef __Intel®_COMPILER_UPDATE
            return (*env)->NewStringUTF(env, "Hello from Intel® C++ !");
        #else
            return (*env)->NewStringUTF(env, "Hello from default C++ !");
        #endif
    }
    
  2. Créez « dummy.c » : créez un autre fichier vide « dummy.c ».

    Ce fichier est nécessaire seulement sur Windows et ne sera probablement pas requis dans la version finale d'Android Studio.

  3. Maintenant, vous avez trois fichiers dans le dossier « jni » : com_example_nativedemo_app_MainActivity.h, main.c et dummy.c.
Image non disponible

III-C. Définissez la racine du NDK dans le projet

Ouvrez le fichier du projet « local.properties » et ajoutez ndk.dir.

Exemple : sdk.dir=C\:/Android/android-studio/sdk

ndk.dir=C\:/android-ndk-r9d

III-D. Remplacez « libapp.so » définie par défaut par « myNativeTest.lib »

  1. Ouvrez « build.gradle » : ajoutez la section « ndk » suivante dans « defaultConfig » comme ci-dessous :

     
    Sélectionnez
    1.
    2.
    3.
    4.
    5.
    6.
    7.
    8.
    9.
    10.
    defaultConfig {
        minSdkVersion 18
        targetSdkVersion 19
        versionCode 1
        versionName "1.0"
        ndk {
            moduleName "myNativeTest"
            abiFilter "x86"
        }
    }
    
  2. Maintenant, compilez le projet : sélectionnez [Build > Make Project]. Vous verrez tous les dossiers de sortie et les fichiers « libmyNativeTest.so » dans les dossiers « app\build\ndk\debug\lib » et « app\build\ndk\debug\obj\local ».

III-E. Ajoutez un ID « hello_testview » au widget textview

Ouvrez « res\layout\activity_main.xml » et ajoutez :

 
Sélectionnez
1.
2.
3.
4.
5.
<TextView
    android:text="@string/hello_world"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:id="@+id/hello_textview" />

III-F. Mise à jour « MainActivity.java »

Il faut mettre à jour « MainActivity.java » pour lier l'appel de la bibliothèque native à l'interface utilisateur du widget textview.

 
Sélectionnez
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
public class MainActivity extends Activity {
    static { // load the native library "myNativeTest"
        System.loadLibrary("myNativeTest");
    }
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        
        // get the text string from native API, and display on the UI
        TextView tv = (TextView)findViewById(R.id.hello_textview);
        tv.setText(this.getStringFromNative());
    }

Démarrez la machine virtuelle Android « Intel®-Nexus4 ».

Exécutez l'application en cliquant sur le bouton « Run ».

Image non disponible

Cela signifie que le compilateur utilisé est le compilateur C++ d'Intel® pour Android

IV. Résumé

Vous savez maintenant comment compiler une simple application native Android avec le compilateur C++ d'Intel® dans Android Studio. Essayez-le avec une de vos applications natives et dites-nous comment ça se passe.

Retrouvez toutes les ressources et outils Intel pour les développeurs Android sur la Zone des Développeurs Intel Android.

V. Ressources

Vous avez aimé ce tutoriel ? Alors partagez-le en cliquant sur les boutons suivants : Viadeo Twitter Facebook Share on Google+   

  

Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée par les droits d'auteur. Copyright © 2014 Jennifer J.. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.