/*
* Copyright 2018-2023 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.ivs;
import javax.annotation.Generated;
import com.amazonaws.services.ivs.model.*;
import com.amazonaws.client.AwsAsyncClientParams;
import com.amazonaws.annotation.ThreadSafe;
import java.util.concurrent.ExecutorService;
/**
* Client for accessing Amazon IVS 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.
*
*
* Introduction
*
*
* The Amazon Interactive Video Service (IVS) API is REST compatible, using a standard HTTP API and an Amazon Web
* Services EventBridge event stream for responses. JSON is used for both requests and responses, including errors.
*
*
* The API is an Amazon Web Services regional service. For a list of supported regions and Amazon IVS HTTPS service
* endpoints, see the Amazon IVS page in the
* Amazon Web Services General Reference.
*
*
* All API request parameters and URLs are case sensitive.
*
*
* For a summary of notable documentation changes in each release, see Document History.
*
*
* Allowed Header Values
*
*
* -
*
* Accept: application/json
*
*
* -
*
* Accept-Encoding: gzip, deflate
*
*
* -
*
* Content-Type: application/json
*
*
*
*
* Resources
*
*
* The following resources contain information about your IVS live stream (see Getting Started with Amazon IVS):
*
*
* -
*
* Channel — Stores configuration data related to your live stream. You first create a channel and then use the
* channel’s stream key to start your live stream. See the Channel endpoints for more information.
*
*
* -
*
* Stream key — An identifier assigned by Amazon IVS when you create a channel, which is then used to authorize
* streaming. See the StreamKey endpoints for more information. Treat the stream key like a secret, since it
* allows anyone to stream to the channel.
*
*
* -
*
* Playback key pair — Video playback may be restricted using playback-authorization tokens, which use public-key
* encryption. A playback key pair is the public-private pair of keys used to sign and validate the
* playback-authorization token. See the PlaybackKeyPair endpoints for more information.
*
*
* -
*
* Recording configuration — Stores configuration related to recording a live stream and where to store the
* recorded content. Multiple channels can reference the same recording configuration. See the Recording Configuration
* endpoints for more information.
*
*
*
*
* Tagging
*
*
* A tag is a metadata label that you assign to an Amazon Web Services resource. A tag comprises a key and
* a value, both set by you. For example, you might set a tag as topic:nature to label a particular
* video category. See Tagging Amazon Web
* Services Resources for more information, including restrictions that apply to tags and
* "Tag naming limits and requirements"; Amazon IVS has no service-specific constraints beyond what is documented there.
*
*
* Tags can help you identify and organize your Amazon Web Services resources. For example, you can use the same tag for
* different resources to indicate that they are related. You can also use tags to manage access (see Access Tags).
*
*
* The Amazon IVS API has these tag-related endpoints: TagResource, UntagResource, and
* ListTagsForResource. The following resources support tagging: Channels, Stream Keys, Playback Key Pairs, and
* Recording Configurations.
*
*
* At most 50 tags can be applied to a resource.
*
*
* Authentication versus Authorization
*
*
* Note the differences between these concepts:
*
*
* -
*
* Authentication is about verifying identity. You need to be authenticated to sign Amazon IVS API requests.
*
*
* -
*
* Authorization is about granting permissions. Your IAM roles need to have permissions for Amazon IVS API
* requests. In addition, authorization is needed to view Amazon IVS private channels.
* (Private channels are channels that are enabled for "playback authorization.")
*
*
*
*
* Authentication
*
*
* All Amazon IVS API requests must be authenticated with a signature. The Amazon Web Services Command-Line Interface
* (CLI) and Amazon IVS Player SDKs take care of signing the underlying API calls for you. However, if your application
* calls the Amazon IVS API directly, it’s your responsibility to sign the requests.
*
*
* You generate a signature using valid Amazon Web Services credentials that have permission to perform the requested
* action. For example, you must sign PutMetadata requests with a signature generated from a user account that has the
* ivs:PutMetadata permission.
*
*
* For more information:
*
*
*
* Amazon Resource Names (ARNs)
*
*
* ARNs uniquely identify AWS resources. An ARN is required when you need to specify a resource unambiguously across all
* of AWS, such as in IAM policies and API calls. For more information, see Amazon Resource Names in the
* AWS General Reference.
*
*
* Channel Endpoints
*
*
* -
*
* CreateChannel — Creates a new channel and an associated stream key to start streaming.
*
*
* -
*
* GetChannel — Gets the channel configuration for the specified channel ARN.
*
*
* -
*
* BatchGetChannel — Performs GetChannel on multiple ARNs simultaneously.
*
*
* -
*
* ListChannels — Gets summary information about all channels in your account, in the Amazon Web Services region
* where the API request is processed. This list can be filtered to match a specified name or recording-configuration
* ARN. Filters are mutually exclusive and cannot be used together. If you try to use both filters, you will get an
* error (409 Conflict Exception).
*
*
* -
*
* UpdateChannel — Updates a channel's configuration. This does not affect an ongoing stream of this channel. You
* must stop and restart the stream for the changes to take effect.
*
*
* -
*
* DeleteChannel — Deletes the specified channel.
*
*
*
*
* StreamKey Endpoints
*
*
* -
*
* CreateStreamKey — Creates a stream key, used to initiate a stream, for the specified channel ARN.
*
*
* -
*
* GetStreamKey — Gets stream key information for the specified ARN.
*
*
* -
*
* BatchGetStreamKey — Performs GetStreamKey on multiple ARNs simultaneously.
*
*
* -
*
* ListStreamKeys — Gets summary information about stream keys for the specified channel.
*
*
* -
*
* DeleteStreamKey — Deletes the stream key for the specified ARN, so it can no longer be used to stream.
*
*
*
*
* Stream Endpoints
*
*
* -
*
* GetStream — Gets information about the active (live) stream on a specified channel.
*
*
* -
*
* GetStreamSession — Gets metadata on a specified stream.
*
*
* -
*
* ListStreams — Gets summary information about live streams in your account, in the Amazon Web Services region
* where the API request is processed.
*
*
* -
*
* ListStreamSessions — Gets a summary of current and previous streams for a specified channel in your account,
* in the AWS region where the API request is processed.
*
*
* -
*
* StopStream — Disconnects the incoming RTMPS stream for the specified channel. Can be used in conjunction with
* DeleteStreamKey to prevent further streaming to a channel.
*
*
* -
*
* PutMetadata — Inserts metadata into the active stream of the specified channel. At most 5 requests per second
* per channel are allowed, each with a maximum 1 KB payload. (If 5 TPS is not sufficient for your needs, we recommend
* batching your data into a single PutMetadata call.) At most 155 requests per second per account are allowed.
*
*
*
*
* Private Channel Endpoints
*
*
* For more information, see Setting Up
* Private Channels in the Amazon IVS User Guide.
*
*
* -
*
* ImportPlaybackKeyPair — Imports the public portion of a new key pair and returns its arn and
* fingerprint. The privateKey can then be used to generate viewer authorization tokens, to
* grant viewers access to private channels (channels enabled for playback authorization).
*
*
* -
*
* GetPlaybackKeyPair — Gets a specified playback authorization key pair and returns the arn and
* fingerprint. The privateKey held by the caller can be used to generate viewer authorization
* tokens, to grant viewers access to private channels.
*
*
* -
*
* ListPlaybackKeyPairs — Gets summary information about playback key pairs.
*
*
* -
*
* DeletePlaybackKeyPair — Deletes a specified authorization key pair. This invalidates future viewer tokens
* generated using the key pair’s privateKey.
*
*
* -
*
* StartViewerSessionRevocation — Starts the process of revoking the viewer session associated with a specified
* channel ARN and viewer ID. Optionally, you can provide a version to revoke viewer sessions less than and including
* that version.
*
*
* -
*
* BatchStartViewerSessionRevocation — Performs StartViewerSessionRevocation on multiple channel ARN and
* viewer ID pairs simultaneously.
*
*
*
*
* RecordingConfiguration Endpoints
*
*
*
* Amazon Web Services Tags Endpoints
*
*
* -
*
* TagResource — Adds or updates tags for the Amazon Web Services resource with the specified ARN.
*
*
* -
*
* UntagResource — Removes tags from the resource with the specified ARN.
*
*
* -
*
* ListTagsForResource — Gets information about Amazon Web Services tags for the specified ARN.
*
*
*
*/
@ThreadSafe
@Generated("com.amazonaws:aws-java-sdk-code-generator")
public class AmazonIVSAsyncClient extends AmazonIVSClient implements AmazonIVSAsync {
private static final int DEFAULT_THREAD_POOL_SIZE = 50;
private final java.util.concurrent.ExecutorService executorService;
public static AmazonIVSAsyncClientBuilder asyncBuilder() {
return AmazonIVSAsyncClientBuilder.standard();
}
/**
* Constructs a new asynchronous client to invoke service methods on Amazon IVS using the specified parameters.
*
* @param asyncClientParams
* Object providing client parameters.
*/
AmazonIVSAsyncClient(AwsAsyncClientParams asyncClientParams) {
this(asyncClientParams, false);
}
/**
* Constructs a new asynchronous client to invoke service methods on Amazon IVS using the specified parameters.
*
* @param asyncClientParams
* Object providing client parameters.
* @param endpointDiscoveryEnabled
* true will enable endpoint discovery if the service supports it.
*/
AmazonIVSAsyncClient(AwsAsyncClientParams asyncClientParams, boolean endpointDiscoveryEnabled) {
super(asyncClientParams, endpointDiscoveryEnabled);
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 batchGetChannelAsync(BatchGetChannelRequest request) {
return batchGetChannelAsync(request, null);
}
@Override
public java.util.concurrent.Future batchGetChannelAsync(final BatchGetChannelRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final BatchGetChannelRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public BatchGetChannelResult call() throws Exception {
BatchGetChannelResult result = null;
try {
result = executeBatchGetChannel(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 batchGetStreamKeyAsync(BatchGetStreamKeyRequest request) {
return batchGetStreamKeyAsync(request, null);
}
@Override
public java.util.concurrent.Future batchGetStreamKeyAsync(final BatchGetStreamKeyRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final BatchGetStreamKeyRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public BatchGetStreamKeyResult call() throws Exception {
BatchGetStreamKeyResult result = null;
try {
result = executeBatchGetStreamKey(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 batchStartViewerSessionRevocationAsync(
BatchStartViewerSessionRevocationRequest request) {
return batchStartViewerSessionRevocationAsync(request, null);
}
@Override
public java.util.concurrent.Future batchStartViewerSessionRevocationAsync(
final BatchStartViewerSessionRevocationRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final BatchStartViewerSessionRevocationRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public BatchStartViewerSessionRevocationResult call() throws Exception {
BatchStartViewerSessionRevocationResult result = null;
try {
result = executeBatchStartViewerSessionRevocation(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 createChannelAsync(CreateChannelRequest request) {
return createChannelAsync(request, null);
}
@Override
public java.util.concurrent.Future createChannelAsync(final CreateChannelRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final CreateChannelRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public CreateChannelResult call() throws Exception {
CreateChannelResult result = null;
try {
result = executeCreateChannel(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 createRecordingConfigurationAsync(CreateRecordingConfigurationRequest request) {
return createRecordingConfigurationAsync(request, null);
}
@Override
public java.util.concurrent.Future createRecordingConfigurationAsync(final CreateRecordingConfigurationRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final CreateRecordingConfigurationRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public CreateRecordingConfigurationResult call() throws Exception {
CreateRecordingConfigurationResult result = null;
try {
result = executeCreateRecordingConfiguration(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 createStreamKeyAsync(CreateStreamKeyRequest request) {
return createStreamKeyAsync(request, null);
}
@Override
public java.util.concurrent.Future createStreamKeyAsync(final CreateStreamKeyRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final CreateStreamKeyRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public CreateStreamKeyResult call() throws Exception {
CreateStreamKeyResult result = null;
try {
result = executeCreateStreamKey(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 deleteChannelAsync(DeleteChannelRequest request) {
return deleteChannelAsync(request, null);
}
@Override
public java.util.concurrent.Future deleteChannelAsync(final DeleteChannelRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final DeleteChannelRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DeleteChannelResult call() throws Exception {
DeleteChannelResult result = null;
try {
result = executeDeleteChannel(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 deletePlaybackKeyPairAsync(DeletePlaybackKeyPairRequest request) {
return deletePlaybackKeyPairAsync(request, null);
}
@Override
public java.util.concurrent.Future deletePlaybackKeyPairAsync(final DeletePlaybackKeyPairRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final DeletePlaybackKeyPairRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DeletePlaybackKeyPairResult call() throws Exception {
DeletePlaybackKeyPairResult result = null;
try {
result = executeDeletePlaybackKeyPair(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 deleteRecordingConfigurationAsync(DeleteRecordingConfigurationRequest request) {
return deleteRecordingConfigurationAsync(request, null);
}
@Override
public java.util.concurrent.Future deleteRecordingConfigurationAsync(final DeleteRecordingConfigurationRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final DeleteRecordingConfigurationRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DeleteRecordingConfigurationResult call() throws Exception {
DeleteRecordingConfigurationResult result = null;
try {
result = executeDeleteRecordingConfiguration(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 deleteStreamKeyAsync(DeleteStreamKeyRequest request) {
return deleteStreamKeyAsync(request, null);
}
@Override
public java.util.concurrent.Future deleteStreamKeyAsync(final DeleteStreamKeyRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final DeleteStreamKeyRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DeleteStreamKeyResult call() throws Exception {
DeleteStreamKeyResult result = null;
try {
result = executeDeleteStreamKey(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 getChannelAsync(GetChannelRequest request) {
return getChannelAsync(request, null);
}
@Override
public java.util.concurrent.Future getChannelAsync(final GetChannelRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final GetChannelRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public GetChannelResult call() throws Exception {
GetChannelResult result = null;
try {
result = executeGetChannel(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 getPlaybackKeyPairAsync(GetPlaybackKeyPairRequest request) {
return getPlaybackKeyPairAsync(request, null);
}
@Override
public java.util.concurrent.Future getPlaybackKeyPairAsync(final GetPlaybackKeyPairRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final GetPlaybackKeyPairRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public GetPlaybackKeyPairResult call() throws Exception {
GetPlaybackKeyPairResult result = null;
try {
result = executeGetPlaybackKeyPair(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 getRecordingConfigurationAsync(GetRecordingConfigurationRequest request) {
return getRecordingConfigurationAsync(request, null);
}
@Override
public java.util.concurrent.Future getRecordingConfigurationAsync(final GetRecordingConfigurationRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final GetRecordingConfigurationRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public GetRecordingConfigurationResult call() throws Exception {
GetRecordingConfigurationResult result = null;
try {
result = executeGetRecordingConfiguration(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 getStreamAsync(GetStreamRequest request) {
return getStreamAsync(request, null);
}
@Override
public java.util.concurrent.Future getStreamAsync(final GetStreamRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final GetStreamRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public GetStreamResult call() throws Exception {
GetStreamResult result = null;
try {
result = executeGetStream(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 getStreamKeyAsync(GetStreamKeyRequest request) {
return getStreamKeyAsync(request, null);
}
@Override
public java.util.concurrent.Future getStreamKeyAsync(final GetStreamKeyRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final GetStreamKeyRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public GetStreamKeyResult call() throws Exception {
GetStreamKeyResult result = null;
try {
result = executeGetStreamKey(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 getStreamSessionAsync(GetStreamSessionRequest request) {
return getStreamSessionAsync(request, null);
}
@Override
public java.util.concurrent.Future getStreamSessionAsync(final GetStreamSessionRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final GetStreamSessionRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public GetStreamSessionResult call() throws Exception {
GetStreamSessionResult result = null;
try {
result = executeGetStreamSession(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 importPlaybackKeyPairAsync(ImportPlaybackKeyPairRequest request) {
return importPlaybackKeyPairAsync(request, null);
}
@Override
public java.util.concurrent.Future importPlaybackKeyPairAsync(final ImportPlaybackKeyPairRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final ImportPlaybackKeyPairRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public ImportPlaybackKeyPairResult call() throws Exception {
ImportPlaybackKeyPairResult result = null;
try {
result = executeImportPlaybackKeyPair(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 listChannelsAsync(ListChannelsRequest request) {
return listChannelsAsync(request, null);
}
@Override
public java.util.concurrent.Future listChannelsAsync(final ListChannelsRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final ListChannelsRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public ListChannelsResult call() throws Exception {
ListChannelsResult result = null;
try {
result = executeListChannels(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 listPlaybackKeyPairsAsync(ListPlaybackKeyPairsRequest request) {
return listPlaybackKeyPairsAsync(request, null);
}
@Override
public java.util.concurrent.Future listPlaybackKeyPairsAsync(final ListPlaybackKeyPairsRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final ListPlaybackKeyPairsRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public ListPlaybackKeyPairsResult call() throws Exception {
ListPlaybackKeyPairsResult result = null;
try {
result = executeListPlaybackKeyPairs(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 listRecordingConfigurationsAsync(ListRecordingConfigurationsRequest request) {
return listRecordingConfigurationsAsync(request, null);
}
@Override
public java.util.concurrent.Future listRecordingConfigurationsAsync(final ListRecordingConfigurationsRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final ListRecordingConfigurationsRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public ListRecordingConfigurationsResult call() throws Exception {
ListRecordingConfigurationsResult result = null;
try {
result = executeListRecordingConfigurations(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 listStreamKeysAsync(ListStreamKeysRequest request) {
return listStreamKeysAsync(request, null);
}
@Override
public java.util.concurrent.Future listStreamKeysAsync(final ListStreamKeysRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final ListStreamKeysRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public ListStreamKeysResult call() throws Exception {
ListStreamKeysResult result = null;
try {
result = executeListStreamKeys(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 listStreamSessionsAsync(ListStreamSessionsRequest request) {
return listStreamSessionsAsync(request, null);
}
@Override
public java.util.concurrent.Future listStreamSessionsAsync(final ListStreamSessionsRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final ListStreamSessionsRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public ListStreamSessionsResult call() throws Exception {
ListStreamSessionsResult result = null;
try {
result = executeListStreamSessions(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 listStreamsAsync(ListStreamsRequest request) {
return listStreamsAsync(request, null);
}
@Override
public java.util.concurrent.Future listStreamsAsync(final ListStreamsRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final ListStreamsRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public ListStreamsResult call() throws Exception {
ListStreamsResult result = null;
try {
result = executeListStreams(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 listTagsForResourceAsync(ListTagsForResourceRequest request) {
return listTagsForResourceAsync(request, null);
}
@Override
public java.util.concurrent.Future listTagsForResourceAsync(final ListTagsForResourceRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final ListTagsForResourceRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public ListTagsForResourceResult call() throws Exception {
ListTagsForResourceResult result = null;
try {
result = executeListTagsForResource(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 putMetadataAsync(PutMetadataRequest request) {
return putMetadataAsync(request, null);
}
@Override
public java.util.concurrent.Future putMetadataAsync(final PutMetadataRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final PutMetadataRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public PutMetadataResult call() throws Exception {
PutMetadataResult result = null;
try {
result = executePutMetadata(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 startViewerSessionRevocationAsync(StartViewerSessionRevocationRequest request) {
return startViewerSessionRevocationAsync(request, null);
}
@Override
public java.util.concurrent.Future startViewerSessionRevocationAsync(final StartViewerSessionRevocationRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final StartViewerSessionRevocationRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public StartViewerSessionRevocationResult call() throws Exception {
StartViewerSessionRevocationResult result = null;
try {
result = executeStartViewerSessionRevocation(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 stopStreamAsync(StopStreamRequest request) {
return stopStreamAsync(request, null);
}
@Override
public java.util.concurrent.Future stopStreamAsync(final StopStreamRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final StopStreamRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public StopStreamResult call() throws Exception {
StopStreamResult result = null;
try {
result = executeStopStream(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 updateChannelAsync(UpdateChannelRequest request) {
return updateChannelAsync(request, null);
}
@Override
public java.util.concurrent.Future updateChannelAsync(final UpdateChannelRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final UpdateChannelRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public UpdateChannelResult call() throws Exception {
UpdateChannelResult result = null;
try {
result = executeUpdateChannel(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();
}
}