Objectif
Cet article est une introduction pour novice à la création d’applications Android* natives (NDK) pour appareils basés sur l’architecture Intel®. Nous aborderons également le portage sur des appareils basés sur l’architecture Intel d’applications Android NDK ayant été créées pour des appareils basés sur une autre architecture. Nous allons décrire deux scénarios, l’un démontrant de bout en bout le processus de création d’une application Android* NDK de base et l’autre démontrant un processus simple de portage d’une application Android NDK existante sur des appareils basés sur l’architecture Intel.
Table des matières
a. Création d’un projet Android par défaut
b. Invocation du code natif de sources Java
c. Utilisation de javah pour générer des stubs d’en-tête JNI pour code natif
d. Construction d’un code natif avec le NDK pour architecture Intel
e. Reconstruction, installation et exécution de l’application Android NDK pour l'architecture Intel
Introduction
Les applications Android peuvent incorporer du code natif en utilisant le jeu d’outils du NDK (Native Development Kit). Cela permet aux développeurs de réutiliser le code existant, le code de matériel de bas niveau, ou de différencier leurs applications en tirant parti de fonctionnalités qui ne seraient pas optimales ou possibles autrement.
Cet article est une introduction de base montrant de bout en bout comment créer des applications NDK pour l’architecture Intel, et décrit également des cas d’utilisation simples permettant de porter des applications NDK existantes sur des appareils basés sur l’architecture Intel. Nous décrirons pas à pas un scénario de développement d’application afin de démontrer le processus.
Nous prenons pour hypothèse que vous avez déjà installé l’environnement de développement Android, y compris le SDK Android, le NDK Android et que vous avez configuré l’émulateur x86 pour tester les applications. Reportez-vous à la section Communauté Android du site Web Intel pour davantage d’informations. Pour préserver la simplicité de notre environnement de développement, nous allons utiliser principalement les outils de ligne de commande Linux*.
Création d’une application Android NDK pour appareil basé sur l'architecture Intel – Description d’une application simple
Prenons pour hypothèse que nous avons du code existant qui utilise du C et du langage d’assemblage pour analyser le CPUID (reportez-vous à http://en.wikipedia.org/wiki/CPUID* pour davantage d’information sur le CPUID). Vous trouverez ci-dessous la liste de sources de notre exemple de code C « existant » cpuid.c (pour démonstration uniquement).
Nous aimerions appeler cpuid_parse depuis notre application Android (pour démonstration uniquement – la fonction cpuid_parse attend un tampon pré-alloué) et afficher la sortie à l’intérieur de l’application.
Vous trouverez ci-dessous une description pas à pas permettant de créer une application Android de bout en bout et d’utiliser le code natif existant ci-dessus.
1. Création d’un projet Android par défaut
Le SDK Android possède des outils de ligne de commande permettant de générer une structure de projet par défaut pour les applications hello world typiques. Nous allons tout d’abord créer un projet par défaut puis modifier les sources java pour ajouter des appels JNI et du code natif.
Dans la capture d’écran ci-dessus, nous avons d’abord créé un répertoire appelé labs/lab2 et utilisé l'outil de ligne de commande « android » pour générer le projet par défaut. Nous avons spécifié android-15 comme niveau d’API et nommé notre application « CPUIdApp » avec le package com.example.cpuid.
Nous avons ensuite utilisé l’outil de ligne de commande « ant » pour construire le projet en mode de débogage et l'installer avec « adb » (ou le réinstaller s’il existe sur l’émulateur ou la cible). Nous prenons pour hypothèse que vous avez déjà un émulateur ou qu’un appareil est connecté et c’est le seul appareil indiqué dans la sortie de commande « adb devices ».
Vous trouverez ci-dessous une capture d’écran de l’émulateur x86 Android avec ICS une fois le processus ci-dessus terminé.
Lorsque vous cliquez sur l’application, vous pouvez voir la sortie par défaut hello world de l’application. Nous allons maintenant modifier l’application pour utiliser du code natif.
2. Invocation de code natif depuis des sources java
Le projet Android par défaut génère les sources Java d’un projet hello world typique avec un espace de nom de package (par ex. : com.example.cpuid). La capture d’écran ci-dessous montre le code source généré pour le fichier source Java principal.
Pour utiliser du code c/c++ natif dans votre fichier source Java, nous devons tout d’abord déclarer l’appel JNI et charger la bibliothèque native, comme mis en évidence par le cadre jaune dans la capture d’écran ci-dessous.
Comme vu dans la déclaration, l’appel natif retourne une chaîne Java que nous pouvons utiliser n’importe où dans notre source Java. Comme le montre la capture d’écran ci-dessus, nous avons modifié la vue TextView pour qu’elle affiche la chaîne obtenue de l’appel natif. Cela est mis en évidence dans le cadre rouge.
Ceci est un cas très simple de déclaration et d’utilisation d’appels JNI natifs dans les sources Java d’applications Android. Ensuite, nous allons utiliser l’outil « javah » pour générer les stubs d’en-tête JNI du code natif et ajouter ou modifier du code natif afin de nous conformer aux en-têtes JNI natifs.
3. Utilisation de « javah » pour générer des stubs d’en-tête JNI pour code natif
Nous devons maintenant modifier notre code natif afin qu’il se conforme à la spécification d’appel JNI. L’outil « javah » aide à générer automatiquement les stubs d’en-tête JNI en fonction des fichiers source Java. L’outil « javah » nécessite le fichier des classes Java compilées pour générer les en-têtes. Nous avons donc utilisé l’outil « ant » pour générer rapidement le fichier de classes java class comme illustré dans la capture d’écran ci-dessous (« ant debug »).
Utilisez « javah » pour générer l’en-tête JNI comme montré dans la capture d’écran (deuxième cadre jaune). Cela crée le répertoire « jni » et le stub d’en-tête basé sur la classe Java. La capture d’écran ci-dessous montre le stub d’en-tête natif JNI généré.
Créez un fichier source C correspondant (« com_example_cpuid_CPUIdApp.c ») pour l’en-tête généré ci-dessus. Vous trouverez ci-dessous la liste des sources :
Nous appelons le code natif cpuid_parse et retournons le tampon analysé sous forme de chaîne JNI. Nous sommes maintenant prêts à compiler le code natif à l’aide du jeu d’outils NDK x86.
4. Construction d’un code natif avec le NDK pour x86
Reportez-vous à la section de la communauté Android du site Web Intel (/en-us/articles/ndk-for-ia) pour davantage d’informations sur l’installation et l’utilisation du NDK pour l' architecture Intel.
Le jeu d’outils du NDK Android utilise un système de build, qui nécessite la présence d’un fichier make « Android.mk » spécifique Android dans le dossier « jni » du projet pour compiler le code natif. Android.mk spécifie tous les fichiers source C/C++ natifs à compiler, les en-têtes et le type de build (par ex. : shared_library).
Vous trouverez ci-dessous la liste make Android du code natif de notre projet (« jni/Android.mk »)
Il s’agit d'un scénario simple avec deux fichiers source C et les spécification de construction d'une bibliothèque partagée.
Nous pouvons maintenant utiliser « ndk-build APP_ABI=x86 » pour construire notre code natif et générer la bibliothèque partagée. Le système de build Android fournit un autre fichier make, « Application.mk », que nous pouvons utiliser pour spécifier des options de configuration supplémentaires. Par exemple, nous pouvons spécifier toutes les ABI prises en charge dans le fichier Application.mk, et le build du NDK générera les bibliothèques partagées natives ciblant toutes les architectures.
La capture d’écran ci-dessus montre la compilation réussie d’un code natif pour x86, ainsi que la bibliothèque partagée étant générée et installée. Nous sommes maintenant prêts à reconstruire notre application Android et à l’installer/exécuter sur l’émulateur x86 ou l’appareil cible.
5. Reconstruction, installation et exécution de l’application Android NDK pour l'architecture Intel
Nous pouvons utiliser « ant debug clean » pour effacer les anciens fichiers de build et émettre à nouveau la commande « ant debug » pour lancer la reconstruction complète du projet Android. Utilisez « adb » pour réinstaller l’application sur l’appareil cible ou l’émulateur x86 comme montré dans la capture d’écran ci-dessous.
La capture d’écran ci-dessous montre l’icône de l’application à l’intérieur de l’émulateur x86 et le résultat de l’exécution de l’application dans l’émulateur x86.
Nous avons construit avec succès une application Android NDK de bout en bout.
Utilisation du jeu d’outils du NDK x86 pour porter des applications NDK existantes sur des appareils basés sur l’architecture Intel
Les applications Android à code natif possèdent habituellement une structure de projet standard, avec un dossier « jni » contenant les sources natives, et les fichiers de build Android.mk/Application.mk correspondants. Dans la section précédente, nous avons vu un exemple simple avec un code source natif et le fichier Android.mk correspondant.
Le jeu d’outils NDK Android permet de spécifier toutes les ABI cibles en même temps dans le fichier Application.mk et génère automatiquement les bibliothèques partagées natives de toutes les cibles. Le système de build Android intègre automatiquement toutes les bibliothèques cibles natives dans l’APK et, au moment de l’installation, le gestionnaire de package Android installe uniquement la bibliothèque native appropriée en fonction de l’architecture de la cible.
Nous pouvons invoquer « ndk-build » ou le spécifier dans Application.mk
APP_ABI := all OU APP_ABI := armeabi armeabi-v7a x86 |
Reportez-vous à http://developer.android.com/sdk/ndk/index.html pour davantage d’informations.
Pour porter une application Android existante avec un code natif qui ne cible pas actuellement x86, le processus de modification de l’application destiné à prendre en charge l’architecture Intel est simple dans la plupart des cas (comme décrit ci-dessus), à moins que l’application utilise un langage d’assemblage ou des constructions spécifiques à l’architecture. D’autres problèmes peuvent survenir, tels que l’alignement de la mémoire ou une utilisation des instructions spécifique à la plate-forme. Reportez-vous à /en-us/articles/ndk-android-application-porting-methodologies pour davantage d’informations.
Résumé
Cet article décrivait la création et le portage d’applications Android NDK sur l’architecture Intel. Nous avons décrit le processus pas à pas afin de démontrer le processus de création d’une application NDK utilisant l’architecture Intel de bout en bout. Nous avons également décrit le processus simple rendu disponible par le jeu d'outils du NDK permettant de porter des applications Android NDK existantes sur l’architecture Intel.
Avis
Intel est une marque de commerce d’Intel Corporation aux États-Unis et dans d’autres pays.
LES INFORMATIONS CONTENUES DANS CE DOCUMENT CONCERNENT LES PRODUITS INTEL. LA SOCIÉTÉ INTEL N'ACCORDE AUCUNE LICENCE EXPRESS, NI IMPLICITE, PAR FORCLUSION OU AUTRE SUR UN DROIT QUELCONQUE DE PROPRIÉTÉ INTELLECTUELLE. À L'EXCEPTION DES DISPOSITIONS PRÉVUES AUX CONDITIONS GÉNÉRALES DE VENTE D'INTEL POUR LESDITS PRODUITS, INTEL DÉCLINE TOUTE RESPONSABILITÉ ET EXCLUT TOUTE GARANTIE EXPLICITE OU IMPLICITE SE RAPPORTANT À LEUR VENTE OU À LEUR UTILISATION. INTEL DÉCLINE NOTAMMENT TOUTE RESPONSABILITÉ ET TOUTE GARANTIE CONCERNANT LEUR ADÉQUATION À UN USAGE PARTICULIER, LEUR QUALITÉ LOYALE ET MARCHANDE, LA CONTREFAÇON DE TOUT BREVET, LA VIOLATION DE DROITS D'AUTEUR OU D'AUTRES DROITS DE PROPRIÉTÉ INTELLECTUELLE.
Une « Application essentielle à la mission » est une application dans laquelle la défaillance d’un produit Intel pourrait entraîner, directement ou indirectement, un préjudice corporel ou la mort. SI VOUS ACHETEZ OU UTILISEZ DES PRODUITS D’INTEL POUR UNE TELLE APPLICATION ESSENTIELLE À LA MISSION, VOUS SEREZ TENU D’INDEMNISER ET D'EXONÉRER INTEL ET SES FILIALES, SOUS-TRAITANTS ET SOCIÉTÉS AFFILIÉES, AINSI QUE LEURS DIRECTEURS, RESPONSABLES ET EMPLOYÉS, DE TOUTE RESPONSABILITÉ CONCERNANT LES COÛTS LIÉS AUX PLAINTES, DOMMAGES ET DÉPENSES ET LES HONORAIRES D’AVOCAT RAISONNABLES ISSUS, DIRECTEMENT OU INDIRECTEMENT, DE PLAINTES LIÉES À LA FIABILITÉ DU PRODUIT, UN PRÉJUDICE CORPOREL, OU LA MORT ISSUES DE QUELQUE MANIÈRE QUE CE SOIT DE L’UTILISATION D’UNE TELLE APPLICATION ESSENTIELLE À LA MISSION, QU’INTEL OU SES SOUS-TRAITANTS AIENT ÉTÉ OU NON NÉGLIGENTS DANS LA CONCEPTION, LA FABRICATION OU LES AVERTISSEMENTS CONCERNANT LE PRODUIT INTEL OU UN DE SES COMPOSANTS QUELCONQUE.
Intel se réserve le droit de modifier à tout moment sans préavis les spécifications et les descriptions de ses produits. Les concepteurs ne doivent pas se fier à l'absence ou aux caractéristiques de fonctionnalités ou d'instructions marquées comme « réservées » ou « non définies ». Intel se réserve la possibilité de compléter ses définitions à l'avenir et ne saurait être tenue responsable de quelque manière que ce soit pour les conflits et les incompatibilités découlant des modifications qui y seront apportées alors. Les informations fournies ici étant sujettes à des modification sans préavis, ne finalisez aucune création avec ces informations.
Les produits décrits dans le présent document peuvent comporter des défauts ou erreurs de conception, connus sous le nom d’errata, susceptibles de faire s’écarter le produit des spécifications publiées. La liste des errata déjà identifiés peut être fournie sur demande.
Interrogez votre point de vente local ou votre distributeur Intel pour obtenir les plus récentes spécifications avant de passer commande d'un produit.
Des copies des documents comportant un numéro d'ordre et référencés dans le présent document ou dans d'autres documents Intel peuvent être obtenues en appelant le 1-800-548-4725 ou depuis le site Web d'Intel : http://www.intel.com/design/literature.htm * Les autres noms et désignations peuvent être revendiqués comme marques par des tiers.
Copyright © 2012 Intel Corporation. Tous droits réservés.