UML


UML (Unified Modeling Language, que l'on peut traduire par "langage de modélisation unifié) est une notation
permettant de modéliser un problème de façon standard. Ce langage est né de la fusion de plusieurs
méthodes existant auparavant, et est devenu désormais la référence en terme de modélisation objet,
à un tel point que sa connaissance est souvent nécessaire pour obtenir un poste de développeur objet.

La notion d'objet

La programmation orientée objet consiste à modéliser informatiquement
un ensemble d'éléments d'une partie du monde réel (que l'on appelle domaine)
en un ensemble d'entités informatiques.
Ces entités informatiques sont appelées objets. Il s'agit de données informatiques
regroupant les principales caractéristiques des éléments du monde réel (taille, la couleur, ...).

La difficulté de cette modélisation consiste à créer une représentation
abstraite, sous forme d'objets, d'entités ayant une existence matérielle (chien, voiture, ampoule, ...)
ou bien virtuelle (sécurité sociale, temps, ...).

Les méthodes objets

La modélisation objet consiste à créer une représentation informatique
des éléments du monde réel auxquels on s'intéresse, sans se préoccuper
de l'implémentation, ce qui signifie indépendamment d'un langage de programmation. Il
s'agit donc de déterminer les objets présents et d'isoler leurs données et les fonctions
qui les utilisent. Pour cela des méthodes ont été mises au point. Entre 1970 et 1990,
de nombreux analystes ont mis au point des approches orientées objets, si bien qu'en 1994 il existait
plus de 50 méthodes objet. Toutefois seules 3 méthodes ont véritablement émergé :
  • La méthode OMT de Rumbaugh
  • La méthode BOOCH'93 de Booch
  • La méthode OOSE de Jacobson (Object Oriented Software Engineering)


A partir de 1994, Rumbaugh et Booch (rejoints en 1995 par Jacobson) ont unis leurs efforts pour mettre
au point la méthode unifiée (unified method 0.8), incorporant les avantages de chacunes des méthodes précédentes.


La méthode unifiée à partir de la version 1.0 devient UML (Unified Modeling Language),
une notation universelle pour la modélisation objet.

Nota
UML n'est pas une méthode dans la mesure où elle ne présente aucune démarche.
A ce titre UML est un formalisme de modélisation objet. Le mot méthode parfois utilisé
par abus de langage dans les pages suivantes ne doit donc pas être entendu comme une "démarche".



UML 1.0 est soumise à l'OMG (Object Management Group) en janvier 1997, mais elle ne sera acceptée
qu'en novembre 1997 dans sa version 1.1, date à partir de laquelle UML devient un
standard international.

Voici le récapitulatif des évolutions de ce langage de modélisation :
  • En 1995: Méthode unifiée 0.8 (intègrant les méthodes Booch'93 et OMT)
  • En 1995: UML 0.9 (intègrant la méthode OOSE)
  • En 1996: UML 1.0 (proposée à l'OMG)
  • En 1997: UML 1.1 (standardisée par l'OMG)
  • En 1998: UML 1.2
  • En 1999: UML 1.3
  • En 2000: UML 1.4
  • En 2003: UML 1.5
  • Les dernières versions des spécifications peuvent être téléchargées

Cette méthode représente un moyen de spécifier, représenter et construire les composantes d'un système informatique.


Avec la méthode UML, un objet est par exemple représenté de la façon suivante :

representation d\


Intérêt d'une méthode objet

Les langages orientés objet constituent chacun une manière spécifique
d'implémenter le paradigme objet. Ainsi, une méthode objet permet de définir
le problème à haut niveau sans rentrer dans les spécificités d'un
langage. Il représente ainsi un outil permettant de définir un problème
de façon graphique, afin par exemple de le présenter à tous les acteurs d'un projet
(n'étant pas forcément des experts en un langage de programmation).

De plus, le fait de programmer à l'aide d'un langage orienté objet ne fait pas
d'un programmeur un concepteur objet. En effet il est tout à fait possible de produire
un code syntaxiquement juste sans pour autant adopter une approche objet. Ainsi la programmation
orientée objet implique
  • en premier lieu une conception abstraite d'un modèle objet (c'est le rôle de la méthode objet)
  • en second plan l'implémentation à l'aide d'un langage orienté objet (tel que C++/Java/...)



Une méthode objet est donc d'une part une méthode d'analyse
du problème (afin de couvrir toutes les facettes du problème), d'autre part un langage permettant
une représentation standard stricte des concepts abstraits (la modélisation) afin
de constituer un langage commun.

La normalisation OMG

Ainsi, il est nécessaire qu'une méthode objet soit définie de manière
rigoureuse et unique afin de lever les ambiguités. De nombreuses méthodes objet
ont été définies, mais aucune n'a sû s'imposer en raison du manque
de standardisation. C'est pourquoi l'ensemble des acteurs du monde informatique a fondé en 1989
l'OMG (Object Management Group),
une organisation à but non lucratif, dont le but est de mettre au point des standards garantissant
la compatibilité entre des applications programmées à l'aide de langages objet
et fonctionnant sur des réseaux hétérogènes (de différents types).

A partir de 1997, UML est devenue une norme de l'OMG, ce qui lui a permis de s'imposer en tant
que méthode de développement objet et être reconnue et utilisée par de nombreuses
entreprises.
11/08/2013 06:44:00 AM

La programmation sous Android

 

Android, c’est quoi ?

Android est un OS mobile Open Source pour smartphone, PDA, MP3 et tablette. Conçu initialement par Android Inc. Android a été racheté par Google en 2005.
Pour commencer la programmation Android, il faut d’abords installer le SDK Android et comprendre les bases de la programmation sous Android. Puis nous allons faire notre premier programme sous Android c’est-à-dire le bien connu “Hello Word” pour bien comprendre ces bases.

Composantes d’une application Android

Une application Android est composée d’éléments de base :

Activities (Activités en Français)

Une activité est la composante principale pour une application Android. Elle représente l’implémentation et les interactions de vos interfaces.
Prenant l’exemple d’une application qui liste toutes les images présentes dans votre téléphone, le projet pourrait se décomposer comme çi-dessous :
  • Une vue pour afficher la liste des images.
  • Une activité pour gérer le remplissage et l’affichage de la liste.
  • Si l’on veut pouvoir rajouter, supprimer des images, on pourrait rajouter d’autres activités.

Services

Un service, à la différence d’une activité, ne possède pas de vue mais permet l’exécution d’un algorithme sur un temps indéfini. Il ne s’arrêtera que lorsque la tâche est finie ou que son exécution est arrêtée.
Il peut être lancé à différents moments :
  • Au démarrage du téléphone.
  • Au moment d’un événement (arrivée d’un appel, SMS, mail, etc…).
  • Lancement de votre application.
  • Action particulière dans votre application.

Broadcast and Intent Receivers

Un Broadcast Receiver comme son nom l’indique permet d’écouter ce qui se passe sur le système ou sur votre application et déclencher une action que vous aurez prédéfinie. C’est souvent par ce mécanisme que les services sont lancés.

Content providers

Les “content providers”servent à accéder à des données depuis votre application. Vous pouvez accéder :
  • Aux contacts stockés dans le téléphone.
  • A l’agenda.
  • Aux photos.
  • Ainsi que d’autres données depuis votre application grâce aux content providers.

Cycle de vie d’une application Android

 

onCreate

Cette méthode est appelée à la création de votre activité  (Activity). Elle sert à initialiser votre activité ainsi que toutes les données nécessaires à cette dernière.
Quand la méthode OnCreate est appelée, on lui passe un Bundle en argument. Ce Bundle contient l’état de sauvegarde enregistré lors de la dernière exécution de votre activité.

onStart

Cette méthode est pour signifié le début d’éxecution de votre activité (début du passage au premier plan).
Si votre activité ne peut pas aller en avant plan quelque soit la raison, l’activité sera transférée à OnStop.

onResume

Cette méthode est appelée après OnStart (au moment où votre application repasse en foreground). à la fin de l’appel à la méthode onResume votre application se trouve au premier plan et reçoit les interactions utilisateurs.

onPause

Si une autre activité passe au premier plan, la méthode onPause est appelée sur votre activité. Afin que vous sauvegardiez l’état de l’activité et les différents traitements effectués par l’utilisateur.
A ce stade, votre activité n’a plus accès à l’écran, vous devez arrêter de faire toute action en rapport avec l’interaction utilisateur (désabonner les listeners). Vous pouvez par contre continuer à exécuter des algorithmes nécessaires mais qui ne consomment pas trop de CPU.

onStop

Appelée quand votre activité n’est plus du tout visible quelque soit la raison. Dans cette méthode vous devez arrêter tous les traitements et services exécutés par votre application.

onDestroy

Appelée quand votre application est totalement fermée (Processus terminé). Toutes les données non sauvegardées sont perdues

Installer votre environnement de développement.

Installation du SDK Android

  1. Pour commencer allez sur le lien suivant : http://developer.android.com/sdk/index.html et téléchargez la version du SDK qui convient à votre OS. (Pour la suite on est sur un Mac).
  2. Une fois le SDK téléchargé, allez dans le dossier où se trouve le fichier zip et l’extraire dans le dossier de votre choix.
  3. Installer Eclipse : http://www.eclipse.org/downloads/ (Téléchargez une version comprenant Java, Soit la version pour les développeurs Java ou la version pour les développeurs J2EE) : Version installée pour ce tutoriel : 3.6.1 Helios.
  4. Il faut aussi installer JDK (Java Development Kit) et JRE (Java Runtime Environement) si c’est pas déjà fait : http://java.sun.com/javase/downloads/index.jsp.
  5. Maintenant, il faut installer le plugin ADT (Android Developpment Tools) permettant d’intégrer l’environnement de développement Android dans Eclipse
  6. Lancez votre Eclipse, Allez dans le menu “Help and Install New Software”
  7. Dans la partie “Available Software”, cliquez sur “Add”.
  8. Rajoutez le nom du site (“ADT plugin” par exemple). Dans la location rajoutez : https://dl-ssl.google.com/android/eclipse/, puis cliquez sur OK.
  9. Revenez dans “Available Software”, vous devez voir “Developer Tools”. Sélectionnez-le et appuyez sur “Next”.
  10. Cliquez sur “Next” pour lire et accepter la licence et puis cliquez sur “Finish”.
  11. Pour finir l’installation relancez Eclipse.
Voilà votre environnement de développement est prêt à être utilisé.

Configuration de votre environnement de développement

Vous avez dû remarquer que six petites icones sont apparues dans le menu du haut d’eclipse dans le menu du haut :
  • Permet de lancer le SDK Manager afin de mettre à jour les différents SDK et outils installés ou installer de nouvelles versions
  • Permet de lancer un outil servant à gérer les différents émulateurs d’un appareil
  • Permet d’utiliser l’outil Android Lint (qui sera présenté dans le chapitre …).
  • Permet de créer un nouveau projet Android
  • Permet de créer un nouveau projet de test Android
  • Permet de créer un fichier XML Android
Cliquez sur la premiére icône (SDK Manager), une nouvelle fenêtre va apparaître
Cet écran vous permettra de :
  • Installer de nouvelle version du SDK ou d’outils.
  • Mettre à jour des versions ou des outils.
Pour commencer, installer le contenu d’Android 4.0.3 et 4.1.
La deuxième icone, vous permet de créer et gérer des émulateurs :
Pour créer un nouvel émulateur, cliquez sur le bouton “New”
  • Name : Le nom de votre émulateur (sans espace).
  • Target : Version du SDK Android de l’émulateur.
  • SD Card (Facultatif) : Configuration de la SD Card (Taille…etc).
  • Skins : Choisissez la taille, résolution de votre émulateur. Des émulateurs pré-configurer se trouve dans la partie Built-in.
  • Hardware : Cette partie permet de rajouter le matériel spécifique à votre émulateur. Par exemple vous pouvez rajouter un GPS, configurer le clavier, l’accéléromètre, etc…
L’émulateur apparaîtra maintenant dans la liste des émulateurs disponibles.
Maintenant on va passer à la partie la plus intéressante.

Ma première application sous Android

Création du projet “Hello World”

Dans éclipse, cliquez sur l’icone permettant de créer un nouveau projet (présenté dans la partie précédente).
La création de projet s’effectue en suivant 3 écrans :
  • Le premier permet de spécifier de nom de l’application (Application Name), le nom du projet (Project Name – affiché uniquement dans Eclipse), le nom du paquet (Package Name – Utilisé comme identifiant de l’application sur Google Play).
  • Ainsi que la version du SDK utilisé pour développer l’application et la version minimum permettant de faire fonctionner correctement l’application.
  • Vous pouvez aussi créer l’icone de votre application dans l’écran suivant et cela en laissant la case “Create Custom Icon Launcher” cochée

Puis cliquez sur “Next”, le prochain écran permet de créer l’icone de l’application

Puis cliquez sur “Next”, afin d’arriver sur l’écran vous permettant de choisir un template de départ pour votre application. Choisissez l’option “Blank activity afin de créer une nouvelle activité vide”, puis cliquez sur “Next”.
Le dernier écran permet de configurer les spécificités de l’activité qui sera créé :
  • Nom de l’activité
  • Nom de la vue representant l’activité
  • Type de navigation choisi dans l’application (Tabulation, Tabulation + Scroll, Scroll avec un titre sur chaque page – Exemple de Google Play, Dropdown sur la barre d’action – Exemple de l’application Gmail)
  • La classe mère de l’activité à creer (Activity par défaut)
  • Titre de l’activité

Puis cliquez sur Finish pour terminer. Le projet “Hello World” va maintenant apparaître dans l’arborescence d’eclipse.

Explication de l’arborescence du projet

Voici le résultat de la création de votre projet et l’arborescence de ce dernier
  • src : Ce dossier contient les sources de votre application (code JAVA) et les packages.
    • com.tuto.android.helloworld : un package de votre application. Bien sûr vous pouvez avoir plusieurs packages dans votre application.
    • HelloWorldActivity.java : Notre principale activité.
  • gen : Dossier qui contiendra les fichiers R.java (ce fichier est généré automatiquement à partir de vos ressource) et BuildConfig.java (permettant de gérer l’affichage des logs uniquement pendant les phases de développement et tests et non dans la version finale. Ce qui réduit les interactions entre votre application et l’appareil).
    • R.java : Ce fichier est automatiquement généré par le SDK Android à chaque pré-compilation.
    • BuildConfig.java: Sera automatiquement mis à jour lors de la création de la version finale de l’Apk afin de desactive les logs.
  • assets : Contient des données non internationalisées qui seront utilisées dans votre application (images, vidéos, licence…etc).
  • res : C’est le dossier qui contiendra les ressources de votre application (images, vidéos, styles).
    • drawable-xxx : Contient vos images dans les différentes résolutions (basse, moyenne, haute et trés haute).
    • ic_launcher.png : L’icône de votre application.
    • layout-xxx : Le SDK Android offre une technique de création d’interfaces graphiques à l’aide de fichiers XML. C’est dans ce dossier que vous inclurez l’ensemble des fichiers décrivant vos interfaces. Vous pouvez créer d’autres dossiers pour les menus par exemple. Vous pouvez créer différents dossier en fonction de l’orientation, la taille de l’écran et la version d’Android …etc
    • activity_hello_world.xml : Le fichier principal de votre interface.
    • values : Ce dossier contient un ensemble de fichiers décrivant les valeurs (pseudo variables) utilisées par votre application. On peut, par exemple, y mettre des chaines de caractères (strings.xml), des tableaux (arrays.xml), des entiers, des couleurs, … Vous pouvez créer différents dossier en fonction de l’orientation, la taille de l’écran (values-large) et la version d’Android (values-v11 et values-v14) …etc
    • strings.xml : Fichier qui contient vos déclarations de chaines de caractères.
    • dimens.xml : Contient toutes les dimensions utilisées dans votre application. Ces dimensions seront surchargés pour les écrans larges (values-large) afin de prendre en compte l’espace disponible
    • styles.xml : Représente le thème par défaut utilisé par votre application. Le thème sera surchargé pour les appareils tournant sous Android 3.0 (values-v11) et 4.0 (values-v14) afin de prendre en compte le nouveau théme Holo
  • AndroidManifest.xml : Définit le comportement de votre application au système Android. Ce fichier définit par exemple (Le nom, l’icône, la version min du SDK, les activités, les services, etc…).

“Hello, World!”

Le projet exemple créé ar eclipse représente un “Hello World!”. Vous pouvez le lancer en tant qu’une application Android (Pour cela, il vous suffit de cliquer droit sur le projet, puis sélectionner l’option « Run As -> Android Application ») et la l’émulateur devrait se lancer.. L’émulateur prendra un peu de temps à se lancer la première fois (ne le fermez pas entre vos différentes modifications).
Le lancement du projet donnera les résultats suivants :
Sur un appareil android 2.3 :

Sur un appareil Android 4.0.3 :

Vous pouvez remarquer que le style de l’application est différents entre les deux appareils (absence de la barre d’action) cela est dû à la surcharge du thème pour les versions 11 et 14.
Notre Hello Word est bien fonctionnel mais reste encore à le comprendre. Allons voir le code pour comprendre ce qui se passe.
  • AndroidManifest.xml
<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="com.tutos.android.helloworld"
    android:versionCode="1"
    android:versionName="1.0" >

    <uses-sdk
        android:minSdkVersion="8"
        android:targetSdkVersion="15" />

    <application
        android:icon="@drawable/ic_launcher"
        android:label="@string/app_name"
        android:theme="@style/AppTheme" >
        <activity
            android:name=".HelloWordActivity"
            android:label="@string/title_activity_hello_word" >
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />
                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
    </application>
</manifest>
  • La balise “manifest” à la ligne deux contient plusieurs arguments, le plus important est ”package”, qui donne le nom du package dans lequel se trouve votre activité principale. Les deux autres attributs représente la version du code de l’application (versionCode – non visible à l’utilisateur) ainsi que la version de l’application (versionName – visible sur Google Play)
  • La balise “application” sert à la déclaration de différentes propriétés de votre application :
    • android:icon : L’emplacement où se trouve l’icône de votre application.
    • android:label : Le nom de votre application (il se trouve dans strings.xml).
    • android:theme=”@style/AppTheme” : Spécifier le thème utilisé par votre application. Ce thème pointe vers le style AppTheme declaré dans le fichier styles.xml
  • La balise “activity” permet de déclarer une activité, à chaque nouvelle activité il faut remettre cette balise.
    • android:name : le nom de la classe java qui représente l’activité. Le nom doit commencer par un . et on ne met pas le .java à la fin.
    • android:label : le label de l’activité en question
    • intent-filter : c’est pour spécifier une action.
  • strings.xml
  • <resources>
    
        <string name="app_name">Hello World</string>
        <string name="hello_world">Hello world!</string>
        <string name="menu_settings">Settings</string>
        <string name="title_activity_hello_word">HelloWord</string>
    
    </resources>
    
  • dimens.xml
  • <resources>
    
        <dimen name="padding_small">8dp</dimen>
        <dimen name="padding_medium">8dp</dimen>
        <dimen name="padding_large">16dp</dimen>
    
    </resources>
    
    • Représente la taille des différentes marges internes utilisées dans l’application
    • Ces marges sont surchargées pour les grands écrans dans le dossier values-large.
    • <resources>
      
          <dimen name="padding_small">8dp</dimen>
          <dimen name="padding_medium">16dp</dimen>
          <dimen name="padding_large">16dp</dimen>
      
      </resources>
      

  • styles.xml

  • <resources>
    
        <style name="AppTheme" parent="android:Theme.Light" />
    
    </resources>
    
    • Représente le thème appliqué par l’application
    • Par défaut, le thème appliqué correspond au thème clair Android par défaut
    • Le thème utilisé est surchargé pour les versions 3.0 et 4.0 d’android afin d’utiliser les différents thème Holo introduit dans ces versions (vous pouvez remarquer la présence d’une barre d’action dans ce thème ce qui explique sa présence lors de l’exécution sur un appareil tournant sous Android 4)
    • <resources>
      
          <style name="AppTheme" parent="android:Theme.Holo.Light.DarkActionBar" />
      
      </resources>
      


  • activity_hello_world.xml
    <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" >
    
        <TextView
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:layout_centerHorizontal="true"
            android:layout_centerVertical="true"
            android:padding="@dimen/padding_medium"
            android:text="@string/hello_world"
         />
    
    </RelativeLayout>
    
    
    • On dispose de deux modes de visualisation.
      • Onglet Graphical Layout : Mode visualisation et édition d’interface.
      • Onglet activity_hello_world.xml : mode code source
    • On commence par une balise qui définit le layout : ici RelativeLayout.
    • Voici un lien pour la liste des différents layout : http://developer.android.com/reference/android/view/ViewGroup.html. Un tutoriel sur le RelativeLayout est disponible à cette adresse : http://www.tutos-android.com/comprendre-relativelayout-android
    • On déclare une composante TextView pour afficher du texte et on lui indique la chaine de caractère à afficher : @string/hello_world, donc de la variable hello_world qui est déclarée dans strings.xml.
    • Le texte est centré verticalement et horizontalement
    • On utilise les marges internes déclarées dans le fichier dimens.xml
    • Chaque élement doit posséder une autre et une largueur correspond à la taille de son contenu (wrap_content).


  • HelloWorldActivity.java
package com.mti.android;

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

public class HelloWordActivity extends Activity {
    /** Called when the activity is first created. */
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_hello_word);
    }
}
  • Notre activité principale doit hériter de la classe Activity ou d’une sous classe de cette dernière.
  • http://developer.android.com/reference/android/app/Activity.html.
  • La méthode “OnCreate” est équivalente est appelée à la création de votre vue.
  • On appelle simplement le OnCreate de la classe mère puis on initialise la vue en utilisant la méthode setContentView. Cette méthode prends en argument l’interface à charger (ici R.layout.activity_hello_word).
  • A chaque fois que vous voyez “R” , c’est à dire que l’on utilise du code qui a été généré par les différents fichiers xml de ressource.
  • “R.layout” : On va chercher la vue déclarée dans le dossier layout et qui s’appelle activity_hello_worddonc notre activity_hello_word.xml
  • R.java
  • /* AUTO-GENERATED FILE.  DO NOT MODIFY.
     *
     * This class was automatically generated by the
     * aapt tool from the resource data it found.  It
     * should not be modified by hand.
     */
    
    package com.tutos.android.helloworld;
    
    public final class R {
        public static final class attr {
        }
        public static final class dimen {
            public static final int padding_large=0x7f040002;
            public static final int padding_medium=0x7f040001;
            public static final int padding_small=0x7f040000;
        }
        public static final class drawable {
            public static final int ic_action_search=0x7f020000;
            public static final int ic_launcher=0x7f020001;
        }
        public static final class id {
            public static final int menu_settings=0x7f080000;
        }
        public static final class layout {
            public static final int activity_hello_word=0x7f030000;
        }
        public static final class menu {
            public static final int activity_hello_word=0x7f070000;
        }
        public static final class string {
            public static final int app_name=0x7f050000;
            public static final int hello_world=0x7f050001;
            public static final int menu_settings=0x7f050002;
            public static final int title_activity_hello_word=0x7f050003;
        }
        public static final class style {
            public static final int AppTheme=0x7f060000;
        }
    }
    
    • Vous ne devez pas toucher à ce fichier, il est généré automatiquement à partir de vos fichiers qui se trouvent dans le dossier des ressources (res).
    • Vous remarquez que toutes les variables déclarées dans strings.xml sont présentes, que l’interface déclarée dans main.xml aussi (Ce qui explique l’utilisation de la ligne R.layout.main dans le HelloWorldActivity.java) ainsi que l’icône de l’application.

    Conclusion

    Voilà on s’arrête ici pour ce premier tutoriel, d’autre tutoriels vont suivre très prochainement et aborderont des sujets plus approfondis
11/08/2013 06:43:00 AM

La géolocalisation sous Android

LocationListener

Pour pouvoir géocaliser un utilisateur, il faut que vous possédiez une instance de la classe LocationListener ou que l’activité incluant votre carte implémente l’interface LocationListener. Nous allons opter pour la seconde solution et faire en sorte que la classe HelloGoogleMapActivity implémenter cette interface.
Ainsi afin de pouvoir s’abonner à la mise à jour des coordonnées de l’utilisateur, il faut utiliser la méthode requestLocationUpdates(String, long, float, LocationListener).
Cette méthode posséde 4 arguments :
  • Le provider utiliser pour recevoir les mises à jour des coordonnées utilisateurs (GPS / NETWORK …)
  • Un interval minimum entre deux notifications (en millisecondes)
  • Un interval minimum entre deux notifications (en metre)
  • L’instance de votre LocationListener
Il est conseillé de s’abonner aux mises à jour des coordonnées de l’utilisateur dans la méthode onResume et de se désabonner dans le méthode onStop afin de stopper l’utilisateur des ressources de localisation alors que l’application n’en a plus l’utilité.
Ce qui donnera :
@Override
protected void onResume() {
 super.onResume();
 lm = (LocationManager) this.getSystemService(LOCATION_SERVICE);
 if (lm.isProviderEnabled(LocationManager.GPS_PROVIDER))
  lm.requestLocationUpdates(LocationManager.GPS_PROVIDER, 10000, 0, this);
 lm.requestLocationUpdates(LocationManager.NETWORK_PROVIDER, 10000, 0, this);
}

@Override
protected void onPause() {
 super.onPause();
 lm.removeUpdates(this);
}
Implémenter l’interface LocationListener équivaut à surchager les 4 méthodes suivantes :
  • OnProviderEnabled(String provider) : Cette méthode est appelée quand une source de localisation est activée (GPS, 3G..etc). L’argument représente le nom de la source activée. Vous pouvez par exemple vous abonner à la mise à jour de localisation via cette source. Ce qui donnera :
  • @Override
    public void onProviderEnabled(String provider) {
     String msg = String.format(getResources().getString(R.string.provider_enabled), provider);
     Toast.makeText(this, msg, Toast.LENGTH_SHORT).show();
    }
    
    avec
    <string name="provider_enabled">The provider %s is now enabled</string>
  • OnProviderDisabled(String provider) : Cette méthode est appelée quand une source de localisation est désactivée(GPS, 3G..etc). L’argument est le nom de la source désactivée. Vous pouvez par exemple vous désabonner à la mise à jour de localisation via cette source. Ce qui donnera :
  • @Override
    public void onProviderDisabled(String provider) {
     String msg = String.format(getResources().getString(R.string.provider_disabled), provider);
     Toast.makeText(this, msg, Toast.LENGTH_SHORT).show();
    }
    
    
    avec
    <string name="provider_disabled">The provider %s is now disabled</string>
  • OnStatusChanged(String provider, int status, Bundle extras) : Appeler quand le status d’une source change. Il existe 3 statuts (OUT_OF_SERVICE, TEMPORARILY_UNAVAILABLE, AVAILABLE). Ce qui donnera :
  • @Override
    public void onStatusChanged(String provider, int status, Bundle extras) {
     String newStatus = "";
     switch (status) {
      case LocationProvider.OUT_OF_SERVICE:
       newStatus = "OUT_OF_SERVICE";
       break;
      case LocationProvider.TEMPORARILY_UNAVAILABLE:
       newStatus = "TEMPORARILY_UNAVAILABLE";
       break;
      case LocationProvider.AVAILABLE:
       newStatus = "AVAILABLE";
       break;
     }
     String msg = String.format(getResources().getString(R.string.provider_disabled), provider, newStatus);
     Toast.makeText(this, msg, Toast.LENGTH_SHORT).show();
    }
    
    avec
    <string name="provider_new_status">The provider %1$s has now a new status %2$s</string>
  • OnLocationChanged(Location location) : Cette méthode est appelée quand la localisation de l’utilisateur est mise à jour. L’argument représente la nouvelle position. Vous pouvez récupérer plusieurs informations comme la latitude, longitude, altitude et précision (en mètre). Ce qui donnera :
  • @Override
    public void onLocationChanged(Location location) {
     latitude = location.getLatitude();
     longitude = location.getLongitude();
     altitude = location.getAltitude();
     accuracy = location.getAccuracy();
    
     String msg = String.format(
       getResources().getString(R.string.new_location), latitude,
       longitude, altitude, accuracy);
     Toast.makeText(this, msg, Toast.LENGTH_LONG).show();
    }
    
    avec
    <string name="new_location">New Location : Latitude = %1$s, Longitude = %2$s, Altitude = %3$s avec une précision de %4$s mètres </string>
Ce qui donne pour la classe complète :
package com.android.map;

import android.location.Location;
import android.location.LocationListener;
import android.location.LocationManager;
import android.location.LocationProvider;
import android.os.Bundle;
import android.view.KeyEvent;
import android.view.Menu;
import android.widget.Toast;

import com.google.android.maps.GeoPoint;
import com.google.android.maps.MapActivity;
import com.google.android.maps.MapController;
import com.google.android.maps.MapView;

public class HelloGoogleMapActivity extends MapActivity implements
  LocationListener {

 private MapView mapView;
 private MapController mc;

 private LocationManager lm;

 private double latitude;
 private double longitude;
 private double altitude;
 private float accuracy;

 @Override
 public void onCreate(Bundle savedInstanceState) {
  super.onCreate(savedInstanceState);
  setContentView(R.layout.main);

  mapView = (MapView) this.findViewById(R.id.mapView);
  mapView.setBuiltInZoomControls(true);

  mc = mapView.getController();
  mc.setZoom(17);
 }

 @Override
 protected void onResume() {
  super.onResume();
  lm = (LocationManager) this.getSystemService(LOCATION_SERVICE);
  if (lm.isProviderEnabled(LocationManager.GPS_PROVIDER))
   lm.requestLocationUpdates(LocationManager.GPS_PROVIDER, 10000, 0,
     this);
  lm.requestLocationUpdates(LocationManager.NETWORK_PROVIDER, 10000, 0,
    this);
 }

 @Override
 protected void onPause() {
  super.onPause();
  lm.removeUpdates(this);
 }

 @Override
 protected boolean isRouteDisplayed() {
  return false;
 }

 @Override
 public void onLocationChanged(Location location) {
  latitude = location.getLatitude();
  longitude = location.getLongitude();
  altitude = location.getAltitude();
  accuracy = location.getAccuracy();

  String msg = String.format(
    getResources().getString(R.string.new_location), latitude,
    longitude, altitude, accuracy);
  Toast.makeText(this, msg, Toast.LENGTH_LONG).show();
 }

 @Override
 public void onProviderDisabled(String provider) {
  String msg = String.format(
    getResources().getString(R.string.provider_disabled), provider);
  Toast.makeText(this, msg, Toast.LENGTH_SHORT).show();
 }

 @Override
 public void onProviderEnabled(String provider) {
  String msg = String.format(
    getResources().getString(R.string.provider_enabled), provider);
  Toast.makeText(this, msg, Toast.LENGTH_SHORT).show();
 }

 @Override
 public void onStatusChanged(String provider, int status, Bundle extras) {
  String newStatus = "";
  switch (status) {
  case LocationProvider.OUT_OF_SERVICE:
   newStatus = "OUT_OF_SERVICE";
   break;
  case LocationProvider.TEMPORARILY_UNAVAILABLE:
   newStatus = "TEMPORARILY_UNAVAILABLE";
   break;
  case LocationProvider.AVAILABLE:
   newStatus = "AVAILABLE";
   break;
  }
  String msg = String.format(
    getResources().getString(R.string.provider_disabled), provider,
    newStatus);
  Toast.makeText(this, msg, Toast.LENGTH_SHORT).show();
 }

}
Petite explications :
  • Nous avons besoin d’une instance de la classe LocationManager. Cette dernière donne accès au service de localisation. Cela permet aux applications d’obtenir des mises à jour périodiques de la position de l’utilisateur.
  • On appele la méthode requestLocationUpdate pour la mise à jour via le Réseau (NetWork) et le GPS.
  • On implémente les méthodes obligatoires de LocationListener.
Sans oublier les permissions suivantes :
<uses-permission android:name="android.permission.INTERNET" />
<uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />
<uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION" />
  • INTERNET : Pour télécharger et afficher les cartes
  • ACCESS_FINE_LOCATION : Pour pouvoir localiser précisément l’utilisateur (GPS)
  • ACCESS_COARSE_LOCATION : Pour pouvoir localiser approximativement l’utilisateur (WIFI, 3G..)

Mise à jour de la position sur la carte

Maintenant que les nouvelles coordonnées de l’utilisateur sont récupérées, on aimerait mettre à jour la carte afin qu’elle se positionne à l’emplacement de l’utilisateur. Pour cela, il faut créer une instance de la classe GeoPoint (Représentant un point sur un carte) à l’aide des nouvelles coordonnées, puis demander à la carte de se déplacer à cette position. Ce qui donnera :
@Override
public void onLocationChanged(Location location) {
 latitude = location.getLatitude();
 longitude = location.getLongitude();
 altitude = location.getAltitude();
 accuracy = location.getAccuracy();

 String msg = String.format(
   getResources().getString(R.string.new_location), latitude,
   longitude, altitude, accuracy);
 Toast.makeText(this, msg, Toast.LENGTH_LONG).show();

 GeoPoint p = new GeoPoint((int) (latitude * 1E6), (int) (longitude * 1E6));
 mc.animateTo(p);
 mc.setCenter(p);
}
Voici le résultat de cet exemple :
Pour pouvoir mettre à jour les coordonnées de l’utilisateur à l’aide d’un émulateur, deux solutions sont disponibles :
  • l’émulateur contrôle : Fourni avec le SDK et intégré à Eclipse.
  • Un client telnet (PuttyTel) : Pour l’utiliser, il suffit de le lancer et remplir les champs suivants (Host Name : localhost et Port 5554) et pour finir taper help pour connaître les différentes commandes. En ce qui concerne la géolocalisation la commande est la suivante : geo fix latitude longitude.
Dans l’émulateur contrôle, dans la partie Location Controls, saisissez la nouvelle position de l’utilisateur (latitude, longitude) puis cliquez sur send.

Conclusion

Voila ce tutoriel est maintenant fini, en espérant qu’il vous a aidé à mieux comprendre la géolocalisation sousAndroid. N’hésitez pas à me contacter, commenter ou poser vos questions. Je vous fourni le code du projet ici.
11/08/2013 06:36:00 AM

Afficher les marqueurs dans la carte Google Map sous Android

Nous allons voir dans ce tutoriel comment ajouter des points d’intérêts à votre Google Map. Avant tout vous devez déjà avoir implémenter une map au sein de votre application. Vous pouvez reprendre le projet “HelloGoogleMap” vue dans le tutoriel “Intégration d’une Google Map Sous Android”.


ItimizedOverlay

Vous allez tout d’abord créer une classe qui implémente la classe ItimizedOverlay, elle représenteras votre liste de point d’intérêt.

Vous devez spécifier :
  • Le nom de votre classe.
  • Dériver votre classe de com.google.android.maps.ItemizedOverlay (Champ superclass).
  • Cocher la case “Constructors from superclass”.
  • Enfin cliquer sur finish.
Dans notre classe nous allons créer une liste qui va nous permettre de stocker nos points d’intérêts :
private ArrayList<OverlayItem>  arrayListOverlayItem = new ArrayList<OverlayItem>();
Ce qui va nous donner la classe suivante :
package com.tuto.googlemap;

import java.util.ArrayList;

import android.app.AlertDialog;
import android.content.Context;
import android.graphics.drawable.Drawable;

import com.google.android.maps.ItemizedOverlay;
import com.google.android.maps.OverlayItem;

public class ListItimizedOverlay extends ItemizedOverlay<OverlayItem>
{

 private ArrayList<OverlayItem> arrayListOverlayItem = new ArrayList<OverlayItem>();

 public ListItimizedOverlay(Drawable defaultMarker)
 {
  super(boundCenterBottom(defaultMarker));
 }

 @Override
 protected OverlayItem createItem(int i)
 {
  return arrayListOverlayItem.get(i);
 }

 @Override
 public int size()
 {
  return arrayListOverlayItem.size();
 }

 public void addOverlayItem(OverlayItem overlay)
 {
  arrayListOverlayItem.add(overlay);
  populate();
 }

}
Passons à quelques explications :
  • Tout d’abord votre constructeur reçoit en paramètre un Drawable : defaultMarker. Lors de la construction de votre objet ListItimizedOverlay, vous pouvez spécifier l’image qui représentera votre marqueur sur la carte.
  • Toujours en ce qui concerne le constructeur, on remarque aussi l’appel à la méthode boundCenterBottom(defaultMarker) qui englobe le defaultMarker. Cette fonction permet de centrer l’image de votre marqueur juste au dessus du point cible.
  • On ajoute une méthode addOverlayItem qui prends en paramètre des OverlayItem, ce qui nous permettras une fois l’objet créer de rajouter des points dans notre liste : arrayListOverlayItem.add(overlay).
  • La fonction populate() ajoute les points sur la carte. Elle s’occupe de préparer les éléments à dessiner en appelant entre autre votre méthode creatItem.
  • D’où la nécessiter de surcharger les méthodes createItem(int i) qui retourne un élément présent dans notre liste de point.
  • Ma méthode size() indique le nombre d’élément présent dans notre liste.

Ajout du marqueur

Reprenons l’activité qui contient votre Google Map. Nous allons créer un objet de type ListItimizedOverlay qui va contenir nos points. Il va falloir choisir une image Drawable pour l’utiliser en paramètres à la création de notre instance. Pour finir ajouter des points de type GeoPoint avec les coordonnées ciblées.
Voici le code à rajouté à la fin de votre activité :
Drawable drawable = this.getResources().getDrawable(R.drawable.ic_launcher);
LisItimizedOverlay itemizedoverlay = new LisItimizedOverlay(drawable);

GeoPoint geoPoint = new GeoPoint(-17595983, -149487411);
OverlayItem overlayitem = new OverlayItem(geoPoint, "Hello from", "Tahiti");
itemizedoverlay.addOverlayItem(overlayitem);
Lorsque vous voulez ajouter un point à votre liste d’overlay, il faut d’abord créer les points à l’aide de la classe OverlayItem avec comme paramètres les coordonnées du point, un titre et un snippet.
Si vous souhaitez ajouter un autre point, il faut utiliser les lignes suivantes :
GeoPoint geoPoint2 = new GeoPoint(-17528941, -149826891);
OverlayItem overlayitem2 = new OverlayItem(geoPoint2, "Hello from", "Moorea");
itemizedoverlay.addOverlayItem(overlayitem2);
Une fois la liste de point créée, ajoutez les à votre carte. Pour cela, il faut récupérer la liste des points déjà existants (méthode getOverlays()) et y ajouter notre liste .
List<Overlay> mapOverlays = mapView.getOverlays();
mapOverlays.add(itemizedoverlay);
Vous pouvez dès a présent compiler votre projet et y ajouter autant de points que vous souhaitez.

Gestion du clique sur un marqueur

Si vous souhaitez ajouter une action au moment du clique sur un marqueur, une modification de la classe ListItimizedOverlay est nécessaire :
@Override
protected boolean onTap(int index)
{
 OverlayItem item = arrayListOverlayItem.get(index);
AlertDialog.Builder dialog = new AlertDialog.Builder(context);
dialog.setTitle(item.getTitle());
dialog.setMessage(item.getSnippet());
dialog.show();
return true;
}
Nous allons simplement créer un message d’alerte affichant les informations sur le point sélectionné.
Vous pouvez remarquer que l’utilisation d’un AlertDialog nécessite un contexte. Pour cela, nous allons surcharger le constructeur de notre classe afin de pouvoir lui passer un contexte en paramètre.
private Context context;

public LisItimizedOverlay(Drawable defaultMarker, Context pContext)
{
super(boundCenterBottom(defaultMarker));
this.context = pContext;
}
Enfin dans l’activité de votre map, appeler ce nouveau constructeur avec le paramètre this qui représentera notre contexte :
ListItimizedOverlay itemizedoverlay = new ListItimizedOverlay(drawable,this);

Conclusion

Voila ce tutoriel s’arrête ici en espérant qu’il vous a aidé à comprendre comment ajouter des points d’intérêt à votre google map. L’ensemble des sources du projet est disponible ici.
11/08/2013 06:35:00 AM

Geste de rotation

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 , 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.
rotation
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.
doigts
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)
trigo
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:
formule

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 !
11/08/2013 06:33:00 AM

Google Map V2




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)
   <meta-data
            android:name="com.google.android.maps.v2.API_KEY"
            android:value="your_api_key" />
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)
<permission
        android:name="com.tutos.android.gmapv2.permission.MAPS_RECEIVE"
        android:protectionLevel="signature" />

    <uses-permission android:name="com.tutos.android.gmapv2.permission.MAPS_RECEIVE" />
Ainsi que les permissions suivantes :
    <!-- Permission pour utiliser la connexion internet -->
    <uses-permission android:name="android.permission.INTERNET" />
    <!-- Permission permettant de vérifier l'état de la connexion -->
    <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
    <!-- Permission pour stocker des données en cache de la map -->
    <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
    <uses-permission android:name="com.google.android.providers.gsf.permission.READ_GSERVICES" />
    <uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION" />
    <uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />
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
<uses-feature
        android:glEsVersion="0x00020000"
        android:required="true" />
Voici à quoi ressemblera votre fichier AndroidManifest
<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="com.tutos.android.gmapv2"
    android:versionCode="1"
    android:versionName="1.0" >

    <uses-sdk
        android:minSdkVersion="9"
        android:targetSdkVersion="17" />

    <permission
        android:name="com.tutos.android.gmapv2.permission.MAPS_RECEIVE"
        android:protectionLevel="signature" />

    <uses-permission android:name="com.tutos.android.gmapv2.permission.MAPS_RECEIVE" />

    <!-- Permission pour utiliser la connexion internet -->
    <uses-permission android:name="android.permission.INTERNET" />
    <!-- Permission permettant de vérifier l'état de la connexion -->
    <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
    <!-- Permission pour stocker des données en cache de la map -->
    <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
    <uses-permission android:name="com.google.android.providers.gsf.permission.READ_GSERVICES" />
    <uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION" />
    <uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />

    <uses-feature
        android:glEsVersion="0x00020000"
        android:required="true" />

    <application
        android:allowBackup="true"
        android:icon="@drawable/ic_launcher"
        android:label="@string/app_name"
        android:theme="@style/AppTheme" >
        <meta-data
            android:name="com.google.android.maps.v2.API_KEY"
            android:value="AIzaSyBUmd2bMQmcuEpHaw2lKduIdVAPoIXe9ic" />

        <activity
            android:name="com.tutos.android.gmapv2.MapActivity"
            android:label="@string/app_name" >
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />

                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
    </application>

</manifest>

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
<?xml version="1.0" encoding="utf-8"?>
<fragment xmlns:android="http://schemas.android.com/apk/res/android"
    android:id="@+id/map"
    android:name="com.google.android.gms.maps.MapFragment"
    android:layout_width="match_parent"
    android:layout_height="match_parent" />
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
11/08/2013 06:31:00 AM