Amazon Web Services (AWS) Kinesis Video Streams does not provide built-in functionality to monitor connections or perform real-time actions on WebRTC channels.

To achieve the functionality you described, you may need to build a custom solution using other AWS services and APIs. Here's a high-level overview of how you could approach each requirement:

1. Monitoring the number of viewers:

You can track the number of viewers connected to a channel by implementing custom logic in your application. You can use AWS SDKs or APIs to interact with Kinesis Video Streams and maintain a count of active viewers. This could involve using APIs like DescribeSignalingChannel and GetSignalingChannelEndpoint to retrieve information about the channel and its viewers.

Here's a code example in Python that demonstrates how to monitor the number of viewers connected to a Kinesis Video Streams channel using the AWS SDK for Python (Boto3):

import boto3

Configure the AWS credentials and region

session = boto3.Session( aws_access_key_id='YOUR_ACCESS_KEY', aws_secret_access_key='YOUR_SECRET_KEY', region_name='YOUR_REGION' )

Create a Kinesis Video Streams client

kinesis_client = session.client('kinesisvideo')

Specify the name of the signaling channel

channel_name = 'your-channel-name'

def get_viewer_count(): # Retrieve the signaling channel ARN response = kinesis_client.describe_signaling_channel( ChannelName=channel_name ) channel_arn = response['ChannelInfo']['ChannelARN']

# Retrieve the signaling channel endpoint
response = kinesis_client.get_signaling_channel_endpoint(
    ChannelARN=channel_arn,
    SingleMasterChannelEndpointConfiguration={
        'Protocols': ['HTTPS']
    }
)
endpoint = response['ResourceEndpointList'][0]['ResourceEndpoint']

# Use the signaling channel endpoint to retrieve the viewer count
signaling_client = boto3.client('kinesis-video-signaling', endpoint_url=endpoint)
response = signaling_client.get_channel_info(
    ChannelARN=channel_arn
)
viewer_count = response['ChannelInfo']['ActiveViewerCount']

return viewer_count

Example usage

viewer_count = get_viewer_count() print(f"Number of viewers: {viewer_count}")

Make sure to replace 'YOUR_ACCESS_KEY', 'YOUR_SECRET_KEY', 'YOUR_REGION', and 'your-channel-name' with your own AWS credentials, region, and signaling channel information. The code retrieves the signaling channel ARN, gets the signaling channel endpoint, and then uses the endpoint to fetch the viewer count.

2. Time duration for a stream:

You would need to track the start time and end time of the stream within your application logic. By monitoring the WebRTC connection status, you can calculate the duration of the stream. This would require implementing timers and tracking the start and end events within your application.

Here's a code example in Python that demonstrates how to track the start time and end time of a stream and calculate its duration using timers and WebRTC connection status:

import time

Variables to track stream start and end time

stream_start_time = None

stream_end_time = None

Function to handle stream start event

def handle_stream_start():

global stream_start_time

stream_start_time = time.time()

Function to handle stream end event

def handle_stream_end():

global stream_end_time

stream_end_time = time.time()

Function to calculate stream duration

def calculate_stream_duration():

if stream_start_time is None or stream_end_time is None:
    return None

else:
    return stream_end_time - stream_start_time

Example usage

handle_stream_start() # Call this when the stream starts time.sleep(10) # Simulating a 10-second duration handle_stream_end() # Call this when the stream ends

stream_duration = calculate_stream_duration() print(f"Stream duration: {stream_duration} seconds")

In this example, the handle_stream_start() function is called when the stream starts, and it sets the stream_start_time variable to the current time using time.time().

Similarly, the handle_stream_end() function is called when the stream ends, and it sets the stream_end_time variable to the current time using time.time().

The calculate_stream_duration() function calculates the duration of the stream by subtracting the stream_start_time from the stream_end_time. If either of the variables is None, indicating that the stream start or end events have not occurred, the function returns None.

3 Forcing close client connections:

There is no built-in feature to force close client connections after a specific time duration. You would need to implement this logic in your application code by periodically checking the duration of the stream and terminating the connection if it exceeds a predefined threshold. If you want to force close client connections after a specific time duration, you would need to implement the logic in your application code. Here's an example in Python using a timer and a predefined threshold:

import time

Predefined threshold for stream duration in seconds

threshold_duration = 3600 # 1 hour

Function to check stream duration and force close connections if exceeded

def check_stream_duration(): stream_start_time = time.time() # Retrieve the stream start time from your application logic current_time = time.time() stream_duration = current_time - stream_start_time

if stream_duration >= threshold_duration:
    # Code to force close client connections
    # This can vary depending on your application and the protocol used for streaming

    # Example code for WebSocket-based connections
    for connection in active_connections:
        connection.close()

    # Example code for HTTP-based connections
    # Terminate the streaming session or respond with an appropriate error

Example usage

check_stream_duration()

In this example, the check_stream_duration() function calculates the duration of the stream by subtracting the stream's start time (retrieved from your application logic) from the current time using time.time(). If the stream duration exceeds the predefined threshold (threshold_duration), you can implement the necessary logic to force close the client connections.

Hi, thanks for reply but I think some suggested code cannot works. For example the following:

# Use the signaling channel endpoint to retrieve the viewer count
signaling_client = boto3.client('kinesis-video-signaling', endpoint_url=endpoint)
response = signaling_client.get_channel_info(
    ChannelARN=channel_arn
)

doesn't work due to the 'get_channel_info' method is not defined in boto sdk (at least the official one)

Perhaps I'm missing some information or resource where I can look at. Any suggestion?