Vous êtes prêt !

Pour passer à l'étape de développement, accédez à notre documentation pour les développeurs.

Activer Google Maps SDK for iOS

Pour commencer, nous allons vous guider à travers la console Google Developers et effectuer deux ou trois petites choses :

  1. Créer ou choisir un projet
  2. Activer Google Maps SDK for iOS
  3. Créer les clés appropriées
Continuer

Formes

Google Maps SDK for iOS dispose de moyens simples vous permettant d'ajouter des formes à vos cartes. Les formes suivantes sont prises en charge :

  • Une polyligne est une série de segments de ligne connectés qui peuvent créer n'importe quelle forme et être utilisés pour marquer des tracés et des itinéraires sur la carte.
  • Un polygone est une forme fermée qui peut être utilisée pour marquer des zones sur la carte.
  • Un cercle est une projection géographique précise d'un cercle sur la surface de la Terre.

Vous pouvez modifier l'apparence de chaque forme de nombreuses façons.

Polylignes

Les polylignes vous permettent de dessiner des lignes sur la carte. Un objet GMSPolyline représente une séquence ordonnée de points géographiques, affichés par une série de segments de ligne. Vous pouvez définir la couleur d'une polyligne avec GMSStrokeStyle.

Pour créer une polyligne, vous devez spécifier son tracé en créant un objet GMSMutablePath correspondant avec deux points ou plus. Chaque élément CLLocationCoordinate2D représente un point sur la surface de la Terre. Des segments de ligne sont alors dessinés entre ces points dans l'ordre dans lequel vous les ajoutez au tracé. Vous pouvez ajouter des points au tracé à l'aide des méthodes addCoordinate: ou addLatitude:longitude:.

Swift

let path = GMSMutablePath()
path.add(CLLocationCoordinate2D(latitude: -33.85, longitude: 151.20))
path.add(CLLocationCoordinate2D(latitude: -33.70, longitude: 151.40))
path.add(CLLocationCoordinate2D(latitude: -33.73, longitude: 151.41))
let polyline = GMSPolyline(path: path)

Objective-C

GMSMutablePath *path = [GMSMutablePath path];
[path addCoordinate:CLLocationCoordinate2DMake(-33.85, 151.20)];
[path addCoordinate:CLLocationCoordinate2DMake(-33.70, 151.40)];
[path addCoordinate:CLLocationCoordinate2DMake(-33.73, 151.41)];
GMSPolyline *polyline = [GMSPolyline polylineWithPath:path];

Ajouter une polyligne

  1. Créez un objet GMSMutablePath.
  2. Définissez les points sur le tracé à l'aide des méthodes addCoordinate: ou addLatitude:longitude:.
  3. Instanciez un nouvel objet GMSPolyline en utilisant le tracé comme un argument.
  4. Définissez d'autres propriétés, telles que strokeWidth et strokeColor, comme souhaité.
  5. Définissez la propriété map de GMSPolyline.
  6. La polyligne apparaît sur la carte.

L'extrait de code suivant ajoute un rectangle à une carte :

Swift

let path = GMSMutablePath()
path.add(CLLocationCoordinate2D(latitude: 37.36, longitude: -122.0))
path.add(CLLocationCoordinate2D(latitude: 37.45, longitude: -122.0))
path.add(CLLocationCoordinate2D(latitude: 37.45, longitude: -122.2))
path.add(CLLocationCoordinate2D(latitude: 37.36, longitude: -122.2))
path.add(CLLocationCoordinate2D(latitude: 37.36, longitude: -122.0))

let rectangle = GMSPolyline(path: path)
rectangle.map = mapView

Objective-C

GMSMutablePath *path = [GMSMutablePath path];
[path addCoordinate:CLLocationCoordinate2DMake(37.36, -122.0)];
[path addCoordinate:CLLocationCoordinate2DMake(37.45, -122.0)];
[path addCoordinate:CLLocationCoordinate2DMake(37.45, -122.2)];
[path addCoordinate:CLLocationCoordinate2DMake(37.36, -122.2)];
[path addCoordinate:CLLocationCoordinate2DMake(37.36, -122.0)];

GMSPolyline *rectangle = [GMSPolyline polylineWithPath:path];
rectangle.map = mapView;

Une polyligne rectangulaire

Supprimer une polyligne

Vous pouvez supprimer une polyligne de la carte en définissant la propriété map de GMSPolyline sur nil. Vous pouvez également supprimer toutes les superpositions (y compris les polylignes et les autres formes) actuellement sur la carte en appelant la méthode GMSMapView clear.

Swift

let camera = GMSCameraPosition.camera(withLatitude: -33.8683,
                                      longitude: 151.2086,
                                      zoom:12)
let mapView = GMSMapView.map(withFrame: self.view.bounds, camera: camera)
...
mapView.clear()

Objective-C

GMSCameraPosition *camera = [GMSCameraPosition cameraWithLatitude:-33.8683
                                                        longitude:151.2086
                                                             zoom:12];
mapView = [GMSMapView mapWithFrame:self.view.bounds camera:camera];
...
[mapView clear];

Si vous voulez apporter des modifications à une polyligne après l'avoir ajoutée à la carte, veillez à conserver l'objet GMSPolyline. Vous pourrez modifier la polyligne ultérieurement en appliquant des changements à cet objet.

Swift

let polyline = GMSPolyline(path: path)
polyline.map = mapView
...
polyline.strokeColor = .black

Objective-C

GMSPolyline *polyline = [GMSPolyline polylineWithPath:path];
polyline.map = mapView;
...
polyline.strokeColor = [UIColor blackColor];

Personnaliser une polyligne

L'objet GMSPolyline fournit plusieurs propriétés qui permettent de contrôler l'apparence de la ligne. Il prend en charge les options suivantes :

strokeWidth
Largeur de la ligne entière, en points d'écran. Définie sur un 1 par défaut, l'épaisseur n'est pas mise à l'échelle lorsque l'on effectue un zoom sur la carte.
geodesic
Si le paramètre est YES, le bord de cette polyligne est rendu comme une géodésique. Les segments géodésiques suivent le tracé le plus court à la surface de la Terre et peuvent apparaître comme des lignes courbes sur une carte utilisant une projection de Mercator. Les segments non géodésiques sont représentés par des lignes droites sur la carte. La valeur par défaut est NO.
spans
Sert à spécifier la couleur d'un ou de plusieurs segments d'une polyline. La propriété spans est un tableau d'objets GMSStyleSpan . La méthode privilégiée pour modifier la couleur d'une polyligne consiste à définir la propriété spans.
strokeColor
Objet UIColor qui spécifie la couleur de la polyligne. La valeur par défaut est blueColor. La propriété strokeColor est ignorée si spans est défini.

Le fragment suivant trace une polyligne épaisse de Melbourne à Perth, avec une interpolation géodésique.

Swift

let path = GMSMutablePath()
path.addLatitude(-37.81319, longitude: 144.96298)
path.addLatitude(-31.95285, longitude: 115.85734)
let polyline = GMSPolyline(path: path)
polyline.strokeWidth = 10.0
polyline.geodesic = true
polyline.map = mapView

Objective-C

GMSMutablePath *path = [GMSMutablePath path];
[path addLatitude:-37.81319 longitude:144.96298];
[path addLatitude:-31.95285 longitude:115.85734];
GMSPolyline *polyline = [GMSPolyline polylineWithPath:path];
polyline.strokeWidth = 10.f;
polyline.geodesic = YES;
polyline.map = mapView;

Pour modifier une polyligne après l'avoir ajoutée à la carte, assurez-vous de conserver l'objet GMSPolyline.

Swift

let polyline = GMSPolyline(path: path)
polyline.map = mapView
...
polyline.strokeColor = .blue

Objective-C

GMSPolyline *polyline = [GMSPolyline polylineWithPath:path];
polyline.map = mapView;
...
polyline.strokeColor = [UIColor blueColor];

Modifier la couleur d'une polyligne

Les polylignes sont dessinées sous la forme d'une série de segments sur la carte. Vous pouvez modifier la couleur de chaque segment, ou de la ligne entière, grâce à la propriété spans. Bien que cette propriété vous donne un contrôle détaillé de la coloration d'une polyligne, il existe plusieurs méthodes pratiques qui facilitent l'application d'un style unique à la ligne entière.

Le fragment ci-dessous utilise la méthode spanWithColor: pour modifier la couleur de la ligne entière en rouge.

Swift

polyline.spans = [GMSStyleSpan(color: .red)]

Objective-C

polyline.spans = @[[GMSStyleSpan spanWithColor:[UIColor redColor]]];

Si vous avez déjà accès à un objet GMSStrokeStyle, vous pouvez également utiliser la méthode spanWithStyle:.

Swift

let solidRed = GMSStrokeStyle.solidColor(.red)
polyline.spans = [GMSStyleSpan(style: solidRed)]

Objective-C

GMSStrokeStyle *solidRed = [GMSStrokeStyle solidColor:[UIColor redColor]];
polyline.spans = @[[GMSStyleSpan spanWithStyle:solidRed]];

Avant la version 1.7 de Google Maps SDK for iOS, la propriété unique strokeColor était disponible pour définir la couleur d'une GMSPolyline entière. La propriété spans prime sur strokeColor.

Swift

polyline.strokeColor = .red

Objective-C

polyline.strokeColor = [UIColor redColor];

Styles

Si votre application applique plusieurs fois la même couleur de trait, il peut s'avérer utile de définir un style réutilisable. Les styles de polyligne sont spécifiés au moyen de l'objet GMSStrokeStyle. Un style de trait peut être une couleur unie ou un gradient d'une couleur à une autre. Lorsque vous avez créé un style, vous pouvez l'appliquer à un élément GMSStyleSpan avec la méthode spanWithStyle:.

Swift

// Create two styles: one that is solid blue, and one that is a gradient from red to yellow
let solidBlue = GMSStrokeStyle.solidColor(.blue)
let solidBlueSpan = GMSStyleSpan(style: solidBlue)
let redYellow =
  GMSStrokeStyle.gradient(from: .red, to: .yellow)
let redYellowSpan = GMSStyleSpan(style: redYellow)

Objective-C

// Create two styles: one that is solid blue, and one that is a gradient from red to yellow
GMSStrokeStyle *solidBlue = [GMSStrokeStyle solidColor:[UIColor blueColor]];
GMSStyleSpan *solidBlueSpan = [GMSStyleSpan spanWithStyle:solidBlue];
GMSStrokeStyle *redYellow =
    [GMSStrokeStyle gradientFromColor:[UIColor redColor] toColor:[UIColor yellowColor]];
GMSStyleSpan *redYellowSpan = [GMSStyleSpan spanWithStyle:redYellow];

Un style de span continue jusqu'à la fin de la polyligne, ou tant qu'un nouveau style n'a pas été défini. Vous pouvez modifier la couleur d'une ligne entière en définissant la propriété spans d'une polyligne sur un élément GMSStyleSpan unique. Le fragment ci-dessous montre comment appliquer un gradient sur toute la longueur de la polyligne.

Swift

let polyline = GMSPolyline(path: path)
let redYellow =
  GMSStrokeStyle.gradient(from: .red, to: .yellow)
polyline.spans = [GMSStyleSpan(style: redYellow)]

Objective-C

GMSPolyline *polyline = [GMSPolyline polylineWithPath:path];
GMSStrokeStyle *redYellow =
    [GMSStrokeStyle gradientFromColor:[UIColor redColor] toColor:[UIColor yellowColor]];
polyline.spans = @[[GMSStyleSpan spanWithStyle:redYellow]];

Modifier la couleur des segments de ligne individuels

Si vous souhaitez styliser individuellement chaque segment de votre polyligne, vous pouvez créer un tableau d'objets GMSStyleSpan, et le transmettre à la propriété spans. Par défaut, chaque élément dans le tableau définit la couleur du segment de ligne correspondant. S'il y a plus d'éléments dans le tableau que de segments dans la ligne, les éléments supplémentaires sont ignorés. S'il y a moins d'éléments dans le tableau, l'élément GMSStyleSpan final décrit la couleur du reste de la ligne.

Vous pouvez utiliser des blocs de polylignes colorées et/ou avec un gradient pour indiquer des changements le long de votre polyligne, comme l'altitude ou la vitesse. Le fragment ci-dessous définit la couleur des deux premiers segments d'une polyligne en rouge, et le reste de la ligne est un gradient du rouge au jaune.

Swift

let polyline = GMSPolyline(path: path)
let solidRed = GMSStrokeStyle.solidColor(.red)
let redYellow =
    GMSStrokeStyle.gradient(from: .red, to: .yellow)
polyline.spans = [GMSStyleSpan(style: solidRed),
                  GMSStyleSpan(style: solidRed),
                  GMSStyleSpan(style: redYellow)]

Objective-C

GMSPolyline *polyline = [GMSPolyline polylineWithPath:path];
GMSStrokeStyle *solidRed = [GMSStrokeStyle solidColor:[UIColor redColor]];
GMSStrokeStyle *redYellow =
    [GMSStrokeStyle gradientFromColor:[UIColor redColor] toColor:[UIColor yellowColor]];
polyline.spans = @[[GMSStyleSpan spanWithStyle:solidRed],
                   [GMSStyleSpan spanWithStyle:solidRed],
                   [GMSStyleSpan spanWithStyle:redYellow]];

Vous pouvez utiliser la méthode spanWithStyle:segments: pour définir simultanément le style de plusieurs segments. Par exemple, le code suivant équivaut au code ci-dessus. La longueur du segment de l'élément GMSStyleSpan final est toujours ignorée car le style est utilisé pour décrire le reste de la ligne.

Swift

polyline.spans = [GMSStyleSpan(style: solidRed, segments:2),
                  GMSStyleSpan(style: redYellow, segments:10)]

Objective-C

polyline.spans = @[[GMSStyleSpan spanWithStyle:solidRed segments:2],
                   [GMSStyleSpan spanWithStyle:redYellow segments:10]];

Segments fractionnaires

Les segments peuvent aussi être spécifiés par une valeur fractionnaire. Le style est ainsi appliqué au nombre fractionnaire de segments, ce qui est susceptible d'entraîner une division dans un segment unique. Chaque élément GMSStyleSpan commence immédiatement après l'élément précédent : dans l'exemple ci-dessous, la couleur grise commence à ½ du deuxième segment et continue jusqu'à ½ du troisième segment.

Swift

polyline.spans = [GMSStyleSpan(style: solidRed, segments: 2.5),
                  GMSStyleSpan(color: .gray),
                  GMSStyleSpan(color: .purple, segments: 0.75),
                  GMSStyleSpan(style: redYellow)]

Objective-C

polyline.spans = @[[GMSStyleSpan spanWithStyle:solidRed segments:2.5],
                   [GMSStyleSpan spanWithColor:[UIColor grayColor],
                   [GMSStyleSpan spanWithColor:[UIColor purpleColor] segments:0.75,
                   [GMSStyleSpan spanWithStyle:redYellow]];

Ajouter un motif coloré répété à une polyligne

Si vous souhaitez ajouter un motif à une polyligne, vous pouvez utiliser la méthode utilitaire GMSStyleSpans dans GMSGeometryUtils. La méthode GMSStyleSpans accepte deux tableaux qui définissent le motif répété. Un tableau définit les styles devant être répétés, et l'autre définit l'intervalle de répétition. En les utilisant ensemble, vous pouvez créer un motif que vous pouvez appliquer à n'importe quelle polyligne, indépendamment de sa longueur ou du nombre de segments disponibles.

Par exemple, l'extrait de code ci-dessous définit une polyligne avec un motif alternant le noir et le blanc. Ses longueurs sont traitées comme des mètres le long d'une loxodromie (dans la projection de Mercator, il s'agit d'une ligne droite) car le type est spécifié en tant que kGMSLengthRhumb.

Swift

let styles = [GMSStrokeStyle.solidColor(.white),
              GMSStrokeStyle.solidColor(.black)]
let lengths: [NSNumber] = [100000, 50000]
polyline.spans = GMSStyleSpans(polyline.path!, styles, lengths, kGMSLengthRhumb)

Objective-C

NSArray *styles = @[[GMSStrokeStyle solidColor:[UIColor whiteColor]],
                    [GMSStrokeStyle solidColor:[UIColor blackColor]]];
NSArray *lengths = @[@100000, @50000];
polyline.spans = GMSStyleSpans(polyline.path, styles, lengths, kGMSLengthRhumb);

Polygones

Les polygones sont similaires aux polylignes en ce sens qu'ils consistent en une série de coordonnées dans une séquence ordonnée. Toutefois, au lieu d'être ouverts, les polygones sont conçus pour définir des régions dont l'intérieur est plein au sein d'une boucle fermée. Les polygones sont définis dans Google Maps SDK for iOS par la classe GMSPolygon .

Pour ajouter un GMSPolygon à la carte, vous pouvez procéder de la même manière que pour ajouter une GMSPolyline. Vous devez d'abord spécifier son tracé en créant un objet GMSMutablePath correspondant et en y ajoutant des points. Ces points forment le contour du polygone. Chaque élémentCLLocationCoordinate2D représente un point sur la surface de la Terre. Des segments de ligne sont alors dessinés entre ces points dans l'ordre dans lequel vous les ajoutez au tracé.

Ajouter un polygone

  1. Créez un objet GMSMutablePath.
  2. Définissez les points sur le tracé à l'aide des méthodes addCoordinate: ou addLatitude:longitude:. Ces points forment le contour du polygone.
  3. Instanciez un nouvel objet GMSPolygon en utilisant le tracé comme un argument.
  4. Définissez d'autres propriétés, telles que strokeWidth, strokeColor ou fillColor, comme souhaité.
  5. Attribuez le polygone à un objet GMSMapView en définissant la propriété GMSPolygon.map.
  6. La polyligne apparaît sur la carte.

L'extrait de code suivant ajoute un rectangle à une carte :

Swift

// Create a rectangular path
let rect = GMSMutablePath()
rect.add(CLLocationCoordinate2D(latitude: 37.36, longitude: -122.0))
rect.add(CLLocationCoordinate2D(latitude: 37.45, longitude: -122.0))
rect.add(CLLocationCoordinate2D(latitude: 37.45, longitude: -122.2))
rect.add(CLLocationCoordinate2D(latitude: 37.36, longitude: -122.2))

// Create the polygon, and assign it to the map.
let polygon = GMSPolygon(path: rect)
polygon.fillColor = UIColor(red: 0.25, green: 0, blue: 0, alpha: 0.05);
polygon.strokeColor = .black
polygon.strokeWidth = 2
polygon.map = mapView

Objective-C

// Create a rectangular path
GMSMutablePath *rect = [GMSMutablePath path];
[rect addCoordinate:CLLocationCoordinate2DMake(37.36, -122.0)];
[rect addCoordinate:CLLocationCoordinate2DMake(37.45, -122.0)];
[rect addCoordinate:CLLocationCoordinate2DMake(37.45, -122.2)];
[rect addCoordinate:CLLocationCoordinate2DMake(37.36, -122.2)];

// Create the polygon, and assign it to the map.
GMSPolygon *polygon = [GMSPolygon polygonWithPath:rect];
polygon.fillColor = [UIColor colorWithRed:0.25 green:0 blue:0 alpha:0.05];
polygon.strokeColor = [UIColor blackColor];
polygon.strokeWidth = 2;
polygon.map = mapView;

Vous pouvez personnaliser l'aspect du polygone aussi bien avant qu'après l'avoir ajouté à la carte.

Cercles

Outre la classe GMSPolygon générique, Google Maps SDK for iOS inclut également GMSCircle, qui vous permet de dessiner aisément des cercles à la surface de la Terre.

Pour construire un cercle, vous devez spécifier les deux propriétés suivantes :

  • position en tant que CLLocationCoordinate2D.
  • radius en mètres.

Un cercle est ensuite défini comme étant l'ensemble de tous les points à la surface de la Terre situés dans un rayon (radius) de n mètres autour d'un centre (center) donné. Étant donné que Maps API utilise une projection de Mercator pour effectuer le rendu d'une sphère sur une surface plane, cela donnera l'apparence d'un cercle presque parfait sur une carte au niveau de l'équateur, et de moins en moins circulaire (à l'écran) à mesure que ce cercle s'éloigne de l'équateur.

Ajouter un cercle

L'extrait de code suivant ajoute un cercle à la carte :

Swift

let circleCenter = CLLocationCoordinate2D(latitude: 37.35, longitude: -122.0)
let circ = GMSCircle(position: circleCenter, radius: 1000)
circ.map = mapView

Objective-C

CLLocationCoordinate2D circleCenter = CLLocationCoordinate2DMake(37.35, -122.0);
GMSCircle *circ = [GMSCircle circleWithPosition:circleCenter
                                         radius:1000];
circ.map = mapView;

Vous pouvez personnaliser l'aspect du cercle aussi bien avant qu'après l'avoir ajouté à la carte.

Personnaliser un cercle

Vous pouvez spécifier des couleurs et des largeurs de trait personnalisées en modifiant les propriétés de GMSCircle. Il prend en charge les options suivantes :

fillColor
Objet UIColor qui spécifie la couleur de l'intérieur du cercle. Sa valeur par défaut est transparent.
strokeColor
Objet UIColor qui spécifie la couleur du contour du cercle. La valeur par défaut est blackColor.
strokeWidth
Épaisseur du contour du cercle, en points d'écran. Définie sur un 1 par défaut, l'épaisseur n'est pas mise à l'échelle lorsque l'on effectue un zoom sur la carte.

Le fragment suivant ajoute un cercle rouge épais avec un remplissage rouge semi-transparent.

Swift

let circleCenter = CLLocationCoordinate2D(latitude: 37.35, longitude: -122.0)
let circ = GMSCircle(position: circleCenter, radius: 1000)

circ.fillColor = UIColor(red: 0.35, green: 0, blue: 0, alpha: 0.05)
circ.strokeColor = .red
circ.strokeWidth = 5
circ.map = mapView

Objective-C

CLLocationCoordinate2D circleCenter = CLLocationCoordinate2DMake(37.35, -122.0);
GMSCircle *circ = [GMSCircle circleWithPosition:circleCenter
                                         radius:1000];

circ.fillColor = [UIColor colorWithRed:0.25 green:0 blue:0 alpha:0.05];
circ.strokeColor = [UIColor redColor];
circ.strokeWidth = 5;
circ.map = mapView;

Créer un polygone creux

Vous pouvez combiner plusieurs tracés dans un même objet GMSPolygon afin de créer des formes complexes, comme des anneaux pleins, ou « donuts » (où les zones polygonales apparaissent à l'intérieur du polygone comme des formes séparées). Les formes complexes sont composées de plusieurs tracés.

Créez un polygone avec un tracé spécifiant la zone la plus large couverte par le polygone. Spécifiez ensuite la propriété holes du polygone en tant que tableau d'un ou plusieurs objets GMSPath définissant les trous dans le polygone.

Si un tracé plus petit se trouve entièrement à l'intérieur du tracé plus grand, on a l'impression qu'une partie du polygone a été retirée.

L'échantillon de code suivant crée un polygone avec deux trous :

Swift

override func loadView() {
  let hydeParkLocation = CLLocationCoordinate2D(latitude: -33.87344, longitude: 151.21135)
  let camera = GMSCameraPosition.camera(withTarget: hydeParkLocation, zoom: 16)
  let mapView = GMSMapView.map(withFrame: .zero, camera: camera)
  mapView.animate(to: camera)

  let hydePark = "tpwmEkd|y[QVe@Pk@BsHe@mGc@iNaAKMaBIYIq@qAMo@Eo@@[Fe@DoALu@HUb@c@XUZS^ELGxOhAd@@ZB`@J^BhFRlBN\\BZ@`AFrATAJAR?rAE\\C~BIpD"
  let archibaldFountain = "tlvmEqq|y[NNCXSJQOB[TI"
  let reflectionPool = "bewmEwk|y[Dm@zAPEj@{AO"

  let polygon = GMSPolygon()
  polygon.path = GMSPath(fromEncodedPath: hydePark)
  polygon.holes = [GMSPath(fromEncodedPath: archibaldFountain)!, GMSPath(fromEncodedPath: reflectionPool)!]
  polygon.fillColor = UIColor(colorLiteralRed: 1.0, green: 0.0, blue: 0.0, alpha: 0.2)
  polygon.strokeColor = UIColor(colorLiteralRed: 1.0, green: 0.0, blue: 0.0, alpha: 1.0)
  polygon.strokeWidth = 2
  polygon.map = mapView
  view = mapView
}

Objective-C

- (void)loadView {
  CLLocationCoordinate2D hydeParkLocation = CLLocationCoordinate2DMake(-33.87344, 151.21135);
  GMSCameraPosition *camera = [GMSCameraPosition cameraWithTarget:hydeParkLocation
                                                             zoom:16];
  _mapView = [GMSMapView mapWithFrame:CGRectZero camera:camera];

  NSString *hydePark = @"tpwmEkd|y[QVe@Pk@BsHe@mGc@iNaAKMaBIYIq@qAMo@Eo@@[Fe@DoALu@HUb@c@XUZS^ELGxOhAd@@ZB`@J^BhFRlBN\\BZ@`AFrATAJAR?rAE\\C~BIpD";
  NSString *archibaldFountain = @"tlvmEqq|y[NNCXSJQOB[TI";
  NSString *reflectionPool = @"bewmEwk|y[Dm@zAPEj@{AO";

  GMSPolygon *polygon = [[GMSPolygon alloc] init];
  polygon.path = [GMSPath pathFromEncodedPath:hydePark];
  polygon.holes = @[[GMSPath pathFromEncodedPath:archibaldFountain],
                    [GMSPath pathFromEncodedPath:reflectionPool]];
  polygon.fillColor = [UIColor colorWithRed:1.0 green:0.0 blue:0.0 alpha:0.2];
  polygon.strokeColor = [UIColor colorWithRed:1.0 green:0.0 blue:0.0 alpha:1.0];
  polygon.strokeWidth = 2;
  polygon.map = _mapView;
  self.view = _mapView;
}

Envoyer des commentaires concernant…

Google Maps SDK for iOS
Google Maps SDK for iOS
Besoin d'aide ? Consultez notre page d'assistance.