com.amazonaws.services.cognitoidp.AWSCognitoIdentityProviderAsyncClient Maven / Gradle / Ivy
Show all versions of aws-java-sdk-cognitoidp Show documentation
/*
* Copyright 2011-2016 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.cognitoidp;
import com.amazonaws.services.cognitoidp.model.*;
import com.amazonaws.client.AwsAsyncClientParams;
import com.amazonaws.annotation.ThreadSafe;
/**
* Interface for accessing Amazon Cognito Identity Provider asynchronously. Each asynchronous method will return a Java
* Future object representing the asynchronous operation; overloads which accept an {@code AsyncHandler} can be used to
* receive notification when an asynchronous operation completes.
*
*
* Using the Amazon Cognito Your User Pools API, you can create a user pool to manage directories and users. You can
* authenticate a user to obtain tokens related to user identity and access policies.
*
*
* This API reference provides information about user pools in Amazon Cognito Your User Pools.
*
*
* For more information, see the Amazon Cognito Documentation.
*
*/
@ThreadSafe
public class AWSCognitoIdentityProviderAsyncClient extends AWSCognitoIdentityProviderClient implements AWSCognitoIdentityProviderAsync {
private static final int DEFAULT_THREAD_POOL_SIZE = 50;
private final java.util.concurrent.ExecutorService executorService;
/**
* Constructs a new asynchronous client to invoke service methods on Amazon Cognito Identity Provider. A credentials
* provider chain will be used that searches for credentials in this order:
*
* - Environment Variables - AWS_ACCESS_KEY_ID and AWS_SECRET_KEY
* - Java System Properties - aws.accessKeyId and aws.secretKey
* - Credential profiles file at the default location (~/.aws/credentials) shared by all AWS SDKs and the AWS CLI
* - Instance profile credentials delivered through the Amazon EC2 metadata service
*
*
* Asynchronous methods are delegated to a fixed-size thread pool containing 50 threads (to match the default
* maximum number of concurrent connections to the service).
*
* @see com.amazonaws.auth.DefaultAWSCredentialsProviderChain
* @see java.util.concurrent.Executors#newFixedThreadPool(int)
*/
public AWSCognitoIdentityProviderAsyncClient() {
this(com.amazonaws.auth.DefaultAWSCredentialsProviderChain.getInstance());
}
/**
* Constructs a new asynchronous client to invoke service methods on Amazon Cognito Identity Provider. A credentials
* provider chain will be used that searches for credentials in this order:
*
* - Environment Variables - AWS_ACCESS_KEY_ID and AWS_SECRET_KEY
* - Java System Properties - aws.accessKeyId and aws.secretKey
* - Credential profiles file at the default location (~/.aws/credentials) shared by all AWS SDKs and the AWS CLI
* - Instance profile credentials delivered through the Amazon EC2 metadata service
*
*
* Asynchronous methods are delegated to a fixed-size thread pool containing a number of threads equal to the
* maximum number of concurrent connections configured via {@code ClientConfiguration.getMaxConnections()}.
*
* @param clientConfiguration
* The client configuration options controlling how this client connects to Amazon Cognito Identity Provider
* (ex: proxy settings, retry counts, etc).
*
* @see com.amazonaws.auth.DefaultAWSCredentialsProviderChain
* @see java.util.concurrent.Executors#newFixedThreadPool(int)
*/
public AWSCognitoIdentityProviderAsyncClient(com.amazonaws.ClientConfiguration clientConfiguration) {
this(com.amazonaws.auth.DefaultAWSCredentialsProviderChain.getInstance(), clientConfiguration, java.util.concurrent.Executors
.newFixedThreadPool(clientConfiguration.getMaxConnections()));
}
/**
* Constructs a new asynchronous client to invoke service methods on Amazon Cognito Identity Provider using the
* specified AWS account credentials.
*
* Asynchronous methods are delegated to a fixed-size thread pool containing 50 threads (to match the default
* maximum number of concurrent connections to the service).
*
* @param awsCredentials
* The AWS credentials (access key ID and secret key) to use when authenticating with AWS services.
* @see java.util.concurrent.Executors#newFixedThreadPool(int)
*/
public AWSCognitoIdentityProviderAsyncClient(com.amazonaws.auth.AWSCredentials awsCredentials) {
this(awsCredentials, java.util.concurrent.Executors.newFixedThreadPool(DEFAULT_THREAD_POOL_SIZE));
}
/**
* Constructs a new asynchronous client to invoke service methods on Amazon Cognito Identity Provider using the
* specified AWS account credentials and executor service. Default client settings will be used.
*
* @param awsCredentials
* The AWS credentials (access key ID and secret key) to use when authenticating with AWS services.
* @param executorService
* The executor service by which all asynchronous requests will be executed.
*/
public AWSCognitoIdentityProviderAsyncClient(com.amazonaws.auth.AWSCredentials awsCredentials, java.util.concurrent.ExecutorService executorService) {
this(awsCredentials, configFactory.getConfig(), executorService);
}
/**
* Constructs a new asynchronous client to invoke service methods on Amazon Cognito Identity Provider using the
* specified AWS account credentials, executor service, and client configuration options.
*
* @param awsCredentials
* The AWS credentials (access key ID and secret key) to use when authenticating with AWS services.
* @param clientConfiguration
* Client configuration options (ex: max retry limit, proxy settings, etc).
* @param executorService
* The executor service by which all asynchronous requests will be executed.
*/
public AWSCognitoIdentityProviderAsyncClient(com.amazonaws.auth.AWSCredentials awsCredentials, com.amazonaws.ClientConfiguration clientConfiguration,
java.util.concurrent.ExecutorService executorService) {
super(awsCredentials, clientConfiguration);
this.executorService = executorService;
}
/**
* Constructs a new asynchronous client to invoke service methods on Amazon Cognito Identity Provider using the
* specified AWS account credentials provider. Default client settings will be used.
*
* Asynchronous methods are delegated to a fixed-size thread pool containing 50 threads (to match the default
* maximum number of concurrent connections to the service).
*
* @param awsCredentialsProvider
* The AWS credentials provider which will provide credentials to authenticate requests with AWS services.
* @see java.util.concurrent.Executors#newFixedThreadPool(int)
*/
public AWSCognitoIdentityProviderAsyncClient(com.amazonaws.auth.AWSCredentialsProvider awsCredentialsProvider) {
this(awsCredentialsProvider, java.util.concurrent.Executors.newFixedThreadPool(DEFAULT_THREAD_POOL_SIZE));
}
/**
* Constructs a new asynchronous client to invoke service methods on Amazon Cognito Identity Provider using the
* provided AWS account credentials provider and client configuration options.
*
* Asynchronous methods are delegated to a fixed-size thread pool containing a number of threads equal to the
* maximum number of concurrent connections configured via {@code ClientConfiguration.getMaxConnections()}.
*
* @param awsCredentialsProvider
* The AWS credentials provider which will provide credentials to authenticate requests with AWS services.
* @param clientConfiguration
* Client configuration options (ex: max retry limit, proxy settings, etc).
*
* @see com.amazonaws.auth.DefaultAWSCredentialsProviderChain
* @see java.util.concurrent.Executors#newFixedThreadPool(int)
*/
public AWSCognitoIdentityProviderAsyncClient(com.amazonaws.auth.AWSCredentialsProvider awsCredentialsProvider,
com.amazonaws.ClientConfiguration clientConfiguration) {
this(awsCredentialsProvider, clientConfiguration, java.util.concurrent.Executors.newFixedThreadPool(clientConfiguration.getMaxConnections()));
}
/**
* Constructs a new asynchronous client to invoke service methods on Amazon Cognito Identity Provider using the
* specified AWS account credentials provider and executor service. Default client settings will be used.
*
* @param awsCredentialsProvider
* The AWS credentials provider which will provide credentials to authenticate requests with AWS services.
* @param executorService
* The executor service by which all asynchronous requests will be executed.
*/
public AWSCognitoIdentityProviderAsyncClient(com.amazonaws.auth.AWSCredentialsProvider awsCredentialsProvider,
java.util.concurrent.ExecutorService executorService) {
this(awsCredentialsProvider, configFactory.getConfig(), executorService);
}
/**
* Constructs a new asynchronous client to invoke service methods on Amazon Cognito Identity Provider using the
* specified AWS account credentials provider, executor service, and client configuration options.
*
* @param awsCredentialsProvider
* The AWS credentials provider which will provide credentials to authenticate requests with AWS services.
* @param clientConfiguration
* Client configuration options (ex: max retry limit, proxy settings, etc).
* @param executorService
* The executor service by which all asynchronous requests will be executed.
*/
public AWSCognitoIdentityProviderAsyncClient(com.amazonaws.auth.AWSCredentialsProvider awsCredentialsProvider,
com.amazonaws.ClientConfiguration clientConfiguration, java.util.concurrent.ExecutorService executorService) {
super(awsCredentialsProvider, clientConfiguration);
this.executorService = executorService;
}
/**
* Constructs a new asynchronous client to invoke service methods on Amazon Cognito Identity Provider using the
* specified parameters.
*
* @param asyncClientParams
* Object providing client parameters.
*/
AWSCognitoIdentityProviderAsyncClient(AwsAsyncClientParams asyncClientParams) {
super(asyncClientParams);
this.executorService = asyncClientParams.getExecutor();
}
/**
* Returns the executor service used by this client to execute async requests.
*
* @return The executor service used by this client to execute async requests.
*/
public java.util.concurrent.ExecutorService getExecutorService() {
return executorService;
}
@Override
public java.util.concurrent.Future addCustomAttributesAsync(AddCustomAttributesRequest request) {
return addCustomAttributesAsync(request, null);
}
@Override
public java.util.concurrent.Future addCustomAttributesAsync(final AddCustomAttributesRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public AddCustomAttributesResult call() throws Exception {
AddCustomAttributesResult result;
try {
result = addCustomAttributes(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future adminConfirmSignUpAsync(AdminConfirmSignUpRequest request) {
return adminConfirmSignUpAsync(request, null);
}
@Override
public java.util.concurrent.Future adminConfirmSignUpAsync(final AdminConfirmSignUpRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public AdminConfirmSignUpResult call() throws Exception {
AdminConfirmSignUpResult result;
try {
result = adminConfirmSignUp(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future adminCreateUserAsync(AdminCreateUserRequest request) {
return adminCreateUserAsync(request, null);
}
@Override
public java.util.concurrent.Future adminCreateUserAsync(final AdminCreateUserRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public AdminCreateUserResult call() throws Exception {
AdminCreateUserResult result;
try {
result = adminCreateUser(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future adminDeleteUserAsync(AdminDeleteUserRequest request) {
return adminDeleteUserAsync(request, null);
}
@Override
public java.util.concurrent.Future adminDeleteUserAsync(final AdminDeleteUserRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public AdminDeleteUserResult call() throws Exception {
AdminDeleteUserResult result;
try {
result = adminDeleteUser(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future adminDeleteUserAttributesAsync(AdminDeleteUserAttributesRequest request) {
return adminDeleteUserAttributesAsync(request, null);
}
@Override
public java.util.concurrent.Future adminDeleteUserAttributesAsync(final AdminDeleteUserAttributesRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public AdminDeleteUserAttributesResult call() throws Exception {
AdminDeleteUserAttributesResult result;
try {
result = adminDeleteUserAttributes(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future adminDisableUserAsync(AdminDisableUserRequest request) {
return adminDisableUserAsync(request, null);
}
@Override
public java.util.concurrent.Future adminDisableUserAsync(final AdminDisableUserRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public AdminDisableUserResult call() throws Exception {
AdminDisableUserResult result;
try {
result = adminDisableUser(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future adminEnableUserAsync(AdminEnableUserRequest request) {
return adminEnableUserAsync(request, null);
}
@Override
public java.util.concurrent.Future adminEnableUserAsync(final AdminEnableUserRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public AdminEnableUserResult call() throws Exception {
AdminEnableUserResult result;
try {
result = adminEnableUser(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future adminForgetDeviceAsync(AdminForgetDeviceRequest request) {
return adminForgetDeviceAsync(request, null);
}
@Override
public java.util.concurrent.Future adminForgetDeviceAsync(final AdminForgetDeviceRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public AdminForgetDeviceResult call() throws Exception {
AdminForgetDeviceResult result;
try {
result = adminForgetDevice(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future adminGetDeviceAsync(AdminGetDeviceRequest request) {
return adminGetDeviceAsync(request, null);
}
@Override
public java.util.concurrent.Future adminGetDeviceAsync(final AdminGetDeviceRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public AdminGetDeviceResult call() throws Exception {
AdminGetDeviceResult result;
try {
result = adminGetDevice(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future adminGetUserAsync(AdminGetUserRequest request) {
return adminGetUserAsync(request, null);
}
@Override
public java.util.concurrent.Future adminGetUserAsync(final AdminGetUserRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public AdminGetUserResult call() throws Exception {
AdminGetUserResult result;
try {
result = adminGetUser(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future adminInitiateAuthAsync(AdminInitiateAuthRequest request) {
return adminInitiateAuthAsync(request, null);
}
@Override
public java.util.concurrent.Future adminInitiateAuthAsync(final AdminInitiateAuthRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public AdminInitiateAuthResult call() throws Exception {
AdminInitiateAuthResult result;
try {
result = adminInitiateAuth(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future adminListDevicesAsync(AdminListDevicesRequest request) {
return adminListDevicesAsync(request, null);
}
@Override
public java.util.concurrent.Future adminListDevicesAsync(final AdminListDevicesRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public AdminListDevicesResult call() throws Exception {
AdminListDevicesResult result;
try {
result = adminListDevices(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future adminResetUserPasswordAsync(AdminResetUserPasswordRequest request) {
return adminResetUserPasswordAsync(request, null);
}
@Override
public java.util.concurrent.Future adminResetUserPasswordAsync(final AdminResetUserPasswordRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public AdminResetUserPasswordResult call() throws Exception {
AdminResetUserPasswordResult result;
try {
result = adminResetUserPassword(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future adminRespondToAuthChallengeAsync(AdminRespondToAuthChallengeRequest request) {
return adminRespondToAuthChallengeAsync(request, null);
}
@Override
public java.util.concurrent.Future adminRespondToAuthChallengeAsync(final AdminRespondToAuthChallengeRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public AdminRespondToAuthChallengeResult call() throws Exception {
AdminRespondToAuthChallengeResult result;
try {
result = adminRespondToAuthChallenge(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future adminSetUserSettingsAsync(AdminSetUserSettingsRequest request) {
return adminSetUserSettingsAsync(request, null);
}
@Override
public java.util.concurrent.Future adminSetUserSettingsAsync(final AdminSetUserSettingsRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public AdminSetUserSettingsResult call() throws Exception {
AdminSetUserSettingsResult result;
try {
result = adminSetUserSettings(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future adminUpdateDeviceStatusAsync(AdminUpdateDeviceStatusRequest request) {
return adminUpdateDeviceStatusAsync(request, null);
}
@Override
public java.util.concurrent.Future adminUpdateDeviceStatusAsync(final AdminUpdateDeviceStatusRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public AdminUpdateDeviceStatusResult call() throws Exception {
AdminUpdateDeviceStatusResult result;
try {
result = adminUpdateDeviceStatus(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future adminUpdateUserAttributesAsync(AdminUpdateUserAttributesRequest request) {
return adminUpdateUserAttributesAsync(request, null);
}
@Override
public java.util.concurrent.Future adminUpdateUserAttributesAsync(final AdminUpdateUserAttributesRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public AdminUpdateUserAttributesResult call() throws Exception {
AdminUpdateUserAttributesResult result;
try {
result = adminUpdateUserAttributes(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future adminUserGlobalSignOutAsync(AdminUserGlobalSignOutRequest request) {
return adminUserGlobalSignOutAsync(request, null);
}
@Override
public java.util.concurrent.Future adminUserGlobalSignOutAsync(final AdminUserGlobalSignOutRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public AdminUserGlobalSignOutResult call() throws Exception {
AdminUserGlobalSignOutResult result;
try {
result = adminUserGlobalSignOut(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future changePasswordAsync(ChangePasswordRequest request) {
return changePasswordAsync(request, null);
}
@Override
public java.util.concurrent.Future changePasswordAsync(final ChangePasswordRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public ChangePasswordResult call() throws Exception {
ChangePasswordResult result;
try {
result = changePassword(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future confirmDeviceAsync(ConfirmDeviceRequest request) {
return confirmDeviceAsync(request, null);
}
@Override
public java.util.concurrent.Future confirmDeviceAsync(final ConfirmDeviceRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public ConfirmDeviceResult call() throws Exception {
ConfirmDeviceResult result;
try {
result = confirmDevice(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future confirmForgotPasswordAsync(ConfirmForgotPasswordRequest request) {
return confirmForgotPasswordAsync(request, null);
}
@Override
public java.util.concurrent.Future confirmForgotPasswordAsync(final ConfirmForgotPasswordRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public ConfirmForgotPasswordResult call() throws Exception {
ConfirmForgotPasswordResult result;
try {
result = confirmForgotPassword(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future confirmSignUpAsync(ConfirmSignUpRequest request) {
return confirmSignUpAsync(request, null);
}
@Override
public java.util.concurrent.Future confirmSignUpAsync(final ConfirmSignUpRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public ConfirmSignUpResult call() throws Exception {
ConfirmSignUpResult result;
try {
result = confirmSignUp(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future createUserImportJobAsync(CreateUserImportJobRequest request) {
return createUserImportJobAsync(request, null);
}
@Override
public java.util.concurrent.Future createUserImportJobAsync(final CreateUserImportJobRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public CreateUserImportJobResult call() throws Exception {
CreateUserImportJobResult result;
try {
result = createUserImportJob(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future createUserPoolAsync(CreateUserPoolRequest request) {
return createUserPoolAsync(request, null);
}
@Override
public java.util.concurrent.Future createUserPoolAsync(final CreateUserPoolRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public CreateUserPoolResult call() throws Exception {
CreateUserPoolResult result;
try {
result = createUserPool(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future createUserPoolClientAsync(CreateUserPoolClientRequest request) {
return createUserPoolClientAsync(request, null);
}
@Override
public java.util.concurrent.Future createUserPoolClientAsync(final CreateUserPoolClientRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public CreateUserPoolClientResult call() throws Exception {
CreateUserPoolClientResult result;
try {
result = createUserPoolClient(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future deleteUserAsync(DeleteUserRequest request) {
return deleteUserAsync(request, null);
}
@Override
public java.util.concurrent.Future deleteUserAsync(final DeleteUserRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DeleteUserResult call() throws Exception {
DeleteUserResult result;
try {
result = deleteUser(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future deleteUserAttributesAsync(DeleteUserAttributesRequest request) {
return deleteUserAttributesAsync(request, null);
}
@Override
public java.util.concurrent.Future deleteUserAttributesAsync(final DeleteUserAttributesRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DeleteUserAttributesResult call() throws Exception {
DeleteUserAttributesResult result;
try {
result = deleteUserAttributes(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future deleteUserPoolAsync(DeleteUserPoolRequest request) {
return deleteUserPoolAsync(request, null);
}
@Override
public java.util.concurrent.Future deleteUserPoolAsync(final DeleteUserPoolRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DeleteUserPoolResult call() throws Exception {
DeleteUserPoolResult result;
try {
result = deleteUserPool(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future deleteUserPoolClientAsync(DeleteUserPoolClientRequest request) {
return deleteUserPoolClientAsync(request, null);
}
@Override
public java.util.concurrent.Future deleteUserPoolClientAsync(final DeleteUserPoolClientRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DeleteUserPoolClientResult call() throws Exception {
DeleteUserPoolClientResult result;
try {
result = deleteUserPoolClient(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future describeUserImportJobAsync(DescribeUserImportJobRequest request) {
return describeUserImportJobAsync(request, null);
}
@Override
public java.util.concurrent.Future describeUserImportJobAsync(final DescribeUserImportJobRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DescribeUserImportJobResult call() throws Exception {
DescribeUserImportJobResult result;
try {
result = describeUserImportJob(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future describeUserPoolAsync(DescribeUserPoolRequest request) {
return describeUserPoolAsync(request, null);
}
@Override
public java.util.concurrent.Future describeUserPoolAsync(final DescribeUserPoolRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DescribeUserPoolResult call() throws Exception {
DescribeUserPoolResult result;
try {
result = describeUserPool(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future describeUserPoolClientAsync(DescribeUserPoolClientRequest request) {
return describeUserPoolClientAsync(request, null);
}
@Override
public java.util.concurrent.Future describeUserPoolClientAsync(final DescribeUserPoolClientRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DescribeUserPoolClientResult call() throws Exception {
DescribeUserPoolClientResult result;
try {
result = describeUserPoolClient(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future forgetDeviceAsync(ForgetDeviceRequest request) {
return forgetDeviceAsync(request, null);
}
@Override
public java.util.concurrent.Future forgetDeviceAsync(final ForgetDeviceRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public ForgetDeviceResult call() throws Exception {
ForgetDeviceResult result;
try {
result = forgetDevice(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future forgotPasswordAsync(ForgotPasswordRequest request) {
return forgotPasswordAsync(request, null);
}
@Override
public java.util.concurrent.Future forgotPasswordAsync(final ForgotPasswordRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public ForgotPasswordResult call() throws Exception {
ForgotPasswordResult result;
try {
result = forgotPassword(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future getCSVHeaderAsync(GetCSVHeaderRequest request) {
return getCSVHeaderAsync(request, null);
}
@Override
public java.util.concurrent.Future getCSVHeaderAsync(final GetCSVHeaderRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public GetCSVHeaderResult call() throws Exception {
GetCSVHeaderResult result;
try {
result = getCSVHeader(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future getDeviceAsync(GetDeviceRequest request) {
return getDeviceAsync(request, null);
}
@Override
public java.util.concurrent.Future getDeviceAsync(final GetDeviceRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public GetDeviceResult call() throws Exception {
GetDeviceResult result;
try {
result = getDevice(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future getUserAsync(GetUserRequest request) {
return getUserAsync(request, null);
}
@Override
public java.util.concurrent.Future getUserAsync(final GetUserRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public GetUserResult call() throws Exception {
GetUserResult result;
try {
result = getUser(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future getUserAttributeVerificationCodeAsync(
GetUserAttributeVerificationCodeRequest request) {
return getUserAttributeVerificationCodeAsync(request, null);
}
@Override
public java.util.concurrent.Future getUserAttributeVerificationCodeAsync(
final GetUserAttributeVerificationCodeRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public GetUserAttributeVerificationCodeResult call() throws Exception {
GetUserAttributeVerificationCodeResult result;
try {
result = getUserAttributeVerificationCode(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future globalSignOutAsync(GlobalSignOutRequest request) {
return globalSignOutAsync(request, null);
}
@Override
public java.util.concurrent.Future globalSignOutAsync(final GlobalSignOutRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public GlobalSignOutResult call() throws Exception {
GlobalSignOutResult result;
try {
result = globalSignOut(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future initiateAuthAsync(InitiateAuthRequest request) {
return initiateAuthAsync(request, null);
}
@Override
public java.util.concurrent.Future initiateAuthAsync(final InitiateAuthRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public InitiateAuthResult call() throws Exception {
InitiateAuthResult result;
try {
result = initiateAuth(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future listDevicesAsync(ListDevicesRequest request) {
return listDevicesAsync(request, null);
}
@Override
public java.util.concurrent.Future listDevicesAsync(final ListDevicesRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public ListDevicesResult call() throws Exception {
ListDevicesResult result;
try {
result = listDevices(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future listUserImportJobsAsync(ListUserImportJobsRequest request) {
return listUserImportJobsAsync(request, null);
}
@Override
public java.util.concurrent.Future listUserImportJobsAsync(final ListUserImportJobsRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public ListUserImportJobsResult call() throws Exception {
ListUserImportJobsResult result;
try {
result = listUserImportJobs(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future listUserPoolClientsAsync(ListUserPoolClientsRequest request) {
return listUserPoolClientsAsync(request, null);
}
@Override
public java.util.concurrent.Future listUserPoolClientsAsync(final ListUserPoolClientsRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public ListUserPoolClientsResult call() throws Exception {
ListUserPoolClientsResult result;
try {
result = listUserPoolClients(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future listUserPoolsAsync(ListUserPoolsRequest request) {
return listUserPoolsAsync(request, null);
}
@Override
public java.util.concurrent.Future listUserPoolsAsync(final ListUserPoolsRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public ListUserPoolsResult call() throws Exception {
ListUserPoolsResult result;
try {
result = listUserPools(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future listUsersAsync(ListUsersRequest request) {
return listUsersAsync(request, null);
}
@Override
public java.util.concurrent.Future listUsersAsync(final ListUsersRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public ListUsersResult call() throws Exception {
ListUsersResult result;
try {
result = listUsers(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future resendConfirmationCodeAsync(ResendConfirmationCodeRequest request) {
return resendConfirmationCodeAsync(request, null);
}
@Override
public java.util.concurrent.Future resendConfirmationCodeAsync(final ResendConfirmationCodeRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public ResendConfirmationCodeResult call() throws Exception {
ResendConfirmationCodeResult result;
try {
result = resendConfirmationCode(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future respondToAuthChallengeAsync(RespondToAuthChallengeRequest request) {
return respondToAuthChallengeAsync(request, null);
}
@Override
public java.util.concurrent.Future respondToAuthChallengeAsync(final RespondToAuthChallengeRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public RespondToAuthChallengeResult call() throws Exception {
RespondToAuthChallengeResult result;
try {
result = respondToAuthChallenge(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future setUserSettingsAsync(SetUserSettingsRequest request) {
return setUserSettingsAsync(request, null);
}
@Override
public java.util.concurrent.Future setUserSettingsAsync(final SetUserSettingsRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public SetUserSettingsResult call() throws Exception {
SetUserSettingsResult result;
try {
result = setUserSettings(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future signUpAsync(SignUpRequest request) {
return signUpAsync(request, null);
}
@Override
public java.util.concurrent.Future signUpAsync(final SignUpRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public SignUpResult call() throws Exception {
SignUpResult result;
try {
result = signUp(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future startUserImportJobAsync(StartUserImportJobRequest request) {
return startUserImportJobAsync(request, null);
}
@Override
public java.util.concurrent.Future startUserImportJobAsync(final StartUserImportJobRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public StartUserImportJobResult call() throws Exception {
StartUserImportJobResult result;
try {
result = startUserImportJob(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future stopUserImportJobAsync(StopUserImportJobRequest request) {
return stopUserImportJobAsync(request, null);
}
@Override
public java.util.concurrent.Future stopUserImportJobAsync(final StopUserImportJobRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public StopUserImportJobResult call() throws Exception {
StopUserImportJobResult result;
try {
result = stopUserImportJob(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future updateDeviceStatusAsync(UpdateDeviceStatusRequest request) {
return updateDeviceStatusAsync(request, null);
}
@Override
public java.util.concurrent.Future updateDeviceStatusAsync(final UpdateDeviceStatusRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public UpdateDeviceStatusResult call() throws Exception {
UpdateDeviceStatusResult result;
try {
result = updateDeviceStatus(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future updateUserAttributesAsync(UpdateUserAttributesRequest request) {
return updateUserAttributesAsync(request, null);
}
@Override
public java.util.concurrent.Future updateUserAttributesAsync(final UpdateUserAttributesRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public UpdateUserAttributesResult call() throws Exception {
UpdateUserAttributesResult result;
try {
result = updateUserAttributes(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future updateUserPoolAsync(UpdateUserPoolRequest request) {
return updateUserPoolAsync(request, null);
}
@Override
public java.util.concurrent.Future updateUserPoolAsync(final UpdateUserPoolRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public UpdateUserPoolResult call() throws Exception {
UpdateUserPoolResult result;
try {
result = updateUserPool(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future updateUserPoolClientAsync(UpdateUserPoolClientRequest request) {
return updateUserPoolClientAsync(request, null);
}
@Override
public java.util.concurrent.Future updateUserPoolClientAsync(final UpdateUserPoolClientRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public UpdateUserPoolClientResult call() throws Exception {
UpdateUserPoolClientResult result;
try {
result = updateUserPoolClient(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future verifyUserAttributeAsync(VerifyUserAttributeRequest request) {
return verifyUserAttributeAsync(request, null);
}
@Override
public java.util.concurrent.Future verifyUserAttributeAsync(final VerifyUserAttributeRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public VerifyUserAttributeResult call() throws Exception {
VerifyUserAttributeResult result;
try {
result = verifyUserAttribute(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
/**
* Shuts down the client, releasing all managed resources. This includes forcibly terminating all pending
* asynchronous service calls. Clients who wish to give pending asynchronous service calls time to complete should
* call {@code getExecutorService().shutdown()} followed by {@code getExecutorService().awaitTermination()} prior to
* calling this method.
*/
@Override
public void shutdown() {
super.shutdown();
executorService.shutdownNow();
}
}