jsonErrorUnmarshallers;
/**
* Constructs a new client to invoke service methods on AWSKinesisVideo. A
* credentials provider chain will be used that searches for credentials in
* this order:
*
* - Environment Variables - AWS_ACCESS_KEY_ID and AWS_SECRET_KEY
* - Java System Properties - aws.accessKeyId and aws.secretKey
* - Instance profile credentials delivered through the Amazon EC2
* metadata service
*
*
* All service calls made using this new client object are blocking, and
* will not return until the service call completes.
*
* @see DefaultAWSCredentialsProviderChain
*/
@Deprecated
public AWSKinesisVideoClient() {
this(new DefaultAWSCredentialsProviderChain(), new ClientConfiguration());
}
/**
* Constructs a new client to invoke service methods on AWSKinesisVideo. A
* credentials provider chain will be used that searches for credentials in
* this order:
*
* - Environment Variables - AWS_ACCESS_KEY_ID and AWS_SECRET_KEY
* - Java System Properties - aws.accessKeyId and aws.secretKey
* - Instance profile credentials delivered through the Amazon EC2
* metadata service
*
*
* All service calls made using this new client object are blocking, and
* will not return until the service call completes.
*
* @param clientConfiguration The client configuration options controlling
* how this client connects to AWSKinesisVideo (ex: proxy
* settings, retry counts, etc.).
* @see DefaultAWSCredentialsProviderChain
*/
@Deprecated
public AWSKinesisVideoClient(ClientConfiguration clientConfiguration) {
this(new DefaultAWSCredentialsProviderChain(), clientConfiguration);
}
/**
* Constructs a new client to invoke service methods on AWSKinesisVideo
* using the specified AWS account credentials.
*
* The client requests are authenticated using the {@link AWSCredentials}
* provided in this constructor. Static AWSCredentials can be passed for
* quick testing. However, it is strongly recommended to use Amazon Cognito
* vended temporary credentials for use in production. This can be achieved
* by using {@link AWSMobileClient}. Please see
* https://aws-amplify.github.io/docs/android/authentication for
* instructions on how to enable {@link AWSMobileClient}.
*
*
* AWSMobileClient.getInstance().initialize(getApplicationContext(), new Callback<UserStateDetails>() {
* @Override
* public void onResult(final UserStateDetails details) {
* AWSKinesisVideoClient client = new AWSKinesisVideoClient(AWSMobileClient.getInstance());
* }
*
* @Override
* public void onError(final Exception e) {
* e.printStackTrace();
* }
* });
*
*
* All service calls made using this new client object are blocking, and
* will not return until the service call completes.
*
* @param awsCredentials The AWS credentials (access key ID and secret key)
* to use when authenticating with AWS services.
*/
public AWSKinesisVideoClient(AWSCredentials awsCredentials) {
this(awsCredentials, new ClientConfiguration());
}
/**
* Constructs a new client to invoke service methods on AWSKinesisVideo
* using the specified AWS account credentials and client configuration
* options.
*
* The client requests are authenticated using the {@link AWSCredentials}
* provided in this constructor. Static AWSCredentials can be passed for
* quick testing. However, it is strongly recommended to use Amazon Cognito
* vended temporary credentials for use in production. This can be achieved
* by using {@link AWSMobileClient}. Please see
* https://aws-amplify.github.io/docs/android/authentication for
* instructions on how to enable {@link AWSMobileClient}.
*
*
* AWSMobileClient.getInstance().initialize(getApplicationContext(), new Callback<UserStateDetails>() {
* @Override
* public void onResult(final UserStateDetails details) {
* AWSKinesisVideoClient client = new AWSKinesisVideoClient(AWSMobileClient.getInstance());
* }
*
* @Override
* public void onError(final Exception e) {
* e.printStackTrace();
* }
* });
*
*
* All service calls made using this new client object are blocking, and
* will not return until the service call completes.
*
* @param awsCredentials The AWS credentials (access key ID and secret key)
* to use when authenticating with AWS services.
* @param clientConfiguration The client configuration options controlling
* how this client connects to AWSKinesisVideo (ex: proxy
* settings, retry counts, etc.).
*/
public AWSKinesisVideoClient(AWSCredentials awsCredentials,
ClientConfiguration clientConfiguration) {
this(new StaticCredentialsProvider(awsCredentials), clientConfiguration);
}
/**
* Constructs a new client to invoke service methods on AWSKinesisVideo
* using the specified AWS account credentials provider.
*
* The client requests are authenticated using the {@link AWSCredentials}
* provided by the {@link AWSCredentialsProvider}. Static AWSCredentials can
* be passed for quick testing. However, it is strongly recommended to use
* Amazon Cognito vended temporary credentials for use in production. This
* can be achieved by using {@link AWSMobileClient}. Please see
* https://aws-amplify.github.io/docs/android/authentication for
* instructions on how to enable {@link AWSMobileClient}.
*
*
* AWSMobileClient.getInstance().initialize(getApplicationContext(), new Callback<UserStateDetails>() {
* @Override
* public void onResult(final UserStateDetails details) {
* AWSKinesisVideoClient client = new AWSKinesisVideoClient(AWSMobileClient.getInstance());
* }
*
* @Override
* public void onError(final Exception e) {
* e.printStackTrace();
* }
* });
*
*
* All service calls made using this new client object are blocking, and
* will not return until the service call completes.
*
* @param awsCredentialsProvider The AWS credentials provider which will
* provide credentials to authenticate requests with AWS
* services.
*/
public AWSKinesisVideoClient(AWSCredentialsProvider awsCredentialsProvider) {
this(awsCredentialsProvider, new ClientConfiguration());
}
/**
* Constructs a new client to invoke service methods on AWSKinesisVideo
* using the specified AWS account credentials provider and client
* configuration options.
*
* The client requests are authenticated using the {@link AWSCredentials}
* provided by the {@link AWSCredentialsProvider}. Static AWSCredentials can
* be passed for quick testing. However, it is strongly recommended to use
* Amazon Cognito vended temporary credentials for use in production. This
* can be achieved by using {@link AWSMobileClient}. Please see
* https://aws-amplify.github.io/docs/android/authentication for
* instructions on how to enable {@link AWSMobileClient}.
*
*
* AWSMobileClient.getInstance().initialize(getApplicationContext(), new Callback<UserStateDetails>() {
* @Override
* public void onResult(final UserStateDetails details) {
* AWSKinesisVideoClient client = new AWSKinesisVideoClient(AWSMobileClient.getInstance());
* }
*
* @Override
* public void onError(final Exception e) {
* e.printStackTrace();
* }
* });
*
*
* All service calls made using this new client object are blocking, and
* will not return until the service call completes.
*
* @param awsCredentialsProvider The AWS credentials provider which will
* provide credentials to authenticate requests with AWS
* services.
* @param clientConfiguration The client configuration options controlling
* how this client connects to AWSKinesisVideo (ex: proxy
* settings, retry counts, etc.).
*/
public AWSKinesisVideoClient(AWSCredentialsProvider awsCredentialsProvider,
ClientConfiguration clientConfiguration) {
this(awsCredentialsProvider, clientConfiguration, new UrlHttpClient(clientConfiguration));
}
/**
* Constructs a new client to invoke service methods on AWSKinesisVideo
* using the specified AWS account credentials provider, client
* configuration options and request metric collector.
*
* All service calls made using this new client object are blocking, and
* will not return until the service call completes.
*
* @param awsCredentialsProvider The AWS credentials provider which will
* provide credentials to authenticate requests with AWS
* services.
* @param clientConfiguration The client configuration options controlling
* how this client connects to AWSKinesisVideo (ex: proxy
* settings, retry counts, etc.).
* @param requestMetricCollector optional request metric collector
*/
@Deprecated
public AWSKinesisVideoClient(AWSCredentialsProvider awsCredentialsProvider,
ClientConfiguration clientConfiguration,
RequestMetricCollector requestMetricCollector) {
super(adjustClientConfiguration(clientConfiguration), requestMetricCollector);
this.awsCredentialsProvider = awsCredentialsProvider;
init();
}
/**
* Constructs a new client to invoke service methods on AWSKinesisVideo
* using the specified AWS account credentials provider, client
* configuration options and request metric collector.
*
* The client requests are authenticated using the {@link AWSCredentials}
* provided by the {@link AWSCredentialsProvider}. Static AWSCredentials can
* be passed for quick testing. However, it is strongly recommended to use
* Amazon Cognito vended temporary credentials for use in production. This
* can be achieved by using {@link AWSMobileClient}. Please see
* https://aws-amplify.github.io/docs/android/authentication for
* instructions on how to enable {@link AWSMobileClient}.
*
*
* AWSMobileClient.getInstance().initialize(getApplicationContext(), new Callback<UserStateDetails>() {
* @Override
* public void onResult(final UserStateDetails details) {
* AWSKinesisVideoClient client = new AWSKinesisVideoClient(AWSMobileClient.getInstance());
* }
*
* @Override
* public void onError(final Exception e) {
* e.printStackTrace();
* }
* });
*
*
* All service calls made using this new client object are blocking, and
* will not return until the service call completes.
*
* @param awsCredentialsProvider The AWS credentials provider which will
* provide credentials to authenticate requests with AWS
* services.
* @param clientConfiguration The client configuration options controlling
* how this client connects to AWSKinesisVideo (ex: proxy
* settings, retry counts, etc.).
* @param httpClient A http client
*/
public AWSKinesisVideoClient(AWSCredentialsProvider awsCredentialsProvider,
ClientConfiguration clientConfiguration, HttpClient httpClient) {
super(adjustClientConfiguration(clientConfiguration), httpClient);
this.awsCredentialsProvider = awsCredentialsProvider;
init();
}
private void init() {
jsonErrorUnmarshallers = new ArrayList();
jsonErrorUnmarshallers.add(new AccessDeniedExceptionUnmarshaller());
jsonErrorUnmarshallers.add(new AccountChannelLimitExceededExceptionUnmarshaller());
jsonErrorUnmarshallers.add(new AccountStreamLimitExceededExceptionUnmarshaller());
jsonErrorUnmarshallers.add(new ClientLimitExceededExceptionUnmarshaller());
jsonErrorUnmarshallers.add(new DeviceStreamLimitExceededExceptionUnmarshaller());
jsonErrorUnmarshallers.add(new InvalidArgumentExceptionUnmarshaller());
jsonErrorUnmarshallers.add(new InvalidDeviceExceptionUnmarshaller());
jsonErrorUnmarshallers.add(new InvalidResourceFormatExceptionUnmarshaller());
jsonErrorUnmarshallers.add(new NoDataRetentionExceptionUnmarshaller());
jsonErrorUnmarshallers.add(new NotAuthorizedExceptionUnmarshaller());
jsonErrorUnmarshallers.add(new ResourceInUseExceptionUnmarshaller());
jsonErrorUnmarshallers.add(new ResourceNotFoundExceptionUnmarshaller());
jsonErrorUnmarshallers.add(new StreamEdgeConfigurationNotFoundExceptionUnmarshaller());
jsonErrorUnmarshallers.add(new TagsPerResourceExceededLimitExceptionUnmarshaller());
jsonErrorUnmarshallers.add(new VersionMismatchExceptionUnmarshaller());
jsonErrorUnmarshallers.add(new JsonErrorUnmarshaller());
// calling this.setEndPoint(...) will also modify the signer accordingly
this.setEndpoint("https://kinesisvideo.us-west-2.amazonaws.com");
this.endpointPrefix = "kinesisvideo";
HandlerChainFactory chainFactory = new HandlerChainFactory();
requestHandler2s.addAll(chainFactory.newRequestHandlerChain(
"/com/amazonaws/services/kinesisvideo/request.handlers"));
requestHandler2s.addAll(chainFactory.newRequestHandler2Chain(
"/com/amazonaws/services/kinesisvideo/request.handler2s"));
}
private static ClientConfiguration adjustClientConfiguration(ClientConfiguration orig) {
ClientConfiguration config = orig;
return config;
}
/**
*
* Creates a signaling channel.
*
*
* CreateSignalingChannel is an asynchronous operation.
*
*
* @param createSignalingChannelRequest
* @return createSignalingChannelResult The response from the
* CreateSignalingChannel service method, as returned by
* AWSKinesisVideoFrontend.
* @throws InvalidArgumentException
* @throws ClientLimitExceededException
* @throws AccountChannelLimitExceededException
* @throws ResourceInUseException
* @throws AccessDeniedException
* @throws TagsPerResourceExceededLimitException
* @throws AmazonClientException If any internal errors are encountered
* inside the client while attempting to make the request or
* handle the response. For example if a network connection is
* not available.
* @throws AmazonServiceException If an error response is returned by
* AWSKinesisVideoFrontend indicating either a problem with the
* data in the request, or a server side issue.
*/
public CreateSignalingChannelResult createSignalingChannel(
CreateSignalingChannelRequest createSignalingChannelRequest)
throws AmazonServiceException, AmazonClientException {
ExecutionContext executionContext = createExecutionContext(createSignalingChannelRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new CreateSignalingChannelRequestMarshaller()
.marshall(createSignalingChannelRequest);
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
Unmarshaller unmarshaller = new CreateSignalingChannelResultJsonUnmarshaller();
JsonResponseHandler responseHandler = new JsonResponseHandler(
unmarshaller);
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
awsRequestMetrics.endEvent(Field.ClientExecuteTime);
endClientExecution(awsRequestMetrics, request, response, LOGGING_AWS_REQUEST_METRIC);
}
}
/**
*
* Creates a new Kinesis video stream.
*
*
* When you create a new stream, Kinesis Video Streams assigns it a version
* number. When you change the stream's metadata, Kinesis Video Streams
* updates the version.
*
*
* CreateStream is an asynchronous operation.
*
*
* For information about how the service works, see How it Works.
*
*
* You must have permissions for the KinesisVideo:CreateStream
* action.
*
*
* @param createStreamRequest
* @return createStreamResult The response from the CreateStream service
* method, as returned by AWSKinesisVideoFrontend.
* @throws AccountStreamLimitExceededException
* @throws DeviceStreamLimitExceededException
* @throws ResourceInUseException
* @throws InvalidDeviceException
* @throws InvalidArgumentException
* @throws ClientLimitExceededException
* @throws TagsPerResourceExceededLimitException
* @throws AmazonClientException If any internal errors are encountered
* inside the client while attempting to make the request or
* handle the response. For example if a network connection is
* not available.
* @throws AmazonServiceException If an error response is returned by
* AWSKinesisVideoFrontend indicating either a problem with the
* data in the request, or a server side issue.
*/
public CreateStreamResult createStream(CreateStreamRequest createStreamRequest)
throws AmazonServiceException, AmazonClientException {
ExecutionContext executionContext = createExecutionContext(createStreamRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new CreateStreamRequestMarshaller().marshall(createStreamRequest);
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
Unmarshaller unmarshaller = new CreateStreamResultJsonUnmarshaller();
JsonResponseHandler responseHandler = new JsonResponseHandler(
unmarshaller);
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
awsRequestMetrics.endEvent(Field.ClientExecuteTime);
endClientExecution(awsRequestMetrics, request, response, LOGGING_AWS_REQUEST_METRIC);
}
}
/**
*
* An asynchronous API that deletes a stream’s existing edge configuration,
* as well as the corresponding media from the Edge Agent.
*
*
* When you invoke this API, the sync status is set to DELETING
* . A deletion process starts, in which active edge jobs are stopped and
* all media is deleted from the edge device. The time to delete varies,
* depending on the total amount of stored media. If the deletion process
* fails, the sync status changes to DELETE_FAILED. You will
* need to re-try the deletion.
*
*
* When the deletion process has completed successfully, the edge
* configuration is no longer accessible.
*
*
* @param deleteEdgeConfigurationRequest
* @return deleteEdgeConfigurationResult The response from the
* DeleteEdgeConfiguration service method, as returned by
* AWSKinesisVideoFrontend.
* @throws AccessDeniedException
* @throws ClientLimitExceededException
* @throws InvalidArgumentException
* @throws ResourceNotFoundException
* @throws StreamEdgeConfigurationNotFoundException
* @throws AmazonClientException If any internal errors are encountered
* inside the client while attempting to make the request or
* handle the response. For example if a network connection is
* not available.
* @throws AmazonServiceException If an error response is returned by
* AWSKinesisVideoFrontend indicating either a problem with the
* data in the request, or a server side issue.
*/
public DeleteEdgeConfigurationResult deleteEdgeConfiguration(
DeleteEdgeConfigurationRequest deleteEdgeConfigurationRequest)
throws AmazonServiceException, AmazonClientException {
ExecutionContext executionContext = createExecutionContext(deleteEdgeConfigurationRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DeleteEdgeConfigurationRequestMarshaller()
.marshall(deleteEdgeConfigurationRequest);
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
Unmarshaller unmarshaller = new DeleteEdgeConfigurationResultJsonUnmarshaller();
JsonResponseHandler responseHandler = new JsonResponseHandler(
unmarshaller);
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
awsRequestMetrics.endEvent(Field.ClientExecuteTime);
endClientExecution(awsRequestMetrics, request, response, LOGGING_AWS_REQUEST_METRIC);
}
}
/**
*
* Deletes a specified signaling channel.
* DeleteSignalingChannel is an asynchronous operation. If you
* don't specify the channel's current version, the most recent version is
* deleted.
*
*
* @param deleteSignalingChannelRequest
* @return deleteSignalingChannelResult The response from the
* DeleteSignalingChannel service method, as returned by
* AWSKinesisVideoFrontend.
* @throws InvalidArgumentException
* @throws ClientLimitExceededException
* @throws ResourceNotFoundException
* @throws AccessDeniedException
* @throws VersionMismatchException
* @throws ResourceInUseException
* @throws AmazonClientException If any internal errors are encountered
* inside the client while attempting to make the request or
* handle the response. For example if a network connection is
* not available.
* @throws AmazonServiceException If an error response is returned by
* AWSKinesisVideoFrontend indicating either a problem with the
* data in the request, or a server side issue.
*/
public DeleteSignalingChannelResult deleteSignalingChannel(
DeleteSignalingChannelRequest deleteSignalingChannelRequest)
throws AmazonServiceException, AmazonClientException {
ExecutionContext executionContext = createExecutionContext(deleteSignalingChannelRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DeleteSignalingChannelRequestMarshaller()
.marshall(deleteSignalingChannelRequest);
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
Unmarshaller unmarshaller = new DeleteSignalingChannelResultJsonUnmarshaller();
JsonResponseHandler responseHandler = new JsonResponseHandler(
unmarshaller);
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
awsRequestMetrics.endEvent(Field.ClientExecuteTime);
endClientExecution(awsRequestMetrics, request, response, LOGGING_AWS_REQUEST_METRIC);
}
}
/**
*
* Deletes a Kinesis video stream and the data contained in the stream.
*
*
* This method marks the stream for deletion, and makes the data in the
* stream inaccessible immediately.
*
*
*
*
* To ensure that you have the latest version of the stream before deleting
* it, you can specify the stream version. Kinesis Video Streams assigns a
* version to each stream. When you update a stream, Kinesis Video Streams
* assigns a new version number. To get the latest stream version, use the
* DescribeStream API.
*
*
* This operation requires permission for the
* KinesisVideo:DeleteStream action.
*
*
* @param deleteStreamRequest
* @return deleteStreamResult The response from the DeleteStream service
* method, as returned by AWSKinesisVideoFrontend.
* @throws ClientLimitExceededException
* @throws InvalidArgumentException
* @throws ResourceNotFoundException
* @throws NotAuthorizedException
* @throws VersionMismatchException
* @throws ResourceInUseException
* @throws AmazonClientException If any internal errors are encountered
* inside the client while attempting to make the request or
* handle the response. For example if a network connection is
* not available.
* @throws AmazonServiceException If an error response is returned by
* AWSKinesisVideoFrontend indicating either a problem with the
* data in the request, or a server side issue.
*/
public DeleteStreamResult deleteStream(DeleteStreamRequest deleteStreamRequest)
throws AmazonServiceException, AmazonClientException {
ExecutionContext executionContext = createExecutionContext(deleteStreamRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DeleteStreamRequestMarshaller().marshall(deleteStreamRequest);
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
Unmarshaller unmarshaller = new DeleteStreamResultJsonUnmarshaller();
JsonResponseHandler responseHandler = new JsonResponseHandler(
unmarshaller);
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
awsRequestMetrics.endEvent(Field.ClientExecuteTime);
endClientExecution(awsRequestMetrics, request, response, LOGGING_AWS_REQUEST_METRIC);
}
}
/**
*
* Describes a stream’s edge configuration that was set using the
* StartEdgeConfigurationUpdate API and the latest status of
* the edge agent's recorder and uploader jobs. Use this API to get the
* status of the configuration to determine if the configuration is in sync
* with the Edge Agent. Use this API to evaluate the health of the Edge
* Agent.
*
*
* @param describeEdgeConfigurationRequest
* @return describeEdgeConfigurationResult The response from the
* DescribeEdgeConfiguration service method, as returned by
* AWSKinesisVideoFrontend.
* @throws AccessDeniedException
* @throws ClientLimitExceededException
* @throws InvalidArgumentException
* @throws ResourceNotFoundException
* @throws StreamEdgeConfigurationNotFoundException
* @throws AmazonClientException If any internal errors are encountered
* inside the client while attempting to make the request or
* handle the response. For example if a network connection is
* not available.
* @throws AmazonServiceException If an error response is returned by
* AWSKinesisVideoFrontend indicating either a problem with the
* data in the request, or a server side issue.
*/
public DescribeEdgeConfigurationResult describeEdgeConfiguration(
DescribeEdgeConfigurationRequest describeEdgeConfigurationRequest)
throws AmazonServiceException, AmazonClientException {
ExecutionContext executionContext = createExecutionContext(describeEdgeConfigurationRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DescribeEdgeConfigurationRequestMarshaller()
.marshall(describeEdgeConfigurationRequest);
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
Unmarshaller unmarshaller = new DescribeEdgeConfigurationResultJsonUnmarshaller();
JsonResponseHandler responseHandler = new JsonResponseHandler(
unmarshaller);
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
awsRequestMetrics.endEvent(Field.ClientExecuteTime);
endClientExecution(awsRequestMetrics, request, response, LOGGING_AWS_REQUEST_METRIC);
}
}
/**
*
* Gets the ImageGenerationConfiguration for a given Kinesis
* video stream.
*
*
* @param describeImageGenerationConfigurationRequest
* @return describeImageGenerationConfigurationResult The response from the
* DescribeImageGenerationConfiguration service method, as returned
* by AWSKinesisVideoFrontend.
* @throws InvalidArgumentException
* @throws ClientLimitExceededException
* @throws ResourceNotFoundException
* @throws AccessDeniedException
* @throws AmazonClientException If any internal errors are encountered
* inside the client while attempting to make the request or
* handle the response. For example if a network connection is
* not available.
* @throws AmazonServiceException If an error response is returned by
* AWSKinesisVideoFrontend indicating either a problem with the
* data in the request, or a server side issue.
*/
public DescribeImageGenerationConfigurationResult describeImageGenerationConfiguration(
DescribeImageGenerationConfigurationRequest describeImageGenerationConfigurationRequest)
throws AmazonServiceException, AmazonClientException {
ExecutionContext executionContext = createExecutionContext(describeImageGenerationConfigurationRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DescribeImageGenerationConfigurationRequestMarshaller()
.marshall(describeImageGenerationConfigurationRequest);
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
Unmarshaller unmarshaller = new DescribeImageGenerationConfigurationResultJsonUnmarshaller();
JsonResponseHandler responseHandler = new JsonResponseHandler(
unmarshaller);
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
awsRequestMetrics.endEvent(Field.ClientExecuteTime);
endClientExecution(awsRequestMetrics, request, response, LOGGING_AWS_REQUEST_METRIC);
}
}
/**
*
* Returns the most current information about the stream. The
* streamName or streamARN should be provided in
* the input.
*
*
* @param describeMappedResourceConfigurationRequest
* @return describeMappedResourceConfigurationResult The response from the
* DescribeMappedResourceConfiguration service method, as returned
* by AWSKinesisVideoFrontend.
* @throws ResourceNotFoundException
* @throws InvalidArgumentException
* @throws AccessDeniedException
* @throws ClientLimitExceededException
* @throws AmazonClientException If any internal errors are encountered
* inside the client while attempting to make the request or
* handle the response. For example if a network connection is
* not available.
* @throws AmazonServiceException If an error response is returned by
* AWSKinesisVideoFrontend indicating either a problem with the
* data in the request, or a server side issue.
*/
public DescribeMappedResourceConfigurationResult describeMappedResourceConfiguration(
DescribeMappedResourceConfigurationRequest describeMappedResourceConfigurationRequest)
throws AmazonServiceException, AmazonClientException {
ExecutionContext executionContext = createExecutionContext(describeMappedResourceConfigurationRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DescribeMappedResourceConfigurationRequestMarshaller()
.marshall(describeMappedResourceConfigurationRequest);
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
Unmarshaller unmarshaller = new DescribeMappedResourceConfigurationResultJsonUnmarshaller();
JsonResponseHandler responseHandler = new JsonResponseHandler(
unmarshaller);
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
awsRequestMetrics.endEvent(Field.ClientExecuteTime);
endClientExecution(awsRequestMetrics, request, response, LOGGING_AWS_REQUEST_METRIC);
}
}
/**
*
* Returns the most current information about the channel. Specify the
* ChannelName or ChannelARN in the input.
*
*
* @param describeMediaStorageConfigurationRequest
* @return describeMediaStorageConfigurationResult The response from the
* DescribeMediaStorageConfiguration service method, as returned by
* AWSKinesisVideoFrontend.
* @throws ResourceNotFoundException
* @throws InvalidArgumentException
* @throws AccessDeniedException
* @throws ClientLimitExceededException
* @throws AmazonClientException If any internal errors are encountered
* inside the client while attempting to make the request or
* handle the response. For example if a network connection is
* not available.
* @throws AmazonServiceException If an error response is returned by
* AWSKinesisVideoFrontend indicating either a problem with the
* data in the request, or a server side issue.
*/
public DescribeMediaStorageConfigurationResult describeMediaStorageConfiguration(
DescribeMediaStorageConfigurationRequest describeMediaStorageConfigurationRequest)
throws AmazonServiceException, AmazonClientException {
ExecutionContext executionContext = createExecutionContext(describeMediaStorageConfigurationRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DescribeMediaStorageConfigurationRequestMarshaller()
.marshall(describeMediaStorageConfigurationRequest);
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
Unmarshaller unmarshaller = new DescribeMediaStorageConfigurationResultJsonUnmarshaller();
JsonResponseHandler responseHandler = new JsonResponseHandler(
unmarshaller);
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
awsRequestMetrics.endEvent(Field.ClientExecuteTime);
endClientExecution(awsRequestMetrics, request, response, LOGGING_AWS_REQUEST_METRIC);
}
}
/**
*
* Gets the NotificationConfiguration for a given Kinesis video
* stream.
*
*
* @param describeNotificationConfigurationRequest
* @return describeNotificationConfigurationResult The response from the
* DescribeNotificationConfiguration service method, as returned by
* AWSKinesisVideoFrontend.
* @throws InvalidArgumentException
* @throws ClientLimitExceededException
* @throws ResourceNotFoundException
* @throws AccessDeniedException
* @throws AmazonClientException If any internal errors are encountered
* inside the client while attempting to make the request or
* handle the response. For example if a network connection is
* not available.
* @throws AmazonServiceException If an error response is returned by
* AWSKinesisVideoFrontend indicating either a problem with the
* data in the request, or a server side issue.
*/
public DescribeNotificationConfigurationResult describeNotificationConfiguration(
DescribeNotificationConfigurationRequest describeNotificationConfigurationRequest)
throws AmazonServiceException, AmazonClientException {
ExecutionContext executionContext = createExecutionContext(describeNotificationConfigurationRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DescribeNotificationConfigurationRequestMarshaller()
.marshall(describeNotificationConfigurationRequest);
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
Unmarshaller unmarshaller = new DescribeNotificationConfigurationResultJsonUnmarshaller();
JsonResponseHandler responseHandler = new JsonResponseHandler(
unmarshaller);
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
awsRequestMetrics.endEvent(Field.ClientExecuteTime);
endClientExecution(awsRequestMetrics, request, response, LOGGING_AWS_REQUEST_METRIC);
}
}
/**
*
* Returns the most current information about the signaling channel. You
* must specify either the name or the Amazon Resource Name (ARN) of the
* channel that you want to describe.
*
*
* @param describeSignalingChannelRequest
* @return describeSignalingChannelResult The response from the
* DescribeSignalingChannel service method, as returned by
* AWSKinesisVideoFrontend.
* @throws InvalidArgumentException
* @throws ClientLimitExceededException
* @throws ResourceNotFoundException
* @throws AccessDeniedException
* @throws AmazonClientException If any internal errors are encountered
* inside the client while attempting to make the request or
* handle the response. For example if a network connection is
* not available.
* @throws AmazonServiceException If an error response is returned by
* AWSKinesisVideoFrontend indicating either a problem with the
* data in the request, or a server side issue.
*/
public DescribeSignalingChannelResult describeSignalingChannel(
DescribeSignalingChannelRequest describeSignalingChannelRequest)
throws AmazonServiceException, AmazonClientException {
ExecutionContext executionContext = createExecutionContext(describeSignalingChannelRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DescribeSignalingChannelRequestMarshaller()
.marshall(describeSignalingChannelRequest);
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
Unmarshaller unmarshaller = new DescribeSignalingChannelResultJsonUnmarshaller();
JsonResponseHandler responseHandler = new JsonResponseHandler(
unmarshaller);
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
awsRequestMetrics.endEvent(Field.ClientExecuteTime);
endClientExecution(awsRequestMetrics, request, response, LOGGING_AWS_REQUEST_METRIC);
}
}
/**
*
* Returns the most current information about the specified stream. You must
* specify either the StreamName or the StreamARN.
*
*
* @param describeStreamRequest
* @return describeStreamResult The response from the DescribeStream service
* method, as returned by AWSKinesisVideoFrontend.
* @throws InvalidArgumentException
* @throws ResourceNotFoundException
* @throws ClientLimitExceededException
* @throws NotAuthorizedException
* @throws AmazonClientException If any internal errors are encountered
* inside the client while attempting to make the request or
* handle the response. For example if a network connection is
* not available.
* @throws AmazonServiceException If an error response is returned by
* AWSKinesisVideoFrontend indicating either a problem with the
* data in the request, or a server side issue.
*/
public DescribeStreamResult describeStream(DescribeStreamRequest describeStreamRequest)
throws AmazonServiceException, AmazonClientException {
ExecutionContext executionContext = createExecutionContext(describeStreamRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DescribeStreamRequestMarshaller().marshall(describeStreamRequest);
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
Unmarshaller unmarshaller = new DescribeStreamResultJsonUnmarshaller();
JsonResponseHandler responseHandler = new JsonResponseHandler(
unmarshaller);
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
awsRequestMetrics.endEvent(Field.ClientExecuteTime);
endClientExecution(awsRequestMetrics, request, response, LOGGING_AWS_REQUEST_METRIC);
}
}
/**
*
* Gets an endpoint for a specified stream for either reading or writing.
* Use this endpoint in your application to read from the specified stream
* (using the GetMedia or GetMediaForFragmentList
* operations) or write to it (using the PutMedia operation).
*
*
*
* The returned endpoint does not have the API name appended. The client
* needs to add the API name to the returned endpoint.
*
*
*
* In the request, specify the stream either by StreamName or
* StreamARN.
*
*
* @param getDataEndpointRequest
* @return getDataEndpointResult The response from the GetDataEndpoint
* service method, as returned by AWSKinesisVideoFrontend.
* @throws InvalidArgumentException
* @throws ResourceNotFoundException
* @throws ClientLimitExceededException
* @throws NotAuthorizedException
* @throws AmazonClientException If any internal errors are encountered
* inside the client while attempting to make the request or
* handle the response. For example if a network connection is
* not available.
* @throws AmazonServiceException If an error response is returned by
* AWSKinesisVideoFrontend indicating either a problem with the
* data in the request, or a server side issue.
*/
public GetDataEndpointResult getDataEndpoint(GetDataEndpointRequest getDataEndpointRequest)
throws AmazonServiceException, AmazonClientException {
ExecutionContext executionContext = createExecutionContext(getDataEndpointRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new GetDataEndpointRequestMarshaller().marshall(getDataEndpointRequest);
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
Unmarshaller unmarshaller = new GetDataEndpointResultJsonUnmarshaller();
JsonResponseHandler responseHandler = new JsonResponseHandler(
unmarshaller);
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
awsRequestMetrics.endEvent(Field.ClientExecuteTime);
endClientExecution(awsRequestMetrics, request, response, LOGGING_AWS_REQUEST_METRIC);
}
}
/**
*
* Provides an endpoint for the specified signaling channel to send and
* receive messages. This API uses the
* SingleMasterChannelEndpointConfiguration input parameter,
* which consists of the Protocols and Role
* properties.
*
*
* Protocols is used to determine the communication mechanism.
* For example, if you specify WSS as the protocol, this API
* produces a secure websocket endpoint. If you specify HTTPS
* as the protocol, this API generates an HTTPS endpoint.
*
*
* Role determines the messaging permissions. A
* MASTER role results in this API generating an endpoint that
* a client can use to communicate with any of the viewers on the channel. A
* VIEWER role results in this API generating an endpoint that
* a client can use to communicate only with a MASTER.
*
*
* @param getSignalingChannelEndpointRequest
* @return getSignalingChannelEndpointResult The response from the
* GetSignalingChannelEndpoint service method, as returned by
* AWSKinesisVideoFrontend.
* @throws InvalidArgumentException
* @throws ClientLimitExceededException
* @throws ResourceNotFoundException
* @throws ResourceInUseException
* @throws AccessDeniedException
* @throws AmazonClientException If any internal errors are encountered
* inside the client while attempting to make the request or
* handle the response. For example if a network connection is
* not available.
* @throws AmazonServiceException If an error response is returned by
* AWSKinesisVideoFrontend indicating either a problem with the
* data in the request, or a server side issue.
*/
public GetSignalingChannelEndpointResult getSignalingChannelEndpoint(
GetSignalingChannelEndpointRequest getSignalingChannelEndpointRequest)
throws AmazonServiceException, AmazonClientException {
ExecutionContext executionContext = createExecutionContext(getSignalingChannelEndpointRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new GetSignalingChannelEndpointRequestMarshaller()
.marshall(getSignalingChannelEndpointRequest);
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
Unmarshaller unmarshaller = new GetSignalingChannelEndpointResultJsonUnmarshaller();
JsonResponseHandler responseHandler = new JsonResponseHandler(
unmarshaller);
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
awsRequestMetrics.endEvent(Field.ClientExecuteTime);
endClientExecution(awsRequestMetrics, request, response, LOGGING_AWS_REQUEST_METRIC);
}
}
/**
*
* Returns an array of edge configurations associated with the specified
* Edge Agent.
*
*
* In the request, you must specify the Edge Agent HubDeviceArn
* .
*
*
* @param listEdgeAgentConfigurationsRequest
* @return listEdgeAgentConfigurationsResult The response from the
* ListEdgeAgentConfigurations service method, as returned by
* AWSKinesisVideoFrontend.
* @throws NotAuthorizedException
* @throws ClientLimitExceededException
* @throws InvalidArgumentException
* @throws AmazonClientException If any internal errors are encountered
* inside the client while attempting to make the request or
* handle the response. For example if a network connection is
* not available.
* @throws AmazonServiceException If an error response is returned by
* AWSKinesisVideoFrontend indicating either a problem with the
* data in the request, or a server side issue.
*/
public ListEdgeAgentConfigurationsResult listEdgeAgentConfigurations(
ListEdgeAgentConfigurationsRequest listEdgeAgentConfigurationsRequest)
throws AmazonServiceException, AmazonClientException {
ExecutionContext executionContext = createExecutionContext(listEdgeAgentConfigurationsRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new ListEdgeAgentConfigurationsRequestMarshaller()
.marshall(listEdgeAgentConfigurationsRequest);
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
Unmarshaller unmarshaller = new ListEdgeAgentConfigurationsResultJsonUnmarshaller();
JsonResponseHandler responseHandler = new JsonResponseHandler(
unmarshaller);
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
awsRequestMetrics.endEvent(Field.ClientExecuteTime);
endClientExecution(awsRequestMetrics, request, response, LOGGING_AWS_REQUEST_METRIC);
}
}
/**
*
* Returns an array of ChannelInfo objects. Each object
* describes a signaling channel. To retrieve only those channels that
* satisfy a specific condition, you can specify a
* ChannelNameCondition.
*
*
* @param listSignalingChannelsRequest
* @return listSignalingChannelsResult The response from the
* ListSignalingChannels service method, as returned by
* AWSKinesisVideoFrontend.
* @throws InvalidArgumentException
* @throws ClientLimitExceededException
* @throws AccessDeniedException
* @throws AmazonClientException If any internal errors are encountered
* inside the client while attempting to make the request or
* handle the response. For example if a network connection is
* not available.
* @throws AmazonServiceException If an error response is returned by
* AWSKinesisVideoFrontend indicating either a problem with the
* data in the request, or a server side issue.
*/
public ListSignalingChannelsResult listSignalingChannels(
ListSignalingChannelsRequest listSignalingChannelsRequest)
throws AmazonServiceException, AmazonClientException {
ExecutionContext executionContext = createExecutionContext(listSignalingChannelsRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new ListSignalingChannelsRequestMarshaller()
.marshall(listSignalingChannelsRequest);
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
Unmarshaller unmarshaller = new ListSignalingChannelsResultJsonUnmarshaller();
JsonResponseHandler responseHandler = new JsonResponseHandler(
unmarshaller);
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
awsRequestMetrics.endEvent(Field.ClientExecuteTime);
endClientExecution(awsRequestMetrics, request, response, LOGGING_AWS_REQUEST_METRIC);
}
}
/**
*
* Returns an array of StreamInfo objects. Each object
* describes a stream. To retrieve only streams that satisfy a specific
* condition, you can specify a StreamNameCondition.
*
*
* @param listStreamsRequest
* @return listStreamsResult The response from the ListStreams service
* method, as returned by AWSKinesisVideoFrontend.
* @throws ClientLimitExceededException
* @throws InvalidArgumentException
* @throws AmazonClientException If any internal errors are encountered
* inside the client while attempting to make the request or
* handle the response. For example if a network connection is
* not available.
* @throws AmazonServiceException If an error response is returned by
* AWSKinesisVideoFrontend indicating either a problem with the
* data in the request, or a server side issue.
*/
public ListStreamsResult listStreams(ListStreamsRequest listStreamsRequest)
throws AmazonServiceException, AmazonClientException {
ExecutionContext executionContext = createExecutionContext(listStreamsRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new ListStreamsRequestMarshaller().marshall(listStreamsRequest);
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
Unmarshaller unmarshaller = new ListStreamsResultJsonUnmarshaller();
JsonResponseHandler responseHandler = new JsonResponseHandler(
unmarshaller);
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
awsRequestMetrics.endEvent(Field.ClientExecuteTime);
endClientExecution(awsRequestMetrics, request, response, LOGGING_AWS_REQUEST_METRIC);
}
}
/**
*
* Returns a list of tags associated with the specified signaling channel.
*
*
* @param listTagsForResourceRequest
* @return listTagsForResourceResult The response from the
* ListTagsForResource service method, as returned by
* AWSKinesisVideoFrontend.
* @throws InvalidArgumentException
* @throws ClientLimitExceededException
* @throws ResourceNotFoundException
* @throws AccessDeniedException
* @throws AmazonClientException If any internal errors are encountered
* inside the client while attempting to make the request or
* handle the response. For example if a network connection is
* not available.
* @throws AmazonServiceException If an error response is returned by
* AWSKinesisVideoFrontend indicating either a problem with the
* data in the request, or a server side issue.
*/
public ListTagsForResourceResult listTagsForResource(
ListTagsForResourceRequest listTagsForResourceRequest)
throws AmazonServiceException, AmazonClientException {
ExecutionContext executionContext = createExecutionContext(listTagsForResourceRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new ListTagsForResourceRequestMarshaller()
.marshall(listTagsForResourceRequest);
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
Unmarshaller unmarshaller = new ListTagsForResourceResultJsonUnmarshaller();
JsonResponseHandler responseHandler = new JsonResponseHandler(
unmarshaller);
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
awsRequestMetrics.endEvent(Field.ClientExecuteTime);
endClientExecution(awsRequestMetrics, request, response, LOGGING_AWS_REQUEST_METRIC);
}
}
/**
*
* Returns a list of tags associated with the specified stream.
*
*
* In the request, you must specify either the StreamName or
* the StreamARN.
*
*
* @param listTagsForStreamRequest
* @return listTagsForStreamResult The response from the ListTagsForStream
* service method, as returned by AWSKinesisVideoFrontend.
* @throws ClientLimitExceededException
* @throws InvalidArgumentException
* @throws ResourceNotFoundException
* @throws NotAuthorizedException
* @throws InvalidResourceFormatException
* @throws AmazonClientException If any internal errors are encountered
* inside the client while attempting to make the request or
* handle the response. For example if a network connection is
* not available.
* @throws AmazonServiceException If an error response is returned by
* AWSKinesisVideoFrontend indicating either a problem with the
* data in the request, or a server side issue.
*/
public ListTagsForStreamResult listTagsForStream(
ListTagsForStreamRequest listTagsForStreamRequest)
throws AmazonServiceException, AmazonClientException {
ExecutionContext executionContext = createExecutionContext(listTagsForStreamRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new ListTagsForStreamRequestMarshaller()
.marshall(listTagsForStreamRequest);
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
Unmarshaller unmarshaller = new ListTagsForStreamResultJsonUnmarshaller();
JsonResponseHandler responseHandler = new JsonResponseHandler(
unmarshaller);
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
awsRequestMetrics.endEvent(Field.ClientExecuteTime);
endClientExecution(awsRequestMetrics, request, response, LOGGING_AWS_REQUEST_METRIC);
}
}
/**
*
* An asynchronous API that updates a stream’s existing edge configuration.
* The Kinesis Video Stream will sync the stream’s edge configuration with
* the Edge Agent IoT Greengrass component that runs on an IoT Hub Device,
* setup at your premise. The time to sync can vary and depends on the
* connectivity of the Hub Device. The SyncStatus will be
* updated as the edge configuration is acknowledged, and synced with the
* Edge Agent.
*
*
* If this API is invoked for the first time, a new edge configuration will
* be created for the stream, and the sync status will be set to
* SYNCING. You will have to wait for the sync status to reach
* a terminal state such as: IN_SYNC, or
* SYNC_FAILED, before using this API again. If you invoke this
* API during the syncing process, a ResourceInUseException
* will be thrown. The connectivity of the stream’s edge configuration and
* the Edge Agent will be retried for 15 minutes. After 15 minutes, the
* status will transition into the SYNC_FAILED state.
*
*
* @param startEdgeConfigurationUpdateRequest
* @return startEdgeConfigurationUpdateResult The response from the
* StartEdgeConfigurationUpdate service method, as returned by
* AWSKinesisVideoFrontend.
* @throws AccessDeniedException
* @throws ClientLimitExceededException
* @throws InvalidArgumentException
* @throws NoDataRetentionException
* @throws ResourceInUseException
* @throws ResourceNotFoundException
* @throws AmazonClientException If any internal errors are encountered
* inside the client while attempting to make the request or
* handle the response. For example if a network connection is
* not available.
* @throws AmazonServiceException If an error response is returned by
* AWSKinesisVideoFrontend indicating either a problem with the
* data in the request, or a server side issue.
*/
public StartEdgeConfigurationUpdateResult startEdgeConfigurationUpdate(
StartEdgeConfigurationUpdateRequest startEdgeConfigurationUpdateRequest)
throws AmazonServiceException, AmazonClientException {
ExecutionContext executionContext = createExecutionContext(startEdgeConfigurationUpdateRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new StartEdgeConfigurationUpdateRequestMarshaller()
.marshall(startEdgeConfigurationUpdateRequest);
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
Unmarshaller unmarshaller = new StartEdgeConfigurationUpdateResultJsonUnmarshaller();
JsonResponseHandler responseHandler = new JsonResponseHandler(
unmarshaller);
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
awsRequestMetrics.endEvent(Field.ClientExecuteTime);
endClientExecution(awsRequestMetrics, request, response, LOGGING_AWS_REQUEST_METRIC);
}
}
/**
*
* Adds one or more tags to a signaling channel. A tag is a key-value
* pair (the value is optional) that you can define and assign to Amazon Web
* Services resources. If you specify a tag that already exists, the tag
* value is replaced with the value that you specify in the request. For
* more information, see Using Cost Allocation Tags in the Billing and Cost Management and
* Cost Management User Guide.
*
*
* @param tagResourceRequest
* @return tagResourceResult The response from the TagResource service
* method, as returned by AWSKinesisVideoFrontend.
* @throws InvalidArgumentException
* @throws ClientLimitExceededException
* @throws ResourceNotFoundException
* @throws AccessDeniedException
* @throws TagsPerResourceExceededLimitException
* @throws AmazonClientException If any internal errors are encountered
* inside the client while attempting to make the request or
* handle the response. For example if a network connection is
* not available.
* @throws AmazonServiceException If an error response is returned by
* AWSKinesisVideoFrontend indicating either a problem with the
* data in the request, or a server side issue.
*/
public TagResourceResult tagResource(TagResourceRequest tagResourceRequest)
throws AmazonServiceException, AmazonClientException {
ExecutionContext executionContext = createExecutionContext(tagResourceRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new TagResourceRequestMarshaller().marshall(tagResourceRequest);
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
Unmarshaller unmarshaller = new TagResourceResultJsonUnmarshaller();
JsonResponseHandler responseHandler = new JsonResponseHandler(
unmarshaller);
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
awsRequestMetrics.endEvent(Field.ClientExecuteTime);
endClientExecution(awsRequestMetrics, request, response, LOGGING_AWS_REQUEST_METRIC);
}
}
/**
*
* Adds one or more tags to a stream. A tag is a key-value pair (the
* value is optional) that you can define and assign to Amazon Web Services
* resources. If you specify a tag that already exists, the tag value is
* replaced with the value that you specify in the request. For more
* information, see Using Cost Allocation Tags in the Billing and Cost Management and
* Cost Management User Guide.
*
*
* You must provide either the StreamName or the
* StreamARN.
*
*
* This operation requires permission for the
* KinesisVideo:TagStream action.
*
*
* A Kinesis video stream can support up to 50 tags.
*
*
* @param tagStreamRequest
* @return tagStreamResult The response from the TagStream service method,
* as returned by AWSKinesisVideoFrontend.
* @throws ClientLimitExceededException
* @throws InvalidArgumentException
* @throws ResourceNotFoundException
* @throws NotAuthorizedException
* @throws InvalidResourceFormatException
* @throws TagsPerResourceExceededLimitException
* @throws AmazonClientException If any internal errors are encountered
* inside the client while attempting to make the request or
* handle the response. For example if a network connection is
* not available.
* @throws AmazonServiceException If an error response is returned by
* AWSKinesisVideoFrontend indicating either a problem with the
* data in the request, or a server side issue.
*/
public TagStreamResult tagStream(TagStreamRequest tagStreamRequest)
throws AmazonServiceException, AmazonClientException {
ExecutionContext executionContext = createExecutionContext(tagStreamRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new TagStreamRequestMarshaller().marshall(tagStreamRequest);
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
Unmarshaller unmarshaller = new TagStreamResultJsonUnmarshaller();
JsonResponseHandler responseHandler = new JsonResponseHandler(
unmarshaller);
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
awsRequestMetrics.endEvent(Field.ClientExecuteTime);
endClientExecution(awsRequestMetrics, request, response, LOGGING_AWS_REQUEST_METRIC);
}
}
/**
*
* Removes one or more tags from a signaling channel. In the request,
* specify only a tag key or keys; don't specify the value. If you specify a
* tag key that does not exist, it's ignored.
*
*
* @param untagResourceRequest
* @return untagResourceResult The response from the UntagResource service
* method, as returned by AWSKinesisVideoFrontend.
* @throws InvalidArgumentException
* @throws ClientLimitExceededException
* @throws ResourceNotFoundException
* @throws AccessDeniedException
* @throws AmazonClientException If any internal errors are encountered
* inside the client while attempting to make the request or
* handle the response. For example if a network connection is
* not available.
* @throws AmazonServiceException If an error response is returned by
* AWSKinesisVideoFrontend indicating either a problem with the
* data in the request, or a server side issue.
*/
public UntagResourceResult untagResource(UntagResourceRequest untagResourceRequest)
throws AmazonServiceException, AmazonClientException {
ExecutionContext executionContext = createExecutionContext(untagResourceRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new UntagResourceRequestMarshaller().marshall(untagResourceRequest);
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
Unmarshaller unmarshaller = new UntagResourceResultJsonUnmarshaller();
JsonResponseHandler responseHandler = new JsonResponseHandler(
unmarshaller);
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
awsRequestMetrics.endEvent(Field.ClientExecuteTime);
endClientExecution(awsRequestMetrics, request, response, LOGGING_AWS_REQUEST_METRIC);
}
}
/**
*
* Removes one or more tags from a stream. In the request, specify only a
* tag key or keys; don't specify the value. If you specify a tag key that
* does not exist, it's ignored.
*
*
* In the request, you must provide the StreamName or
* StreamARN.
*
*
* @param untagStreamRequest
* @return untagStreamResult The response from the UntagStream service
* method, as returned by AWSKinesisVideoFrontend.
* @throws ClientLimitExceededException
* @throws InvalidArgumentException
* @throws ResourceNotFoundException
* @throws NotAuthorizedException
* @throws InvalidResourceFormatException
* @throws AmazonClientException If any internal errors are encountered
* inside the client while attempting to make the request or
* handle the response. For example if a network connection is
* not available.
* @throws AmazonServiceException If an error response is returned by
* AWSKinesisVideoFrontend indicating either a problem with the
* data in the request, or a server side issue.
*/
public UntagStreamResult untagStream(UntagStreamRequest untagStreamRequest)
throws AmazonServiceException, AmazonClientException {
ExecutionContext executionContext = createExecutionContext(untagStreamRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new UntagStreamRequestMarshaller().marshall(untagStreamRequest);
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
Unmarshaller unmarshaller = new UntagStreamResultJsonUnmarshaller();
JsonResponseHandler responseHandler = new JsonResponseHandler(
unmarshaller);
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
awsRequestMetrics.endEvent(Field.ClientExecuteTime);
endClientExecution(awsRequestMetrics, request, response, LOGGING_AWS_REQUEST_METRIC);
}
}
/**
*
* Increases or decreases the stream's data retention period by the value
* that you specify. To indicate whether you want to increase or decrease
* the data retention period, specify the Operation parameter
* in the request body. In the request, you must specify either the
* StreamName or the StreamARN.
*
*
*
* The retention period that you specify replaces the current value.
*
*
*
* This operation requires permission for the
* KinesisVideo:UpdateDataRetention action.
*
*
* Changing the data retention period affects the data in the stream as
* follows:
*
*
* -
*
* If the data retention period is increased, existing data is retained for
* the new retention period. For example, if the data retention period is
* increased from one hour to seven hours, all existing data is retained for
* seven hours.
*
*
* -
*
* If the data retention period is decreased, existing data is retained for
* the new retention period. For example, if the data retention period is
* decreased from seven hours to one hour, all existing data is retained for
* one hour, and any data older than one hour is deleted immediately.
*
*
*
*
* @param updateDataRetentionRequest
* @return updateDataRetentionResult The response from the
* UpdateDataRetention service method, as returned by
* AWSKinesisVideoFrontend.
* @throws ClientLimitExceededException
* @throws InvalidArgumentException
* @throws ResourceNotFoundException
* @throws ResourceInUseException
* @throws NotAuthorizedException
* @throws VersionMismatchException
* @throws AmazonClientException If any internal errors are encountered
* inside the client while attempting to make the request or
* handle the response. For example if a network connection is
* not available.
* @throws AmazonServiceException If an error response is returned by
* AWSKinesisVideoFrontend indicating either a problem with the
* data in the request, or a server side issue.
*/
public UpdateDataRetentionResult updateDataRetention(
UpdateDataRetentionRequest updateDataRetentionRequest)
throws AmazonServiceException, AmazonClientException {
ExecutionContext executionContext = createExecutionContext(updateDataRetentionRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new UpdateDataRetentionRequestMarshaller()
.marshall(updateDataRetentionRequest);
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
Unmarshaller unmarshaller = new UpdateDataRetentionResultJsonUnmarshaller();
JsonResponseHandler responseHandler = new JsonResponseHandler(
unmarshaller);
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
awsRequestMetrics.endEvent(Field.ClientExecuteTime);
endClientExecution(awsRequestMetrics, request, response, LOGGING_AWS_REQUEST_METRIC);
}
}
/**
*
* Updates the StreamInfo and
* ImageProcessingConfiguration fields.
*
*
* @param updateImageGenerationConfigurationRequest
* @return updateImageGenerationConfigurationResult The response from the
* UpdateImageGenerationConfiguration service method, as returned by
* AWSKinesisVideoFrontend.
* @throws InvalidArgumentException
* @throws ClientLimitExceededException
* @throws ResourceNotFoundException
* @throws AccessDeniedException
* @throws ResourceInUseException
* @throws NoDataRetentionException
* @throws AmazonClientException If any internal errors are encountered
* inside the client while attempting to make the request or
* handle the response. For example if a network connection is
* not available.
* @throws AmazonServiceException If an error response is returned by
* AWSKinesisVideoFrontend indicating either a problem with the
* data in the request, or a server side issue.
*/
public UpdateImageGenerationConfigurationResult updateImageGenerationConfiguration(
UpdateImageGenerationConfigurationRequest updateImageGenerationConfigurationRequest)
throws AmazonServiceException, AmazonClientException {
ExecutionContext executionContext = createExecutionContext(updateImageGenerationConfigurationRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new UpdateImageGenerationConfigurationRequestMarshaller()
.marshall(updateImageGenerationConfigurationRequest);
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
Unmarshaller unmarshaller = new UpdateImageGenerationConfigurationResultJsonUnmarshaller();
JsonResponseHandler responseHandler = new JsonResponseHandler(
unmarshaller);
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
awsRequestMetrics.endEvent(Field.ClientExecuteTime);
endClientExecution(awsRequestMetrics, request, response, LOGGING_AWS_REQUEST_METRIC);
}
}
/**
*
* Associates a SignalingChannel to a stream to store the
* media. There are two signaling modes that can specified :
*
*
* -
*
* If the StorageStatus is disabled, no data will be stored,
* and the StreamARN parameter will not be needed.
*
*
* -
*
* If the StorageStatus is enabled, the data will be stored in
* the StreamARN provided.
*
*
*
*
* @param updateMediaStorageConfigurationRequest
* @return updateMediaStorageConfigurationResult The response from the
* UpdateMediaStorageConfiguration service method, as returned by
* AWSKinesisVideoFrontend.
* @throws ResourceInUseException
* @throws InvalidArgumentException
* @throws ClientLimitExceededException
* @throws ResourceNotFoundException
* @throws AccessDeniedException
* @throws NoDataRetentionException
* @throws AmazonClientException If any internal errors are encountered
* inside the client while attempting to make the request or
* handle the response. For example if a network connection is
* not available.
* @throws AmazonServiceException If an error response is returned by
* AWSKinesisVideoFrontend indicating either a problem with the
* data in the request, or a server side issue.
*/
public UpdateMediaStorageConfigurationResult updateMediaStorageConfiguration(
UpdateMediaStorageConfigurationRequest updateMediaStorageConfigurationRequest)
throws AmazonServiceException, AmazonClientException {
ExecutionContext executionContext = createExecutionContext(updateMediaStorageConfigurationRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new UpdateMediaStorageConfigurationRequestMarshaller()
.marshall(updateMediaStorageConfigurationRequest);
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
Unmarshaller unmarshaller = new UpdateMediaStorageConfigurationResultJsonUnmarshaller();
JsonResponseHandler responseHandler = new JsonResponseHandler(
unmarshaller);
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
awsRequestMetrics.endEvent(Field.ClientExecuteTime);
endClientExecution(awsRequestMetrics, request, response, LOGGING_AWS_REQUEST_METRIC);
}
}
/**
*
* Updates the notification information for a stream.
*
*
* @param updateNotificationConfigurationRequest
* @return updateNotificationConfigurationResult The response from the
* UpdateNotificationConfiguration service method, as returned by
* AWSKinesisVideoFrontend.
* @throws InvalidArgumentException
* @throws ClientLimitExceededException
* @throws ResourceNotFoundException
* @throws AccessDeniedException
* @throws ResourceInUseException
* @throws NoDataRetentionException
* @throws AmazonClientException If any internal errors are encountered
* inside the client while attempting to make the request or
* handle the response. For example if a network connection is
* not available.
* @throws AmazonServiceException If an error response is returned by
* AWSKinesisVideoFrontend indicating either a problem with the
* data in the request, or a server side issue.
*/
public UpdateNotificationConfigurationResult updateNotificationConfiguration(
UpdateNotificationConfigurationRequest updateNotificationConfigurationRequest)
throws AmazonServiceException, AmazonClientException {
ExecutionContext executionContext = createExecutionContext(updateNotificationConfigurationRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new UpdateNotificationConfigurationRequestMarshaller()
.marshall(updateNotificationConfigurationRequest);
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
Unmarshaller unmarshaller = new UpdateNotificationConfigurationResultJsonUnmarshaller();
JsonResponseHandler responseHandler = new JsonResponseHandler(
unmarshaller);
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
awsRequestMetrics.endEvent(Field.ClientExecuteTime);
endClientExecution(awsRequestMetrics, request, response, LOGGING_AWS_REQUEST_METRIC);
}
}
/**
*
* Updates the existing signaling channel. This is an asynchronous operation
* and takes time to complete.
*
*
* If the MessageTtlSeconds value is updated (either increased
* or reduced), it only applies to new messages sent via this channel after
* it's been updated. Existing messages are still expired as per the
* previous MessageTtlSeconds value.
*
*
* @param updateSignalingChannelRequest
* @return updateSignalingChannelResult The response from the
* UpdateSignalingChannel service method, as returned by
* AWSKinesisVideoFrontend.
* @throws InvalidArgumentException
* @throws ClientLimitExceededException
* @throws ResourceNotFoundException
* @throws ResourceInUseException
* @throws AccessDeniedException
* @throws VersionMismatchException
* @throws AmazonClientException If any internal errors are encountered
* inside the client while attempting to make the request or
* handle the response. For example if a network connection is
* not available.
* @throws AmazonServiceException If an error response is returned by
* AWSKinesisVideoFrontend indicating either a problem with the
* data in the request, or a server side issue.
*/
public UpdateSignalingChannelResult updateSignalingChannel(
UpdateSignalingChannelRequest updateSignalingChannelRequest)
throws AmazonServiceException, AmazonClientException {
ExecutionContext executionContext = createExecutionContext(updateSignalingChannelRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new UpdateSignalingChannelRequestMarshaller()
.marshall(updateSignalingChannelRequest);
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
Unmarshaller unmarshaller = new UpdateSignalingChannelResultJsonUnmarshaller();
JsonResponseHandler responseHandler = new JsonResponseHandler(
unmarshaller);
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
awsRequestMetrics.endEvent(Field.ClientExecuteTime);
endClientExecution(awsRequestMetrics, request, response, LOGGING_AWS_REQUEST_METRIC);
}
}
/**
*
* Updates stream metadata, such as the device name and media type.
*
*
* You must provide the stream name or the Amazon Resource Name (ARN) of the
* stream.
*
*
* To make sure that you have the latest version of the stream before
* updating it, you can specify the stream version. Kinesis Video Streams
* assigns a version to each stream. When you update a stream, Kinesis Video
* Streams assigns a new version number. To get the latest stream version,
* use the DescribeStream API.
*
*
* UpdateStream is an asynchronous operation, and takes time to
* complete.
*
*
* @param updateStreamRequest
* @return updateStreamResult The response from the UpdateStream service
* method, as returned by AWSKinesisVideoFrontend.
* @throws ClientLimitExceededException
* @throws InvalidArgumentException
* @throws ResourceNotFoundException
* @throws ResourceInUseException
* @throws NotAuthorizedException
* @throws VersionMismatchException
* @throws AmazonClientException If any internal errors are encountered
* inside the client while attempting to make the request or
* handle the response. For example if a network connection is
* not available.
* @throws AmazonServiceException If an error response is returned by
* AWSKinesisVideoFrontend indicating either a problem with the
* data in the request, or a server side issue.
*/
public UpdateStreamResult updateStream(UpdateStreamRequest updateStreamRequest)
throws AmazonServiceException, AmazonClientException {
ExecutionContext executionContext = createExecutionContext(updateStreamRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new UpdateStreamRequestMarshaller().marshall(updateStreamRequest);
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
Unmarshaller unmarshaller = new UpdateStreamResultJsonUnmarshaller();
JsonResponseHandler responseHandler = new JsonResponseHandler(
unmarshaller);
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
awsRequestMetrics.endEvent(Field.ClientExecuteTime);
endClientExecution(awsRequestMetrics, request, response, LOGGING_AWS_REQUEST_METRIC);
}
}
/**
* Returns additional metadata for a previously executed successful,
* request, typically used for debugging issues where a service isn't acting
* as expected. This data isn't considered part of the result data returned
* by an operation, so it's available through this separate, diagnostic
* interface.
*
* Response metadata is only cached for a limited period of time, so if you
* need to access this extra diagnostic information for an executed request,
* you should use this method to retrieve it as soon as possible after
* executing the request.
*
* @param request The originally executed request
* @return The response metadata for the specified request, or null if none
* is available.
* @deprecated ResponseMetadata cache can hold up to 50 requests and
* responses in memory and will cause memory issue. This method
* now always returns null.
*/
@Deprecated
public ResponseMetadata getCachedResponseMetadata(AmazonWebServiceRequest request) {
return client.getResponseMetadataForRequest(request);
}
private Response invoke(Request request,
HttpResponseHandler> responseHandler,
ExecutionContext executionContext) {
request.setEndpoint(endpoint);
request.setTimeOffset(timeOffset);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
AWSCredentials credentials;
awsRequestMetrics.startEvent(Field.CredentialsRequestTime);
try {
credentials = awsCredentialsProvider.getCredentials();
} finally {
awsRequestMetrics.endEvent(Field.CredentialsRequestTime);
}
AmazonWebServiceRequest originalRequest = request.getOriginalRequest();
if (originalRequest != null && originalRequest.getRequestCredentials() != null) {
credentials = originalRequest.getRequestCredentials();
}
executionContext.setCredentials(credentials);
JsonErrorResponseHandler errorResponseHandler = new JsonErrorResponseHandler(
jsonErrorUnmarshallers);
Response result = client.execute(request, responseHandler,
errorResponseHandler, executionContext);
return result;
}
}