Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

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

AWS fornisce Software Development Kit (SDKs) per più linguaggi di programmazione, che ti consentono di integrare facilmente Amazon Location Service nelle tue applicazioni. Questa pagina descrive i servizi disponibili SDKs, le relative procedure di installazione ed esempi di codice per aiutarti a iniziare a usare Amazon Location Service nel tuo ambiente di sviluppo preferito.

Esistono diversi strumenti che ti aiuteranno a utilizzare Amazon Location Service.
+ **AWS SDKs**— I kit di sviluppo AWS software (SDKs) sono disponibili in molti linguaggi di programmazione più diffusi e forniscono un'API, esempi di codice e documentazione che semplifica la creazione di applicazioni nel linguaggio preferito. AWS SDKs Includono la posizione APIs e le funzionalità principali di Amazon, incluso l'accesso a mappe, luoghi, percorsi, geofencing e tracker. Per ulteriori informazioni sulla SDKs disponibilità all'uso con Amazon Location Service per diverse applicazioni e lingue, consulta[SDKs per lingua](dev-by-language.md).
+ **MapLibre**— Amazon Location Service consiglia di eseguire il rendering delle mappe utilizzando il motore di [MapLibre](https://github.com/maplibre/maplibre-gl-js)rendering. MapLibre è un motore per la visualizzazione di mappe in applicazioni web o mobili. MapLibre ha anche un modello di plugin e supporta l'interfaccia utente per la ricerca e i percorsi in alcune lingue e piattaforme. Per ulteriori informazioni sull'utilizzo MapLibre e sulle funzionalità che offre, consulta[Usa MapLibre strumenti e librerie correlate con Amazon Location](dev-maplibre.md).
+ **Amazon Location SDKs**: Amazon Location SDKs è un insieme di librerie open source che semplificano lo sviluppo di applicazioni con Amazon Location Service. Le librerie forniscono funzionalità per supportare l'autenticazione per applicazioni mobili e Web, il tracciamento della posizione per le applicazioni mobili, la conversione tra tipi di dati Amazon Location e [GeoJSON](https://geojson.org/), nonché un pacchetto ospitato del client Amazon Location per AWS l'SDK v3. Per ulteriori informazioni su Amazon Location SDKs, consulta[SDKs per lingua](dev-by-language.md).
+ **Amazon Location Migration SDK**: l'Amazon Location Migration SDK fornisce un bridge che consente di migrare le applicazioni esistenti da Google Maps ad Amazon Location. L'SDK di migrazione offre un'opzione per la tua applicazione creata utilizzando l'SDK di Google Maps JavaScript per utilizzare Amazon Location Service senza dover riscrivere alcuna applicazione o logica aziendale se Amazon Location supporta le funzionalità utilizzate. L'SDK di migrazione reindirizza tutte le chiamate API verso Amazon Location anziché su Google Map. Per iniziare, consulta [Amazon Location Migration SDK](https://github.com/aws-geospatial/amazon-location-migration) su GitHub.

# Tutorial per sviluppatori
<a name="sdk-how-to"></a>

Utilizza questa sezione per imparare a utilizzare vari aspetti dell'SDK Amazon Location Service.

**Topics**
+ [

# Come usare gli aiutanti di autenticazione
](how-to-auth-helper.md)
+ [

# Usa il plug-in Amazon Location MapLibre Geocoder GL
](dev-maplibre-geocoder.md)
+ [

# Come usare il tracciamento SDKs
](dev-tracking-sdk.md)
+ [

# Usa MapLibre strumenti e librerie correlate con Amazon Location
](dev-maplibre.md)

# Come usare gli aiutanti di autenticazione
<a name="how-to-auth-helper"></a>

Questa sezione fornisce informazioni aggiuntive sugli helper di autenticazione.

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

Le utilità di JavaScript autenticazione di Amazon Location aiutano nell'autenticazione quando si effettuano chiamate API Amazon Location Service dalle applicazioni. JavaScript Queste utilità supportano specificamente l'autenticazione tramite chiavi API o Amazon Cognito.

**Installazione**
+ Installa questa libreria usando NPM:

  ```
  npm install @aws/amazon-location-utilities-auth-helper
  ```
+ Per utilizzarla direttamente nel browser, includi quanto segue nel tuo file HTML:

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

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

Per utilizzare gli helper di autenticazione, importate la libreria e richiamate le funzioni di utilità necessarie. [Questa libreria supporta l'autenticazione delle richieste da Amazon Location Service SDKs, incluso lo standalone [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/) SDKs, oltre al rendering di mappe con MapLibre GL JS.](https://github.com/maplibre/maplibre-gl-js)

**Utilizzo con i moduli**

Questo esempio dimostra l'uso dell'SDK autonomo di Places per effettuare una richiesta autenticata con chiavi 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);
```

Questo esempio dimostra l'uso dell'SDK Routes standalone per effettuare una richiesta autenticata con chiavi 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);
```

Questo esempio utilizza Location SDK con autenticazione tramite chiave 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);
```

**Utilizzo con Browser**

Le funzioni di utilità sono accessibili tramite l'oggetto globale amazonLocationAuth Helper se utilizzate direttamente in un ambiente browser.

Questo esempio dimostra una richiesta con Amazon Location Client, autenticata tramite chiavi 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);
```

Questo esempio dimostra il rendering di una mappa con MapLibre GL JS, autenticata con una chiave 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}`,
});
```

Questo esempio dimostra il rendering di una mappa con MapLibre GL JS utilizzando 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(),
});
```

**Utilizzo alternativo con identità autenticate**

È possibile modificare la funzione withIdentityPool Id per includere parametri personalizzati per le identità autenticate:

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

L'Amazon Location Service Mobile Authentication SDK per iOS aiuta ad autenticare le richieste ad Amazon Location Service APIs dalle applicazioni iOS. Supporta specificamente l'autenticazione tramite chiavi API o Amazon Cognito.

**Installazione**
+ Apri Xcode e vai su **File > Aggiungi dipendenze del pacchetto**.
+ Digita l'URL del pacchetto ([https://github.com/aws-geospatial/amazon-location-mobile-auth-sdk-ios/](https://github.com/aws-geospatial/amazon-location-mobile-auth-sdk-ios/)) nella barra di ricerca e premi Invio.
+ **Seleziona il pacchetto "amazon-location-mobile-auth-sdk-ios» e fai clic su Aggiungi pacchetto.**
+ Scegli il prodotto del pacchetto "AmazonLocationiOSAuthSDK» e fai clic su **Aggiungi pacchetto**.

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

Dopo aver installato la libreria, usa la `AuthHelper` classe per configurare le impostazioni del client per le chiavi API o Amazon Cognito.

**Chiavi API**

Ecco un esempio di utilizzo dell'SDK Places standalone con autenticazione tramite chiave 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)
}
```

Ecco un esempio di utilizzo dell'SDK Routes standalone con autenticazione tramite chiave 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)
}
```

Ecco un esempio di utilizzo del Location SDK con autenticazione tramite chiave 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)
}
```

Ecco un esempio di utilizzo dell'SDK Places standalone con Amazon Cognito:

```
import AmazonLocationiOSAuthSDK
import AWSGeoPlaces

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

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

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

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

Ecco un esempio di utilizzo dell'SDK Routes standalone con Amazon Cognito:

```
import AmazonLocationiOSAuthSDK
import AWSGeoRoutes

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

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

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

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

Ecco un esempio di utilizzo del Location SDK con Amazon Cognito:

```
import AmazonLocationiOSAuthSDK
import AWSLocation

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

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

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

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

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

L'Amazon Location Service Mobile Authentication SDK per Android ti aiuta ad autenticare le richieste ad Amazon Location APIs Service da applicazioni Android, supportando in particolare l'autenticazione tramite Amazon Cognito.

**Installazione**
+ Questo SDK di autenticazione funziona con l'SDK AWS Kotlin complessivo. Entrambi SDKs sono pubblicati su Maven Central. Controlla l'ultima versione dell'[SDK di autenticazione](https://mvnrepository.com/artifact/software.amazon.location/auth) su Maven Central.
+ Aggiungi le seguenti righe alla sezione delle dipendenze del tuo `build.gradle` file in 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")
  ```
+ Per la versione autonoma di Maps, Places e Routes SDKs, aggiungi le seguenti righe:

  ```
  implementation("aws.sdk.kotlin:geomaps:1.3.65")
  implementation("aws.sdk.kotlin:geoplaces:1.3.65")
  implementation("aws.sdk.kotlin:georoutes:1.3.65")
  ```
+ Per il Location SDK consolidato che include Geofencing and Tracking, aggiungi la seguente riga:

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

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

Importa le seguenti classi nel tuo codice:

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

Puoi crearne uno `AuthHelper` e usarlo con AWS Kotlin SDK:

**Esempio: fornitore di credenziali con ID Identity Pool**

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

**Esempio: fornitore di credenziali con provider di credenziali personalizzato**

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

**Esempio: fornitore di credenziali con chiave 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())
}
```

È possibile utilizzare `LocationCredentialsProvider` per caricare la MapLibre mappa. Ecco un esempio:

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

Usa i client creati per effettuare chiamate verso Amazon Location Service. Ecco un esempio di ricerca di luoghi vicini a una latitudine e una longitudine specificate:

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

# Usa il plug-in Amazon Location MapLibre Geocoder GL
<a name="dev-maplibre-geocoder"></a>

Il plug-in di MapLibre geocodifica Amazon Location è progettato per semplificare l'integrazione della funzionalità di Amazon Location nelle tue JavaScript applicazioni, quando lavori con il rendering di mappe e la geocodifica utilizzando la libreria. [maplibre-gl-geocoder](https://github.com/maplibre/maplibre-gl-geocoder)

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

Installa il plug-in Amazon Location MapLibre geocoder da NPM per l'utilizzo con i moduli. Digita questo comando:

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

Puoi anche importare file HTML e CSS da utilizzare direttamente nel browser con uno 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"
/>
```

## Utilizzo con modulo: SDK standalone GeoPlaces
<a name="geocoder-module"></a>

Questo esempio utilizza l'[AWS SDK per JavaScript V3 per](https://github.com/aws/aws-sdk-js-v3) ottenere un file da fornire GeoPlacesClient alla libreria e [AuthHelper](https://github.com/aws-geospatial/amazon-location-utilities-auth-helper-js)per autenticare il. GeoPlacesClient Abilita tutto per il geocoder APIs .

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

## Utilizzo con un browser: SDK autonomo GeoPlaces
<a name="geocoder-browser"></a>

Questo esempio utilizza il client Amazon Location per effettuare una richiesta di autenticazione tramite una chiave API.

**Nota**  
Alcuni di questi esempi utilizzano Amazon Location GeoPlacesClient. Questo client è basato sull'[AWS SDK per JavaScript V3](https://github.com/aws/aws-sdk-js-v3) e consente di effettuare chiamate ad Amazon Location tramite uno script a cui si fa riferimento in un file HTML.

Includi quanto segue in un file 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>
```

Includi quanto segue in un JavaScript file:

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

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

Di seguito sono elencate le funzioni utilizzate nel plug-in di MapLibre geocodifica Amazon Location:
+ `buildAmazonLocationMaplibreGeocoder`

  Questa classe crea un'istanza di`AmazonLocationMaplibreGeocder`, che è il punto di ingresso per tutte le altre chiamate.

  Utilizzo di chiamate `GeoPlacesClient` API autonome (il client è un'istanza di`GeoPlacesClient`):

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

  Utilizzo di chiamate `LocationClient` API consolidate (il client è un'istanza di`LocationClient`):

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

  Restituisce un ready-to-use IControl oggetto che può essere aggiunto direttamente a una mappa.

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

# Come usare il tracciamento SDKs
<a name="dev-tracking-sdk"></a>

Questo argomento fornisce informazioni su come utilizzare il monitoraggio SDKs.

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

L'SDK di tracciamento mobile Amazon Location fornisce utilità che aiutano a autenticare, acquisire le posizioni dei dispositivi e inviare aggiornamenti di posizione ad Amazon Location Tracker con facilità. L'SDK supporta il filtraggio locale degli aggiornamenti di posizione con intervalli di aggiornamento configurabili. Ciò riduce i costi dei dati e ottimizza la connettività intermittente per le applicazioni iOS.

L'SDK di tracciamento iOS è disponibile su GitHub: [Amazon Location Mobile Tracking SDK](https://github.com/aws-geospatial/amazon-location-mobile-tracking-sdk-ios) per iOS.

Questa sezione tratta i seguenti argomenti per l'SDK iOS per il tracciamento mobile di Amazon Location:

**Topics**
+ [

## Installazione
](#loc-mobile-tracking-install-ios)
+ [

## Utilizzo
](#loc-mobile-tracking-usage-ios)
+ [

## Filtri
](#loc-mobile-tracking-ios-filters)
+ [

## Funzioni di tracciamento dell'SDK per dispositivi mobili iOS
](#loc-mobile-tracking-functions)
+ [

## Esempi
](#loc-mobile-tracking-example-ios)

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

Utilizza la seguente procedura per installare l'SDK di tracciamento mobile per iOS:

1. Nel tuo progetto Xcode, vai su **File** e seleziona **Add Package Dependencies**.

1. Digita il seguente URL: [https://github.com/aws-geospatial/amazon-location-mobile-tracking-sdk-ios/](https://github.com/aws-geospatial/amazon-location-mobile-tracking-sdk-ios/) nella barra di ricerca e premi il tasto invio.

1. Seleziona il `amazon-location-mobile-tracking-sdk-ios` pacchetto e fai clic su **Aggiungi pacchetto**.

1. Seleziona il prodotto del `AmazonLocationiOSTrackingSDK` pacchetto e fai clic su **Aggiungi pacchetto**.

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

La procedura seguente mostra come creare un helper di autenticazione utilizzando le credenziali di Amazon Cognito.

1. Dopo aver installato la libreria, devi aggiungere una o entrambe le descrizioni al file: `info.plist`

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

1. Quindi, importali AuthHelper nella tua classe:

   ```
   import AmazonLocationiOSAuthSDKimport AmazonLocationiOSTrackingSDK
   ```

1. Quindi creerai un `AuthHelper` oggetto e lo utilizzerai con l' AWS SDK, creando un helper di autenticazione utilizzando le credenziali di 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)
   ```

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

L'SDK iOS per il tracciamento mobile di Amazon Location dispone di tre filtri di posizione integrati.
+ `TimeLocationFilter`: filtra la posizione corrente da caricare in base a un intervallo di tempo definito.
+ `DistanceLocationFilter`: filtra gli aggiornamenti della posizione in base a una soglia di distanza specificata.
+ `AccuracyLocationFilter`: filtra gli aggiornamenti della posizione confrontando la distanza percorsa dall'ultimo aggiornamento con la precisione della posizione corrente.

Questo esempio aggiunge filtri in `LocationTracker` al momento della creazione:

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

Questo esempio abilita e disabilita il filtro in fase di esecuzione con`LocationTracker`:

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

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

## Funzioni di tracciamento dell'SDK per dispositivi mobili iOS
<a name="loc-mobile-tracking-functions"></a>

L'SDK di tracciamento mobile Amazon Location per iOS include le seguenti funzioni:
+ **Classe:** `LocationTracker`

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

  Questa è una funzione di inizializzazione per creare un `LocationTracker` oggetto. Richiede istanze di `trackerName` e`LocationCredentialsProvider`, facoltativamente, un'istanza di. `LocationTrackingConfig` Se la configurazione non viene fornita, verrà inizializzata con valori predefiniti.
+ **Classe:** `LocationTracker`

  `setTrackerConfig(config: LocationTrackerConfig)`

  Questo imposta la configurazione di Tracker in modo che abbia effetto in qualsiasi momento dopo l'inizializzazione del localizzatore di posizione.
+ **Classe:** `LocationTracker`

  `getTrackerConfig()`

  In questo modo viene ottenuta la configurazione di tracciamento della posizione da utilizzare o modificare nell'app.

  Restituisce: `LocationTrackerConfig`
+ **Classe**: `LocationTracker`

  `getDeviceId()`

  Ottiene l'ID del dispositivo generato dal localizzatore di posizione.

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

  `startTracking()`

  Avvia il processo di accesso alla posizione dell'utente e di invio al AWS tracker.
+ **Classe:** `LocationTracker`

  `resumeTracking()`

  Riprende il processo di accesso alla posizione dell'utente e di invio della stessa al AWS tracker.
+ **Classe:** `LocationTracker`

  `stopTracking()`

  Interrompe il processo di tracciamento della posizione dell'utente.
+ **Classe**: `LocationTracker`

  `startBackgroundTracking(mode: BackgroundTrackingMode)`

  Avvia il processo di accesso alla posizione dell'utente e di invio al AWS tracker mentre l'applicazione è in background. `BackgroundTrackingMode`ha le seguenti opzioni: 
  + `Active:`Questa opzione non sospende automaticamente gli aggiornamenti della posizione.
  + `BatterySaving:`Questa opzione sospende automaticamente gli aggiornamenti della posizione.
  + `None:`Questa opzione disabilita nel complesso gli aggiornamenti della posizione in background.
+ **Classe:** `LocationTracker`

  `resumeBackgroundTracking(mode: BackgroundTrackingMode)`

  Riprende il processo di accesso alla posizione dell'utente e di invio al AWS tracker mentre l'applicazione è in background.
+ **Classe:** `LocationTracker`

  `stopBackgroundTracking()`

  Interrompe il processo di accesso alla posizione dell'utente e di invio della stessa al AWS tracker mentre l'applicazione è in background.
+ **Classe:** `LocationTracker`

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

  Recupera le posizioni di tracciamento caricate per il dispositivo dell'utente tra la data e l'ora di inizio e fine.

  Restituisce: `Void`
+ **Classe**: `LocationTrackerConfig`

  `init()`

  Questo inizializza LocationTrackerConfig con valori predefiniti.
+ **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)`

  Questo inizializza il `LocationTrackerConfig` con valori dei parametri definiti dall'utente. Se non viene fornito un valore di parametro, verrà impostato su un valore predefinito.
+ **Classe**: `LocationFilter`

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

  `LocationFilter`È un protocollo che gli utenti possono implementare per l'implementazione di filtri personalizzati. Un utente dovrebbe implementare una `shouldUpload` funzione per confrontare la posizione precedente e corrente e restituire se la posizione corrente deve essere caricata.

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

Questa sezione descrive alcuni esempi di utilizzo dell'Amazon Location Mobile Tracking SDK per iOS.

**Nota**  
Assicurati che le autorizzazioni necessarie siano impostate nel `info.plist` file. Queste sono le stesse autorizzazioni elencate nella [Utilizzo](#loc-mobile-tracking-usage-ios) sezione.

L'esempio seguente illustra la funzionalità per il tracciamento della posizione del dispositivo e il recupero delle posizioni tracciate:

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

Inizia a tracciare la posizione:

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

Riprendi a tracciare la posizione:

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

Smetti di tracciare la posizione:

```
locationTracker.stopTracking()
```

Inizia il tracciamento in background:

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

Riprendi il tracciamento in background:

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

Per interrompere il tracciamento in background:

```
locationTracker.stopBackgroundTracking()
```

Recupera le posizioni tracciate del dispositivo dal 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 di monitoraggio per dispositivi mobili Android
<a name="loc-mobile-tracking-android"></a>

L'SDK di tracciamento mobile Amazon Location fornisce utilità che aiutano a autenticare, acquisire le posizioni dei dispositivi e inviare aggiornamenti di posizione ad Amazon Location Tracker con facilità. L'SDK supporta il filtraggio locale degli aggiornamenti di posizione con intervalli di aggiornamento configurabili. Ciò riduce i costi dei dati e ottimizza la connettività intermittente per le applicazioni Android.

L'SDK di tracciamento Android è disponibile su GitHub: [Amazon Location Mobile Tracking SDK](https://github.com/aws-geospatial/amazon-location-mobile-tracking-sdk-android) per Android. [Inoltre, sia l'SDK di autenticazione mobile che l' AWS SDK sono disponibili nel repository Maven.AWS](https://central.sonatype.com/artifact/software.amazon.location/tracking) L'SDK di tracciamento Android è progettato per funzionare con l'SDK generale. AWS 

Questa sezione tratta i seguenti argomenti per l'SDK Android per il tracciamento mobile di Amazon Location:

**Topics**
+ [

## Installazione
](#loc-mobile-tracking-install-android)
+ [

## Utilizzo
](#loc-mobile-tracking-usage-android)
+ [

## Filtri
](#loc-mobile-tracking-android-filters)
+ [

## Funzioni di tracciamento Android Mobile SDK
](#loc-mobile-tracking-functions)
+ [

## Esempi
](#loc-mobile-tracking-example-android)

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

Per installare l'SDK, aggiungi le seguenti righe alla sezione delle dipendenze del tuo file build.gradle in 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")
```

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

Questa procedura mostra come utilizzare l'SDK per autenticare e creare l'oggetto: `LocationTracker`

**Nota**  
Questa procedura presuppone che tu abbia importato la libreria menzionata nella sezione. [Installazione](#loc-mobile-tracking-install-android)

1. Importa le seguenti classi nel tuo codice:

   ```
   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. Quindi crea un`AuthHelper`, poiché il `LocationCredentialsProvider` parametro è necessario per creare un `LocationTracker` oggetto:

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

1. Ora, usate il `LocationCredentialsProvider` comando and `LocationTrackerConfig` per creare un `LocationTracker` oggetto:

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

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

L'SDK Android per il tracciamento mobile di Amazon Location dispone di tre filtri di posizione integrati.
+ `TimeLocationFilter`: filtra la posizione corrente da caricare in base a un intervallo di tempo definito.
+ `DistanceLocationFilter`: filtra gli aggiornamenti della posizione in base a una soglia di distanza specificata.
+ `AccuracyLocationFilter`: filtra gli aggiornamenti della posizione confrontando la distanza percorsa dall'ultimo aggiornamento con la precisione della posizione corrente.

Questo esempio aggiunge filtri in `LocationTracker` al momento della creazione:

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

Questo esempio abilita e disabilita il filtro in fase di esecuzione con`LocationTracker`:

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

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

## Funzioni di tracciamento Android Mobile SDK
<a name="loc-mobile-tracking-functions"></a>

L'SDK di tracciamento mobile Amazon Location per Android include le seguenti funzioni:
+ **Classe:** `LocationTracker`

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

  Questa è una funzione di inizializzazione per creare un `LocationTracker` oggetto. Richiede istanze di `trackerName` e`LocationCredentialsProvider`, facoltativamente, un'istanza di. `LocationTrackingConfig` Se la configurazione non viene fornita, verrà inizializzata con valori predefiniti.
+ **Classe:** `LocationTracker`

  `start(locationTrackingCallback: LocationTrackingCallback)`

  Avvia il processo di accesso alla posizione dell'utente e di invio della stessa a un localizzatore di localizzazione Amazon.
+ **Classe:** `LocationTracker`

  `isTrackingInForeground()`

  Verifica se il tracciamento della posizione è attualmente in corso.
+ **Classe**: `LocationTracker`

  `stop()`

  Interrompe il processo di tracciamento della posizione dell'utente.
+ **Classe**: `LocationTracker`

  `startTracking()`

  Avvia il processo di accesso alla posizione dell'utente e di invio al AWS tracker.
+ **Classe:** `LocationTracker`

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

  Avvia il processo di accesso alla posizione dell'utente e di invio al AWS tracker mentre l'applicazione è in background. `BackgroundTrackingMode`ha le seguenti opzioni:
  + `ACTIVE_TRACKING`: questa opzione tiene traccia attivamente degli aggiornamenti sulla posizione di un utente. 
  + `BATTERY_SAVER_TRACKING`: Questa opzione tiene traccia degli aggiornamenti sulla posizione dell'utente ogni 15 minuti.
+ **Classe**: `LocationTracker`

  `stopBackgroundService()`

  Interrompe il processo di accesso alla posizione dell'utente e di invio della stessa al AWS tracker mentre l'applicazione è in background.
+ **Classe:** `LocationTracker`

  `getTrackerDeviceLocation()`

  Recupera la posizione del dispositivo dai servizi di localizzazione di Amazon. 
+ **Classe:** `LocationTracker`

  `getDeviceLocation(locationTrackingCallback: LocationTrackingCallback?)`

  Recupera la posizione corrente del dispositivo dal client del fornitore di geolocalizzazione fusa e la carica su Amazon Location tracker.
+ **Classe:** `LocationTracker`

  `uploadLocationUpdates(locationTrackingCallback: LocationTrackingCallback?)`

  Carica la posizione del dispositivo nei servizi di localizzazione Amazon dopo averla filtrata in base ai filtri di posizione configurati.
+ **Classe:** `LocationTracker`

  `enableFilter(filter: LocationFilter)`

  Abilita un particolare filtro di posizione.
+ **Classe**: `LocationTracker`

  `checkFilterIsExistsAndUpdateValue(filter: LocationFilter)`

  Disabilita un filtro di posizione particolare.
+ **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()) `

  Questo inizializza il `LocationTrackerConfig` con valori dei parametri definiti dall'utente. Se non viene fornito un valore di parametro, verrà impostato su un valore predefinito.
+ **Classe**: `LocationFilter`

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

  `LocationFilter`È un protocollo che gli utenti possono implementare per l'implementazione di filtri personalizzati. È necessario implementare la `shouldUpload` funzione per confrontare la posizione precedente e quella corrente e restituire se la posizione corrente deve essere caricata.

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

Il seguente esempio di codice mostra la funzionalità dell'SDK di tracciamento mobile.

Questo esempio utilizza `LocationTracker` per avviare e interrompere il tracciamento in background:

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

# Usa MapLibre strumenti e librerie correlate con Amazon Location
<a name="dev-maplibre"></a>

[MapLibre](https://maplibre.org/)è principalmente un motore di rendering per la visualizzazione di mappe in un'applicazione web o mobile. Tuttavia, include anche il supporto per i plug-in e fornisce funzionalità per lavorare con altri aspetti di Amazon Location. Di seguito vengono descritti gli strumenti che puoi utilizzare, in base all'area o al luogo con cui desideri lavorare.

**Nota**  
Per utilizzare qualsiasi aspetto di Amazon Location, installa l'[AWS SDK per la lingua che desideri utilizzare](dev-by-language.md).
+ **Mappe**

  Per visualizzare le mappe nella tua applicazione, è necessario un motore di rendering delle mappe che utilizzi i dati forniti da Amazon Location e disegni sullo schermo. I motori di rendering delle mappe forniscono anche funzionalità per ingrandire e ingrandire la mappa o per aggiungere marcatori, puntine e altre annotazioni alla mappa.

  Amazon Location Service consiglia di eseguire il rendering delle mappe utilizzando il motore di [MapLibre](https://github.com/maplibre/maplibre-gl-js)rendering. MapLibre GL JS è un motore per la visualizzazione di mappe JavaScript, mentre MapLibre Native fornisce mappe per iOS o Android.

  MapLibre dispone anche di un ecosistema di plug-in per estendere le funzionalità di base. Per ulteriori informazioni, visita [https://maplibre. org/maplibre-gl-js/docs/plugins](https://maplibre.org/maplibre-gl-js/docs/plugins/)/.
+ **Ricerca luoghi**

  Per semplificare la creazione di un'interfaccia utente di ricerca, puoi utilizzare il [MapLibre geocodificatore](https://github.com/maplibre/maplibre-gl-geocoder) per il web (le applicazioni Android possono utilizzare il plug-in [Android Places](https://github.com/maplibre/maplibre-plugins-android/tree/master/plugin-places)).

  Utilizza la [libreria Amazon Location for MapLibre geocoder](https://github.com/aws-geospatial/amazon-location-for-maplibre-gl-geocoder?tab=readme-ov-file) per semplificare il processo di utilizzo di Amazon Location `amazon-location-for-maplibre-gl-geocoder` nelle JavaScript applicazioni.

  Per ulteriori informazioni, consulta [Usa il plug-in Amazon Location MapLibre Geocoder GL](dev-maplibre-geocoder.md).
+ **Percorsi**
+ **Geofence e tracker**

  MapLibre non dispone di rendering o strumenti specifici per i geofence e il tracciamento, ma puoi utilizzare la funzionalità di rendering e i [plug-in](https://maplibre.org/maplibre-gl-js/docs/plugins/) per mostrare i geofence e i dispositivi tracciati sulla mappa.

  I dispositivi monitorati possono utilizzare [MQTT](tracking-using-mqtt.md) o inviare manualmente gli aggiornamenti ad Amazon Location Service. È possibile rispondere agli eventi Geofence utilizzando. [AWS Lambda](https://docs.aws.amazon.com/lambda/)

Sono disponibili molte librerie open source per fornire funzionalità aggiuntive per Amazon Location Service, ad esempio [Turf](https://github.com/Turfjs/turf) che fornisce funzionalità di analisi spaziale.

Molte librerie utilizzano dati in formato [GeoJSON](https://geojson.org/) standard aperto. Amazon Location Service fornisce una libreria per convertire le risposte in GeoJSON da utilizzare nelle applicazioni. JavaScript Per ulteriori informazioni, consulta [SDKs e framework per Amazon Location Service](dev-sdks.md). 

# SDKs per lingua
<a name="dev-by-language"></a>

**Versioni SDK**  
Ti consigliamo di utilizzare la build più recente dell' AWS SDK e qualsiasi altra SDKs versione utilizzata nei tuoi progetti e di mantenerla SDKs aggiornata. L' AWS SDK offre le caratteristiche e le funzionalità più recenti e anche aggiornamenti di sicurezza. Per trovare la versione più recente dell' AWS SDK per JavaScript, ad esempio, consulta [l'argomento sull'installazione del browser](https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/index.html#In_the_Browser) nell'*AWS SDK per la documentazione*. JavaScript

Le tabelle seguenti forniscono informazioni AWS SDKs e mappano le versioni di Rendering Framework per linguaggi e framework, per tipo di applicazione: applicazione web, mobile o backend.

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

Le seguenti versioni AWS SDKs e Map Rendering Framework sono disponibili per lo sviluppo di applicazioni web frontend.


| Linguaggio/Framework | AWS SDK | Framework di rendering delle mappe | 
| --- | --- | --- | 
|  **Completamente supportato**  | 
|  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)  | 
|  **Parzialmente supportato**  | 
|  Flutter  |  [https://docs.amplify. aws/start/q/integration/flutter](https://docs.amplify.aws/start/q/integration/flutter/)/ Flutter non è ancora completamente supportato da AWS, ma il supporto offerto tramite Amplify è limitato.  |  [https://github.com/maplibre/flutter-maplibre-gl](https://github.com/maplibre/flutter-maplibre-gl) La libreria MapLibre Flutter è considerata sperimentale.  | 
|  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/)  |  Non c'è MapLibre supporto per PHP.  | 

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

Le seguenti versioni AWS SDKs e Map Rendering Framework sono disponibili per lo sviluppo di applicazioni frontend mobili.


| Linguaggio/Framework | AWS SDK | Framework di rendering delle mappe | 
| --- | --- | --- | 
|  **Completamente supportato**  | 
|  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 di autenticazione mobile Amazon Location Service per Android: -sdk-android https://github.com/aws-geospatial/ amazon-location-mobile-auth](https://github.com/aws-geospatial/amazon-location-mobile-auth-sdk-android) [SDK di localizzazione mobile di Amazon Location Service per 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) Richiede associazioni personalizzate, così come è basato su Java. MapLibre   | 
|  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 di autenticazione mobile Amazon Location Service per iOS: -sdk-ios https://github.com/aws-geospatial/ amazon-location-mobile-auth](https://github.com/aws-geospatial/amazon-location-mobile-auth-sdk-ios) [SDK di localizzazione mobile di Amazon Location Service per 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)  | 
|  **Parzialmente supportato**  | 
|  Flutter  |  [https://docs.amplify. aws/start/q/integration/flutter](https://docs.amplify.aws/start/q/integration/flutter/)/ Flutter non è ancora completamente supportato da AWS, ma il supporto offerto tramite Amplify è limitato.  |  [https://github.com/maplibre/flutter-maplibre-gl](https://github.com/maplibre/flutter-maplibre-gl) La libreria MapLibre Flutter è considerata sperimentale.  | 

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

Quanto segue AWS SDKs è disponibile per lo sviluppo di applicazioni di backend. I framework di rendering delle mappe non sono elencati qui, perché il rendering delle mappe non è in genere necessario per le applicazioni di backend.


| Lingua | 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/) L' AWS SDK per Rust è disponibile in anteprima per sviluppatori.  | 

------

# Map Rendering SDK per lingua
<a name="map-rendering-by-language"></a>

Ti consigliamo di eseguire il rendering delle mappe di Amazon Location Service utilizzando il motore di [MapLibre](https://github.com/maplibre/maplibre-gl-js)rendering.

MapLibre è un motore per la visualizzazione di mappe in applicazioni web o mobili. MapLibredispone anche di un modello di plug-in e supporta interfacce utente per la ricerca e i percorsi in alcune lingue e piattaforme. 

Per ulteriori informazioni sull'utilizzo MapLibre e sulle funzionalità che offre, consulta [Usa MapLibre strumenti e librerie correlate con Amazon Location](dev-maplibre.md) e[Come usare le mappe dinamiche](dynamic-maps-how-to.md). 

Le tabelle seguenti forniscono informazioni sulle SDKs versioni di Map Rendering per linguaggi e framework, per tipo di applicazione: applicazione web o mobile.

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

I seguenti Map Rendering SDKs sono disponibili per lo sviluppo di applicazioni web frontend.


| Linguaggio/Framework | Framework di rendering delle mappe | 
| --- | --- | 
|  **Completamente supportato**  | 
|  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)  | 
|  **Parzialmente supportato**  | 
|  Flutter  |  [https://github.com/maplibre/flutter-maplibre-gl](https://github.com/maplibre/flutter-maplibre-gl) La libreria MapLibre Flutter è considerata sperimentale.  | 
|  Node.js  |   Non è disponibile alcun MapLibre supporto per Node.js.  | 
|  PHP  |   Non c'è MapLibre supporto per PHP.  | 

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

I seguenti renderizzatori di mappe SDKs sono disponibili per lo sviluppo di applicazioni frontend mobili.


| Linguaggio/Framework | Framework di rendering delle mappe | 
| --- | --- | 
|  **Completamente supportato**  | 
|  Java  |  [https://github.com/maplibre/maplibre-native](https://github.com/maplibre/maplibre-native)  | 
|  Kotlin  |  [https://github.com/maplibre/maplibre-nativo](https://github.com/maplibre/maplibre-native) Richiede associazioni personalizzate, così come è basato su Java. MapLibre   | 
|  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-nativo](https://github.com/maplibre/maplibre-native)  | 
|  **Parzialmente supportato**  | 
|  Flutter  |  [https://github.com/maplibre/flutter-maplibre-gl](https://github.com/maplibre/flutter-maplibre-gl) La libreria MapLibre Flutter è considerata sperimentale.  | 

------

# Modulo di indirizzo SDK
<a name="address-form-sdk"></a>

L'Address Form SDK semplifica la creazione di moduli intelligenti per l'immissione degli indirizzi. I moduli di indirizzo creati con l'SDK forniscono suggerimenti pertinenti sugli indirizzi non appena gli utenti iniziano a digitare. Quando un utente seleziona un suggerimento, un modulo di indirizzo compila automaticamente campi come città, stato e codice postale. Ciò riduce gli errori e velocizza l'immissione dei dati riducendo al minimo l'immissione manuale. Gli utenti possono anche visualizzare in anteprima l'indirizzo selezionato su una mappa e regolarne la posizione per indicare ingressi o punti di ritiro specifici, migliorando notevolmente la precisione.

![\[Dimostrazione di Address Form SDK che mostra la funzionalità di completamento automatico\]](http://docs.aws.amazon.com/it_it/location/latest/developerguide/images/address-form-demo.gif)


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

### Demo
<a name="address-form-demo"></a>

Prova la [demo del modulo di indirizzi](https://aws-geospatial.github.io/address-form-sdk-js/) completamente funzionante. 

### Costruiscilo tu stesso
<a name="address-form-builder"></a>

Passa a iniziare [Nozioni di base](#address-form-getting-started) a implementare i moduli di indirizzi utilizzando l'Address Form SDK oppure prova l'approccio senza codice con la [procedura guidata WYSIWYG Address Form Builder](https://console.aws.amazon.com/location/solution-builder/home#/address-form) di Location Service, basata su questo SDK e accessibile nella console Amazon Location Service all'indirizzo. [https://console.aws.amazon.com/location/](https://console.aws.amazon.com/location/) Questa procedura guidata interattiva ti consente di creare moduli personalizzati con suggerimenti predittivi, compilazione automatica dei campi e layout flessibili. Gli sviluppatori possono scaricare ready-to-use pacchetti in React JavaScript, React TypeScript o standalone HTML/JavaScript per una facile integrazione senza scrivere alcun codice.

## Caratteristiche chiave
<a name="address-form-features"></a>

Le caratteristiche principali di Address Form SDK includono:
+ Fornisce suggerimenti di battitura predefiniti per gli indirizzi e velocizza POIs l'immissione dei dati.
+ Consente la ricerca configurabile per tipo di località (ad esempio codici postali, località) per risultati più precisi.
+ Offre il rilevamento automatico della posizione del browser per indirizzare rapidamente gli utenti sulla loro area corrente.
+ Visualizza visualizzazioni cartografiche integrate per una maggiore chiarezza e contesto.
+ Consente di modificare le posizioni degli indirizzi sulla mappa senza perdere la posizione fornita dal sistema, garantendo precisione e controllo.
+ Include uno strumento di creazione WYSIWYG che non richiede alcuna codifica, risparmiando tempo e fatica.
+ Implementa il debouncing e il caching per typeahead per ottimizzare le prestazioni e ridurre i costi. APIs 
+ Supporta la personalizzazione dello stile in base al marchio e all'esperienza utente dell'applicazione.

Utilizza le seguenti operazioni API di Amazon Location Service per fornire informazioni sugli indirizzi nei moduli di indirizzo:

**[GetTile](https://docs.aws.amazon.com/location/latest/APIReference/API_geomaps_GetTile.html)**  
Recupera i riquadri della mappa per renderizzare la mappa interattiva per visualizzare la posizione dell'indirizzo e modificare la posizione di un indirizzo.

**[Completamento automatico](https://docs.aws.amazon.com/location/latest/APIReference/API_geoplaces_Autocomplete.html)**  
Fornisce suggerimenti sugli indirizzi in tempo reale durante la digitazione degli utenti.

**[Suggerisci](https://docs.aws.amazon.com/location/latest/APIReference/API_geoplaces_Suggest.html)**  
Fornisce suggerimenti in tempo reale su indirizzi e POI durante la digitazione degli utenti.

**[ReverseGeocode](https://docs.aws.amazon.com/location/latest/APIReference/API_geoplaces_ReverseGeocode.html)**  
Converte la posizione corrente di un utente nell'indirizzo di indirizzo conosciuto più vicino se sceglie di inserire automaticamente il proprio indirizzo in base alla posizione corrente.

**[GetPlace](https://docs.aws.amazon.com/location/latest/APIReference/API_geoplaces_GetPlace.html)**  
Recupera informazioni dettagliate sul luogo per gli indirizzi selezionati dopo aver selezionato un indirizzo dai risultati dell'API Autocomplete o Suggest.

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

L'SDK è gratuito e [open source](https://github.com/aws-geospatial/address-form-sdk-js) con licenza Apache-2.0. Paghi solo per l'utilizzo dell'API. Consulta la [pagina dei prezzi di Amazon Location Service](https://aws.amazon.com/location/pricing/).

## Nozioni di base
<a name="address-form-getting-started"></a>

L'Address Form SDK può essere utilizzato all'interno di un'app React o in una pagina HTML e JavaScript in una pagina autonomi. Inizia seguendo le istruzioni riportate di seguito.

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

**Nota**  
L'Address Form SDK richiede una chiave API con le autorizzazioni necessarie per funzionare correttamente. Crea una chiave API con le seguenti autorizzazioni utilizzando la procedura [guidata Address Form SDK Builder](https://console.aws.amazon.com/location/solution-builder/home#/address-form) nella console di Amazon Location Service oppure segui le istruzioni riportate di seguito per crearla manualmente.

L'uso dell'Address Form SDK richiede l'autorizzazione delle seguenti azioni nella politica delle chiavi API:
+ `geo-maps:GetTile`- È necessario quando si visualizza il componente della mappa. Vedi il riferimento all'[GetTile](https://docs.aws.amazon.com/location/latest/APIReference/API_geomaps_GetTile.html)API.
+ `geo-places:Autocomplete`- È necessario quando si utilizza l'`Autocomplete`operazione per la funzionalità typeahead. Vedi il riferimento all'API [Autocomplete](https://docs.aws.amazon.com/location/latest/APIReference/API_geoplaces_Autocomplete.html).
+ `geo-places:Suggest`- È necessario quando si utilizza l'`Suggest`operazione per la funzionalità typeahead. Vedi il riferimento all'API [Suggest](https://docs.aws.amazon.com/location/latest/APIReference/API_geoplaces_Suggest.html).
+ `geo-places:ReverseGeocode`- È necessario quando si consente agli utenti di fornire la propria posizione corrente utilizzando l'API di geolocalizzazione dei browser. Vedi il riferimento all'API. [ReverseGeocode](https://docs.aws.amazon.com/location/latest/APIReference/API_geoplaces_ReverseGeocode.html)
+ `geo-places:GetPlace`- È necessario quando si utilizza la funzionalità typeahead. Vedi il riferimento all'[GetPlace](https://docs.aws.amazon.com/location/latest/APIReference/API_geoplaces_GetPlace.html)API.

Segui la guida [Usa le chiavi API per l'autenticazione](https://docs.aws.amazon.com/location/latest/developerguide/using-apikeys.html) per creare una chiave API Amazon Location Service con le autorizzazioni necessarie.

Esempio di politica chiave per l'[CreateKey](https://docs.aws.amazon.com/location/latest/APIReference/API_geotags_CreateKey.html)API con autorizzazioni richieste:

#### CreateKey richiesta di autorizzazioni per Address Form
<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"
    ]
  }
}
```

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

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

Includi i seguenti CSS e JavaScript per l'SDK nel tuo codice 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>

Installa l'SDK da npm: `npm install @aws/address-form-sdk-js`

### Usa l'SDK
<a name="address-form-use-sdk"></a>

Aggiungi il seguente codice alla tua app React. Aggiorna `AMAZON_LOCATION_API_KEY` con la tua chiave API e `AMAZON_LOCATION_REGION` con la regione in cui è stata creata la chiave API. Quando il modulo viene inviato, il `onSubmit` callback fornisce una funzione `getData` asincrona. Chiama questa funzione con un `intendedUse` valore per recuperare i dati del modulo.

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

**Nota**  
Utilizzare `"Storage"` se è necessario archiviare o memorizzare nella cache i risultati. Ciò garantisce la conformità ai [requisiti di utilizzo previsto](https://docs.aws.amazon.com/location/latest/developerguide/places-intended-use.html) di 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>
  );
}
```

------

## Paesi supportati
<a name="address-form-supported-countries"></a>

L'Address Form SDK supporta la compilazione automatica degli indirizzi a livello globale utilizzando Amazon Location Service. I seguenti paesi offrono il supporto completo per l'analisi dei campi degli indirizzi, in cui ogni componente dell'indirizzo viene compilato nel rispettivo campo:
+ Australia (AU)
+ Canada (CA)
+ Francia (FR)
+ Hong Kong (HK)
+ Irlanda (IE)
+ Nuova Zelanda (NZ)
+ Filippine (PH)
+ Singapore (SG)
+ Regno Unito (GB)
+ Stati Uniti (US)

Tutti gli altri paesi sono in stato di anteprima. I paesi di anteprima mostrano l'indirizzo completo nel `addressLineOne` campo senza la formattazione specifica del paese. Le versioni future miglioreranno questo comportamento e potrai accedere a questi miglioramenti utilizzando l'ultima versione dell'SDK.

## Regioni AWS supportate
<a name="address-form-supported-aws-regions"></a>

La procedura guidata Address Form SDK e Address Form Builder sono disponibili in tutte le regioni AWS in cui opera Amazon Location Service, utilizzando la sua `Current` versione. APIs Visualizza l'elenco completo delle regioni supportate nelle regioni [supportate da Amazon Location](https://docs.aws.amazon.com/location/latest/developerguide/location-regions.html).

## Documentazione di riferimento delle API
<a name="address-form-api-reference"></a>

Consulta il riferimento all'[API README.](https://github.com/aws-geospatial/address-form-sdk-js#api-reference)