Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.

# SDKs y marcos para Amazon Location Service
<a name="dev-sdks"></a>

AWS proporciona kits de desarrollo de software (SDKs) para varios lenguajes de programación, lo que le permite integrar fácilmente Amazon Location Service en sus aplicaciones. En esta página se describen las SDKs opciones disponibles, sus procedimientos de instalación y ejemplos de código para ayudarte a empezar a utilizar Amazon Location Service en el entorno de desarrollo que prefieras.

Existen varias herramientas que le ayudarán a utilizar Amazon Location Service.
+ **AWS SDKs**— Los kits de desarrollo de AWS software (SDKs) están disponibles en muchos lenguajes de programación populares y proporcionan una API, ejemplos de código y documentación que facilitan la creación de aplicaciones en el idioma de su preferencia. AWS SDKs Incluyen la ubicación APIs y las funciones principales de Amazon, incluido el acceso a mapas, lugares, rutas, geofencing y rastreadores. Para obtener más información sobre las SDKs opciones disponibles para su uso con Amazon Location Service para diferentes aplicaciones e idiomas, consulte[SDK por lenguaje](dev-by-language.md).
+ **MapLibre**— Amazon Location Service recomienda renderizar los mapas con el motor de [MapLibre](https://github.com/maplibre/maplibre-gl-js)renderizado. MapLibre es un motor para mostrar mapas en aplicaciones web o móviles. MapLibre también tiene un modelo de complemento y es compatible con la interfaz de usuario para la búsqueda y las rutas en algunos idiomas y plataformas. Para obtener más información sobre su uso MapLibre y las funciones que proporciona, consulte[Uso de las herramientas de MapLibre y bibliotecas relacionadas con Amazon Location](dev-maplibre.md).
+ **Amazon Location SDKs**: Amazon Location SDKs es un conjunto de bibliotecas de código abierto que facilitan el desarrollo de aplicaciones con Amazon Location Service. Las bibliotecas proporcionan funciones para admitir la autenticación de aplicaciones móviles y web, el seguimiento de la ubicación para aplicaciones móviles, la conversión entre los tipos de datos de Amazon Location y [GeoJSON](https://geojson.org/), así como un paquete alojado del cliente Amazon Location para el AWS SDK v3. Para obtener más información sobre la sucursal de Amazon SDKs, consulta[SDK por lenguaje](dev-by-language.md).
+ **SDK de migración de Amazon Location**: el SDK de migración de Amazon Location proporciona un puente que le permite migrar las aplicaciones existentes de Google Maps a Amazon Location. El SDK de migración ofrece una opción para que su aplicación creada con el SDK de Google Maps utilice Amazon Location Service sin necesidad de volver a escribir la lógica empresarial o de la aplicación si Amazon Location admite las capacidades utilizadas. JavaScript El SDK de migración redirige todas las llamadas a la API a Amazon Location en lugar de a Google Map. Para empezar, consulta el [SDK de migración de ubicaciones de Amazon](https://github.com/aws-geospatial/amazon-location-migration) en GitHub.

# Tutoriales para desarrolladores
<a name="sdk-how-to"></a>

Utilice esta sección para obtener información sobre cómo utilizar varios aspectos del Amazon Location Service SDK.

**Topics**
+ [Cómo utilizar los ayudantes de autenticación](how-to-auth-helper.md)
+ [Utilice el complemento Amazon Location MapLibre Geocoder GL](dev-maplibre-geocoder.md)
+ [Cómo usar los SDK de seguimiento](dev-tracking-sdk.md)
+ [Uso de las herramientas de MapLibre y bibliotecas relacionadas con Amazon Location](dev-maplibre.md)

# Cómo utilizar los ayudantes de autenticación
<a name="how-to-auth-helper"></a>

En esta sección se proporciona información adicional sobre ayudantes de autenticación.

## Web
<a name="loc-sdk-auth-web"></a>

Las utilidades de JavaScript autenticación de Amazon Location ayudan a autenticarse cuando se realizan llamadas a la API de Amazon Location Service desde JavaScript aplicaciones. Estas utilidades admiten específicamente la autenticación mediante claves de la API o Amazon Cognito.

**Instalación**
+ Instale esta biblioteca mediante NPM:

  ```
  npm install @aws/amazon-location-utilities-auth-helper
  ```
+ Para usarla directamente en el navegador, incluya lo siguiente en su archivo HTML:

  ```
  <script src="https://cdn.jsdelivr.net/npm/@aws/amazon-location-utilities-auth-helper@1"></script>
  ```

### De uso
<a name="loc-sdk-auth-usage"></a>

Para usar los ayudantes de autenticación, importe la biblioteca y llame a las funciones de utilidad necesarias. Esta biblioteca admite las solicitudes de autenticación de Amazon Location Service SDKs, incluida la versión independiente [Maps](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/geo-maps/), [Places](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/geo-places/) and [Routes](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/geo-routes/) SDKs, así como la representación de mapas con [MapLibre GL](https://github.com/maplibre/maplibre-gl-js) JS.

**Uso con módulos**

En este ejemplo se muestra el uso del SDK de Lugares independiente para realizar una solicitud autenticada con claves de API:

```
npm install @aws-sdk/client-geo-places

import { GeoPlacesClient, GeocodeCommand } from "@aws-sdk/client-geo-places";
import { withAPIKey } from "@aws/amazon-location-utilities-auth-helper";

const authHelper = withAPIKey("<API Key>", "<Region>");
const client = new GeoPlacesClient(authHelper.getClientConfig());

const input = { ... };
const command = new GeocodeCommand(input);
const response = await client.send(command);
```

En este ejemplo se muestra el uso del SDK de Rutas independiente para realizar una solicitud autenticada con claves de API:

```
npm install @aws-sdk/geo-routes-client

import { GeoRoutesClient, CalculateRoutesCommand } from "@aws-sdk/geo-routes-client";
import { withAPIKey } from "@aws/amazon-location-utilities-auth-helper";

const authHelper = withAPIKey("<API Key>", "<Region>");
const client = new GeoRoutesClient(authHelper.getClientConfig());

const input = { ... };
const command = new CalculateRoutesCommand(input);
const response = await client.send(command);
```

En este ejemplo, se usa el SDK de Ubicación con autenticación por clave de API:

```
npm install @aws-sdk/client-location

import { LocationClient, ListGeofencesCommand } from "@aws-sdk/client-location";
import { withAPIKey } from "@aws/amazon-location-utilities-auth-helper";

const authHelper = withAPIKey("<API Key>", "<Region>");
const client = new LocationClient(authHelper.getClientConfig());

const input = { ... };
const command = new ListGeofencesCommand(input);
const response = await client.send(command);
```

**Uso con un navegador**

Se puede acceder a las funciones de utilidad desde el objeto global amazonLocationAuth Helper cuando se utilizan directamente en un entorno de navegador.

En este ejemplo se muestra una solicitud con el cliente de Amazon Location, autenticada mediante claves de API:

```
<script src="https://cdn.jsdelivr.net/npm/@aws/amazon-location-client@1"></script>

const authHelper = amazonLocationClient.withAPIKey("<API Key>", "<Region>");
const client = new amazonLocationClient.GeoRoutesClient(authHelper.getClientConfig());
const input = { ... };
const command = new amazonLocationClient.routes.CalculateRoutesCommand(input);
const response = await client.send(command);
```

En este ejemplo, se muestra la representación de un mapa con MapLibre GL JS, autenticado con una clave de API:

```
<script src="https://cdn.jsdelivr.net/npm/maplibre-gl@5.x"></script>

const apiKey = "<API Key>";
const region = "<Region>";
const styleName = "Standard";

const map = new maplibregl.Map({
  container: "map",
  center: [-123.115898, 49.295868],
  zoom: 10,
  style: `https://maps.geo.${region}.amazonaws.com/v2/styles/${styleName}/descriptor?key=${apiKey}`,
});
```

En este ejemplo, se muestra la representación de un mapa con MapLibre GL JS mediante Amazon Cognito:

```
<script src="https://cdn.jsdelivr.net/npm/maplibre-gl@5.x"></script>
<script src="https://cdn.jsdelivr.net/npm/@aws/amazon-location-utilities-auth-helper@1"></script>

const identityPoolId = "<Identity Pool ID>";
const authHelper = await amazonLocationAuthHelper.withIdentityPoolId(identityPoolId);

const map = new maplibregl.Map({
  container: "map",
  center: [-123.115898, 49.295868],
  zoom: 10,
  style: `https://maps.geo.${region}.amazonaws.com/v2/styles/${styleName}/descriptor`,
  ...authHelper.getMapAuthenticationOptions(),
});
```

**Uso alternativo con identidades autenticadas**

Puede modificar la función de withIdentityPool identificación para incluir parámetros personalizados para las identidades autenticadas:

```
const userPoolId = "<User Pool ID>";

const authHelper = await amazonLocationAuthHelper.withIdentityPoolId(identityPoolId, {
  logins: {
    [`cognito-idp.${region}.amazonaws.com/${userPoolId}`]: "cognito-id-token"
  }
});
```

## iOS
<a name="loc-sdk-auth-ios"></a>

El SDK de autenticación móvil de Amazon Location Service para iOS ayuda a autenticar las solicitudes a Amazon Location Service APIs desde aplicaciones iOS. Admite específicamente la autenticación mediante claves de API o Amazon Cognito.

**Instalación**
+ Abra Xcode y vaya a **Archivo > Agregar dependencia de paquete**.
+ Escribe la URL del paquete ([https://github.com/aws-geospatial/amazon-location-mobile-auth-sdk-ios/](https://github.com/aws-geospatial/amazon-location-mobile-auth-sdk-ios/)) en la barra de búsqueda y pulsa Entrar.
+ **Seleccione el paquete "amazon-location-mobile-auth-sdk-ios» y haga clic en Add Package.**
+ Elija el producto del paquete «AmazonLocationiOSAuthSDK» y haga clic en **Add Package**.

### De uso
<a name="loc-sdk-auth-usage"></a>

Tras instalar la biblioteca, utilice la clase `AuthHelper` para configurar los ajustes del cliente para las claves de la API o Amazon Cognito.

**Claves de API**

A continuación, se muestra un ejemplo con el SDK de Lugares independiente con autenticación de clave de la API:

```
import AmazonLocationiOSAuthSDK
import AWSGeoPlaces

func geoPlacesExample() {
    let apiKey = "<API key>"
    let region = "<Region>"

    let authHelper = try await AuthHelper.withApiKey(apiKey: apiKey, region: region)
    let client: GeoPlacesClient = GeoPlacesClient(config: authHelper.getGeoPlacesClientConfig())

    let input = AWSGeoPlaces.SearchTextInput(
        biasPosition: [-97.7457518, 30.268193],
        queryText: "tacos"
    )

    let output = try await client.searchText(input: input)
}
```

A continuación, se muestra un ejemplo con el SDK de Rutas independiente con autenticación de clave de la API:

```
import AmazonLocationiOSAuthSDK
import AWSGeoRoutes

func geoRoutesExample() {
    let apiKey = "<API key>"
    let region = "<Region>"

    let authHelper = try await AuthHelper.withApiKey(apiKey: apiKey, region: region)
    let client: GeoRoutesClient = GeoRoutesClient(config: authHelper.getGeoRoutesClientConfig())

    let input = AWSGeoRoutes.CalculateRoutesInput(
        destination: [-123.1651031, 49.2577281],
        origin: [-97.7457518, 30.268193]
    )

    let output = try await client.calculateRoutes(input: input)
}
```

A continuación, se muestra un ejemplo de cómo usar el SDK de Ubicación con autenticación de clave de la API:

```
import AmazonLocationiOSAuthSDK
import AWSLocation

func locationExample() {
    let apiKey = "<API key>"
    let region = "<Region>"

    let authHelper = try await AuthHelper.withApiKey(apiKey: apiKey, region: region)
    let client: LocationClient = LocationClient(config: authHelper.getLocationClientConfig())

    let input = AWSLocation.ListGeofencesInput(
        collectionName: "<Collection name>"
    )

    let output = try await client.listGeofences(input: input)
}
```

A continuación, se muestra un ejemplo de cómo usar el SDK de Lugares independiente con Amazon Cognito:

```
import AmazonLocationiOSAuthSDK
import AWSGeoPlaces

func geoPlacesExample() {
    let identityPoolId = "<Identity Pool ID>"

    let authHelper = try await AuthHelper.withIdentityPoolId(identityPoolId: identityPoolId)
    let client: GeoPlacesClient = GeoPlacesClient(config: authHelper.getGeoPlacesClientConfig())

    let input = AWSGeoPlaces.SearchTextInput(
        biasPosition: [-97.7457518, 30.268193],
        queryText: "tacos"
    )

    let output = try await client.searchText(input: input)
}
```

A continuación, se muestra un ejemplo de cómo usar el SDK de Rutas independiente con Amazon Cognito:

```
import AmazonLocationiOSAuthSDK
import AWSGeoRoutes

func geoRoutesExample() {
    let identityPoolId = "<Identity Pool ID>"

    let authHelper = try await AuthHelper.withIdentityPoolId(identityPoolId: identityPoolId)
    let client: GeoRoutesClient = GeoRoutesClient(config: authHelper.getGeoRoutesClientConfig())

    let input = AWSGeoRoutes.CalculateRoutesInput(
        destination: [-123.1651031, 49.2577281],
        origin: [-97.7457518, 30.268193]
    )

    let output = try await client.calculateRoutes(input: input)
}
```

A continuación, se muestra un ejemplo de cómo usar el SDK de Ubicación con Amazon Cognito:

```
import AmazonLocationiOSAuthSDK
import AWSLocation

func locationExample() {
    let identityPoolId = "<Identity Pool ID>"

    let authHelper = try await AuthHelper.withIdentityPoolId(identityPoolId: identityPoolId)
    let client: LocationClient = LocationClient(config: authHelper.getLocationClientConfig())

    let input = AWSLocation.ListGeofencesInput(
        collectionName: "<Collection name>"
    )

    let output = try await client.listGeofences(input: input)
}
```

## Android
<a name="loc-sdk-auth-android"></a>

El SDK de autenticación móvil de Amazon Location Service para Android le ayuda a autenticar las solicitudes a Amazon Location Service APIs desde aplicaciones de Android y, en concreto, admite la autenticación mediante Amazon Cognito.

**Instalación**
+ Este SDK de autenticación funciona con el SDK general de AWS Kotlin. Ambos SDKs se publican en Maven Central. Compruebe la versión más reciente del [SDK de autenticación](https://mvnrepository.com/artifact/software.amazon.location/auth) en Maven Central.
+ Agregue las siguientes líneas a la sección de dependencias del archivo `build.gradle` en Android Studio:

  ```
  implementation("software.amazon.location:auth:1.1.0")
  implementation("org.maplibre.gl:android-sdk:11.5.2")
  implementation("com.squareup.okhttp3:okhttp:4.12.0")
  ```
+ Para los mapas, lugares y rutas independientes SDKs, añada las siguientes líneas:

  ```
  implementation("aws.sdk.kotlin:geomaps:1.3.65")
  implementation("aws.sdk.kotlin:geoplaces:1.3.65")
  implementation("aws.sdk.kotlin:georoutes:1.3.65")
  ```
+ Para el SDK de ubicación consolidado que incluye geocercado y seguimiento, agregue la siguiente línea:

  ```
  implementation("aws.sdk.kotlin:location:1.3.65")
  ```

### De uso
<a name="loc-sdk-auth-usage"></a>

Importe las siguientes clases a su código:

```
// For the standalone Maps, Places, and Routes SDKs
import aws.sdk.kotlin.services.geomaps.GeoMapsClient
import aws.sdk.kotlin.services.geoplaces.GeoPlacesClient
import aws.sdk.kotlin.services.georoutes.GeoRoutesClient

// For the consolidated Location SDK
import aws.sdk.kotlin.services.location.LocationClient

import software.amazon.location.auth.AuthHelper
import software.amazon.location.auth.LocationCredentialsProvider
import software.amazon.location.auth.AwsSignerInterceptor
import org.maplibre.android.module.http.HttpRequestUtil
import okhttp3.OkHttpClient
```

Puedes crear una `AuthHelper` y usarla con el SDK de AWS Kotlin:

**Ejemplo: proveedor de credenciales con ID de grupo de identidades**

```
private suspend fun exampleCognitoLogin() {
    val authHelper = AuthHelper.withCognitoIdentityPool("MY-COGNITO-IDENTITY-POOL-ID", applicationContext)
    
    var geoMapsClient = GeoMapsClient(authHelper?.getGeoMapsClientConfig())
    var geoPlacesClient = GeoPlacesClient(authHelper?.getGeoPlacesClientConfig())
    var geoRoutesClient = GeoRoutesClient(authHelper?.getGeoRoutesClientConfig())
    
    var locationClient = LocationClient(authHelper?.getLocationClientConfig())
}
```

**Ejemplo: proveedor de credenciales con proveedor de credenciales personalizado**

```
private suspend fun exampleCustomCredentialLogin() {
    var authHelper = AuthHelper.withCredentialsProvider(MY-CUSTOM-CREDENTIAL-PROVIDER, "MY-AWS-REGION", applicationContext)

    var geoMapsClient = GeoMapsClient(authHelper?.getGeoMapsClientConfig())
    var geoPlacesClient = GeoPlacesClient(authHelper?.getGeoPlacesClientConfig())
    var geoRoutesClient = GeoRoutesClient(authHelper?.getGeoRoutesClientConfig())
    
    var locationClient = LocationClient(authHelper?.getLocationClientConfig())
}
```

**Ejemplo: proveedor de credenciales con clave de la API**

```
private suspend fun exampleApiKeyLogin() {
    var authHelper = AuthHelper.withApiKey("MY-API-KEY", "MY-AWS-REGION", applicationContext)

    var geoMapsClient = GeoMapsClient(authHelper?.getGeoMapsClientConfig())
    var geoPlacesClient = GeoPlacesClient(authHelper?.getGeoPlacesClientConfig())
    var geoRoutesClient = GeoRoutesClient(authHelper?.getGeoRoutesClientConfig())
    
    var locationClient = LocationClient(authHelper?.getLocationClientConfig())
}
```

Puedes usarlo `LocationCredentialsProvider` para cargar el MapLibre mapa. A continuación se muestra un ejemplo:

```
HttpRequestUtil.setOkHttpClient(
    OkHttpClient.Builder()
        .addInterceptor(
            AwsSignerInterceptor(
                "geo",
                "MY-AWS-REGION",
                locationCredentialsProvider,
                applicationContext
            )
        )
        .build()
)
```

Utilice los clientes creados para realizar llamadas a Amazon Location Service. A continuación, se muestra un ejemplo que busca lugares cercanos a una latitud y longitud especificadas:

```
val suggestRequest = SuggestRequest {
       biasPosition = listOf(-97.718833, 30.405423)
       maxResults = MAX_RESULT
       language = "PREFERRED-LANGUAGE"
   }
val nearbyPlaces = geoPlacesClient.suggest(suggestRequest)
```

# Utilice el complemento Amazon Location MapLibre Geocoder GL
<a name="dev-maplibre-geocoder"></a>

El complemento Amazon Location MapLibre geocoder está diseñado para facilitar la incorporación de la funcionalidad Amazon Location en sus JavaScript aplicaciones cuando trabaja con la representación de mapas y la geocodificación mediante la biblioteca. [maplibre-gl-geocoder](https://github.com/maplibre/maplibre-gl-geocoder)

## Instalación
<a name="geocoder-installation"></a>

Instale el complemento Amazon Location MapLibre Geocoder desde NPM para usarlo con módulos. Escriba este comando:

```
npm install @aws/amazon-location-for-maplibre-gl-geocoder
```

Puede importar también archivos HTML y CSS para usarlos directamente en el navegador con un script:

```
<script src="https://cdn.jsdelivr.net/npm/@aws/amazon-location-for-maplibre-gl-geocoder@2"></script>
<link
  href="https://cdn.jsdelivr.net/npm/@aws/amazon-location-for-maplibre-gl-geocoder@2/dist/amazon-location-for-mlg-styles.css"
  rel="stylesheet"
/>
```

## Uso con módulo: SDK independiente GeoPlaces
<a name="geocoder-module"></a>

En este ejemplo, se utiliza el [AWS SDK de la JavaScript versión 3](https://github.com/aws/aws-sdk-js-v3) para proporcionar un GeoPlacesClient elemento a la biblioteca y [AuthHelper](https://github.com/aws-geospatial/amazon-location-utilities-auth-helper-js)para autenticar el. GeoPlacesClient Lo habilita todo APIs para el geocodificador.

```
// Import MapLibre GL JS
import maplibregl from "maplibre-gl";
// Import from the AWS JavaScript SDK V3
import { GeoPlacesClient } from "@aws-sdk/client-geo-places";
// Import the utility functions
import { withAPIKey } from "@aws/amazon-location-utilities-auth-helper";
// Import the AmazonLocationMaplibreGeocoder
import {
  buildAmazonLocationMaplibreGeocoder,
  AmazonLocationMaplibreGeocoder,
} from "@aws/amazon-location-for-maplibre-gl-geocoder";

const apiKey = "<API Key>";
const mapName = "Standard";
const region = "<Region>"; // region containing Amazon Location API Key

// Create an authentication helper instance using an API key and region
const authHelper = await withAPIKey(apiKey, region);

const client = new GeoPlacesClient(authHelper.getClientConfig());

// Render the map
const map = new maplibregl.Map({
  container: "map",
  center: [-123.115898, 49.295868],
  zoom: 10,
  style: `https://maps.geo.${region}.amazonaws.com/v2/styles/${mapStyle}/descriptor?key=${apiKey}`,
});

// Gets an instance of the AmazonLocationMaplibreGeocoder Object.
const amazonLocationMaplibreGeocoder = buildAmazonLocationMaplibreGeocoder(client, { enableAll: true });

// Now we can add the Geocoder to the map.
map.addControl(amazonLocationMaplibreGeocoder.getPlacesGeocoder());
```

## Uso con un navegador: SDK independiente GeoPlaces
<a name="geocoder-browser"></a>

En este ejemplo, se utiliza el cliente de Amazon Location para realizar una solicitud que se autentica mediante una clave de API.

**nota**  
Algunos de estos ejemplos utilizan la ubicación de Amazon GeoPlacesClient. Este cliente se basa en el [AWS SDK de la JavaScript versión 3](https://github.com/aws/aws-sdk-js-v3) y permite realizar llamadas a Amazon Location mediante un script al que se hace referencia en un archivo HTML.

Incluya lo siguiente en un archivo HTML:

```
<!-- Import the Amazon Location For Maplibre Geocoder -->
<script src="https://cdn.jsdelivr.net/npm/@aws/amazon-location-for-maplibre-gl-geocoder@2"></script>
<link
  href="https://cdn.jsdelivr.net/npm/@aws/amazon-location-for-maplibre-gl-geocoder@2/dist/amazon-location-for-mlg-styles.css"
  rel="stylesheet"
/>
<!-- Import the Amazon GeoPlacesClient -->
<script src="https://cdn.jsdelivr.net/npm/@aws/amazon-location-client@1"></script>
```

Incluya lo siguiente en un JavaScript archivo:

```
const apiKey = "<API Key>";
const mapStyle = "Standard";
const region = "<Region>"; // region containing Amazon Location API key

// Create an authentication helper instance using an API key and region
const authHelper = await amazonLocationClient.withAPIKey(apiKey, region);

const client = new amazonLocationClient.GeoPlacesClient(authHelper.getClientConfig());

// Render the map
const map = new maplibregl.Map({
  container: "map",
  center: [-123.115898, 49.295868],
  zoom: 10,
  style: `https://maps.geo.${region}.amazonaws.com/v2/styles/${mapStyle}/descriptor?key=${apiKey}`,
});

// Initialize the AmazonLocationMaplibreGeocoder object
const amazonLocationMaplibreGeocoderObject = amazonLocationMaplibreGeocoder.buildAmazonLocationMaplibreGeocoder(
  client,
  { enableAll: true },
);

// Use the AmazonLocationWithMaplibreGeocoder object to add a geocoder to the map.
map.addControl(amazonLocationMaplibreGeocoderObject.getPlacesGeocoder());
```

## Funciones
<a name="geocoder-functions"></a>

A continuación se enumeran las funciones que se utilizan en el complemento Amazon Location MapLibre Geocoder:
+ `buildAmazonLocationMaplibreGeocoder`

  Esta clase crea una instancia del `AmazonLocationMaplibreGeocder`, que es el punto de entrada para las demás llamadas.

  Uso de llamadas a la API de `GeoPlacesClient` independientes (el cliente es una instancia de `GeoPlacesClient`):

  ```
  const amazonLocationMaplibreGeocoder = buildAmazonLocationMaplibreGeocoder(client, { enableAll: true });
  ```

  Uso de llamadas a la API de `LocationClient` consolidadas (el cliente es una instancia de `LocationClient`):

  ```
  const amazonLocationMaplibreGeocoder = buildAmazonLocationMaplibreGeocoder(client, {
    enableAll: true,
    placesIndex: placeIndex,
  });
  ```
+ `getPlacesGeocoder`

  Devuelve un ready-to-use IControl objeto que se puede añadir directamente a un mapa.

  ```
  const geocoder = getPlacesGeocoder();
  
  // Initialize map see: <insert link to initializing a map instance here>
  let map = await initializeMap();
  
  // Add the geocoder to the map.
  map.addControl(geocoder);
  ```

# Cómo usar los SDK de seguimiento
<a name="dev-tracking-sdk"></a>

En este tema se proporciona información acerca de cómo utilizar los SDK de seguimiento.

# iOS
<a name="loc-mobile-tracking-ios"></a>

El SDK de rastreo en móviles de Amazon Location proporciona utilidades que ayudan a autenticar fácilmente, capturar las posiciones de los dispositivos y enviar actualizaciones de posición a los rastreadores de Amazon Location. El SDK admite el filtrado local de las actualizaciones de ubicación con intervalos de actualización configurables. Esto reduce los costes de datos y optimiza la conectividad intermitente de las aplicaciones iOS.

El SDK de rastreo para iOS está disponible en GitHub: [Amazon Location Mobile Tracking SDK for iOS](https://github.com/aws-geospatial/amazon-location-mobile-tracking-sdk-ios).

En esta sección se tratan los siguientes temas del SDK de Amazon Location de rastreo en móviles para iOS:

**Topics**
+ [Instalación](#loc-mobile-tracking-install-ios)
+ [De uso](#loc-mobile-tracking-usage-ios)
+ [Filtros](#loc-mobile-tracking-ios-filters)
+ [Características de rastreo en móviles del SDK para iOS Mobile](#loc-mobile-tracking-functions)
+ [Ejemplos](#loc-mobile-tracking-example-ios)

## Instalación
<a name="loc-mobile-tracking-install-ios"></a>

Utilice el siguiente procedimiento para instalar el SDK de rastreo en móviles para iOS:

1. En su proyecto de Xcode, vaya a **Archivo** y seleccione **Agregar dependencias de paquete**.

1. Escribe la siguiente URL: [https://github.com/aws-geospatial/amazon-location-mobile-tracking-sdk-ios/](https://github.com/aws-geospatial/amazon-location-mobile-tracking-sdk-ios/) en la barra de búsqueda y pulsa la tecla Intro.

1. Seleccione el paquete `amazon-location-mobile-tracking-sdk-ios` y haga clic en **Agregar paquete**.

1. Seleccione el producto del paquete `AmazonLocationiOSTrackingSDK` y haga clic en **Agregar paquete**.

## De uso
<a name="loc-mobile-tracking-usage-ios"></a>

En el siguiente procedimiento se muestra cómo crear un ayudante de autenticación con las credenciales de Amazon Cognito.

1. Tras instalar la biblioteca, debe agregar una o ambas descripciones al archivo `info.plist`:

   ```
   Privacy - Location When In Use Usage Description
   Privacy - Location Always and When In Use Usage Description
   ```

1. A continuación, importe el archivo a su clase: AuthHelper 

   ```
   import AmazonLocationiOSAuthSDKimport AmazonLocationiOSTrackingSDK
   ```

1. A continuación, creará un `AuthHelper` objeto y lo utilizará con el AWS SDK mediante la creación de un ayudante de autenticación con las credenciales de Amazon Cognito.

   ```
   let authHelper = AuthHelper()
   let locationCredentialsProvider = authHelper.authenticateWithCognitoUserPool(identityPoolId: "My-Cognito-Identity-Pool-Id", region: "My-region") //example: us-east-1
   let locationTracker = LocationTracker(provider: locationCredentialsProvider, trackerName: "My-tracker-name")
   
   // Optionally you can set ClientConfig with your own values in either initialize or in a separate function
   // let trackerConfig = LocationTrackerConfig(locationFilters: [TimeLocationFilter(), DistanceLocationFilter()],
   
        trackingDistanceInterval: 30,
        trackingTimeInterval: 30,
        logLevel: .debug)
   
   // locationTracker = LocationTracker(provider: credentialsProvider, trackerName: "My-tracker-name",config: trackerConfig)
   // locationTracker.setConfig(config: trackerConfig)
   ```

## Filtros
<a name="loc-mobile-tracking-ios-filters"></a>

El SDK de rastreo en móviles de Amazon Location para iOS tiene tres filtros de ubicación integrados.
+ `TimeLocationFilter`: filtra la ubicación actual que se va a cargar en función de un intervalo de tiempo definido.
+ `DistanceLocationFilter`: filtra las actualizaciones de ubicación en función de un umbral de distancia especificado.
+ `AccuracyLocationFilter`: filtra las actualizaciones de ubicación comparando la distancia recorrida desde la última actualización con la precisión de la ubicación actual.

En este ejemplo, se añaden filtros en el `LocationTracker` en el momento de la creación:

```
val config = LocationTrackerConfig(
    trackerName = "MY-TRACKER-NAME",
    logLevel = TrackingSdkLogLevel.DEBUG,
    accuracy = Priority.PRIORITY_HIGH_ACCURACY,
    latency = 1000,
    frequency = 5000,
    waitForAccurateLocation = false,
    minUpdateIntervalMillis = 5000,
    locationFilters = mutableListOf(TimeLocationFilter(), DistanceLocationFilter(), AccuracyLocationFilter())
)

locationTracker = LocationTracker(
    applicationContext,
    locationCredentialsProvider,
    config,
)
```

En este ejemplo se habilita y deshabilita el filtro en el tiempo de ejecución con `LocationTracker`:

```
// To enable the filter
locationTracker?.enableFilter(TimeLocationFilter())

// To disable the filter
locationTracker?.disableFilter(TimeLocationFilter())
```

## Características de rastreo en móviles del SDK para iOS Mobile
<a name="loc-mobile-tracking-functions"></a>

El SDK de rastreo en móviles de Amazon Location para iOS incluye las siguientes características:
+ **Clase**: `LocationTracker`

  `init(provider: LocationCredentialsProvider, trackerName: String, config: LocationTrackerConfig? = nil)`

  Se trata de una función de inicializador para crear un objeto de `LocationTracker`. Requiere instancias de `LocationCredentialsProvider`, `trackerName` y, opcionalmente, una instancia de `LocationTrackingConfig`. Si no se proporciona la configuración, se inicializará con los valores predeterminados.
+ **Clase**: `LocationTracker`

  `setTrackerConfig(config: LocationTrackerConfig)`

  Esto hace que la configuración del rastreador surta efecto en cualquier momento después de la inicialización del rastreador de ubicación.
+ **Clase**: `LocationTracker`

  `getTrackerConfig()`

  Esto hace que la configuración de rastreo de ubicación se use o modifique en su aplicación.

  Devuelve: `LocationTrackerConfig`
+ **Clase**: `LocationTracker`

  `getDeviceId()`

  Obtiene el ID de dispositivo generado por el rastreador de ubicación.

  Devuelve: `String?`
+ **Clase**: `LocationTracker`

  `startTracking()`

  Inicia el proceso de acceder a la ubicación del usuario y enviarla al AWS rastreador.
+ **Clase**: `LocationTracker`

  `resumeTracking()`

  Reanuda el proceso de acceder a la ubicación del usuario y enviarla al AWS rastreador.
+ **Clase**: `LocationTracker`

  `stopTracking()`

  Detiene el proceso de rastreo de la ubicación del usuario.
+ **Clase**: `LocationTracker`

  `startBackgroundTracking(mode: BackgroundTrackingMode)`

  Inicia el proceso de acceder a la ubicación del usuario y enviarla al AWS rastreador mientras la aplicación está en segundo plano. `BackgroundTrackingMode`tiene las siguientes opciones: 
  + `Active:` Esta opción no detiene automáticamente las actualizaciones de ubicación.
  + `BatterySaving:` esta opción detiene automáticamente las actualizaciones de ubicación.
  + `None:` En general, esta opción desactiva las actualizaciones de ubicación en segundo plano.
+ **Clase**: `LocationTracker`

  `resumeBackgroundTracking(mode: BackgroundTrackingMode)`

  Reanuda el proceso de acceder a la ubicación del usuario y enviarla al AWS rastreador mientras la aplicación está en segundo plano.
+ **Clase**: `LocationTracker`

  `stopBackgroundTracking()`

  Detiene el proceso de acceder a la ubicación del usuario y enviarla al AWS rastreador mientras la aplicación está en segundo plano.
+ **Clase**: `LocationTracker`

  `getTrackerDeviceLocation(nextToken: String?, startTime: Date? = nil, endTime: Date? = nil, completion: @escaping (Result<GetLocationResponse, Error>)`

  Recupera las ubicaciones de rastreo subidas para el dispositivo del usuario entre la fecha y la hora de inicio y de finalización.

  Devuelve: `Void`
+ **Clase**: `LocationTrackerConfig`

  `init()`

  Esto inicializa el LocationTrackerConfig con los valores predeterminados.
+ **Clase**: `LocationTrackerConfig`

  `init(locationFilters: [LocationFilter]? = nil, trackingDistanceInterval: Double? = nil, trackingTimeInterval: Double? = nil, trackingAccuracyLevel: Double? = nil, uploadFrequency: Double? = nil, desiredAccuracy: CLLocationAccuracy? = nil, activityType: CLActivityType? = nil, logLevel: LogLevel? = nil)`

  Esto inicializa el `LocationTrackerConfig` con valores de parámetros definidos por el usuario. Si no se proporciona un valor de parámetro, se establecerá en un valor predeterminado.
+ **Clase**: `LocationFilter`

  `shouldUpload(currentLocation: LocationEntity, previousLocation: LocationEntity?, trackerConfig: LocationTrackerConfig)`

  `LocationFilter` es un protocolo que los usuarios pueden implementar para la implementación de sus filtros personalizados. Un usuario tendría que implementar una función de `shouldUpload` para comparar la ubicación anterior con la actual y volver si se debe subir la ubicación actual.

## Ejemplos
<a name="loc-mobile-tracking-example-ios"></a>

En esta sección se detallan ejemplos del uso del SDK de rastreo en móviles de Amazon Location para iOS.

**nota**  
Asegúrese de que los permisos necesarios estén configurados en el archivo de `info.plist`. Son los mismos permisos que se enumeran en la sección [De uso](#loc-mobile-tracking-usage-ios).

El siguiente ejemplo muestra la funcionalidad para rastrear la ubicación del dispositivo y recuperar las ubicaciones rastreadas:

```
Privacy - Location When In Use Usage Description
Privacy - Location Always and When In Use Usage Description
```

Comenzar a rastrear la ubicación:

```
do {
    try locationTracker.startTracking()
    } 
catch TrackingLocationError.permissionDenied {
        // Handle permissionDenied by showing the alert message or opening the app settings
        }
```

Reanudar el rastreo de la ubicación:

```
do { 
    try locationTracker.resumeTracking()
    } 
catch TrackingLocationError.permissionDenied {
    // Handle permissionDenied by showing the alert message or opening the app settings
    }
```

Dejar de rastrear la ubicación:

```
locationTracker.stopTracking()
```

Iniciar el rastreo en segundo plano:

```
do {
    locationTracker.startBackgroundTracking(mode: .Active) // .Active, .BatterySaving, .None
    } 
catch TrackingLocationError.permissionDenied {
   // Handle permissionDenied by showing the alert message or opening the app settings
   }
```

Reanudar el rastreo en segundo plano:

```
do {
    locationTracker.resumeBackgroundTracking(mode: .Active)
    } 
catch TrackingLocationError.permissionDenied {
    // Handle permissionDenied by showing the alert message or opening the app settings
    }
```

Detener el rastreo en segundo plano:

```
locationTracker.stopBackgroundTracking()
```

Recuperar las ubicaciones rastreadas del dispositivo del rastreador:

```
func getTrackingPoints(nextToken: String? = nil) {
let startTime: Date = Date().addingTimeInterval(-86400) // Yesterday's day date and time
let endTime: Date = Date() 
locationTracker.getTrackerDeviceLocation(nextToken: nextToken, startTime: startTime, endTime: endTime, completion: { [weak self] result in
    switch result {
    case .success(let response):
        
        let positions = response.devicePositions
        // You can draw positions on map or use it further as per your requirement

        // If nextToken is available, recursively call to get more data
        if let nextToken = response.nextToken {
            self?.getTrackingPoints(nextToken: nextToken)
        }
    case .failure(let error):
        print(error)
    }
})
}
```

# SDK de rastreo en móviles para Android
<a name="loc-mobile-tracking-android"></a>

El SDK de rastreo en móviles de Amazon Location proporciona utilidades que ayudan a autenticar fácilmente, capturar las posiciones de los dispositivos y enviar actualizaciones de posición a los rastreadores de Amazon Location. El SDK admite el filtrado local de las actualizaciones de ubicación con intervalos de actualización configurables. Esto reduce los costes de datos y optimiza la conectividad intermitente de las aplicaciones Android.

El SDK de rastreo para Android está disponible en GitHub: [Amazon Location Mobile Tracking SDK for Android](https://github.com/aws-geospatial/amazon-location-mobile-tracking-sdk-android). Además, tanto el SDK de autenticación móvil como el AWS SDK están disponibles en el [repositorio de AWS Maven](https://central.sonatype.com/artifact/software.amazon.location/tracking). El SDK de seguimiento de Android está diseñado para funcionar con el AWS SDK general.

En esta sección se tratan los siguientes temas del SDK de Amazon Location de rastreo en móviles para Android:

**Topics**
+ [Instalación](#loc-mobile-tracking-install-android)
+ [De uso](#loc-mobile-tracking-usage-android)
+ [Filtros](#loc-mobile-tracking-android-filters)
+ [Características de rastreo del SDK para móviles de Android](#loc-mobile-tracking-functions)
+ [Ejemplos](#loc-mobile-tracking-example-android)

## Instalación
<a name="loc-mobile-tracking-install-android"></a>

Para instalar el SDK, agregue las siguientes líneas a la sección de dependencias del archivo build.gradle en Android Studio:

```
implementation("software.amazon.location:tracking:0.0.1")
implementation("software.amazon.location:auth:0.0.1")
implementation("com.amazonaws:aws-android-sdk-location:2.72.0")
```

## De uso
<a name="loc-mobile-tracking-usage-android"></a>

Este procedimiento le muestra cómo usar el SDK para autenticar y crear el objeto de `LocationTracker`:

**nota**  
Este procedimiento supone que ha importado la biblioteca mencionada en la sección [Instalación](#loc-mobile-tracking-install-android).

1. Importe las siguientes clases a su código:

   ```
   import software.amazon.location.tracking.LocationTracker
   import software.amazon.location.tracking.config.LocationTrackerConfig
   import software.amazon.location.tracking.util.TrackingSdkLogLevel
   import com.amazonaws.services.geo.AmazonLocationClient
   import software.amazon.location.auth.AuthHelper
   import software.amazon.location.auth.LocationCredentialsProvider
   ```

1. A continuación, cree un `AuthHelper`, ya que se necesita el parámetro de `LocationCredentialsProvider` para crear un objeto de `LocationTracker`:

   ```
   // Create an authentication helper using credentials from Amazon Cognito
   val authHelper = AuthHelper(applicationContext)
   val locationCredentialsProvider : LocationCredentialsProvider = authHelper.authenticateWithCognitoIdentityPool("My-Cognito-Identity-Pool-Id")
   ```

1. Ahora, use `LocationCredentialsProvider` y `LocationTrackerConfig` para crear un objeto de `LocationTracker`:

   ```
   val config = LocationTrackerConfig(
       trackerName = "MY-TRACKER-NAME",
       logLevel = TrackingSdkLogLevel.DEBUG,
       accuracy = Priority.PRIORITY_HIGH_ACCURACY,
       latency = 1000,
       frequency = 5000,
       waitForAccurateLocation = false,
       minUpdateIntervalMillis = 5000,
   )
   locationTracker = LocationTracker(
       applicationContext,
       locationCredentialsProvider,
       config,
   )
   ```

## Filtros
<a name="loc-mobile-tracking-android-filters"></a>

El SDK de rastreo en móviles de Amazon Location para Android tiene tres filtros de ubicación integrados.
+ `TimeLocationFilter`: filtra la ubicación actual que se va a cargar en función de un intervalo de tiempo definido.
+ `DistanceLocationFilter`: filtra las actualizaciones de ubicación en función de un umbral de distancia especificado.
+ `AccuracyLocationFilter`: filtra las actualizaciones de ubicación comparando la distancia recorrida desde la última actualización con la precisión de la ubicación actual.

En este ejemplo, se añaden filtros en el `LocationTracker` en el momento de la creación:

```
val config = LocationTrackerConfig(
    trackerName = "MY-TRACKER-NAME",
    logLevel = TrackingSdkLogLevel.DEBUG,
    accuracy = Priority.PRIORITY_HIGH_ACCURACY,
    latency = 1000,
    frequency = 5000,
    waitForAccurateLocation = false,
    minUpdateIntervalMillis = 5000,
    locationFilters = mutableListOf(TimeLocationFilter(), DistanceLocationFilter(), AccuracyLocationFilter())
)
locationTracker = LocationTracker(
    applicationContext,
    locationCredentialsProvider,
    config,
)
```

En este ejemplo se habilita y deshabilita el filtro en el tiempo de ejecución con `LocationTracker`:

```
// To enable the filter
locationTracker?.enableFilter(TimeLocationFilter())

// To disable the filter
locationTracker?.disableFilter(TimeLocationFilter())
```

## Características de rastreo del SDK para móviles de Android
<a name="loc-mobile-tracking-functions"></a>

El SDK de rastreo en móviles de Amazon Location para Android incluye las siguientes características:
+ **Clase**: `LocationTracker`

  `constructor(context: Context,locationCredentialsProvider: LocationCredentialsProvider,trackerName: String)`, o bien `constructor(context: Context,locationCredentialsProvider: LocationCredentialsProvider,clientConfig: LocationTrackerConfig)`

  Se trata de una función de inicializador para crear un objeto de `LocationTracker`. Requiere instancias de `LocationCredentialsProvider`, `trackerName` y, opcionalmente, una instancia de `LocationTrackingConfig`. Si no se proporciona la configuración, se inicializará con los valores predeterminados.
+ **Clase**: `LocationTracker`

  `start(locationTrackingCallback: LocationTrackingCallback)`

  Inicia el proceso de acceder a la ubicación del usuario y enviarla a un rastreador de Amazon Location.
+ **Clase**: `LocationTracker`

  `isTrackingInForeground()`

  Comprueba si el rastreo de la ubicación está en curso actualmente.
+ **Clase**: `LocationTracker`

  `stop()`

  Detiene el proceso de rastreo de la ubicación del usuario.
+ **Clase**: `LocationTracker`

  `startTracking()`

  Inicia el proceso de acceder a la ubicación del usuario y enviarla al AWS rastreador.
+ **Clase**: `LocationTracker`

  `startBackground(mode: BackgroundTrackingMode, serviceCallback: ServiceCallback)`

  Inicia el proceso de acceder a la ubicación del usuario y enviarla al AWS rastreador mientras la aplicación está en segundo plano. `BackgroundTrackingMode`tiene las siguientes opciones:
  + `ACTIVE_TRACKING`: esta opción realiza un rastreo activo de las actualizaciones de ubicación de un usuario. 
  + `BATTERY_SAVER_TRACKING`: esta opción rastrea las actualizaciones de ubicación del usuario cada 15 minutos.
+ **Clase**: `LocationTracker`

  `stopBackgroundService()`

  Detiene el proceso de acceder a la ubicación del usuario y enviarla al AWS rastreador mientras la aplicación está en segundo plano.
+ **Clase**: `LocationTracker`

  `getTrackerDeviceLocation()`

  Recupera la ubicación del dispositivo desde Amazon Location Services. 
+ **Clase**: `LocationTracker`

  `getDeviceLocation(locationTrackingCallback: LocationTrackingCallback?)`

  Recupera la ubicación actual del dispositivo del cliente del proveedor de ubicaciones fusionadas y la carga en el rastreador de Amazon Location.
+ **Clase**: `LocationTracker`

  `uploadLocationUpdates(locationTrackingCallback: LocationTrackingCallback?)`

  Sube la ubicación del dispositivo a Amazon Location Services después de filtrarla en función de los filtros de ubicación configurados.
+ **Clase**: `LocationTracker`

  `enableFilter(filter: LocationFilter)`

  Habilita un filtro de ubicación concreto.
+ **Clase**: `LocationTracker`

  `checkFilterIsExistsAndUpdateValue(filter: LocationFilter)`

  Deshabilita un filtro de ubicación concreto.
+ **Clase**: `LocationTrackerConfig`

  `LocationTrackerConfig( // Required var trackerName: String, // Optional var locationFilters: MutableList = mutableListOf( TimeLocationFilter(), DistanceLocationFilter(), ), var logLevel: TrackingSdkLogLevel = TrackingSdkLogLevel.DEBUG, var accuracy: Int = Priority.PRIORITY_HIGH_ACCURACY, var latency: Long = 1000, var frequency: Long = 1500, var waitForAccurateLocation: Boolean = false, var minUpdateIntervalMillis: Long = 1000, var persistentNotificationConfig: NotificationConfig = NotificationConfig()) `

  Esto inicializa el `LocationTrackerConfig` con valores de parámetros definidos por el usuario. Si no se proporciona un valor de parámetro, se establecerá en un valor predeterminado.
+ **Clase**: `LocationFilter`

  `shouldUpload(currentLocation: LocationEntry, previousLocation: LocationEntry?): Boolean`

  `LocationFilter` es un protocolo que los usuarios pueden implementar para la implementación de sus filtros personalizados. Debe implementar la función `shouldUpload` para comparar la ubicación anterior y actual, y devolver si se debe subir la ubicación actual.

## Ejemplos
<a name="loc-mobile-tracking-example-android"></a>

En el siguiente ejemplo de código se muestra la funcionalidad del SDK de rastreo en móviles.

En este ejemplo, se utiliza el `LocationTracker` para iniciar y detener el rastreo en segundo plano:

```
// For starting the location tracking
locationTracker?.startBackground(
BackgroundTrackingMode.ACTIVE_TRACKING,
object : ServiceCallback {
    override fun serviceStopped() {
        if (selectedTrackingMode == BackgroundTrackingMode.ACTIVE_TRACKING) {
            isLocationTrackingBackgroundActive = false
        } else {
            isLocationTrackingBatteryOptimizeActive = false
        }
    }
},
)

// For stopping the location tracking
locationTracker?.stopBackgroundService()
```

# Uso de las herramientas de MapLibre y bibliotecas relacionadas con Amazon Location
<a name="dev-maplibre"></a>

[MapLibre](https://maplibre.org/) es principalmente un motor de renderizado para mostrar mapas en una aplicación web o móvil. Sin embargo, también incluye soporte para complementos y proporciona funciones para trabajar con otros aspectos de Amazon Location. A continuación, se describen las herramientas que puede utilizar en función del área o ubicación con la que desee trabajar.

**nota**  
Para utilizar cualquier aspecto de Amazon Location, instale el [SDK de AWS para el lenguaje que desee utilizar](dev-by-language.md).
+ **Mapas**

  Para mostrar mapas en su aplicación, necesita un motor de renderizado de mapas que utilice los datos proporcionados por Amazon Location y los dibuje en la pantalla. Los motores de renderización de mapas también ofrecen la funcionalidad de desplazar y ampliar el mapa, o de agregar marcadores o chinchetas y otras anotaciones al mapa.

  Amazon Location Service recomienda renderizar los mapas con el motor de renderizado [MapLibre](https://github.com/maplibre/maplibre-gl-js). MapLibre GL JS es un motor para mostrar mapas en JavaScript, mientras que MapLibre Native proporciona mapas para iOS o Android.

  MapLibre también tiene un ecosistema de complementos para ampliar la funcionalidad principal. Para obtener más información, visite [https://maplibre.org/maplibre-gl-js/docs/plugins/](https://maplibre.org/maplibre-gl-js/docs/plugins/).
+ **Búsqueda de lugares**

  Para facilitar la creación de una interfaz de usuario de búsqueda, puede utilizar el [geocodificador MapLibre](https://github.com/maplibre/maplibre-gl-geocoder) para web (las aplicaciones de Android pueden utilizar el [complemento Android Places](https://github.com/maplibre/maplibre-plugins-android/tree/master/plugin-places)).

  Utilice [Amazon Location para la biblioteca de geocodificador MapLibre](https://github.com/aws-geospatial/amazon-location-for-maplibre-gl-geocoder?tab=readme-ov-file) a fin de simplificar el proceso de uso de Amazon Location con `amazon-location-for-maplibre-gl-geocoder` en aplicaciones de JavaScript.

  Para obtener más información, consulte [Utilice el complemento Amazon Location MapLibre Geocoder GL](dev-maplibre-geocoder.md).
+ **Rutas**
+ **Geocercas y rastreadores**

  MapLibre no dispone de ninguna representación ni herramientas específicas para las geocercas y el rastreo, pero puede utilizar la función de renderizado y los [complementos](https://maplibre.org/maplibre-gl-js/docs/plugins/) para mostrar las geocercas y los dispositivos rastreados en el mapa.

  Los dispositivos que se están rastreando pueden usar [MQTT](tracking-using-mqtt.md) o enviar actualizaciones manualmente a Amazon Location Service. Se puede responder a los eventos de Geofence utilizando [AWS Lambda](https://docs.aws.amazon.com/lambda/).

Hay muchas librerías de código abierto disponibles para proporcionar funciones adicionales a Amazon Location Service, por ejemplo, [Turf](https://github.com/Turfjs/turf), que proporciona funciones de análisis espacial.

Muchas librerías utilizan los datos con formato de estándar abierto [GeoJSON](https://geojson.org/). Amazon Location Service proporciona una biblioteca para convertir las respuestas en GeoJSON para el uso en aplicaciones de JavaScript. Para obtener más información, consulte [SDKs y marcos para Amazon Location Service](dev-sdks.md). 

# SDK por lenguaje
<a name="dev-by-language"></a>

**Versiones del SDK**  
Le recomendamos que utilice la versión más reciente del SDK de AWS y cualquier otro SDK que utilice en sus proyectos y que mantenga los SDK actualizados. El SDK de AWS le proporciona las funciones y funcionalidades más recientes, así como actualizaciones de seguridad. Para encontrar la versión más reciente del SDK de AWS para JavaScript, por ejemplo, consulte el tema de [Instalación en el navegador](https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/index.html#In_the_Browser) en la documentación del *SDK de AWS para JavaScript*.

En las tablas siguientes se proporciona información sobre los AWS SDK y las versiones del marco de renderización de mapas para lenguajes y marcos, por tipo de aplicación: aplicación web, móvil o de backend.

------
#### [ Web frontend ]

Los siguientes AWS SDK y las versiones del marco de renderización de mapas están disponibles para el desarrollo de aplicaciones de frontend web.


| Lenguaje / marco | AWS SDK | Marco de renderización de mapas | 
| --- | --- | --- | 
|  **Totalmente compatible**  | 
|  JavaScript  |  [https://aws.amazon.com/sdk-for-javascript/](https://aws.amazon.com/sdk-for-javascript/)  |  [https://github.com/maplibre/maplibre-gl-js](https://github.com/maplibre/maplibre-gl-js)  | 
|  ReactJS  |  [https://aws.amazon.com/sdk-for-javascript/](https://aws.amazon.com/sdk-for-javascript/)  |  [https://github.com/maplibre/maplibre-react-native](https://github.com/maplibre/maplibre-react-native)  | 
|  TypeScript  |  [https://aws.amazon.com/sdk-for-javascript/](https://aws.amazon.com/sdk-for-javascript/)  |  [https://github.com/maplibre/maplibre-gl-js](https://github.com/maplibre/maplibre-gl-js)  | 
|  **Compatible parcialmente**  | 
|  Flutter  |  [https://docs.amplify.aws/start/q/integration/flutter/](https://docs.amplify.aws/start/q/integration/flutter/) Flutter aún no es totalmente compatible con AWS, pero Amplify ofrece un soporte limitado.  |  [https://github.com/maplibre/flutter-maplibre-gl](https://github.com/maplibre/flutter-maplibre-gl) La librería Flutter de MapLibre se considera experimental.  | 
|  Node.js  |  [https://aws.amazon.com/sdk-for-javascript/](https://aws.amazon.com/sdk-for-javascript/)  | [https://github.com/maplibre/maplibre-native](https://github.com/maplibre/maplibre-native) [https://www.npmjs.com/package/@maplibre/maplibre-gl-native](https://www.npmjs.com/package/@maplibre/maplibre-gl-native) | 
|  PHP  |  [https://aws.amazon.com/sdk-for-php/](https://aws.amazon.com/sdk-for-php/)  |  MapLibre no admite PHP.  | 

------
#### [ Mobile frontend ]

Los siguientes AWS SDK y las versiones del marco de renderización de mapas están disponibles para el desarrollo de aplicaciones de frontend móvil.


| Lenguaje / marco | AWS SDK | Marco de renderización de mapas | 
| --- | --- | --- | 
|  **Totalmente compatible**  | 
|  Java  |  [https://aws.amazon.com/sdk-for-java/](https://aws.amazon.com/sdk-for-java/)  |  [https://github.com/maplibre/maplibre-native](https://github.com/maplibre/maplibre-native)  | 
|  Kotlin  |  [https://aws.amazon.com/sdk-for-kotlin/](https://aws.amazon.com/sdk-for-kotlin/)  SDK de autenticación en móviles de Amazon Location Service para Android: [https://github.com/aws-geospatial/amazon-location-mobile-auth-sdk-android](https://github.com/aws-geospatial/amazon-location-mobile-auth-sdk-android) SDK de rastreo en móviles de Amazon Location Service para Android: [https://github.com/aws-geospatial/amazon-location-mobile-tracking-sdk-android](https://github.com/aws-geospatial/amazon-location-mobile-tracking-sdk-android)  |  [https://github.com/maplibre/maplibre-native](https://github.com/maplibre/maplibre-native) Requiere enlaces personalizados, ya que MapLibre está basado en Java.  | 
|  ObjectiveC  |  [https://github.com/aws-amplify/aws-sdk-ios](https://github.com/aws-amplify/aws-sdk-ios)  |  [https://github.com/maplibre/maplibre-native](https://github.com/maplibre/maplibre-native)  | 
|  React Native  |  [https://aws.amazon.com/sdk-for-javascript/](https://aws.amazon.com/sdk-for-javascript/)  |  [https://github.com/maplibre/maplibre-react-native](https://github.com/maplibre/maplibre-react-native)  | 
|  Swift  |  [https://aws.amazon.com/sdk-for-swift/](https://aws.amazon.com/sdk-for-swift/) SDK de autenticación en móviles de Amazon Location Service para iOS: [https://github.com/aws-geospatial/amazon-location-mobile-auth-sdk-ios](https://github.com/aws-geospatial/amazon-location-mobile-auth-sdk-ios) SDK de rastreo en móviles de Amazon Location Service para iOS: [https://github.com/aws-geospatial/amazon-location-mobile-tracking-sdk-ios](https://github.com/aws-geospatial/amazon-location-mobile-tracking-sdk-ios)  |  [https://github.com/maplibre/maplibre-native](https://github.com/maplibre/maplibre-native)  | 
|  **Compatible parcialmente**  | 
|  Flutter  |  [https://docs.amplify.aws/start/q/integration/flutter/](https://docs.amplify.aws/start/q/integration/flutter/) Flutter aún no es totalmente compatible con AWS, pero Amplify ofrece un soporte limitado.  |  [https://github.com/maplibre/flutter-maplibre-gl](https://github.com/maplibre/flutter-maplibre-gl) La librería Flutter de MapLibre se considera experimental.  | 

------
#### [ Backend application ]

Los siguientes SDK de AWS están disponibles para el desarrollo de aplicaciones de backend. Los marcos de renderización de mapas no aparecen en esta lista porque las aplicaciones de backend no suelen necesitar renderizar mapas.


| Idioma | AWS SDK | 
| --- | --- | 
|  .NET  |  [https://aws.amazon.com/sdk-for-net/](https://aws.amazon.com/sdk-for-net/)  | 
|  C\$1\$1  |  [https://aws.amazon.com/sdk-for-cpp/](https://aws.amazon.com/sdk-for-cpp/)  | 
|  Go  |  [https://aws.amazon.com/sdk-for-go/](https://aws.amazon.com/sdk-for-go/)  | 
|  Java  |  [https://aws.amazon.com/sdk-for-java/](https://aws.amazon.com/sdk-for-java/)  | 
|  JavaScript  |  [https://aws.amazon.com/sdk-for-javascript/](https://aws.amazon.com/sdk-for-javascript/)  | 
|  Node.js  |  [https://aws.amazon.com/sdk-for-javascript/](https://aws.amazon.com/sdk-for-javascript/)  | 
|  TypeScript  |  [https://aws.amazon.com/sdk-for-javascript/](https://aws.amazon.com/sdk-for-javascript/)  | 
|  Kotlin  |  [https://aws.amazon.com/sdk-for-kotlin/](https://aws.amazon.com/sdk-for-kotlin/)  | 
|  PHP  |  [https://aws.amazon.com/sdk-for-php/](https://aws.amazon.com/sdk-for-php/)  | 
|  Python  |  [https://aws.amazon.com/sdk-for-python/](https://aws.amazon.com/sdk-for-python/)  | 
|  Ruby  |  [https://aws.amazon.com/sdk-for-ruby/](https://aws.amazon.com/sdk-for-ruby/)  | 
|  Rust  |  [https://aws.amazon.com/sdk-for-rust/](https://aws.amazon.com/sdk-for-rust/) El SDK de AWS para Rust se encuentra en la versión preliminar para desarrolladores.  | 

------

# SDK de representación de mapas por idioma
<a name="map-rendering-by-language"></a>

Recomendamos renderizar los mapas de Amazon Location Service con el motor de renderizado [MapLibre](https://github.com/maplibre/maplibre-gl-js).

MapLibre es un motor para mostrar mapas en aplicaciones web o móviles. MapLibre también tiene un modelo de complemento y es compatible con las interfaces de usuario para la búsqueda y las rutas en algunos idiomas y plataformas. 

Para obtener más información sobre el uso de MapLibre y las funcionalidades que proporciona, consulte [Uso de las herramientas de MapLibre y bibliotecas relacionadas con Amazon Location](dev-maplibre.md) y [Cómo usar mapas dinámicos](dynamic-maps-how-to.md). 

En las tablas siguientes se proporciona información sobre las versiones de SDK de representación de mapas para idiomas y marcos, por tipo de aplicación: aplicación web o móvil.

------
#### [ Web frontend ]

Los siguientes SDK de representación de mapas están disponibles para el desarrollo de aplicaciones de frontend web.


| Lenguaje / marco | Marco de renderización de mapas | 
| --- | --- | 
|  **Totalmente compatible**  | 
|  JavaScript  |  [https://github.com/maplibre/maplibre-gl-js](https://github.com/maplibre/maplibre-gl-js)  | 
|  ReactJS  |  [https://github.com/maplibre/maplibre-react-native](https://github.com/maplibre/maplibre-react-native)  | 
|  TypeScript  |  [https://github.com/maplibre/maplibre-gl-js](https://github.com/maplibre/maplibre-gl-js)  | 
|  **Compatible parcialmente**  | 
|  Flutter  |  [https://github.com/maplibre/flutter-maplibre-gl](https://github.com/maplibre/flutter-maplibre-gl) La librería Flutter de MapLibre se considera experimental.  | 
|  Node.js  |   MapLibre no admite Node.js.  | 
|  PHP  |   MapLibre no admite PHP.  | 

------
#### [ Mobile frontend ]

Los siguientes SDK de representación de mapas están disponibles para el desarrollo de aplicaciones de frontend móviles.


| Lenguaje / marco | Marco de renderización de mapas | 
| --- | --- | 
|  **Totalmente compatible**  | 
|  Java  |  [https://github.com/maplibre/maplibre-native](https://github.com/maplibre/maplibre-native)  | 
|  Kotlin  |  [https://github.com/maplibre/maplibre-native](https://github.com/maplibre/maplibre-native) Requiere enlaces personalizados, ya que MapLibre está basado en Java.  | 
|  ObjectiveC  |  [https://github.com/maplibre/maplibre-native](https://github.com/maplibre/maplibre-native)  | 
|  React Native  |  [https://github.com/maplibre/maplibre-react-native](https://github.com/maplibre/maplibre-react-native)  | 
|  Swift  |  [https://github.com/maplibre/maplibre-native](https://github.com/maplibre/maplibre-native)  | 
|  **Compatible parcialmente**  | 
|  Flutter  |  [https://github.com/maplibre/flutter-maplibre-gl](https://github.com/maplibre/flutter-maplibre-gl) La librería Flutter de MapLibre se considera experimental.  | 

------

# SDK de formulario de direcciones
<a name="address-form-sdk"></a>

El SDK de formularios de direcciones agiliza la creación de formularios inteligentes para introducir direcciones. Los formularios de direcciones creados con el SDK proporcionan sugerencias de direcciones relevantes a medida que los usuarios comienzan a escribir. Cuando un usuario selecciona una sugerencia, el formulario de direcciones rellena automáticamente campos como la ciudad, el estado y el código postal. Esto reduce los errores y acelera la entrada de datos al minimizar la entrada manual. Los usuarios también pueden obtener una vista previa de la dirección seleccionada en un mapa y ajustar su marcador de ubicación para indicar entradas o puntos de recogida específicos, lo que mejora considerablemente la precisión.

![\[Demostración del SDK de Address Form que muestra la funcionalidad de autocompletar\]](http://docs.aws.amazon.com/es_es/location/latest/developerguide/images/address-form-demo.gif)


## Pruébalo
<a name="address-form-try-it"></a>

### Demostración
<a name="address-form-demo"></a>

Pruebe la [demostración del formulario de direcciones](https://aws-geospatial.github.io/address-form-sdk-js/) completamente funcional. 

### Constrúyalo usted mismo
<a name="address-form-builder"></a>

Comience [Introducción](#address-form-getting-started) a implementar formularios de direcciones con el SDK de formularios de direcciones o pruebe el enfoque sin código con el [asistente WYSIWYG Address Form Builder](https://console.aws.amazon.com/location/solution-builder/home#/address-form) de Location Service, que funciona con este SDK y al que se puede acceder desde la consola de Amazon Location Service en. [https://console.aws.amazon.com/location/](https://console.aws.amazon.com/location/) Este asistente interactivo le permite crear formularios personalizados con sugerencias predictivas, relleno automático de campos y diseños flexibles. Los desarrolladores pueden descargar ready-to-use paquetes en React JavaScript TypeScript, React o de forma independiente HTML/JavaScript para facilitar la integración sin necesidad de escribir código.

## Características principales de
<a name="address-form-features"></a>

Las principales características del SDK Address Form incluyen:
+ Proporciona sugerencias integradas para escribir direcciones con anticipación y POIs agiliza la entrada de datos.
+ Permite realizar búsquedas configurables por tipo de lugar (p. ej., códigos postales o localidades) para obtener resultados más precisos.
+ Ofrece una detección automática de la ubicación del navegador para centrar rápidamente a los usuarios en su área actual.
+ Muestra visualizaciones de mapas integradas para una mayor claridad y contexto.
+ Permite ajustar las ubicaciones de las direcciones en el mapa sin perder la ubicación proporcionada por el sistema, lo que garantiza la precisión y el control.
+ Incluye una herramienta de creación WYSIWYG que no requiere codificación, lo que ahorra tiempo y esfuerzo.
+ Implementa la eliminación de rebotes y el almacenamiento en caché para escribir con antelación APIs a fin de optimizar el rendimiento y reducir los costes.
+ Admite la personalización del estilo para que se adapte a la marca y la experiencia de usuario de la aplicación.

Utiliza las siguientes operaciones de la API de Amazon Location Service para proporcionar información de dirección a los formularios de direcciones:

**[GetTile](https://docs.aws.amazon.com/location/latest/APIReference/API_geomaps_GetTile.html)**  
Recupera los mosaicos del mapa para representar el mapa interactivo a fin de visualizar la ubicación de la dirección y ajustar la posición de una dirección.

**[Autocompletar](https://docs.aws.amazon.com/location/latest/APIReference/API_geoplaces_Autocomplete.html)**  
Proporciona sugerencias de direcciones en tiempo real a medida que los usuarios escriben.

**[Sugerir](https://docs.aws.amazon.com/location/latest/APIReference/API_geoplaces_Suggest.html)**  
Proporciona sugerencias de direcciones y puntos de interés en tiempo real a medida que los usuarios escriben.

**[ReverseGeocode](https://docs.aws.amazon.com/location/latest/APIReference/API_geoplaces_ReverseGeocode.html)**  
Convierte la ubicación actual de un usuario en la dirección conocida más cercana si decide rellenar automáticamente su dirección en función de su ubicación actual.

**[GetPlace](https://docs.aws.amazon.com/location/latest/APIReference/API_geoplaces_GetPlace.html)**  
Recupera información detallada sobre la ubicación de las direcciones seleccionadas después de seleccionar una dirección de los resultados de la API Autocomplete o Suggest.

## Precios
<a name="address-form-pricing"></a>

El SDK es gratuito y de [código abierto bajo la licencia](https://github.com/aws-geospatial/address-form-sdk-js) Apache-2.0. Solo pagas por el uso de la API. Consulta la [página de precios de Amazon Location Service](https://aws.amazon.com/location/pricing/).

## Introducción
<a name="address-form-getting-started"></a>

El SDK Address Form se puede utilizar en una aplicación de React o en una JavaScript página y HTML independientes. Para empezar, sigue las instrucciones que aparecen a continuación.

### Requisitos previos
<a name="address-form-prerequisites"></a>

**nota**  
El SDK de Address Form requiere una clave de API con los permisos necesarios para funcionar correctamente. Cree una clave de API con los siguientes permisos mediante el [asistente Address Form SDK Builder](https://console.aws.amazon.com/location/solution-builder/home#/address-form) de la consola Amazon Location Service o siga las instrucciones que se indican a continuación para crearla manualmente.

El uso del SDK de formularios de direcciones requiere que se permitan las siguientes acciones en la política de claves de la API:
+ `geo-maps:GetTile`- Esto es obligatorio al mostrar el componente del mapa. Consulta la referencia [GetTile](https://docs.aws.amazon.com/location/latest/APIReference/API_geomaps_GetTile.html)de la API.
+ `geo-places:Autocomplete`- Esto es obligatorio cuando se utiliza la `Autocomplete` operación para la funcionalidad de escritura anticipada. Consulta la referencia de la API de [autocompletado](https://docs.aws.amazon.com/location/latest/APIReference/API_geoplaces_Autocomplete.html).
+ `geo-places:Suggest`- Esto es obligatorio cuando se utiliza la `Suggest` operación para la función de escritura anticipada. Consulta la referencia sobre la API [Suggest](https://docs.aws.amazon.com/location/latest/APIReference/API_geoplaces_Suggest.html).
+ `geo-places:ReverseGeocode`- Esto es obligatorio cuando se permite a los usuarios proporcionar su ubicación actual mediante la API de geolocalización de los navegadores. Consulta la referencia de la API. [ReverseGeocode](https://docs.aws.amazon.com/location/latest/APIReference/API_geoplaces_ReverseGeocode.html)
+ `geo-places:GetPlace`- Esto es obligatorio cuando se utiliza la función de escritura anticipada. Consulta la referencia de la [GetPlace](https://docs.aws.amazon.com/location/latest/APIReference/API_geoplaces_GetPlace.html)API.

Sigue la guía [Use API Keys to Authenticate](https://docs.aws.amazon.com/location/latest/developerguide/using-apikeys.html) para crear una clave API de Amazon Location Service con los permisos necesarios.

Ejemplo de política clave para la [CreateKey](https://docs.aws.amazon.com/location/latest/APIReference/API_geotags_CreateKey.html)API con los permisos necesarios:

#### CreateKey solicitud de permisos para el formulario de direcciones
<a name="createkey-example"></a>

```
{
  "KeyName": "ExampleKey",
  "ExpireTime": "YYYY-MM-DDThh:mm:ss.sss",
  "Restrictions": {
    "AllowActions": [
      "geo-maps:GetTile",
      "geo-places:Autocomplete",
      "geo-places:Suggest",
      "geo-places:GetPlace",
      "geo-places:ReverseGeocode"
    ],
    "AllowResources": [
      "arn:aws:geo-maps:<Region>::provider/default",
      "arn:aws:geo-places:<Region>::provider/default"
    ]
  }
}
```

### Instalación
<a name="address-form-installation"></a>

#### HTML/ JavaScript
<a name="address-form-html-js-install"></a>

Incluye el siguiente CSS y JavaScript para el SDK en tu código HTML

```
...
<head>
...
<link
rel="stylesheet"
href="https://cdn.jsdelivr.net/npm/@aws/address-form-sdk-js/dist/standalone/address-form-sdk.css"
/>
...
</head>
...
<body>
...
<script src="https://cdn.jsdelivr.net/npm/@aws/address-form-sdk-js/dist/standalone/address-form-sdk.umd.js"></script>
</body>
...
```

#### React
<a name="address-form-react-install"></a>

Instala el SDK desde npm: `npm install @aws/address-form-sdk-js`

### Uso del SDK de
<a name="address-form-use-sdk"></a>

Agrega el siguiente código a tu aplicación React. Actualiza `AMAZON_LOCATION_API_KEY` con tu clave de API y `AMAZON_LOCATION_REGION` con la región en la que se creó la clave de API. Cuando se envía el formulario, la `onSubmit` retrollamada proporciona una función `getData` asíncrona. Llame a esta función con un `intendedUse` valor para recuperar los datos del formulario.

```
onSubmit: async (getData) => {
  const data = await getData({
    intendedUse: "SingleUse", // or "Storage"
  });
};
```

**nota**  
`"Storage"`Utilícela si necesita almacenar o almacenar en caché los resultados. Esto garantiza el cumplimiento de los [requisitos de uso previsto](https://docs.aws.amazon.com/location/latest/developerguide/places-intended-use.html) de Amazon Location Service.

------
#### [ HTML/JavaScript ]

```
<html lang="en">
  <head>
    <meta charset="UTF-8" />
    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
    <title>Address Form</title>
    <link
      rel="stylesheet"
      href="https://cdn.jsdelivr.net/npm/@aws/address-form-sdk-js/dist/standalone/address-form-sdk.css"
    />
  </head>
  <body>
    <form
      id="amazon-location-address-form"
      class="address-form flex-row flex-1"
    >
      <div class="flex-column">
        <input
          data-type="address-form"
          name="addressLineOne"
          data-api-name="suggest"
          data-show-current-location="true"
        />
        <input data-type="address-form" name="addressLineTwo" />
        <input data-type="address-form" name="city" />
        <input data-type="address-form" name="province" />
        <input data-type="address-form" name="postalCode" />
        <input data-type="address-form" name="country" />
        <div class="flex-row">
          <button data-type="address-form" type="submit">Submit</button>
          <button data-type="address-form" type="reset">Reset</button>
        </div>
      </div>
      <div data-type="address-form" data-map-style="Standard,Light"></div>
    </form>
    <></script>
script src="https://cdn.jsdelivr.net/npm/@aws/address-form-sdk-js/dist/standalone/address-form-sdk.umd.js"
    <script>
      AddressFormSDK.render({
        root: "#amazon-location-address-form",
        apiKey: "AMAZON_LOCATION_API_KEY",
        region: "AMAZON_LOCATION_REGION",
        showCurrentCountryResultsOnly: true,
        onSubmit: async (getData) => {
          // Get form data with intendedUse parameter
          // Use "SingleUse" for one-time display only
          // Use "Storage" if you plan to store/cache the results - makes an extra API call to grant storage rights
          const data = await getData({ intendedUse: "SingleUse" });
          console.log(data);
        },
      });
    </script>
  </body>
</html>
```

------
#### [ React ]

```
import React from 'react';
import { AddressForm, Flex } from "@aws/address-form-sdk-js";

export default function App() {
  return (
    <AddressForm
      apiKey="AMAZON_LOCATION_API_KEY"
      region="AMAZON_LOCATION_REGION"
      onSubmit={async (getData) => {
        // Get form data with intendedUse parameter
        // Use "SingleUse" for one-time display only
        // Use "Storage" if you plan to store/cache the results - makes an extra API call to grant storage rights
        const data = await getData({ intendedUse: "SingleUse" });
        console.log(data);
      }}
    >
      <Flex
        direction="row"
        flex
      >
        <Flex direction="column">
          <input
            data-api-name="autocomplete"
            data-type="address-form"
            name="addressLineOne"
            placeholder="Enter address"
          />
          <input
            data-type="address-form"
            name="addressLineTwo"
          />
          <input
            data-type="address-form"
            name="city"
            placeholder="City"
          />
          <input
            data-type="address-form"
            name="province"
            placeholder="State/Province"
          />
          <input
            data-type="address-form"
            name="postalCode"
          />
          <input
            data-type="address-form"
            name="country"
            placeholder="Country"
          />
          <Flex direction="row">
            <button address-form="submit">
              Submit
            </button>
            <button address-form="reset">
              Reset
            </button>
          </Flex>
        </Flex>
        <AddressFormMap
          mapStyle={[
            'Standard',
            'Light'
          ]}
         />
      </Flex>
    </AddressForm>
  );
}
```

------

## Países admitidos
<a name="address-form-supported-countries"></a>

El SDK de formularios de direcciones permite rellenar automáticamente direcciones en todo el mundo mediante Amazon Location Service. Los siguientes países son totalmente compatibles con el análisis de campos de direcciones, en el que cada componente de la dirección se rellena en su campo respectivo:
+ Australia (AU)
+ Canadá (CA)
+ Francia (FR)
+ Hong Kong (HK)
+ Irlanda (IE)
+ Nueva Zelanda (NZ)
+ Filipinas (PH)
+ Singapur (SG)
+ Reino Unido (GB)
+ Estados Unidos (EE. UU.)

Todos los demás países están en estado de vista previa. Los países de vista previa muestran la dirección completa en el `addressLineOne` campo sin ningún formato específico del país. Las versiones futuras mejorarán este comportamiento y podrás acceder a estas mejoras mediante la última versión del SDK.

## Regiones de AWS admitidas
<a name="address-form-supported-aws-regions"></a>

El SDK de Address Form y el asistente Address Form Builder están disponibles en todas las regiones de AWS en las que opera Amazon Location Service, utilizando la `Current` versión de su APIs. Consulta la lista completa de regiones compatibles en las regiones [admitidas por Amazon Location](https://docs.aws.amazon.com/location/latest/developerguide/location-regions.html).

## referencia de la API
<a name="address-form-api-reference"></a>

Consulta la referencia de la [API README](https://github.com/aws-geospatial/address-form-sdk-js#api-reference).