Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

# SDKs et frameworks pour Amazon Location Service
<a name="dev-sdks"></a>

AWS fournit des kits de développement logiciel (SDKs) pour plusieurs langages de programmation, vous permettant d'intégrer facilement Amazon Location Service dans vos applications. Cette page décrit les options disponibles SDKs, leurs procédures d'installation et des exemples de code pour vous aider à démarrer avec Amazon Location Service dans votre environnement de développement préféré.

Plusieurs outils vous aideront à utiliser Amazon Location Service.
+ **AWS SDKs**— Les kits de développement AWS logiciel (SDKs) sont disponibles dans de nombreux langages de programmation courants et fournissent une API, des exemples de code et de la documentation qui facilitent la création d'applications dans la langue de votre choix. Ils AWS SDKs incluent les fonctionnalités de base d'Amazon Location APIs , notamment l'accès aux cartes, aux lieux, aux itinéraires, au géofencing et aux traceurs. Pour en savoir plus sur la SDKs possibilité d'utiliser Amazon Location Service pour différentes applications et langues, consultez[SDKs par langue](dev-by-language.md).
+ **MapLibre**— Amazon Location Service recommande de rendre les cartes à l'aide du moteur de [MapLibre](https://github.com/maplibre/maplibre-gl-js)rendu. MapLibre est un moteur permettant d'afficher des cartes dans des applications Web ou mobiles. MapLibre dispose également d'un modèle de plugin et prend en charge l'interface utilisateur pour la recherche et les itinéraires dans certaines langues et plateformes. Pour en savoir plus sur MapLibre son utilisation et ses fonctionnalités, consultez[Utiliser MapLibre les outils et les bibliothèques associées avec Amazon Location](dev-maplibre.md).
+ **Amazon Location SDKs** — Les Amazon Location SDKs sont un ensemble de bibliothèques open source qui facilitent le développement d'applications avec Amazon Location Service. Les bibliothèques fournissent des fonctionnalités permettant l'authentification pour les applications mobiles et Web, le suivi de la localisation pour les applications mobiles, la conversion entre les types de données Amazon Location et [GeoJSON](https://geojson.org/), ainsi qu'un package hébergé du client Amazon Location pour le AWS SDK v3. Pour en savoir plus sur l'emplacement Amazon SDKs, consultez[SDKs par langue](dev-by-language.md).
+ SDK **Amazon Location Migration — Le SDK** Amazon Location Migration fournit une passerelle qui vous permet de migrer des applications existantes de Google Maps vers Amazon Location. Le SDK de migration fournit une option pour votre application créée à l'aide du SDK Google Maps JavaScript afin d'utiliser Amazon Location Service sans avoir à réécrire l'application ou la logique métier si Amazon Location prend en charge les fonctionnalités utilisées. Le SDK de migration redirige tous les appels d'API vers Amazon Location plutôt que vers Google Map. Pour commencer, consultez le [SDK Amazon Location Migration](https://github.com/aws-geospatial/amazon-location-migration) sur GitHub.

# Tutoriels pour développeurs
<a name="sdk-how-to"></a>

Utilisez cette section pour découvrir comment utiliser les différents aspects du SDK Amazon Location Service.

**Topics**
+ [Comment utiliser les aides à l'authentification](how-to-auth-helper.md)
+ [Utiliser le plugin Amazon Location MapLibre Geocoder GL](dev-maplibre-geocoder.md)
+ [Comment utiliser le suivi SDKs](dev-tracking-sdk.md)
+ [Utiliser MapLibre les outils et les bibliothèques associées avec Amazon Location](dev-maplibre.md)

# Comment utiliser les aides à l'authentification
<a name="how-to-auth-helper"></a>

Cette section fournit des informations supplémentaires sur les aides à l'authentification.

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

Les utilitaires JavaScript d'authentification Amazon Location facilitent l'authentification lorsque vous effectuez des appels d'API Amazon Location Service depuis des JavaScript applications. Ces utilitaires prennent spécifiquement en charge l'authentification à l'aide de clés d'API ou d'Amazon Cognito.

**Installation**
+ Installez cette bibliothèque à l'aide de NPM :

  ```
  npm install @aws/amazon-location-utilities-auth-helper
  ```
+ Pour l'utiliser directement dans le navigateur, incluez les éléments suivants dans votre fichier HTML :

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

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

Pour utiliser les aides à l'authentification, importez la bibliothèque et appelez les fonctions utilitaires nécessaires. Cette bibliothèque prend en charge l'authentification des demandes provenant d'Amazon Location Service SDKs, y compris les demandes autonomes [Maps](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/geo-maps/), [Places](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/geo-places/) et [Routes](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/geo-routes/) SDKs, ainsi que le rendu de cartes avec [MapLibre GL](https://github.com/maplibre/maplibre-gl-js) JS.

**Utilisation avec les modules**

Cet exemple illustre l'utilisation du SDK Places autonome pour effectuer une demande authentifiée à l'aide de clés d'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);
```

Cet exemple illustre l'utilisation du SDK Routes autonome pour effectuer une demande authentifiée à l'aide de clés d'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);
```

Cet exemple utilise le SDK de localisation avec authentification par clé d'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);
```

**Utilisation avec le navigateur**

Les fonctions utilitaires sont accessibles sous l'objet global amazonLocationAuth Helper lorsqu'elles sont utilisées directement dans un environnement de navigateur.

Cet exemple illustre une demande auprès du client Amazon Location, authentifiée à l'aide de clés d'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);
```

Cet exemple illustre le rendu d'une carte avec MapLibre GL JS, authentifiée à l'aide d'une clé d'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}`,
});
```

Cet exemple illustre le rendu d'une carte avec MapLibre GL JS à l'aide d'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(),
});
```

**Utilisation alternative avec des identités authentifiées**

Vous pouvez modifier la fonction withIdentityPool Id pour inclure des paramètres personnalisés pour les identités authentifiées :

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

Le SDK Amazon Location Service Mobile Authentication pour iOS permet d'authentifier les demandes adressées à Amazon Location Service à APIs partir d'applications iOS. Il prend spécifiquement en charge l'authentification via des clés d'API ou Amazon Cognito.

**Installation**
+ Ouvrez Xcode et accédez à **Fichier > Ajouter des dépendances de package**.
+ Tapez l'URL du package ([https://github.com/aws-geospatial/amazon-location-mobile-auth-sdk-ios/](https://github.com/aws-geospatial/amazon-location-mobile-auth-sdk-ios/)) dans la barre de recherche et appuyez sur Entrée.
+ **Sélectionnez le package « amazon-location-mobile-auth -sdk-ios » et cliquez sur Ajouter un package.**
+ Choisissez le package « AmazonLocationi OSAuth SDK » et cliquez sur **Ajouter un package**.

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

Après avoir installé la bibliothèque, utilisez la `AuthHelper` classe pour configurer les paramètres du client pour les clés d'API ou pour Amazon Cognito.

**Clés d'API**

Voici un exemple d'utilisation du SDK Places autonome avec authentification par clé d'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)
}
```

Voici un exemple d'utilisation du SDK Routes autonome avec authentification par clé d'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)
}
```

Voici un exemple d'utilisation du SDK de localisation avec authentification par clé d'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)
}
```

Voici un exemple d'utilisation du SDK Places autonome avec 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)
}
```

Voici un exemple d'utilisation du SDK Routes autonome avec 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)
}
```

Voici un exemple d'utilisation du SDK de localisation avec 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>

Le SDK Amazon Location Service Mobile Authentication pour Android vous aide à authentifier les demandes adressées à Amazon Location APIs Service à partir d'applications Android, en prenant notamment en charge l'authentification à l'aide d'Amazon Cognito.

**Installation**
+ Ce SDK d'authentification fonctionne avec l'ensemble du SDK AWS Kotlin. Les deux SDKs sont publiés sur Maven Central. Vérifiez la dernière version du [SDK d'authentification](https://mvnrepository.com/artifact/software.amazon.location/auth) sur Maven Central.
+ Ajoutez les lignes suivantes à la section des dépendances de votre `build.gradle` fichier dans 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")
  ```
+ Pour les cartes, lieux et itinéraires autonomes SDKs, ajoutez les lignes suivantes :

  ```
  implementation("aws.sdk.kotlin:geomaps:1.3.65")
  implementation("aws.sdk.kotlin:geoplaces:1.3.65")
  implementation("aws.sdk.kotlin:georoutes:1.3.65")
  ```
+ Pour le SDK de localisation consolidé qui inclut le géofencing et le suivi, ajoutez la ligne suivante :

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

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

Importez les classes suivantes dans votre code :

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

Vous pouvez créer un `AuthHelper` et l'utiliser avec le SDK AWS Kotlin :

**Exemple : fournisseur d'informations d'identification avec ID de pool d'identités**

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

**Exemple : fournisseur d'informations d'identification avec fournisseur d'informations d'identification personnalisé**

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

**Exemple : fournisseur d'informations d'identification avec clé d'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())
}
```

Vous pouvez l'utiliser `LocationCredentialsProvider` pour charger la MapLibre carte. Voici un exemple :

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

Utilisez les clients créés pour passer des appels vers Amazon Location Service. Voici un exemple qui recherche des lieux proches d'une latitude et d'une longitude spécifiées :

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

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

Le plugin de MapLibre géocodeur Amazon Location est conçu pour vous permettre d'intégrer plus facilement les fonctionnalités Amazon Location dans vos JavaScript applications lorsque vous travaillez sur le rendu de cartes et le géocodage à l'aide de la [maplibre-gl-geocoder](https://github.com/maplibre/maplibre-gl-geocoder)bibliothèque.

## Installation
<a name="geocoder-installation"></a>

Installez le plugin de MapLibre géocodeur Amazon Location de NPM pour une utilisation avec les modules. Tapez cette commande :

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

Vous pouvez également importer des fichiers HTML et CSS pour les utiliser directement dans le navigateur à l'aide d'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"
/>
```

## Utilisation avec le module - SDK autonome GeoPlaces
<a name="geocoder-module"></a>

Cet exemple utilise le [AWS SDK pour JavaScript V3 pour](https://github.com/aws/aws-sdk-js-v3) obtenir un à fournir GeoPlacesClient à la bibliothèque et [AuthHelper](https://github.com/aws-geospatial/amazon-location-utilities-auth-helper-js)pour authentifier le. GeoPlacesClient Il active tout APIs pour le géocodeur.

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

## Utilisation avec un navigateur - SDK autonome GeoPlaces
<a name="geocoder-browser"></a>

Cet exemple utilise le client Amazon Location pour effectuer une demande authentifiée à l'aide d'une clé d'API.

**Note**  
Certains de ces exemples utilisent l'emplacement Amazon GeoPlacesClient. Ce client est basé sur le [AWS SDK pour JavaScript V3](https://github.com/aws/aws-sdk-js-v3) et permet de passer des appels à Amazon Location via un script référencé dans un fichier HTML.

Incluez les éléments suivants dans un fichier 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>
```

Incluez les éléments suivants dans un JavaScript fichier :

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

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

Les fonctions utilisées dans le plug-in de MapLibre géocodeur Amazon Location sont répertoriées ci-dessous :
+ `buildAmazonLocationMaplibreGeocoder`

  Cette classe crée une instance de`AmazonLocationMaplibreGeocder`, qui est le point d'entrée de tous les autres appels.

  À l'aide d'appels `GeoPlacesClient` d'API autonomes (le client est une instance de`GeoPlacesClient`) :

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

  À l'aide `LocationClient` d'appels d'API consolidés (le client est une instance de`LocationClient`) :

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

  Renvoie un ready-to-use IControl objet qui peut être ajouté directement à une carte.

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

# Comment utiliser le suivi SDKs
<a name="dev-tracking-sdk"></a>

Cette rubrique fournit des informations sur l'utilisation du suivi SDKs.

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

Le SDK de suivi mobile Amazon Location fournit des utilitaires qui permettent d'authentifier, de capturer les positions des appareils et d'envoyer des mises à jour de position à Amazon Location Trackers en toute simplicité. Le SDK prend en charge le filtrage local des mises à jour de localisation avec des intervalles de mise à jour configurables. Cela permet de réduire les coûts de données et d'optimiser la connectivité intermittente pour vos applications iOS.

Le SDK de suivi iOS est disponible sur GitHub : [Amazon Location Mobile Tracking SDK for](https://github.com/aws-geospatial/amazon-location-mobile-tracking-sdk-ios) iOS.

Cette section aborde les sujets suivants relatifs au SDK iOS de suivi mobile Amazon Location :

**Topics**
+ [Installation](#loc-mobile-tracking-install-ios)
+ [Usage](#loc-mobile-tracking-usage-ios)
+ [Filtres](#loc-mobile-tracking-ios-filters)
+ [Fonctions de suivi du SDK iOS Mobile](#loc-mobile-tracking-functions)
+ [Exemples](#loc-mobile-tracking-example-ios)

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

Pour installer le SDK de suivi mobile pour iOS, procédez comme suit :

1. Dans votre projet Xcode, accédez à **Fichier** et sélectionnez **Ajouter des dépendances de package**.

1. Tapez l'URL suivante : [https://github.com/aws-geospatial/amazon-location-mobile-tracking-sdk-ios/](https://github.com/aws-geospatial/amazon-location-mobile-tracking-sdk-ios/) dans la barre de recherche et appuyez sur la touche Entrée.

1. Sélectionnez le `amazon-location-mobile-tracking-sdk-ios` package et cliquez sur **Ajouter un package**.

1. Sélectionnez le produit `AmazonLocationiOSTrackingSDK` du package et cliquez sur **Ajouter un package**.

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

La procédure suivante explique comment créer un assistant d'authentification à l'aide des informations d'identification d'Amazon Cognito.

1. Après avoir installé la bibliothèque, vous devez ajouter l'une des descriptions ou les deux dans votre `info.plist` fichier :

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

1. Importez ensuite le AuthHelper dans votre classe :

   ```
   import AmazonLocationiOSAuthSDKimport AmazonLocationiOSTrackingSDK
   ```

1. Vous allez ensuite créer un `AuthHelper` objet et l'utiliser avec le AWS SDK, en créant un assistant d'authentification à l'aide des informations d'identification d'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)
   ```

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

Le SDK iOS de suivi mobile Amazon Location intègre trois filtres de localisation.
+ `TimeLocationFilter`: filtre l'emplacement actuel à télécharger en fonction d'un intervalle de temps défini.
+ `DistanceLocationFilter`: filtre les mises à jour de localisation en fonction d'un seuil de distance spécifié.
+ `AccuracyLocationFilter`: filtre les mises à jour de localisation en comparant la distance parcourue depuis la dernière mise à jour avec la précision de la position actuelle.

Cet exemple ajoute des filtres `LocationTracker` au moment de la création :

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

Cet exemple active et désactive le filtre lors de l'exécution avec `LocationTracker` :

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

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

## Fonctions de suivi du SDK iOS Mobile
<a name="loc-mobile-tracking-functions"></a>

Le SDK de suivi mobile Amazon Location pour iOS inclut les fonctions suivantes :
+ **Classe** : `LocationTracker`

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

  Il s'agit d'une fonction d'initialisation permettant de créer un `LocationTracker` objet. Il nécessite des instances de`LocationCredentialsProvider`, `trackerName` et éventuellement une instance de`LocationTrackingConfig`. Si la configuration n'est pas fournie, elle sera initialisée avec les valeurs par défaut.
+ **Classe** : `LocationTracker`

  `setTrackerConfig(config: LocationTrackerConfig)`

  Cela définit la configuration du Tracker pour qu'elle prenne effet à tout moment après l'initialisation du suivi de localisation.
+ **Classe** : `LocationTracker`

  `getTrackerConfig()`

  Cela permet d'obtenir la configuration de suivi de localisation à utiliser ou à modifier dans votre application.

  Retours : `LocationTrackerConfig`
+ **Classe** : `LocationTracker`

  `getDeviceId()`

  Obtient l'identifiant de l'appareil généré par le traqueur de localisation.

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

  `startTracking()`

  Lance le processus d'accès à la position de l'utilisateur et d'envoi de celle-ci au AWS tracker.
+ **Classe** : `LocationTracker`

  `resumeTracking()`

  Reprend le processus d'accès à la position de l'utilisateur et d'envoi de celle-ci au AWS traceur.
+ **Classe** : `LocationTracker`

  `stopTracking()`

  Arrête le processus de suivi de la position de l'utilisateur.
+ **Classe** : `LocationTracker`

  `startBackgroundTracking(mode: BackgroundTrackingMode)`

  Lance le processus d'accès à la position de l'utilisateur et de son envoi au AWS tracker alors que l'application est en arrière-plan. `BackgroundTrackingMode`propose les options suivantes : 
  + `Active:`Cette option n'interrompt pas automatiquement les mises à jour de localisation.
  + `BatterySaving:`Cette option suspend automatiquement les mises à jour de localisation.
  + `None:`Cette option désactive globalement les mises à jour de localisation en arrière-plan.
+ **Classe** : `LocationTracker`

  `resumeBackgroundTracking(mode: BackgroundTrackingMode)`

  Reprend le processus d'accès à la position de l'utilisateur et d'envoi de celle-ci au AWS tracker alors que l'application est en arrière-plan.
+ **Classe** : `LocationTracker`

  `stopBackgroundTracking()`

  Arrête le processus d'accès à la position de l'utilisateur et d'envoi de celle-ci au AWS tracker alors que l'application est en arrière-plan.
+ **Classe** : `LocationTracker`

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

  Récupère les emplacements de suivi téléchargés pour l'appareil de l'utilisateur entre la date et l'heure de début et de fin.

  Retours : `Void`
+ **Classe** : `LocationTrackerConfig`

  `init()`

  Cela initialise le LocationTrackerConfig avec les valeurs par défaut.
+ **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)`

  Cela initialise le `LocationTrackerConfig` avec des valeurs de paramètres définies par l'utilisateur. Si aucune valeur de paramètre n'est fournie, elle sera définie sur une valeur par défaut.
+ **Classe** : `LocationFilter`

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

  `LocationFilter`Il s'agit d'un protocole que les utilisateurs peuvent implémenter pour leur mise en œuvre de filtres personnalisés. Un utilisateur devra implémenter une `shouldUpload` fonction pour comparer l'emplacement précédent et actuel et revenir si l'emplacement actuel doit être téléchargé.

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

Cette section présente des exemples d'utilisation du SDK de suivi mobile Amazon Location pour iOS.

**Note**  
Assurez-vous que les autorisations nécessaires sont définies dans le `info.plist` fichier. Il s'agit des mêmes autorisations que celles répertoriées dans la [Usage](#loc-mobile-tracking-usage-ios) section.

L'exemple suivant illustre les fonctionnalités permettant de suivre la position des appareils et de récupérer les positions suivies :

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

Commencez à suivre la position :

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

Reprenez le suivi de la localisation :

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

Arrêtez de suivre la position :

```
locationTracker.stopTracking()
```

Démarrez le suivi en arrière-plan :

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

Suivi des antécédents du CV :

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

Pour arrêter le suivi en arrière-plan, procédez comme suit :

```
locationTracker.stopBackgroundTracking()
```

Récupérez les positions suivies de l'appareil à partir du tracker :

```
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 suivi mobile Android
<a name="loc-mobile-tracking-android"></a>

Le SDK de suivi mobile Amazon Location fournit des utilitaires qui permettent d'authentifier, de capturer les positions des appareils et d'envoyer des mises à jour de position à Amazon Location Trackers en toute simplicité. Le SDK prend en charge le filtrage local des mises à jour de localisation avec des intervalles de mise à jour configurables. Cela réduit les coûts de données et optimise la connectivité intermittente pour vos applications Android.

Le SDK de suivi Android est disponible sur GitHub : [Amazon Location Mobile Tracking SDK for](https://github.com/aws-geospatial/amazon-location-mobile-tracking-sdk-android) Android. En outre, le SDK d'authentification mobile et le AWS SDK sont disponibles dans le référentiel [AWS Maven](https://central.sonatype.com/artifact/software.amazon.location/tracking). Le SDK de suivi Android est conçu pour fonctionner avec le AWS SDK général.

Cette section couvre les sujets suivants relatifs au SDK Android de suivi mobile Amazon Location :

**Topics**
+ [Installation](#loc-mobile-tracking-install-android)
+ [Usage](#loc-mobile-tracking-usage-android)
+ [Filtres](#loc-mobile-tracking-android-filters)
+ [Fonctions de suivi du SDK Android Mobile](#loc-mobile-tracking-functions)
+ [Exemples](#loc-mobile-tracking-example-android)

## Installation
<a name="loc-mobile-tracking-install-android"></a>

Pour installer le SDK, ajoutez les lignes suivantes à la section des dépendances de votre fichier build.gradle dans 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>

Cette procédure explique comment utiliser le SDK pour authentifier et créer l'`LocationTracker`objet :

**Note**  
Cette procédure suppose que vous avez importé la bibliothèque mentionnée dans la [Installation](#loc-mobile-tracking-install-android) section.

1. Importez les classes suivantes dans votre code :

   ```
   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. Créez ensuite un`AuthHelper`, puisque le `LocationCredentialsProvider` paramètre est obligatoire pour créer un `LocationTracker` objet :

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

1. Maintenant, utilisez le `LocationCredentialsProvider` et `LocationTrackerConfig` pour créer un `LocationTracker` objet :

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

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

Le SDK Android de suivi mobile Amazon Location intègre trois filtres de localisation.
+ `TimeLocationFilter`: filtre l'emplacement actuel à télécharger en fonction d'un intervalle de temps défini.
+ `DistanceLocationFilter`: filtre les mises à jour de localisation en fonction d'un seuil de distance spécifié.
+ `AccuracyLocationFilter`: filtre les mises à jour de localisation en comparant la distance parcourue depuis la dernière mise à jour avec la précision de la position actuelle.

Cet exemple ajoute des filtres `LocationTracker` au moment de la création :

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

Cet exemple active et désactive le filtre lors de l'exécution avec `LocationTracker` :

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

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

## Fonctions de suivi du SDK Android Mobile
<a name="loc-mobile-tracking-functions"></a>

Le SDK de suivi mobile Amazon Location pour Android inclut les fonctions suivantes :
+ **Classe** : `LocationTracker`

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

  Il s'agit d'une fonction d'initialisation permettant de créer un `LocationTracker` objet. Il nécessite des instances de`LocationCredentialsProvider`, `trackerName` et éventuellement une instance de`LocationTrackingConfig`. Si la configuration n'est pas fournie, elle sera initialisée avec les valeurs par défaut.
+ **Classe** : `LocationTracker`

  `start(locationTrackingCallback: LocationTrackingCallback)`

  Lance le processus d'accès à la position de l'utilisateur et de son envoi à un outil de suivi de localisation Amazon.
+ **Classe** : `LocationTracker`

  `isTrackingInForeground()`

  Vérifie si le suivi de localisation est actuellement en cours.
+ **Classe** : `LocationTracker`

  `stop()`

  Arrête le processus de suivi de la position de l'utilisateur.
+ **Classe** : `LocationTracker`

  `startTracking()`

  Lance le processus d'accès à la position de l'utilisateur et d'envoi de celle-ci au AWS tracker.
+ **Classe** : `LocationTracker`

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

  Lance le processus d'accès à la position de l'utilisateur et de son envoi au AWS tracker alors que l'application est en arrière-plan. `BackgroundTrackingMode`propose les options suivantes :
  + `ACTIVE_TRACKING`: Cette option suit activement les mises à jour de localisation d'un utilisateur. 
  + `BATTERY_SAVER_TRACKING`: Cette option suit les mises à jour de localisation de l'utilisateur toutes les 15 minutes.
+ **Classe** : `LocationTracker`

  `stopBackgroundService()`

  Arrête le processus d'accès à la position de l'utilisateur et d'envoi de celle-ci au AWS tracker alors que l'application est en arrière-plan.
+ **Classe** : `LocationTracker`

  `getTrackerDeviceLocation()`

  Récupère l'emplacement de l'appareil auprès des services de localisation Amazon. 
+ **Classe** : `LocationTracker`

  `getDeviceLocation(locationTrackingCallback: LocationTrackingCallback?)`

  Récupère la position actuelle de l'appareil auprès du client du fournisseur de localisation fusionné et la télécharge sur Amazon Location Tracker.
+ **Classe** : `LocationTracker`

  `uploadLocationUpdates(locationTrackingCallback: LocationTrackingCallback?)`

  Télécharge la position de l'appareil vers les services de localisation Amazon après avoir filtré en fonction des filtres de localisation configurés.
+ **Classe** : `LocationTracker`

  `enableFilter(filter: LocationFilter)`

  Active un filtre de localisation spécifique.
+ **Classe** : `LocationTracker`

  `checkFilterIsExistsAndUpdateValue(filter: LocationFilter)`

  Désactivez un filtre de localisation particulier.
+ **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()) `

  Cela initialise le `LocationTrackerConfig` avec des valeurs de paramètres définies par l'utilisateur. Si aucune valeur de paramètre n'est fournie, elle sera définie sur une valeur par défaut.
+ **Classe** : `LocationFilter`

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

  `LocationFilter`Il s'agit d'un protocole que les utilisateurs peuvent implémenter pour implémenter leur filtre personnalisé. Vous devez implémenter la `shouldUpload` fonction pour comparer l'emplacement précédent et actuel et indiquer si l'emplacement actuel doit être téléchargé.

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

L'exemple de code suivant illustre les fonctionnalités du SDK de suivi mobile.

Cet exemple utilise le `LocationTracker` pour démarrer et arrêter le suivi en arrière-plan :

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

# Utiliser MapLibre les outils et les bibliothèques associées avec Amazon Location
<a name="dev-maplibre"></a>

[MapLibre](https://maplibre.org/)est principalement un moteur de rendu permettant d'afficher des cartes dans une application Web ou mobile. Cependant, il inclut également la prise en charge des plug-ins et fournit des fonctionnalités permettant de travailler avec d'autres aspects d'Amazon Location. Les outils suivants décrivent les outils que vous pouvez utiliser, en fonction de la zone ou de l'emplacement avec lequel vous souhaitez travailler.

**Note**  
Pour utiliser n'importe quel aspect d'Amazon Location, installez le [AWS SDK correspondant à la langue que vous souhaitez utiliser](dev-by-language.md).
+ **Cartes**

  Pour afficher des cartes dans votre application, vous avez besoin d'un moteur de rendu cartographique qui utilise les données fournies par Amazon Location et dessine à l'écran. Les moteurs de rendu de carte fournissent également des fonctionnalités permettant de déplacer et de zoomer la carte, ou d'ajouter des marqueurs, des punaises et d'autres annotations à la carte.

  Amazon Location Service recommande de rendre les cartes à l'aide du moteur de [MapLibre](https://github.com/maplibre/maplibre-gl-js)rendu. MapLibre GL JS est un moteur d'affichage de cartes JavaScript, tandis que MapLibre Native fournit des cartes pour iOS ou Android.

  MapLibre dispose également d'un écosystème de plug-ins pour étendre les fonctionnalités de base. Pour plus d'informations, rendez-vous [sur https://maplibre. org/maplibre-gl-js/docs/plugins](https://maplibre.org/maplibre-gl-js/docs/plugins/)/.
+ **Recherche de lieux**

  Pour simplifier la création d'une interface utilisateur de recherche, vous pouvez utiliser le [MapLibre géocodeur](https://github.com/maplibre/maplibre-gl-geocoder) pour le Web (les applications Android peuvent utiliser le [plug-in Android Places](https://github.com/maplibre/maplibre-plugins-android/tree/master/plugin-places)).

  Utilisez la [bibliothèque Amazon Location for MapLibre Geocoder](https://github.com/aws-geospatial/amazon-location-for-maplibre-gl-geocoder?tab=readme-ov-file) pour simplifier le processus d'utilisation d'Amazon Location `amazon-location-for-maplibre-gl-geocoder` dans les JavaScript applications.

  Pour de plus amples informations, veuillez consulter [Utiliser le plugin Amazon Location MapLibre Geocoder GL](dev-maplibre-geocoder.md).
+ **Itinéraires**
+ **Geofences et traceurs**

  MapLibre ne dispose pas d'outils de rendu ou d'outils spécifiques pour les géofences et le suivi, mais vous pouvez utiliser la fonctionnalité de rendu et les [plug-ins](https://maplibre.org/maplibre-gl-js/docs/plugins/) pour afficher les géofences et les appareils suivis sur la carte.

  Les appareils suivis peuvent utiliser le [MQTT](tracking-using-mqtt.md) ou envoyer manuellement des mises à jour à Amazon Location Service. Les événements Geofence peuvent être traités en utilisant. [AWS Lambda](https://docs.aws.amazon.com/lambda/)

De nombreuses bibliothèques open source sont disponibles pour fournir des fonctionnalités supplémentaires à Amazon Location Service, par exemple [Turf](https://github.com/Turfjs/turf) qui fournit des fonctionnalités d'analyse spatiale.

De nombreuses bibliothèques utilisent les données au format [GeoJSON](https://geojson.org/) standard ouvert. Amazon Location Service fournit une bibliothèque permettant de convertir les réponses en GeoJSON pour une utilisation dans JavaScript des applications. Pour de plus amples informations, veuillez consulter [SDKs et frameworks pour Amazon Location Service](dev-sdks.md). 

# SDKs par langue
<a name="dev-by-language"></a>

**Versions du SDK**  
Nous vous recommandons d'utiliser la version la plus récente du AWS SDK, ainsi que toute autre SDKs version que vous utilisez dans vos projets, et de la maintenir SDKs à jour. Le AWS SDK vous fournit les fonctionnalités les plus récentes, ainsi que des mises à jour de sécurité. Pour trouver la dernière version du AWS SDK pour JavaScript, par exemple, consultez la rubrique relative à l'[installation du navigateur](https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/index.html#In_the_Browser) dans le *AWS SDK pour obtenir JavaScript* de la documentation.

Les tableaux suivants fournissent des informations sur AWS SDKs les versions du Map Rendering Framework pour les langages et les frameworks, par type d'application : application Web, mobile ou principale.

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

Les versions suivantes AWS SDKs et Map Rendering Framework sont disponibles pour le développement d'applications Web frontales.


| Langage/Framework | AWS SDK | Cadre de rendu cartographique | 
| --- | --- | --- | 
|  **Entièrement pris en charge**  | 
|  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)  | 
|  **Partiellement pris en charge**  | 
|  Flottement  |  [https://docs.amplify. aws/start/q/integration/flutter](https://docs.amplify.aws/start/q/integration/flutter/)/ Flutter n'est pas encore entièrement pris en charge par AWS Amplify, mais un support limité est proposé.  |  [https://github.com/maplibre/flutter-maplibre-gl](https://github.com/maplibre/flutter-maplibre-gl) La bibliothèque MapLibre Flutter est considérée comme expérimentale.  | 
|  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/)  |  Il n'y a aucun MapLibre support pour PHP.  | 

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

Les versions suivantes AWS SDKs et Map Rendering Framework sont disponibles pour le développement d'applications frontales mobiles.


| Langage/Framework | AWS SDK | Cadre de rendu cartographique | 
| --- | --- | --- | 
|  **Entièrement pris en charge**  | 
|  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 d'authentification mobile Amazon Location Service pour Android : -sdk-android https://github.com/aws-geospatial/ amazon-location-mobile-auth](https://github.com/aws-geospatial/amazon-location-mobile-auth-sdk-android) [SDK de suivi mobile Amazon Location Service pour Android : -sdk-android https://github.com/aws-geospatial/ amazon-location-mobile-tracking](https://github.com/aws-geospatial/amazon-location-mobile-tracking-sdk-android)  |  [https://github.com/maplibre/maplibre-native](https://github.com/maplibre/maplibre-native) Nécessite des liaisons personnalisées, comme MapLibre c'est le cas 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)  | 
|  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/) [SDK d'authentification mobile Amazon Location Service pour iOS : -sdk-ios https://github.com/aws-geospatial/ amazon-location-mobile-auth](https://github.com/aws-geospatial/amazon-location-mobile-auth-sdk-ios) [SDK de suivi mobile Amazon Location Service pour iOS : -sdk-ios https://github.com/aws-geospatial/ amazon-location-mobile-tracking](https://github.com/aws-geospatial/amazon-location-mobile-tracking-sdk-ios)  |  [https://github.com/maplibre/maplibre-native](https://github.com/maplibre/maplibre-native)  | 
|  **Partiellement pris en charge**  | 
|  Flottement  |  [https://docs.amplify. aws/start/q/integration/flutter](https://docs.amplify.aws/start/q/integration/flutter/)/ Flutter n'est pas encore entièrement pris en charge par AWS Amplify, mais un support limité est proposé.  |  [https://github.com/maplibre/flutter-maplibre-gl](https://github.com/maplibre/flutter-maplibre-gl) La bibliothèque MapLibre Flutter est considérée comme expérimentale.  | 

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

Les éléments suivants AWS SDKs sont disponibles pour le développement d'applications backend. Les frameworks de rendu cartographique ne sont pas répertoriés ici, car le rendu cartographique n'est généralement pas nécessaire pour les applications principales.


| Langue | 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/) Le AWS SDK pour Rust est en version préliminaire pour les développeurs.  | 

------

# SDK de rendu cartographique par langue
<a name="map-rendering-by-language"></a>

Nous recommandons le rendu des cartes Amazon Location Service à l'aide du moteur de [MapLibre](https://github.com/maplibre/maplibre-gl-js)rendu.

MapLibre est un moteur permettant d'afficher des cartes dans des applications Web ou mobiles. MapLibredispose également d'un modèle de plugin et prend en charge les interfaces utilisateur pour la recherche et les itinéraires dans certaines langues et plateformes. 

Pour en savoir plus sur MapLibre son utilisation et ses fonctionnalités, consultez [Utiliser MapLibre les outils et les bibliothèques associées avec Amazon Location](dev-maplibre.md) et[Comment utiliser des cartes dynamiques](dynamic-maps-how-to.md). 

Les tableaux suivants fournissent des informations sur SDKs les versions de rendu cartographique pour les langages et les frameworks, par type d'application : application Web ou mobile.

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

Les rendus cartographiques suivants SDKs sont disponibles pour le développement d'applications Web frontales.


| Langage/Framework | Cadre de rendu cartographique | 
| --- | --- | 
|  **Entièrement pris en charge**  | 
|  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)  | 
|  **Partiellement pris en charge**  | 
|  Flottement  |  [https://github.com/maplibre/flutter-maplibre-gl](https://github.com/maplibre/flutter-maplibre-gl) La bibliothèque MapLibre Flutter est considérée comme expérimentale.  | 
|  Node.js  |   Node.js n'est pas MapLibre pris en charge.  | 
|  PHP  |   Il n'y a aucun MapLibre support pour PHP.  | 

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

Les rendus cartographiques suivants SDKs sont disponibles pour le développement d'applications frontales mobiles.


| Langage/Framework | Cadre de rendu cartographique | 
| --- | --- | 
|  **Entièrement pris en charge**  | 
|  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) Nécessite des liaisons personnalisées, comme MapLibre c'est le cas en 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)  | 
|  **Partiellement pris en charge**  | 
|  Flottement  |  [https://github.com/maplibre/flutter-maplibre-gl](https://github.com/maplibre/flutter-maplibre-gl) La bibliothèque MapLibre Flutter est considérée comme expérimentale.  | 

------

# SDK de formulaire d'adresse
<a name="address-form-sdk"></a>

Le SDK Address Form rationalise la création de formulaires de saisie d'adresses intelligents. Les formulaires d'adresse créés avec le SDK fournissent des suggestions d'adresses pertinentes lorsque les utilisateurs commencent à taper du texte. Lorsqu'un utilisateur sélectionne une suggestion, un formulaire d'adresse remplit automatiquement les champs tels que la ville, l'État et le code postal. Cela réduit les erreurs et accélère la saisie des données en minimisant la saisie manuelle. Les utilisateurs peuvent également prévisualiser l'adresse sélectionnée sur une carte et ajuster son épingle de localisation pour indiquer des entrées ou des lieux de prise en charge spécifiques, ce qui améliore considérablement la précision.

![\[Démonstration du SDK Address Form illustrant la fonctionnalité de saisie semi-automatique\]](http://docs.aws.amazon.com/fr_fr/location/latest/developerguide/images/address-form-demo.gif)


## À vous d'essayer \$1
<a name="address-form-try-it"></a>

### Démonstration
<a name="address-form-demo"></a>

Essayez la [démo du formulaire d'adresse](https://aws-geospatial.github.io/address-form-sdk-js/) entièrement fonctionnelle. 

### Construisez-le vous-même
<a name="address-form-builder"></a>

Pour commencer [Démarrage](#address-form-getting-started) à implémenter des formulaires d'adresse à l'aide du SDK Address Form, ou essayez l'approche sans code avec l'[assistant WYSIWYG Address Form Builder du Service de localisation, alimenté par ce SDK et accessible depuis la console Amazon Location Service à l'adresse](https://console.aws.amazon.com/location/solution-builder/home#/address-form). [https://console.aws.amazon.com/location/](https://console.aws.amazon.com/location/) Cet assistant interactif vous permet de créer des formulaires personnalisés avec des suggestions prédictives, un remplissage automatique des champs et des mises en page flexibles. Les développeurs peuvent télécharger ready-to-use des packages dans React JavaScript TypeScript, React ou de manière autonome HTML/JavaScript pour une intégration facile sans écrire de code.

## Fonctionnalités principales
<a name="address-form-features"></a>

Les principales fonctionnalités du SDK Address Form sont les suivantes :
+ Fournit des suggestions d'adresses dactylographiées intégrées et POIs accélère la saisie des données.
+ Permet une recherche par type de lieu configurable (par exemple, codes postaux, localités) pour des résultats plus précis.
+ Permet de détecter automatiquement l'emplacement du navigateur afin de recentrer rapidement les utilisateurs sur leur zone actuelle.
+ Affiche des visualisations cartographiques intégrées pour plus de clarté et de contexte.
+ Permet d'ajuster les emplacements des adresses sur la carte sans perdre l'emplacement fourni par le système, ce qui garantit à la fois précision et contrôle.
+ Inclut un outil de création WYSIWYG qui ne nécessite aucun codage, ce qui permet d'économiser du temps et des efforts.
+ Implémente le rebond et la mise en cache pour Typeahead APIs afin d'optimiser les performances et de réduire les coûts.
+ Permet de personnaliser le style en fonction de la marque et de l'expérience utilisateur de votre application.

Il utilise les opérations d'API Amazon Location Service suivantes pour fournir des informations d'adresse aux formulaires d'adresse :

**[GetTile](https://docs.aws.amazon.com/location/latest/APIReference/API_geomaps_GetTile.html)**  
Récupère les tuiles de carte pour le rendu de la carte interactive afin de visualiser l'emplacement de l'adresse et d'ajuster la position d'une adresse.

**[Remplissage automatique](https://docs.aws.amazon.com/location/latest/APIReference/API_geoplaces_Autocomplete.html)**  
Fournit des suggestions d'adresses en temps réel à mesure que les utilisateurs saisissent.

**[Suggérer](https://docs.aws.amazon.com/location/latest/APIReference/API_geoplaces_Suggest.html)**  
Fournit des suggestions d'adresses et de POI en temps réel au fur et à mesure que les utilisateurs saisissent

**[ReverseGeocode](https://docs.aws.amazon.com/location/latest/APIReference/API_geoplaces_ReverseGeocode.html)**  
Convertit l'emplacement actuel d'un utilisateur en l'adresse connue la plus proche s'il choisit de renseigner automatiquement son adresse en fonction de sa position actuelle.

**[GetPlace](https://docs.aws.amazon.com/location/latest/APIReference/API_geoplaces_GetPlace.html)**  
Récupère des informations détaillées sur le lieu pour les adresses sélectionnées après avoir sélectionné une adresse à partir des résultats de l'API Autocomplete ou Suggest.

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

Le SDK est gratuit et [open source sous licence](https://github.com/aws-geospatial/address-form-sdk-js) Apache-2.0. Vous ne payez que pour l'utilisation de l'API. Consultez la [page de tarification d'Amazon Location Service](https://aws.amazon.com/location/pricing/).

## Démarrage
<a name="address-form-getting-started"></a>

Le SDK Address Form peut être utilisé dans une application React ou dans un code HTML et JavaScript une page autonomes. Commencez en suivant les instructions ci-dessous.

### Conditions préalables
<a name="address-form-prerequisites"></a>

**Note**  
Le SDK Address Form nécessite une clé d'API dotée des autorisations requises pour fonctionner correctement. Créez une clé d'API avec les autorisations suivantes à l'aide de l'[assistant Address Form SDK Builder](https://console.aws.amazon.com/location/solution-builder/home#/address-form) de la console Amazon Location Service, ou suivez les instructions ci-dessous pour la créer manuellement.

L'utilisation du SDK Address Form nécessite que les actions suivantes soient autorisées dans la politique des clés d'API :
+ `geo-maps:GetTile`- Cela est obligatoire lors de l'affichage du composant cartographique. Consultez la référence de [GetTile](https://docs.aws.amazon.com/location/latest/APIReference/API_geomaps_GetTile.html)l'API.
+ `geo-places:Autocomplete`- Cela est nécessaire lors de l'utilisation de l'`Autocomplete`opération pour la fonctionnalité de saisie anticipée. Consultez la référence de l'API [Autocomplete](https://docs.aws.amazon.com/location/latest/APIReference/API_geoplaces_Autocomplete.html).
+ `geo-places:Suggest`- Cela est nécessaire lors de l'utilisation de l'`Suggest`opération pour la fonctionnalité de saisie anticipée. Consultez la référence de l'API [Suggest](https://docs.aws.amazon.com/location/latest/APIReference/API_geoplaces_Suggest.html).
+ `geo-places:ReverseGeocode`- Cela est nécessaire lorsque vous autorisez les utilisateurs à fournir leur position actuelle à l'aide de l'API de géolocalisation des navigateurs. Consultez la référence de [ReverseGeocode](https://docs.aws.amazon.com/location/latest/APIReference/API_geoplaces_ReverseGeocode.html)l'API.
+ `geo-places:GetPlace`- Cela est nécessaire lors de l'utilisation de la fonctionnalité Typeahead. Consultez la référence de [GetPlace](https://docs.aws.amazon.com/location/latest/APIReference/API_geoplaces_GetPlace.html)l'API.

Suivez le guide [Utiliser les clés d'API pour vous authentifier](https://docs.aws.amazon.com/location/latest/developerguide/using-apikeys.html) afin de créer une clé d'API Amazon Location Service avec les autorisations nécessaires.

Exemple de politique clé pour l'[CreateKey](https://docs.aws.amazon.com/location/latest/APIReference/API_geotags_CreateKey.html)API avec les autorisations requises :

#### CreateKey demande d'autorisations pour le formulaire d'adresse
<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"
    ]
  }
}
```

### Installation
<a name="address-form-installation"></a>

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

Incluez le code CSS et JavaScript le SDK suivants dans votre code 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>

Installez le SDK depuis npm : `npm install @aws/address-form-sdk-js`

### Utiliser le SDK
<a name="address-form-use-sdk"></a>

Ajoutez le code suivant à votre application React. Effectuez la mise à jour `AMAZON_LOCATION_API_KEY` avec votre clé d'API et `AMAZON_LOCATION_REGION` avec la région où la clé d'API a été créée. Lorsque le formulaire est soumis, le `onSubmit` rappel fournit une fonction `getData` asynchrone. Appelez cette fonction avec une `intendedUse` valeur pour récupérer les données du formulaire.

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

**Note**  
À utiliser `"Storage"` si vous devez stocker ou mettre en cache les résultats. Cela garantit la conformité aux [exigences d'utilisation prévues d'](https://docs.aws.amazon.com/location/latest/developerguide/places-intended-use.html)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>
  );
}
```

------

## Pays pris en charge
<a name="address-form-supported-countries"></a>

Le SDK Address Form prend en charge le remplissage automatique des adresses dans le monde entier à l'aide d'Amazon Location Service. Les pays suivants offrent une prise en charge complète de l'analyse des champs d'adresse, chaque composant d'adresse étant renseigné dans son champ respectif :
+ Australie (AU)
+ Canada (CA)
+ France (FR)
+ Hong Kong (HK)
+ Irlande (IE)
+ Nouvelle-Zélande (NZ)
+ Philippines (PH)
+ Singapour (SG)
+ Royaume-Uni (GB)
+ États-Unis (US)

Tous les autres pays sont en version préliminaire. Les pays d'aperçu affichent l'adresse complète dans le `addressLineOne` champ sans mise en forme spécifique au pays. Les prochaines versions amélioreront ce comportement et vous pourrez accéder à ces améliorations en utilisant la dernière version du SDK.

## Régions AWS prises en charge
<a name="address-form-supported-aws-regions"></a>

Le SDK Address Form et l'assistant Address Form Builder sont disponibles dans toutes les régions AWS où Amazon Location Service opère, en utilisant la `Current` version de celui-ci APIs. Consultez la liste complète des régions prises en charge dans les régions prises en [charge par Amazon Location](https://docs.aws.amazon.com/location/latest/developerguide/location-regions.html).

## Référence d’API
<a name="address-form-api-reference"></a>

Reportez-vous à la référence de [l'API README](https://github.com/aws-geospatial/address-form-sdk-js#api-reference).