Sono disponibili altri esempi AWS SDK nel repository [AWS Doc SDK](https://github.com/awsdocs/aws-doc-sdk-examples) Examples. GitHub
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à.
# Esempi per l’API del servizio di posizione Amazon con SDK per Kotlin
I seguenti esempi di codice mostrano come eseguire azioni e implementare scenari comuni utilizzando l' AWS SDK per Kotlin con Amazon Location.
*Nozioni di base*: esempi di codice che mostrano come eseguire le operazioni essenziali all’interno di un servizio.
Le *azioni* sono estratti di codice da programmi più grandi e devono essere eseguite nel contesto. Sebbene le azioni mostrino come richiamare le singole funzioni del servizio, è possibile visualizzarle contestualizzate negli scenari correlati.
Ogni esempio include un link al codice sorgente completo, in cui vengono fornite le istruzioni su come configurare ed eseguire il codice nel contesto.
**Topics**
+ [Nozioni di base](#get_started)
+ [Nozioni di base](#basics)
+ [Azioni](#actions)
## Nozioni di base
### Hello Amazon Location
Il seguente esempio di codice mostra come iniziare a utilizzare Amazon Location Service.
**SDK per Kotlin**
C'è altro su GitHub. Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/kotlin/services/location#code-examples).
```
/**
Before running this Kotlin code example, set up your development environment,
including your credentials.
For more information, see the following documentation topic:
https://docs.aws.amazon.com/sdk-for-kotlin/latest/developer-guide/setup.html
In addition, you need to create a collection using the AWS Management
console. For information, see the following documentation.
https://docs.aws.amazon.com/location/latest/developerguide/geofence-gs.html
*/
suspend fun main(args: Array) {
val usage = """
Usage:
Where:
colletionName - The Amazon location collection name.
"""
if (args.size != 1) {
println(usage)
exitProcess(0)
}
val colletionName = args[0]
listGeofences(colletionName)
}
/**
* Lists the geofences for the specified collection name.
*
* @param collectionName the name of the geofence collection
*/
suspend fun listGeofences(collectionName: String) {
val request = ListGeofencesRequest {
this.collectionName = collectionName
}
LocationClient.fromEnvironment { region = "us-east-1" }.use { client ->
val response = client.listGeofences(request)
val geofences = response.entries
if (geofences.isNullOrEmpty()) {
println("No Geofences found")
} else {
geofences.forEach { geofence ->
println("Geofence ID: ${geofence.geofenceId}")
}
}
}
}
```
+ Per informazioni dettagliate sull’API, consulta i seguenti argomenti nella *documentazione di riferimento dell’API AWS SDK per Kotlin*.
+ [ListGeofenceCollections](https://sdk.amazonaws.com/kotlin/api/latest/index.html)
+ [ListGeofences](https://sdk.amazonaws.com/kotlin/api/latest/index.html)
## Nozioni di base
### Informazioni di base
L’esempio di codice seguente mostra come:
+ Creare una mappa del servizio di posizione Amazon.
+ Creare una chiave dell’API del servizio di posizione Amazon.
+ Visualizzare l’URL della mappa.
+ Creare una collezione di recinzioni geografiche virtuali.
+ Memorizzare una geometria di recinzioni geografiche virtuali.
+ Creare una risorsa tracciatore.
+ Aggiornare la posizione di un dispositivo.
+ Recuperare l’aggiornamento più recente della posizione per un dispositivo specificato.
+ Creare un calcolatore di route.
+ Determinare la distanza tra Seattle e Vancouver.
+ Usa il livello superiore di Amazon Location APIs.
+ Eliminare gli asset del servizio di posizione Amazon.
**SDK per Kotlin**
C'è altro da fare GitHub. Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/kotlin/services/location#code-examples).
```
/**
Before running this Kotlin code example, set up your development environment,
including your credentials.
For more information, see the following documentation topic:
https://docs.aws.amazon.com/sdk-for-kotlin/latest/developer-guide/setup.html
*/
val scanner = Scanner(System.`in`)
val DASHES = String(CharArray(80)).replace("\u0000", "-")
suspend fun main(args: Array) {
val usage = """
Usage:
Where:
mapName - The name of the map to create (e.g., "AWSMap").
keyName - The name of the API key to create (e.g., "AWSApiKey").
collectionName - The name of the geofence collection (e.g., "AWSLocationCollection").
geoId - The geographic identifier used for the geofence or map (e.g., "geoId").
trackerName - The name of the tracker (e.g., "geoTracker").
calculatorName - The name of the route calculator (e.g., "AWSRouteCalc").
deviceId - The ID of the device (e.g., "iPhone-112356").
"""
if (args.size != 7) {
println(usage)
exitProcess(0)
}
val mapName = args[0]
val keyName = args[1]
val collectionName = args[2]
val geoId = args[3]
val trackerName = args[4]
val calculatorName = args[5]
val deviceId = args[6]
println(
"""
AWS Location Service is a fully managed service offered by Amazon Web Services (AWS) that
provides location-based services for developers. This service simplifies
the integration of location-based features into applications, making it
easier to build and deploy location-aware applications.
The AWS Location Service offers a range of location-based services,
including:
- Maps: The service provides access to high-quality maps, satellite imagery,
and geospatial data from various providers, allowing developers to
easily embed maps into their applications.
- Tracking: The Location Service enables real-time tracking of mobile devices,
assets, or other entities, allowing developers to build applications
that can monitor the location of people, vehicles, or other objects.
- Geocoding: The service provides the ability to convert addresses or
location names into geographic coordinates (latitude and longitude),
and vice versa, enabling developers to integrate location-based search
and routing functionality into their applications.
""".trimIndent(),
)
waitForInputToContinue(scanner)
println(DASHES)
println("1. Create an AWS Location Service map")
println(
"""
An AWS Location map can enhance the user experience of your
application by providing accurate and personalized location-based
features. For example, you could use the geocoding capabilities to
allow users to search for and locate businesses, landmarks, or
other points of interest within a specific region.
""".trimIndent(),
)
waitForInputToContinue(scanner)
val mapArn = createMap(mapName)
println("The Map ARN is: $mapArn")
waitForInputToContinue(scanner)
println(DASHES)
waitForInputToContinue(scanner)
println("2. Create an AWS Location API key")
println(
"""
When you embed a map in a web app or website, the API key is
included in the map tile URL to authenticate requests. You can
restrict API keys to specific AWS Location operations (e.g., only
maps, not geocoding). API keys can expire, ensuring temporary
access control.
""".trimIndent(),
)
val keyArn = createKey(keyName, mapArn)
println("The Key ARN is: $keyArn")
waitForInputToContinue(scanner)
println(DASHES)
println(DASHES)
println("3. Display Map URL")
println(
"""
In order to get the MAP URL, you need to get the API Key value.
You can get the key value using the AWS Management Console under
Location Services. This operation cannot be completed using the
AWS SDK. For more information about getting the key value, see
the AWS Location Documentation.
""".trimIndent(),
)
val mapUrl = "https://maps.geo.aws.amazon.com/maps/v0/maps/$mapName/tiles/{z}/{x}/{y}?key={KeyValue}"
println("Embed this URL in your Web app: $mapUrl")
println("")
waitForInputToContinue(scanner)
println(DASHES)
println(DASHES)
println("4. Create a geofence collection, which manages and stores geofences.")
waitForInputToContinue(scanner)
val collectionArn: String =
createGeofenceCollection(collectionName)
println("The geofence collection was successfully created: $collectionArn")
waitForInputToContinue(scanner)
println(DASHES)
println("5. Store a geofence geometry in a given geofence collection.")
println(
"""
An AWS Location geofence is a virtual boundary that defines a geographic area
on a map. It is a useful feature for tracking the location of
assets or monitoring the movement of objects within a specific region.
To define a geofence, you need to specify the coordinates of a
polygon that represents the area of interest. The polygon must be
defined in a counter-clockwise direction, meaning that the points of
the polygon must be listed in a counter-clockwise order.
This is a requirement for the AWS Location service to correctly
interpret the geofence and ensure that the location data is
accurately processed within the defined area.
""".trimIndent(),
)
waitForInputToContinue(scanner)
putGeofence(collectionName, geoId)
println("Successfully created geofence: $geoId")
waitForInputToContinue(scanner)
println(DASHES)
println(DASHES)
println("6. Create a tracker resource which lets you retrieve current and historical location of devices.")
waitForInputToContinue(scanner)
val trackerArn: String = createTracker(trackerName)
println("Successfully created tracker. ARN: $trackerArn")
waitForInputToContinue(scanner)
println(DASHES)
println(DASHES)
println("7. Update the position of a device in the location tracking system.")
println(
"""
The AWS location service does not enforce a strict format for deviceId, but it must:
- Be a string (case-sensitive).
- Be 1–100 characters long.
- Contain only:
- Alphanumeric characters (A-Z, a-z, 0-9)
- Underscores (_)
- Hyphens (-)
- Be the same ID used when sending and retrieving positions.
""".trimIndent(),
)
waitForInputToContinue(scanner)
updateDevicePosition(trackerName, deviceId)
println("$deviceId was successfully updated in the location tracking system.")
waitForInputToContinue(scanner)
println(DASHES)
println(DASHES)
println("8. Retrieve the most recent position update for a specified device.")
waitForInputToContinue(scanner)
val response = getDevicePosition(trackerName, deviceId)
println("Successfully fetched device position: ${response.position}")
waitForInputToContinue(scanner)
println(DASHES)
println(DASHES)
println("9. Create a route calculator.")
waitForInputToContinue(scanner)
val routeResponse = createRouteCalculator(calculatorName)
println("Route calculator created successfully: ${routeResponse.calculatorArn}")
waitForInputToContinue(scanner)
println(DASHES)
println(DASHES)
println("10. Determine the distance in kilometers between Seattle and Vancouver using the route calculator.")
waitForInputToContinue(scanner)
val responseDis = calcDistance(calculatorName)
println("Successfully calculated route. The distance in kilometers is ${responseDis.summary?.distance}")
waitForInputToContinue(scanner)
println(DASHES)
println(DASHES)
println("11. Use the GeoPlacesClient to perform additional operations.")
println(
"""
This scenario will show use of the GeoPlacesClient that enables
location search and geocoding capabilities for your applications.
We are going to use this client to perform these AWS Location tasks:
- Reverse Geocoding (reverseGeocode): Converts geographic coordinates into addresses.
- Place Search (searchText): Finds places based on search queries.
- Nearby Search (searchNearby): Finds places near a specific location.
""".trimIndent(),
)
waitForInputToContinue(scanner)
println("First we will perform a Reverse Geocoding operation")
waitForInputToContinue(scanner)
reverseGeocode()
println("Now we are going to perform a text search using coffee shop.")
waitForInputToContinue(scanner)
searchText("coffee shop")
waitForInputToContinue(scanner)
println("Now we are going to perform a nearby Search.")
waitForInputToContinue(scanner)
searchNearby()
waitForInputToContinue(scanner)
println(DASHES)
println(DASHES)
println("12. Delete the AWS Location Services resources.")
println("Would you like to delete the AWS Location Services resources? (y/n)")
val delAns = scanner.nextLine().trim { it <= ' ' }
if (delAns.equals("y", ignoreCase = true)) {
deleteMap(mapName)
deleteKey(keyName)
deleteGeofenceCollection(collectionName)
deleteTracker(trackerName)
deleteRouteCalculator(calculatorName)
} else {
println("The AWS resources will not be deleted.")
}
waitForInputToContinue(scanner)
println(DASHES)
println(DASHES)
println(" This concludes the AWS Location Service scenario.")
println(DASHES)
}
/**
* Deletes a route calculator from the system.
* @param calcName the name of the route calculator to delete
*/
suspend fun deleteRouteCalculator(calcName: String) {
val calculatorRequest = DeleteRouteCalculatorRequest {
this.calculatorName = calcName
}
LocationClient.fromEnvironment { region = "us-east-1" }.use { client ->
client.deleteRouteCalculator(calculatorRequest)
println("The route calculator $calcName was deleted.")
}
}
/**
* Deletes a tracker with the specified name.
* @param trackerName the name of the tracker to be deleted
*/
suspend fun deleteTracker(trackerName: String) {
val trackerRequest = DeleteTrackerRequest {
this.trackerName = trackerName
}
LocationClient { region = "us-east-1" }.use { client ->
client.deleteTracker(trackerRequest)
println("The tracker $trackerName was deleted.")
}
}
/**
* Deletes a geofence collection.
*
* @param collectionName the name of the geofence collection to be deleted
* @return a {@link CompletableFuture} that completes when the geofence collection has been deleted
*/
suspend fun deleteGeofenceCollection(collectionName: String) {
val collectionRequest = DeleteGeofenceCollectionRequest {
this.collectionName = collectionName
}
LocationClient.fromEnvironment { region = "us-east-1" }.use { client ->
client.deleteGeofenceCollection(collectionRequest)
println("The geofence collection $collectionName was deleted.")
}
}
/**
* Deletes the specified key from the key-value store.
*
* @param keyName the name of the key to be deleted
*/
suspend fun deleteKey(keyName: String) {
val keyRequest = DeleteKeyRequest {
this.keyName = keyName
}
LocationClient.fromEnvironment { region = "us-east-1" }.use { client ->
client.deleteKey(keyRequest)
println("The key $keyName was deleted.")
}
}
/**
* Deletes the specified key from the key-value store.
*
* @param keyName the name of the key to be deleted
*/
suspend fun deleteMap(mapName: String) {
val mapRequest = DeleteMapRequest {
this.mapName = mapName
}
LocationClient.fromEnvironment { region = "us-east-1" }.use { client ->
client.deleteMap(mapRequest)
println("The map $mapName was deleted.")
}
}
/**
* Performs a nearby places search based on the provided geographic coordinates (latitude and longitude).
* The method sends an asynchronous request to search for places within a 1-kilometer radius of the specified location.
* The results are processed and printed once the search completes successfully.
*/
suspend fun searchNearby() {
val latitude = 37.7749
val longitude = -122.4194
val queryPosition = listOf(longitude, latitude)
// Set up the request for searching nearby places.
val request = SearchNearbyRequest {
this.queryPosition = queryPosition
this.queryRadius = 1000L
}
GeoPlacesClient.fromEnvironment { region = "us-east-1" }.use { client ->
val response = client.searchNearby(request)
// Process the response and print the results.
response.resultItems?.forEach { result ->
println("Title: ${result.title}")
println("Address: ${result.address?.label}")
println("Distance: ${result.distance} meters")
println("-------------------------")
}
}
}
/**
* Searches for a place using the provided search query and prints the detailed information of the first result.
*
* @param searchQuery the search query to be used for the place search (ex, coffee shop)
*/
suspend fun searchText(searchQuery: String) {
val latitude = 37.7749
val longitude = -122.4194
val queryPosition = listOf(longitude, latitude)
val request = SearchTextRequest {
this.queryText = searchQuery
this.biasPosition = queryPosition
}
GeoPlacesClient.fromEnvironment { region = "us-east-1" }.use { client ->
val response = client.searchText(request)
response.resultItems?.firstOrNull()?.let { result ->
val placeId = result.placeId // Get Place ID
println("Found Place with id: $placeId")
// Fetch detailed info using getPlace.
val getPlaceRequest = GetPlaceRequest {
this.placeId = placeId
}
val placeResponse = client.getPlace(getPlaceRequest)
// Print detailed place information.
println("Detailed Place Information:")
println("Title: ${placeResponse.title}")
println("Address: ${placeResponse.address?.label}")
// Print each food type (if any).
placeResponse.foodTypes?.takeIf { it.isNotEmpty() }?.let {
println("Food Types:")
it.forEach { foodType ->
println(" - $foodType")
}
} ?: run {
println("No food types available.")
}
println("-------------------------")
}
}
}
/**
* Performs reverse geocoding using the AWS Geo Places API.
* Reverse geocoding is the process of converting geographic coordinates (latitude and longitude) to a human-readable address.
* This method uses the latitude and longitude of San Francisco as the input, and prints the resulting address.
*/
suspend fun reverseGeocode() {
val latitude = 37.7749
val longitude = -122.4194
println("Use latitude 37.7749 and longitude -122.4194")
// AWS expects [longitude, latitude].
val queryPosition = listOf(longitude, latitude)
val request = ReverseGeocodeRequest {
this.queryPosition = queryPosition
}
GeoPlacesClient.fromEnvironment { region = "us-east-1" }.use { client ->
val response = client.reverseGeocode(request)
response.resultItems?.forEach { result ->
println("The address is: ${result.address?.label}")
}
}
}
/**
* Calculates the distance between two locations.
*
* @param routeCalcName the name of the route calculator to use
* @return a {@link CompletableFuture} that will complete with a {@link CalculateRouteResponse} containing the distance and estimated duration of the route
*/
suspend fun calcDistance(routeCalcName: String): CalculateRouteResponse {
// Define coordinates for Seattle, WA and Vancouver, BC.
val departurePosition = listOf(-122.3321, 47.6062)
val arrivePosition = listOf(-123.1216, 49.2827)
val request = CalculateRouteRequest {
this.calculatorName = routeCalcName
this.departurePosition = departurePosition
this.destinationPosition = arrivePosition
this.travelMode = TravelMode.Car // Options: Car, Truck, Walking, Bicycle
this.distanceUnit = DistanceUnit.Kilometers // Options: Meters, Kilometers, Miles
}
LocationClient.fromEnvironment { region = "us-east-1" }.use { client ->
return client.calculateRoute(request)
}
}
/**
* Creates a new route calculator with the specified name and data source.
*
* @param routeCalcName the name of the route calculator to be created
*/
suspend fun createRouteCalculator(routeCalcName: String): CreateRouteCalculatorResponse {
val dataSource = "Esri"
val request = CreateRouteCalculatorRequest {
this.calculatorName = routeCalcName
this.dataSource = dataSource
}
LocationClient.fromEnvironment { region = "us-east-1" }.use { client ->
return client.createRouteCalculator(request)
}
}
/**
* Retrieves the position of a device using the provided LocationClient.
*
* @param trackerName The name of the tracker associated with the device.
* @param deviceId The ID of the device to retrieve the position for.
*/
suspend fun getDevicePosition(trackerName: String, deviceId: String): GetDevicePositionResponse {
val request = GetDevicePositionRequest {
this.trackerName = trackerName
this.deviceId = deviceId
}
LocationClient.fromEnvironment { region = "us-east-1" }.use { client ->
return client.getDevicePosition(request)
}
}
/**
* Updates the position of a device in the location tracking system.
*
* @param trackerName the name of the tracker associated with the device
* @param deviceId the unique identifier of the device
*/
suspend fun updateDevicePosition(trackerName: String, deviceId: String) {
val latitude = 37.7749
val longitude = -122.4194
val positionUpdate = DevicePositionUpdate {
this.deviceId = deviceId
sampleTime = aws.smithy.kotlin.runtime.time.Instant.now() // Timestamp of position update.
position = listOf(longitude, latitude) // AWS requires [longitude, latitude]
}
val request = BatchUpdateDevicePositionRequest {
this.trackerName = trackerName
updates = listOf(positionUpdate)
}
LocationClient.fromEnvironment { region = "us-east-1" }.use { client ->
client.batchUpdateDevicePosition(request)
}
}
/**
* Creates a new tracker resource in your AWS account, which you can use to track the location of devices.
*
* @param trackerName the name of the tracker to be created
* @return a {@link CompletableFuture} that, when completed, will contain the Amazon Resource Name (ARN) of the created tracker
*/
suspend fun createTracker(trackerName: String): String {
val trackerRequest = CreateTrackerRequest {
description = "Created using the Kotlin SDK"
this.trackerName = trackerName
positionFiltering = PositionFiltering.TimeBased // Options: TimeBased, DistanceBased, AccuracyBased
}
LocationClient.fromEnvironment { region = "us-east-1" }.use { client ->
val response = client.createTracker(trackerRequest)
return response.trackerArn
}
}
/**
* Adds a new geofence to the specified collection.
*
* @param collectionName the name of the geofence collection to add the geofence to
* @param geoId the unique identifier for the geofence
*/
suspend fun putGeofence(collectionName: String, geoId: String) {
val geofenceGeometry = GeofenceGeometry {
polygon = listOf(
listOf(
listOf(-122.3381, 47.6101),
listOf(-122.3281, 47.6101),
listOf(-122.3281, 47.6201),
listOf(-122.3381, 47.6201),
listOf(-122.3381, 47.6101),
),
)
}
val geofenceRequest = PutGeofenceRequest {
this.collectionName = collectionName
this.geofenceId = geoId
this.geometry = geofenceGeometry
}
LocationClient.fromEnvironment { region = "us-east-1" }.use { client ->
client.putGeofence(geofenceRequest)
}
}
/**
* Creates a new geofence collection.
*
* @param collectionName the name of the geofence collection to be created
*/
suspend fun createGeofenceCollection(collectionName: String): String {
val collectionRequest = CreateGeofenceCollectionRequest {
this.collectionName = collectionName
description = "Created by using the AWS SDK for Kotlin"
}
LocationClient.fromEnvironment { region = "us-east-1" }.use { client ->
val response = client.createGeofenceCollection(collectionRequest)
return response.collectionArn
}
}
/**
* Creates a new API key with the specified name and restrictions.
*
* @param keyName the name of the API key to be created
* @param mapArn the Amazon Resource Name (ARN) of the map resource to which the API key will be associated
* @return the Amazon Resource Name (ARN) of the created API key
*/
suspend fun createKey(keyName: String, mapArn: String): String {
val keyRestrictions = ApiKeyRestrictions {
allowActions = listOf("geo:GetMap*")
allowResources = listOf(mapArn)
}
val request = CreateKeyRequest {
this.keyName = keyName
this.restrictions = keyRestrictions
noExpiry = true
}
LocationClient.fromEnvironment { region = "us-east-1" }.use { client ->
val response = client.createKey(request)
return response.keyArn
}
}
/**
* Creates a new map with the specified name and configuration.
*
* @param mapName the name of the map to be created
* @return he Amazon Resource Name (ARN) of the created map
*/
suspend fun createMap(mapName: String): String {
val configuration = MapConfiguration {
style = "VectorEsriNavigation"
}
val mapRequest = CreateMapRequest {
this.mapName = mapName
this.configuration = configuration
description = "A map created using the Kotlin SDK"
}
LocationClient.fromEnvironment { region = "us-east-1" }.use { client ->
val response = client.createMap(mapRequest)
return response.mapArn
}
}
fun waitForInputToContinue(scanner: Scanner) {
while (true) {
println("")
println("Enter 'c' followed by to continue:")
val input = scanner.nextLine()
if (input.trim { it <= ' ' }.equals("c", ignoreCase = true)) {
println("Continuing with the program...")
println("")
break
} else {
println("Invalid input. Please try again.")
}
}
}
```
+ Per informazioni dettagliate sull’API, consulta i seguenti argomenti nella *documentazione di riferimento dell’API AWS SDK per Kotlin*.
+ [BatchUpdateDevicePosition](https://sdk.amazonaws.com/kotlin/api/latest/index.html)
+ [CalculateRoute](https://sdk.amazonaws.com/kotlin/api/latest/index.html)
+ [CreateGeofenceCollection](https://sdk.amazonaws.com/kotlin/api/latest/index.html)
+ [CreateKey](https://sdk.amazonaws.com/kotlin/api/latest/index.html)
+ [CreateMap](https://sdk.amazonaws.com/kotlin/api/latest/index.html)
+ [CreateRouteCalculator](https://sdk.amazonaws.com/kotlin/api/latest/index.html)
+ [CreateTracker](https://sdk.amazonaws.com/kotlin/api/latest/index.html)
+ [DeleteGeofenceCollection](https://sdk.amazonaws.com/kotlin/api/latest/index.html)
+ [DeleteKey](https://sdk.amazonaws.com/kotlin/api/latest/index.html)
+ [DeleteMap](https://sdk.amazonaws.com/kotlin/api/latest/index.html)
+ [DeleteRouteCalculator](https://sdk.amazonaws.com/kotlin/api/latest/index.html)
+ [DeleteTracker](https://sdk.amazonaws.com/kotlin/api/latest/index.html)
+ [GetDevicePosition](https://sdk.amazonaws.com/kotlin/api/latest/index.html)
+ [PutGeofence](https://sdk.amazonaws.com/kotlin/api/latest/index.html)
## Azioni
### `BatchUpdateDevicePosition`
Il seguente esempio di codice mostra come usare`BatchUpdateDevicePosition`.
**SDK per Kotlin**
C'è altro da fare GitHub. Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/kotlin/services/location#code-examples).
```
/**
* Updates the position of a device in the location tracking system.
*
* @param trackerName the name of the tracker associated with the device
* @param deviceId the unique identifier of the device
*/
suspend fun updateDevicePosition(trackerName: String, deviceId: String) {
val latitude = 37.7749
val longitude = -122.4194
val positionUpdate = DevicePositionUpdate {
this.deviceId = deviceId
sampleTime = aws.smithy.kotlin.runtime.time.Instant.now() // Timestamp of position update.
position = listOf(longitude, latitude) // AWS requires [longitude, latitude]
}
val request = BatchUpdateDevicePositionRequest {
this.trackerName = trackerName
updates = listOf(positionUpdate)
}
LocationClient.fromEnvironment { region = "us-east-1" }.use { client ->
client.batchUpdateDevicePosition(request)
}
}
```
+ Per i dettagli sull'API, [BatchUpdateDevicePosition](https://sdk.amazonaws.com/kotlin/api/latest/index.html)consulta *AWS SDK for Kotlin* API reference.
### `CalculateRoute`
Il seguente esempio di codice mostra come utilizzare. `CalculateRoute`
**SDK per Kotlin**
C'è altro da fare GitHub. Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/kotlin/services/location#code-examples).
```
/**
* Calculates the distance between two locations.
*
* @param routeCalcName the name of the route calculator to use
* @return a {@link CompletableFuture} that will complete with a {@link CalculateRouteResponse} containing the distance and estimated duration of the route
*/
suspend fun calcDistance(routeCalcName: String): CalculateRouteResponse {
// Define coordinates for Seattle, WA and Vancouver, BC.
val departurePosition = listOf(-122.3321, 47.6062)
val arrivePosition = listOf(-123.1216, 49.2827)
val request = CalculateRouteRequest {
this.calculatorName = routeCalcName
this.departurePosition = departurePosition
this.destinationPosition = arrivePosition
this.travelMode = TravelMode.Car // Options: Car, Truck, Walking, Bicycle
this.distanceUnit = DistanceUnit.Kilometers // Options: Meters, Kilometers, Miles
}
LocationClient.fromEnvironment { region = "us-east-1" }.use { client ->
return client.calculateRoute(request)
}
}
```
+ Per i dettagli sull'API, [CalculateRoute](https://sdk.amazonaws.com/kotlin/api/latest/index.html)consulta *AWS SDK for Kotlin* API reference.
### `CreateGeofenceCollection`
Il seguente esempio di codice mostra come utilizzare. `CreateGeofenceCollection`
**SDK per Kotlin**
C'è altro da fare GitHub. Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/kotlin/services/location#code-examples).
```
/**
* Creates a new geofence collection.
*
* @param collectionName the name of the geofence collection to be created
*/
suspend fun createGeofenceCollection(collectionName: String): String {
val collectionRequest = CreateGeofenceCollectionRequest {
this.collectionName = collectionName
description = "Created by using the AWS SDK for Kotlin"
}
LocationClient.fromEnvironment { region = "us-east-1" }.use { client ->
val response = client.createGeofenceCollection(collectionRequest)
return response.collectionArn
}
}
```
+ Per i dettagli sull'API, [CreateGeofenceCollection](https://sdk.amazonaws.com/kotlin/api/latest/index.html)consulta *AWS SDK for Kotlin* API reference.
### `CreateKey`
Il seguente esempio di codice mostra come utilizzare. `CreateKey`
**SDK per Kotlin**
C'è altro da fare GitHub. Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/kotlin/services/location#code-examples).
```
/**
* Creates a new API key with the specified name and restrictions.
*
* @param keyName the name of the API key to be created
* @param mapArn the Amazon Resource Name (ARN) of the map resource to which the API key will be associated
* @return the Amazon Resource Name (ARN) of the created API key
*/
suspend fun createKey(keyName: String, mapArn: String): String {
val keyRestrictions = ApiKeyRestrictions {
allowActions = listOf("geo:GetMap*")
allowResources = listOf(mapArn)
}
val request = CreateKeyRequest {
this.keyName = keyName
this.restrictions = keyRestrictions
noExpiry = true
}
LocationClient.fromEnvironment { region = "us-east-1" }.use { client ->
val response = client.createKey(request)
return response.keyArn
}
}
```
+ Per i dettagli sull'API, [CreateKey](https://sdk.amazonaws.com/kotlin/api/latest/index.html)consulta *AWS SDK for Kotlin* API reference.
### `CreateMap`
Il seguente esempio di codice mostra come utilizzare. `CreateMap`
**SDK per Kotlin**
C'è altro da fare GitHub. Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/kotlin/services/location#code-examples).
```
/**
* Creates a new map with the specified name and configuration.
*
* @param mapName the name of the map to be created
* @return he Amazon Resource Name (ARN) of the created map
*/
suspend fun createMap(mapName: String): String {
val configuration = MapConfiguration {
style = "VectorEsriNavigation"
}
val mapRequest = CreateMapRequest {
this.mapName = mapName
this.configuration = configuration
description = "A map created using the Kotlin SDK"
}
LocationClient.fromEnvironment { region = "us-east-1" }.use { client ->
val response = client.createMap(mapRequest)
return response.mapArn
}
}
```
+ Per i dettagli sull'API, [CreateMap](https://sdk.amazonaws.com/kotlin/api/latest/index.html)consulta *AWS SDK for Kotlin* API reference.
### `CreateRouteCalculator`
Il seguente esempio di codice mostra come utilizzare. `CreateRouteCalculator`
**SDK per Kotlin**
C'è altro da fare GitHub. Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/kotlin/services/location#code-examples).
```
/**
* Creates a new route calculator with the specified name and data source.
*
* @param routeCalcName the name of the route calculator to be created
*/
suspend fun createRouteCalculator(routeCalcName: String): CreateRouteCalculatorResponse {
val dataSource = "Esri"
val request = CreateRouteCalculatorRequest {
this.calculatorName = routeCalcName
this.dataSource = dataSource
}
LocationClient.fromEnvironment { region = "us-east-1" }.use { client ->
return client.createRouteCalculator(request)
}
}
```
+ Per i dettagli sull'API, [CreateRouteCalculator](https://sdk.amazonaws.com/kotlin/api/latest/index.html)consulta *AWS SDK for Kotlin* API reference.
### `CreateTracker`
Il seguente esempio di codice mostra come utilizzare. `CreateTracker`
**SDK per Kotlin**
C'è altro da fare GitHub. Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/kotlin/services/location#code-examples).
```
/**
* Creates a new tracker resource in your AWS account, which you can use to track the location of devices.
*
* @param trackerName the name of the tracker to be created
* @return a {@link CompletableFuture} that, when completed, will contain the Amazon Resource Name (ARN) of the created tracker
*/
suspend fun createTracker(trackerName: String): String {
val trackerRequest = CreateTrackerRequest {
description = "Created using the Kotlin SDK"
this.trackerName = trackerName
positionFiltering = PositionFiltering.TimeBased // Options: TimeBased, DistanceBased, AccuracyBased
}
LocationClient.fromEnvironment { region = "us-east-1" }.use { client ->
val response = client.createTracker(trackerRequest)
return response.trackerArn
}
}
```
+ Per i dettagli sull'API, [CreateTracker](https://sdk.amazonaws.com/kotlin/api/latest/index.html)consulta *AWS SDK for Kotlin* API reference.
### `DeleteGeofenceCollection`
Il seguente esempio di codice mostra come utilizzare. `DeleteGeofenceCollection`
**SDK per Kotlin**
C'è altro da fare GitHub. Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/kotlin/services/location#code-examples).
```
/**
* Deletes a geofence collection.
*
* @param collectionName the name of the geofence collection to be deleted
* @return a {@link CompletableFuture} that completes when the geofence collection has been deleted
*/
suspend fun deleteGeofenceCollection(collectionName: String) {
val collectionRequest = DeleteGeofenceCollectionRequest {
this.collectionName = collectionName
}
LocationClient.fromEnvironment { region = "us-east-1" }.use { client ->
client.deleteGeofenceCollection(collectionRequest)
println("The geofence collection $collectionName was deleted.")
}
}
```
+ Per i dettagli sull'API, [DeleteGeofenceCollection](https://sdk.amazonaws.com/kotlin/api/latest/index.html)consulta *AWS SDK for Kotlin* API reference.
### `DeleteKey`
Il seguente esempio di codice mostra come utilizzare. `DeleteKey`
**SDK per Kotlin**
C'è altro da fare GitHub. Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/kotlin/services/location#code-examples).
```
/**
* Deletes the specified key from the key-value store.
*
* @param keyName the name of the key to be deleted
*/
suspend fun deleteKey(keyName: String) {
val keyRequest = DeleteKeyRequest {
this.keyName = keyName
}
LocationClient.fromEnvironment { region = "us-east-1" }.use { client ->
client.deleteKey(keyRequest)
println("The key $keyName was deleted.")
}
}
```
+ Per i dettagli sull'API, [DeleteKey](https://sdk.amazonaws.com/kotlin/api/latest/index.html)consulta *AWS SDK for Kotlin* API reference.
### `DeleteMap`
Il seguente esempio di codice mostra come utilizzare. `DeleteMap`
**SDK per Kotlin**
C'è altro da fare GitHub. Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/kotlin/services/location#code-examples).
```
/**
* Deletes the specified key from the key-value store.
*
* @param keyName the name of the key to be deleted
*/
suspend fun deleteMap(mapName: String) {
val mapRequest = DeleteMapRequest {
this.mapName = mapName
}
LocationClient.fromEnvironment { region = "us-east-1" }.use { client ->
client.deleteMap(mapRequest)
println("The map $mapName was deleted.")
}
}
```
+ Per i dettagli sull'API, [DeleteMap](https://sdk.amazonaws.com/kotlin/api/latest/index.html)consulta *AWS SDK for Kotlin* API reference.
### `DeleteRouteCalculator`
Il seguente esempio di codice mostra come utilizzare. `DeleteRouteCalculator`
**SDK per Kotlin**
C'è altro da fare GitHub. Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/kotlin/services/location#code-examples).
```
/**
* Deletes a route calculator from the system.
* @param calcName the name of the route calculator to delete
*/
suspend fun deleteRouteCalculator(calcName: String) {
val calculatorRequest = DeleteRouteCalculatorRequest {
this.calculatorName = calcName
}
LocationClient.fromEnvironment { region = "us-east-1" }.use { client ->
client.deleteRouteCalculator(calculatorRequest)
println("The route calculator $calcName was deleted.")
}
}
```
+ Per i dettagli sull'API, [DeleteRouteCalculator](https://sdk.amazonaws.com/kotlin/api/latest/index.html)consulta *AWS SDK for Kotlin* API reference.
### `DeleteTracker`
Il seguente esempio di codice mostra come utilizzare. `DeleteTracker`
**SDK per Kotlin**
C'è altro da fare GitHub. Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/kotlin/services/location#code-examples).
```
/**
* Deletes a tracker with the specified name.
* @param trackerName the name of the tracker to be deleted
*/
suspend fun deleteTracker(trackerName: String) {
val trackerRequest = DeleteTrackerRequest {
this.trackerName = trackerName
}
LocationClient { region = "us-east-1" }.use { client ->
client.deleteTracker(trackerRequest)
println("The tracker $trackerName was deleted.")
}
}
```
+ Per i dettagli sull'API, [DeleteTracker](https://sdk.amazonaws.com/kotlin/api/latest/index.html)consulta *AWS SDK for Kotlin* API reference.
### `GetDevicePosition`
Il seguente esempio di codice mostra come utilizzare. `GetDevicePosition`
**SDK per Kotlin**
C'è altro da fare GitHub. Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/kotlin/services/location#code-examples).
```
/**
* Retrieves the position of a device using the provided LocationClient.
*
* @param trackerName The name of the tracker associated with the device.
* @param deviceId The ID of the device to retrieve the position for.
*/
suspend fun getDevicePosition(trackerName: String, deviceId: String): GetDevicePositionResponse {
val request = GetDevicePositionRequest {
this.trackerName = trackerName
this.deviceId = deviceId
}
LocationClient.fromEnvironment { region = "us-east-1" }.use { client ->
return client.getDevicePosition(request)
}
}
```
+ Per i dettagli sull'API, [GetDevicePosition](https://sdk.amazonaws.com/kotlin/api/latest/index.html)consulta *AWS SDK for Kotlin* API reference.
### `PutGeofence`
Il seguente esempio di codice mostra come utilizzare. `PutGeofence`
**SDK per Kotlin**
C'è altro da fare GitHub. Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/kotlin/services/location#code-examples).
```
/**
* Adds a new geofence to the specified collection.
*
* @param collectionName the name of the geofence collection to add the geofence to
* @param geoId the unique identifier for the geofence
*/
suspend fun putGeofence(collectionName: String, geoId: String) {
val geofenceGeometry = GeofenceGeometry {
polygon = listOf(
listOf(
listOf(-122.3381, 47.6101),
listOf(-122.3281, 47.6101),
listOf(-122.3281, 47.6201),
listOf(-122.3381, 47.6201),
listOf(-122.3381, 47.6101),
),
)
}
val geofenceRequest = PutGeofenceRequest {
this.collectionName = collectionName
this.geofenceId = geoId
this.geometry = geofenceGeometry
}
LocationClient.fromEnvironment { region = "us-east-1" }.use { client ->
client.putGeofence(geofenceRequest)
}
}
```
+ Per i dettagli sull'API, [PutGeofence](https://sdk.amazonaws.com/kotlin/api/latest/index.html)consulta *AWS SDK for Kotlin* API reference.