/* * 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.kinesisvideo; import org.w3c.dom.*; import java.net.*; import java.util.*; import javax.annotation.Generated; import org.apache.commons.logging.*; import com.amazonaws.*; import com.amazonaws.annotation.SdkInternalApi; import com.amazonaws.auth.*; import com.amazonaws.handlers.*; import com.amazonaws.http.*; import com.amazonaws.internal.*; import com.amazonaws.internal.auth.*; import com.amazonaws.metrics.*; import com.amazonaws.regions.*; import com.amazonaws.transform.*; import com.amazonaws.util.*; import com.amazonaws.protocol.json.*; import com.amazonaws.util.AWSRequestMetrics.Field; import com.amazonaws.annotation.ThreadSafe; import com.amazonaws.client.AwsSyncClientParams; import com.amazonaws.client.builder.AdvancedConfig; import com.amazonaws.services.kinesisvideo.AmazonKinesisVideoClientBuilder; import com.amazonaws.AmazonServiceException; import com.amazonaws.services.kinesisvideo.model.*; import com.amazonaws.services.kinesisvideo.model.transform.*; /** * Client for accessing Kinesis Video. All service calls made using this client are blocking, and will not return until * the service call completes. *

*

*/ @ThreadSafe @Generated("com.amazonaws:aws-java-sdk-code-generator") public class AmazonKinesisVideoClient extends AmazonWebServiceClient implements AmazonKinesisVideo { /** Provider for AWS credentials. */ private final AWSCredentialsProvider awsCredentialsProvider; private static final Log log = LogFactory.getLog(AmazonKinesisVideo.class); /** Default signing name for the service. */ private static final String DEFAULT_SIGNING_NAME = "kinesisvideo"; /** Client configuration factory providing ClientConfigurations tailored to this client */ protected static final ClientConfigurationFactory configFactory = new ClientConfigurationFactory(); private final AdvancedConfig advancedConfig; private static final com.amazonaws.protocol.json.SdkJsonProtocolFactory protocolFactory = new com.amazonaws.protocol.json.SdkJsonProtocolFactory( new JsonClientMetadata() .withProtocolVersion("1.1") .withSupportsCbor(false) .withSupportsIon(false) .withContentTypeOverride("application/json") .addErrorMetadata( new JsonErrorShapeMetadata().withErrorCode("AccountStreamLimitExceededException").withExceptionUnmarshaller( com.amazonaws.services.kinesisvideo.model.transform.AccountStreamLimitExceededExceptionUnmarshaller.getInstance())) .addErrorMetadata( new JsonErrorShapeMetadata().withErrorCode("ResourceInUseException").withExceptionUnmarshaller( com.amazonaws.services.kinesisvideo.model.transform.ResourceInUseExceptionUnmarshaller.getInstance())) .addErrorMetadata( new JsonErrorShapeMetadata().withErrorCode("VersionMismatchException").withExceptionUnmarshaller( com.amazonaws.services.kinesisvideo.model.transform.VersionMismatchExceptionUnmarshaller.getInstance())) .addErrorMetadata( new JsonErrorShapeMetadata().withErrorCode("AccountChannelLimitExceededException").withExceptionUnmarshaller( com.amazonaws.services.kinesisvideo.model.transform.AccountChannelLimitExceededExceptionUnmarshaller.getInstance())) .addErrorMetadata( new JsonErrorShapeMetadata().withErrorCode("ClientLimitExceededException").withExceptionUnmarshaller( com.amazonaws.services.kinesisvideo.model.transform.ClientLimitExceededExceptionUnmarshaller.getInstance())) .addErrorMetadata( new JsonErrorShapeMetadata().withErrorCode("StreamEdgeConfigurationNotFoundException").withExceptionUnmarshaller( com.amazonaws.services.kinesisvideo.model.transform.StreamEdgeConfigurationNotFoundExceptionUnmarshaller.getInstance())) .addErrorMetadata( new JsonErrorShapeMetadata().withErrorCode("InvalidResourceFormatException").withExceptionUnmarshaller( com.amazonaws.services.kinesisvideo.model.transform.InvalidResourceFormatExceptionUnmarshaller.getInstance())) .addErrorMetadata( new JsonErrorShapeMetadata().withErrorCode("AccessDeniedException").withExceptionUnmarshaller( com.amazonaws.services.kinesisvideo.model.transform.AccessDeniedExceptionUnmarshaller.getInstance())) .addErrorMetadata( new JsonErrorShapeMetadata().withErrorCode("InvalidArgumentException").withExceptionUnmarshaller( com.amazonaws.services.kinesisvideo.model.transform.InvalidArgumentExceptionUnmarshaller.getInstance())) .addErrorMetadata( new JsonErrorShapeMetadata().withErrorCode("NoDataRetentionException").withExceptionUnmarshaller( com.amazonaws.services.kinesisvideo.model.transform.NoDataRetentionExceptionUnmarshaller.getInstance())) .addErrorMetadata( new JsonErrorShapeMetadata().withErrorCode("ResourceNotFoundException").withExceptionUnmarshaller( com.amazonaws.services.kinesisvideo.model.transform.ResourceNotFoundExceptionUnmarshaller.getInstance())) .addErrorMetadata( new JsonErrorShapeMetadata().withErrorCode("InvalidDeviceException").withExceptionUnmarshaller( com.amazonaws.services.kinesisvideo.model.transform.InvalidDeviceExceptionUnmarshaller.getInstance())) .addErrorMetadata( new JsonErrorShapeMetadata().withErrorCode("TagsPerResourceExceededLimitException").withExceptionUnmarshaller( com.amazonaws.services.kinesisvideo.model.transform.TagsPerResourceExceededLimitExceptionUnmarshaller.getInstance())) .addErrorMetadata( new JsonErrorShapeMetadata().withErrorCode("DeviceStreamLimitExceededException").withExceptionUnmarshaller( com.amazonaws.services.kinesisvideo.model.transform.DeviceStreamLimitExceededExceptionUnmarshaller.getInstance())) .addErrorMetadata( new JsonErrorShapeMetadata().withErrorCode("NotAuthorizedException").withExceptionUnmarshaller( com.amazonaws.services.kinesisvideo.model.transform.NotAuthorizedExceptionUnmarshaller.getInstance())) .withBaseServiceExceptionClass(com.amazonaws.services.kinesisvideo.model.AmazonKinesisVideoException.class)); public static AmazonKinesisVideoClientBuilder builder() { return AmazonKinesisVideoClientBuilder.standard(); } /** * Constructs a new client to invoke service methods on Kinesis Video using the specified parameters. * *

* All service calls made using this new client object are blocking, and will not return until the service call * completes. * * @param clientParams * Object providing client parameters. */ AmazonKinesisVideoClient(AwsSyncClientParams clientParams) { this(clientParams, false); } /** * Constructs a new client to invoke service methods on Kinesis Video using the specified parameters. * *

* All service calls made using this new client object are blocking, and will not return until the service call * completes. * * @param clientParams * Object providing client parameters. */ AmazonKinesisVideoClient(AwsSyncClientParams clientParams, boolean endpointDiscoveryEnabled) { super(clientParams); this.awsCredentialsProvider = clientParams.getCredentialsProvider(); this.advancedConfig = clientParams.getAdvancedConfig(); init(); } private void init() { setServiceNameIntern(DEFAULT_SIGNING_NAME); setEndpointPrefix(ENDPOINT_PREFIX); // calling this.setEndPoint(...) will also modify the signer accordingly setEndpoint("kinesisvideo.us-east-1.amazonaws.com"); HandlerChainFactory chainFactory = new HandlerChainFactory(); requestHandler2s.addAll(chainFactory.newRequestHandlerChain("/com/amazonaws/services/kinesisvideo/request.handlers")); requestHandler2s.addAll(chainFactory.newRequestHandler2Chain("/com/amazonaws/services/kinesisvideo/request.handler2s")); requestHandler2s.addAll(chainFactory.getGlobalHandlers()); } /** *

* Creates a signaling channel. *

*

* CreateSignalingChannel is an asynchronous operation. *

* * @param createSignalingChannelRequest * @return Result of the CreateSignalingChannel operation returned by the service. * @throws InvalidArgumentException * The value for this input parameter is invalid. * @throws ClientLimitExceededException * Kinesis Video Streams has throttled the request because you have exceeded the limit of allowed client * calls. Try making the call later. * @throws AccountChannelLimitExceededException * You have reached the maximum limit of active signaling channels for this Amazon Web Services account in * this region. * @throws ResourceInUseException * When the input StreamARN or ChannelARN in CLOUD_STORAGE_MODE is * already mapped to a different Kinesis Video Stream resource, or if the provided input * StreamARN or ChannelARN is not in Active status, try one of the following : *

*
    *
  1. *

    * The DescribeMediaStorageConfiguration API to determine what the stream given channel is * mapped to. *

    *
    2. *
  2. *

    * The DescribeMappedResourceConfiguration API to determine the channel that the given stream * is mapped to. *

    *
    3. *
  3. *

    * The DescribeStream or DescribeSignalingChannel API to determine the status of * the resource. *

    *
    4. * @throws AccessDeniedException * You do not have required permissions to perform this operation. * @throws TagsPerResourceExceededLimitException * You have exceeded the limit of tags that you can associate with the resource. A Kinesis video stream can * support up to 50 tags. * @sample AmazonKinesisVideo.CreateSignalingChannel * @see AWS API Documentation */ @Override public CreateSignalingChannelResult createSignalingChannel(CreateSignalingChannelRequest request) { request = beforeClientExecution(request); return executeCreateSignalingChannel(request); } @SdkInternalApi final CreateSignalingChannelResult executeCreateSignalingChannel(CreateSignalingChannelRequest createSignalingChannelRequest) { 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 CreateSignalingChannelRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(createSignalingChannelRequest)); // Binds the request metrics to the current request. request.setAWSRequestMetrics(awsRequestMetrics); request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint); request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden()); request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion()); request.addHandlerContext(HandlerContextKey.SERVICE_ID, "Kinesis Video"); request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "CreateSignalingChannel"); request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig); } finally { awsRequestMetrics.endEvent(Field.RequestMarshallTime); } HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler( new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new CreateSignalingChannelResultJsonUnmarshaller()); response = invoke(request, responseHandler, executionContext); return response.getAwsResponse(); } finally { endClientExecution(awsRequestMetrics, request, response); } } /** *

    * 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 Result of the CreateStream operation returned by the service. * @throws AccountStreamLimitExceededException * The number of streams created for the account is too high. * @throws DeviceStreamLimitExceededException * Not implemented. * @throws ResourceInUseException * When the input StreamARN or ChannelARN in CLOUD_STORAGE_MODE is * already mapped to a different Kinesis Video Stream resource, or if the provided input * StreamARN or ChannelARN is not in Active status, try one of the following : *

    *
      *
    1. *

      * The DescribeMediaStorageConfiguration API to determine what the stream given channel is * mapped to. *

      *
      2. *
    2. *

      * The DescribeMappedResourceConfiguration API to determine the channel that the given stream * is mapped to. *

      *
      3. *
    3. *

      * The DescribeStream or DescribeSignalingChannel API to determine the status of * the resource. *

      *
      4. * @throws InvalidDeviceException * Not implemented. * @throws InvalidArgumentException * The value for this input parameter is invalid. * @throws ClientLimitExceededException * Kinesis Video Streams has throttled the request because you have exceeded the limit of allowed client * calls. Try making the call later. * @throws TagsPerResourceExceededLimitException * You have exceeded the limit of tags that you can associate with the resource. A Kinesis video stream can * support up to 50 tags. * @sample AmazonKinesisVideo.CreateStream * @see AWS API * Documentation */ @Override public CreateStreamResult createStream(CreateStreamRequest request) { request = beforeClientExecution(request); return executeCreateStream(request); } @SdkInternalApi final CreateStreamResult executeCreateStream(CreateStreamRequest createStreamRequest) { 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 CreateStreamRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(createStreamRequest)); // Binds the request metrics to the current request. request.setAWSRequestMetrics(awsRequestMetrics); request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint); request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden()); request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion()); request.addHandlerContext(HandlerContextKey.SERVICE_ID, "Kinesis Video"); request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "CreateStream"); request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig); } finally { awsRequestMetrics.endEvent(Field.RequestMarshallTime); } HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler( new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new CreateStreamResultJsonUnmarshaller()); response = invoke(request, responseHandler, executionContext); return response.getAwsResponse(); } finally { endClientExecution(awsRequestMetrics, request, response); } } /** *

      * 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 Result of the DeleteEdgeConfiguration operation returned by the service. * @throws AccessDeniedException * You do not have required permissions to perform this operation. * @throws ClientLimitExceededException * Kinesis Video Streams has throttled the request because you have exceeded the limit of allowed client * calls. Try making the call later. * @throws InvalidArgumentException * The value for this input parameter is invalid. * @throws ResourceNotFoundException * Amazon Kinesis Video Streams can't find the stream that you specified. * @throws StreamEdgeConfigurationNotFoundException * The Exception rendered when the Amazon Kinesis Video Stream can't find a stream's edge configuration that * you specified. * @sample AmazonKinesisVideo.DeleteEdgeConfiguration * @see AWS API Documentation */ @Override public DeleteEdgeConfigurationResult deleteEdgeConfiguration(DeleteEdgeConfigurationRequest request) { request = beforeClientExecution(request); return executeDeleteEdgeConfiguration(request); } @SdkInternalApi final DeleteEdgeConfigurationResult executeDeleteEdgeConfiguration(DeleteEdgeConfigurationRequest deleteEdgeConfigurationRequest) { 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 DeleteEdgeConfigurationRequestProtocolMarshaller(protocolFactory).marshall(super .beforeMarshalling(deleteEdgeConfigurationRequest)); // Binds the request metrics to the current request. request.setAWSRequestMetrics(awsRequestMetrics); request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint); request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden()); request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion()); request.addHandlerContext(HandlerContextKey.SERVICE_ID, "Kinesis Video"); request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DeleteEdgeConfiguration"); request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig); } finally { awsRequestMetrics.endEvent(Field.RequestMarshallTime); } HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler( new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new DeleteEdgeConfigurationResultJsonUnmarshaller()); response = invoke(request, responseHandler, executionContext); return response.getAwsResponse(); } finally { endClientExecution(awsRequestMetrics, request, response); } } /** *

      * 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 Result of the DeleteSignalingChannel operation returned by the service. * @throws InvalidArgumentException * The value for this input parameter is invalid. * @throws ClientLimitExceededException * Kinesis Video Streams has throttled the request because you have exceeded the limit of allowed client * calls. Try making the call later. * @throws ResourceNotFoundException * Amazon Kinesis Video Streams can't find the stream that you specified. * @throws AccessDeniedException * You do not have required permissions to perform this operation. * @throws VersionMismatchException * The stream version that you specified is not the latest version. To get the latest version, use the DescribeStream * API. * @throws ResourceInUseException * When the input StreamARN or ChannelARN in CLOUD_STORAGE_MODE is * already mapped to a different Kinesis Video Stream resource, or if the provided input * StreamARN or ChannelARN is not in Active status, try one of the following : *

      *
        *
      1. *

        * The DescribeMediaStorageConfiguration API to determine what the stream given channel is * mapped to. *

        *
        2. *
      2. *

        * The DescribeMappedResourceConfiguration API to determine the channel that the given stream * is mapped to. *

        *
        3. *
      3. *

        * The DescribeStream or DescribeSignalingChannel API to determine the status of * the resource. *

        *
        4. * @sample AmazonKinesisVideo.DeleteSignalingChannel * @see AWS API Documentation */ @Override public DeleteSignalingChannelResult deleteSignalingChannel(DeleteSignalingChannelRequest request) { request = beforeClientExecution(request); return executeDeleteSignalingChannel(request); } @SdkInternalApi final DeleteSignalingChannelResult executeDeleteSignalingChannel(DeleteSignalingChannelRequest deleteSignalingChannelRequest) { 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 DeleteSignalingChannelRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(deleteSignalingChannelRequest)); // Binds the request metrics to the current request. request.setAWSRequestMetrics(awsRequestMetrics); request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint); request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden()); request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion()); request.addHandlerContext(HandlerContextKey.SERVICE_ID, "Kinesis Video"); request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DeleteSignalingChannel"); request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig); } finally { awsRequestMetrics.endEvent(Field.RequestMarshallTime); } HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler( new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new DeleteSignalingChannelResultJsonUnmarshaller()); response = invoke(request, responseHandler, executionContext); return response.getAwsResponse(); } finally { endClientExecution(awsRequestMetrics, request, response); } } /** *

        * 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 Result of the DeleteStream operation returned by the service. * @throws ClientLimitExceededException * Kinesis Video Streams has throttled the request because you have exceeded the limit of allowed client * calls. Try making the call later. * @throws InvalidArgumentException * The value for this input parameter is invalid. * @throws ResourceNotFoundException * Amazon Kinesis Video Streams can't find the stream that you specified. * @throws NotAuthorizedException * The caller is not authorized to perform this operation. * @throws VersionMismatchException * The stream version that you specified is not the latest version. To get the latest version, use the DescribeStream * API. * @throws ResourceInUseException * When the input StreamARN or ChannelARN in CLOUD_STORAGE_MODE is * already mapped to a different Kinesis Video Stream resource, or if the provided input * StreamARN or ChannelARN is not in Active status, try one of the following : *

        *
          *
        1. *

          * The DescribeMediaStorageConfiguration API to determine what the stream given channel is * mapped to. *

          *
          2. *
        2. *

          * The DescribeMappedResourceConfiguration API to determine the channel that the given stream * is mapped to. *

          *
          3. *
        3. *

          * The DescribeStream or DescribeSignalingChannel API to determine the status of * the resource. *

          *
          4. * @sample AmazonKinesisVideo.DeleteStream * @see AWS API * Documentation */ @Override public DeleteStreamResult deleteStream(DeleteStreamRequest request) { request = beforeClientExecution(request); return executeDeleteStream(request); } @SdkInternalApi final DeleteStreamResult executeDeleteStream(DeleteStreamRequest deleteStreamRequest) { 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 DeleteStreamRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(deleteStreamRequest)); // Binds the request metrics to the current request. request.setAWSRequestMetrics(awsRequestMetrics); request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint); request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden()); request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion()); request.addHandlerContext(HandlerContextKey.SERVICE_ID, "Kinesis Video"); request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DeleteStream"); request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig); } finally { awsRequestMetrics.endEvent(Field.RequestMarshallTime); } HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler( new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new DeleteStreamResultJsonUnmarshaller()); response = invoke(request, responseHandler, executionContext); return response.getAwsResponse(); } finally { endClientExecution(awsRequestMetrics, request, response); } } /** *

          * 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 Result of the DescribeEdgeConfiguration operation returned by the service. * @throws AccessDeniedException * You do not have required permissions to perform this operation. * @throws ClientLimitExceededException * Kinesis Video Streams has throttled the request because you have exceeded the limit of allowed client * calls. Try making the call later. * @throws InvalidArgumentException * The value for this input parameter is invalid. * @throws ResourceNotFoundException * Amazon Kinesis Video Streams can't find the stream that you specified. * @throws StreamEdgeConfigurationNotFoundException * The Exception rendered when the Amazon Kinesis Video Stream can't find a stream's edge configuration that * you specified. * @sample AmazonKinesisVideo.DescribeEdgeConfiguration * @see AWS API Documentation */ @Override public DescribeEdgeConfigurationResult describeEdgeConfiguration(DescribeEdgeConfigurationRequest request) { request = beforeClientExecution(request); return executeDescribeEdgeConfiguration(request); } @SdkInternalApi final DescribeEdgeConfigurationResult executeDescribeEdgeConfiguration(DescribeEdgeConfigurationRequest describeEdgeConfigurationRequest) { 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 DescribeEdgeConfigurationRequestProtocolMarshaller(protocolFactory).marshall(super .beforeMarshalling(describeEdgeConfigurationRequest)); // Binds the request metrics to the current request. request.setAWSRequestMetrics(awsRequestMetrics); request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint); request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden()); request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion()); request.addHandlerContext(HandlerContextKey.SERVICE_ID, "Kinesis Video"); request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DescribeEdgeConfiguration"); request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig); } finally { awsRequestMetrics.endEvent(Field.RequestMarshallTime); } HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler( new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new DescribeEdgeConfigurationResultJsonUnmarshaller()); response = invoke(request, responseHandler, executionContext); return response.getAwsResponse(); } finally { endClientExecution(awsRequestMetrics, request, response); } } /** *

          * Gets the ImageGenerationConfiguration for a given Kinesis video stream. *

          * * @param describeImageGenerationConfigurationRequest * @return Result of the DescribeImageGenerationConfiguration operation returned by the service. * @throws InvalidArgumentException * The value for this input parameter is invalid. * @throws ClientLimitExceededException * Kinesis Video Streams has throttled the request because you have exceeded the limit of allowed client * calls. Try making the call later. * @throws ResourceNotFoundException * Amazon Kinesis Video Streams can't find the stream that you specified. * @throws AccessDeniedException * You do not have required permissions to perform this operation. * @sample AmazonKinesisVideo.DescribeImageGenerationConfiguration * @see AWS API Documentation */ @Override public DescribeImageGenerationConfigurationResult describeImageGenerationConfiguration(DescribeImageGenerationConfigurationRequest request) { request = beforeClientExecution(request); return executeDescribeImageGenerationConfiguration(request); } @SdkInternalApi final DescribeImageGenerationConfigurationResult executeDescribeImageGenerationConfiguration( DescribeImageGenerationConfigurationRequest describeImageGenerationConfigurationRequest) { 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 DescribeImageGenerationConfigurationRequestProtocolMarshaller(protocolFactory).marshall(super .beforeMarshalling(describeImageGenerationConfigurationRequest)); // Binds the request metrics to the current request. request.setAWSRequestMetrics(awsRequestMetrics); request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint); request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden()); request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion()); request.addHandlerContext(HandlerContextKey.SERVICE_ID, "Kinesis Video"); request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DescribeImageGenerationConfiguration"); request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig); } finally { awsRequestMetrics.endEvent(Field.RequestMarshallTime); } HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler( new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new DescribeImageGenerationConfigurationResultJsonUnmarshaller()); response = invoke(request, responseHandler, executionContext); return response.getAwsResponse(); } finally { endClientExecution(awsRequestMetrics, request, response); } } /** *

          * Returns the most current information about the stream. The streamName or streamARN * should be provided in the input. *

          * * @param describeMappedResourceConfigurationRequest * @return Result of the DescribeMappedResourceConfiguration operation returned by the service. * @throws ResourceNotFoundException * Amazon Kinesis Video Streams can't find the stream that you specified. * @throws InvalidArgumentException * The value for this input parameter is invalid. * @throws AccessDeniedException * You do not have required permissions to perform this operation. * @throws ClientLimitExceededException * Kinesis Video Streams has throttled the request because you have exceeded the limit of allowed client * calls. Try making the call later. * @sample AmazonKinesisVideo.DescribeMappedResourceConfiguration * @see AWS API Documentation */ @Override public DescribeMappedResourceConfigurationResult describeMappedResourceConfiguration(DescribeMappedResourceConfigurationRequest request) { request = beforeClientExecution(request); return executeDescribeMappedResourceConfiguration(request); } @SdkInternalApi final DescribeMappedResourceConfigurationResult executeDescribeMappedResourceConfiguration( DescribeMappedResourceConfigurationRequest describeMappedResourceConfigurationRequest) { 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 DescribeMappedResourceConfigurationRequestProtocolMarshaller(protocolFactory).marshall(super .beforeMarshalling(describeMappedResourceConfigurationRequest)); // Binds the request metrics to the current request. request.setAWSRequestMetrics(awsRequestMetrics); request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint); request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden()); request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion()); request.addHandlerContext(HandlerContextKey.SERVICE_ID, "Kinesis Video"); request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DescribeMappedResourceConfiguration"); request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig); } finally { awsRequestMetrics.endEvent(Field.RequestMarshallTime); } HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler( new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new DescribeMappedResourceConfigurationResultJsonUnmarshaller()); response = invoke(request, responseHandler, executionContext); return response.getAwsResponse(); } finally { endClientExecution(awsRequestMetrics, request, response); } } /** *

          * Returns the most current information about the channel. Specify the ChannelName or * ChannelARN in the input. *

          * * @param describeMediaStorageConfigurationRequest * @return Result of the DescribeMediaStorageConfiguration operation returned by the service. * @throws ResourceNotFoundException * Amazon Kinesis Video Streams can't find the stream that you specified. * @throws InvalidArgumentException * The value for this input parameter is invalid. * @throws AccessDeniedException * You do not have required permissions to perform this operation. * @throws ClientLimitExceededException * Kinesis Video Streams has throttled the request because you have exceeded the limit of allowed client * calls. Try making the call later. * @sample AmazonKinesisVideo.DescribeMediaStorageConfiguration * @see AWS API Documentation */ @Override public DescribeMediaStorageConfigurationResult describeMediaStorageConfiguration(DescribeMediaStorageConfigurationRequest request) { request = beforeClientExecution(request); return executeDescribeMediaStorageConfiguration(request); } @SdkInternalApi final DescribeMediaStorageConfigurationResult executeDescribeMediaStorageConfiguration( DescribeMediaStorageConfigurationRequest describeMediaStorageConfigurationRequest) { 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 DescribeMediaStorageConfigurationRequestProtocolMarshaller(protocolFactory).marshall(super .beforeMarshalling(describeMediaStorageConfigurationRequest)); // Binds the request metrics to the current request. request.setAWSRequestMetrics(awsRequestMetrics); request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint); request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden()); request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion()); request.addHandlerContext(HandlerContextKey.SERVICE_ID, "Kinesis Video"); request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DescribeMediaStorageConfiguration"); request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig); } finally { awsRequestMetrics.endEvent(Field.RequestMarshallTime); } HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler( new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new DescribeMediaStorageConfigurationResultJsonUnmarshaller()); response = invoke(request, responseHandler, executionContext); return response.getAwsResponse(); } finally { endClientExecution(awsRequestMetrics, request, response); } } /** *

          * Gets the NotificationConfiguration for a given Kinesis video stream. *

          * * @param describeNotificationConfigurationRequest * @return Result of the DescribeNotificationConfiguration operation returned by the service. * @throws InvalidArgumentException * The value for this input parameter is invalid. * @throws ClientLimitExceededException * Kinesis Video Streams has throttled the request because you have exceeded the limit of allowed client * calls. Try making the call later. * @throws ResourceNotFoundException * Amazon Kinesis Video Streams can't find the stream that you specified. * @throws AccessDeniedException * You do not have required permissions to perform this operation. * @sample AmazonKinesisVideo.DescribeNotificationConfiguration * @see AWS API Documentation */ @Override public DescribeNotificationConfigurationResult describeNotificationConfiguration(DescribeNotificationConfigurationRequest request) { request = beforeClientExecution(request); return executeDescribeNotificationConfiguration(request); } @SdkInternalApi final DescribeNotificationConfigurationResult executeDescribeNotificationConfiguration( DescribeNotificationConfigurationRequest describeNotificationConfigurationRequest) { 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 DescribeNotificationConfigurationRequestProtocolMarshaller(protocolFactory).marshall(super .beforeMarshalling(describeNotificationConfigurationRequest)); // Binds the request metrics to the current request. request.setAWSRequestMetrics(awsRequestMetrics); request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint); request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden()); request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion()); request.addHandlerContext(HandlerContextKey.SERVICE_ID, "Kinesis Video"); request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DescribeNotificationConfiguration"); request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig); } finally { awsRequestMetrics.endEvent(Field.RequestMarshallTime); } HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler( new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new DescribeNotificationConfigurationResultJsonUnmarshaller()); response = invoke(request, responseHandler, executionContext); return response.getAwsResponse(); } finally { endClientExecution(awsRequestMetrics, request, response); } } /** *

          * 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 Result of the DescribeSignalingChannel operation returned by the service. * @throws InvalidArgumentException * The value for this input parameter is invalid. * @throws ClientLimitExceededException * Kinesis Video Streams has throttled the request because you have exceeded the limit of allowed client * calls. Try making the call later. * @throws ResourceNotFoundException * Amazon Kinesis Video Streams can't find the stream that you specified. * @throws AccessDeniedException * You do not have required permissions to perform this operation. * @sample AmazonKinesisVideo.DescribeSignalingChannel * @see AWS API Documentation */ @Override public DescribeSignalingChannelResult describeSignalingChannel(DescribeSignalingChannelRequest request) { request = beforeClientExecution(request); return executeDescribeSignalingChannel(request); } @SdkInternalApi final DescribeSignalingChannelResult executeDescribeSignalingChannel(DescribeSignalingChannelRequest describeSignalingChannelRequest) { 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 DescribeSignalingChannelRequestProtocolMarshaller(protocolFactory).marshall(super .beforeMarshalling(describeSignalingChannelRequest)); // Binds the request metrics to the current request. request.setAWSRequestMetrics(awsRequestMetrics); request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint); request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden()); request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion()); request.addHandlerContext(HandlerContextKey.SERVICE_ID, "Kinesis Video"); request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DescribeSignalingChannel"); request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig); } finally { awsRequestMetrics.endEvent(Field.RequestMarshallTime); } HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler( new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new DescribeSignalingChannelResultJsonUnmarshaller()); response = invoke(request, responseHandler, executionContext); return response.getAwsResponse(); } finally { endClientExecution(awsRequestMetrics, request, response); } } /** *

          * Returns the most current information about the specified stream. You must specify either the * StreamName or the StreamARN. *

          * * @param describeStreamRequest * @return Result of the DescribeStream operation returned by the service. * @throws InvalidArgumentException * The value for this input parameter is invalid. * @throws ResourceNotFoundException * Amazon Kinesis Video Streams can't find the stream that you specified. * @throws ClientLimitExceededException * Kinesis Video Streams has throttled the request because you have exceeded the limit of allowed client * calls. Try making the call later. * @throws NotAuthorizedException * The caller is not authorized to perform this operation. * @sample AmazonKinesisVideo.DescribeStream * @see AWS * API Documentation */ @Override public DescribeStreamResult describeStream(DescribeStreamRequest request) { request = beforeClientExecution(request); return executeDescribeStream(request); } @SdkInternalApi final DescribeStreamResult executeDescribeStream(DescribeStreamRequest describeStreamRequest) { 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 DescribeStreamRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(describeStreamRequest)); // Binds the request metrics to the current request. request.setAWSRequestMetrics(awsRequestMetrics); request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint); request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden()); request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion()); request.addHandlerContext(HandlerContextKey.SERVICE_ID, "Kinesis Video"); request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DescribeStream"); request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig); } finally { awsRequestMetrics.endEvent(Field.RequestMarshallTime); } HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler( new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new DescribeStreamResultJsonUnmarshaller()); response = invoke(request, responseHandler, executionContext); return response.getAwsResponse(); } finally { endClientExecution(awsRequestMetrics, request, response); } } /** *

          * 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 Result of the GetDataEndpoint operation returned by the service. * @throws InvalidArgumentException * The value for this input parameter is invalid. * @throws ResourceNotFoundException * Amazon Kinesis Video Streams can't find the stream that you specified. * @throws ClientLimitExceededException * Kinesis Video Streams has throttled the request because you have exceeded the limit of allowed client * calls. Try making the call later. * @throws NotAuthorizedException * The caller is not authorized to perform this operation. * @sample AmazonKinesisVideo.GetDataEndpoint * @see AWS * API Documentation */ @Override public GetDataEndpointResult getDataEndpoint(GetDataEndpointRequest request) { request = beforeClientExecution(request); return executeGetDataEndpoint(request); } @SdkInternalApi final GetDataEndpointResult executeGetDataEndpoint(GetDataEndpointRequest getDataEndpointRequest) { 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 GetDataEndpointRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(getDataEndpointRequest)); // Binds the request metrics to the current request. request.setAWSRequestMetrics(awsRequestMetrics); request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint); request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden()); request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion()); request.addHandlerContext(HandlerContextKey.SERVICE_ID, "Kinesis Video"); request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "GetDataEndpoint"); request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig); } finally { awsRequestMetrics.endEvent(Field.RequestMarshallTime); } HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler( new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new GetDataEndpointResultJsonUnmarshaller()); response = invoke(request, responseHandler, executionContext); return response.getAwsResponse(); } finally { endClientExecution(awsRequestMetrics, request, response); } } /** *

          * 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 Result of the GetSignalingChannelEndpoint operation returned by the service. * @throws InvalidArgumentException * The value for this input parameter is invalid. * @throws ClientLimitExceededException * Kinesis Video Streams has throttled the request because you have exceeded the limit of allowed client * calls. Try making the call later. * @throws ResourceNotFoundException * Amazon Kinesis Video Streams can't find the stream that you specified. * @throws ResourceInUseException * When the input StreamARN or ChannelARN in CLOUD_STORAGE_MODE is * already mapped to a different Kinesis Video Stream resource, or if the provided input * StreamARN or ChannelARN is not in Active status, try one of the following : *

          *
            *
          1. *

            * The DescribeMediaStorageConfiguration API to determine what the stream given channel is * mapped to. *

            *
            2. *
          2. *

            * The DescribeMappedResourceConfiguration API to determine the channel that the given stream * is mapped to. *

            *
            3. *
          3. *

            * The DescribeStream or DescribeSignalingChannel API to determine the status of * the resource. *

            *
            4. * @throws AccessDeniedException * You do not have required permissions to perform this operation. * @sample AmazonKinesisVideo.GetSignalingChannelEndpoint * @see AWS API Documentation */ @Override public GetSignalingChannelEndpointResult getSignalingChannelEndpoint(GetSignalingChannelEndpointRequest request) { request = beforeClientExecution(request); return executeGetSignalingChannelEndpoint(request); } @SdkInternalApi final GetSignalingChannelEndpointResult executeGetSignalingChannelEndpoint(GetSignalingChannelEndpointRequest getSignalingChannelEndpointRequest) { 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 GetSignalingChannelEndpointRequestProtocolMarshaller(protocolFactory).marshall(super .beforeMarshalling(getSignalingChannelEndpointRequest)); // Binds the request metrics to the current request. request.setAWSRequestMetrics(awsRequestMetrics); request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint); request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden()); request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion()); request.addHandlerContext(HandlerContextKey.SERVICE_ID, "Kinesis Video"); request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "GetSignalingChannelEndpoint"); request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig); } finally { awsRequestMetrics.endEvent(Field.RequestMarshallTime); } HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler( new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new GetSignalingChannelEndpointResultJsonUnmarshaller()); response = invoke(request, responseHandler, executionContext); return response.getAwsResponse(); } finally { endClientExecution(awsRequestMetrics, request, response); } } /** *

            * 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 Result of the ListEdgeAgentConfigurations operation returned by the service. * @throws NotAuthorizedException * The caller is not authorized to perform this operation. * @throws ClientLimitExceededException * Kinesis Video Streams has throttled the request because you have exceeded the limit of allowed client * calls. Try making the call later. * @throws InvalidArgumentException * The value for this input parameter is invalid. * @sample AmazonKinesisVideo.ListEdgeAgentConfigurations * @see AWS API Documentation */ @Override public ListEdgeAgentConfigurationsResult listEdgeAgentConfigurations(ListEdgeAgentConfigurationsRequest request) { request = beforeClientExecution(request); return executeListEdgeAgentConfigurations(request); } @SdkInternalApi final ListEdgeAgentConfigurationsResult executeListEdgeAgentConfigurations(ListEdgeAgentConfigurationsRequest listEdgeAgentConfigurationsRequest) { 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 ListEdgeAgentConfigurationsRequestProtocolMarshaller(protocolFactory).marshall(super .beforeMarshalling(listEdgeAgentConfigurationsRequest)); // Binds the request metrics to the current request. request.setAWSRequestMetrics(awsRequestMetrics); request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint); request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden()); request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion()); request.addHandlerContext(HandlerContextKey.SERVICE_ID, "Kinesis Video"); request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "ListEdgeAgentConfigurations"); request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig); } finally { awsRequestMetrics.endEvent(Field.RequestMarshallTime); } HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler( new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new ListEdgeAgentConfigurationsResultJsonUnmarshaller()); response = invoke(request, responseHandler, executionContext); return response.getAwsResponse(); } finally { endClientExecution(awsRequestMetrics, request, response); } } /** *

            * 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 Result of the ListSignalingChannels operation returned by the service. * @throws InvalidArgumentException * The value for this input parameter is invalid. * @throws ClientLimitExceededException * Kinesis Video Streams has throttled the request because you have exceeded the limit of allowed client * calls. Try making the call later. * @throws AccessDeniedException * You do not have required permissions to perform this operation. * @sample AmazonKinesisVideo.ListSignalingChannels * @see AWS API Documentation */ @Override public ListSignalingChannelsResult listSignalingChannels(ListSignalingChannelsRequest request) { request = beforeClientExecution(request); return executeListSignalingChannels(request); } @SdkInternalApi final ListSignalingChannelsResult executeListSignalingChannels(ListSignalingChannelsRequest listSignalingChannelsRequest) { 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 ListSignalingChannelsRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(listSignalingChannelsRequest)); // Binds the request metrics to the current request. request.setAWSRequestMetrics(awsRequestMetrics); request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint); request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden()); request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion()); request.addHandlerContext(HandlerContextKey.SERVICE_ID, "Kinesis Video"); request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "ListSignalingChannels"); request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig); } finally { awsRequestMetrics.endEvent(Field.RequestMarshallTime); } HttpResponseHandler> responseHandler = protocolFactory .createResponseHandler(new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new ListSignalingChannelsResultJsonUnmarshaller()); response = invoke(request, responseHandler, executionContext); return response.getAwsResponse(); } finally { endClientExecution(awsRequestMetrics, request, response); } } /** *

            * 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 Result of the ListStreams operation returned by the service. * @throws ClientLimitExceededException * Kinesis Video Streams has throttled the request because you have exceeded the limit of allowed client * calls. Try making the call later. * @throws InvalidArgumentException * The value for this input parameter is invalid. * @sample AmazonKinesisVideo.ListStreams * @see AWS API * Documentation */ @Override public ListStreamsResult listStreams(ListStreamsRequest request) { request = beforeClientExecution(request); return executeListStreams(request); } @SdkInternalApi final ListStreamsResult executeListStreams(ListStreamsRequest listStreamsRequest) { 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 ListStreamsRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(listStreamsRequest)); // Binds the request metrics to the current request. request.setAWSRequestMetrics(awsRequestMetrics); request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint); request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden()); request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion()); request.addHandlerContext(HandlerContextKey.SERVICE_ID, "Kinesis Video"); request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "ListStreams"); request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig); } finally { awsRequestMetrics.endEvent(Field.RequestMarshallTime); } HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler( new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new ListStreamsResultJsonUnmarshaller()); response = invoke(request, responseHandler, executionContext); return response.getAwsResponse(); } finally { endClientExecution(awsRequestMetrics, request, response); } } /** *

            * Returns a list of tags associated with the specified signaling channel. *

            * * @param listTagsForResourceRequest * @return Result of the ListTagsForResource operation returned by the service. * @throws InvalidArgumentException * The value for this input parameter is invalid. * @throws ClientLimitExceededException * Kinesis Video Streams has throttled the request because you have exceeded the limit of allowed client * calls. Try making the call later. * @throws ResourceNotFoundException * Amazon Kinesis Video Streams can't find the stream that you specified. * @throws AccessDeniedException * You do not have required permissions to perform this operation. * @sample AmazonKinesisVideo.ListTagsForResource * @see AWS API Documentation */ @Override public ListTagsForResourceResult listTagsForResource(ListTagsForResourceRequest request) { request = beforeClientExecution(request); return executeListTagsForResource(request); } @SdkInternalApi final ListTagsForResourceResult executeListTagsForResource(ListTagsForResourceRequest listTagsForResourceRequest) { 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 ListTagsForResourceRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(listTagsForResourceRequest)); // Binds the request metrics to the current request. request.setAWSRequestMetrics(awsRequestMetrics); request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint); request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden()); request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion()); request.addHandlerContext(HandlerContextKey.SERVICE_ID, "Kinesis Video"); request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "ListTagsForResource"); request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig); } finally { awsRequestMetrics.endEvent(Field.RequestMarshallTime); } HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler( new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new ListTagsForResourceResultJsonUnmarshaller()); response = invoke(request, responseHandler, executionContext); return response.getAwsResponse(); } finally { endClientExecution(awsRequestMetrics, request, response); } } /** *

            * 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 Result of the ListTagsForStream operation returned by the service. * @throws ClientLimitExceededException * Kinesis Video Streams has throttled the request because you have exceeded the limit of allowed client * calls. Try making the call later. * @throws InvalidArgumentException * The value for this input parameter is invalid. * @throws ResourceNotFoundException * Amazon Kinesis Video Streams can't find the stream that you specified. * @throws NotAuthorizedException * The caller is not authorized to perform this operation. * @throws InvalidResourceFormatException * The format of the StreamARN is invalid. * @sample AmazonKinesisVideo.ListTagsForStream * @see AWS * API Documentation */ @Override public ListTagsForStreamResult listTagsForStream(ListTagsForStreamRequest request) { request = beforeClientExecution(request); return executeListTagsForStream(request); } @SdkInternalApi final ListTagsForStreamResult executeListTagsForStream(ListTagsForStreamRequest listTagsForStreamRequest) { 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 ListTagsForStreamRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(listTagsForStreamRequest)); // Binds the request metrics to the current request. request.setAWSRequestMetrics(awsRequestMetrics); request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint); request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden()); request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion()); request.addHandlerContext(HandlerContextKey.SERVICE_ID, "Kinesis Video"); request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "ListTagsForStream"); request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig); } finally { awsRequestMetrics.endEvent(Field.RequestMarshallTime); } HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler( new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new ListTagsForStreamResultJsonUnmarshaller()); response = invoke(request, responseHandler, executionContext); return response.getAwsResponse(); } finally { endClientExecution(awsRequestMetrics, request, response); } } /** *

            * 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 Result of the StartEdgeConfigurationUpdate operation returned by the service. * @throws AccessDeniedException * You do not have required permissions to perform this operation. * @throws ClientLimitExceededException * Kinesis Video Streams has throttled the request because you have exceeded the limit of allowed client * calls. Try making the call later. * @throws InvalidArgumentException * The value for this input parameter is invalid. * @throws NoDataRetentionException * The Stream data retention in hours is equal to zero. * @throws ResourceInUseException * When the input StreamARN or ChannelARN in CLOUD_STORAGE_MODE is * already mapped to a different Kinesis Video Stream resource, or if the provided input * StreamARN or ChannelARN is not in Active status, try one of the following : *

            *
              *
            1. *

              * The DescribeMediaStorageConfiguration API to determine what the stream given channel is * mapped to. *

              *
              2. *
            2. *

              * The DescribeMappedResourceConfiguration API to determine the channel that the given stream * is mapped to. *

              *
              3. *
            3. *

              * The DescribeStream or DescribeSignalingChannel API to determine the status of * the resource. *

              *
              4. * @throws ResourceNotFoundException * Amazon Kinesis Video Streams can't find the stream that you specified. * @sample AmazonKinesisVideo.StartEdgeConfigurationUpdate * @see AWS API Documentation */ @Override public StartEdgeConfigurationUpdateResult startEdgeConfigurationUpdate(StartEdgeConfigurationUpdateRequest request) { request = beforeClientExecution(request); return executeStartEdgeConfigurationUpdate(request); } @SdkInternalApi final StartEdgeConfigurationUpdateResult executeStartEdgeConfigurationUpdate(StartEdgeConfigurationUpdateRequest startEdgeConfigurationUpdateRequest) { 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 StartEdgeConfigurationUpdateRequestProtocolMarshaller(protocolFactory).marshall(super .beforeMarshalling(startEdgeConfigurationUpdateRequest)); // Binds the request metrics to the current request. request.setAWSRequestMetrics(awsRequestMetrics); request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint); request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden()); request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion()); request.addHandlerContext(HandlerContextKey.SERVICE_ID, "Kinesis Video"); request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "StartEdgeConfigurationUpdate"); request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig); } finally { awsRequestMetrics.endEvent(Field.RequestMarshallTime); } HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler( new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new StartEdgeConfigurationUpdateResultJsonUnmarshaller()); response = invoke(request, responseHandler, executionContext); return response.getAwsResponse(); } finally { endClientExecution(awsRequestMetrics, request, response); } } /** *

              * 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 Result of the TagResource operation returned by the service. * @throws InvalidArgumentException * The value for this input parameter is invalid. * @throws ClientLimitExceededException * Kinesis Video Streams has throttled the request because you have exceeded the limit of allowed client * calls. Try making the call later. * @throws ResourceNotFoundException * Amazon Kinesis Video Streams can't find the stream that you specified. * @throws AccessDeniedException * You do not have required permissions to perform this operation. * @throws TagsPerResourceExceededLimitException * You have exceeded the limit of tags that you can associate with the resource. A Kinesis video stream can * support up to 50 tags. * @sample AmazonKinesisVideo.TagResource * @see AWS API * Documentation */ @Override public TagResourceResult tagResource(TagResourceRequest request) { request = beforeClientExecution(request); return executeTagResource(request); } @SdkInternalApi final TagResourceResult executeTagResource(TagResourceRequest tagResourceRequest) { 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 TagResourceRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(tagResourceRequest)); // Binds the request metrics to the current request. request.setAWSRequestMetrics(awsRequestMetrics); request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint); request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden()); request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion()); request.addHandlerContext(HandlerContextKey.SERVICE_ID, "Kinesis Video"); request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "TagResource"); request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig); } finally { awsRequestMetrics.endEvent(Field.RequestMarshallTime); } HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler( new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new TagResourceResultJsonUnmarshaller()); response = invoke(request, responseHandler, executionContext); return response.getAwsResponse(); } finally { endClientExecution(awsRequestMetrics, request, response); } } /** *

              * 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 Result of the TagStream operation returned by the service. * @throws ClientLimitExceededException * Kinesis Video Streams has throttled the request because you have exceeded the limit of allowed client * calls. Try making the call later. * @throws InvalidArgumentException * The value for this input parameter is invalid. * @throws ResourceNotFoundException * Amazon Kinesis Video Streams can't find the stream that you specified. * @throws NotAuthorizedException * The caller is not authorized to perform this operation. * @throws InvalidResourceFormatException * The format of the StreamARN is invalid. * @throws TagsPerResourceExceededLimitException * You have exceeded the limit of tags that you can associate with the resource. A Kinesis video stream can * support up to 50 tags. * @sample AmazonKinesisVideo.TagStream * @see AWS API * Documentation */ @Override public TagStreamResult tagStream(TagStreamRequest request) { request = beforeClientExecution(request); return executeTagStream(request); } @SdkInternalApi final TagStreamResult executeTagStream(TagStreamRequest tagStreamRequest) { 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 TagStreamRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(tagStreamRequest)); // Binds the request metrics to the current request. request.setAWSRequestMetrics(awsRequestMetrics); request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint); request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden()); request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion()); request.addHandlerContext(HandlerContextKey.SERVICE_ID, "Kinesis Video"); request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "TagStream"); request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig); } finally { awsRequestMetrics.endEvent(Field.RequestMarshallTime); } HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(new JsonOperationMetadata() .withPayloadJson(true).withHasStreamingSuccessResponse(false), new TagStreamResultJsonUnmarshaller()); response = invoke(request, responseHandler, executionContext); return response.getAwsResponse(); } finally { endClientExecution(awsRequestMetrics, request, response); } } /** *

              * 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 Result of the UntagResource operation returned by the service. * @throws InvalidArgumentException * The value for this input parameter is invalid. * @throws ClientLimitExceededException * Kinesis Video Streams has throttled the request because you have exceeded the limit of allowed client * calls. Try making the call later. * @throws ResourceNotFoundException * Amazon Kinesis Video Streams can't find the stream that you specified. * @throws AccessDeniedException * You do not have required permissions to perform this operation. * @sample AmazonKinesisVideo.UntagResource * @see AWS API * Documentation */ @Override public UntagResourceResult untagResource(UntagResourceRequest request) { request = beforeClientExecution(request); return executeUntagResource(request); } @SdkInternalApi final UntagResourceResult executeUntagResource(UntagResourceRequest untagResourceRequest) { 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 UntagResourceRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(untagResourceRequest)); // Binds the request metrics to the current request. request.setAWSRequestMetrics(awsRequestMetrics); request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint); request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden()); request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion()); request.addHandlerContext(HandlerContextKey.SERVICE_ID, "Kinesis Video"); request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "UntagResource"); request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig); } finally { awsRequestMetrics.endEvent(Field.RequestMarshallTime); } HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler( new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new UntagResourceResultJsonUnmarshaller()); response = invoke(request, responseHandler, executionContext); return response.getAwsResponse(); } finally { endClientExecution(awsRequestMetrics, request, response); } } /** *

              * 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 Result of the UntagStream operation returned by the service. * @throws ClientLimitExceededException * Kinesis Video Streams has throttled the request because you have exceeded the limit of allowed client * calls. Try making the call later. * @throws InvalidArgumentException * The value for this input parameter is invalid. * @throws ResourceNotFoundException * Amazon Kinesis Video Streams can't find the stream that you specified. * @throws NotAuthorizedException * The caller is not authorized to perform this operation. * @throws InvalidResourceFormatException * The format of the StreamARN is invalid. * @sample AmazonKinesisVideo.UntagStream * @see AWS API * Documentation */ @Override public UntagStreamResult untagStream(UntagStreamRequest request) { request = beforeClientExecution(request); return executeUntagStream(request); } @SdkInternalApi final UntagStreamResult executeUntagStream(UntagStreamRequest untagStreamRequest) { 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 UntagStreamRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(untagStreamRequest)); // Binds the request metrics to the current request. request.setAWSRequestMetrics(awsRequestMetrics); request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint); request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden()); request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion()); request.addHandlerContext(HandlerContextKey.SERVICE_ID, "Kinesis Video"); request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "UntagStream"); request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig); } finally { awsRequestMetrics.endEvent(Field.RequestMarshallTime); } HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler( new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new UntagStreamResultJsonUnmarshaller()); response = invoke(request, responseHandler, executionContext); return response.getAwsResponse(); } finally { endClientExecution(awsRequestMetrics, request, response); } } /** *

              * 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 Result of the UpdateDataRetention operation returned by the service. * @throws ClientLimitExceededException * Kinesis Video Streams has throttled the request because you have exceeded the limit of allowed client * calls. Try making the call later. * @throws InvalidArgumentException * The value for this input parameter is invalid. * @throws ResourceNotFoundException * Amazon Kinesis Video Streams can't find the stream that you specified. * @throws ResourceInUseException * When the input StreamARN or ChannelARN in CLOUD_STORAGE_MODE is * already mapped to a different Kinesis Video Stream resource, or if the provided input * StreamARN or ChannelARN is not in Active status, try one of the following : *

              *
                *
              1. *

                * The DescribeMediaStorageConfiguration API to determine what the stream given channel is * mapped to. *

                *
                2. *
              2. *

                * The DescribeMappedResourceConfiguration API to determine the channel that the given stream * is mapped to. *

                *
                3. *
              3. *

                * The DescribeStream or DescribeSignalingChannel API to determine the status of * the resource. *

                *
                4. * @throws NotAuthorizedException * The caller is not authorized to perform this operation. * @throws VersionMismatchException * The stream version that you specified is not the latest version. To get the latest version, use the DescribeStream * API. * @sample AmazonKinesisVideo.UpdateDataRetention * @see AWS API Documentation */ @Override public UpdateDataRetentionResult updateDataRetention(UpdateDataRetentionRequest request) { request = beforeClientExecution(request); return executeUpdateDataRetention(request); } @SdkInternalApi final UpdateDataRetentionResult executeUpdateDataRetention(UpdateDataRetentionRequest updateDataRetentionRequest) { 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 UpdateDataRetentionRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(updateDataRetentionRequest)); // Binds the request metrics to the current request. request.setAWSRequestMetrics(awsRequestMetrics); request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint); request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden()); request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion()); request.addHandlerContext(HandlerContextKey.SERVICE_ID, "Kinesis Video"); request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "UpdateDataRetention"); request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig); } finally { awsRequestMetrics.endEvent(Field.RequestMarshallTime); } HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler( new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new UpdateDataRetentionResultJsonUnmarshaller()); response = invoke(request, responseHandler, executionContext); return response.getAwsResponse(); } finally { endClientExecution(awsRequestMetrics, request, response); } } /** *

                * Updates the StreamInfo and ImageProcessingConfiguration fields. *

                * * @param updateImageGenerationConfigurationRequest * @return Result of the UpdateImageGenerationConfiguration operation returned by the service. * @throws InvalidArgumentException * The value for this input parameter is invalid. * @throws ClientLimitExceededException * Kinesis Video Streams has throttled the request because you have exceeded the limit of allowed client * calls. Try making the call later. * @throws ResourceNotFoundException * Amazon Kinesis Video Streams can't find the stream that you specified. * @throws AccessDeniedException * You do not have required permissions to perform this operation. * @throws ResourceInUseException * When the input StreamARN or ChannelARN in CLOUD_STORAGE_MODE is * already mapped to a different Kinesis Video Stream resource, or if the provided input * StreamARN or ChannelARN is not in Active status, try one of the following : *

                *
                  *
                1. *

                  * The DescribeMediaStorageConfiguration API to determine what the stream given channel is * mapped to. *

                  *
                  2. *
                2. *

                  * The DescribeMappedResourceConfiguration API to determine the channel that the given stream * is mapped to. *

                  *
                  3. *
                3. *

                  * The DescribeStream or DescribeSignalingChannel API to determine the status of * the resource. *

                  *
                  4. * @throws NoDataRetentionException * The Stream data retention in hours is equal to zero. * @sample AmazonKinesisVideo.UpdateImageGenerationConfiguration * @see AWS API Documentation */ @Override public UpdateImageGenerationConfigurationResult updateImageGenerationConfiguration(UpdateImageGenerationConfigurationRequest request) { request = beforeClientExecution(request); return executeUpdateImageGenerationConfiguration(request); } @SdkInternalApi final UpdateImageGenerationConfigurationResult executeUpdateImageGenerationConfiguration( UpdateImageGenerationConfigurationRequest updateImageGenerationConfigurationRequest) { 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 UpdateImageGenerationConfigurationRequestProtocolMarshaller(protocolFactory).marshall(super .beforeMarshalling(updateImageGenerationConfigurationRequest)); // Binds the request metrics to the current request. request.setAWSRequestMetrics(awsRequestMetrics); request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint); request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden()); request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion()); request.addHandlerContext(HandlerContextKey.SERVICE_ID, "Kinesis Video"); request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "UpdateImageGenerationConfiguration"); request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig); } finally { awsRequestMetrics.endEvent(Field.RequestMarshallTime); } HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler( new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new UpdateImageGenerationConfigurationResultJsonUnmarshaller()); response = invoke(request, responseHandler, executionContext); return response.getAwsResponse(); } finally { endClientExecution(awsRequestMetrics, request, response); } } /** *

                  * 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 Result of the UpdateMediaStorageConfiguration operation returned by the service. * @throws ResourceInUseException * When the input StreamARN or ChannelARN in CLOUD_STORAGE_MODE is * already mapped to a different Kinesis Video Stream resource, or if the provided input * StreamARN or ChannelARN is not in Active status, try one of the following : *

                  *
                    *
                  1. *

                    * The DescribeMediaStorageConfiguration API to determine what the stream given channel is * mapped to. *

                    *
                    2. *
                  2. *

                    * The DescribeMappedResourceConfiguration API to determine the channel that the given stream * is mapped to. *

                    *
                    3. *
                  3. *

                    * The DescribeStream or DescribeSignalingChannel API to determine the status of * the resource. *

                    *
                    4. * @throws InvalidArgumentException * The value for this input parameter is invalid. * @throws ClientLimitExceededException * Kinesis Video Streams has throttled the request because you have exceeded the limit of allowed client * calls. Try making the call later. * @throws ResourceNotFoundException * Amazon Kinesis Video Streams can't find the stream that you specified. * @throws AccessDeniedException * You do not have required permissions to perform this operation. * @throws NoDataRetentionException * The Stream data retention in hours is equal to zero. * @sample AmazonKinesisVideo.UpdateMediaStorageConfiguration * @see AWS API Documentation */ @Override public UpdateMediaStorageConfigurationResult updateMediaStorageConfiguration(UpdateMediaStorageConfigurationRequest request) { request = beforeClientExecution(request); return executeUpdateMediaStorageConfiguration(request); } @SdkInternalApi final UpdateMediaStorageConfigurationResult executeUpdateMediaStorageConfiguration( UpdateMediaStorageConfigurationRequest updateMediaStorageConfigurationRequest) { 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 UpdateMediaStorageConfigurationRequestProtocolMarshaller(protocolFactory).marshall(super .beforeMarshalling(updateMediaStorageConfigurationRequest)); // Binds the request metrics to the current request. request.setAWSRequestMetrics(awsRequestMetrics); request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint); request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden()); request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion()); request.addHandlerContext(HandlerContextKey.SERVICE_ID, "Kinesis Video"); request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "UpdateMediaStorageConfiguration"); request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig); } finally { awsRequestMetrics.endEvent(Field.RequestMarshallTime); } HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler( new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new UpdateMediaStorageConfigurationResultJsonUnmarshaller()); response = invoke(request, responseHandler, executionContext); return response.getAwsResponse(); } finally { endClientExecution(awsRequestMetrics, request, response); } } /** *

                    * Updates the notification information for a stream. *

                    * * @param updateNotificationConfigurationRequest * @return Result of the UpdateNotificationConfiguration operation returned by the service. * @throws InvalidArgumentException * The value for this input parameter is invalid. * @throws ClientLimitExceededException * Kinesis Video Streams has throttled the request because you have exceeded the limit of allowed client * calls. Try making the call later. * @throws ResourceNotFoundException * Amazon Kinesis Video Streams can't find the stream that you specified. * @throws AccessDeniedException * You do not have required permissions to perform this operation. * @throws ResourceInUseException * When the input StreamARN or ChannelARN in CLOUD_STORAGE_MODE is * already mapped to a different Kinesis Video Stream resource, or if the provided input * StreamARN or ChannelARN is not in Active status, try one of the following : *

                    *
                      *
                    1. *

                      * The DescribeMediaStorageConfiguration API to determine what the stream given channel is * mapped to. *

                      *
                      2. *
                    2. *

                      * The DescribeMappedResourceConfiguration API to determine the channel that the given stream * is mapped to. *

                      *
                      3. *
                    3. *

                      * The DescribeStream or DescribeSignalingChannel API to determine the status of * the resource. *

                      *
                      4. * @throws NoDataRetentionException * The Stream data retention in hours is equal to zero. * @sample AmazonKinesisVideo.UpdateNotificationConfiguration * @see AWS API Documentation */ @Override public UpdateNotificationConfigurationResult updateNotificationConfiguration(UpdateNotificationConfigurationRequest request) { request = beforeClientExecution(request); return executeUpdateNotificationConfiguration(request); } @SdkInternalApi final UpdateNotificationConfigurationResult executeUpdateNotificationConfiguration( UpdateNotificationConfigurationRequest updateNotificationConfigurationRequest) { 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 UpdateNotificationConfigurationRequestProtocolMarshaller(protocolFactory).marshall(super .beforeMarshalling(updateNotificationConfigurationRequest)); // Binds the request metrics to the current request. request.setAWSRequestMetrics(awsRequestMetrics); request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint); request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden()); request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion()); request.addHandlerContext(HandlerContextKey.SERVICE_ID, "Kinesis Video"); request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "UpdateNotificationConfiguration"); request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig); } finally { awsRequestMetrics.endEvent(Field.RequestMarshallTime); } HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler( new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new UpdateNotificationConfigurationResultJsonUnmarshaller()); response = invoke(request, responseHandler, executionContext); return response.getAwsResponse(); } finally { endClientExecution(awsRequestMetrics, request, response); } } /** *

                      * 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 Result of the UpdateSignalingChannel operation returned by the service. * @throws InvalidArgumentException * The value for this input parameter is invalid. * @throws ClientLimitExceededException * Kinesis Video Streams has throttled the request because you have exceeded the limit of allowed client * calls. Try making the call later. * @throws ResourceNotFoundException * Amazon Kinesis Video Streams can't find the stream that you specified. * @throws ResourceInUseException * When the input StreamARN or ChannelARN in CLOUD_STORAGE_MODE is * already mapped to a different Kinesis Video Stream resource, or if the provided input * StreamARN or ChannelARN is not in Active status, try one of the following : *

                      *
                        *
                      1. *

                        * The DescribeMediaStorageConfiguration API to determine what the stream given channel is * mapped to. *

                        *
                        2. *
                      2. *

                        * The DescribeMappedResourceConfiguration API to determine the channel that the given stream * is mapped to. *

                        *
                        3. *
                      3. *

                        * The DescribeStream or DescribeSignalingChannel API to determine the status of * the resource. *

                        *
                        4. * @throws AccessDeniedException * You do not have required permissions to perform this operation. * @throws VersionMismatchException * The stream version that you specified is not the latest version. To get the latest version, use the DescribeStream * API. * @sample AmazonKinesisVideo.UpdateSignalingChannel * @see AWS API Documentation */ @Override public UpdateSignalingChannelResult updateSignalingChannel(UpdateSignalingChannelRequest request) { request = beforeClientExecution(request); return executeUpdateSignalingChannel(request); } @SdkInternalApi final UpdateSignalingChannelResult executeUpdateSignalingChannel(UpdateSignalingChannelRequest updateSignalingChannelRequest) { 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 UpdateSignalingChannelRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(updateSignalingChannelRequest)); // Binds the request metrics to the current request. request.setAWSRequestMetrics(awsRequestMetrics); request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint); request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden()); request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion()); request.addHandlerContext(HandlerContextKey.SERVICE_ID, "Kinesis Video"); request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "UpdateSignalingChannel"); request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig); } finally { awsRequestMetrics.endEvent(Field.RequestMarshallTime); } HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler( new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new UpdateSignalingChannelResultJsonUnmarshaller()); response = invoke(request, responseHandler, executionContext); return response.getAwsResponse(); } finally { endClientExecution(awsRequestMetrics, request, response); } } /** *

                        * 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 Result of the UpdateStream operation returned by the service. * @throws ClientLimitExceededException * Kinesis Video Streams has throttled the request because you have exceeded the limit of allowed client * calls. Try making the call later. * @throws InvalidArgumentException * The value for this input parameter is invalid. * @throws ResourceNotFoundException * Amazon Kinesis Video Streams can't find the stream that you specified. * @throws ResourceInUseException * When the input StreamARN or ChannelARN in CLOUD_STORAGE_MODE is * already mapped to a different Kinesis Video Stream resource, or if the provided input * StreamARN or ChannelARN is not in Active status, try one of the following : *

                        *
                          *
                        1. *

                          * The DescribeMediaStorageConfiguration API to determine what the stream given channel is * mapped to. *

                          *
                          2. *
                        2. *

                          * The DescribeMappedResourceConfiguration API to determine the channel that the given stream * is mapped to. *

                          *
                          3. *
                        3. *

                          * The DescribeStream or DescribeSignalingChannel API to determine the status of * the resource. *

                          *
                          4. * @throws NotAuthorizedException * The caller is not authorized to perform this operation. * @throws VersionMismatchException * The stream version that you specified is not the latest version. To get the latest version, use the DescribeStream * API. * @sample AmazonKinesisVideo.UpdateStream * @see AWS API * Documentation */ @Override public UpdateStreamResult updateStream(UpdateStreamRequest request) { request = beforeClientExecution(request); return executeUpdateStream(request); } @SdkInternalApi final UpdateStreamResult executeUpdateStream(UpdateStreamRequest updateStreamRequest) { 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 UpdateStreamRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(updateStreamRequest)); // Binds the request metrics to the current request. request.setAWSRequestMetrics(awsRequestMetrics); request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint); request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden()); request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion()); request.addHandlerContext(HandlerContextKey.SERVICE_ID, "Kinesis Video"); request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "UpdateStream"); request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig); } finally { awsRequestMetrics.endEvent(Field.RequestMarshallTime); } HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler( new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new UpdateStreamResultJsonUnmarshaller()); response = invoke(request, responseHandler, executionContext); return response.getAwsResponse(); } finally { endClientExecution(awsRequestMetrics, request, response); } } /** * Returns additional metadata for a previously executed successful, request, typically used for debugging issues * where a service isn't acting as expected. This data isn't considered part of the result data returned by an * operation, so it's available through this separate, diagnostic interface. *

                          * Response metadata is only cached for a limited period of time, so if you need to access this extra diagnostic * information for an executed request, you should use this method to retrieve it as soon as possible after * executing the request. * * @param request * The originally executed request * * @return The response metadata for the specified request, or null if none is available. */ public ResponseMetadata getCachedResponseMetadata(AmazonWebServiceRequest request) { return client.getResponseMetadataForRequest(request); } /** * Normal invoke with authentication. Credentials are required and may be overriden at the request level. **/ private Response invoke(Request request, HttpResponseHandler> responseHandler, ExecutionContext executionContext) { return invoke(request, responseHandler, executionContext, null, null); } /** * Normal invoke with authentication. Credentials are required and may be overriden at the request level. **/ private Response invoke(Request request, HttpResponseHandler> responseHandler, ExecutionContext executionContext, URI cachedEndpoint, URI uriFromEndpointTrait) { executionContext.setCredentialsProvider(CredentialUtils.getCredentialsProvider(request.getOriginalRequest(), awsCredentialsProvider)); return doInvoke(request, responseHandler, executionContext, cachedEndpoint, uriFromEndpointTrait); } /** * Invoke with no authentication. Credentials are not required and any credentials set on the client or request will * be ignored for this operation. **/ private Response anonymousInvoke(Request request, HttpResponseHandler> responseHandler, ExecutionContext executionContext) { return doInvoke(request, responseHandler, executionContext, null, null); } /** * Invoke the request using the http client. Assumes credentials (or lack thereof) have been configured in the * ExecutionContext beforehand. **/ private Response doInvoke(Request request, HttpResponseHandler> responseHandler, ExecutionContext executionContext, URI discoveredEndpoint, URI uriFromEndpointTrait) { if (discoveredEndpoint != null) { request.setEndpoint(discoveredEndpoint); request.getOriginalRequest().getRequestClientOptions().appendUserAgent("endpoint-discovery"); } else if (uriFromEndpointTrait != null) { request.setEndpoint(uriFromEndpointTrait); } else { request.setEndpoint(endpoint); } request.setTimeOffset(timeOffset); HttpResponseHandler errorResponseHandler = protocolFactory.createErrorResponseHandler(new JsonErrorResponseMetadata()); return client.execute(request, responseHandler, errorResponseHandler, executionContext); } @com.amazonaws.annotation.SdkInternalApi static com.amazonaws.protocol.json.SdkJsonProtocolFactory getProtocolFactory() { return protocolFactory; } @Override public void shutdown() { super.shutdown(); } }