Weitere AWS SDK-Beispiele sind im GitHub Repo [AWS Doc SDK Examples](https://github.com/awsdocs/aws-doc-sdk-examples) verfügbar.
Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.
# Beispiele für Amazon Location unter Verwendung von SDK für Kotlin
Die folgenden Codebeispiele zeigen Ihnen, wie Sie mithilfe des AWS SDK für Kotlin mit Amazon Location Aktionen ausführen und allgemeine Szenarien implementieren.
Bei *Grundlagen* handelt es sich um Codebeispiele, die Ihnen zeigen, wie Sie die wesentlichen Vorgänge innerhalb eines Services ausführen.
*Aktionen* sind Codeauszüge aus größeren Programmen und müssen im Kontext ausgeführt werden. Während Aktionen Ihnen zeigen, wie Sie einzelne Service-Funktionen aufrufen, können Sie Aktionen im Kontext der zugehörigen Szenarien anzeigen.
Jedes Beispiel enthält einen Link zum vollständigen Quellcode, wo Sie Anweisungen zum Einrichten und Ausführen des Codes im Kodex finden.
**Topics**
+ [Erste Schritte](#get_started)
+ [Grundlagen](#basics)
+ [Aktionen](#actions)
## Erste Schritte
### Hello Amazon Location
Das folgende Codebeispiel zeigt, wie Sie mit Amazon Location Service beginnen können.
**SDK für Kotlin**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/kotlin/services/location#code-examples) einrichten und ausführen.
```
/**
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}")
}
}
}
}
```
+ Weitere API-Informationen finden Sie in den folgenden Themen der *API-Referenz zum AWS -SDK für Kotlin*.
+ [ListGeofenceCollections](https://sdk.amazonaws.com/kotlin/api/latest/index.html)
+ [ListGeofences](https://sdk.amazonaws.com/kotlin/api/latest/index.html)
## Grundlagen
### Kennenlernen der Grundlagen
Wie das aussehen kann, sehen Sie am nachfolgenden Beispielcode:
+ Erstellen Sie eine Amazon-Location-Karte.
+ Erstellen Sie einen API-Schlüssel für Amazon Location.
+ Zeigen Sie die Karten-URL an.
+ Erstellen Sie eine Geofence-Sammlung.
+ Speichern einer Geofence-Geometrie
+ Erstellen einer Tracker-Ressource
+ Aktualisieren der Position eines Geräts
+ Rufen Sie die neueste Positionsaktualisierung für ein bestimmtes Gerät ab.
+ Erstellen Sie einen Routenrechner.
+ Ermitteln der Entfernung zwischen Seattle und Vancouver
+ Verwenden Sie Amazon Location auf höherer Ebene APIs.
+ Löschen Sie die Amazon-Location-Komponenten.
**SDK für Kotlin**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/kotlin/services/location#code-examples) einrichten und ausführen.
```
/**
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.")
}
}
}
```
+ Weitere API-Informationen finden Sie in den folgenden Themen der *API-Referenz zum AWS -SDK für 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)
## Aktionen
### `BatchUpdateDevicePosition`
Das folgende Codebeispiel zeigt, wie man es benutzt`BatchUpdateDevicePosition`.
**SDK für Kotlin**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/kotlin/services/location#code-examples) einrichten und ausführen.
```
/**
* 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)
}
}
```
+ API-Details finden Sie [BatchUpdateDevicePosition](https://sdk.amazonaws.com/kotlin/api/latest/index.html)in der *API-Referenz zum AWS SDK für Kotlin*.
### `CalculateRoute`
Das folgende Codebeispiel zeigt die Verwendung`CalculateRoute`.
**SDK für Kotlin**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/kotlin/services/location#code-examples) einrichten und ausführen.
```
/**
* 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)
}
}
```
+ API-Details finden Sie [CalculateRoute](https://sdk.amazonaws.com/kotlin/api/latest/index.html)in der *API-Referenz zum AWS SDK für Kotlin*.
### `CreateGeofenceCollection`
Das folgende Codebeispiel zeigt die Verwendung`CreateGeofenceCollection`.
**SDK für Kotlin**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/kotlin/services/location#code-examples) einrichten und ausführen.
```
/**
* 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
}
}
```
+ API-Details finden Sie [CreateGeofenceCollection](https://sdk.amazonaws.com/kotlin/api/latest/index.html)in der *API-Referenz zum AWS SDK für Kotlin*.
### `CreateKey`
Das folgende Codebeispiel zeigt die Verwendung`CreateKey`.
**SDK für Kotlin**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/kotlin/services/location#code-examples) einrichten und ausführen.
```
/**
* 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
}
}
```
+ Einzelheiten zur API finden Sie [CreateKey](https://sdk.amazonaws.com/kotlin/api/latest/index.html)in der *API-Referenz zum AWS SDK für Kotlin*.
### `CreateMap`
Das folgende Codebeispiel zeigt die Verwendung`CreateMap`.
**SDK für Kotlin**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/kotlin/services/location#code-examples) einrichten und ausführen.
```
/**
* 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
}
}
```
+ Einzelheiten zur API finden Sie [CreateMap](https://sdk.amazonaws.com/kotlin/api/latest/index.html)in der *API-Referenz zum AWS SDK für Kotlin*.
### `CreateRouteCalculator`
Das folgende Codebeispiel zeigt die Verwendung`CreateRouteCalculator`.
**SDK für Kotlin**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/kotlin/services/location#code-examples) einrichten und ausführen.
```
/**
* 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)
}
}
```
+ Einzelheiten zur API finden Sie [CreateRouteCalculator](https://sdk.amazonaws.com/kotlin/api/latest/index.html)in der *API-Referenz zum AWS SDK für Kotlin*.
### `CreateTracker`
Das folgende Codebeispiel zeigt die Verwendung`CreateTracker`.
**SDK für Kotlin**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/kotlin/services/location#code-examples) einrichten und ausführen.
```
/**
* 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
}
}
```
+ Einzelheiten zur API finden Sie [CreateTracker](https://sdk.amazonaws.com/kotlin/api/latest/index.html)in der *API-Referenz zum AWS SDK für Kotlin*.
### `DeleteGeofenceCollection`
Das folgende Codebeispiel zeigt die Verwendung`DeleteGeofenceCollection`.
**SDK für Kotlin**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/kotlin/services/location#code-examples) einrichten und ausführen.
```
/**
* 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.")
}
}
```
+ Einzelheiten zur API finden Sie [DeleteGeofenceCollection](https://sdk.amazonaws.com/kotlin/api/latest/index.html)in der *API-Referenz zum AWS SDK für Kotlin*.
### `DeleteKey`
Das folgende Codebeispiel zeigt die Verwendung`DeleteKey`.
**SDK für Kotlin**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/kotlin/services/location#code-examples) einrichten und ausführen.
```
/**
* 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.")
}
}
```
+ Einzelheiten zur API finden Sie [DeleteKey](https://sdk.amazonaws.com/kotlin/api/latest/index.html)in der *API-Referenz zum AWS SDK für Kotlin*.
### `DeleteMap`
Das folgende Codebeispiel zeigt die Verwendung`DeleteMap`.
**SDK für Kotlin**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/kotlin/services/location#code-examples) einrichten und ausführen.
```
/**
* 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.")
}
}
```
+ Einzelheiten zur API finden Sie [DeleteMap](https://sdk.amazonaws.com/kotlin/api/latest/index.html)in der *API-Referenz zum AWS SDK für Kotlin*.
### `DeleteRouteCalculator`
Das folgende Codebeispiel zeigt die Verwendung`DeleteRouteCalculator`.
**SDK für Kotlin**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/kotlin/services/location#code-examples) einrichten und ausführen.
```
/**
* 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.")
}
}
```
+ Einzelheiten zur API finden Sie [DeleteRouteCalculator](https://sdk.amazonaws.com/kotlin/api/latest/index.html)in der *API-Referenz zum AWS SDK für Kotlin*.
### `DeleteTracker`
Das folgende Codebeispiel zeigt die Verwendung`DeleteTracker`.
**SDK für Kotlin**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/kotlin/services/location#code-examples) einrichten und ausführen.
```
/**
* 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.")
}
}
```
+ Einzelheiten zur API finden Sie [DeleteTracker](https://sdk.amazonaws.com/kotlin/api/latest/index.html)in der *API-Referenz zum AWS SDK für Kotlin*.
### `GetDevicePosition`
Das folgende Codebeispiel zeigt die Verwendung`GetDevicePosition`.
**SDK für Kotlin**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/kotlin/services/location#code-examples) einrichten und ausführen.
```
/**
* 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)
}
}
```
+ Einzelheiten zur API finden Sie [GetDevicePosition](https://sdk.amazonaws.com/kotlin/api/latest/index.html)in der *API-Referenz zum AWS SDK für Kotlin*.
### `PutGeofence`
Das folgende Codebeispiel zeigt die Verwendung`PutGeofence`.
**SDK für Kotlin**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/kotlin/services/location#code-examples) einrichten und ausführen.
```
/**
* 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)
}
}
```
+ Einzelheiten zur API finden Sie [PutGeofence](https://sdk.amazonaws.com/kotlin/api/latest/index.html)in der *API-Referenz zum AWS SDK für Kotlin*.