As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.

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

AWS fornece kits de desenvolvimento de software (SDKs) para várias linguagens de programação, permitindo que você integre facilmente o Amazon Location Service aos seus aplicativos. Esta página descreve os procedimentos disponíveis SDKs, seus procedimentos de instalação e exemplos de código para ajudar você a começar a usar o Amazon Location Service em seu ambiente de desenvolvimento preferido.

Existem várias ferramentas que ajudarão você a usar o Amazon Location Service.
+ **AWS SDKs**— Os kits de desenvolvimento de AWS software (SDKs) estão disponíveis em várias linguagens de programação populares, fornecendo uma API, exemplos de código e documentação que facilitam a criação de aplicativos em sua linguagem preferida. AWS SDKs Isso inclui a localização APIs e a funcionalidade principais da Amazon, incluindo acesso a mapas, lugares, rotas, cercas geográficas e rastreadores. Para saber mais sobre a SDKs disponibilidade para uso com o Amazon Location Service em diferentes aplicativos e idiomas, consulte[SDKs por linguagem](dev-by-language.md).
+ **MapLibre**— O Amazon Location Service recomenda a renderização de mapas usando o mecanismo de [MapLibre](https://github.com/maplibre/maplibre-gl-js)renderização. MapLibre é um mecanismo para exibir mapas em aplicativos da web ou móveis. MapLibre também tem um modelo de plug-in e suporta interface de usuário para pesquisas e rotas em alguns idiomas e plataformas. Para saber mais sobre o uso MapLibre e a funcionalidade que ele fornece, consulte[Utilizar ferramentas e bibliotecas relacionadas do MapLibre com o Amazon Location](dev-maplibre.md).
+ **Amazon Location SDKs** — O Amazon Location SDKs é um conjunto de bibliotecas de código aberto que facilitam o desenvolvimento de aplicativos com o Amazon Location Service. As bibliotecas fornecem funcionalidade para oferecer suporte à autenticação para aplicativos móveis e web, rastreamento de localização para aplicativos móveis, conversão entre tipos de dados de localização da Amazon e [GeoJSON](https://geojson.org/), bem como um pacote hospedado do cliente Amazon Location para AWS o SDK v3. Para saber mais sobre a localização da Amazon SDKs, consulte[SDKs por linguagem](dev-by-language.md).
+ **Amazon Location Migration SDK**: o Amazon Location Migration SDK fornece uma ponte que permite migrar aplicações existentes do Google Maps para o Amazon Location. O SDK de migração fornece uma opção para seu aplicativo criado usando o SDK do Google Maps JavaScript usar o Amazon Location Service sem precisar reescrever nenhum aplicativo ou lógica de negócios se o Amazon Location suportar os recursos usados. O SDK de migração redireciona todas as chamadas de API para o Amazon Location em vez do Google Map. Para começar, consulte o [Amazon Location Migration SDK](https://github.com/aws-geospatial/amazon-location-migration) em GitHub.

# Tutoriais para desenvolvedores
<a name="sdk-how-to"></a>

Use esta seção para aprender como usar vários aspectos do SDK do Amazon Location Service.

**Topics**
+ [Como usar auxiliares de autenticação](how-to-auth-helper.md)
+ [Use o plugin Amazon Location MapLibre Geocoder GL](dev-maplibre-geocoder.md)
+ [Como usar o SDKs de rastreamento](dev-tracking-sdk.md)
+ [Utilizar ferramentas e bibliotecas relacionadas do MapLibre com o Amazon Location](dev-maplibre.md)

# Como usar auxiliares de autenticação
<a name="how-to-auth-helper"></a>

Esta seção fornece informações adicionais sobre os auxiliares de autenticação.

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

Os utilitários de JavaScript autenticação de localização da Amazon ajudam na autenticação ao fazer chamadas de API do Amazon Location Service a partir de JavaScript aplicativos. Esses utilitários permitem especificamente a autenticação que usa chaves de API ou o Amazon Cognito.

**Instalação**
+ Instale esta biblioteca usando o NPM:

  ```
  npm install @aws/amazon-location-utilities-auth-helper
  ```
+ Para usá-la diretamente no navegador, inclua o seguinte em seu arquivo HTML:

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

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

Para usar os auxiliares de autenticação, importe a biblioteca e chame as funções utilitárias necessárias. [Essa biblioteca suporta solicitações de autenticação do Amazon Location Service SDKs, incluindo [Maps](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/geo-maps/), [Places](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/geo-places/) e [Routes](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/geo-routes/) independentes SDKs, bem como a renderização de mapas com MapLibre o GL JS.](https://github.com/maplibre/maplibre-gl-js)

**Uso com módulos**

Este exemplo demonstra o uso do SDK autônomo de Locais para fazer uma solicitação autenticada com chaves 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);
```

Este exemplo demonstra o uso do SDK autônomo de Rotas para fazer uma solicitação autenticada com chaves 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);
```

Este exemplo usa o SDK de Localização com autenticação por chave 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 com um navegador**

As funções utilitárias podem ser acessadas sob o objeto global amazonLocationAuth Helper quando usadas diretamente em um ambiente de navegador.

Este exemplo demonstra uma solicitação com o cliente Amazon Location, autenticada usando chaves 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);
```

Este exemplo demonstra a renderização de um mapa com MapLibre GL JS, autenticado com uma chave 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}`,
});
```

Este exemplo demonstra a renderização de um mapa com MapLibre GL JS usando o 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 com identidades autenticadas**

Você pode modificar a função withIdentityPool Id para incluir parâmetros personalizados para 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>

O Amazon Location Service Mobile Authentication SDK para iOS ajuda a autenticar solicitações para o Amazon Location Service a APIs partir de aplicativos iOS. Ele permite especificamente a autenticação por meio de chaves de API ou do Amazon Cognito.

**Instalação**
+ Abra o Xcode e acesse **File > Add Package Dependencies**.
+ Digite a URL do pacote ([https://github.com/aws-geospatial/amazon-location-mobile-auth-sdk-ios/](https://github.com/aws-geospatial/amazon-location-mobile-auth-sdk-ios/)) na barra de pesquisa e pressione Enter.
+ **Selecione o pacote "amazon-location-mobile-auth-sdk-ios” e clique em Add Package.**
+ Escolha o produto do pacote "AmazonLocationiOSAuthSDK” e clique em **Add Package**.

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

Depois de instalar a biblioteca, use a classe `AuthHelper` para definir as configurações do cliente para as chaves de API ou para o Amazon Cognito.

**Chaves de API**

Veja um exemplo que usa o SDK autônomo de Locais com autenticação de chave de 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)
}
```

Veja um exemplo que usa o SDK autônomo de Rotas com autenticação de chave de 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)
}
```

Veja um exemplo que usa o SDK de Localização com autenticação de chave de 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)
}
```

Veja um exemplo que usa o SDK autônomo de Locais com o 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)
}
```

Veja um exemplo que usa o SDK autônomo de Rotas com o 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)
}
```

Veja um exemplo que usa o SDK de Localização com o 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>

O Amazon Location Service Mobile Authentication SDK para Android ajuda você a autenticar solicitações para o Amazon Location APIs Service a partir de aplicativos Android, oferecendo suporte específico à autenticação usando o Amazon Cognito.

**Instalação**
+ Esse SDK de autenticação funciona com o SDK geral do AWS Kotlin. Ambos SDKs são publicados no Maven Central. Verifique a versão mais recente do [auth SDK](https://mvnrepository.com/artifact/software.amazon.location/auth) no Maven Central.
+ Adicione as seguintes linhas à seção de dependências do arquivo `build.gradle` no 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 os Mapas, Locais e Rotas independentes SDKs, adicione as seguintes linhas:

  ```
  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 o SDK de Localização consolidado que inclui geocercas e rastreamento, adicione a seguinte linha:

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

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

Importe as seguintes classes em seu 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
```

Você pode criar um `AuthHelper` e usá-lo com o AWS SDK do Kotlin:

**Exemplo: provedor de credenciais com ID do banco 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())
}
```

**Exemplo: provedor de credenciais com provedor de credenciais 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())
}
```

**Exemplo: provedor de credenciais com chave de 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())
}
```

Você pode usar `LocationCredentialsProvider` para carregar o MapLibre mapa. Exemplo:

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

Use os clientes criados para fazer chamadas para o Amazon Location Service. Este exemplo pesquisa lugares próximos a uma latitude e longitude especificadas:

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

# Use o plugin Amazon Location MapLibre Geocoder GL
<a name="dev-maplibre-geocoder"></a>

O plug-in do MapLibre geocodificador Amazon Location foi projetado para facilitar a incorporação da funcionalidade Amazon Location em seus JavaScript aplicativos, ao trabalhar com renderização de mapas e geocodificação usando a biblioteca. [maplibre-gl-geocoder](https://github.com/maplibre/maplibre-gl-geocoder)

## Instalação
<a name="geocoder-installation"></a>

Instale o plug-in Amazon Location MapLibre geocoder do NPM para uso com módulos. Digite este comando:

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

Você também pode importar arquivos HTML e CSS para uso diretamente no navegador, com um 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 com módulo - SDK autônomo GeoPlaces
<a name="geocoder-module"></a>

Este exemplo usa o [AWS SDK para JavaScript V3](https://github.com/aws/aws-sdk-js-v3) para obter um GeoPlacesClient para fornecer à biblioteca e [AuthHelper](https://github.com/aws-geospatial/amazon-location-utilities-auth-helper-js)para autenticar o. GeoPlacesClient Ele habilita tudo APIs para o 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 com um navegador - SDK autônomo GeoPlaces
<a name="geocoder-browser"></a>

Este exemplo usa o cliente do Amazon Location para fazer uma solicitação que se autentica usando a chave de API.

**nota**  
Alguns desses exemplos usam o Amazon Location GeoPlacesClient. Esse cliente é baseado no [AWS SDK para JavaScript V3](https://github.com/aws/aws-sdk-js-v3) e permite fazer chamadas para a Amazon Location por meio de um script referenciado em um arquivo HTML.

Inclua o código a seguir no arquivo:

```
<!-- 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>
```

Inclua o seguinte em um JavaScript arquivo:

```
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());
```

## Funções
<a name="geocoder-functions"></a>

Abaixo estão listadas as funções usadas no plug-in de MapLibre geocodificador Amazon Location:
+ `buildAmazonLocationMaplibreGeocoder`

  Essa classe cria uma instância do `AmazonLocationMaplibreGeocder` que é o ponto de entrada para todas as outras chamadas.

  Usando chamadas de API `GeoPlacesClient` autônomas (o cliente é instância de `GeoPlacesClient`):

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

  Usando chamadas de API `LocationClient` consolidadas (o cliente é instância de `LocationClient`):

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

  Retorna um ready-to-use IControl objeto que pode ser adicionado diretamente a um 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);
  ```

# Como usar o SDKs de rastreamento
<a name="dev-tracking-sdk"></a>

Esse tópico fornece informações sobre como usar os SDKs de rastreamento.

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

O SDK de rastreamento móvel do Amazon Location fornece utilitários que ajudam a autenticar, capturar posições de dispositivos e enviar atualizações de posição para rastreadores do Amazon Location com facilidade. O SDK é compatível com a filtragem local de atualizações de localização com intervalos de atualização configuráveis. Isso reduz os custos de dados e otimiza a conectividade intermitente para suas aplicações iOS.

O SDK de rastreamento do iOS está disponível em GitHub: [Amazon Location Mobile Tracking SDK](https://github.com/aws-geospatial/amazon-location-mobile-tracking-sdk-ios) para iOS.

Esta seção aborda os seguintes tópicos do SDK do iOS de rastreamento móvel do Amazon Location:

**Topics**
+ [Instalação](#loc-mobile-tracking-install-ios)
+ [Usage](#loc-mobile-tracking-usage-ios)
+ [Filtros](#loc-mobile-tracking-ios-filters)
+ [Funções de rastreamento do SDK móvel para iOS](#loc-mobile-tracking-functions)
+ [Exemplos](#loc-mobile-tracking-example-ios)

## Instalação
<a name="loc-mobile-tracking-install-ios"></a>

Use o seguinte procedimento para instalar o SDK de rastreamento móvel para iOS:

1. No seu projeto do Xcode, acesse **File** e selecione **Add Package Dependencies**.

1. Digite o seguinte URL: [https://github.com/aws-geospatial/amazon-location-mobile-tracking-sdk-ios/](https://github.com/aws-geospatial/amazon-location-mobile-tracking-sdk-ios/) na barra de pesquisa e pressione a tecla enter.

1. Selecione o pacote `amazon-location-mobile-tracking-sdk-ios` e clique em **Add Package**.

1. Selecione o produto do pacote `AmazonLocationiOSTrackingSDK` e clique em **Add Package**.

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

O procedimento a seguir mostra como criar um assistente de autenticação usando-se as credenciais do Amazon Cognito.

1. Depois de instalar a biblioteca, você precisa adicionar uma ou ambas as descrições ao seu arquivo `info.plist`:

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

1. Em seguida, importe o AuthHelper em sua classe:

   ```
   import AmazonLocationiOSAuthSDKimport AmazonLocationiOSTrackingSDK
   ```

1. Em seguida, você criará um `AuthHelper` objeto e o usará com o AWS SDK, criando um auxiliar de autenticação usando credenciais do 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>

O SDK do iOS de rastreamento móvel do Amazon Location tem três filtros de localização embutidos.
+ `TimeLocationFilter`: filtra a localização atual a ser carregada com base em um intervalo de tempo definido.
+ `DistanceLocationFilter`: filtra as atualizações de localização com base em um limite de distância especificado.
+ `AccuracyLocationFilter`: filtra as atualizações de localização comparando a distância percorrida desde a última atualização com a precisão da localização atual.

Este exemplo adiciona filtros no `LocationTracker` no momento da criação:

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

Este exemplo ativa e desativa o filtro em runtime com o `LocationTracker`:

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

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

## Funções de rastreamento do SDK móvel para iOS
<a name="loc-mobile-tracking-functions"></a>

O SDK de rastreamento móvel do Amazon Location para iOS inclui as seguintes funções:
+ **Classe**: `LocationTracker`

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

  Essa é uma função inicializadora para criar um objeto `LocationTracker`. Requer instâncias de `LocationCredentialsProvider`, `trackerName` e, opcionalmente, uma instância de `LocationTrackingConfig`. Se a configuração não for fornecida, ela será inicializada com valores padrão.
+ **Classe**: `LocationTracker`

  `setTrackerConfig(config: LocationTrackerConfig)`

  Isso define a configuração do rastreador para entrar em vigor a qualquer momento após a inicialização do rastreador de localização.
+ **Classe**: `LocationTracker`

  `getTrackerConfig()`

  Isso faz com que a configuração de rastreamento de localização seja usada ou modificada na sua aplicação.

  Retorna: `LocationTrackerConfig`
+ **Classe**: `LocationTracker`

  `getDeviceId()`

  Obtém o ID do dispositivo gerado pelo rastreador de localização.

  Retorna: `String?`
+ **Classe**: `LocationTracker`

  `startTracking()`

  Inicia o processo de acessar a localização do usuário e enviá-la ao AWS rastreador.
+ **Classe**: `LocationTracker`

  `resumeTracking()`

  Retoma o processo de acessar a localização do usuário e enviá-la ao AWS rastreador.
+ **Classe**: `LocationTracker`

  `stopTracking()`

  Interrompe o processo de rastreamento da localização do usuário.
+ **Classe**: `LocationTracker`

  `startBackgroundTracking(mode: BackgroundTrackingMode)`

  Inicia o processo de acessar a localização do usuário e enviá-la ao AWS rastreador enquanto o aplicativo está em segundo plano. `BackgroundTrackingMode`tem as seguintes opções: 
  + `Active:` essa opção não pausa automaticamente as atualizações de localização.
  + `BatterySaving:` essa opção pausa automaticamente as atualizações de localização.
  + `None:` em geral, essa opção desativa as atualizações de localização em segundo plano.
+ **Classe**: `LocationTracker`

  `resumeBackgroundTracking(mode: BackgroundTrackingMode)`

  Retoma o processo de acessar a localização do usuário e enviá-la ao AWS rastreador enquanto o aplicativo está em segundo plano.
+ **Classe**: `LocationTracker`

  `stopBackgroundTracking()`

  Interrompe o processo de acessar a localização do usuário e enviá-la ao AWS rastreador enquanto o aplicativo está em segundo plano.
+ **Classe**: `LocationTracker`

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

  Recupera os locais de rastreamento enviados para o dispositivo do usuário entre a data e hora de início e término.

  Retorna: `Void`
+ **Classe**: `LocationTrackerConfig`

  `init()`

  Isso inicializa o LocationTrackerConfig com valores padrão.
+ **Classe**: `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)`

  Isso inicializa o `LocationTrackerConfig` com valores de parâmetros definidos pelo usuário. Se um valor de parâmetro não for fornecido, ele será definido como um valor padrão.
+ **Classe**: `LocationFilter`

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

  O `LocationFilter` é um protocolo que os usuários podem implementar para a implementação de filtros personalizados. Um usuário precisaria implementar uma função `shouldUpload` para comparar a localização anterior e atual e retornar se a localização atual deveria ser carregada.

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

Esta seção detalha exemplos do uso do Amazon Location Mobile Tracking SDK para iOS.

**nota**  
Certifique-se de que as permissões necessárias estejam definidas no arquivo `info.plist`. Essas são as mesmas permissões listadas na seção [Usage](#loc-mobile-tracking-usage-ios).

O exemplo a seguir demonstra a funcionalidade para rastrear a localização do dispositivo e recuperar os locais rastreados:

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

Comece a rastrear a localização:

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

Retome o rastreamento da localização:

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

Pare de rastrear a localização:

```
locationTracker.stopTracking()
```

Inicie o rastreamento em 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
   }
```

Retomar o rastreamento em segundo plano:

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

Para interromper o rastreamento em segundo plano:

```
locationTracker.stopBackgroundTracking()
```

Recupere as localizações rastreadas do dispositivo a partir do 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 rastreamento móvel para Android
<a name="loc-mobile-tracking-android"></a>

O SDK de rastreamento móvel do Amazon Location fornece utilitários que ajudam a autenticar, capturar posições de dispositivos e enviar atualizações de posição para rastreadores do Amazon Location com facilidade. O SDK é compatível com a filtragem local de atualizações de localização com intervalos de atualização configuráveis. Isso reduz os custos de dados e otimiza a conectividade intermitente para suas aplicações Android.

O SDK de rastreamento do Android está disponível em GitHub: [Amazon Location Mobile Tracking SDK](https://github.com/aws-geospatial/amazon-location-mobile-tracking-sdk-android) para Android. Além disso, tanto o SDK de autenticação móvel quanto o AWS SDK estão disponíveis no repositório [AWS Maven](https://central.sonatype.com/artifact/software.amazon.location/tracking). O SDK de rastreamento do Android foi projetado para funcionar com o AWS SDK geral.

Esta seção aborda os seguintes tópicos do SDK do Android de rastreamento móvel do Amazon Location:

**Topics**
+ [Instalação](#loc-mobile-tracking-install-android)
+ [Usage](#loc-mobile-tracking-usage-android)
+ [Filtros](#loc-mobile-tracking-android-filters)
+ [Funções de rastreamento do Android Mobile SDK](#loc-mobile-tracking-functions)
+ [Exemplos](#loc-mobile-tracking-example-android)

## Instalação
<a name="loc-mobile-tracking-install-android"></a>

Para instalar o SDK, adicione as seguintes linhas à seção de dependências do seu arquivo build.gradle no 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")
```

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

Este procedimento mostra como usar o SDK para autenticar e criar o objeto `LocationTracker`:

**nota**  
Esse procedimento pressupõe que você tenha importado a biblioteca mencionada na seção [Instalação](#loc-mobile-tracking-install-android).

1. Importe as seguintes classes em seu 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. Em seguida, crie um `AuthHelper`, pois o parâmetro `LocationCredentialsProvider` é necessário para criar um objeto `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. Agora, use `LocationCredentialsProvider` e `LocationTrackerConfig` para criar um objeto `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>

O SDK do Android de rastreamento móvel do Amazon Location tem três filtros de localização embutidos.
+ `TimeLocationFilter`: filtra a localização atual a ser carregada com base em um intervalo de tempo definido.
+ `DistanceLocationFilter`: filtra as atualizações de localização com base em um limite de distância especificado.
+ `AccuracyLocationFilter`: filtra as atualizações de localização comparando a distância percorrida desde a última atualização com a precisão da localização atual.

Este exemplo adiciona filtros no `LocationTracker` no momento da criação:

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

Este exemplo ativa e desativa o filtro em runtime com o `LocationTracker`:

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

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

## Funções de rastreamento do Android Mobile SDK
<a name="loc-mobile-tracking-functions"></a>

O SDK de rastreamento móvel do Amazon Location para Android inclui as seguintes funções:
+ **Classe**: `LocationTracker`

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

  Essa é uma função inicializadora para criar um objeto `LocationTracker`. Requer instâncias de `LocationCredentialsProvider`, `trackerName` e, opcionalmente, uma instância de `LocationTrackingConfig`. Se a configuração não for fornecida, ela será inicializada com valores padrão.
+ **Classe**: `LocationTracker`

  `start(locationTrackingCallback: LocationTrackingCallback)`

  Inicia o processo de acessar a localização do usuário e enviá-la para um rastreador do Amazon Location.
+ **Classe**: `LocationTracker`

  `isTrackingInForeground()`

  Verifica se o rastreamento de localização está em andamento.
+ **Classe**: `LocationTracker`

  `stop()`

  Interrompe o processo de rastreamento da localização do usuário.
+ **Classe**: `LocationTracker`

  `startTracking()`

  Inicia o processo de acessar a localização do usuário e enviá-la ao AWS rastreador.
+ **Classe**: `LocationTracker`

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

  Inicia o processo de acessar a localização do usuário e enviá-la ao AWS rastreador enquanto o aplicativo está em segundo plano. `BackgroundTrackingMode`tem as seguintes opções:
  + `ACTIVE_TRACKING`: essa opção rastreia ativamente as atualizações de localização de um usuário. 
  + `BATTERY_SAVER_TRACKING`: essa opção rastreia as atualizações de localização do usuário a cada 15 minutos.
+ **Classe**: `LocationTracker`

  `stopBackgroundService()`

  Interrompe o processo de acessar a localização do usuário e enviá-la ao AWS rastreador enquanto o aplicativo está em segundo plano.
+ **Classe**: `LocationTracker`

  `getTrackerDeviceLocation()`

  Recupera a localização do dispositivo dos serviços do Amazon Location. 
+ **Classe**: `LocationTracker`

  `getDeviceLocation(locationTrackingCallback: LocationTrackingCallback?)`

  Recupera a localização atual do dispositivo do cliente do provedor de localização fundido e a carrega no rastreador do Amazon Location.
+ **Classe**: `LocationTracker`

  `uploadLocationUpdates(locationTrackingCallback: LocationTrackingCallback?)`

  Carrega a localização do dispositivo para os serviços do Amazon Location após a filtragem com base nos filtros de localização configurados.
+ **Classe**: `LocationTracker`

  `enableFilter(filter: LocationFilter)`

  Ativa um filtro de localização específico.
+ **Classe**: `LocationTracker`

  `checkFilterIsExistsAndUpdateValue(filter: LocationFilter)`

  Desativa o filtro de localização específico.
+ **Classe**: `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()) `

  Isso inicializa o `LocationTrackerConfig` com valores de parâmetros definidos pelo usuário. Se um valor de parâmetro não for fornecido, ele será definido como um valor padrão.
+ **Classe**: `LocationFilter`

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

  O `LocationFilter` é um protocolo que os usuários podem implementar para a implementação de filtros personalizados. Você precisa implementar a função `shouldUpload` para comparar a localização anterior e atual e retornar se a localização atual deve ser carregada.

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

O exemplo de código a seguir mostra a funcionalidade do SDK de rastreamento móvel.

Este exemplo usa o `LocationTracker` para iniciar e interromper o rastreamento em 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()
```

# Utilizar ferramentas e bibliotecas relacionadas do MapLibre com o Amazon Location
<a name="dev-maplibre"></a>

O [MapLibre](https://maplibre.org/) é, primeiramente, um mecanismo de renderização para exibir mapas em um aplicativo web ou móvel. No entanto, ele também inclui suporte para plug-ins e fornece funcionalidade para trabalhar com outros aspectos do Amazon Location. A seguir, descrevemos as ferramentas que você pode usar com base na área ou localização com a qual você deseja trabalhar.

**nota**  
Para usar qualquer aspecto do Amazon Location, instale o [AWS SDK para a linguagem que você deseja usar](dev-by-language.md).
+ **Mapas**

  Para exibir mapas em seu aplicativo, você precisa de um mecanismo de renderização de mapas que use os dados fornecidos pela Amazon Location e desenhe na tela. Os mecanismos de renderização de mapas também fornecem funcionalidade para deslocar e ampliar o mapa ou para adicionar marcadores, alfinetes e outras anotações ao mapa.

  O Amazon Location Service recomenda a renderização de mapas usando o mecanismo de renderização do [MapLibre](https://github.com/maplibre/maplibre-gl-js). O MapLibre GL JS é um mecanismo para exibir mapas em JavaScript, enquanto o MapLibre Native fornece mapas para iOS ou Android.

  O MapLibre também tem um ecossistema de plug-ins para estender a funcionalidade principal. Para obter mais informações, acesse [https://maplibre.org/maplibre-gl-js/docs/plugins/](https://maplibre.org/maplibre-gl-js/docs/plugins/).
+ **Pesquisa de lugares**

  Para simplificar a criação de uma interface de usuário de pesquisa, você pode usar o [geocodificador MapLibre](https://github.com/maplibre/maplibre-gl-geocoder) para Web (aplicativos Android podem usar o [plug-in Android Places](https://github.com/maplibre/maplibre-plugins-android/tree/master/plugin-places)).

  Use a [biblioteca de geocodificadores do Amazon Location para MapLibre](https://github.com/aws-geospatial/amazon-location-for-maplibre-gl-geocoder?tab=readme-ov-file) para simplificar o processo de uso do Amazon Location com `amazon-location-for-maplibre-gl-geocoder` em aplicações JavaScript.

  Para obter mais informações, consulte [Use o plugin Amazon Location MapLibre Geocoder GL](dev-maplibre-geocoder.md).
+ **Rotas**
+ **Geocercas e rastreadores**

  O MapLibre não tem nenhuma renderização ou ferramenta específica para geocercas e rastreamento, mas você pode usar a funcionalidade de renderização e os [plug-ins](https://maplibre.org/maplibre-gl-js/docs/plugins/) para mostrar as geocercas e os dispositivos rastreados no mapa.

  Os dispositivos que estão sendo rastreados podem usar o [MQTT](tracking-using-mqtt.md) ou enviar atualizações manualmente para o Amazon Location Service. Os eventos de geocercas podem ser respondidos usando [AWS Lambda](https://docs.aws.amazon.com/lambda/).

Muitas bibliotecas de código aberto estão disponíveis para fornecer funcionalidade adicional para o Amazon Location Service, por exemplo, o [Turf](https://github.com/Turfjs/turf), que fornece funcionalidade de análise espacial.

Muitas bibliotecas usam os dados formatados [GeoJSON](https://geojson.org/) de padrão aberto. O Amazon Location Service fornece uma biblioteca para converter respostas em GeoJSON para usar em aplicações JavaScript. Para obter mais informações, consulte [SDKs e estruturas para Amazon Location Service](dev-sdks.md). 

# SDKs por linguagem
<a name="dev-by-language"></a>

**Versões do SDK**  
Recomendamos que você use a versão mais recente do AWS SDK e quaisquer outros SDKs usados em seus projetos e que mantenha os SDKs atualizados. O AWS SDK fornece os atributos e funcionalidades mais recentes, além de atualizações de segurança. Para encontrar a versão mais recente do AWS SDK para JavaScript, por exemplo, consulte o tópico de [instalação do navegador](https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/index.html#In_the_Browser) na documentação do *AWS SDK para JavaScript*.

As tabelas a seguir fornecem informações sobre SDKs e versões da Estrutura de renderização de mapas da AWS para linguagens e estruturas, por tipo de aplicação: web, móvel ou de back-end.

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

Os seguintes SDKs e versões da Estrutura de renderização de mapas da AWS estão disponíveis para desenvolvimento de aplicações front-end na Web.


| Linguagem/Estrutura | AWS SDK | Estrutura de renderização de mapas | 
| --- | --- | --- | 
|  **Suporte total**  | 
|  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)  | 
|  **Suporte parcial**  | 
|  Flutter  |  [https://docs.amplify.aws/start/q/integration/flutter/](https://docs.amplify.aws/start/q/integration/flutter/) O Flutter ainda não tem suporte total da AWS, mas um suporte limitado é oferecido via Amplify.  |  [https://github.com/maplibre/flutter-maplibre-gl](https://github.com/maplibre/flutter-maplibre-gl) A biblioteca MapLibre Flutter é considerada 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/)  |  Não há suporte do MapLibre para PHP.  | 

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

Os seguintes SDKs e versões da Estrutura de renderização de mapas da AWS estão disponíveis para desenvolvimento de aplicações móveis e de front-end.


| Linguagem/Estrutura | AWS SDK | Estrutura de renderização de mapas | 
| --- | --- | --- | 
|  **Suporte total**  | 
|  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/)  Amazon Location Service Mobile Authentication SDK for Android: [https://github.com/aws-geospatial/amazon-location-mobile-auth-sdk-android](https://github.com/aws-geospatial/amazon-location-mobile-auth-sdk-android) Amazon Location Service Mobile Tracking SDK for 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) Requer ligações personalizadas, pois o MapLibre é baseado em 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)  | 
|  ReactNative  |  [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/) Amazon Location Service Mobile Authentication SDK for iOS: [https://github.com/aws-geospatial/amazon-location-mobile-auth-sdk-ios](https://github.com/aws-geospatial/amazon-location-mobile-auth-sdk-ios) Amazon Location Service Mobile Tracking SDK for 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)  | 
|  **Suporte parcial**  | 
|  Flutter  |  [https://docs.amplify.aws/start/q/integration/flutter/](https://docs.amplify.aws/start/q/integration/flutter/) O Flutter ainda não tem suporte total da AWS, mas um suporte limitado é oferecido via Amplify.  |  [https://github.com/maplibre/flutter-maplibre-gl](https://github.com/maplibre/flutter-maplibre-gl) A biblioteca MapLibre Flutter é considerada experimental.  | 

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

Os seguintes AWS SDKs estão disponíveis para desenvolvimento de aplicativos de back-end. As Estruturas de renderização de mapas não estão listadas aqui, porque a renderização de mapas normalmente não é necessária para aplicações de back-end.


| 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/) O AWS SDK para Rust está em versão de pré-visualização para desenvolvedores.  | 

------

# SDK de renderização de mapas por idioma
<a name="map-rendering-by-language"></a>

O Amazon Location Service recomenda a renderização de mapas usando-se o mecanismo de renderização [MapLibre](https://github.com/maplibre/maplibre-gl-js).

O MapLibre é um mecanismo para exibir mapas em aplicativos web ou móveis. O MapLibre também tem um modelo de plug-in e suporta interfaces de usuários para pesquisa e rotas em algumas linguagens e plataformas. 

Para saber mais sobre como usar o MapLibre e a funcionalidade que ele fornece, consulte [Utilizar ferramentas e bibliotecas relacionadas do MapLibre com o Amazon Location](dev-maplibre.md) e [Como usar mapas dinâmicos](dynamic-maps-how-to.md). 

As tabelas a seguir fornecem informações sobre as versões de SDKs de renderização de mapas para linguagens e estruturas, por tipo de aplicativo: aplicativo web ou móvel.

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

Os SDKs de renderização de mapas a seguir estão disponíveis para desenvolvimento de aplicativos web front-end.


| Linguagem/Estrutura | Estrutura de renderização de mapas | 
| --- | --- | 
|  **Suporte total**  | 
|  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)  | 
|  **Suporte parcial**  | 
|  Flutter  |  [https://github.com/maplibre/flutter-maplibre-gl](https://github.com/maplibre/flutter-maplibre-gl) A biblioteca MapLibre Flutter é considerada experimental.  | 
|  Node.js  |   Não há suporte do MapLibre para o Node.js.  | 
|  PHP  |   Não há suporte do MapLibre para PHP.  | 

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

Os SDKs de renderização de mapas a seguir estão disponíveis para desenvolvimento de aplicativos móveis front-end.


| Linguagem/Estrutura | Estrutura de renderização de mapas | 
| --- | --- | 
|  **Suporte total**  | 
|  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) Requer ligações personalizadas, pois o MapLibre é baseado em Java.  | 
|  ObjectiveC  |  [https://github.com/maplibre/maplibre-native](https://github.com/maplibre/maplibre-native)  | 
|  ReactNative  |  [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)  | 
|  **Suporte parcial**  | 
|  Flutter  |  [https://github.com/maplibre/flutter-maplibre-gl](https://github.com/maplibre/flutter-maplibre-gl) A biblioteca MapLibre Flutter é considerada experimental.  | 

------

# Formulário de endereço SDK
<a name="address-form-sdk"></a>

O SDK do Formulário de Endereço simplifica a criação de formulários inteligentes de entrada de endereços. Os formulários de endereço criados com o SDK fornecem sugestões de endereço relevantes à medida que os usuários começam a digitar. Quando um usuário seleciona uma sugestão, um formulário de endereço preenche automaticamente campos como cidade, estado e código postal. Isso reduz os erros e acelera a entrada de dados, minimizando a entrada manual. Os usuários também podem visualizar o endereço selecionado em um mapa e ajustar seu pino de localização para indicar entradas específicas ou locais de coleta, melhorando significativamente a precisão.

![\[Demonstração do SDK do formulário de endereço mostrando a funcionalidade de preenchimento automático\]](http://docs.aws.amazon.com/pt_br/location/latest/developerguide/images/address-form-demo.gif)


## Experimente
<a name="address-form-try-it"></a>

### Demonstração
<a name="address-form-demo"></a>

Experimente a [demonstração do formulário de endereço](https://aws-geospatial.github.io/address-form-sdk-js/) totalmente funcional. 

### Construa você mesmo
<a name="address-form-builder"></a>

Comece [Conceitos básicos](#address-form-getting-started) a implementar formulários de endereço usando o SDK do Address Form ou experimente a abordagem sem código com o [assistente WYSIWYG Address Form Builder](https://console.aws.amazon.com/location/solution-builder/home#/address-form) do Location Service, desenvolvido por esse SDK e acessível no console do Amazon Location Service em. [https://console.aws.amazon.com/location/](https://console.aws.amazon.com/location/) Esse assistente interativo permite criar formulários personalizados com sugestões preditivas, preenchimento automático de campos e layouts flexíveis. Os desenvolvedores podem baixar ready-to-use pacotes em React JavaScript TypeScript, React ou standalone HTML/JavaScript para facilitar a integração sem escrever nenhum código.

## Recursos principais
<a name="address-form-features"></a>

Os principais recursos do SDK do formulário de endereço incluem:
+ Fornece sugestões de digitação antecipada integradas para endereços e POIs acelera a entrada de dados.
+ Permite a pesquisa configurável por tipo de local (por exemplo, códigos postais, localidades) para obter resultados mais precisos.
+ Oferece detecção automática da localização do navegador para centralizar rapidamente os usuários em sua área atual.
+ Exibe visualizações de mapas integradas para maior clareza e contexto.
+ Permite que as localizações dos endereços sejam ajustadas no mapa sem perder a localização fornecida pelo sistema, garantindo precisão e controle.
+ Inclui uma ferramenta de criação WYSIWYG que não requer codificação, economizando tempo e esforço.
+ Implementa depuração e armazenamento em cache para digitação antecipada para otimizar o desempenho e reduzir APIs custos.
+ Suporta personalização de estilo para combinar com a marca e a experiência do usuário do seu aplicativo.

Ele usa as seguintes operações de API do Amazon Location Service para fornecer informações de endereço aos formulários de endereço:

**[GetTile](https://docs.aws.amazon.com/location/latest/APIReference/API_geomaps_GetTile.html)**  
Recupera blocos do mapa para renderizar o mapa interativo para visualizar a localização do endereço e ajustar a posição de um endereço.

**[Autocompletar](https://docs.aws.amazon.com/location/latest/APIReference/API_geoplaces_Autocomplete.html)**  
Fornece sugestões de endereço em tempo real à medida que os usuários digitam.

**[Sugira](https://docs.aws.amazon.com/location/latest/APIReference/API_geoplaces_Suggest.html)**  
Fornece sugestões de endereço e POI em tempo real à medida que os usuários digitam.

**[ReverseGeocode](https://docs.aws.amazon.com/location/latest/APIReference/API_geoplaces_ReverseGeocode.html)**  
Converte a localização atual de um usuário no endereço conhecido mais próximo se ele optar por preencher automaticamente o endereço com base na localização atual.

**[GetPlace](https://docs.aws.amazon.com/location/latest/APIReference/API_geoplaces_GetPlace.html)**  
Recupera informações detalhadas sobre o local dos endereços selecionados depois de selecionar um endereço nos resultados da API Autocomplete ou Suggest.

## Preços
<a name="address-form-pricing"></a>

O SDK é gratuito e de [código aberto](https://github.com/aws-geospatial/address-form-sdk-js) sob a licença Apache-2.0. Você paga apenas pelo uso da API. Consulte a [página de preços do Amazon Location Service](https://aws.amazon.com/location/pricing/).

## Conceitos básicos
<a name="address-form-getting-started"></a>

O SDK do Formulário de Endereço pode ser usado em um aplicativo React ou em uma página e JavaScript HTML autônomos. Comece seguindo as instruções abaixo.

### Pré-requisitos
<a name="address-form-prerequisites"></a>

**nota**  
O SDK do formulário de endereço exige uma chave de API com as permissões necessárias para funcionar corretamente. Crie uma chave de API com as seguintes permissões usando o [assistente Address Form SDK Builder](https://console.aws.amazon.com/location/solution-builder/home#/address-form) no console do Amazon Location Service ou siga as instruções abaixo para criá-la manualmente.

O uso do SDK do formulário de endereço exige que as seguintes ações sejam permitidas na política de chaves de API:
+ `geo-maps:GetTile`- Isso é necessário ao exibir o componente do mapa. Veja a referência [GetTile](https://docs.aws.amazon.com/location/latest/APIReference/API_geomaps_GetTile.html)da API.
+ `geo-places:Autocomplete`- Isso é necessário ao usar a `Autocomplete` operação para a funcionalidade de digitação antecipada. Veja a referência da API de [preenchimento automático](https://docs.aws.amazon.com/location/latest/APIReference/API_geoplaces_Autocomplete.html).
+ `geo-places:Suggest`- Isso é necessário ao usar a `Suggest` operação para a funcionalidade de digitação antecipada. Veja a referência da API [Suggest](https://docs.aws.amazon.com/location/latest/APIReference/API_geoplaces_Suggest.html).
+ `geo-places:ReverseGeocode`- Isso é necessário ao permitir que os usuários forneçam sua localização atual usando a API de geolocalização dos navegadores. Veja a referência [ReverseGeocode](https://docs.aws.amazon.com/location/latest/APIReference/API_geoplaces_ReverseGeocode.html)da API.
+ `geo-places:GetPlace`- Isso é necessário ao usar a funcionalidade de digitação antecipada. Veja a referência [GetPlace](https://docs.aws.amazon.com/location/latest/APIReference/API_geoplaces_GetPlace.html)da API.

Siga o guia [Use API Keys to authenticate](https://docs.aws.amazon.com/location/latest/developerguide/using-apikeys.html) para criar uma chave de API do Amazon Location Service com as permissões necessárias.

Exemplo de política de chaves para a [CreateKey](https://docs.aws.amazon.com/location/latest/APIReference/API_geotags_CreateKey.html)API com as permissões necessárias:

#### CreateKey solicitação de permissões do Formulário de Endereço
<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"
    ]
  }
}
```

### Instalação
<a name="address-form-installation"></a>

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

Inclua o seguinte CSS e JavaScript para o SDK em seu 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>

Instale o SDK do npm: `npm install @aws/address-form-sdk-js`

### Usar o SDK do
<a name="address-form-use-sdk"></a>

Adicione o código a seguir ao seu aplicativo React. Atualize `AMAZON_LOCATION_API_KEY` com sua chave de API e `AMAZON_LOCATION_REGION` com a região em que a chave de API foi criada. Quando o formulário é enviado, o `onSubmit` retorno de chamada fornece uma função `getData` assíncrona. Chame essa função com um `intendedUse` valor para recuperar os dados do formulário.

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

**nota**  
Use `"Storage"` se precisar armazenar ou armazenar em cache os resultados. Isso garante a conformidade com os [requisitos de uso pretendido](https://docs.aws.amazon.com/location/latest/developerguide/places-intended-use.html) do 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 compatíveis
<a name="address-form-supported-countries"></a>

O SDK do Address Form suporta o preenchimento automático de endereços em todo o mundo usando o Amazon Location Service. Os seguintes países têm suporte total com a análise do campo de endereço, em que cada componente de endereço é preenchido em seu respectivo campo:
+ Austrália (AU)
+ Canadá (CA)
+ França (FR)
+ Hong Kong (HK)
+ Irlanda (IE)
+ Nova Zelândia (NZ)
+ Filipinas (PH)
+ Singapura (SG)
+ Reino Unido (GB)
+ Estados Unidos (EUA)

Todos os outros países estão no status Pré-visualização. Os países de visualização exibem o endereço completo no `addressLineOne` campo sem formatação específica do país. Versões futuras melhorarão esse comportamento e você poderá acessar essas melhorias usando a versão mais recente do SDK.

## Regiões da AWS compatíveis
<a name="address-form-supported-aws-regions"></a>

O Address Form SDK e o assistente Address Form Builder estão disponíveis em todas as regiões da AWS nas quais o Amazon Location Service opera, usando sua `Current` APIs versão. Veja a lista completa de regiões suportadas nas [regiões suportadas pela Amazon Location](https://docs.aws.amazon.com/location/latest/developerguide/location-regions.html).

## Referência da API
<a name="address-form-api-reference"></a>

Consulte a referência da [API README](https://github.com/aws-geospatial/address-form-sdk-js#api-reference).