Tutos Android

Introduction au NDK sous Android

Benbourahla Nazim — Tue, 12 Mar 2013 14:43:27 +0000

Qu’est ce que le NDK

Le NDK (Native Developpement Kit – Kit de développement natif) est un outil permettant d’implémenter des parties natives (en C ou C++) pour vos application. Cela vous permet par exemple, de créer du code commun (bibliothèque) entre plusieurs applications ou entre des applications Android & IOS par exemple.

Pré-requis

Pour commencer, téléchargez le NDK correspondant à votre OS (le tutoriel ce déroule sous MacOSX) sur le site suivant : http://developer.android.com/tools/sdk/ndk/index.html
Décompressez le contenu de votre NDK à l’emplacement de
Si vous êtes sous Windows, il faut absolument installer une solution tel que Cygwin, pour faciliter l’utilisation du NDK et la compilation
L’utilisation du SDK nécessite aussi l’installation de “make” afin de compiler les sources natives

Création d’un projet

Pour commencer, créez un projet Android (“HelloNDK” dans l’exemple) en suivant les étapes çi-dessous :

Maintenant, créez un dossier “jni” (Java Native Interface) à la racine de votre projet. Ce dossier contiendra tout d’abord deux fichiers :

Un fichier Android.mk : Ce fichier servira à décrire la structure de votre projet utilisé par le NDK pour la compilation de vos fichiers natifs
Un fichier de code natif (ici hello.c) : Contiendra votre code natif

Android Makefile

L’un des fichiers important de votre projet est votre Android Makefile ‘Android.mk‘. Comme expliqué précipitamment, ce fichier sert défini les éléments nécessaires à la compilation de vos fichiers natifs. Il peux contenir les éléments suivants :

Le nom de votre module : Option LOCAL_MODULE
Les fichiers sources de votre application : Option LOCAL_SRC_FILSE
Les bibliothéques utilisées par votre code natif : Option LOCAL_SHARED_LIBRARIES
Des variables utiles pour votre compilation, ces variables doivent être vider à chaque compilation, donc utilisez include $(CLEAR-VARS)
Des tags : Options LOCAL_MODULE_TAGS
Le type de build souhaité : BUILD_PACKAGE, BUILD_EXECUTABLE, BUILD_SHARED_LIBRARY …

Voici l’exemple correspondant à notre projet

LOCAL_PATH := $(call my-dir)
#Vider les variables utilisées
include $(CLEAR_VARS)
#Nom du module (donc de la bibliothéque générée)
LOCAL_MODULE := hellondk
#Fichiers sources utilisées
LOCAL_SRC_FILES := hello.c
#Type de fichier en sortie (ici bibliothéque partagée)
include $(BUILD_SHARED_LIBRARY)

hello.c

Ce fichier contient votre code natif, dans notre cas, ce code servira uniquement à afficher le message “Hello NDK ”

#include 
#include 

jstring Java_com_tuto_hellondk_MainActivity_invokeNativeFunction(JNIEnv* env, jobject thiz)
{
	return (*env)->NewStringUTF(env, "Hello NDK  ");
}

Le nom de votre méthode doit être se composer des parties suivantes :

Commence par Java
puis votre nom de package ou vous remplacez les points par des _
puis le nom de l’activité cible (ici MainActivity)
puis le nom de votre fonction (ici invokeNativeFunction)

Compilation

Maintenant, nous allons compiler notre projet NDK pour créer une bibliothèque (.so = bibliothèque dynamique) afin de l’intégrer dans notre classe Java.

Pour compiler, il suffit de vous déplacer dans le dossier de votre projet et exécutez la commande “ndk-build”

La bibliothéque .so est généré dans le dossier libs/armeabi de votre projet

Intégration JAVA

Maintenant, nous allons intégrer la bibliothèque généré dans l’activité de notre projet (MainActivity) à l’aide de la méthode loadLibreary. Il faut spécifier le nom de la bibliothèque à charger.

static {
	System.loadLibrary("hellondk");
}

Puis la déclaration de la méthode invoteNativeFunction() disponible dans la bibliothèque chargé précédemment

private native String invokeNativeFunction();

Puis utilisez la méthode pour récupérer la chaîne de caractère renvoyer par la méthode native

String hello = invokeNativeFunction();

Ce qui donnera pour votre activité

package com.tuto.hellondk;

import android.os.Bundle;
import android.app.Activity;
import android.widget.TextView;

public class MainActivity extends Activity {
	
	static {
		System.loadLibrary("hellondk");
	}
	
	private native String invokeNativeFunction();
	
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        
        TextView helloTextView = (TextView) findViewById(R.id.hello);
        String hello = invokeNativeFunction();
        helloTextView.setText(hello);
    }
    
}

Résultat

Maintenant, exécutez votre application sur un appareil ou un émulateur. Ce qui donnera :

Vous pouvez télécharger, le projet d’exemple, à l’adresse suivante

Si vous voulez, aller plus loin, dans l’utilisation du NDK (en attendant d’autres tuto ), voici le lien vers une conférence du PAUG sur le NDK (slide & vidéo) : http://www.paug.fr/conference-paug/compte-rendu-conference-paug/slides-et-video-conference-android-ndk-1er-mars-2013-par-sylvain-ratabouil/

à bientôt

Introduction à Google Map V2

Benbourahla Nazim — Fri, 01 Mar 2013 13:12:58 +0000

Bonjour/Bonsoir à tous, après une petite absence (je m’excuse au passage pour cette absence). C’est avec grand plaisir que je publie ce nouveau tutoriel sur la nouvelle version de Google Map, la maniéré de l’intégrer et l’utiliser dans une application Android.

Pré-requis

Il faut tout d’abord installer et configurer “Google Play Services” disponible dans le SDK Manager.
Puis, vous devez récupérer une clé API à l’adresse suivante “Google APIs Console“
Créez un projet à l’aide du bouton Create, puis dans la partie “Services” (menu de gauche), activez le service Google Map Android API V2.
Cliquez sur le bouton “API Access” situé sur la barre de navigation (à gauche de l’écran)
Récupérez la clé SHA-1 correspondante à la clé “keystore” utilisée
Pour trouver l’emplacement du keystore utilisé, regardez les préférences d’Eclipse :
Récupérez votre clé SHA-1 à l’aide de la commande suivante :
keytool.exe -v -list -alias androiddebugkey -keystore ~/.android/debug.keystore -storepass android -keypass android
Créez un projet Android et notez votre nom de package, ici : com.tutos.android.gmapv2
Cliquez sur bouton “Create New Android Key” et copiez collez votre empreinte SHA-1 ainsi que votre nom de package :
Puis cliquez sur le bouton “Create” et vous obtiendrez ainsi votre API Key (Gardez là de côté)

Mise à jour du projet

Dans l’AndroidManifest de votre projet, rajoutez les lignes suivantes (dans la balise application)

Ainsi que les lignes suivantes afin de déclarer une permission nécessaire à l’utilisation de GMap (remplacer com.tutos.android.gmapv2 par votre nom de package)

Ainsi que les permissions suivantes :

Afin de pouvoir utiliser GMap V2 sur un appareil, celui ci nécessite la présence d’OpenGL ES Version 2. Les lignes suivantes permettent de rendre l’application indisponible aux appareils qui ne possède pas cette version d’OpenGL

Voici à quoi ressemblera votre fichier AndroidManifest

Intégration de la carte

Modifiez votre fichier main.xml afin d’intégrer une carte possédant les attributs suivants :

Un Fragment représentant la carte

Un identifiant pour pouvoir intéragir avec la carte

Ainsi que votre activité afin de spécifier la vue à charger

package com.tutos.android.gmapv2; import android.os.Bundle; import android.app.Activity; import android.view.Menu; public class MapActivity extends Activity { @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_map); } @Override public boolean onCreateOptionsMenu(Menu menu) { // Inflate the menu; this adds items to the action bar if it is present. getMenuInflater().inflate(R.menu.map, menu); return true; } }

N’oubliez pas de rajouter la bibliothèque google play service à votre projet (télécharger précédemment). Elle est disponible dans votre dossier sdk.
Il suffit d’importer le projet suivant dans eclipse : D:\Users\xxxxx\android-sdks\extras\google\google_play_services\libproject\google-play-services_lib puis le rajouter à votre projet GMap

Résultat

Maintenant vous pouvez exécuter le projet sur votre appareil. Ce qui donnera le résultat suivant :

Vous pouvez télécharger ici le code d’exemple de ce tuto.

N’hésitez pas à poser vos questions

Les notifications sous Android Jelly Bean

Benbourahla Nazim — Thu, 15 Nov 2012 09:28:09 +0000

Le but de ce tutoriel est d’apprendre à utiliser les notifications sous Android, ce système facilite les interactions entre votre application et l’utilisateur lors de la survenue d’évènements particuliers.

Le système de notifications fourni une indication permettant de prévenir l’utilisateur de certains évènements (arriver d’un SMS, mail, appel en absence …).

Mise en place

Nous allons créer un projet qui comprendra deux boutons :

Un pour créer une notification

Un autre pour en supprimer

Commençons par créer un projet avec les données suivantes :

Nom du projet : tuto_notification

SDK : 4.1

Nom de l’application : Tuto Notification

Nom du package : com.tutos.android.notification

Activité : TutoNotificationHomeActivity

Création de la vue principale

Nous allons modifier le fichier “main.xml” afin d’avoir deux boutons.

Le fichier “strings.xml” pour rajouter les différentes strings pour le texte des boutons

Ajouter une notification Supprimer une notification Tuto Notification

Voici le résultat que vous allez obtenir.

Rajouter le Listener sur les boutons

Nous allons rajouter des “Listener” sur les boutons pour gérer le clic. Ce qui donnera sur la classe “TutoNotificationHomeActivity”

package com.tutos.android.notification; import android.app.Activity; import android.os.Bundle; import android.view.View; import android.view.View.OnClickListener; import android.widget.Button; import android.widget.Toast; public class TutoNotificationHomeActivity extends Activity { private Button addNotificationBtn; private Button deleteNotificationBtn; @Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.main); addNotificationBtn = (Button) findViewById(R.id.add_notification); addNotificationBtn.setOnClickListener(new OnClickListener() { @Override public void onClick(View arg0) { Toast.makeText(getBaseContext(), "Ajout d'une notification", Toast.LENGTH_SHORT).show(); } }); deleteNotificationBtn = (Button) findViewById(R.id.delete_notification); deleteNotificationBtn.setOnClickListener(new OnClickListener() { @Override public void onClick(View arg0) { Toast.makeText(getBaseContext(), "Suppression d'une notification", Toast.LENGTH_SHORT).show(); } }); } }

Création d’une notification.

Nous allons créer une méthode “createNotification” qu’on appelera au clic sur le bouton “Ajouter une notification”. Voici a quoi ressemble cette méthode :

private final void createNotification(){ final NotificationManager mNotification = (NotificationManager) getSystemService(NOTIFICATION_SERVICE); final Intent launchNotifiactionIntent = new Intent(this, TutoNotificationHomeActivity.class); final PendingIntent pendingIntent = PendingIntent.getActivity(this, REQUEST_CODE, launchNotifiactionIntent, PendingIntent.FLAG_ONE_SHOT); Notification.Builder builder = new Notification.Builder(this) .setWhen(System.currentTimeMillis()) .setTicker(notificationTitle) .setSmallIcon(R.drawable.notification) .setContentTitle(getResources().getString(R.string.notification_title)) .setContentText(getResources().getString(R.string.notification_desc)) .setContentIntent(pendingIntent); mNotification.notify(NOTIFICATION_ID, builder.build()); }

La création d’une notification est trés simple et s’effectue en suivant les étapes décritent ci-dessous :

Récupération d’une instance de la classe NotificationManager

Créer l’intent correspondant à la vue lancée lors du clic sur la notification

Créer un pending intent décrivant l’intent précédant

Créer une notification à l’aide d’un Builder, en spécifiant le contexte, le délais de déclenchement de la notification, le titre de la notification, l’icone, le titre et la description du contenu de la notification, l’intent à lier à la notification.

Le déclenchement de la notification s’effectue à l’aide de la méthode notify

Je vous met l’icone que j’ai utilisé pour la notification ici.
Il suffit maintenant d’appeler la méthode dans votre code, ce qui donnera :

addNotificationBtn = (Button) findViewById(R.id.add_notification); addNotificationBtn.setOnClickListener(new OnClickListener() { @Override public void onClick(View arg0) { createNotification(); } });

Il faut rajouter la permission “Vibration” dans l’AndroidManifest.xml

et les nouveaux textes dans le fichier “Strings.xml”

Notification www.tutos-android.com Ma premiere notification www.tutos-android.com Cliquez sur moi je suis une notification

Jelly Bean

La version JellyBean d’Android apporte quelques nouveautés aux notifications :

Priorité : Ce système permet d’indiquer la priorité d’une notification, plus la notification est prioritaire plus elle sera mise en avant dans la barre de notification. Elle peut posséder l’une des valeurs suivantes (PRIORITY_MAX, PRIORITY_HIGH, PRIORITY_DEFAULT, PRIORITY_LOW, PRIORITY_MIN)

Nouvelles zones de contenues : Des nouvelles zones de contenus sont disponibles (bigPicture, bigText…) permettant d’enrichir vos notifications

Actions : Vous pouvez rajouter des actions aux notification à l’aide de la méthode addAction. Ces actions permettent d’offrir à l’utilisateur un autre moyen d’interagir avec les notifications. Ce qui permet par exemple, lors de la réception d’un appel en absence, de rappeler directement la personne ou lui envoyer un sms.

Notification.Builder builder = new Notification.Builder(this) .setWhen(System.currentTimeMillis()) .setTicker(notificationTitle) .setSmallIcon(R.drawable.notification) .setContentTitle(getResources().getString(R.string.notification_title)) .setContentText(getResources().getString(R.string.notification_desc)) .setContentIntent(pendingIntent) .addAction(R.drawable.play,"Play", PendingIntent.getActivity(getApplicationContext(), 0, getIntent(), 0, null)) .addAction(R.drawable.pause, "Pause", PendingIntent.getActivity(getApplicationContext(), 0, getIntent(), 0, null)); Notification notification = new Notification.BigPictureStyle(builder) .bigPicture(BitmapFactory.decodeResource(getResources(), R.drawable.zoidberg_android)).build(); mNotification.notify(NOTIFICATION_ID, notification);

Suppression d’une notification

Nous allons créer une méthode “deleteNotification”, pour supprimer notre notification depuis l’application.

private void deleteNotification(){ final NotificationManager notificationManager = (NotificationManager)getSystemService(Context.NOTIFICATION_SERVICE); //la suppression de la notification se fait grâce a son ID notificationManager.cancel(NOTIFICATION_ID); }

Puis l’appeler dans le code Java au moment du clic

deleteNotificationBtn = (Button) findViewById(R.id.delete_notification); deleteNotificationBtn.setOnClickListener(new OnClickListener() { @Override public void onClick(View arg0) { deleteNotification(); } });

Le projet sera très bientôt disponible en téléchargement.

Multi-touch et fragments: Geste de “rotation”

Arnaud Bossmann — Sun, 09 Sep 2012 10:58:37 +0000

Bonjour à tous! Ce nouveau tutoriel orienté algorithmique va tenter d’expliquer la manière de gérer le geste de rotation multitouch. Peu de code Java dans ce tutoriel, juste de quoi illustrer mes propos et donner des pistes de réflexion. La fonction principale sera détaillée mais exceptionnellement, je ne mettrai pas de projet en téléchargement par manque de temps pour l’implémenter proprement.

Pour les gestes simple-touch, l’implémentation est très facile grâce au Gesture Builder (tutoriel en anglais ici), mais pour le multi-touch, c’est un peu plus compliqué car aucune library n’existe. Si on veut pouvoir utiliser des gestes cools dans son application, il faut donc les implémenter.

Principe global

On souhaite reconnaître un mouvement de rotation effectué avec 2 doigts pour par exemple inverser 2 fragments positionnés l’un en dessous de l’autre comme indiqué sur l’image ci dessous.

Concrètement, nous allons enregistrer les coordonnées de départ et d’arrivée de nos deux doigts puis calculer l’angle formé par ceux-ci, comme indiqué dans le schéma ci-dessous. Dans notre cas, si l’angle mesuré est supérieur à 8° (par exemple), la rotation s’effectue.

Algorithme

On détecte lorsque plusieurs doigts sont posés sur l’écran puis on sauvegarde les coordonnées des points touchés. Lorsque les doigts sont enlevées, on enregistre également leurs coordonnées.

On calcule ensuite le point d’intersection I de la droite formée par les deux doigts au départ celle formée à l’arrivée. Appelons A le point de départ du doigt 1 et B son point d’arrivée. L’étape suivante consite à calculer les distances des côtés du triangle ABI. Comme on possède les coordonnées de ces points, il ne reste qu’à utiliser la formule:

AB= (xA – xB)² + (yB – y1)² , où A (xA, yA) et B (xB, yB)

Enfin, pour calculer l’angle en radian, on utilise le théorème d’Al Kashi (ou théorème de Pythagore généralisé) dont la formule est la suivante:

Implémentation Java: quelques pistes

Premièrement, il faut placer un listener sur votre layout principal, celui qui fait la taille de la page et qui contient tout les éléments. C’est lui qui captera l’évènement.

mainLayout.setOnTouchListener(new View.OnTouchListener() { @Override public boolean onTouch(View view, MotionEvent motionEvent) { int pointerIndex = ((motionEvent.getAction() & MotionEvent.ACTION_POINTER_ID_MASK) >> MotionEvent.ACTION_POINTER_ID_SHIFT); int action = (motionEvent.getAction() & MotionEvent.ACTION_MASK); int pointCnt = motionEvent.getPointerCount(); try { // On effectue un traitement seulement lorsque 2 doigts touchent l'écran if ((pointCnt == 2)&& (pointerIndex <=1)){ switch (action) { case MotionEvent.ACTION_POINTER_DOWN: // Sauvegarde des coordonnées de départ des 2 doigts for (int i = 0; i < pointCnt; i++) { int id = motionEvent.getPointerId(i); //simple exemple de comment récupérer les coordonnées des points. Celles-ci doivent être traitées en fonction de ce que l'on veut faire float x= motionEvent.getX(i) float y= motionEvent.getY(i)); } break; case MotionEvent.ACTION_POINTER_UP: // Sauvegarde des coordonnées des doigts lorsque l'utilisateur les enlève de l'écran for (int i = 0; i < pointCnt; i++) { int id = motionEvent.getPointerId(i); //simple exemple de comment récupérer les coordonnées des points. Celles-ci doivent être traitées en fonction de ce que l'on veut faire float x= motionEvent.getX(i) float y= motionEvent.getY(i)); } //calculer ici la valeur de l'angle formé, comme expliqué dans le paragraphe précédent break; default: break; } } } catch (Exception e) { Log.e("error", e.getMessage()); } return true; } });

Conclusion

En espérant que ce tutoriel vous soit utile pour la compréhension du multitouch. Vous avez maintenant toutes les cartes en main pour l’implémenter !

ActionBar sous Android (Partie 2)

Benbourahla Nazim — Fri, 20 Jul 2012 10:40:55 +0000

Voici la suite du tutoriel sur l’ActionBar. Dans cette partie, nous allons reprendre le projet crée lors du tutoriel précédant afin d’aborder les points suivants :

La navigation à l’aide de l’icone de votre application (présente sur l’ActionBar)

La séparation de l’ActionBar en deux

Séparer l’ActionBar en deux

Si vous possédez plusieurs actions importantes dans votre application, vous pouvez séparer votre barre d’action en deux :

La première ActionBar contiendra l’icone de votre application, le titre et la navigation de votre application (Dropdown menu)

La deuxième ActionBar contiendra les différentes actions disponibles via votre application

Cette fonctionnalité est disponible qu’à partir de l’API 14 d’Android donc à partir de la version 4.0 d’Android.

Pour séparer votre ActionBar en deux, il suffit de rajouter l’attribut android:uiOptions=”splitActionBarWhenNarrow” sur la balise application (si vous souhaitez séparer votre ActionBar sur toute l’application) ou sur la balise activity (si vous souhaitez séparer votre ActionBar uniquement sur quelques activités cibles) du fichier manifeste de l’application.

Ce qui donnera sur un appareil Android (4.0 ou supérieur)

Navigation via l’icone de votre application

Afin de pouvoir activer la navigation via l’icone de votre application (icone disponible sur l’ActionBar), il suffit de rajouter le code suivant dans la méthode onCreateOptionsMenu (aprés le chargement du fichier XML représentant votre menu/ActionBar).

ActionBar actionBar = getActionBar(); actionBar.setDisplayHomeAsUpEnabled(true);

La première ligne permet de récupérer l’instance de l’ActionBar

La deuxième ligne permet d’activer la navigation à l’aide de l’icone de votre application

La méthode setDisplayHomeAsUpEnabled est disponible qu’a partir d’Android 3.0 (Honeycomb). Afin de conserver la compatibilité avec les anciennes version d’Android, il faut vérifier la version actuelle de l’appareil avant d’éxecuter cette partie du code. Cette vérification s’effectue rapidement à l’aide de la classe Build.VERSION.SDK_INT.

Ce qui donnera :

@Override public boolean onCreateOptionsMenu(Menu menu) { getMenuInflater().inflate(R.menu.activity_main, menu); if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB) { ActionBar actionBar = getActionBar(); actionBar.setDisplayHomeAsUpEnabled(true); } return true; }

Si vous exécutez l’exemple, vous allez remarquer que l’icone devient cliquable (aucune action n’est liée à ce clic pour le moment)

Pour pouvoir exécuter l’action de votre choix lors du clic sur l’icone, il faut gérer l’élement android.R.id.home dans la méthode onOptionsItemSelected. Vous pouvez par exemple revenir à l’activité lancée précédemment (onBackPressed : permet de simuler le clic sur le bouton précedant) ou lancer l’activité de votre choix.

@Override public boolean onOptionsItemSelected(MenuItem item) { switch (item.getItemId()) { case android.R.id.home: onBackPressed(); case R.id.menu_about: // Comportement du bouton "A Propos" return true; case R.id.menu_help: // Comportement du bouton "Aide" return true; case R.id.menu_refresh: // Comportement du bouton "Rafraichir" return true; case R.id.menu_search: // Comportement du bouton "Recherche" return true; case R.id.menu_settings: // Comportement du bouton "Paramétres" return true; default: return super.onOptionsItemSelected(item); } }

Ce qui donnera :
Android 3.0

Android 4.0

Vous pouvez trouver le code de cet exemple ici.

ActionBar sous Android (Partie 1)

Benbourahla Nazim — Sun, 15 Jul 2012 14:05:23 +0000

La version 3.0 d’Android (Honeycomb) à introduit un nouveau composant essentiel dans une application, il s’agit de la barre d’action (ActionBar).
Ce composant remplace les menus disponibles dans les anciennes version d’Android et permet à l’utilisateur d’accéder facilement aux fonctionnalités les plus importantes d’une application.

Voici l’exemple de l’ActionBar dans l’application Google + :

Principe

Une ActionBar peut se composer de 4 parties :

L’icone de l’application : Etablie l’identité visuelle de l’application et permet aussi de naviguer dans l’application (remonter à la vue mère par exemple).

Dropdown Menu : Permet d’afficher le titre de la vue actuelle ainsi que naviguer dans l’application (exemple de l’application Gmail).

Actions principales : Définie les actions principales de votre application.

Autres actions : Permet d’accéder aux fonctionnalités moins importantes de l’application.

L’implémentation d’une ActionBar s’effectue dans le dossier menu (situé dans le dossier res de votre projet) et ressemble énormément à l’implémentation d’un menu.
Afin de gérer la compatibilité avec des versions d’Android ne possédant pas d’ActionBar (entre 1.6 et 2.3.x), il est conseillé de remplacer son implémentation par des menus et cela en créent plusieurs dossiers :

fichier styles.xml dans le dossier values: Permet de spécifier le thème utilisé par l’application et donc un thème n’utilisant pas de barre d’action (conversion automatique en menu).

fichier styles.xml dans le dossier values-v11 : Permet de spécifier le thème utilisé (thème Honeycomb) utilisant les ActionBar fournies par cette version d’Android.

fichier styles.xml dans le dossier values-v14 : Permet de spécifier le thème utilisé (thème ICS / JellyBean) utilisant les ActionBar fournies par cette version d’Android.

Le chiffre se situant aprés la lettre v correspond au numéro de l’API Android cible

Exemple

L’exemple abordé dans cette partie servira à implémenter une ActionBar pour les appareils 3.x et supérieur et un menu pour les autres.

Nous allons créer une application Android possédant les actions suivantes (accessible via ActionBar ou via menu) :

Recherche

Rafraichir

Aide

A propos

Paramètres

Dans le dossier menu présent dans le dossier res, créez un fichier XML représentant votre menu :

Chaque élement du menu correspond à la déclaration d’une balise item

Chaque élement possède un identifiant, une icone (nom conseillé : ic_action_*), un titre

L’attribut showAsAction permet de spécifier le comportement de l’élement dans une ActionBar, il peut posséder les valeurs suivantes :

ifRoom : L’élement sera ajouté aux actions principales de l’ActionBar si une place est disponible

never : Ne jamais rajouter l’action aux actions principales de l’ActionBar

always : Toujours rajouter l’action aux actions principales de l’ActionBar. Cette valeur n’est pas conseillé car peut entrainer une superposition d’élement (si nombre de place disponible < nombre d'élément ajouté à l'ActionBar), préférez la valeur ifRoom.

withText : Toujours afficher le texte représentant l’action

Sans oublier d’implémenter les fichiers styles.xml présent dans les dossiers (values / values-v11 / values-v14)

values/styles.xml