• Home
• com.amazonaws
• aws-java-sdk-alexaforbusiness
• 1.11.474
• source code
• AmazonAlexaForBusinessAsyncClient.java

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

com.amazonaws.services.alexaforbusiness.AmazonAlexaForBusinessAsyncClient Maven / Gradle / Ivy

/*
 * Copyright 2013-2018 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.alexaforbusiness;

import javax.annotation.Generated;

import com.amazonaws.services.alexaforbusiness.model.*;
import com.amazonaws.client.AwsAsyncClientParams;
import com.amazonaws.annotation.ThreadSafe;

import java.util.concurrent.ExecutorService;

/**
 * Client for accessing Alexa For Business 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.
 * 

 * 

 * Alexa for Business helps you use Alexa in your organization. Alexa for Business provides you with the tools to manage
 * Alexa devices, enroll your users, and assign skills, at scale. You can build your own context-aware voice skills
 * using the Alexa Skills Kit and the Alexa for Business API operations. You can also make these available as private
 * skills for your organization. Alexa for Business makes it efficient to voice-enable your products and services, thus
 * providing context-aware voice experiences for your customers. Device makers building with the Alexa Voice Service
 * (AVS) can create fully integrated solutions, register their products with Alexa for Business, and manage them as
 * shared devices in their organization.
 * 
 */
@ThreadSafe
@Generated("com.amazonaws:aws-java-sdk-code-generator")
public class AmazonAlexaForBusinessAsyncClient extends AmazonAlexaForBusinessClient implements AmazonAlexaForBusinessAsync {

    private static final int DEFAULT_THREAD_POOL_SIZE = 50;

    private final java.util.concurrent.ExecutorService executorService;

    public static AmazonAlexaForBusinessAsyncClientBuilder asyncBuilder() {
        return AmazonAlexaForBusinessAsyncClientBuilder.standard();
    }

    /**
     * Constructs a new asynchronous client to invoke service methods on Alexa For Business using the specified
     * parameters.
     *
     * @param asyncClientParams
     *        Object providing client parameters.
     */
    AmazonAlexaForBusinessAsyncClient(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 ExecutorService getExecutorService() {
        return executorService;
    }

    @Override
    public java.util.concurrent.Future approveSkillAsync(ApproveSkillRequest request) {

        return approveSkillAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future approveSkillAsync(final ApproveSkillRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final ApproveSkillRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public ApproveSkillResult call() throws Exception {
                ApproveSkillResult result = null;

                try {
                    result = executeApproveSkill(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future associateContactWithAddressBookAsync(
            AssociateContactWithAddressBookRequest request) {

        return associateContactWithAddressBookAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future associateContactWithAddressBookAsync(
            final AssociateContactWithAddressBookRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final AssociateContactWithAddressBookRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public AssociateContactWithAddressBookResult call() throws Exception {
                AssociateContactWithAddressBookResult result = null;

                try {
                    result = executeAssociateContactWithAddressBook(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future associateDeviceWithRoomAsync(AssociateDeviceWithRoomRequest request) {

        return associateDeviceWithRoomAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future associateDeviceWithRoomAsync(final AssociateDeviceWithRoomRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final AssociateDeviceWithRoomRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public AssociateDeviceWithRoomResult call() throws Exception {
                AssociateDeviceWithRoomResult result = null;

                try {
                    result = executeAssociateDeviceWithRoom(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future associateSkillGroupWithRoomAsync(AssociateSkillGroupWithRoomRequest request) {

        return associateSkillGroupWithRoomAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future associateSkillGroupWithRoomAsync(final AssociateSkillGroupWithRoomRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final AssociateSkillGroupWithRoomRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public AssociateSkillGroupWithRoomResult call() throws Exception {
                AssociateSkillGroupWithRoomResult result = null;

                try {
                    result = executeAssociateSkillGroupWithRoom(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future associateSkillWithSkillGroupAsync(AssociateSkillWithSkillGroupRequest request) {

        return associateSkillWithSkillGroupAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future associateSkillWithSkillGroupAsync(final AssociateSkillWithSkillGroupRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final AssociateSkillWithSkillGroupRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public AssociateSkillWithSkillGroupResult call() throws Exception {
                AssociateSkillWithSkillGroupResult result = null;

                try {
                    result = executeAssociateSkillWithSkillGroup(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future associateSkillWithUsersAsync(AssociateSkillWithUsersRequest request) {

        return associateSkillWithUsersAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future associateSkillWithUsersAsync(final AssociateSkillWithUsersRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final AssociateSkillWithUsersRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public AssociateSkillWithUsersResult call() throws Exception {
                AssociateSkillWithUsersResult result = null;

                try {
                    result = executeAssociateSkillWithUsers(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future createAddressBookAsync(CreateAddressBookRequest request) {

        return createAddressBookAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future createAddressBookAsync(final CreateAddressBookRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final CreateAddressBookRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public CreateAddressBookResult call() throws Exception {
                CreateAddressBookResult result = null;

                try {
                    result = executeCreateAddressBook(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future createBusinessReportScheduleAsync(CreateBusinessReportScheduleRequest request) {

        return createBusinessReportScheduleAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future createBusinessReportScheduleAsync(final CreateBusinessReportScheduleRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final CreateBusinessReportScheduleRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public CreateBusinessReportScheduleResult call() throws Exception {
                CreateBusinessReportScheduleResult result = null;

                try {
                    result = executeCreateBusinessReportSchedule(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future createConferenceProviderAsync(CreateConferenceProviderRequest request) {

        return createConferenceProviderAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future createConferenceProviderAsync(final CreateConferenceProviderRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final CreateConferenceProviderRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public CreateConferenceProviderResult call() throws Exception {
                CreateConferenceProviderResult result = null;

                try {
                    result = executeCreateConferenceProvider(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future createContactAsync(CreateContactRequest request) {

        return createContactAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future createContactAsync(final CreateContactRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final CreateContactRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public CreateContactResult call() throws Exception {
                CreateContactResult result = null;

                try {
                    result = executeCreateContact(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future createProfileAsync(CreateProfileRequest request) {

        return createProfileAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future createProfileAsync(final CreateProfileRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final CreateProfileRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public CreateProfileResult call() throws Exception {
                CreateProfileResult result = null;

                try {
                    result = executeCreateProfile(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future createRoomAsync(CreateRoomRequest request) {

        return createRoomAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future createRoomAsync(final CreateRoomRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final CreateRoomRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public CreateRoomResult call() throws Exception {
                CreateRoomResult result = null;

                try {
                    result = executeCreateRoom(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future createSkillGroupAsync(CreateSkillGroupRequest request) {

        return createSkillGroupAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future createSkillGroupAsync(final CreateSkillGroupRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final CreateSkillGroupRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public CreateSkillGroupResult call() throws Exception {
                CreateSkillGroupResult result = null;

                try {
                    result = executeCreateSkillGroup(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future createUserAsync(CreateUserRequest request) {

        return createUserAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future createUserAsync(final CreateUserRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final CreateUserRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public CreateUserResult call() throws Exception {
                CreateUserResult result = null;

                try {
                    result = executeCreateUser(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future deleteAddressBookAsync(DeleteAddressBookRequest request) {

        return deleteAddressBookAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future deleteAddressBookAsync(final DeleteAddressBookRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DeleteAddressBookRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DeleteAddressBookResult call() throws Exception {
                DeleteAddressBookResult result = null;

                try {
                    result = executeDeleteAddressBook(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future deleteBusinessReportScheduleAsync(DeleteBusinessReportScheduleRequest request) {

        return deleteBusinessReportScheduleAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future deleteBusinessReportScheduleAsync(final DeleteBusinessReportScheduleRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DeleteBusinessReportScheduleRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DeleteBusinessReportScheduleResult call() throws Exception {
                DeleteBusinessReportScheduleResult result = null;

                try {
                    result = executeDeleteBusinessReportSchedule(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future deleteConferenceProviderAsync(DeleteConferenceProviderRequest request) {

        return deleteConferenceProviderAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future deleteConferenceProviderAsync(final DeleteConferenceProviderRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DeleteConferenceProviderRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DeleteConferenceProviderResult call() throws Exception {
                DeleteConferenceProviderResult result = null;

                try {
                    result = executeDeleteConferenceProvider(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future deleteContactAsync(DeleteContactRequest request) {

        return deleteContactAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future deleteContactAsync(final DeleteContactRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DeleteContactRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DeleteContactResult call() throws Exception {
                DeleteContactResult result = null;

                try {
                    result = executeDeleteContact(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future deleteDeviceAsync(DeleteDeviceRequest request) {

        return deleteDeviceAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future deleteDeviceAsync(final DeleteDeviceRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DeleteDeviceRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DeleteDeviceResult call() throws Exception {
                DeleteDeviceResult result = null;

                try {
                    result = executeDeleteDevice(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future deleteProfileAsync(DeleteProfileRequest request) {

        return deleteProfileAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future deleteProfileAsync(final DeleteProfileRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DeleteProfileRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DeleteProfileResult call() throws Exception {
                DeleteProfileResult result = null;

                try {
                    result = executeDeleteProfile(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future deleteRoomAsync(DeleteRoomRequest request) {

        return deleteRoomAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future deleteRoomAsync(final DeleteRoomRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DeleteRoomRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DeleteRoomResult call() throws Exception {
                DeleteRoomResult result = null;

                try {
                    result = executeDeleteRoom(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future deleteRoomSkillParameterAsync(DeleteRoomSkillParameterRequest request) {

        return deleteRoomSkillParameterAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future deleteRoomSkillParameterAsync(final DeleteRoomSkillParameterRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DeleteRoomSkillParameterRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DeleteRoomSkillParameterResult call() throws Exception {
                DeleteRoomSkillParameterResult result = null;

                try {
                    result = executeDeleteRoomSkillParameter(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future deleteSkillAuthorizationAsync(DeleteSkillAuthorizationRequest request) {

        return deleteSkillAuthorizationAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future deleteSkillAuthorizationAsync(final DeleteSkillAuthorizationRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DeleteSkillAuthorizationRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DeleteSkillAuthorizationResult call() throws Exception {
                DeleteSkillAuthorizationResult result = null;

                try {
                    result = executeDeleteSkillAuthorization(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future deleteSkillGroupAsync(DeleteSkillGroupRequest request) {

        return deleteSkillGroupAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future deleteSkillGroupAsync(final DeleteSkillGroupRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DeleteSkillGroupRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DeleteSkillGroupResult call() throws Exception {
                DeleteSkillGroupResult result = null;

                try {
                    result = executeDeleteSkillGroup(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, 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) {
        final DeleteUserRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DeleteUserResult call() throws Exception {
                DeleteUserResult result = null;

                try {
                    result = executeDeleteUser(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future disassociateContactFromAddressBookAsync(
            DisassociateContactFromAddressBookRequest request) {

        return disassociateContactFromAddressBookAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future disassociateContactFromAddressBookAsync(
            final DisassociateContactFromAddressBookRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DisassociateContactFromAddressBookRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DisassociateContactFromAddressBookResult call() throws Exception {
                DisassociateContactFromAddressBookResult result = null;

                try {
                    result = executeDisassociateContactFromAddressBook(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future disassociateDeviceFromRoomAsync(DisassociateDeviceFromRoomRequest request) {

        return disassociateDeviceFromRoomAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future disassociateDeviceFromRoomAsync(final DisassociateDeviceFromRoomRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DisassociateDeviceFromRoomRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DisassociateDeviceFromRoomResult call() throws Exception {
                DisassociateDeviceFromRoomResult result = null;

                try {
                    result = executeDisassociateDeviceFromRoom(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future disassociateSkillFromSkillGroupAsync(
            DisassociateSkillFromSkillGroupRequest request) {

        return disassociateSkillFromSkillGroupAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future disassociateSkillFromSkillGroupAsync(
            final DisassociateSkillFromSkillGroupRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DisassociateSkillFromSkillGroupRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DisassociateSkillFromSkillGroupResult call() throws Exception {
                DisassociateSkillFromSkillGroupResult result = null;

                try {
                    result = executeDisassociateSkillFromSkillGroup(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future disassociateSkillFromUsersAsync(DisassociateSkillFromUsersRequest request) {

        return disassociateSkillFromUsersAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future disassociateSkillFromUsersAsync(final DisassociateSkillFromUsersRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DisassociateSkillFromUsersRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DisassociateSkillFromUsersResult call() throws Exception {
                DisassociateSkillFromUsersResult result = null;

                try {
                    result = executeDisassociateSkillFromUsers(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future disassociateSkillGroupFromRoomAsync(DisassociateSkillGroupFromRoomRequest request) {

        return disassociateSkillGroupFromRoomAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future disassociateSkillGroupFromRoomAsync(
            final DisassociateSkillGroupFromRoomRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DisassociateSkillGroupFromRoomRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DisassociateSkillGroupFromRoomResult call() throws Exception {
                DisassociateSkillGroupFromRoomResult result = null;

                try {
                    result = executeDisassociateSkillGroupFromRoom(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future forgetSmartHomeAppliancesAsync(ForgetSmartHomeAppliancesRequest request) {

        return forgetSmartHomeAppliancesAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future forgetSmartHomeAppliancesAsync(final ForgetSmartHomeAppliancesRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final ForgetSmartHomeAppliancesRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public ForgetSmartHomeAppliancesResult call() throws Exception {
                ForgetSmartHomeAppliancesResult result = null;

                try {
                    result = executeForgetSmartHomeAppliances(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future getAddressBookAsync(GetAddressBookRequest request) {

        return getAddressBookAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future getAddressBookAsync(final GetAddressBookRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final GetAddressBookRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public GetAddressBookResult call() throws Exception {
                GetAddressBookResult result = null;

                try {
                    result = executeGetAddressBook(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future getConferencePreferenceAsync(GetConferencePreferenceRequest request) {

        return getConferencePreferenceAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future getConferencePreferenceAsync(final GetConferencePreferenceRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final GetConferencePreferenceRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public GetConferencePreferenceResult call() throws Exception {
                GetConferencePreferenceResult result = null;

                try {
                    result = executeGetConferencePreference(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future getConferenceProviderAsync(GetConferenceProviderRequest request) {

        return getConferenceProviderAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future getConferenceProviderAsync(final GetConferenceProviderRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final GetConferenceProviderRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public GetConferenceProviderResult call() throws Exception {
                GetConferenceProviderResult result = null;

                try {
                    result = executeGetConferenceProvider(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future getContactAsync(GetContactRequest request) {

        return getContactAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future getContactAsync(final GetContactRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final GetContactRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public GetContactResult call() throws Exception {
                GetContactResult result = null;

                try {
                    result = executeGetContact(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, 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) {
        final GetDeviceRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public GetDeviceResult call() throws Exception {
                GetDeviceResult result = null;

                try {
                    result = executeGetDevice(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future getProfileAsync(GetProfileRequest request) {

        return getProfileAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future getProfileAsync(final GetProfileRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final GetProfileRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public GetProfileResult call() throws Exception {
                GetProfileResult result = null;

                try {
                    result = executeGetProfile(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future getRoomAsync(GetRoomRequest request) {

        return getRoomAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future getRoomAsync(final GetRoomRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final GetRoomRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public GetRoomResult call() throws Exception {
                GetRoomResult result = null;

                try {
                    result = executeGetRoom(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future getRoomSkillParameterAsync(GetRoomSkillParameterRequest request) {

        return getRoomSkillParameterAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future getRoomSkillParameterAsync(final GetRoomSkillParameterRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final GetRoomSkillParameterRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public GetRoomSkillParameterResult call() throws Exception {
                GetRoomSkillParameterResult result = null;

                try {
                    result = executeGetRoomSkillParameter(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future getSkillGroupAsync(GetSkillGroupRequest request) {

        return getSkillGroupAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future getSkillGroupAsync(final GetSkillGroupRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final GetSkillGroupRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public GetSkillGroupResult call() throws Exception {
                GetSkillGroupResult result = null;

                try {
                    result = executeGetSkillGroup(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future listBusinessReportSchedulesAsync(ListBusinessReportSchedulesRequest request) {

        return listBusinessReportSchedulesAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future listBusinessReportSchedulesAsync(final ListBusinessReportSchedulesRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final ListBusinessReportSchedulesRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public ListBusinessReportSchedulesResult call() throws Exception {
                ListBusinessReportSchedulesResult result = null;

                try {
                    result = executeListBusinessReportSchedules(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future listConferenceProvidersAsync(ListConferenceProvidersRequest request) {

        return listConferenceProvidersAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future listConferenceProvidersAsync(final ListConferenceProvidersRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final ListConferenceProvidersRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public ListConferenceProvidersResult call() throws Exception {
                ListConferenceProvidersResult result = null;

                try {
                    result = executeListConferenceProviders(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future listDeviceEventsAsync(ListDeviceEventsRequest request) {

        return listDeviceEventsAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future listDeviceEventsAsync(final ListDeviceEventsRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final ListDeviceEventsRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public ListDeviceEventsResult call() throws Exception {
                ListDeviceEventsResult result = null;

                try {
                    result = executeListDeviceEvents(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future listSkillsAsync(ListSkillsRequest request) {

        return listSkillsAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future listSkillsAsync(final ListSkillsRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final ListSkillsRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public ListSkillsResult call() throws Exception {
                ListSkillsResult result = null;

                try {
                    result = executeListSkills(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future listSkillsStoreCategoriesAsync(ListSkillsStoreCategoriesRequest request) {

        return listSkillsStoreCategoriesAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future listSkillsStoreCategoriesAsync(final ListSkillsStoreCategoriesRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final ListSkillsStoreCategoriesRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public ListSkillsStoreCategoriesResult call() throws Exception {
                ListSkillsStoreCategoriesResult result = null;

                try {
                    result = executeListSkillsStoreCategories(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future listSkillsStoreSkillsByCategoryAsync(
            ListSkillsStoreSkillsByCategoryRequest request) {

        return listSkillsStoreSkillsByCategoryAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future listSkillsStoreSkillsByCategoryAsync(
            final ListSkillsStoreSkillsByCategoryRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final ListSkillsStoreSkillsByCategoryRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public ListSkillsStoreSkillsByCategoryResult call() throws Exception {
                ListSkillsStoreSkillsByCategoryResult result = null;

                try {
                    result = executeListSkillsStoreSkillsByCategory(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future listSmartHomeAppliancesAsync(ListSmartHomeAppliancesRequest request) {

        return listSmartHomeAppliancesAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future listSmartHomeAppliancesAsync(final ListSmartHomeAppliancesRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final ListSmartHomeAppliancesRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public ListSmartHomeAppliancesResult call() throws Exception {
                ListSmartHomeAppliancesResult result = null;

                try {
                    result = executeListSmartHomeAppliances(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future listTagsAsync(ListTagsRequest request) {

        return listTagsAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future listTagsAsync(final ListTagsRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final ListTagsRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public ListTagsResult call() throws Exception {
                ListTagsResult result = null;

                try {
                    result = executeListTags(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future putConferencePreferenceAsync(PutConferencePreferenceRequest request) {

        return putConferencePreferenceAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future putConferencePreferenceAsync(final PutConferencePreferenceRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final PutConferencePreferenceRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public PutConferencePreferenceResult call() throws Exception {
                PutConferencePreferenceResult result = null;

                try {
                    result = executePutConferencePreference(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future putRoomSkillParameterAsync(PutRoomSkillParameterRequest request) {

        return putRoomSkillParameterAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future putRoomSkillParameterAsync(final PutRoomSkillParameterRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final PutRoomSkillParameterRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public PutRoomSkillParameterResult call() throws Exception {
                PutRoomSkillParameterResult result = null;

                try {
                    result = executePutRoomSkillParameter(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future putSkillAuthorizationAsync(PutSkillAuthorizationRequest request) {

        return putSkillAuthorizationAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future putSkillAuthorizationAsync(final PutSkillAuthorizationRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final PutSkillAuthorizationRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public PutSkillAuthorizationResult call() throws Exception {
                PutSkillAuthorizationResult result = null;

                try {
                    result = executePutSkillAuthorization(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future registerAVSDeviceAsync(RegisterAVSDeviceRequest request) {

        return registerAVSDeviceAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future registerAVSDeviceAsync(final RegisterAVSDeviceRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final RegisterAVSDeviceRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public RegisterAVSDeviceResult call() throws Exception {
                RegisterAVSDeviceResult result = null;

                try {
                    result = executeRegisterAVSDevice(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future rejectSkillAsync(RejectSkillRequest request) {

        return rejectSkillAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future rejectSkillAsync(final RejectSkillRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final RejectSkillRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public RejectSkillResult call() throws Exception {
                RejectSkillResult result = null;

                try {
                    result = executeRejectSkill(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future resolveRoomAsync(ResolveRoomRequest request) {

        return resolveRoomAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future resolveRoomAsync(final ResolveRoomRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final ResolveRoomRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public ResolveRoomResult call() throws Exception {
                ResolveRoomResult result = null;

                try {
                    result = executeResolveRoom(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future revokeInvitationAsync(RevokeInvitationRequest request) {

        return revokeInvitationAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future revokeInvitationAsync(final RevokeInvitationRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final RevokeInvitationRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public RevokeInvitationResult call() throws Exception {
                RevokeInvitationResult result = null;

                try {
                    result = executeRevokeInvitation(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future searchAddressBooksAsync(SearchAddressBooksRequest request) {

        return searchAddressBooksAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future searchAddressBooksAsync(final SearchAddressBooksRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final SearchAddressBooksRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public SearchAddressBooksResult call() throws Exception {
                SearchAddressBooksResult result = null;

                try {
                    result = executeSearchAddressBooks(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future searchContactsAsync(SearchContactsRequest request) {

        return searchContactsAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future searchContactsAsync(final SearchContactsRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final SearchContactsRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public SearchContactsResult call() throws Exception {
                SearchContactsResult result = null;

                try {
                    result = executeSearchContacts(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future searchDevicesAsync(SearchDevicesRequest request) {

        return searchDevicesAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future searchDevicesAsync(final SearchDevicesRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final SearchDevicesRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public SearchDevicesResult call() throws Exception {
                SearchDevicesResult result = null;

                try {
                    result = executeSearchDevices(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future searchProfilesAsync(SearchProfilesRequest request) {

        return searchProfilesAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future searchProfilesAsync(final SearchProfilesRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final SearchProfilesRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public SearchProfilesResult call() throws Exception {
                SearchProfilesResult result = null;

                try {
                    result = executeSearchProfiles(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future searchRoomsAsync(SearchRoomsRequest request) {

        return searchRoomsAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future searchRoomsAsync(final SearchRoomsRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final SearchRoomsRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public SearchRoomsResult call() throws Exception {
                SearchRoomsResult result = null;

                try {
                    result = executeSearchRooms(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future searchSkillGroupsAsync(SearchSkillGroupsRequest request) {

        return searchSkillGroupsAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future searchSkillGroupsAsync(final SearchSkillGroupsRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final SearchSkillGroupsRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public SearchSkillGroupsResult call() throws Exception {
                SearchSkillGroupsResult result = null;

                try {
                    result = executeSearchSkillGroups(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future searchUsersAsync(SearchUsersRequest request) {

        return searchUsersAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future searchUsersAsync(final SearchUsersRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final SearchUsersRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public SearchUsersResult call() throws Exception {
                SearchUsersResult result = null;

                try {
                    result = executeSearchUsers(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future sendInvitationAsync(SendInvitationRequest request) {

        return sendInvitationAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future sendInvitationAsync(final SendInvitationRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final SendInvitationRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public SendInvitationResult call() throws Exception {
                SendInvitationResult result = null;

                try {
                    result = executeSendInvitation(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future startDeviceSyncAsync(StartDeviceSyncRequest request) {

        return startDeviceSyncAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future startDeviceSyncAsync(final StartDeviceSyncRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final StartDeviceSyncRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public StartDeviceSyncResult call() throws Exception {
                StartDeviceSyncResult result = null;

                try {
                    result = executeStartDeviceSync(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future startSmartHomeApplianceDiscoveryAsync(
            StartSmartHomeApplianceDiscoveryRequest request) {

        return startSmartHomeApplianceDiscoveryAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future startSmartHomeApplianceDiscoveryAsync(
            final StartSmartHomeApplianceDiscoveryRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final StartSmartHomeApplianceDiscoveryRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public StartSmartHomeApplianceDiscoveryResult call() throws Exception {
                StartSmartHomeApplianceDiscoveryResult result = null;

                try {
                    result = executeStartSmartHomeApplianceDiscovery(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future tagResourceAsync(TagResourceRequest request) {

        return tagResourceAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future tagResourceAsync(final TagResourceRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final TagResourceRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public TagResourceResult call() throws Exception {
                TagResourceResult result = null;

                try {
                    result = executeTagResource(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future untagResourceAsync(UntagResourceRequest request) {

        return untagResourceAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future untagResourceAsync(final UntagResourceRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final UntagResourceRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public UntagResourceResult call() throws Exception {
                UntagResourceResult result = null;

                try {
                    result = executeUntagResource(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future updateAddressBookAsync(UpdateAddressBookRequest request) {

        return updateAddressBookAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future updateAddressBookAsync(final UpdateAddressBookRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final UpdateAddressBookRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public UpdateAddressBookResult call() throws Exception {
                UpdateAddressBookResult result = null;

                try {
                    result = executeUpdateAddressBook(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future updateBusinessReportScheduleAsync(UpdateBusinessReportScheduleRequest request) {

        return updateBusinessReportScheduleAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future updateBusinessReportScheduleAsync(final UpdateBusinessReportScheduleRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final UpdateBusinessReportScheduleRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public UpdateBusinessReportScheduleResult call() throws Exception {
                UpdateBusinessReportScheduleResult result = null;

                try {
                    result = executeUpdateBusinessReportSchedule(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future updateConferenceProviderAsync(UpdateConferenceProviderRequest request) {

        return updateConferenceProviderAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future updateConferenceProviderAsync(final UpdateConferenceProviderRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final UpdateConferenceProviderRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public UpdateConferenceProviderResult call() throws Exception {
                UpdateConferenceProviderResult result = null;

                try {
                    result = executeUpdateConferenceProvider(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future updateContactAsync(UpdateContactRequest request) {

        return updateContactAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future updateContactAsync(final UpdateContactRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final UpdateContactRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public UpdateContactResult call() throws Exception {
                UpdateContactResult result = null;

                try {
                    result = executeUpdateContact(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future updateDeviceAsync(UpdateDeviceRequest request) {

        return updateDeviceAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future updateDeviceAsync(final UpdateDeviceRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final UpdateDeviceRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public UpdateDeviceResult call() throws Exception {
                UpdateDeviceResult result = null;

                try {
                    result = executeUpdateDevice(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future updateProfileAsync(UpdateProfileRequest request) {

        return updateProfileAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future updateProfileAsync(final UpdateProfileRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final UpdateProfileRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public UpdateProfileResult call() throws Exception {
                UpdateProfileResult result = null;

                try {
                    result = executeUpdateProfile(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future updateRoomAsync(UpdateRoomRequest request) {

        return updateRoomAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future updateRoomAsync(final UpdateRoomRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final UpdateRoomRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public UpdateRoomResult call() throws Exception {
                UpdateRoomResult result = null;

                try {
                    result = executeUpdateRoom(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future updateSkillGroupAsync(UpdateSkillGroupRequest request) {

        return updateSkillGroupAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future updateSkillGroupAsync(final UpdateSkillGroupRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final UpdateSkillGroupRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public UpdateSkillGroupResult call() throws Exception {
                UpdateSkillGroupResult result = null;

                try {
                    result = executeUpdateSkillGroup(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, 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();
    }
}