D'autres exemples de AWS SDK sont disponibles dans le référentiel [AWS Doc SDK Examples](https://github.com/awsdocs/aws-doc-sdk-examples) GitHub .
Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.
# Actions pour Amazon Location utilisant AWS SDKs
Les exemples de code suivants montrent comment effectuer des actions Amazon Location individuelles avec AWS SDKs. Chaque exemple inclut un lien vers GitHub, où vous pouvez trouver des instructions pour configurer et exécuter le code.
Les exemples suivants incluent uniquement les actions les plus couramment utilisées. Pour obtenir la liste complète, consultez la [Référence des API Amazon Location Service](https://docs.aws.amazon.com/location/latest/APIReference/Welcome.html).
**Topics**
+ [`BatchUpdateDevicePosition`](location_example_location_BatchUpdateDevicePosition_section.md)
+ [`CalculateRoute`](location_example_location_CalculateRoute_section.md)
+ [`CreateGeofenceCollection`](location_example_location_CreateGeofenceCollection_section.md)
+ [`CreateKey`](location_example_location_CreateKey_section.md)
+ [`CreateMap`](location_example_location_CreateMap_section.md)
+ [`CreateRouteCalculator`](location_example_location_CreateRouteCalculator_section.md)
+ [`CreateTracker`](location_example_location_CreateTracker_section.md)
+ [`DeleteGeofenceCollection`](location_example_location_DeleteGeofenceCollection_section.md)
+ [`DeleteKey`](location_example_location_DeleteKey_section.md)
+ [`DeleteMap`](location_example_location_DeleteMap_section.md)
+ [`DeleteRouteCalculator`](location_example_location_DeleteRouteCalculator_section.md)
+ [`DeleteTracker`](location_example_location_DeleteTracker_section.md)
+ [`GetDevicePosition`](location_example_location_GetDevicePosition_section.md)
+ [`PutGeofence`](location_example_location_PutGeofence_section.md)
# Utilisation `BatchUpdateDevicePosition` avec un AWS SDK
Les exemples de code suivants illustrent comment utiliser `BatchUpdateDevicePosition`.
Les exemples d’actions sont des extraits de code de programmes de plus grande envergure et doivent être exécutés en contexte. Vous pouvez voir cette action en contexte dans l’exemple de code suivant :
+ [Principes de base](location_example_location_Scenario_section.md)
------
#### [ Java ]
**SDK pour Java 2.x**
Il y en a plus sur GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/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
* @throws RuntimeException if an error occurs while updating the device position
*/
public CompletableFuture updateDevicePosition(String trackerName, String deviceId) {
double latitude = 37.7749; // Example: San Francisco
double longitude = -122.4194;
DevicePositionUpdate positionUpdate = DevicePositionUpdate.builder()
.deviceId(deviceId)
.sampleTime(Instant.now()) // Timestamp of position update.
.position(Arrays.asList(longitude, latitude)) // AWS requires [longitude, latitude]
.build();
BatchUpdateDevicePositionRequest request = BatchUpdateDevicePositionRequest.builder()
.trackerName(trackerName)
.updates(positionUpdate)
.build();
CompletableFuture futureResponse = getClient().batchUpdateDevicePosition(request);
return futureResponse.whenComplete((response, exception) -> {
if (exception != null) {
Throwable cause = exception.getCause();
if (cause instanceof ResourceNotFoundException) {
throw new CompletionException("The resource was not found: " + cause.getMessage(), cause);
} else {
throw new CompletionException("Error updating device position: " + exception.getMessage(), exception);
}
}
});
}
```
+ Pour plus de détails sur l'API, voir [BatchUpdateDevicePosition](https://docs.aws.amazon.com/goto/SdkForJavaV2/location-2020-11-19/BatchUpdateDevicePosition)la section *Référence des AWS SDK for Java 2.x API*.
------
#### [ JavaScript ]
**SDK pour JavaScript (v3)**
Il y en a plus sur GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/location/actions#code-examples).
```
import { fileURLToPath } from "node:url";
import {
BatchUpdateDevicePositionCommand,
LocationClient,
ResourceNotFoundException,
} from "@aws-sdk/client-location";
import data from "./inputs.json" with { type: "json" };
const region = "eu-west-1";
const locationClient = new LocationClient({ region: region });
const updateDevicePosParams = {
TrackerName: `${data.inputs.trackerName}`,
Updates: [
{
DeviceId: `${data.inputs.deviceId}`,
SampleTime: new Date(),
Position: [-122.4194, 37.7749],
},
],
};
export const main = async () => {
try {
const command = new BatchUpdateDevicePositionCommand(updateDevicePosParams);
const response = await locationClient.send(command);
//console.log("response ", response.Errors[0].Error);
console.log(
`Device with id ${data.inputs.deviceId} was successfully updated in the location tracking system. `,
response,
);
} catch (error) {
console.log("error ", error);
}
};
```
+ Pour plus de détails sur l'API, voir [BatchUpdateDevicePosition](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/location/command/BatchUpdateDevicePositionCommand)la section *Référence des AWS SDK pour JavaScript API*.
------
#### [ Kotlin ]
**SDK pour Kotlin**
Il y en a plus sur GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code 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)
}
}
```
+ Pour plus de détails sur l'API, consultez [BatchUpdateDevicePosition](https://sdk.amazonaws.com/kotlin/api/latest/index.html)la section *AWS SDK pour la référence de l'API Kotlin*.
------
# Utilisation `CalculateRoute` avec un AWS SDK
Les exemples de code suivants illustrent comment utiliser `CalculateRoute`.
Les exemples d’actions sont des extraits de code de programmes de plus grande envergure et doivent être exécutés en contexte. Vous pouvez voir cette action en contexte dans l’exemple de code suivant :
+ [Principes de base](location_example_location_Scenario_section.md)
------
#### [ Java ]
**SDK pour Java 2.x**
Il y en a plus sur GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/location#code-examples).
```
/**
* Calculates the distance between two locations asynchronously.
*
* @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
*/
public CompletableFuture calcDistanceAsync(String routeCalcName) {
// Define coordinates for Seattle, WA and Vancouver, BC.
List departurePosition = Arrays.asList(-122.3321, 47.6062);
List arrivePosition = Arrays.asList(-123.1216, 49.2827);
CalculateRouteRequest request = CalculateRouteRequest.builder()
.calculatorName(routeCalcName)
.departurePosition(departurePosition)
.destinationPosition(arrivePosition)
.travelMode("Car") // Options: Car, Truck, Walking, Bicycle
.distanceUnit("Kilometers") // Options: Meters, Kilometers, Miles
.build();
return getClient().calculateRoute(request)
.whenComplete((response, exception) -> {
if (exception != null) {
Throwable cause = exception.getCause();
if (cause instanceof ResourceNotFoundException) {
throw new CompletionException("The AWS resource was not found: " + cause.getMessage(), cause);
}
throw new CompletionException("Failed to calculate route: " + exception.getMessage(), exception);
}
});
}
```
+ Pour plus de détails sur l'API, voir [CalculateRoute](https://docs.aws.amazon.com/goto/SdkForJavaV2/location-2020-11-19/CalculateRoute)la section *Référence des AWS SDK for Java 2.x API*.
------
#### [ JavaScript ]
**SDK pour JavaScript (v3)**
Il y en a plus sur GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/location/actions#code-examples).
```
import { fileURLToPath } from "node:url";
import {
CalculateRouteCommand,
ResourceNotFoundException,
LocationClient,
} from "@aws-sdk/client-location";
import data from "./inputs.json" with { type: "json" };
const region = "eu-west-1";
const locationClient = new LocationClient({ region: region });
export const main = async () => {
const routeCalcParams = {
CalculatorName: `${data.inputs.calculatorName}`,
DeparturePosition: [-122.3321, 47.6062],
DestinationPosition: [-123.1216, 49.2827],
TravelMode: "Car",
DistanceUnit: "Kilometers",
};
try {
const command = new CalculateRouteCommand(routeCalcParams);
const response = await locationClient.send(command);
console.log(
"Successfully calculated route. The distance in kilometers is : ",
response.Summary.Distance,
);
} catch (caught) {
if (caught instanceof ResourceNotFoundException) {
console.error(
`An conflict occurred: ${caught.message} \n Exiting program.`,
);
return;
}
}
};
```
+ Pour plus de détails sur l'API, voir [CalculateRoute](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/location/command/CalculateRouteCommand)la section *Référence des AWS SDK pour JavaScript API*.
------
#### [ Kotlin ]
**SDK pour Kotlin**
Il y en a plus sur GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code 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)
}
}
```
+ Pour plus de détails sur l'API, consultez [CalculateRoute](https://sdk.amazonaws.com/kotlin/api/latest/index.html)la section *AWS SDK pour la référence de l'API Kotlin*.
------
# Utilisation `CreateGeofenceCollection` avec un AWS SDK
Les exemples de code suivants illustrent comment utiliser `CreateGeofenceCollection`.
Les exemples d’actions sont des extraits de code de programmes de plus grande envergure et doivent être exécutés en contexte. Vous pouvez voir cette action en contexte dans l’exemple de code suivant :
+ [Principes de base](location_example_location_Scenario_section.md)
------
#### [ Java ]
**SDK pour Java 2.x**
Il y en a plus sur GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/location#code-examples).
```
/**
* Creates a new geofence collection.
*
* @param collectionName the name of the geofence collection to be created
*/
public CompletableFuture createGeofenceCollection(String collectionName) {
CreateGeofenceCollectionRequest collectionRequest = CreateGeofenceCollectionRequest.builder()
.collectionName(collectionName)
.description("Created by using the AWS SDK for Java")
.build();
return getClient().createGeofenceCollection(collectionRequest)
.whenComplete((response, exception) -> {
if (exception != null) {
Throwable cause = exception.getCause();
if (cause instanceof ConflictException) {
throw new CompletionException("The geofence collection was not created due to ConflictException.", cause);
}
throw new CompletionException("Failed to create geofence collection: " + exception.getMessage(), exception);
}
})
.thenApply(response -> response.collectionArn()); // Return only the ARN
}
```
+ Pour plus de détails sur l'API, voir [CreateGeofenceCollection](https://docs.aws.amazon.com/goto/SdkForJavaV2/location-2020-11-19/CreateGeofenceCollection)la section *Référence des AWS SDK for Java 2.x API*.
------
#### [ JavaScript ]
**SDK pour JavaScript (v3)**
Il y en a plus sur GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/location/actions#code-examples).
```
import { fileURLToPath } from "node:url";
import {
ConflictException,
CreateGeofenceCollectionCommand,
LocationClient,
} from "@aws-sdk/client-location";
import data from "./inputs.json" with { type: "json" };
const region = "eu-west-1";
export const main = async () => {
const geoFenceCollParams = {
CollectionName: `${data.inputs.collectionName}`,
};
const locationClient = new LocationClient({ region: region });
try {
const command = new CreateGeofenceCollectionCommand(geoFenceCollParams);
const response = await locationClient.send(command);
console.log(
"Collection created. Collection name is: ",
response.CollectionName,
);
} catch (caught) {
if (caught instanceof ConflictException) {
console.error("A conflict occurred. Exiting program.");
return;
}
}
};
```
+ Pour plus de détails sur l'API, voir [CreateGeofenceCollection](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/location/command/CreateGeofenceCollectionCommand)la section *Référence des AWS SDK pour JavaScript API*.
------
#### [ Kotlin ]
**SDK pour Kotlin**
Il y en a plus sur GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code 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
}
}
```
+ Pour plus de détails sur l'API, consultez [CreateGeofenceCollection](https://sdk.amazonaws.com/kotlin/api/latest/index.html)la section *AWS SDK pour la référence de l'API Kotlin*.
------
# Utilisation `CreateKey` avec un AWS SDK
Les exemples de code suivants illustrent comment utiliser `CreateKey`.
Les exemples d’actions sont des extraits de code de programmes de plus grande envergure et doivent être exécutés en contexte. Vous pouvez voir cette action en contexte dans l’exemple de code suivant :
+ [Principes de base](location_example_location_Scenario_section.md)
------
#### [ Java ]
**SDK pour Java 2.x**
Il y en a plus sur GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/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 a {@link CompletableFuture} that completes with the Amazon Resource Name (ARN) of the created API key,
* or {@code null} if the operation failed
*/
public CompletableFuture createKey(String keyName, String mapArn) {
ApiKeyRestrictions keyRestrictions = ApiKeyRestrictions.builder()
.allowActions("geo:GetMap*")
.allowResources(mapArn)
.build();
CreateKeyRequest request = CreateKeyRequest.builder()
.keyName(keyName)
.restrictions(keyRestrictions)
.noExpiry(true)
.build();
return getClient().createKey(request)
.whenComplete((response, exception) -> {
if (exception != null) {
Throwable cause = exception.getCause();
if (cause instanceof AccessDeniedException) {
throw new CompletionException("The request was denied because of insufficient access or permissions.", cause);
}
throw new CompletionException("Failed to create API key: " + exception.getMessage(), exception);
}
})
.thenApply(response -> response.keyArn()); // This will never return null if the response reaches here
}
```
+ Pour plus de détails sur l'API, voir [CreateKey](https://docs.aws.amazon.com/goto/SdkForJavaV2/location-2020-11-19/CreateKey)la section *Référence des AWS SDK for Java 2.x API*.
------
#### [ Kotlin ]
**SDK pour Kotlin**
Il y en a plus sur GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code 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
}
}
```
+ Pour plus de détails sur l'API, consultez [CreateKey](https://sdk.amazonaws.com/kotlin/api/latest/index.html)la section *AWS SDK pour la référence de l'API Kotlin*.
------
# Utilisation `CreateMap` avec un AWS SDK
Les exemples de code suivants illustrent comment utiliser `CreateMap`.
Les exemples d’actions sont des extraits de code de programmes de plus grande envergure et doivent être exécutés en contexte. Vous pouvez voir cette action en contexte dans l’exemple de code suivant :
+ [Principes de base](location_example_location_Scenario_section.md)
------
#### [ Java ]
**SDK pour Java 2.x**
Il y en a plus sur GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/location#code-examples).
```
/**
* Creates a new map with the specified name and configuration.
*
* @param mapName the name of the map to be created
* @return a {@link CompletableFuture} that, when completed, will contain the Amazon Resource Name (ARN) of the created map
* @throws CompletionException if an error occurs while creating the map, such as exceeding the service quota
*/
public CompletableFuture createMap(String mapName) {
MapConfiguration configuration = MapConfiguration.builder()
.style("VectorEsriNavigation")
.build();
CreateMapRequest mapRequest = CreateMapRequest.builder()
.mapName(mapName)
.configuration(configuration)
.description("A map created using the Java V2 API")
.build();
return getClient().createMap(mapRequest)
.whenComplete((response, exception) -> {
if (exception != null) {
Throwable cause = exception.getCause();
if (cause instanceof ServiceQuotaExceededException) {
throw new CompletionException("The operation was denied because the request would exceed the maximum quota.", cause);
}
throw new CompletionException("Failed to create map: " + exception.getMessage(), exception);
}
})
.thenApply(response -> response.mapArn()); // Return the map ARN
}
```
+ Pour plus de détails sur l'API, voir [CreateMap](https://docs.aws.amazon.com/goto/SdkForJavaV2/location-2020-11-19/CreateMap)la section *Référence des AWS SDK for Java 2.x API*.
------
#### [ JavaScript ]
**SDK pour JavaScript (v3)**
Il y en a plus sur GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/location/actions#code-examples).
```
import { fileURLToPath } from "node:url";
import { CreateMapCommand, LocationClient } from "@aws-sdk/client-location";
import data from "./inputs.json" with { type: "json" };
const region = "eu-west-1";
export const main = async () => {
const CreateMapCommandInput = {
MapName: `${data.inputs.mapName}`,
Configuration: { style: "VectorEsriNavigation" },
};
const locationClient = new LocationClient({ region: region });
try {
const command = new CreateMapCommand(CreateMapCommandInput);
const response = await locationClient.send(command);
console.log("Map created. Map ARN is : ", response.MapArn);
} catch (error) {
console.error("Error creating map: ", error);
throw error;
}
};
```
+ Pour plus de détails sur l'API, voir [CreateMap](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/location/command/CreateMapCommand)la section *Référence des AWS SDK pour JavaScript API*.
------
#### [ Kotlin ]
**SDK pour Kotlin**
Il y en a plus sur GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code 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
}
}
```
+ Pour plus de détails sur l'API, consultez [CreateMap](https://sdk.amazonaws.com/kotlin/api/latest/index.html)la section *AWS SDK pour la référence de l'API Kotlin*.
------
# Utilisation `CreateRouteCalculator` avec un AWS SDK
Les exemples de code suivants illustrent comment utiliser `CreateRouteCalculator`.
Les exemples d’actions sont des extraits de code de programmes de plus grande envergure et doivent être exécutés en contexte. Vous pouvez voir cette action en contexte dans l’exemple de code suivant :
+ [Principes de base](location_example_location_Scenario_section.md)
------
#### [ Java ]
**SDK pour Java 2.x**
Il y en a plus sur GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/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
*/
public CompletableFuture createRouteCalculator(String routeCalcName) {
String dataSource = "Esri"; // or "Here"
CreateRouteCalculatorRequest request = CreateRouteCalculatorRequest.builder()
.calculatorName(routeCalcName)
.dataSource(dataSource)
.build();
return getClient().createRouteCalculator(request)
.whenComplete((response, exception) -> {
if (exception != null) {
Throwable cause = exception.getCause();
if (cause instanceof ConflictException) {
throw new CompletionException("A conflict error occurred: " + cause.getMessage(), cause);
}
throw new CompletionException("Failed to create route calculator: " + exception.getMessage(), exception);
}
});
}
```
+ Pour plus de détails sur l'API, voir [CreateRouteCalculator](https://docs.aws.amazon.com/goto/SdkForJavaV2/location-2020-11-19/CreateRouteCalculator)la section *Référence des AWS SDK for Java 2.x API*.
------
#### [ JavaScript ]
**SDK pour JavaScript (v3)**
Il y en a plus sur GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/location/actions#code-examples).
```
import { fileURLToPath } from "node:url";
import {
ConflictException,
CreateRouteCalculatorCommand,
LocationClient,
} from "@aws-sdk/client-location";
import data from "./inputs.json" with { type: "json" };
const region = "eu-west-1";
const locationClient = new LocationClient({ region: region });
export const main = async () => {
const routeCalcParams = {
CalculatorName: `${data.inputs.calculatorName}`,
DataSource: "Esri",
};
try {
const command = new CreateRouteCalculatorCommand(routeCalcParams);
const response = await locationClient.send(command);
console.log(
"Route calculator created successfully. Calculator name is ",
response.CalculatorName,
);
} catch (caught) {
if (caught instanceof ConflictException) {
console.error(
`An conflict occurred: ${caught.message} \n Exiting program.`,
);
return;
}
}
};
```
+ Pour plus de détails sur l'API, voir [CreateRouteCalculator](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/location/command/CreateRouteCalculatorCommand)la section *Référence des AWS SDK pour JavaScript API*.
------
#### [ Kotlin ]
**SDK pour Kotlin**
Il y en a plus sur GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code 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)
}
}
```
+ Pour plus de détails sur l'API, consultez [CreateRouteCalculator](https://sdk.amazonaws.com/kotlin/api/latest/index.html)la section *AWS SDK pour la référence de l'API Kotlin*.
------
# Utilisation `CreateTracker` avec un AWS SDK
Les exemples de code suivants illustrent comment utiliser `CreateTracker`.
Les exemples d’actions sont des extraits de code de programmes de plus grande envergure et doivent être exécutés en contexte. Vous pouvez voir cette action en contexte dans l’exemple de code suivant :
+ [Principes de base](location_example_location_Scenario_section.md)
------
#### [ Java ]
**SDK pour Java 2.x**
Il y en a plus sur GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/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
*/
public CompletableFuture createTracker(String trackerName) {
CreateTrackerRequest trackerRequest = CreateTrackerRequest.builder()
.description("Created using the Java V2 SDK")
.trackerName(trackerName)
.positionFiltering("TimeBased") // Options: TimeBased, DistanceBased, AccuracyBased
.build();
return getClient().createTracker(trackerRequest)
.whenComplete((response, exception) -> {
if (exception != null) {
Throwable cause = exception.getCause();
if (cause instanceof ConflictException) {
throw new CompletionException("Conflict occurred while creating tracker: " + cause.getMessage(), cause);
}
throw new CompletionException("Error creating tracker: " + exception.getMessage(), exception);
}
})
.thenApply(CreateTrackerResponse::trackerArn); // Return only the tracker ARN
}
```
+ Pour plus de détails sur l'API, voir [CreateTracker](https://docs.aws.amazon.com/goto/SdkForJavaV2/location-2020-11-19/CreateTracker)la section *Référence des AWS SDK for Java 2.x API*.
------
#### [ JavaScript ]
**SDK pour JavaScript (v3)**
Il y en a plus sur GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/location/actions#code-examples).
```
import { fileURLToPath } from "node:url";
import { CreateTrackerCommand, LocationClient } from "@aws-sdk/client-location";
import data from "./inputs.json" with { type: "json" };
const region = "eu-west-1";
export const main = async () => {
const createTrackerParams = {
TrackerName: `${data.inputs.trackerName}`,
};
const locationClient = new LocationClient({ region: region });
try {
const command = new CreateTrackerCommand(createTrackerParams);
const response = await locationClient.send(command);
//state.trackerName - response.TrackerName;
console.log("Tracker created. Tracker name is : ", response.TrackerName);
} catch (error) {
console.error("Error creating map: ", error);
throw error;
}
};
```
+ Pour plus de détails sur l'API, voir [CreateTracker](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/location/command/CreateTrackerCommand)la section *Référence des AWS SDK pour JavaScript API*.
------
#### [ Kotlin ]
**SDK pour Kotlin**
Il y en a plus sur GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code 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
}
}
```
+ Pour plus de détails sur l'API, consultez [CreateTracker](https://sdk.amazonaws.com/kotlin/api/latest/index.html)la section *AWS SDK pour la référence de l'API Kotlin*.
------
# Utilisation `DeleteGeofenceCollection` avec un AWS SDK
Les exemples de code suivants illustrent comment utiliser `DeleteGeofenceCollection`.
Les exemples d’actions sont des extraits de code de programmes de plus grande envergure et doivent être exécutés en contexte. Vous pouvez voir cette action en contexte dans l’exemple de code suivant :
+ [Principes de base](location_example_location_Scenario_section.md)
------
#### [ Java ]
**SDK pour Java 2.x**
Il y en a plus sur GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/location#code-examples).
```
/**
* Deletes a geofence collection asynchronously.
*
* @param collectionName the name of the geofence collection to be deleted
* @return a {@link CompletableFuture} that completes when the geofence collection has been deleted
*/
public CompletableFuture deleteGeofenceCollectionAsync(String collectionName) {
DeleteGeofenceCollectionRequest collectionRequest = DeleteGeofenceCollectionRequest.builder()
.collectionName(collectionName)
.build();
return getClient().deleteGeofenceCollection(collectionRequest)
.whenComplete((response, exception) -> {
if (exception != null) {
Throwable cause = exception.getCause();
if (cause instanceof ResourceNotFoundException) {
throw new CompletionException("The requested geofence collection was not found.", cause);
}
throw new CompletionException("Failed to delete geofence collection: " + exception.getMessage(), exception);
}
logger.info("The geofence collection {} was deleted.", collectionName);
})
.thenApply(response -> null);
}
```
+ Pour plus de détails sur l'API, voir [DeleteGeofenceCollection](https://docs.aws.amazon.com/goto/SdkForJavaV2/location-2020-11-19/DeleteGeofenceCollection)la section *Référence des AWS SDK for Java 2.x API*.
------
#### [ JavaScript ]
**SDK pour JavaScript (v3)**
Il y en a plus sur GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/location/actions#code-examples).
```
import { fileURLToPath } from "node:url";
import {
DeleteGeofenceCollectionCommand,
LocationClient,
ResourceNotFoundException,
} from "@aws-sdk/client-location";
import data from "./inputs.json" with { type: "json" };
const region = "eu-west-1";
export const main = async () => {
const deleteGeofenceCollParams = {
CollectionName: `${data.inputs.collectionName}`,
};
const locationClient = new LocationClient({ region: region });
try {
const command = new DeleteGeofenceCollectionCommand(
deleteGeofenceCollParams,
);
const response = await locationClient.send(command);
console.log("Collection deleted.");
} catch (caught) {
if (caught instanceof ResourceNotFoundException) {
console.error(
`${data.inputs.collectionName} Geofence collection not found.`,
);
return;
}
}
};
```
+ Pour plus de détails sur l'API, voir [DeleteGeofenceCollection](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/location/command/DeleteGeofenceCollectionCommand)la section *Référence des AWS SDK pour JavaScript API*.
------
#### [ Kotlin ]
**SDK pour Kotlin**
Il y en a plus sur GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code 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.")
}
}
```
+ Pour plus de détails sur l'API, consultez [DeleteGeofenceCollection](https://sdk.amazonaws.com/kotlin/api/latest/index.html)la section *AWS SDK pour la référence de l'API Kotlin*.
------
# Utilisation `DeleteKey` avec un AWS SDK
Les exemples de code suivants illustrent comment utiliser `DeleteKey`.
Les exemples d’actions sont des extraits de code de programmes de plus grande envergure et doivent être exécutés en contexte. Vous pouvez voir cette action en contexte dans l’exemple de code suivant :
+ [Principes de base](location_example_location_Scenario_section.md)
------
#### [ Java ]
**SDK pour Java 2.x**
Il y en a plus sur GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/location#code-examples).
```
/**
* Deletes the specified key from the key-value store.
*
* @param keyName the name of the key to be deleted
* @return a {@link CompletableFuture} that completes when the key has been deleted
* @throws CompletionException if the key was not found or if an error occurred during the deletion process
*/
public CompletableFuture deleteKey(String keyName) {
DeleteKeyRequest keyRequest = DeleteKeyRequest.builder()
.keyName(keyName)
.build();
return getClient().deleteKey(keyRequest)
.whenComplete((response, exception) -> {
if (exception != null) {
Throwable cause = exception.getCause();
if (cause instanceof ResourceNotFoundException) {
throw new CompletionException("The key was not found.", cause);
}
throw new CompletionException("Failed to delete key: " + exception.getMessage(), exception);
}
logger.info("The key {} was deleted.", keyName);
})
.thenApply(response -> null);
}
```
+ Pour plus de détails sur l'API, voir [DeleteKey](https://docs.aws.amazon.com/goto/SdkForJavaV2/location-2020-11-19/DeleteKey)la section *Référence des AWS SDK for Java 2.x API*.
------
#### [ Kotlin ]
**SDK pour Kotlin**
Il y en a plus sur GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code 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.")
}
}
```
+ Pour plus de détails sur l'API, consultez [DeleteKey](https://sdk.amazonaws.com/kotlin/api/latest/index.html)la section *AWS SDK pour la référence de l'API Kotlin*.
------
# Utilisation `DeleteMap` avec un AWS SDK
Les exemples de code suivants illustrent comment utiliser `DeleteMap`.
Les exemples d’actions sont des extraits de code de programmes de plus grande envergure et doivent être exécutés en contexte. Vous pouvez voir cette action en contexte dans l’exemple de code suivant :
+ [Principes de base](location_example_location_Scenario_section.md)
------
#### [ Java ]
**SDK pour Java 2.x**
Il y en a plus sur GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/location#code-examples).
```
/**
* Deletes a map with the specified name.
*
* @param mapName the name of the map to be deleted
* @return a {@link CompletableFuture} that completes when the map deletion is successful, or throws a {@link CompletionException} if an error occurs
*/
public CompletableFuture deleteMap(String mapName) {
DeleteMapRequest mapRequest = DeleteMapRequest.builder()
.mapName(mapName)
.build();
return getClient().deleteMap(mapRequest)
.whenComplete((response, exception) -> {
if (exception != null) {
Throwable cause = exception.getCause();
if (cause instanceof ResourceNotFoundException) {
throw new CompletionException("The map was not found.", cause);
}
throw new CompletionException("Failed to delete map: " + exception.getMessage(), exception);
}
logger.info("The map {} was deleted.", mapName);
})
.thenApply(response -> null);
}
```
+ Pour plus de détails sur l'API, voir [DeleteMap](https://docs.aws.amazon.com/goto/SdkForJavaV2/location-2020-11-19/DeleteMap)la section *Référence des AWS SDK for Java 2.x API*.
------
#### [ JavaScript ]
**SDK pour JavaScript (v3)**
Il y en a plus sur GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/location/actions#code-examples).
```
import { fileURLToPath } from "node:url";
import {
DeleteMapCommand,
LocationClient,
ResourceNotFoundException,
} from "@aws-sdk/client-location";
import data from "./inputs.json" with { type: "json" };
const region = "eu-west-1";
export const main = async () => {
const deleteMapParams = {
MapName: `${data.inputs.mapName}`,
};
try {
const locationClient = new LocationClient({ region: region });
const command = new DeleteMapCommand(deleteMapParams);
const response = await locationClient.send(command);
console.log("Map deleted.");
} catch (caught) {
if (caught instanceof ResourceNotFoundException) {
console.error(`${data.inputs.mapName} map not found.`);
return;
}
}
};
```
+ Pour plus de détails sur l'API, voir [DeleteMap](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/location/command/DeleteMapCommand)la section *Référence des AWS SDK pour JavaScript API*.
------
#### [ Kotlin ]
**SDK pour Kotlin**
Il y en a plus sur GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code 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.")
}
}
```
+ Pour plus de détails sur l'API, consultez [DeleteMap](https://sdk.amazonaws.com/kotlin/api/latest/index.html)la section *AWS SDK pour la référence de l'API Kotlin*.
------
# Utilisation `DeleteRouteCalculator` avec un AWS SDK
Les exemples de code suivants illustrent comment utiliser `DeleteRouteCalculator`.
Les exemples d’actions sont des extraits de code de programmes de plus grande envergure et doivent être exécutés en contexte. Vous pouvez voir cette action en contexte dans l’exemple de code suivant :
+ [Principes de base](location_example_location_Scenario_section.md)
------
#### [ Java ]
**SDK pour Java 2.x**
Il y en a plus sur GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/location#code-examples).
```
/**
* Deletes a route calculator from the system.
*
* @param calcName the name of the route calculator to delete
* @return a {@link CompletableFuture} that completes when the route calculator has been deleted
* @throws CompletionException if an error occurs while deleting the route calculator
* - If the route calculator was not found, a {@link ResourceNotFoundException} will be thrown
* - If any other error occurs, a generic {@link CompletionException} will be thrown
*/
public CompletableFuture deleteRouteCalculator(String calcName) {
DeleteRouteCalculatorRequest calculatorRequest = DeleteRouteCalculatorRequest.builder()
.calculatorName(calcName)
.build();
return getClient().deleteRouteCalculator(calculatorRequest)
.whenComplete((response, exception) -> {
if (exception != null) {
Throwable cause = exception.getCause();
if (cause instanceof ResourceNotFoundException) {
throw new CompletionException("The route calculator was not found.", cause);
}
throw new CompletionException("Failed to delete the route calculator: " + exception.getMessage(), exception);
}
logger.info("The route calculator {} was deleted.", calcName);
})
.thenApply(response -> null);
}
```
+ Pour plus de détails sur l'API, voir [DeleteRouteCalculator](https://docs.aws.amazon.com/goto/SdkForJavaV2/location-2020-11-19/DeleteRouteCalculator)la section *Référence des AWS SDK for Java 2.x API*.
------
#### [ JavaScript ]
**SDK pour JavaScript (v3)**
Il y en a plus sur GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/location/actions#code-examples).
```
import { fileURLToPath } from "node:url";
import {
DeleteRouteCalculatorCommand,
LocationClient,
ResourceNotFoundException,
} from "@aws-sdk/client-location";
import data from "./inputs.json" with { type: "json" };
const region = "eu-west-1";
export const main = async () => {
const deleteRouteCalculatorParams = {
CalculatorName: `${data.inputs.calculatorName}`,
};
try {
const locationClient = new LocationClient({ region: region });
const command = new DeleteRouteCalculatorCommand(
deleteRouteCalculatorParams,
);
const response = await locationClient.send(command);
console.log("Route calculator deleted.");
} catch (caught) {
if (caught instanceof ResourceNotFoundException) {
console.error(
`${data.inputs.calculatorName} route calculator not found.`,
);
return;
}
}
};
```
+ Pour plus de détails sur l'API, voir [DeleteRouteCalculator](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/location/command/DeleteRouteCalculatorCommand)la section *Référence des AWS SDK pour JavaScript API*.
------
#### [ Kotlin ]
**SDK pour Kotlin**
Il y en a plus sur GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code 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.")
}
}
```
+ Pour plus de détails sur l'API, consultez [DeleteRouteCalculator](https://sdk.amazonaws.com/kotlin/api/latest/index.html)la section *AWS SDK pour la référence de l'API Kotlin*.
------
# Utilisation `DeleteTracker` avec un AWS SDK
Les exemples de code suivants illustrent comment utiliser `DeleteTracker`.
Les exemples d’actions sont des extraits de code de programmes de plus grande envergure et doivent être exécutés en contexte. Vous pouvez voir cette action en contexte dans l’exemple de code suivant :
+ [Principes de base](location_example_location_Scenario_section.md)
------
#### [ Java ]
**SDK pour Java 2.x**
Il y en a plus sur GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/location#code-examples).
```
/**
* Deletes a tracker with the specified name.
*
* @param trackerName the name of the tracker to be deleted
* @return a {@link CompletableFuture} that completes when the tracker has been deleted
* @throws CompletionException if an error occurs while deleting the tracker
* - if the tracker was not found, a {@link ResourceNotFoundException} is thrown wrapped in the CompletionException
* - if any other error occurs, a generic CompletionException is thrown with the error message
*/
public CompletableFuture deleteTracker(String trackerName) {
DeleteTrackerRequest trackerRequest = DeleteTrackerRequest.builder()
.trackerName(trackerName)
.build();
return getClient().deleteTracker(trackerRequest)
.whenComplete((response, exception) -> {
if (exception != null) {
Throwable cause = exception.getCause();
if (cause instanceof ResourceNotFoundException) {
throw new CompletionException("The tracker was not found.", cause);
}
throw new CompletionException("Failed to delete the tracker: " + exception.getMessage(), exception);
}
logger.info("The tracker {} was deleted.", trackerName);
})
.thenApply(response -> null); // Ensures CompletableFuture
}
```
+ Pour plus de détails sur l'API, voir [DeleteTracker](https://docs.aws.amazon.com/goto/SdkForJavaV2/location-2020-11-19/DeleteTracker)la section *Référence des AWS SDK for Java 2.x API*.
------
#### [ JavaScript ]
**SDK pour JavaScript (v3)**
Il y en a plus sur GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/location/actions#code-examples).
```
import { fileURLToPath } from "node:url";
import {
DeleteTrackerCommand,
LocationClient,
ResourceNotFoundException,
} from "@aws-sdk/client-location";
import data from "./inputs.json" with { type: "json" };
const region = "eu-west-1";
export const main = async () => {
const deleteTrackerParams = {
TrackerName: `${data.inputs.trackerName}`,
};
try {
const locationClient = new LocationClient({ region: region });
const command = new DeleteTrackerCommand(deleteTrackerParams);
const response = await locationClient.send(command);
console.log("Tracker deleted.");
} catch (caught) {
if (caught instanceof ResourceNotFoundException) {
console.error(`${data.inputs.trackerName} tracker not found.`);
return;
}
}
};
```
+ Pour plus de détails sur l'API, voir [DeleteTracker](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/location/command/DeleteTrackerCommand)la section *Référence des AWS SDK pour JavaScript API*.
------
#### [ Kotlin ]
**SDK pour Kotlin**
Il y en a plus sur GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code 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.")
}
}
```
+ Pour plus de détails sur l'API, consultez [DeleteTracker](https://sdk.amazonaws.com/kotlin/api/latest/index.html)la section *AWS SDK pour la référence de l'API Kotlin*.
------
# Utilisation `GetDevicePosition` avec un AWS SDK
Les exemples de code suivants illustrent comment utiliser `GetDevicePosition`.
Les exemples d’actions sont des extraits de code de programmes de plus grande envergure et doivent être exécutés en contexte. Vous pouvez voir cette action en contexte dans l’exemple de code suivant :
+ [Principes de base](location_example_location_Scenario_section.md)
------
#### [ Java ]
**SDK pour Java 2.x**
Il y en a plus sur GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/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.
* @throws RuntimeException If there is an error fetching the device position.
*/
public CompletableFuture getDevicePosition(String trackerName, String deviceId) {
GetDevicePositionRequest request = GetDevicePositionRequest.builder()
.trackerName(trackerName)
.deviceId(deviceId)
.build();
return getClient().getDevicePosition(request)
.whenComplete((response, exception) -> {
if (exception != null) {
Throwable cause = exception.getCause();
if (cause instanceof ResourceNotFoundException) {
throw new CompletionException("The AWS resource was not found: " + cause.getMessage(), cause);
}
throw new CompletionException("Error fetching device position: " + exception.getMessage(), exception);
}
});
}
```
+ Pour plus de détails sur l'API, voir [GetDevicePosition](https://docs.aws.amazon.com/goto/SdkForJavaV2/location-2020-11-19/GetDevicePosition)la section *Référence des AWS SDK for Java 2.x API*.
------
#### [ JavaScript ]
**SDK pour JavaScript (v3)**
Il y en a plus sur GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/location/actions#code-examples).
```
import { fileURLToPath } from "node:url";
import {
GetDevicePositionCommand,
LocationClient,
ResourceNotFoundException,
} from "@aws-sdk/client-location";
import data from "./inputs.json" with { type: "json" };
const region = "eu-west-1";
export const main = async () => {
const locationClient = new LocationClient({ region: region });
const deviceId = `${data.inputs.deviceId}`;
const trackerName = `${data.inputs.trackerName}`;
const devicePositionParams = {
DeviceId: deviceId,
TrackerName: trackerName,
};
try {
const command = new GetDevicePositionCommand(devicePositionParams);
const response = await locationClient.send(command);
//state.position = response.position;
console.log("Successfully fetched device position: ", response);
} catch (error) {
console.log("Error ", error);
/* if (caught instanceof ResourceNotFoundException) {
console.error(
`"The resource was not found: ${caught.message} \n Exiting program.`,
);
} else {
`An unexpected error error occurred: ${caught.message} \n Exiting program.`;
}
return;*/
}
};
```
+ Pour plus de détails sur l'API, voir [GetDevicePosition](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/location/command/GetDevicePositionCommand)la section *Référence des AWS SDK pour JavaScript API*.
------
#### [ Kotlin ]
**SDK pour Kotlin**
Il y en a plus sur GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code 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)
}
}
```
+ Pour plus de détails sur l'API, consultez [GetDevicePosition](https://sdk.amazonaws.com/kotlin/api/latest/index.html)la section *AWS SDK pour la référence de l'API Kotlin*.
------
# Utilisation `PutGeofence` avec un AWS SDK
Les exemples de code suivants illustrent comment utiliser `PutGeofence`.
Les exemples d’actions sont des extraits de code de programmes de plus grande envergure et doivent être exécutés en contexte. Vous pouvez voir cette action en contexte dans l’exemple de code suivant :
+ [Principes de base](location_example_location_Scenario_section.md)
------
#### [ Java ]
**SDK pour Java 2.x**
Il y en a plus sur GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/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
*/
public CompletableFuture putGeofence(String collectionName, String geoId) {
// Define the geofence geometry (polygon).
GeofenceGeometry geofenceGeometry = GeofenceGeometry.builder()
.polygon(List.of(
List.of(
List.of(-122.3381, 47.6101), // First point
List.of(-122.3281, 47.6101),
List.of(-122.3281, 47.6201),
List.of(-122.3381, 47.6201),
List.of(-122.3381, 47.6101) // Closing the polygon
)
))
.build();
PutGeofenceRequest geofenceRequest = PutGeofenceRequest.builder()
.collectionName(collectionName) // Specify the collection.
.geofenceId(geoId) // Unique ID for the geofence.
.geometry(geofenceGeometry)
.build();
return getClient().putGeofence(geofenceRequest)
.whenComplete((response, exception) -> {
if (exception != null) {
Throwable cause = exception.getCause();
if (cause instanceof ValidationException) {
throw new CompletionException("Validation error while creating geofence: " + cause.getMessage(), cause);
}
throw new CompletionException("Error creating geofence: " + exception.getMessage(), exception);
}
});
}
```
+ Pour plus de détails sur l'API, voir [PutGeofence](https://docs.aws.amazon.com/goto/SdkForJavaV2/location-2020-11-19/PutGeofence)la section *Référence des AWS SDK for Java 2.x API*.
------
#### [ JavaScript ]
**SDK pour JavaScript (v3)**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/location/actions#code-examples).
```
import { fileURLToPath } from "node:url";
import {
PutGeofenceCommand,
LocationClient,
ValidationException,
} from "@aws-sdk/client-location";
import data from "./inputs.json" with { type: "json" };
const region = "eu-west-1";
const locationClient = new LocationClient({ region: region });
export const main = async () => {
const geoFenceGeoParams = {
CollectionName: `${data.inputs.collectionName}`,
GeofenceId: `${data.inputs.geoId}`,
Geometry: {
Polygon: [
[
[-122.3381, 47.6101],
[-122.3281, 47.6101],
[-122.3281, 47.6201],
[-122.3381, 47.6201],
[-122.3381, 47.6101],
],
],
},
};
try {
const command = new PutGeofenceCommand(geoFenceGeoParams);
const response = await locationClient.send(command);
console.log("GeoFence created. GeoFence ID is: ", response.GeofenceId);
} catch (error) {
console.error(
`A validation error occurred while creating geofence: ${error} \n Exiting program.`,
);
return;
}
};
```
+ Pour plus de détails sur l'API, voir [PutGeofence](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/location/command/PutGeofenceCommand)la section *Référence des AWS SDK pour JavaScript API*.
------
#### [ Kotlin ]
**SDK pour Kotlin**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code 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)
}
}
```
+ Pour plus de détails sur l'API, consultez [PutGeofence](https://sdk.amazonaws.com/kotlin/api/latest/index.html)la section *AWS SDK pour la référence de l'API Kotlin*.
------