/*
* Copyright 2012-2017 Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License"). You may not use this file except in compliance with
* the License. A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
* CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions
* and limitations under the License.
*/
package com.amazonaws.services.rekognition;
import org.w3c.dom.*;
import java.net.*;
import java.util.*;
import javax.annotation.Generated;
import org.apache.commons.logging.*;
import com.amazonaws.*;
import com.amazonaws.annotation.SdkInternalApi;
import com.amazonaws.auth.*;
import com.amazonaws.handlers.*;
import com.amazonaws.http.*;
import com.amazonaws.internal.*;
import com.amazonaws.internal.auth.*;
import com.amazonaws.metrics.*;
import com.amazonaws.regions.*;
import com.amazonaws.transform.*;
import com.amazonaws.util.*;
import com.amazonaws.protocol.json.*;
import com.amazonaws.util.AWSRequestMetrics.Field;
import com.amazonaws.annotation.ThreadSafe;
import com.amazonaws.client.AwsSyncClientParams;
import com.amazonaws.services.rekognition.AmazonRekognitionClientBuilder;
import com.amazonaws.AmazonServiceException;
import com.amazonaws.services.rekognition.model.*;
import com.amazonaws.services.rekognition.model.transform.*;
/**
* Client for accessing Amazon Rekognition. All service calls made using this client are blocking, and will not return
* until the service call completes.
* <p>
* <p>
* This is the Amazon Rekognition API reference.
* </p>
*/
@ThreadSafe
@Generated("com.amazonaws:aws-java-sdk-code-generator")
public class AmazonRekognitionClient extends AmazonWebServiceClient implements AmazonRekognition {
/** Provider for AWS credentials. */
private final AWSCredentialsProvider awsCredentialsProvider;
private static final Log log = LogFactory.getLog(AmazonRekognition.class);
/** Default signing name for the service. */
private static final String DEFAULT_SIGNING_NAME = "rekognition";
/** Client configuration factory providing ClientConfigurations tailored to this client */
protected static final ClientConfigurationFactory configFactory = new ClientConfigurationFactory();
private final com.amazonaws.protocol.json.SdkJsonProtocolFactory protocolFactory = new com.amazonaws.protocol.json.SdkJsonProtocolFactory(
new JsonClientMetadata()
.withProtocolVersion("1.1")
.withSupportsCbor(false)
.withSupportsIon(false)
.addErrorMetadata(
new JsonErrorShapeMetadata().withErrorCode("AccessDeniedException").withModeledClass(
com.amazonaws.services.rekognition.model.AccessDeniedException.class))
.addErrorMetadata(
new JsonErrorShapeMetadata().withErrorCode("InvalidParameterException").withModeledClass(
com.amazonaws.services.rekognition.model.InvalidParameterException.class))
.addErrorMetadata(
new JsonErrorShapeMetadata().withErrorCode("ResourceNotFoundException").withModeledClass(
com.amazonaws.services.rekognition.model.ResourceNotFoundException.class))
.addErrorMetadata(
new JsonErrorShapeMetadata().withErrorCode("InvalidImageFormatException").withModeledClass(
com.amazonaws.services.rekognition.model.InvalidImageFormatException.class))
.addErrorMetadata(
new JsonErrorShapeMetadata().withErrorCode("ThrottlingException").withModeledClass(
com.amazonaws.services.rekognition.model.ThrottlingException.class))
.addErrorMetadata(
new JsonErrorShapeMetadata().withErrorCode("ProvisionedThroughputExceededException").withModeledClass(
com.amazonaws.services.rekognition.model.ProvisionedThroughputExceededException.class))
.addErrorMetadata(
new JsonErrorShapeMetadata().withErrorCode("ImageTooLargeException").withModeledClass(
com.amazonaws.services.rekognition.model.ImageTooLargeException.class))
.addErrorMetadata(
new JsonErrorShapeMetadata().withErrorCode("ResourceAlreadyExistsException").withModeledClass(
com.amazonaws.services.rekognition.model.ResourceAlreadyExistsException.class))
.addErrorMetadata(
new JsonErrorShapeMetadata().withErrorCode("InvalidPaginationTokenException").withModeledClass(
com.amazonaws.services.rekognition.model.InvalidPaginationTokenException.class))
.addErrorMetadata(
new JsonErrorShapeMetadata().withErrorCode("InvalidS3ObjectException").withModeledClass(
com.amazonaws.services.rekognition.model.InvalidS3ObjectException.class))
.addErrorMetadata(
new JsonErrorShapeMetadata().withErrorCode("InternalServerError").withModeledClass(
com.amazonaws.services.rekognition.model.InternalServerErrorException.class))
.withBaseServiceExceptionClass(com.amazonaws.services.rekognition.model.AmazonRekognitionException.class));
/**
* Constructs a new client to invoke service methods on Amazon Rekognition. A credentials provider chain will be
* used that searches for credentials in this order:
* <ul>
* <li>Environment Variables - AWS_ACCESS_KEY_ID and AWS_SECRET_KEY</li>
* <li>Java System Properties - aws.accessKeyId and aws.secretKey</li>
* <li>Instance profile credentials delivered through the Amazon EC2 metadata service</li>
* </ul>
*
* <p>
* All service calls made using this new client object are blocking, and will not return until the service call
* completes.
*
* @see DefaultAWSCredentialsProviderChain
* @deprecated use {@link AmazonRekognitionClientBuilder#defaultClient()}
*/
@Deprecated
public AmazonRekognitionClient() {
this(DefaultAWSCredentialsProviderChain.getInstance(), configFactory.getConfig());
}
/**
* Constructs a new client to invoke service methods on Amazon Rekognition. A credentials provider chain will be
* used that searches for credentials in this order:
* <ul>
* <li>Environment Variables - AWS_ACCESS_KEY_ID and AWS_SECRET_KEY</li>
* <li>Java System Properties - aws.accessKeyId and aws.secretKey</li>
* <li>Instance profile credentials delivered through the Amazon EC2 metadata service</li>
* </ul>
*
* <p>
* All service calls made using this new client object are blocking, and will not return until the service call
* completes.
*
* @param clientConfiguration
* The client configuration options controlling how this client connects to Amazon Rekognition (ex: proxy
* settings, retry counts, etc.).
*
* @see DefaultAWSCredentialsProviderChain
* @deprecated use {@link AmazonRekognitionClientBuilder#withClientConfiguration(ClientConfiguration)}
*/
@Deprecated
public AmazonRekognitionClient(ClientConfiguration clientConfiguration) {
this(DefaultAWSCredentialsProviderChain.getInstance(), clientConfiguration);
}
/**
* Constructs a new client to invoke service methods on Amazon Rekognition using the specified AWS account
* credentials.
*
* <p>
* All service calls made using this new client object are blocking, and will not return until the service call
* completes.
*
* @param awsCredentials
* The AWS credentials (access key ID and secret key) to use when authenticating with AWS services.
* @deprecated use {@link AmazonRekognitionClientBuilder#withCredentials(AWSCredentialsProvider)} for example:
* {@code AmazonRekognitionClientBuilder.standard().withCredentials(new AWSStaticCredentialsProvider(awsCredentials)).build();}
*/
@Deprecated
public AmazonRekognitionClient(AWSCredentials awsCredentials) {
this(awsCredentials, configFactory.getConfig());
}
/**
* Constructs a new client to invoke service methods on Amazon Rekognition using the specified AWS account
* credentials and client configuration options.
*
* <p>
* All service calls made using this new client object are blocking, and will not return until the service call
* completes.
*
* @param awsCredentials
* The AWS credentials (access key ID and secret key) to use when authenticating with AWS services.
* @param clientConfiguration
* The client configuration options controlling how this client connects to Amazon Rekognition (ex: proxy
* settings, retry counts, etc.).
* @deprecated use {@link AmazonRekognitionClientBuilder#withCredentials(AWSCredentialsProvider)} and
* {@link AmazonRekognitionClientBuilder#withClientConfiguration(ClientConfiguration)}
*/
@Deprecated
public AmazonRekognitionClient(AWSCredentials awsCredentials, ClientConfiguration clientConfiguration) {
super(clientConfiguration);
this.awsCredentialsProvider = new StaticCredentialsProvider(awsCredentials);
init();
}
/**
* Constructs a new client to invoke service methods on Amazon Rekognition using the specified AWS account
* credentials provider.
*
* <p>
* All service calls made using this new client object are blocking, and will not return until the service call
* completes.
*
* @param awsCredentialsProvider
* The AWS credentials provider which will provide credentials to authenticate requests with AWS services.
* @deprecated use {@link AmazonRekognitionClientBuilder#withCredentials(AWSCredentialsProvider)}
*/
@Deprecated
public AmazonRekognitionClient(AWSCredentialsProvider awsCredentialsProvider) {
this(awsCredentialsProvider, configFactory.getConfig());
}
/**
* Constructs a new client to invoke service methods on Amazon Rekognition using the specified AWS account
* credentials provider and client configuration options.
*
* <p>
* All service calls made using this new client object are blocking, and will not return until the service call
* completes.
*
* @param awsCredentialsProvider
* The AWS credentials provider which will provide credentials to authenticate requests with AWS services.
* @param clientConfiguration
* The client configuration options controlling how this client connects to Amazon Rekognition (ex: proxy
* settings, retry counts, etc.).
* @deprecated use {@link AmazonRekognitionClientBuilder#withCredentials(AWSCredentialsProvider)} and
* {@link AmazonRekognitionClientBuilder#withClientConfiguration(ClientConfiguration)}
*/
@Deprecated
public AmazonRekognitionClient(AWSCredentialsProvider awsCredentialsProvider, ClientConfiguration clientConfiguration) {
this(awsCredentialsProvider, clientConfiguration, null);
}
/**
* Constructs a new client to invoke service methods on Amazon Rekognition using the specified AWS account
* credentials provider, client configuration options, and request metric collector.
*
* <p>
* All service calls made using this new client object are blocking, and will not return until the service call
* completes.
*
* @param awsCredentialsProvider
* The AWS credentials provider which will provide credentials to authenticate requests with AWS services.
* @param clientConfiguration
* The client configuration options controlling how this client connects to Amazon Rekognition (ex: proxy
* settings, retry counts, etc.).
* @param requestMetricCollector
* optional request metric collector
* @deprecated use {@link AmazonRekognitionClientBuilder#withCredentials(AWSCredentialsProvider)} and
* {@link AmazonRekognitionClientBuilder#withClientConfiguration(ClientConfiguration)} and
* {@link AmazonRekognitionClientBuilder#withMetricsCollector(RequestMetricCollector)}
*/
@Deprecated
public AmazonRekognitionClient(AWSCredentialsProvider awsCredentialsProvider, ClientConfiguration clientConfiguration,
RequestMetricCollector requestMetricCollector) {
super(clientConfiguration, requestMetricCollector);
this.awsCredentialsProvider = awsCredentialsProvider;
init();
}
public static AmazonRekognitionClientBuilder builder() {
return AmazonRekognitionClientBuilder.standard();
}
/**
* Constructs a new client to invoke service methods on Amazon Rekognition using the specified parameters.
*
* <p>
* All service calls made using this new client object are blocking, and will not return until the service call
* completes.
*
* @param clientParams
* Object providing client parameters.
*/
AmazonRekognitionClient(AwsSyncClientParams clientParams) {
super(clientParams);
this.awsCredentialsProvider = clientParams.getCredentialsProvider();
init();
}
private void init() {
setServiceNameIntern(DEFAULT_SIGNING_NAME);
setEndpointPrefix(ENDPOINT_PREFIX);
// calling this.setEndPoint(...) will also modify the signer accordingly
setEndpoint("rekognition.us-east-1.amazonaws.com");
HandlerChainFactory chainFactory = new HandlerChainFactory();
requestHandler2s.addAll(chainFactory.newRequestHandlerChain("/com/amazonaws/services/rekognition/request.handlers"));
requestHandler2s.addAll(chainFactory.newRequestHandler2Chain("/com/amazonaws/services/rekognition/request.handler2s"));
requestHandler2s.addAll(chainFactory.getGlobalHandlers());
}
/**
* <p>
* Compares a face in the <i>source</i> input image with each face detected in the <i>target</i> input image.
* </p>
* <note>
* <p>
* If the source image contains multiple faces, the service detects the largest face and uses it to compare with
* each face detected in the target image.
* </p>
* </note>
* <p>
* In response, the operation returns an array of face matches ordered by similarity score with the highest
* similarity scores first. For each face match, the response provides a bounding box of the face and
* <code>confidence</code> value (indicating the level of confidence that the bounding box contains a face). The
* response also provides a <code>similarity</code> score, which indicates how closely the faces match.
* </p>
* <note>
* <p>
* By default, only faces with the similarity score of greater than or equal to 80% are returned in the response.
* You can change this value.
* </p>
* </note>
* <p>
* In addition to the face matches, the response returns information about the face in the source image, including
* the bounding box of the face and confidence value.
* </p>
* <note>
* <p>
* This is a stateless API operation. That is, the operation does not persist any data.
* </p>
* </note>
* <p>
* For an example, see <a>get-started-exercise-compare-faces</a>
* </p>
* <p>
* This operation requires permissions to perform the <code>rekognition:CompareFaces</code> action.
* </p>
*
* @param compareFacesRequest
* @return Result of the CompareFaces operation returned by the service.
* @throws InvalidParameterException
* Input parameter violated a constraint. Validate your parameter before calling the API operation again.
* @throws InvalidS3ObjectException
* Amazon Rekognition is unable to access the S3 object specified in the request.
* @throws ImageTooLargeException
* The input image size exceeds the allowed limit. For more information, see <a>limits</a>.
* @throws AccessDeniedException
* You are not authorized to perform the action.
* @throws InternalServerErrorException
* Amazon Rekognition experienced a service issue. Try your call again.
* @throws ThrottlingException
* Amazon Rekognition is temporarily unable to process the request. Try your call again.
* @throws ProvisionedThroughputExceededException
* The number of requests exceeded your throughput limit. If you want to increase this limit, contact Amazon
* Rekognition.
* @throws InvalidImageFormatException
* The provided image format is not supported.
* @sample AmazonRekognition.CompareFaces
*/
@Override
public CompareFacesResult compareFaces(CompareFacesRequest request) {
request = beforeClientExecution(request);
return executeCompareFaces(request);
}
@SdkInternalApi
final CompareFacesResult executeCompareFaces(CompareFacesRequest compareFacesRequest) {
ExecutionContext executionContext = createExecutionContext(compareFacesRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request<CompareFacesRequest> request = null;
Response<CompareFacesResult> response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new CompareFacesRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(compareFacesRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler<AmazonWebServiceResponse<CompareFacesResult>> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new CompareFacesResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
* <p>
* Creates a collection in an AWS Region. You can add faces to the collection using the operation.
* </p>
* <p>
* For example, you might create collections, one for each of your application users. A user can then index faces
* using the <code>IndexFaces</code> operation and persist results in a specific collection. Then, a user can search
* the collection for faces in the user-specific container.
* </p>
* <p>
* For an example, see <a>example1</a>.
* </p>
* <p>
* This operation requires permissions to perform the <code>rekognition:CreateCollection</code> action.
* </p>
*
* @param createCollectionRequest
* @return Result of the CreateCollection operation returned by the service.
* @throws InvalidParameterException
* Input parameter violated a constraint. Validate your parameter before calling the API operation again.
* @throws AccessDeniedException
* You are not authorized to perform the action.
* @throws InternalServerErrorException
* Amazon Rekognition experienced a service issue. Try your call again.
* @throws ThrottlingException
* Amazon Rekognition is temporarily unable to process the request. Try your call again.
* @throws ProvisionedThroughputExceededException
* The number of requests exceeded your throughput limit. If you want to increase this limit, contact Amazon
* Rekognition.
* @throws ResourceAlreadyExistsException
* A collection with the specified ID already exists.
* @sample AmazonRekognition.CreateCollection
*/
@Override
public CreateCollectionResult createCollection(CreateCollectionRequest request) {
request = beforeClientExecution(request);
return executeCreateCollection(request);
}
@SdkInternalApi
final CreateCollectionResult executeCreateCollection(CreateCollectionRequest createCollectionRequest) {
ExecutionContext executionContext = createExecutionContext(createCollectionRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request<CreateCollectionRequest> request = null;
Response<CreateCollectionResult> response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new CreateCollectionRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(createCollectionRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler<AmazonWebServiceResponse<CreateCollectionResult>> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new CreateCollectionResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
* <p>
* Deletes the specified collection. Note that this operation removes all faces in the collection. For an example,
* see <a>example1</a>.
* </p>
* <p>
* This operation requires permissions to perform the <code>rekognition:DeleteCollection</code> action.
* </p>
*
* @param deleteCollectionRequest
* @return Result of the DeleteCollection operation returned by the service.
* @throws InvalidParameterException
* Input parameter violated a constraint. Validate your parameter before calling the API operation again.
* @throws AccessDeniedException
* You are not authorized to perform the action.
* @throws InternalServerErrorException
* Amazon Rekognition experienced a service issue. Try your call again.
* @throws ThrottlingException
* Amazon Rekognition is temporarily unable to process the request. Try your call again.
* @throws ProvisionedThroughputExceededException
* The number of requests exceeded your throughput limit. If you want to increase this limit, contact Amazon
* Rekognition.
* @throws ResourceNotFoundException
* Collection specified in the request is not found.
* @sample AmazonRekognition.DeleteCollection
*/
@Override
public DeleteCollectionResult deleteCollection(DeleteCollectionRequest request) {
request = beforeClientExecution(request);
return executeDeleteCollection(request);
}
@SdkInternalApi
final DeleteCollectionResult executeDeleteCollection(DeleteCollectionRequest deleteCollectionRequest) {
ExecutionContext executionContext = createExecutionContext(deleteCollectionRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request<DeleteCollectionRequest> request = null;
Response<DeleteCollectionResult> response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DeleteCollectionRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(deleteCollectionRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler<AmazonWebServiceResponse<DeleteCollectionResult>> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new DeleteCollectionResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
* <p>
* Deletes faces from a collection. You specify a collection ID and an array of face IDs to remove from the
* collection.
* </p>
* <p>
* This operation requires permissions to perform the <code>rekognition:DeleteFaces</code> action.
* </p>
*
* @param deleteFacesRequest
* @return Result of the DeleteFaces operation returned by the service.
* @throws InvalidParameterException
* Input parameter violated a constraint. Validate your parameter before calling the API operation again.
* @throws AccessDeniedException
* You are not authorized to perform the action.
* @throws InternalServerErrorException
* Amazon Rekognition experienced a service issue. Try your call again.
* @throws ThrottlingException
* Amazon Rekognition is temporarily unable to process the request. Try your call again.
* @throws ProvisionedThroughputExceededException
* The number of requests exceeded your throughput limit. If you want to increase this limit, contact Amazon
* Rekognition.
* @throws ResourceNotFoundException
* Collection specified in the request is not found.
* @sample AmazonRekognition.DeleteFaces
*/
@Override
public DeleteFacesResult deleteFaces(DeleteFacesRequest request) {
request = beforeClientExecution(request);
return executeDeleteFaces(request);
}
@SdkInternalApi
final DeleteFacesResult executeDeleteFaces(DeleteFacesRequest deleteFacesRequest) {
ExecutionContext executionContext = createExecutionContext(deleteFacesRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request<DeleteFacesRequest> request = null;
Response<DeleteFacesResult> response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DeleteFacesRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(deleteFacesRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler<AmazonWebServiceResponse<DeleteFacesResult>> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new DeleteFacesResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
* <p>
* Detects faces within an image (JPEG or PNG) that is provided as input.
* </p>
* <p>
* For each face detected, the operation returns face details including a bounding box of the face, a confidence
* value (that the bounding box contains a face), and a fixed set of attributes such as facial landmarks (for
* example, coordinates of eye and mouth), gender, presence of beard, sunglasses, etc.
* </p>
* <p>
* The face-detection algorithm is most effective on frontal faces. For non-frontal or obscured faces, the algorithm
* may not detect the faces or might detect faces with lower confidence.
* </p>
* <note>
* <p>
* This is a stateless API operation. That is, the operation does not persist any data.
* </p>
* </note>
* <p>
* For an example, see <a>get-started-exercise-detect-faces</a>.
* </p>
* <p>
* This operation requires permissions to perform the <code>rekognition:DetectFaces</code> action.
* </p>
*
* @param detectFacesRequest
* @return Result of the DetectFaces operation returned by the service.
* @throws InvalidS3ObjectException
* Amazon Rekognition is unable to access the S3 object specified in the request.
* @throws InvalidParameterException
* Input parameter violated a constraint. Validate your parameter before calling the API operation again.
* @throws ImageTooLargeException
* The input image size exceeds the allowed limit. For more information, see <a>limits</a>.
* @throws AccessDeniedException
* You are not authorized to perform the action.
* @throws InternalServerErrorException
* Amazon Rekognition experienced a service issue. Try your call again.
* @throws ThrottlingException
* Amazon Rekognition is temporarily unable to process the request. Try your call again.
* @throws ProvisionedThroughputExceededException
* The number of requests exceeded your throughput limit. If you want to increase this limit, contact Amazon
* Rekognition.
* @throws InvalidImageFormatException
* The provided image format is not supported.
* @sample AmazonRekognition.DetectFaces
*/
@Override
public DetectFacesResult detectFaces(DetectFacesRequest request) {
request = beforeClientExecution(request);
return executeDetectFaces(request);
}
@SdkInternalApi
final DetectFacesResult executeDetectFaces(DetectFacesRequest detectFacesRequest) {
ExecutionContext executionContext = createExecutionContext(detectFacesRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request<DetectFacesRequest> request = null;
Response<DetectFacesResult> response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DetectFacesRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(detectFacesRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler<AmazonWebServiceResponse<DetectFacesResult>> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new DetectFacesResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
* <p>
* Detects instances of real-world labels within an image (JPEG or PNG) provided as input. This includes objects
* like flower, tree, and table; events like wedding, graduation, and birthday party; and concepts like landscape,
* evening, and nature. For an example, see <a>get-started-exercise-detect-labels</a>.
* </p>
* <p>
* For each object, scene, and concept the API returns one or more labels. Each label provides the object name, and
* the level of confidence that the image contains the object. For example, suppose the input image has a
* lighthouse, the sea, and a rock. The response will include all three labels, one for each object.
* </p>
* <p>
* <code>{Name: lighthouse, Confidence: 98.4629}</code>
* </p>
* <p>
* <code>{Name: rock,Confidence: 79.2097}</code>
* </p>
* <p>
* <code> {Name: sea,Confidence: 75.061}</code>
* </p>
* <p>
* In the preceding example, the operation returns one label for each of the three objects. The operation can also
* return multiple labels for the same object in the image. For example, if the input image shows a flower (for
* example, a tulip), the operation might return the following three labels.
* </p>
* <p>
* <code>{Name: flower,Confidence: 99.0562}</code>
* </p>
* <p>
* <code>{Name: plant,Confidence: 99.0562}</code>
* </p>
* <p>
* <code>{Name: tulip,Confidence: 99.0562}</code>
* </p>
* <p>
* In this example, the detection algorithm more precisely identifies the flower as a tulip.
* </p>
* <p>
* You can provide the input image as an S3 object or as base64-encoded bytes. In response, the API returns an array
* of labels. In addition, the response also includes the orientation correction. Optionally, you can specify
* <code>MinConfidence</code> to control the confidence threshold for the labels returned. The default is 50%. You
* can also add the <code>MaxLabels</code> parameter to limit the number of labels returned.
* </p>
* <note>
* <p>
* If the object detected is a person, the operation doesn't provide the same facial details that the
* <a>DetectFaces</a> operation provides.
* </p>
* </note>
* <p>
* This is a stateless API operation. That is, the operation does not persist any data.
* </p>
* <p>
* This operation requires permissions to perform the <code>rekognition:DetectLabels</code> action.
* </p>
*
* @param detectLabelsRequest
* @return Result of the DetectLabels operation returned by the service.
* @throws InvalidS3ObjectException
* Amazon Rekognition is unable to access the S3 object specified in the request.
* @throws InvalidParameterException
* Input parameter violated a constraint. Validate your parameter before calling the API operation again.
* @throws ImageTooLargeException
* The input image size exceeds the allowed limit. For more information, see <a>limits</a>.
* @throws AccessDeniedException
* You are not authorized to perform the action.
* @throws InternalServerErrorException
* Amazon Rekognition experienced a service issue. Try your call again.
* @throws ThrottlingException
* Amazon Rekognition is temporarily unable to process the request. Try your call again.
* @throws ProvisionedThroughputExceededException
* The number of requests exceeded your throughput limit. If you want to increase this limit, contact Amazon
* Rekognition.
* @throws InvalidImageFormatException
* The provided image format is not supported.
* @sample AmazonRekognition.DetectLabels
*/
@Override
public DetectLabelsResult detectLabels(DetectLabelsRequest request) {
request = beforeClientExecution(request);
return executeDetectLabels(request);
}
@SdkInternalApi
final DetectLabelsResult executeDetectLabels(DetectLabelsRequest detectLabelsRequest) {
ExecutionContext executionContext = createExecutionContext(detectLabelsRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request<DetectLabelsRequest> request = null;
Response<DetectLabelsResult> response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DetectLabelsRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(detectLabelsRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler<AmazonWebServiceResponse<DetectLabelsResult>> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new DetectLabelsResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
* <p>
* Detects explicit or suggestive adult content in a specified .jpeg or .png image. Use
* <code>DetectModerationLabels</code> to moderate images depending on your requirements. For example, you might
* want to filter images that contain nudity, but not images containing suggestive content.
* </p>
* <p>
* To filter images, use the labels returned by <code>DetectModerationLabels</code> to determine which types of
* content are appropriate. For information about moderation labels, see <a>howitworks-moderateimage</a>.
* </p>
*
* @param detectModerationLabelsRequest
* @return Result of the DetectModerationLabels operation returned by the service.
* @throws InvalidS3ObjectException
* Amazon Rekognition is unable to access the S3 object specified in the request.
* @throws InvalidParameterException
* Input parameter violated a constraint. Validate your parameter before calling the API operation again.
* @throws ImageTooLargeException
* The input image size exceeds the allowed limit. For more information, see <a>limits</a>.
* @throws AccessDeniedException
* You are not authorized to perform the action.
* @throws InternalServerErrorException
* Amazon Rekognition experienced a service issue. Try your call again.
* @throws ThrottlingException
* Amazon Rekognition is temporarily unable to process the request. Try your call again.
* @throws ProvisionedThroughputExceededException
* The number of requests exceeded your throughput limit. If you want to increase this limit, contact Amazon
* Rekognition.
* @throws InvalidImageFormatException
* The provided image format is not supported.
* @sample AmazonRekognition.DetectModerationLabels
*/
@Override
public DetectModerationLabelsResult detectModerationLabels(DetectModerationLabelsRequest request) {
request = beforeClientExecution(request);
return executeDetectModerationLabels(request);
}
@SdkInternalApi
final DetectModerationLabelsResult executeDetectModerationLabels(DetectModerationLabelsRequest detectModerationLabelsRequest) {
ExecutionContext executionContext = createExecutionContext(detectModerationLabelsRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request<DetectModerationLabelsRequest> request = null;
Response<DetectModerationLabelsResult> response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DetectModerationLabelsRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(detectModerationLabelsRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler<AmazonWebServiceResponse<DetectModerationLabelsResult>> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new DetectModerationLabelsResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
* <p>
* Detects faces in the input image and adds them to the specified collection.
* </p>
* <p>
* Amazon Rekognition does not save the actual faces detected. Instead, the underlying detection algorithm first
* detects the faces in the input image, and for each face extracts facial features into a feature vector, and
* stores it in the back-end database. Amazon Rekognition uses feature vectors when performing face match and search
* operations using the and operations.
* </p>
* <p>
* If you provide the optional <code>externalImageID</code> for the input image you provided, Amazon Rekognition
* associates this ID with all faces that it detects. When you call the operation, the response returns the external
* ID. You can use this external image ID to create a client-side index to associate the faces with each image. You
* can then use the index to find all faces in an image.
* </p>
* <p>
* In response, the operation returns an array of metadata for all detected faces. This includes, the bounding box
* of the detected face, confidence value (indicating the bounding box contains a face), a face ID assigned by the
* service for each face that is detected and stored, and an image ID assigned by the service for the input image If
* you request all facial attributes (using the <code>detectionAttributes</code> parameter, Amazon Rekognition
* returns detailed facial attributes such as facial landmarks (for example, location of eye and mount) and other
* facial attributes such gender. If you provide the same image, specify the same collection, and use the same
* external ID in the <code>IndexFaces</code> operation, Amazon Rekognition doesn't save duplicate face metadata.
* </p>
* <p>
* For an example, see <a>example2</a>.
* </p>
* <p>
* This operation requires permissions to perform the <code>rekognition:IndexFaces</code> action.
* </p>
*
* @param indexFacesRequest
* @return Result of the IndexFaces operation returned by the service.
* @throws InvalidS3ObjectException
* Amazon Rekognition is unable to access the S3 object specified in the request.
* @throws InvalidParameterException
* Input parameter violated a constraint. Validate your parameter before calling the API operation again.
* @throws ImageTooLargeException
* The input image size exceeds the allowed limit. For more information, see <a>limits</a>.
* @throws AccessDeniedException
* You are not authorized to perform the action.
* @throws InternalServerErrorException
* Amazon Rekognition experienced a service issue. Try your call again.
* @throws ThrottlingException
* Amazon Rekognition is temporarily unable to process the request. Try your call again.
* @throws ProvisionedThroughputExceededException
* The number of requests exceeded your throughput limit. If you want to increase this limit, contact Amazon
* Rekognition.
* @throws ResourceNotFoundException
* Collection specified in the request is not found.
* @throws InvalidImageFormatException
* The provided image format is not supported.
* @sample AmazonRekognition.IndexFaces
*/
@Override
public IndexFacesResult indexFaces(IndexFacesRequest request) {
request = beforeClientExecution(request);
return executeIndexFaces(request);
}
@SdkInternalApi
final IndexFacesResult executeIndexFaces(IndexFacesRequest indexFacesRequest) {
ExecutionContext executionContext = createExecutionContext(indexFacesRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request<IndexFacesRequest> request = null;
Response<IndexFacesResult> response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new IndexFacesRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(indexFacesRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler<AmazonWebServiceResponse<IndexFacesResult>> responseHandler = protocolFactory.createResponseHandler(new JsonOperationMetadata()
.withPayloadJson(true).withHasStreamingSuccessResponse(false), new IndexFacesResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
* <p>
* Returns list of collection IDs in your account. If the result is truncated, the response also provides a
* <code>NextToken</code> that you can use in the subsequent request to fetch the next set of collection IDs.
* </p>
* <p>
* For an example, see <a>example1</a>.
* </p>
* <p>
* This operation requires permissions to perform the <code>rekognition:ListCollections</code> action.
* </p>
*
* @param listCollectionsRequest
* @return Result of the ListCollections operation returned by the service.
* @throws InvalidParameterException
* Input parameter violated a constraint. Validate your parameter before calling the API operation again.
* @throws AccessDeniedException
* You are not authorized to perform the action.
* @throws InternalServerErrorException
* Amazon Rekognition experienced a service issue. Try your call again.
* @throws ThrottlingException
* Amazon Rekognition is temporarily unable to process the request. Try your call again.
* @throws ProvisionedThroughputExceededException
* The number of requests exceeded your throughput limit. If you want to increase this limit, contact Amazon
* Rekognition.
* @throws InvalidPaginationTokenException
* Pagination token in the request is not valid.
* @throws ResourceNotFoundException
* Collection specified in the request is not found.
* @sample AmazonRekognition.ListCollections
*/
@Override
public ListCollectionsResult listCollections(ListCollectionsRequest request) {
request = beforeClientExecution(request);
return executeListCollections(request);
}
@SdkInternalApi
final ListCollectionsResult executeListCollections(ListCollectionsRequest listCollectionsRequest) {
ExecutionContext executionContext = createExecutionContext(listCollectionsRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request<ListCollectionsRequest> request = null;
Response<ListCollectionsResult> response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new ListCollectionsRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(listCollectionsRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler<AmazonWebServiceResponse<ListCollectionsResult>> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new ListCollectionsResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
* <p>
* Returns metadata for faces in the specified collection. This metadata includes information such as the bounding
* box coordinates, the confidence (that the bounding box contains a face), and face ID. For an example, see
* <a>example3</a>.
* </p>
* <p>
* This operation requires permissions to perform the <code>rekognition:ListFaces</code> action.
* </p>
*
* @param listFacesRequest
* @return Result of the ListFaces operation returned by the service.
* @throws InvalidParameterException
* Input parameter violated a constraint. Validate your parameter before calling the API operation again.
* @throws AccessDeniedException
* You are not authorized to perform the action.
* @throws InternalServerErrorException
* Amazon Rekognition experienced a service issue. Try your call again.
* @throws ThrottlingException
* Amazon Rekognition is temporarily unable to process the request. Try your call again.
* @throws ProvisionedThroughputExceededException
* The number of requests exceeded your throughput limit. If you want to increase this limit, contact Amazon
* Rekognition.
* @throws InvalidPaginationTokenException
* Pagination token in the request is not valid.
* @throws ResourceNotFoundException
* Collection specified in the request is not found.
* @sample AmazonRekognition.ListFaces
*/
@Override
public ListFacesResult listFaces(ListFacesRequest request) {
request = beforeClientExecution(request);
return executeListFaces(request);
}
@SdkInternalApi
final ListFacesResult executeListFaces(ListFacesRequest listFacesRequest) {
ExecutionContext executionContext = createExecutionContext(listFacesRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request<ListFacesRequest> request = null;
Response<ListFacesResult> response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new ListFacesRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(listFacesRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler<AmazonWebServiceResponse<ListFacesResult>> responseHandler = protocolFactory.createResponseHandler(new JsonOperationMetadata()
.withPayloadJson(true).withHasStreamingSuccessResponse(false), new ListFacesResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
* <p>
* For a given input face ID, searches for matching faces in the collection the face belongs to. You get a face ID
* when you add a face to the collection using the <a>IndexFaces</a> operation. The operation compares the features
* of the input face with faces in the specified collection.
* </p>
* <note>
* <p>
* You can also search faces without indexing faces by using the <code>SearchFacesByImage</code> operation.
* </p>
* </note>
* <p>
* The operation response returns an array of faces that match, ordered by similarity score with the highest
* similarity first. More specifically, it is an array of metadata for each face match that is found. Along with the
* metadata, the response also includes a <code>confidence</code> value for each face match, indicating the
* confidence that the specific face matches the input face.
* </p>
* <p>
* For an example, see <a>example3</a>.
* </p>
* <p>
* This operation requires permissions to perform the <code>rekognition:SearchFaces</code> action.
* </p>
*
* @param searchFacesRequest
* @return Result of the SearchFaces operation returned by the service.
* @throws InvalidParameterException
* Input parameter violated a constraint. Validate your parameter before calling the API operation again.
* @throws AccessDeniedException
* You are not authorized to perform the action.
* @throws InternalServerErrorException
* Amazon Rekognition experienced a service issue. Try your call again.
* @throws ThrottlingException
* Amazon Rekognition is temporarily unable to process the request. Try your call again.
* @throws ProvisionedThroughputExceededException
* The number of requests exceeded your throughput limit. If you want to increase this limit, contact Amazon
* Rekognition.
* @throws ResourceNotFoundException
* Collection specified in the request is not found.
* @sample AmazonRekognition.SearchFaces
*/
@Override
public SearchFacesResult searchFaces(SearchFacesRequest request) {
request = beforeClientExecution(request);
return executeSearchFaces(request);
}
@SdkInternalApi
final SearchFacesResult executeSearchFaces(SearchFacesRequest searchFacesRequest) {
ExecutionContext executionContext = createExecutionContext(searchFacesRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request<SearchFacesRequest> request = null;
Response<SearchFacesResult> response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new SearchFacesRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(searchFacesRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler<AmazonWebServiceResponse<SearchFacesResult>> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new SearchFacesResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
* <p>
* For a given input image, first detects the largest face in the image, and then searches the specified collection
* for matching faces. The operation compares the features of the input face with faces in the specified collection.
* </p>
* <note>
* <p>
* To search for all faces in an input image, you might first call the operation, and then use the face IDs returned
* in subsequent calls to the operation.
* </p>
* <p>
* You can also call the <code>DetectFaces</code> operation and use the bounding boxes in the response to make face
* crops, which then you can pass in to the <code>SearchFacesByImage</code> operation.
* </p>
* </note>
* <p>
* The response returns an array of faces that match, ordered by similarity score with the highest similarity first.
* More specifically, it is an array of metadata for each face match found. Along with the metadata, the response
* also includes a <code>similarity</code> indicating how similar the face is to the input face. In the response,
* the operation also returns the bounding box (and a confidence level that the bounding box contains a face) of the
* face that Amazon Rekognition used for the input image.
* </p>
* <p>
* For an example, see <a>example3</a>.
* </p>
* <p>
* This operation requires permissions to perform the <code>rekognition:SearchFacesByImage</code> action.
* </p>
*
* @param searchFacesByImageRequest
* @return Result of the SearchFacesByImage operation returned by the service.
* @throws InvalidS3ObjectException
* Amazon Rekognition is unable to access the S3 object specified in the request.
* @throws InvalidParameterException
* Input parameter violated a constraint. Validate your parameter before calling the API operation again.
* @throws ImageTooLargeException
* The input image size exceeds the allowed limit. For more information, see <a>limits</a>.
* @throws AccessDeniedException
* You are not authorized to perform the action.
* @throws InternalServerErrorException
* Amazon Rekognition experienced a service issue. Try your call again.
* @throws ThrottlingException
* Amazon Rekognition is temporarily unable to process the request. Try your call again.
* @throws ProvisionedThroughputExceededException
* The number of requests exceeded your throughput limit. If you want to increase this limit, contact Amazon
* Rekognition.
* @throws ResourceNotFoundException
* Collection specified in the request is not found.
* @throws InvalidImageFormatException
* The provided image format is not supported.
* @sample AmazonRekognition.SearchFacesByImage
*/
@Override
public SearchFacesByImageResult searchFacesByImage(SearchFacesByImageRequest request) {
request = beforeClientExecution(request);
return executeSearchFacesByImage(request);
}
@SdkInternalApi
final SearchFacesByImageResult executeSearchFacesByImage(SearchFacesByImageRequest searchFacesByImageRequest) {
ExecutionContext executionContext = createExecutionContext(searchFacesByImageRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request<SearchFacesByImageRequest> request = null;
Response<SearchFacesByImageResult> response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new SearchFacesByImageRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(searchFacesByImageRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler<AmazonWebServiceResponse<SearchFacesByImageResult>> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new SearchFacesByImageResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
* Returns additional metadata for a previously executed successful, request, typically used for debugging issues
* where a service isn't acting as expected. This data isn't considered part of the result data returned by an
* operation, so it's available through this separate, diagnostic interface.
* <p>
* Response metadata is only cached for a limited period of time, so if you need to access this extra diagnostic
* information for an executed request, you should use this method to retrieve it as soon as possible after
* executing the request.
*
* @param request
* The originally executed request
*
* @return The response metadata for the specified request, or null if none is available.
*/
public ResponseMetadata getCachedResponseMetadata(AmazonWebServiceRequest request) {
return client.getResponseMetadataForRequest(request);
}
/**
* Normal invoke with authentication. Credentials are required and may be overriden at the request level.
**/
private <X, Y extends AmazonWebServiceRequest> Response<X> invoke(Request<Y> request, HttpResponseHandler<AmazonWebServiceResponse<X>> responseHandler,
ExecutionContext executionContext) {
executionContext.setCredentialsProvider(CredentialUtils.getCredentialsProvider(request.getOriginalRequest(), awsCredentialsProvider));
return doInvoke(request, responseHandler, executionContext);
}
/**
* Invoke with no authentication. Credentials are not required and any credentials set on the client or request will
* be ignored for this operation.
**/
private <X, Y extends AmazonWebServiceRequest> Response<X> anonymousInvoke(Request<Y> request,
HttpResponseHandler<AmazonWebServiceResponse<X>> responseHandler, ExecutionContext executionContext) {
return doInvoke(request, responseHandler, executionContext);
}
/**
* Invoke the request using the http client. Assumes credentials (or lack thereof) have been configured in the
* ExecutionContext beforehand.
**/
private <X, Y extends AmazonWebServiceRequest> Response<X> doInvoke(Request<Y> request, HttpResponseHandler<AmazonWebServiceResponse<X>> responseHandler,
ExecutionContext executionContext) {
request.setEndpoint(endpoint);
request.setTimeOffset(timeOffset);
HttpResponseHandler<AmazonServiceException> errorResponseHandler = protocolFactory.createErrorResponseHandler(new JsonErrorResponseMetadata());
return client.execute(request, responseHandler, errorResponseHandler, executionContext);
}
}