Partager via

Utilisation de l’API Google Maps dans votre application

  • Article

L’utilisation de l’application Cartes est idéale, mais vous souhaitez parfois inclure des cartes directement dans votre application. En plus de l’application de cartes intégrée, Google propose également une API de mappage native pour Android. L’API Maps convient aux cas où vous souhaitez conserver un contrôle accru sur l’expérience de mappage. Les éléments possibles avec l’API Maps sont les suivants :

  • Modification programmatique du point de vue de la carte.
  • Ajout et personnalisation de marqueurs.
  • Annoter une carte avec des superpositions.

Contrairement à l’API Android Google Maps v1 désormais déconseillée, l’API Android Google Maps v2 fait partie des services Google Play. Une application Xamarin.Android doit remplir certaines conditions préalables obligatoires avant de pouvoir utiliser l’API Android Google Maps.

Prérequis de l’API Google Maps

Plusieurs étapes doivent être effectuées avant de pouvoir utiliser l’API Maps, notamment :

Obtenir une clé API Google Maps

La première étape consiste à obtenir une clé API Google Maps (notez que vous ne pouvez pas réutiliser une clé API à partir de l’API Google Maps v1 héritée). Pour plus d’informations sur l’obtention et l’utilisation de la clé API avec Xamarin.Android, consultez Obtention d’une clé API Google Maps.

Installer le Kit de développement logiciel (SDK) Google Play Services

Google Play Services est une technologie de Google qui permet aux applications Android de tirer parti de diverses fonctionnalités google telles que Google+, In-App Facturation et Cartes. Ces fonctionnalités sont accessibles sur les appareils Android en tant que services en arrière-plan, qui sont contenus dans l’APK des services Google Play.

Les applications Android interagissent avec Google Play Services via la bibliothèque cliente Google Play Services. Cette bibliothèque contient les interfaces et les classes pour les services individuels tels que Maps. Le diagramme suivant montre la relation entre une application Android et Google Play Services :

Diagramme illustrant le Google Play Store mettant à jour l’APK des services Google Play

L’API Android Maps est fournie dans le cadre de Google Play Services. Pour qu’une application Xamarin.Android puisse utiliser l’API Maps, le Kit de développement logiciel (SDK) Google Play Services doit être installé à l’aide du Gestionnaire du KIT de développement logiciel (SDK) Android. La capture d’écran suivante montre où se trouve le client des services Google Play dans le Gestionnaire du SDK Android :

Google Play Services apparaît sous Extras dans le Gestionnaire du SDK Android

Notes

L’APK des services Google Play est un produit sous licence qui peut ne pas être présent sur tous les appareils. S’il n’est pas installé, Google Maps ne fonctionnera pas sur l’appareil.

Installer le package Xamarin.GooglePlayServices.Maps à partir de NuGet

Le package Xamarin.GooglePlayServices.Maps contient les liaisons Xamarin.Android pour l’API Google Play Services Maps. Pour ajouter le package Google Play Services Map, cliquez avec le bouton droit sur le dossier Références de votre projet dans le Explorateur de solutions, puis cliquez sur Gérer les packages NuGet... :

Explorateur de solutions montrant l’élément de menu contextuel Gérer les packages NuGet sous Références

Le Gestionnaire de package NuGet s’ouvre. Cliquez sur Parcourir et entrez Xamarin Google Play Services Maps dans le champ de recherche. Sélectionnez Xamarin.GooglePlayServices.Maps, puis cliquez sur Installer. (Si ce package avait été installé précédemment, cliquez sur Mettre à jour.) :

Gestionnaire de package NuGet avec le package Xamarin.GooglePlayServices.Maps sélectionné

Notez que les packages de dépendances suivants sont également installés :

  • Xamarin.GooglePlayServices.Base
  • Xamarin.GooglePlayServices.Basement
  • Xamarin.GooglePlayServices.Tasks

Spécifier les autorisations requises

Les applications doivent identifier les exigences en matière de matériel et d’autorisation pour pouvoir utiliser l’API Google Maps. Certaines autorisations sont automatiquement accordées par le Kit de développement logiciel (SDK) Google Play Services, et il n’est pas nécessaire pour un développeur de les ajouter explicitement à AndroidManfest.XML:

  • Accès à l’état du réseau : l’API Cartes doit pouvoir case activée si elle peut télécharger les vignettes de carte.

  • Accès Internet : l’accès à Internet est nécessaire pour télécharger les vignettes de carte et communiquer avec les serveurs Google Play pour l’accès à l’API.

Les autorisations et fonctionnalités suivantes doivent être spécifiées dans le AndroidManifest.XML pour l’API Android Google Maps :

  • OpenGL ES v2 : l’application doit déclarer la condition requise pour OpenGL ES v2.

  • Clé API Google Maps : la clé API est utilisée pour confirmer que l’application est inscrite et autorisée à utiliser les services Google Play. Pour plus d’informations sur cette clé, consultez Obtention d’une clé API Google Maps .

  • Demander le client HTTP Apache hérité : les applications qui ciblent Android 9.0 (niveau d’API 28) ou supérieur doivent spécifier que le client Apache HTTP hérité est une bibliothèque facultative à utiliser.

  • Accès aux services web Google : l’application a besoin d’autorisations pour accéder aux services web de Google qui secours l’API Android Maps.

  • Autorisations pour les notifications Google Play Services : l’application doit être autorisée à recevoir des notifications à distance des services Google Play.

  • Accès aux fournisseurs d’emplacement : il s’agit d’autorisations facultatives. Ils permettront à la GoogleMap classe d’afficher l’emplacement de l’appareil sur la carte.

En outre, Android 9 a supprimé la bibliothèque de client Http Apache du chemin d’amorçage, et n’est donc pas disponible pour les applications qui ciblent l’API 28 ou une version ultérieure. La ligne suivante doit être ajoutée au application nœud de votre fichier AndroidManifest.xml pour continuer à utiliser le client HTTP Apache dans les applications qui ciblent l’API 28 ou une version ultérieure :

<application ...>
   ...
   <uses-library android:name="org.apache.http.legacy" android:required="false" />    
</application>

Notes

Les versions très anciennes du Kit de développement logiciel (SDK) Google Play nécessitaient une application pour demander l’autorisation WRITE_EXTERNAL_STORAGE . Cette exigence n’est plus nécessaire avec les liaisons Xamarin récentes pour Google Play Services.

L’extrait de code suivant est un exemple des paramètres qui doivent être ajoutés à AndroidManifest.XML:

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android" android:versionName="4.5" package="com.xamarin.docs.android.mapsandlocationdemo2" android:versionCode="6">
    <uses-sdk android:minSdkVersion="23" android:targetSdkVersion="28" />

    <!-- Google Maps for Android v2 requires OpenGL ES v2 -->
    <uses-feature android:glEsVersion="0x00020000" android:required="true" />

    <!-- Necessary for apps that target Android 9.0 or higher -->
    <uses-library android:name="org.apache.http.legacy" android:required="false" />

    <!-- Permission to receive remote notifications from Google Play Services -->
    <!-- Notice here that we have the package name of our application as a prefix on the permissions. -->
    <uses-permission android:name="<PACKAGE NAME>.permission.MAPS_RECEIVE" />
    <permission android:name="<PACKAGE NAME>.permission.MAPS_RECEIVE" android:protectionLevel="signature" />

    <!-- These are optional, but recommended. They will allow Maps to use the My Location provider. -->
    <uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION" />
    <uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />

    <application android:label="@string/app_name">
        <!-- Put your Google Maps V2 API Key here. -->
        <meta-data android:name="com.google.android.maps.v2.API_KEY" android:value="YOUR_API_KEY" />
        <meta-data android:name="com.google.android.gms.version" android:value="@integer/google_play_services_version" />
        <!-- Necessary for apps that target Android 9.0 or higher -->
        <uses-library android:name="org.apache.http.legacy" android:required="false" />
    </application>
</manifest>

En plus de demander les autorisations AndroidManifest.XML, une application doit également effectuer des vérifications d’autorisation d’exécution pour les ACCESS_COARSE_LOCATION autorisations et ACCESS_FINE_LOCATION . Pour plus d’informations sur l’exécution des vérifications d’autorisation, consultez le Guide des autorisations Xamarin.Android .

Créer un émulateur avec les API Google

Dans le cas où un appareil Android physique avec les services Google Play n’est pas installé, il est possible de créer une image d’émulateur pour le développement. Pour plus d’informations, consultez le Gestionnaire de périphériques.

Classe GoogleMap

Une fois les prérequis satisfaits, il est temps de commencer à développer l’application et à utiliser l’API Android Maps. La classe GoogleMap est l’API main qu’une application Xamarin.Android utilisera pour afficher et interagir avec un Google Maps pour Android. Cette classe a les responsabilités suivantes :

  • Interaction avec les services Google Play pour autoriser l’application avec le service web Google.

  • Téléchargement, mise en cache et affichage des vignettes de carte.

  • Affichage des contrôles de l’interface utilisateur tels que panoramique et zoom sur l’utilisateur.

  • Dessin de marqueurs et de formes géométriques sur des cartes.

est GoogleMap ajouté à une activité de l’une des deux manières suivantes :

  • MapFragment : MapFragment est un fragment spécialisé qui agit comme hôte pour l’objet GoogleMap . nécessite MapFragment le niveau d’API Android 12 ou supérieur. Les versions antérieures d’Android peuvent utiliser SupportMapFragment. Ce guide se concentre sur l’utilisation de la MapFragment classe.

  • MapView : MapView est une sous-classe View spécialisée, qui peut servir d’hôte pour un GoogleMap objet. Les utilisateurs de cette classe doivent transférer toutes les méthodes de cycle de vie d’activité à la MapView classe .

Chacun de ces conteneurs expose une Map propriété qui retourne une instance de GoogleMap. La préférence doit être donnée à la classe MapFragment , car il s’agit d’une API plus simple qui réduit la quantité de code réutilisable qu’un développeur doit implémenter manuellement.

Ajout d’un MapFragment à une activité

La capture d’écran suivante est un exemple d’un simple MapFragment:

Capture d’écran d’un appareil affichant un fragment Google Map

Comme pour les autres classes Fragment, il existe deux façons d’ajouter un MapFragment à une activité :

  • Déclarativement : MapFragment peut être ajouté via le fichier de disposition XML de l’activité. L’extrait de code XML suivant montre un exemple d’utilisation de l’élément fragment :

    <?xml version="1.0" encoding="utf-8"?>
<fragment xmlns:android="http://schemas.android.com/apk/res/android"
          android:id="@+id/map"
          android:layout_width="match_parent"
          android:layout_height="match_parent"
          class="com.google.android.gms.maps.MapFragment" />

  • Programmatiquement : MapFragment peut être instancié par programmation à l’aide de la MapFragment.NewInstance méthode, puis ajouté à une activité. Cet extrait de code montre la façon la plus simple d’instancier un MapFragment objet et de l’ajouter à une activité :

        var mapFrag = MapFragment.NewInstance();
    activity.FragmentManager.BeginTransaction()
                            .Add(Resource.Id.map_container, mapFrag, "map_fragment")
                            .Commit();

    Il est possible de configurer l’objet MapFragment en passant un GoogleMapOptions objet à NewInstance. Cela est décrit dans la section Propriétés GoogleMap qui apparaît plus loin dans ce guide.

La MapFragment.GetMapAsync méthode est utilisée pour initialiser le GoogleMap qui est hébergé par le fragment et obtenir une référence à l’objet map hébergé par .MapFragment Cette méthode prend un objet qui implémente l’interface IOnMapReadyCallback .

Cette interface a une seule méthode, IMapReadyCallback.OnMapReady(MapFragment map) qui sera appelée quand l’application pourra interagir avec l’objet GoogleMap . L’extrait de code suivant montre comment une activité Android peut initialiser un MapFragment et implémenter l’interface IOnMapReadyCallback :

public class MapWithMarkersActivity : AppCompatActivity, IOnMapReadyCallback
{
    protected override void OnCreate(Bundle bundle)
    {
        base.OnCreate(bundle);
        SetContentView(Resource.Layout.MapLayout);

        var mapFragment = (MapFragment) FragmentManager.FindFragmentById(Resource.Id.map);
        mapFragment.GetMapAsync(this);

        // remainder of code omitted
    }

    public void OnMapReady(GoogleMap map)
    {
        // Do something with the map, i.e. add markers, move to a specific location, etc.
    }
}

Types de carte

Il existe cinq types de cartes différents disponibles à partir de l’API Google Maps :

  • Normal : il s’agit du type de carte par défaut. Il présente des routes et des caractéristiques naturelles importantes ainsi que certains points d’intérêt artificiels (tels que les bâtiments et les ponts).

  • Satellite : cette carte montre la photographie par satellite.

  • Hybride : cette carte montre des photographies satellites et des cartes routières.

  • Terrain - Ceci montre principalement les caractéristiques topographiques avec certaines routes.

  • Aucun : cette carte ne charge aucune vignette, elle est affichée sous la forme d’une grille vide.

L’image ci-dessous montre trois des différents types de cartes, de gauche à droite (normal, hybride, terrain) :

Trois exemples de captures d’écran de carte : Normal, Hybride et Terrain

La GoogleMap.MapType propriété est utilisée pour définir ou modifier le type de carte affiché. L’extrait de code suivant montre comment afficher une carte satellite.

public void OnMapReady(GoogleMap map)
{
    map.MapType = GoogleMap.MapTypeHybrid;
}

Propriétés GoogleMap

GoogleMap définit plusieurs propriétés qui peuvent contrôler les fonctionnalités et l’apparence de la carte. Une façon de configurer l’état initial d’un GoogleMap consiste à passer un objet GoogleMapOptions lors de la création d’un MapFragment. L’extrait de code suivant est un exemple d’utilisation d’un GoogleMapOptions objet lors de la création d’un MapFragment:

GoogleMapOptions mapOptions = new GoogleMapOptions()
    .InvokeMapType(GoogleMap.MapTypeSatellite)
    .InvokeZoomControlsEnabled(false)
    .InvokeCompassEnabled(true);

FragmentTransaction fragTx = FragmentManager.BeginTransaction();
mapFragment = MapFragment.NewInstance(mapOptions);
fragTx.Add(Resource.Id.map, mapFragment, "map");
fragTx.Commit();

L’autre façon de configurer un GoogleMap consiste à manipuler des propriétés sur les UiSettings de l’objet map. L’exemple de code suivant montre comment configurer un GoogleMap pour afficher les contrôles de zoom et une boussole :

public void OnMapReady(GoogleMap map)
{
    map.UiSettings.ZoomControlsEnabled = true;
    map.UiSettings.CompassEnabled = true;
}

Interaction avec GoogleMap

L’API Cartes Android fournit des API qui permettent à une activité de modifier le point de vue, d’ajouter des marqueurs, de placer des superpositions personnalisées ou de dessiner des formes géométriques. Cette section explique comment accomplir certaines de ces tâches dans Xamarin.Android.

Modification du point de vue

Les cartes sont modélisées comme un plan plat à l’écran, en fonction de la projection Mercator. La vue de carte est celle d’une caméra regardant droit vers le bas sur ce plan. La position de la caméra peut être contrôlée en modifiant l’emplacement, le zoom, l’inclinaison et le roulement. La classe CameraUpdate est utilisée pour déplacer l’emplacement de la caméra. CameraUpdate les objets ne sont pas instanciés directement, mais l’API Maps fournit la classe CameraUpdateFactory .

Une fois qu’un CameraUpdate objet a été créé, il est passé en tant que paramètre aux méthodes GoogleMap.MoveCamera ou GoogleMap.AnimateCamera . La MoveCamera méthode met à jour la carte instantanément tandis que la AnimateCamera méthode fournit une transition fluide et animée.

Cet extrait de code est un exemple simple de la façon d’utiliser pour CameraUpdateFactory créer un CameraUpdate qui incrémentera le niveau de zoom de la carte d’un niveau de zoom :

MapFragment mapFrag = (MapFragment) FragmentManager.FindFragmentById(Resource.Id.my_mapfragment_container);
mapFrag.GetMapAsync(this);
...

public void OnMapReady(GoogleMap map)
{   
    map.MoveCamera(CameraUpdateFactory.ZoomIn());
}

L’API Maps fournit une CameraPosition qui agrège toutes les valeurs possibles pour la position de la caméra. Une instance de cette classe peut être fournie à la méthode CameraUpdateFactory.NewCameraPosition qui retourne un CameraUpdate objet. L’API Maps inclut également la classe CameraPosition.Builder qui fournit une API Fluent pour la création d’objets CameraPosition . L’extrait de code suivant montre un exemple de création d’un CameraUpdate à partir d’un CameraPosition et de l’utiliser pour modifier la position de la caméra sur un GoogleMap:

public void OnMapReady(GoogleMap map)
{
    LatLng location = new LatLng(50.897778, 3.013333);

    CameraPosition.Builder builder = CameraPosition.InvokeBuilder();
    builder.Target(location);
    builder.Zoom(18);
    builder.Bearing(155);
    builder.Tilt(65);

    CameraPosition cameraPosition = builder.Build();

    CameraUpdate cameraUpdate = CameraUpdateFactory.NewCameraPosition(cameraPosition);

    map.MoveCamera(cameraUpdate);
}

Dans l’extrait de code précédent, un emplacement spécifique sur la carte est représenté par la classe LatLng . Le niveau de zoom est défini sur 18, qui est une mesure arbitraire du zoom utilisée par Google Maps. Le palier est la mesure de la boussole dans le sens des aiguilles d’une montre à partir du nord. La propriété Tilt contrôle l’angle de vue et spécifie un angle de 25 degrés par rapport à la verticale. La capture d’écran suivante montre le GoogleMap après l’exécution du code précédent :

Exemple Google Map montrant un emplacement spécifié avec un angle de vue incliné

Dessin sur la carte

L’API Cartes Android fournit des API pour dessiner les éléments suivants sur une carte :

  • Marqueurs : il s’agit d’icônes spéciales utilisées pour identifier un emplacement unique sur une carte.

  • Superpositions : il s’agit d’une image qui peut être utilisée pour identifier une collection d’emplacements ou de zones sur la carte.

  • Lignes, polygones et cercles : il s’agit d’API qui permettent aux activités d’ajouter des formes à une carte.

Marqueurs

L’API Maps fournit une classe Marker qui encapsule toutes les données relatives à un emplacement unique sur une carte. Par défaut, la classe Marker utilise une icône standard fournie par Google Maps. Il est possible de personnaliser l’apparence d’un marqueur et de répondre aux clics de l’utilisateur.

Ajout d’un marqueur

Pour ajouter un marqueur à une carte, il est nécessaire de créer un objet MarkerOptions, puis d’appeler la méthode AddMarker sur un GoogleMap instance. Cette méthode retourne un objet Marker .

public void OnMapReady(GoogleMap map)
{
    MarkerOptions markerOpt1 = new MarkerOptions();
    markerOpt1.SetPosition(new LatLng(50.379444, 2.773611));
    markerOpt1.SetTitle("Vimy Ridge");

    map.AddMarker(markerOpt1);
}

Le titre du marqueur s’affiche dans une fenêtre d’informations lorsque l’utilisateur appuie sur le marqueur. La capture d’écran suivante montre à quoi ressemble ce marqueur :

Exemple google map avec un marqueur et une fenêtre d’informations pour la crête de Vimy

Personnalisation d’un marqueur

Il est possible de personnaliser l’icône utilisée par le marqueur en appelant la méthode lors de l’ajout MarkerOptions.InvokeIcon du marqueur à la carte. Cette méthode prend un objet BitmapDescriptor contenant les données nécessaires au rendu de l’icône. La classe BitmapDescriptorFactory fournit des méthodes d’assistance pour simplifier la création d’un BitmapDescriptor. La liste suivante présente certaines de ces méthodes :

  • DefaultMarker(float colour) – Utilisez le marqueur Google Maps par défaut, mais modifiez la couleur.

  • FromAsset(string assetName) : utilisez une icône personnalisée à partir du fichier spécifié dans le dossier Assets.

  • FromBitmap(Bitmap image) : utilisez l’image bitmap spécifiée comme icône.

  • FromFile(string fileName) : créez l’icône personnalisée à partir du fichier au chemin d’accès spécifié.

  • FromResource(int resourceId) : créez une icône personnalisée à partir de la ressource spécifiée.

L’extrait de code suivant montre un exemple de création d’un marqueur par défaut de couleur cyan :

public void OnMapReady(GoogleMap map)
{
    MarkerOptions markerOpt1 = new MarkerOptions();
    markerOpt1.SetPosition(new LatLng(50.379444, 2.773611));
    markerOpt1.SetTitle("Vimy Ridge");

    var bmDescriptor = BitmapDescriptorFactory.DefaultMarker (BitmapDescriptorFactory.HueCyan);
    markerOpt1.InvokeIcon(bmDescriptor);

    map.AddMarker(markerOpt1);
}

Fenêtres d’informations

Les fenêtres d’informations sont des fenêtres spéciales qui s’affichent pour afficher des informations à l’utilisateur lorsqu’il appuie sur un marqueur spécifique. Par défaut, la fenêtre d’informations affiche le contenu du titre du marqueur. Si le titre n’a pas été attribué, aucune fenêtre d’informations n’apparaît. Une seule fenêtre d’informations peut être affichée à la fois.

Il est possible de personnaliser la fenêtre d’informations en implémentant l’interface GoogleMap.IInfoWindowAdapter . Il existe deux méthodes importantes sur cette interface :

  • public View GetInfoWindow(Marker marker) : cette méthode est appelée pour obtenir une fenêtre d’informations personnalisée pour un marqueur. S’il retourne null , le rendu de fenêtre par défaut sera utilisé. Si cette méthode retourne une vue, cette vue est placée à l’intérieur du cadre de la fenêtre d’informations.

  • public View GetInfoContents(Marker marker) : cette méthode sera appelée uniquement si GetInfoWindow retourne null . Cette méthode peut retourner une null valeur si le rendu par défaut du contenu de la fenêtre d’informations doit être utilisé. Sinon, cette méthode doit retourner une vue avec le contenu de la fenêtre d’informations.

Une fenêtre d’informations n’est pas une vue en direct. Au lieu de cela, Android convertit l’affichage en bitmap statique et l’affiche sur l’image. Cela signifie qu’une fenêtre d’informations ne peut pas répondre à des événements ou mouvements tactiles et ne peut pas se mettre à jour automatiquement. Pour mettre à jour une fenêtre d’informations, il est nécessaire d’appeler la méthode GoogleMap.ShowInfoWindow .

L’image suivante montre quelques exemples de fenêtres d’informations personnalisées. L’image à gauche a son contenu personnalisé, tandis que l’image à droite a sa fenêtre et son contenu personnalisé avec des coins arrondis :

Exemple de fenêtres de marqueur pour Melbourne, y compris l’icône et la population. La fenêtre de droite a des coins arrondis.

GroundOverlays

Contrairement aux marqueurs, qui identifient un emplacement spécifique sur une carte, une groundOverlay est une image utilisée pour identifier une collection d’emplacements ou une zone sur la carte.

Ajout d’un GroundOverlay

L’ajout d’une superposition de sol à une carte est similaire à l’ajout d’un marqueur à une carte. Tout d’abord, un objet GroundOverlayOptions est créé. Cet objet est ensuite passé en tant que paramètre à la GoogleMap.AddGroundOverlay méthode, qui retourne un GroundOverlay objet. Cet extrait de code est un exemple d’ajout d’une superposition de sol à une carte :

BitmapDescriptor image = BitmapDescriptorFactory.FromResource(Resource.Drawable.polarbear);
GroundOverlayOptions groundOverlayOptions = new GroundOverlayOptions()
    .Position(position, 150, 200)
    .InvokeImage(image);
GroundOverlay myOverlay = googleMap.AddGroundOverlay(groundOverlayOptions);

La capture d’écran suivante montre cette superposition sur une carte :

Exemple de carte avec une image en retard d’un ours polaire

Lignes, cercles et polygones

Il existe trois types simples de figures géométriques qui peuvent être ajoutés à une carte :

  • Polyline : il s’agit d’une série de segments de ligne connectés. Il peut marquer un chemin sur une carte ou créer une forme géométrique.

  • Cercle : dessine un cercle sur la carte.

  • Polygone : il s’agit d’une forme fermée permettant de marquer des zones sur une carte.

Polylignes

Une Polyline est une liste d’objets consécutifs LatLng qui spécifient les sommets de chaque segment de ligne. Une polyligne est créée en créant d’abord un PolylineOptions objet et en y ajoutant les points. L’objet PolylineOption est ensuite passé à un GoogleMap objet en appelant la AddPolyline méthode .

PolylineOption rectOptions = new PolylineOption();
rectOptions.Add(new LatLng(37.35, -122.0));
rectOptions.Add(new LatLng(37.45, -122.0));
rectOptions.Add(new LatLng(37.45, -122.2));
rectOptions.Add(new LatLng(37.35, -122.2));
rectOptions.Add(new LatLng(37.35, -122.0)); // close the polyline - this makes a rectangle.

googleMap.AddPolyline(rectOptions);
Cercles

Les cercles sont créés en instanciant d’abord un objet CircleOption qui spécifie le centre et le rayon du cercle en mètres. Le cercle est dessiné sur la carte en appelant GoogleMap.AddCircle. L’extrait de code suivant montre comment dessiner un cercle :

CircleOptions circleOptions = new CircleOptions ();
circleOptions.InvokeCenter (new LatLng(37.4, -122.1));
circleOptions.InvokeRadius (1000);

googleMap.AddCircle (circleOptions);
Polygones

Polygonsont similaires à Polylines, mais ils ne sont pas ouverts. Polygonsont une boucle fermée et ont leur intérieur rempli. Polygons sont créés exactement de la même manière qu’un Polyline, à l’exception de la méthode GoogleMap.AddPolygon appelée.

Contrairement à un Polyline, un Polygon est à fermeture automatique. Le polygone est fermé par la AddPolygon méthode en dessinant une ligne qui connecte le premier et le dernier point. L’extrait de code suivant crée un rectangle solide sur la même zone que l’extrait de code précédent dans l’exemple Polyline .

PolygonOptions rectOptions = new PolygonOptions();
rectOptions.Add(new LatLng(37.35, -122.0));
rectOptions.Add(new LatLng(37.45, -122.0));
rectOptions.Add(new LatLng(37.45, -122.2));
rectOptions.Add(new LatLng(37.35, -122.2));
// notice we don't need to close off the polygon

googleMap.AddPolygon(rectOptions);

Réponse aux événements utilisateur

Il existe trois types d’interactions qu’un utilisateur peut avoir avec une carte :

  • Clic de marqueur : l’utilisateur clique sur un marqueur.

  • Glissement du marqueur : l’utilisateur a cliqué longuement sur un mparger

  • Fenêtre d’informations Clic : l’utilisateur a cliqué sur une fenêtre d’informations.

Chacun de ces événements sera abordé plus en détail ci-dessous.

Événements de clic de marqueur

L’événement MarkerClicked est déclenché lorsque l’utilisateur appuie sur un marqueur. Cet événement accepte un GoogleMap.MarkerClickEventArgs objet en tant que paramètre. Cette classe contient deux propriétés :

  • GoogleMap.MarkerClickEventArgs.Handled : cette propriété doit être définie sur true pour indiquer que le gestionnaire d’événements a consommé l’événement. Si cette valeur est définie sur false , le comportement par défaut se produit en plus du comportement personnalisé du gestionnaire d’événements.

  • Marker : cette propriété est une référence au marqueur qui a déclenché l’événement MarkerClick .

Cet extrait de code montre un exemple de qui va changer la position de MarkerClick la caméra en un nouvel emplacement sur la carte :

void MapOnMarkerClick(object sender, GoogleMap.MarkerClickEventArgs markerClickEventArgs)
{
    markerClickEventArgs.Handled = true;

    var marker = markerClickEventArgs.Marker;
    if (marker.Id.Equals(gotMauiMarkerId))
    {
        LatLng InMaui = new LatLng(20.72110, -156.44776);

        // Move the camera to look at Maui.
        PositionPolarBearGroundOverlay(InMaui);
        googleMap.AnimateCamera(CameraUpdateFactory.NewLatLngZoom(InMaui, 13));
        gotMauiMarkerId = null;
        polarBearMarker.Remove();
        polarBearMarker = null;
    }
    else
    {
        Toast.MakeText(this, $"You clicked on Marker ID {marker.Id}", ToastLength.Short).Show();
    }
}

Événements de glissement de marqueur

Cet événement est déclenché lorsque l’utilisateur souhaite faire glisser le marqueur. Par défaut, les marqueurs ne peuvent pas faire glisser. Un marqueur peut être défini comme pouvant être fait glisser en définissant la Marker.Draggable propriété true sur ou en appelant la MarkerOptions.Draggable méthode avec true comme paramètre.

Pour faire glisser le marqueur, l’utilisateur doit d’abord cliquer longuement sur le marqueur, puis son doigt doit rester sur la carte. Lorsque le doigt de l’utilisateur est déplacé sur l’écran, le marqueur se déplace. Lorsque le doigt de l’utilisateur lève l’écran, le marqueur reste en place.

La liste suivante décrit les différents événements qui seront déclenchés pour un marqueur pouvant faire glisser :

  • GoogleMap.MarkerDragStart(object sender, GoogleMap.MarkerDragStartEventArgs e) : cet événement est déclenché lorsque l’utilisateur fait glisser le marqueur pour la première fois.

  • GoogleMap.MarkerDrag(object sender, GoogleMap.MarkerDragEventArgs e) : cet événement est déclenché lorsque le marqueur est en cours de déplacement.

  • GoogleMap.MarkerDragEnd(object sender, GoogleMap.MarkerDragEndEventArgs e) : cet événement est déclenché lorsque l’utilisateur a terminé de faire glisser le marqueur.

Chacun de contient EventArgs une propriété unique appelée P0 qui est une référence à l’objet Marker déplacé.

Fenêtre d’informations Événements click

Une seule fenêtre d’informations peut être affichée à la fois. Lorsque l’utilisateur clique sur une fenêtre d’informations dans une carte, l’objet map déclenche un InfoWindowClick événement. L’extrait de code suivant montre comment connecter un gestionnaire à l’événement :

public void OnMapReady(GoogleMap map)
{
    map.InfoWindowClick += MapOnInfoWindowClick;
}

private void MapOnInfoWindowClick (object sender, GoogleMap.InfoWindowClickEventArgs e)
{
    Marker myMarker = e.Marker;
    // Do something with marker.
}

Rappelez-vous qu’une fenêtre d’informations est une fenêtre statique View qui est rendue sous la forme d’une image sur la carte. Les widgets tels que les boutons, les case activée les zones ou les affichages texte placés à l’intérieur de la fenêtre d’informations sont inertes et ne peuvent pas répondre à leurs événements utilisateur intégraux.