Eso es todo.

Para comenzar a desarrollar, consulta nuestra documentación para desarrolladores.

Activar el Google Maps SDK for iOS

Para que puedas comenzar, te proporcionaremos orientación en la Google Developers Console a fin de que hagas primero algunas acciones:

  1. Crear o seleccionar un proyecto
  2. Activar el Google Maps SDK for iOS
  3. Crear claves correspondientes
Continuar

Formas

La Google Maps SDK for iOS ofrece maneras simples de agregar formas a tus mapas. Se admiten las siguientes formas:

  • Una polilínea es una serie de segmentos de líneas conectados que pueden generar cualquier forma y pueden emplearse para marcar trazados y rutas en el mapa.
  • Un polígono es una forma delimitada que puede emplearse para marcar áreas del mapa.
  • Un círculo es una proyección geográficamente precisa de un círculo de la superficie terrestre dibujado en el mapa.

Puedes modificar el aspecto de cada forma de varias maneras.

Polilíneas

Las polilíneas te permiten dibujar líneas en el mapa. Un objeto GMSPolyline representa una secuencia ordenada de ubicaciones que aparecen como una serie de segmentos de líneas. Puedes establecer el color de una polilínea con GMSStrokeStyle.

Para crear una polilínea, deberás especificar su trazado generando un objeto GMSMutablePath correspondiente con dos o más puntos. Cada CLLocationCoordinate2D representa un lugar de la superficie terrestre. El dibujo de segmentos de línea se establece entre puntos según el orden en el que los agregues al objeto. Puedes agregar puntos al trazado con los métodos addCoordinate: o 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];

Agregar una polilínea

  1. Crea un objeto GMSMutablePath.
  2. Configura los puntos del trazado con los métodos addCoordinate: o addLatitude:longitude:.
  3. Crea una instancia de un objeto GMSPolyline nueva con el trazado como argumento.
  4. Configura otras propiedades, como strokeWidth y strokeColor, según lo desees.
  5. Configura la propiedad map de la GMSPolyline.
  6. La polilínea aparece en el mapa.

Con el fragmento de código siguiente se agrega un rectángulo a un mapa:

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;

 Agregar una polilínea rectangular

Eliminar una polilínea

Puedes eliminar una polilínea del mapa fijando la propiedad map de tu GMSPolyline en nil. También puedes eliminar todas las superposiciones (incluidas las polilíneas y otras formas) que se hallan actualmente en el mapa llamando al método 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 deseas realizar modificaciones en una polilínea después de agregarla al mapa, asegúrate de conservar el objeto GMSPolyline. Puedes modificar la polilínea posteriormente aplicando cambios a este objeto.

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];

Personalizar una polilínea

El objeto GMSPolyline proporciona varias propiedades para controlar el aspecto de la línea. Se admiten las siguientes opciones:

strokeWidth
Ancho de toda la línea, en puntos de la pantalla. El valor predeterminado es 1. El ancho no se adapta cuando se aplica zoom al mapa.
geodesic
Cuando el valor sea YES, representa este borde polilínea como una línea geodésica. Los segmentos geodésicos siguen el trazado más corto en la superficie terrestre y pueden aparecer como líneas curvadas en un mapa con proyección Mercator. Los segmentos no geodésicos se dibujan como líneas rectas en el mapa. El valor predeterminado es NO.
spans
Se usa para especificar el color de uno o más segmentos de una polilínea. La propiedad “spans” es un arreglo de objetos GMSStyleSpan . La configuración de la propiedad spans es el método preferido para modificar el color de una polilínea.
strokeColor
Objeto UIColor que especifica el color de la polilínea. El valor predeterminado es blueColor. La propiedad strokeColor no se tiene en cuenta si se configura spans.

A través del fragmento de código siguiente se agrega una polilínea gruesa desde Melbourne hasta Perth, con interpolación geodésica.

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;

Para modificar una polilínea después de agregarla al mapa, asegúrate de conservar el objeto 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];

Cambiar el color de una polilínea

Las polilíneas se dibujan como una serie de segmentos en el mapa. Puedes cambiar el color de segmentos individuales, o la línea completa, con la propiedad spans. Aunque esta propiedad te proporciona un control detallado de la coloración de una polilínea, existen varios elementos prácticos que facilitan la aplicación de un único estilo a toda la línea.

A través del fragmento de código siguiente se usa el método spanWithColor: para cambiar el color de toda la línea a rojo.

Swift

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

Objective-C

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

De manera alternativa, si ya tienes acceso a un objeto GMSStrokeStyle, puedes usar el método 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]];

Antes de la versión 1.7 del Google Maps SDK for iOS, la propiedad strokeColor estaba disponible para configurar por completo el color de un objeto GMSPolyline. La propiedad spans se antepone a strokeColor en orden de prioridad.

Swift

polyline.strokeColor = .red

Objective-C

polyline.strokeColor = [UIColor redColor];

Estilos

Si en tu aplicación se aplica el mismo color de trazo varias veces, es posible que te resulte útil definir un estilo reutilizable. Los estilos de polilíneas se especifican a través del objeto GMSStrokeStyle. Un estilo de trazo puede ser color sólido o un gradiente de un color a otro. Una vez que crees un estilo, puedes aplicarlo a un GMSStyleSpan con el método spanWithStyle:.

Swift

// Crea dos estilos: uno que sea azul sólido y otro que sea gradiente de rojo a amarillo
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

// Crea dos estilos: uno que sea azul sólido y otro que sea en degradé de rojo a amarillo
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];

El estilo de una propiedad span se mantendrá hasta el fin de la polilínea o hasta que se configute un nuevo estilo. Puedes cambiar el color de toda la línea configurando la propiedad spans de una polilínea a un único objeto GMSStyleSpan. En el fragmento de código se demuestra la manera de aplicar un gradiente en toda la extensión de la polilínea.

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]];

Cambiar el color de segmentos de líneas individuales

Si deseas aplicar ajustes de estilo a cada segmento de tu polilínea de manera individual, puedes hacerlo creando un arreglo de objetos GMSStyleSpan y pasándolo a la propiedad spans. De manera predeterminada, cada elemento del arreglo configurará el color de la línea correspondiente. Si hay más elementos en el arreglo que segmentos en la línea, se ignorarán los elementos adicionales. Si hay menos elementos en el arreglo, en el objeto GMSStyleSpan se describirá el color de lo que resta en la línea.

Puedes usar los bloques de color o las polilíneas de gradientes para indicar cambios en tu polilínea, como la elevación o la velocidad. En el siguiente fragmento de código se fija en rojo el color de los dos primeros segmentos de una polilínea, y el resto de la línea es un gradiente de rojo a amarillo.

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]];

Puedes usar el método spanWithStyle:segments: para configurar el estilo de varios segmentos a la vez. Por ejemplo, el siguiente código es equivalente al anterior. La extensión de segmentos del objeto GMSStyleSpan final nunca se tendrá en cuenta, ya que el estilo se usará para describir el resto de la línea.

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]];

Segmentos fraccionarios

Los segmentos también pueden especificarse como un valor fraccionario. Con esto se aplicará el estilo al número fraccionario de segmentos, lo cual puede generar una división en un único segmento. Cada GMSStyleSpan se inicia de inmediato después del anterior. En el ejemplo siguiente, el color gris comienza a partir de ½, abarca el segundo segmento, continúa hasta ½ y abarca el tercer segmento.

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]];

Agregar un patrón de color repetido a una polilínea

Si deseas agregar un patrón a una polilínea, puedes usar el método de utilidades GMSStyleSpans en GMSGeometryUtils. El método GMSStyleSpans acepta dos arreglos que definen un patrón repetitivo. Con uno se configuran los estilos que deben repetirse y con el otro el intervalo de repetición. Si los usas combinados, puedes crear un patrón que puede aplicarse en cualquier polilínea, independientemente de la extensión o el número de segmentos disponibles.

A través del fragmento de código siguiente, por ejemplo, se define una polilínea con un patrón de alternación de negro y blanco. Sus extensiones se consideran como metros en una línea de rumbo (en la proyección Mercator, es una línea recto), ya que el tipo se especifica como 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);

Polígonos

Los polígonos se asemejan a las polilíneas en que constan de una serie de coordenadas que forman una secuencia ordenada. Sin embargo, en lugar de ser abiertos, los polígonos están diseñados para definir regiones completas dentro de un bucle cerrado. Los polígonos se definen en el Google Maps SDK for iOS a través de la clase GMSPolygon .

Puedes agregar un objeto GMSPolygon al mapa de la misma manera en que agregarías un objeto GMSPolyline. Primero, especifica su trazado generando un objeto GMSMutablePath correspondiente y agregándole puntos. Estos puntos conformarán el contorno del polígono. Cada CLLocationCoordinate2D representa un lugar de la superficie terrestre. El dibujo de segmentos de línea se establece entre puntos según el orden en el que los agregues al objeto.

Agregar un polígono

  1. Crea un objeto GMSMutablePath.
  2. Configura los puntos del trazado con los métodos addCoordinate: o addLatitude:longitude:. Estos puntos conformarán el contorno del polígono.
  3. Crea una instancia de un objeto GMSPolygon nueva con el trazado como argumento.
  4. Configura otras propiedades, como strokeWidth, strokeColor y fillColor, según lo desees.
  5. Asigna el polígono a un objeto GMSMapView configurando la propiedad GMSPolygon.map.
  6. La polilínea aparece en el mapa.

Con el fragmento de código siguiente se agrega un rectángulo a un mapa.

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))

// Crea el polígono y asígnalo al mapa.
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

// Crea un trazado rectangular
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)];

// Crea el polígono y asígnalo al mapa.
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;

Puedes personalizar el aspecto del polígono antes y después de agregarlo al mapa.

Círculos

Además de la clase genérica GMSPolygon, en el Google Maps SDK for iOS también se incluye GMSCircle, lo cual te permite dibujar fácilmente círculos en la superficie terrestre.

Para construir un círculo, debes especificar las dos propiedades siguientes:

  • position como un CLLocationCoordinate2D;
  • radius en metros.

Por lo tanto, se define a un círculo como el conjunto de todos los puntos de la superficie terrestre que se encuentran a radius metros del objeto center. Debido a la manera en que la proyección Mercator empleada por la Google Maps API representa una esfera en una superficie plana, esta aparecerá casi como un círculo perfecto en el mapa cuando se encuentre cerca del ecuador y perderá cada vez más la forma circular (en la pantalla) a medida que el círculo se aleje del ecuador.

Agregar un círculo

En el fragmento de código siguiente se agrega un círculo al mapa:

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;

Puedes personalizar el aspecto del círculo antes y después de agregarlo al mapa.

Personalizar un círculo

Puedes especificar colores y anchos de trazos modificando propiedades de GMSCircle. Se admiten las siguientes opciones:

fillColor
Objeto UIColor que especifica el color del interior del círculo. El valor predeterminado es el transparente.
strokeColor
Objeto UIColor que especifica el color del contorno del círculo. El valor predeterminado es blackColor.
strokeWidth
Grosor del contorno del círculo, en puntos de la pantalla. El valor predeterminado es 1. El espesor no se adapta cuando se aplica zoom al mapa.

A través del fragmento de código siguiente se agrega un círculo rojo de contorno grueso con un área interior de color rojo semitransparente.

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;

Crear un objeto Polygon hueco

Se pueden combinar varios trazados en un único objeto GMSPolygon para crear formas complejas, como los aros con relleno o anillos (en los cuales las áreas poligonales aparecen dentro del polígono como formas separadas). Las formas complejas son la composición de varios trazados.

Crea un polígono con un trazado que especifique el área más grande abarcada por el polígono. Luego especifica la propiedad holes del polígono como una matriz de uno o más objetos GMSPath, que definen los orificios en el polígono.

Cuando el primer trazado delimita al segundo y más pequeño, aparece como si se hubiera eliminado parte del polígono.

En el siguiente ejemplo de código se crea un polígono con dos orificios:

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;
}

Enviar comentarios sobre...

Google Maps SDK for iOS
Google Maps SDK for iOS
Si necesitas ayuda, visita nuestra página de asistencia.