---
title: A2A Implementation Guide
hide_title: false
hide_table_of_contents: false
description: "Complete implementation guide for building Agent to Agent (A2A) systems with VideoSDK AI Agents. Learn to create customer service and specialist agents that collaborate seamlessly using real-world examples."
pagination_label: "A2A Implementation"
keywords:
  - A2A Implementation
  - Agent to Agent Example
  - Multi-Agent System
  - Multiple Agent
  - A2A Protocol
  - AI Agent
  - Google's A2A
  - Customer Service Agent
  - Loan Specialist Agent
  - VideoSDK Agents
  - AI Agent SDK
  - Python Implementation
  - Agent Collaboration
image: img/videosdklive-thumbnail.jpg
sidebar_position: 6
sidebar_label: Implementation
slug: implementation
---

# A2A Implementation Guide

This guide shows you how to build a complete Agent to Agent (A2A) system using the concepts from the [A2A Overview](overview). We'll create a banking customer service system with a main customer service agent and a loan specialist.

## Implementation Overview

We'll build a system with:

- **Customer Service Agent**: Voice-enabled interface agent that users interact with
- **Loan Specialist Agent**: Text-based domain expert for loan-related queries
- **Intelligent Routing**: Automatic detection and forwarding of loan queries
- **Seamless Communication**: Users get expert responses without knowing about the routing

## Structure of the project

```js
A2A
├── agents/
│   ├── customer_agent.py     # CustomerServiceAgent definition
│   ├── loan_agent.py         # LoanAgent definition
│
├── session_manager.py        # Handles session creation, pipeline setup, meeting join/leave
└── main.py                   # Entry point: runs main() and starts agents
```

## Sequence Diagram

![A2A Architecture](https://cdn.videosdk.live/website-resources/docs-resources/a2a_sequence_diagram.png)

## Step 1: Create the Customer Service Agent

- **`Interface Agent`**: Creates `CustomerServiceAgent` as the main user-facing agent with voice capabilities and customer service instructions.
- **`Function Tool`**: Implements`@function_tool forward_to_specialist()`that uses A2A discovery to find and route queries to domain specialists.
- **`Response Relay`**: Includes `handle_specialist_response()` method that automatically receives and relays specialist responses back to users.

```python title="agents/customer_agent.py"
from videosdk.agents import Agent, AgentCard, A2AMessage, function_tool
import asyncio
from typing import Dict, Any

class CustomerServiceAgent(Agent):
    def __init__(self):
        super().__init__(
            agent_id="customer_service_1",
            instructions=(
                "You are a helpful bank customer service agent. "
                "For general banking queries (account balances, transactions, basic services), answer directly. "
                "For ANY loan-related queries, questions, or follow-ups, ALWAYS use the forward_to_specialist function "
                "with domain set to 'loan'. This includes initial loan questions AND all follow-up questions about loans. "
                "Do NOT attempt to answer loan questions yourself - always forward them to the specialist. "
                "After forwarding a loan query, stay engaged and automatically relay any response you receive from the specialist. "
                "When you receive responses from specialists, immediately relay them naturally to the customer."
            )
        )

    @function_tool
    async def forward_to_specialist(self, query: str, domain: str) -> Dict[str, Any]:
        """Forward queries to domain specialist agents using A2A discovery"""

        # Use A2A discovery to find specialists by domain
        specialists = self.a2a.registry.find_agents_by_domain(domain)
        id_of_target_agent = specialists[0] if specialists else None

        if not id_of_target_agent:
            return {"error": f"No specialist found for domain {domain}"}

        # Send A2A message to the specialist
        await self.a2a.send_message(
            to_agent=id_of_target_agent,
            message_type="specialist_query",
            content={"query": query}
        )

        return {
            "status": "forwarded",
            "specialist": id_of_target_agent,
            "message": "Let me get that information for you from our loan specialist..."
        }

    async def handle_specialist_response(self, message: A2AMessage) -> None:
        """Handle responses from specialist agents and relay to user"""
        response = message.content.get("response")
        if response:
            # Brief pause for natural conversation flow
            await asyncio.sleep(0.5)

            # Try multiple methods to relay the response to the user
            prompt = f"The loan specialist has responded: {response}"
            methods_to_try = [
                (self.session.pipeline.send_text_message, prompt),
                (self.session.pipeline.model.send_message, response),
                (self.session.say, response)
            ]

            for method, arg in methods_to_try:
                try:
                    await method(arg)
                    break
                except Exception as e:
                    print(f"Error with {method.__name__}: {e}")

    async def on_enter(self):
        # Register this agent with the A2A system
        await self.register_a2a(AgentCard(
            id="customer_service_1",
            name="Customer Service Agent",
            domain="customer_service",
            capabilities=["query_handling", "specialist_coordination"],
            description="Handles customer queries and coordinates with specialists",
            metadata={"version": "1.0", "type": "interface"}
        ))

        # Greet the user
        await self.session.say("Hello! I am your customer service agent. How can I help you?")

        # Set up message listener for specialist responses
        self.a2a.on_message("specialist_response", self.handle_specialist_response)

    async def on_exit(self):
        print("Customer agent left the meeting")
```

## Step 2: Create the Loan Specialist Agent

- **`Specialist Agent Setup`**: Creates `LoanAgent` class with specialized loan expertise instructions and agent_id `"specialist_1"`.
- **`Message Handlers`**: Implements` handle_specialist_query()` to process incoming queries and handle_model_response() to send responses back.
- **`Registration`**: Registers with A2A system using domain "loan" so it can be `discovered` by other agents needing loan expertise.

```python title="agents/loan_agent.py"
from videosdk.agents import Agent, AgentCard, A2AMessage

class LoanAgent(Agent):
    def __init__(self):
        super().__init__(
            agent_id="specialist_1",
            instructions=(
                "You are a specialized loan expert at a bank. "
                "Provide detailed, helpful information about loans including interest rates, terms, and requirements. "
                "Give complete answers with specific details when possible. "
                "You can discuss personal loans, car loans, home loans, and business loans. "
                "Provide helpful guidance and next steps for loan applications. "
                "Be friendly and professional in your responses. "
                "Keep responses concise within 5-7 lines and easily understandable."
            )
        )

    async def handle_specialist_query(self, message: A2AMessage):
        """Process incoming queries from customer service agent"""
        query = message.content.get("query")
        if query:
            # Send the query to our AI model for processing
            await self.session.pipeline.send_text_message(query)

    async def handle_model_response(self, message: A2AMessage):
        """Send processed responses back to requesting agent"""
        response = message.content.get("response")
        requesting_agent = message.to_agent
        if response and requesting_agent:
            # Send the specialist response back to the customer service agent
            await self.a2a.send_message(
                to_agent=requesting_agent,
                message_type="specialist_response",
                content={"response": response}
            )

    async def on_enter(self):
        print("LoanAgent joined the system")

        # Register this agent with the A2A system
        await self.register_a2a(AgentCard(
            id="specialist_1",
            name="Loan Specialist Agent",
            domain="loan",
            capabilities=["loan_consultation", "loan_information", "interest_rates"],
            description="Handles loan queries with specialized expertise",
            metadata={"version": "1.0", "type": "specialist"}
        ))

        # Set up message listeners for different message types
        self.a2a.on_message("specialist_query", self.handle_specialist_query)
        self.a2a.on_message("model_response", self.handle_model_response)

    async def on_exit(self):
        print("LoanAgent left the system")
```

## Step 3: Configure Session Management

- **`Pipeline Creation`**: Sets up different pipeline configurations - customer agent gets audio-enabled Gemini for voice interaction, specialist gets text-only for efficiency.
- **`Session Factory`**: Provides `create_pipeline()` and `create_session()` functions to properly configure agent sessions based on their roles.
- **`Modality Separation`**: Ensures customer agent can handle voice while specialist processes text in background.

```python title="session_manager.py"
from videosdk.agents import AgentSession, RealTimePipeline
from videosdk.plugins.google import GeminiRealtime, GeminiLiveConfig
from typing import Dict

def create_pipeline(agent_type: str) -> RealTimePipeline:
    """Create appropriate pipeline based on agent type"""

    if agent_type == "customer":
        # Customer agent: Audio-enabled for real-time voice interaction
        model = GeminiRealtime(
            model="gemini-2.0-flash-live-001",
            config=GeminiLiveConfig(
                voice="Leda",  # Available voices: Puck, Charon, Kore, Fenrir, Aoede, Leda, Orus, Zephyr
                response_modalities=["AUDIO"]
            )
        )
    else:
        # Specialist agent: Text-only for efficient processing
        model = GeminiRealtime(
            model="gemini-2.0-flash-live-001",
            config=GeminiLiveConfig(response_modalities=["TEXT"])
        )

    return RealTimePipeline(model=model)

def create_session(agent, pipeline, context: Dict) -> AgentSession:
    """Create agent session with given configuration"""
    return AgentSession(agent=agent, pipeline=pipeline, context=context)
```

:::info
You can use OpenAI's text and audio features, Gemini's text and audio features, or a combination of both.
:::

## Step 4: Deploy A2A System on VideoSDK Platform

- **`Meeting Setup`**: Customer agent joins VideoSDK meeting for user interaction while specialist runs in background mode. Requires environment variables: `VIDEOSDK_AUTH_TOKEN` and `GOOGLE_API_KEY`, plus meeting ID configuration in session context.
- **`System Orchestration`**: Initializes both agents, creates their respective pipelines, and starts their sessions with proper meeting configurations
- **`Resource Management`**: Handles startup sequence, keeps system running, and provides clean shutdown with proper A2A unregistration

```python title="main.py"
import asyncio
from agents.customer_agent import CustomerServiceAgent
from agents.loan_agent import LoanAgent
from session_manager import create_pipeline, create_session

async def main():
    # Initialize both customer and specialist agents
    customer_agent = CustomerServiceAgent()
    specialist_agent = LoanAgent()

    # Create pipelines for different agent types
    customer_pipeline = create_pipeline("customer")
    specialist_pipeline = create_pipeline("specialist")

    # Create sessions with appropriate configurations
    customer_session = create_session(customer_agent, customer_pipeline, {
        "name": "Customer Service Assistant",
        "meetingId": "YOUR_MEETING_ID",  # Replace with your meeting ID
        "join_meeting": True  # Customer agent joins the meeting for user interaction
    })

    specialist_session = create_session(specialist_agent, specialist_pipeline, {
        "join_meeting": False  # Specialist agent runs in background
    })

    try:
        # Start both agent sessions
        await customer_session.start()
        await specialist_session.start()
        # Keep the system running until manually terminated
        await asyncio.Event().wait()

    except KeyboardInterrupt:
        print("\n Shutting down A2A system...")
    finally:
        # Clean up resources
        await customer_session.close()
        await specialist_session.close()
        await customer_agent.unregister_a2a()
        await specialist_agent.unregister_a2a()
        print(" System shutdown complete")

if __name__ == "__main__":
    asyncio.run(main())
```

#### Running the Application

```bash
cd A2A
python main.py
```

:::tip Quick Start

Get the complete working example at [A2A Quick Start Repository](https://github.com/videosdk-live/agents-quickstart/tree/main/A2A) with all the code ready to run.

:::


---

---
title: Agent to Agent (A2A)
hide_title: false
hide_table_of_contents: false
description: "Understanding the core concepts of Agent to Agent (A2A) communication in VideoSDK AI Agents - AgentCard, A2AMessage, agent registration, and discovery mechanisms for building collaborative multi-agent systems."
pagination_label: "A2A Overview"
keywords:
  - A2A Overview
  - A2A Protocol
  - Agent To Agent
  - AI Agent
  - Google's A2A
  - AgentCard
  - A2AMessage
  - Agent Registration
  - Agent Discovery
  - Multi-Agent Communication
  - VideoSDK Agents
  - AI Agent SDK
  - Agent Collaboration
image: img/videosdklive-thumbnail.jpg
sidebar_position: 5
sidebar_label: Overview
slug: overview
---

# Agent to Agent (A2A)

The Agent to Agent (A2A) protocol enables seamless collaboration between specialized AI agents, allowing them to communicate, share knowledge, and coordinate responses based on their unique capabilities and domain expertise. With VideoSDK's A2A implementation, you can create multi-agent systems where different agents work together to provide comprehensive solutions.

## How It Works

### Basic Flow

1. **Agent Registration**: Agents register themselves with an `AgentCard` that contains their capabilities and domain expertise
2. **Client Query**: Client sends a query to the main agent
3. **Agent Discovery**: Main agent discovers relevant specialist agents using agent cards
4. **Query Forwarding**: Main agent forwards specialized queries to appropriate agents
5. **Response Chain**: Specialist agents process queries and respond back to the main agent
6. **Client Response**: Main agent formats and delivers the final response to the client

![A2A Architecture](https://cdn.videosdk.live/website-resources/docs-resources/a2a_diagram.png)

### Example Scenario

```
Client → "Book a flight to New York and find a hotel"
   ↓
Travel Agent (Main) → Analyzes query
   ↓
Travel Agent → Discovers Flight Booking Agent & Hotel Booking Agent
   ↓
Travel Agent → Forwards flight query to Flight Booking Agent
Travel Agent → Forwards hotel query to Hotel Booking Agent
   ↓
Specialist Agents → Process queries and respond back (text format)
   ↓
Travel Agent → Combines responses and sends to client (audio format)
```

# Core Components

## 1. AgentCard

The `AgentCard` is how agents identify themselves and advertise their capabilities to other agents.

#### Structure

```python
AgentCard(
    id="agent_flight_001",
    name="Skymate",
    domain="flight",
    capabilities=[
        "search_flights",
        "modify_bookings",
        "show_flight_status"
    ],
    description="Handles all flight-related tasks"
)
```

#### Parameters

| Parameter      | Type   | Required | Description                          |
| -------------- | ------ | -------- | ------------------------------------ |
| `id`           | string | Yes      | Unique identifier for the agent      |
| `name`         | string | Yes      | Human-readable agent name            |
| `domain`       | string | Yes      | Primary expertise domain             |
| `capabilities` | list   | Yes      | List of specific capabilities        |
| `description`  | string | Yes      | Brief description of agent's purpose |
| `metadata`     | dict   | No       | Additional metadata for the agent    |

## 2. A2AMessage

`A2AMessage` is the standardized communication format between agents.

#### Structure

```python
message = A2AMessage(
    from_agent="travel_agent_1",
    to_agent="agent_flight_001",
    type="flight_status_query",
    content={"query": "What's the status of AI202?"},
    metadata={"client_id": "xyz123", "urgency": "medium"}
)
```

#### Parameters

| Parameter    | Type   | Required | Description                 |
| ------------ | ------ | -------- | --------------------------- |
| `from_agent` | string | Yes      | ID of the sending agent     |
| `to_agent`   | string | Yes      | ID of the receiving agent   |
| `type`       | string | Yes      | Message type/event name     |
| `content`    | dict   | Yes      | Message payload             |
| `metadata`   | dict   | No       | Additional message metadata |

## 3. Agent Registry

#### `register_a2a(agent_card)`

Register an agent with the A2A system.

```python
async def on_enter(self):
    await self.register_a2a(AgentCard(
        id="agent_flight_001",
        name="Skymate",
        domain="flight",
        capabilities=[
            "search_flights",
            "modify_bookings",
            "show_flight_status"
        ],
        description="Handles all flight-related tasks"
))
```

**What Registration Does:**

- Adds the agent to the global `AgentRegistry` singleton
- Makes the agent discoverable by other agents
- Stores both the `AgentCard` and agent instance
- Enables message routing to this agent

#### `unregister()`

Unregister an agent from the A2A system.

```python
await self.unregister_a2a()
```

## 4. A2AProtocol Class

The main class for managing agent-to-agent communication.

### Agent Discovery

#### `find_agents_by_domain(domain: str)`

Discover agents based on their domain expertise.

```python
agents = self.a2a.registry.find_agents_by_domain("hotel")
# Returns: ["agent_hotel_001"]
```

#### `find_agents_by_capability(cap: str)`

Find agents with specific skills.

```python
agents = await self.a2a.registry.find_agents_by_capability("modify_bookings")
# Returns: ["agent_flight_001"]
```

---

### Agent Communications

#### `send_message(to_agent, message_type, content, metadata=None)`

Send messages directly to other agents.

```python
await self.a2a.send_message(
    to_agent="agent_hotel_001",
    message_type="hotel_booking_query",  # Event name that the receiving agent listens for
    content={"query": "Find 3-star hotels in Delhi under $100"},
    metadata={"client_id": "xyz123"}     # Optional metadata
)
```

**Parameters:**

- `to_agent` (string): Target agent ID
- `message_type` (string): Event name the receiving agent listens for
- `content` (dict): Message payload
- `metadata` (dict, optional): Additional message metadata

#### `on_message(message_type, handler)`

Register message handlers for incoming messages.

```python
# Register a handler for specialist queries
self.a2a.on_message("hotel_booking_query", self.handle_specialist_query)

async def handle_specialist_query(self, message):
    # Process the incoming message
    query = message.content.get("query")
    # ... process query ...
    # Return response
    return {"response": "Current mortgage rates are 6.5%"}
```

## Next Steps

Now that you're familiar with the core A2A concepts, it's time to move from theory to practice:

👉 **[Explore the Full A2A Implementation](implementation)**
Dive into a complete, working example that demonstrates agent discovery, messaging, and collaboration in action.


---

---
title: Playground
hide_title: false
hide_table_of_contents: false
description: "Test and interact with your VideoSDK AI agents in real-time using Playground mode. Learn how to enable the interactive testing environment for rapid development and debugging of voice AI agents."
pagination_label: "Playground"
keywords:
  - AI Agent SDK
  - VideoSDK Agents
  - Playground
  - Testing
  - Python SDK
  - Voice AI
  - Real-time Communication
  - AI Integration
  - VideoSDK Cloud
  - Development
  - Debugging
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
sidebar_label: Playground
slug: playground
---

# Agents Playground

The Agents Playground provides an interactive testing environment where you can directly communicate with your AI agents during development. This feature enables rapid prototyping, testing, and debugging of your voice AI implementations without needing a separate client application.

## Overview

Playground mode creates a web-based interface that connects directly to your agent session, allowing you to:
- Test agent in real-time
- Demonstrate agent capabilities to stakeholders

## Enabling Playground Mode

To activate playground mode, simply set `playground: True` in your agent session context:

### Basic Implementation

```python
from videosdk.agents import AgentSession

def make_context():
    return {
        "meetingId": "<Meeting-ID>", 
        "name": "<Agent-Name>", 
        "playground": True
    }

# Initialize the agent session with all components
session = AgentSession(
    agent=VoiceAgent(),
    pipeline=pipeline,
    context=make_context
)

# Start the agent session
session.start()
```

## Accessing the Playground

Once your agent session starts, the playground URL will be displayed in your terminal:

```
Agent started in playground mode
Interact with agent here at:
https://playground.videosdk.live?token={auth_token}&meetingId={meeting_id}
```

### URL Structure

The playground URL follows this format:
```
https://playground.videosdk.live?token={auth_token}&meetingId={meeting_id}
```

Where:
- `auth_token`: videosdk_auth that is provided in session context or in env file.
- `meeting_id`: The meeting ID specified in session context.

**Note**: Playground mode is designed for development and testing purposes. For production deployments, ensure playground mode is disabled to maintain security and performance.


---

---
title: AI Voice Agent Quick Start
hide_title: false
hide_table_of_contents: false
description: "A step-by-step guide to quickly integrate an AI-powered voice agent into your VideoSDK meetings using the AI Agent SDK. Covers prerequisites, installation, custom agent creation, function tools, pipeline setup, and session management."
pagination_label: "AI Voice Agent Quick Start"
keywords:
  - AI Voice Agent
  - Quick Start
  - VideoSDK Agents
  - AI Agent SDK
  - Python
  - OpenAI
  - Gemini
  - Live API
  - Speech To Speech
  - Amazon Nova Sonic 
  - AWS Nova Sonic 
  - Function Tools
  - Real-time AI
  - Voice Integration
  - VideoSDK Meetings
image: img/videosdklive-thumbnail.jpg
sidebar_position: 2
sidebar_label: AI Voice Agent Quick Start
slug: voice-agent-quick-start
---

import Step from '@site/src/components/Step'

# AI Voice Agent Quick Start

This guide will help you integrate an AI-powered voice agent into your VideoSDK meetings.

## Prerequisites

Before you begin, ensure you have:

- A VideoSDK authentication token (generate from [app.videosdk.live](https://app.videosdk.live))
- - A VideoSDK meeting ID (you can generate one using the [Create Room API](https://docs.videosdk.live/api-reference/realtime-communication/create-room) or through the VideoSDK dashboard)
- Python 3.12 or higher
- API Key: An API key corresponding to your chosen model provider:
  - OpenAI API key (for OpenAI models)
  - Google Gemini API key (for Gemini's LiveAPI)
  - AWS credentials (aws_access_key_id and aws_secret_access_key) for Amazon Nova Sonic

## Installation

Create and activate a virtual environment with Python 3.12 or higher:

<Tabs
defaultValue="macOS/Linux"
groupId={"AIAgentQuickStart"}
values={[{label: 'macOS/Linux', value: 'macOS/Linux'},{label: 'Windows', value: 'Windows'}]}>

<TabItem value="macOS/Linux">

```js
python3.12 -m venv venv
source venv/bin/activate
```

</TabItem>

<TabItem value="Windows">

```js
python -m venv venv
venv\Scripts\activate
```
</TabItem>

</Tabs>

First, install the VideoSDK AI Agent package using pip:

```bash
pip install videosdk-agents
```

Now its time to install the plugin for your chosen AI model. Each plugin is tailored for seamless integration with the VideoSDK AI Agent SDK.

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="OpenAI"
groupId={"AIAgentQuickStart"}
values={[{label: 'OpenAI', value: 'OpenAI'},{label: 'Gemini(LiveAPI)', value: 'Gemini(LiveAPI)'},{label: 'AWS-Nova-Sonic', value: 'AWS-Nova-Sonic'}]}>

<TabItem value="OpenAI">

```js
pip install "videosdk-plugins-openai"
```

</TabItem>

<TabItem value="Gemini(LiveAPI)">

```js
pip install "videosdk-plugins-google"
```
</TabItem>


<TabItem value="AWS-Nova-Sonic">

```js
pip install "videosdk-plugins-aws"
```
</TabItem>

</Tabs>

## Environment Setup

It's recommended to use environment variables for secure storage of API keys, secret tokens, and authentication tokens. Create a `.env` file in your project root:

<Tabs
defaultValue="OpenAI"
groupId={"AIAgentQuickStart"}
values={[{label: 'OpenAI', value: 'OpenAI'},{label: 'Gemini(LiveAPI)', value: 'Gemini(LiveAPI)'},{label: 'AWS-Nova-Sonic', value: 'AWS-Nova-Sonic'}]}>

<TabItem value="OpenAI">

```js title=".env"
VIDEOSDK_AUTH_TOKEN=your_videosdk_auth_token
OPENAI_API_KEY=your_openai_api_key
```

</TabItem>

<TabItem value="Gemini(LiveAPI)">

```js title=".env"
VIDEOSDK_AUTH_TOKEN=your_videosdk_auth_token
GOOGLE_API_KEY=your_google_api_key
```
</TabItem>


<TabItem value="AWS-Nova-Sonic">

```js title=".env"
VIDEOSDK_AUTH_TOKEN=your_videosdk_auth_token
AWS_ACCESS_KEY_ID=your_aws_access_key
AWS_SECRET_ACCESS_KEY=your_aws_secret_key
AWS_DEFAULT_REGION=your_aws_region
```
</TabItem>

</Tabs>

## Generating a VideoSDK Meeting ID

Before your AI agent can join a meeting, you'll need to create a meeting ID. You can generate one using the VideoSDK Create Room API:

### Using cURL

```bash
curl -X POST https://api.videosdk.live/v2/rooms \
  -H "Authorization: YOUR_JWT_TOKEN_HERE" \
  -H "Content-Type: application/json"
```

For more details on the Create Room API, refer to the [VideoSDK documentation](https://docs.videosdk.live/api-reference/realtime-communication/create-room).

<div className="heading-toc-only">
### Step 1: Creating a Custom Agent
</div>
<Step number={1} title="Creating a Custom Agent">


First, let's create a custom voice agent by inheriting from the base `Agent` class:

```python title="main.py"
from videosdk.agents import Agent, function_tool

# External Tool
# async def get_weather(self, latitude: str, longitude: str):

class VoiceAgent(Agent):
    def __init__(self):
        super().__init__(
            instructions="You are a helpful voice assistant that can answer questions and help with tasks.",
             tools=[get_weather] # You can register any external tool defined outside of this scope
        )

    async def on_enter(self) -> None:
        """Called when the agent first joins the meeting"""
        await self.session.say("Hi there! How can I help you today?")
```

This code defines a basic voice agent with:

- Custom instructions that define the agent's personality and capabilities
- An entry message when joining a meeting
- State change handling to track the agent's current activity

</Step>

<div className="heading-toc-only">
### Step 2: Implementing Function Tools
</div>
<Step number={2} title="Implementing Function Tools">

Function tools allow your agent to perform actions beyond conversation. There are two ways to define tools:

- **External Tools:** Defined as standalone functions outside the agent class and registered via the `tools` argument in the agent's constructor.
- **Internal Tools:** Defined as methods inside the agent class and decorated with `@function_tool`.

Below is an example of both:

```python title="main.py"
import aiohttp

# External Function Tools
@function_tool
def get_weather(latitude: str, longitude: str):
    """Called when the user asks about the weather. This function will return the weather for
    the given location. When given a location, please estimate the latitude and longitude of the
    location and do not ask the user for them.

    Args:
        latitude: The latitude of the location
        longitude: The longitude of the location
    """
    print(f"Getting weather for {latitude}, {longitude}")
    url = f"https://api.open-meteo.com/v1/forecast?latitude={latitude}&longitude={longitude}&current=temperature_2m"

    async with aiohttp.ClientSession() as session:
        async with session.get(url) as response:
            if response.status == 200:
                data = await response.json()
                return {
                    "temperature": data["current"]["temperature_2m"],
                    "temperature_unit": "Celsius",
                }
            else:
                raise Exception(
                    f"Failed to get weather data, status code: {response.status}"
                )

class VoiceAgent(Agent):
# ... previous code ...
# Internal Function Tools
    @function_tool
    async def get_horoscope(self, sign: str) -> dict:
        """Get today's horoscope for a given zodiac sign.

        Args:
            sign: The zodiac sign (e.g., Aries, Taurus, Gemini, etc.)
        """
        horoscopes = {
            "Aries": "Today is your lucky day!",
            "Taurus": "Focus on your goals today.",
            "Gemini": "Communication will be important today.",
        }
        return {
            "sign": sign,
            "horoscope": horoscopes.get(sign, "The stars are aligned for you today!"),
        }
```

- Use external tools for reusable, standalone functions (registered via `tools=[...]`).
- Use internal tools for agent-specific logic as class methods.
- Both must be decorated with `@function_tool` for the agent to recognize and use them.

</Step>

<div className="heading-toc-only">
### Step 3: Setting Up the Pipeline
</div>
<Step number={3} title="Setting Up the Pipeline">

The pipeline connects your agent to an AI model. In this example, we're using OpenAI's real-time model:

<Tabs
defaultValue="OpenAI"
groupId={"AIAgentQuickStart"}
values={[{label: 'OpenAI', value: 'OpenAI'},{label: 'Gemini(LiveAPI)', value: 'Gemini(LiveAPI)'},{label: 'AWS-Nova-Sonic', value: 'AWS-Nova-Sonic'}]}>

<TabItem value="OpenAI">

```python title="main.py"
from videosdk.plugins.openai import OpenAIRealtime, OpenAIRealtimeConfig
from videosdk.agents import RealTimePipeline
from openai.types.beta.realtime.session import TurnDetection

async def start_session(context: dict):
    # Initialize the AI model
    model = OpenAIRealtime(
        model="gpt-4o-realtime-preview",
        # When OPENAI_API_KEY is set in .env - DON'T pass api_key parameter
        api_key="sk-proj-XXXXXXXXXXXXXXXXXXXX",
        config=OpenAIRealtimeConfig(
            voice="alloy", # alloy, ash, ballad, coral, echo, fable, onyx, nova, sage, shimmer, and verse
            modalities=["text", "audio"],
            turn_detection=TurnDetection(
                type="server_vad",
                threshold=0.5,
                prefix_padding_ms=300,
                silence_duration_ms=200,
            ),
            tool_choice="auto"
        )
    )

    pipeline = RealTimePipeline(model=model)

    # Continue to the next steps...
```

</TabItem>

<TabItem value="Gemini(LiveAPI)">

```python title="main.py"
from videosdk.plugins.google import GeminiRealtime, GeminiLiveConfig
from videosdk.agents import RealTimePipeline

async def start_session(context: dict):
    # Initialize the AI model
    model = GeminiRealtime(
        model="gemini-2.0-flash-live-001",
        # When GOOGLE_API_KEY is set in .env - DON'T pass api_key parameter
        api_key="AKZSXXXXXXXXXXXXXXXXXXXX",
        config=GeminiLiveConfig(
            voice="Leda", # Puck, Charon, Kore, Fenrir, Aoede, Leda, Orus, and Zephyr.
            response_modalities=["AUDIO"]
        )
    )

    pipeline = RealTimePipeline(model=model)

    # Continue to the next steps...
```
</TabItem>


<TabItem value="AWS-Nova-Sonic">

```python title="main.py"
from videosdk.plugins.aws import NovaSonicRealtime, NovaSonicConfig
from videosdk.agents import RealTimePipeline

async def start_session(context: dict):
    # Initialize the AI model
    model = NovaSonicRealtime(
        model="amazon.nova-sonic-v1:0",
        # When AWS credentials and region are set in .env - DON'T pass credential parameters
        region="us-east-1",  # Currently, only "us-east-1" is supported for Amazon Nova Sonic.
        aws_access_key_id="AWSXXXXXXXXXXXXXXXXXXXX", 
        aws_secret_access_key="AQSXXXXXXXXXXXXXXXXXXXX", 
        config=NovaSonicConfig(
            voice="tiffany", #  "tiffany","matthew", "amy"
            temperature=0.7,
            top_p=0.9,
            max_tokens=1024
        )
    )

    pipeline = RealTimePipeline(model=model)

    # Continue to the next steps...
```

:::note
To initiate a conversation with Amazon Nova Sonic, the user must speak first. The model listens for user input to begin the interaction.
:::

</TabItem>

</Tabs>
:::note
When using .env file for credentials, don't pass them as arguments to model instances or context objects. The SDK automatically reads environment variables, so omit api_key, videosdk_auth, and other credential parameters from your code.
:::

</Step>

<div className="heading-toc-only">
### Step 4: Assembling and Starting the Agent Session
</div>
<Step number={4} title="Assembling and Starting the Agent Session">

Now, let's put everything together and start the agent session:

```python title="main.py"
import asyncio
from videosdk.agents import AgentSession

async def start_session(context: dict):
    # ... previous setup code ...

    # Create the agent session
    session = AgentSession(
        agent=VoiceAgent(),
        pipeline=pipeline,
        context=context
    )

    try:
        # Start the session
        await session.start()
        # Keep the session running until manually terminated
        await asyncio.Event().wait()
    finally:
        # Clean up resources when done
        await session.close()

if __name__ == "__main__":
    def make_context():
        # When VIDEOSDK_AUTH_TOKEN is set in .env - DON'T include videosdk_auth
        return {
        "meetingId": "your_actual_meeting_id_here",  # Replace with actual meeting ID
        "name": "AI Voice Agent", 
        "videosdk_auth": "your_videosdk_auth_token_here"  # Replace with actual token
    }
    
    asyncio.run(start_session(context=make_context()))
```
</Step>

<div className="heading-toc-only">
### Step 5: Connecting with VideoSDK Client Applications
</div>
<Step number={5} title="Connecting with VideoSDK Client Applications">

After setting up your AI Agent, you'll need a client application to connect with it. You can use any of the VideoSDK quickstart examples to create a client that joins the same meeting:

- [JavaScript](https://github.com/videosdk-live/quickstart/tree/main/js-rtc)
- [React](https://github.com/videosdk-live/quickstart/tree/main/react-rtc)
- [React Native](https://github.com/videosdk-live/quickstart/tree/main/react-native)
- [Android](https://github.com/videosdk-live/quickstart/tree/main/android-rtc)
- [Flutter](https://github.com/videosdk-live/quickstart/tree/main/flutter-rtc)
- [iOS](https://github.com/videosdk-live/quickstart/tree/main/ios-rtc)

When setting up your client application, make sure to use the same meeting ID that your AI Agent is using.

</Step>

<div className="heading-toc-only">
### Step 6: Running the Project
</div>
<Step number={6} title="Running the Project">

Once you have completed the setup, you can run your AI Voice Agent project using Python. Make sure your `.env` file is properly configured and all dependencies are installed.

```bash
python main.py
```
</Step>

:::tip

Get started quickly with the [Quick Start Example](https://github.com/videosdk-live/agents-quickstart/) for the VideoSDK AI Agent SDK — everything you need to build your first AI agent fast.

:::

---

---
title: Agent Session
hide_title: false
hide_table_of_contents: false
description: "Discover how the `AgentSession` in VideoSDK's AI Agent SDK orchestrates various components into a unified workflow, managing the agent's interaction lifecycle and context for seamless real-time communication."
pagination_label: "Agent Session"
keywords:
  - AgentSession
  - AI Agent SDK
  - VideoSDK Agents
  - Component Orchestration
  - Session Management
  - Context Handling
  - Agent Workflow
  - Real-time AI
  - Python SDK
image: img/videosdklive-thumbnail.jpg
sidebar_position: 5
sidebar_label: Agent Session
slug: agent-session
---

# Agent Session

The `AgentSession` integrates all the components into a cohesive workflow, creating a complete agent interaction system.

#### Key Features:

- Component orchestration
- Session lifecycle management
- Context handling

#### Example Implementation:

```python
from videosdk.agents import AgentSession

def make_context():
    return {"meetingId": "<Meeting-ID>", "name": "<Agent-Name>"}

# Initialize the agent session with all components
session = AgentSession(
    agent=VoiceAgent(),
    pipeline=pipeline,
    context=make_context
)

# Start the agent session
    session.start()
```


---

---
title: Agent
hide_title: false
hide_table_of_contents: false
description: "Learn about the `Agent` base class in the VideoSDK AI Agent SDK. Understand how to create custom agents, define system prompts, manage state, and register function tools."
pagination_label: "Agent"
keywords:
  - Agent Class
  - AI Agent SDK
  - VideoSDK Agents
  - Custom Agents
  - System Prompts
  - State Management
  - Function Tools
  - Python SDK
image: img/videosdklive-thumbnail.jpg
sidebar_position: 2
sidebar_label: Agent
slug: agent
---

# Agent

The `Agent` base class serves as the foundation for creating custom agents. By inheriting from this class, you can define system prompts and register function tools.

### Key Features:

- Custom instruction configuration
- State management lifecycle hooks
- Function tool registration (internal and external)

#### Example Implementation:

You can register function tools in two ways:

- **External Tools:** Defined as standalone functions outside the agent class and registered via the `tools` argument in the agent's constructor.
- **Internal Tools:** Defined as methods inside the agent class and decorated with `@function_tool`.

```python
from videosdk.agents import Agent

# --- External Function Tool ---
@function_tool
def get_weather(latitude: str, longitude: str):
    """Called when the user asks about the weather. This function will return the weather for
    the given location. When given a location, please estimate the latitude and longitude of the
    location and do not ask the user for them.

    Args:
        latitude: The latitude of the location
        longitude: The longitude of the location
    """
    print(f"Getting weather for {latitude}, {longitude}")
    url = f"https://api.open-meteo.com/v1/forecast?latitude={latitude}&longitude={longitude}&current=temperature_2m"

    async with aiohttp.ClientSession() as session:
        async with session.get(url) as response:
            if response.status == 200:
                data = await response.json()
                return {
                    "temperature": data["current"]["temperature_2m"],
                    "temperature_unit": "Celsius",
                }
            else:
                raise Exception(
                    f"Failed to get weather data, status code: {response.status}"
                )

class VoiceAgent(Agent):
    def __init__(self):
        super().__init__(
            instructions="You are a helpful voice assistant that can answer questions and help with tasks.",
            tools=[get_weather]  # Register external tools here
        )

    # --- Internal Function Tool ---
    @function_tool
    async def get_horoscope(self, sign: str) -> dict:
        """Get today's horoscope for a given zodiac sign.

        Args:
            sign: The zodiac sign (e.g., Aries, Taurus, Gemini, etc.)

        Returns:
            dict: Contains the sign and horoscope text
        """
        horoscopes = {
            "Aries": "Today is your lucky day!",
            "Taurus": "Focus on your goals today.",
            "Gemini": "Communication will be important today.",
        }
        return {
            "sign": sign,
            "horoscope": horoscopes.get(sign, "The stars are aligned for you today!"),
        }
```


---

---
title: Cascading Pipeline
hide_title: false
hide_table_of_contents: false
description: "Explore the `Cascading Pipeline` component in the VideoSDK AI Agent SDK. Learn how it manages AI models (like OpenAI and Gemini), configurations, streaming audio, and multi-modal capabilities."
pagination_label: "Cascading Pipeline"
keywords:
  - Pipeline Component
  - AI Agent SDK
  - VideoSDK Agents
  - AI Models
  - OpenAI
  - Gemini
  - Model Configuration
  - Streaming Audio
  - Multi-modal AI
  - Python SDK
image: img/videosdklive-thumbnail.jpg
sidebar_position: 4
sidebar_label: Cascading Pipeline
slug: cascading-pipeline
---

# Cascading Pipeline

The `Cascading Pipeline` component provides a flexible, modular approach to building AI agents by allowing you to mix and match different components for Speech-to-Text (STT), Large Language Models (LLM), Text-to-Speech (TTS), Voice Activity Detection (VAD), and Turn Detection.

#### Key Features:

- **Modular Component Selection** - Choose different providers for each component
- **Flexible Configuration** - Mix and match STT, LLM, TTS, VAD, and Turn Detection
- **Custom Processing** - Add custom processing for STT and LLM outputs
- **Provider Agnostic** - Support for multiple AI service providers
- **Advanced Control** - Fine-tune each component independently

#### Example Implementation:

```python
from videosdk.agents import CascadingPipeline
from videosdk.plugins.openai import OpenAILLM
from videosdk.plugins.deepgram import DeepgramSTT
from videosdk.plugins.silero import SileroVAD
from videosdk.plugins.turn_detector import TurnDetector

    stt=DeepgramSTT(
        api_key=os.getenv("DEEPGRAM_API_KEY"),
        model="nova-2",
        language="en"
    )

    llm=OpenAILLM(
        api_key=os.getenv("OPENAI_API_KEY"),
        model="gpt-4o"
    )

    tts=ElevenLabsTTS(
        api_key=os.getenv("ELEVENLABS_API_KEY"),
        voice_id="your-voice-id"
    )

    vad=SileroVAD(
        threshold = 0.35
    )

    turn_detector=TurnDetector(t
    threshold=0.8
    )

pipeline = CascadingPipeline(stt=stt, llm=llm, tts=tts, vad=vad, turn_detector=turn_detector)
```

#### Use Cases:

- **Multi-language Support** - Use specialized STT for different languages
- **Cost Optimization** - Mix premium and cost-effective services
- **Custom Voice Processing** - Add domain-specific processing logic
- **Performance Optimization** - Choose fastest providers for each component
- **Compliance Requirements** - Use specific providers for regulatory compliance 

---

---
title: Conversation Flow
hide_title: false
hide_table_of_contents: false
description: "Explore the `Conversation Flow` component in the VideoSDK AI Agent SDK. Learn how it manages turn taking in the Agents"
pagination_label: "Conversation Flow"
keywords:
  - Conversation Flow
  - AI Agent SDK
  - VideoSDK Agents
  - AI Models
  - OpenAI
  - Gemini
  - Model Configuration
  - Streaming Audio
  - Multi-modal AI
  - Python SDK
image: img/videosdklive-thumbnail.jpg
sidebar_position: 4
sidebar_label: Conversation Flow
slug: conversation-flow
---

# Conversation Flow

The `Conversation Flow` component is an inheritable class that enables custom turn-taking logic, transcript preprocessing, and memory/RAG integrations before LLM processing.

#### Key Features:

- Custom transcript preprocessing
- Turn-based conversation management
- Memory and RAG integration hooks
- Flexible LLM processing pipeline
- Streaming response support

#### Example Implementation:

```python
from videosdk.agents import Agent, ConversationFlow, ChatContext

class MyConversationFlow(ConversationFlow):
    def __init__(self, agent, stt=None, llm=None, tts=None):
        super().__init__(agent, stt, llm, tts)

    async def run(self, transcript: str) -> AsyncIterator[str]:
        """Main conversation loop: handle a user turn."""
        await self.on_turn_start(transcript)

        # Pre-process transcript: clean, normalize, validate input
        # Apply custom business logic, content filtering
        # sample impl
        processed_transcript = transcript.lower().strip()
        self.agent.chat_context.add_message(role=ChatRole.USER, content=processed_transcript)
        
        # Use process_with_llm method for invoking llm after pre processing transcript
        async for response_chunk in self.process_with_llm():
            yield response_chunk

        await self.on_turn_end()

    async def on_turn_start(self, transcript: str) -> None:
        """Called at the start of a user turn."""
        # Fetch relevant context from memory/database
        # Perform RAG retrieval for enhanced responses  
        # Initialize turn-specific variables
        # Log conversation analytics
        self.is_turn_active = True

    async def on_turn_end(self) -> None:
        """Called at the end of a user turn."""
        # Store conversation in memory/database
        # Update user preferences and context
        # Perform cleanup operations
        # Log turn completion metrics
        self.is_turn_active = False
```

#### Use Cases:

- **RAG Implementation** - Retrieve relevant documents and context before LLM processing
- **Memory Management** - Store and recall conversation history across sessions
- **Content Filtering** - Apply safety checks and content moderation on input/output
- **Analytics & Logging** - Track conversation metrics and user behavior patterns
- **Business Logic Integration** - Add domain-specific processing and validation rules
- **Multi-step Workflows** - Implement complex conversation flows with state management

The key methods allow you to inject custom logic at different stages of the conversation flow, enabling sophisticated AI agent behaviors while maintaining clean separation of concerns.

:::note

Conversation Flow works with [Cascading Pipeline](cascading-pipeline.md) currently.

:::


---

---
title: Overview
hide_title: false
hide_table_of_contents: false
description: "Get an overview of the VideoSDK AI Agent SDK, a framework for building AI agents for real-time conversations. Learn about its core components: Agent, Pipeline, and Agent Session."
pagination_label: "Overview"
keywords:
  - AI Agent SDK
  - VideoSDK Agents
  - Core Components
  - Agent
  - Pipeline
  - Agent Session
  - Real-time AI
  - Agentic Workflow
  - Python SDK
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
sidebar_label: Overview
slug: overview
---

The AI Agent SDK provides a powerful framework for building AI agents that can participate in real-time conversations. This guide explains the core components and demonstrates how to create a complete agentic workflow.

## Core Components

The SDK consists of four primary components:

1. **Agent** - Base class for defining agent behavior and capabilities
2. **Pipeline** - Manages model selection and configuration
3. **Agent Session** - Combines all components into a cohesive workflow

<img style={{height: '500px'}} src="https://cdn.videosdk.live/website-resources/docs-resources/ai_agents_core_components.png" />


---

---
title: Realtime Pipeline
hide_title: false
hide_table_of_contents: false
description: "Explore the `Realtime Pipeline` component in the VideoSDK AI Agent SDK. Learn how it manages AI models (like OpenAI and Gemini), configurations, streaming audio, and multi-modal capabilities."
pagination_label: "Realtime Pipeline"
keywords:
  - Pipeline Component
  - AI Agent SDK
  - VideoSDK Agents
  - AI Models
  - OpenAI
  - Gemini
  - Model Configuration
  - Streaming Audio
  - Multi-modal AI
  - Python SDK
image: img/videosdklive-thumbnail.jpg
sidebar_position: 3
sidebar_label: Realtime Pipeline
slug: realtime-pipeline
---

# Realtime Pipeline

The `Realtime Pipeline` component manages the AI model and its configuration. It provides a standardized interface for different model providers.

#### Key Features:

- Flexible model selection
- Configurable model parameters
- Streaming audio support
- Multi-modal capabilities

#### Example Implementation:

```python
from videosdk.agents import RealTimePipeline
from openai.types.beta.realtime.session import  TurnDetection
from videosdk.plugins.google import OpenAIRealtime, OpenAIRealtimeConfig

# For Gemini
# from videosdk.plugins.gemini import GeminiRealtime, GeminiLiveConfig
# from google.genai.types import AudioTranscriptionConfig

# Option 1: Using OpenAI's real-time models
openai_model = OpenAIRealtime(
    model="gpt-4o-realtime-preview",
    api_key="your-openai-api-key"  # Or use environment variable
)

# Option 2: Using Google's models
# gemini_model = GeminiRealtime(
#     model="gemini-pro-1.5",
#     api_key="your-google-api-key"
# )

# Configure the pipeline with your selected model
    model = OpenAIRealtime(
        model="gpt-4o-realtime-preview",
        config=OpenAIRealtimeConfig(
            modalities=["text", "audio"],
            turn_detection=TurnDetection(
                type="server_vad",
                threshold=0.5,
                prefix_padding_ms=300,
                silence_duration_ms=200,
            ),
            tool_choice="auto"
        )
    )

    # For Gemini
    #     model = GeminiRealtime(
    #     model="gemini-2.0-flash-live-001",
    #     config=GeminiLiveConfig(
    #         response_modalities=["AUDIO"],
    #     )
    # )

# Create the pipeline with the model and configuration
pipeline = RealTimePipeline(model=openai_model)
```


---

---
title: Introduction
hide_title: false
hide_table_of_contents: false
description: "Introduce yourself to the VideoSDK AI Agent SDK, a Python framework for integrating AI-powered voice agents into VideoSDK meetings. Understand its high-level architecture and how it bridges AI models with users for real-time interactions."
pagination_label: "Introduction"
keywords:
  - AI Agent SDK
  - VideoSDK Agents
  - Introduction
  - Python SDK
  - Voice AI
  - Real-time Communication
  - AI Integration
  - VideoSDK Cloud
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
sidebar_label: Introduction
slug: introduction
---

# Introduction

The AI Agent SDK is a Python framework built on top of the VideoSDK Python SDK that enables AI-powered agents to join VideoSDK rooms as participants. This SDK serves as a real-time bridge between AI models (like OpenAI and Gemini) and your users, facilitating seamless voice and media interactions.

## High Level Architecture

This architecture shows how AI voice agents connect to VideoSDK meetings. The system links your backend with VideoSDK's platform, allowing AI assistants to interact with users in real-time.

<img src="https://cdn.videosdk.live/website-resources/docs-resources/ai_agents_high_level_diagram_compressed.png" />

### System Components

- **Your Backend**: Hosts the Worker and Agent Job that powers the AI agents
- **VideoSDK Cloud**: Manages the meeting rooms where agents and users interact in real time
- **Client SDK**: Applications on user devices (web, mobile, or SIP) that connect to VideoSDK meetings

### Process Flow

1. **Register**: Your backend worker registers with the VideoSDK Cloud
2. **Initiate to join Room**: The user initiates joining a VideoSDK Room via the Client SDK on their device
3. **Notify worker for Agent to join Room**: The VideoSDK Cloud notifies your backend worker to have an Agent join the room.
4. **Agent joins the room**: The Agent connects to the VideoSDK Room and can interact with the user.


---

---
title: MCP Integration
hide_title: false
hide_table_of_contents: false
description: "Learn how to integrate Model Context Protocol (MCP) servers with VideoSDK AI Agents to extend your agent's capabilities with external services, databases, and APIs using STDIO and HTTP transport methods."
pagination_label: "MCP Integration"
keywords:
  - MCP Integration
  - Model Context Protocol
  - MCP Client
  - MCP Servers 
  - Multiple MCP Servers 
  - MCP Server Client Example
  - VideoSDK Agents
  - AI Agent SDK
  - Python
  - MCP Tools
  - MCP Standard Input/Output (stdio)
  - MCP Streamable HTTP
  - MCP Server-Sent Events (SSE)
  - External APIs
  - Voice Agent Sessions
  - Real Time MCP 
image: img/videosdklive-thumbnail.jpg
sidebar_position: 4
sidebar_label: MCP Integration
slug: mcp-integration
---

The Model Context Protocol (MCP) is an open standard that enables AI assistants to securely connect to data sources and tools. With VideoSDK's AI Agents, you can seamlessly integrate MCP servers to extend your agent's capabilities with external services or applications, databases, and APIs.
## MCP Server Types
VideoSDK supports two transport methods for MCP servers:

### 1. STDIO Transport
- Direct process communication
- Local Python scripts
- Best for custom tools and functions
- Ideal for server-side integrations

### 2. HTTP Transport (Streamable HTTP or SSE)
- Network-based communication
- External MCP services
- Best for third-party integrations
- Supports remote MCP servers

## How It Works with VideoSDK's AI Agent

MCP tools are automatically discovered and made available to your agent. Agent will intelligently choose which tools to use based on user requests. When a user asks for information that requires external data, the agent will:

- Identify the need for external data based on the user's request
- Select appropriate tools from available MCP servers
- Execute the tools with relevant parameters
- Process the results and provide a natural language response

This seamless integration allows your voice agent to access real-time data and external services while maintaining a natural conversational flow.


## Creating an MCP Server

# Basic MCP Server Structure

A simple MCP server using STDIO to return the current time. First, install the required package:

```bash
pip install fastmcp
```

```python title="mcp_stdio_example.py"
from mcp.server.fastmcp import FastMCP
import datetime

# Create the MCP server
mcp = FastMCP("CurrentTimeServer")

@mcp.tool()
def get_current_time() -> str:
    """Get the current time in the user's location"""

    # Get current time
    now = datetime.datetime.now()
    
    # Return formatted time string
    return f"The current time is {now.strftime('%H:%M:%S')} on {now.strftime('%Y-%m-%d')}"

if __name__ == "__main__":
    # Run the server with STDIO transport
    mcp.run(transport="stdio")
```

## Integrating MCP with VideoSDK Agent

Now we'll see how to integrate MCP servers with your VideoSDK AI Agent:

```python title="main.py"
import asyncio
import pathlib
import sys
from videosdk.agents import Agent, AgentSession, RealTimePipeline,MCPServerStdio, MCPServerHTTP
from videosdk.plugins.google import GeminiRealtime, GeminiLiveConfig

class MyVoiceAgent(Agent):
    def __init__(self):
        # Define paths to your MCP servers
        mcp_script = Path(__file__).parent.parent / "MCP_Example" / "mcp_stdio_example.py"
        super().__init__(
            instructions="""You are a helpful assistant with access to real-time data. 
            You can provide current time information. 
            Always be conversational and helpful in your responses.""",
            mcp_servers=[
                # STDIO MCP Server (Local Python script for time)
                MCPServerStdio(
                    command=sys.executable,  # Use current Python interpreter
                    args=[str(mcp_script)],
                    client_session_timeout_seconds=30
                ),
                # HTTP MCP Server (External service example e.g Zapier)
                MCPServerHTTP(
                    url="https://your-mcp-service.com/api/mcp",
                    client_session_timeout_seconds=30
                )
            ]
        )

    async def on_enter(self) -> None:
        await self.session.say("Hi there! How can I help you today?")

    async def on_exit(self) -> None:
        await self.session.say("Thank you for using the assistant. Goodbye!")

async def main(context: dict):
    
    # Configure Gemini Realtime model
    model = GeminiRealtime(
        model="gemini-2.0-flash-live-001",
        config=GeminiLiveConfig(
            voice="Leda",  # Available voices: Puck, Charon, Kore, Fenrir, Aoede, Leda, Orus, Zephyr
            response_modalities=["AUDIO"]
        )
    )

    pipeline = RealTimePipeline(model=model)
    agent = MyVoiceAgent()

    session = AgentSession(
        agent=agent,
        pipeline=pipeline,
        context=context
    )

    try:
        # Start the session
        await session.start()
        # Keep the session running until manually terminated
        await asyncio.Event().wait()
    finally:
        # Clean up resources when done
        await session.close()

if __name__ == "__main__":
    def make_context():
        # When VIDEOSDK_AUTH_TOKEN is set in .env - DON'T include videosdk_auth
        return {
        "meetingId": "your_actual_meeting_id_here",  # Replace with actual meeting ID
        "name": "AI Voice Agent", 
        "videosdk_auth": "your_videosdk_auth_token_here"  # Replace with actual token
    }

```

:::tip

Get started quickly with the [Quick Start Example](https://github.com/videosdk-live/agents-quickstart/tree/main/MCP%20Server) for the VideoSDK AI Agent SDK With MCP — everything you need to build your first AI agent fast.

:::


---

---
title: Google LLM
hide_title: false
hide_table_of_contents: false
description: "Learn how to use Google's LLM models (Gemini) with the VideoSDK AI Agent SDK. This guide covers model configuration, API integration, and implementing text-based AI capabilities for your conversational agents."
pagination_label: "Google LLM"
keywords:
  - Google
  - Gemini
  - gemini-2.0-flash-001
  - LLM
  - Large Language Model
  - VideoSDK Agents
  - Python SDK
  - Text Generation
  - AI Chat
  - Conversational AI
image: img/videosdklive-thumbnail.jpg
sidebar_position: 2
sidebar_label: Google
slug: google-llm
---

# Google LLM

The Google LLM provider enables your agent to use Google's Gemini family of language models for text-based conversations and processing.

## Installation

Install the Google-enabled VideoSDK Agents package:

```bash
pip install "videosdk-plugins-google"
```

## Importing

```python
from videosdk.plugins.google import GoogleLLM
```

## Example Usage

```python
from videosdk.plugins.google import GoogleLLM
from videosdk.agents import CascadingPipeline

# Initialize the Google LLM model
llm = GoogleLLM(
    model="gemini-2.0-flash-001",
    # When GOOGLE_API_KEY is set in .env - DON'T pass api_key parameter
    api_key="your-google-api-key",
    temperature=0.7,
    tool_choice="auto",
    max_output_tokens=1000
)

#  Add llm to cascading pipeline
pipeline = CascadingPipeline(llm=llm)
```
:::note
When using .env file for credentials, don't pass them as arguments to model instances or context objects. The SDK automatically reads environment variables, so omit `api_key` and other credential parameters from your code.
:::

## Configuration Options

- `model`: (str) The Google model to use (e.g., `"gemini-2.0-flash-001"`, `"gemini-1.5-pro"`) (default: `"gemini-2.0-flash-001"`).
- `api_key`: (str) Your Google API key. Can also be set via the `GOOGLE_API_KEY` environment variable.
- `temperature`: (float) Sampling temperature for response randomness (default: `0.7`).
- `tool_choice`: (ToolChoice) Tool selection mode (`"auto"`, `"required"`, `"none"`) (default: `"auto"`).
- `max_output_tokens`: (int) Maximum number of tokens in the completion response (optional).
- `top_p`: (float) The nucleus sampling probability (optional).
- `top_k`: (int) The top-k sampling parameter (optional).
- `presence_penalty`: (float) Penalizes new tokens based on whether they appear in the text so far (optional).
- `frequency_penalty`: (float) Penalizes new tokens based on their existing frequency in the text so far (optional). 

---

---
title: OpenAI LLM
hide_title: false
hide_table_of_contents: false
description: "Learn how to use OpenAI's LLM models with the VideoSDK AI Agent SDK. This guide covers model configuration, API integration, and implementing text-based AI capabilities for your conversational agents."
pagination_label: "OpenAI LLM"
keywords:
  - OpenAI
  - GPT-4o
  - LLM
  - Large Language Model
  - VideoSDK Agents
  - Python SDK
  - Text Generation
  - AI Chat
  - Conversational AI
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
sidebar_label: OpenAI
slug: openai
---

# OpenAI LLM

The OpenAI LLM provider enables your agent to use OpenAI's language models (like GPT-4o) for text-based conversations and processing.

## Installation

Install the OpenAI-enabled VideoSDK Agents package:

```bash
pip install "videosdk-plugins-openai"
```

## Importing

```python
from videosdk.plugins.openai import OpenAILLM
```

## Example Usage

```python
from videosdk.plugins.openai import OpenAILLM
from videosdk.agents import CascadingPipeline

# Initialize the OpenAI LLM model
llm = OpenAILLM(
    model="gpt-4o",
    # When OPENAI_API_KEY is set in .env - DON'T pass api_key parameter
    api_key="your-openai-api-key",
    temperature=0.7,
    tool_choice="auto",
    max_completion_tokens=1000
)

#  Add llm to cascading pipeline
pipeline = CascadingPipeline(llm=llm)
```
:::note
When using .env file for credentials, don't pass them as arguments to model instances or context objects. The SDK automatically reads environment variables, so omit api_key, videosdk_auth, and other credential parameters from your code.
:::

## Configuration Options

- `model`: The OpenAI model to use (e.g., `"gpt-4o"`, `"gpt-4o-mini"`, `"gpt-3.5-turbo"`)
- `api_key`: Your OpenAI API key (can also be set via environment variable)
- `base_url`: Custom base URL for OpenAI API (optional)
- `temperature`: (float) Sampling temperature for response randomness (0.0 to 2.0, default: 0.7)
- `tool_choice`: Tool selection mode (e.g., `"auto"`, `"none"`, or specific tool)
- `max_completion_tokens`: (int) Maximum number of tokens in the completion response

---

---
title: Sarvam AI LLM
hide_title: false
hide_table_of_contents: false
description: "Learn how to use Sarvam AI's LLM models with the VideoSDK AI Agent SDK. This guide covers model configuration, API integration, and implementing text-based AI capabilities for your conversational agents."
pagination_label: "Sarvam AI LLM"
keywords:
  - Sarvam AI
  - sarvam-m
  - LLM
  - Large Language Model
  - VideoSDK Agents
  - Python SDK
  - Text Generation
  - AI Chat
  - Conversational AI
image: img/videosdklive-thumbnail.jpg
sidebar_position: 3
sidebar_label: Sarvam AI
slug: sarvam-ai-llm
---

# Sarvam AI LLM

The Sarvam AI LLM provider enables your agent to use Sarvam AI's language models for text-based conversations and processing.

## Installation

Install the Sarvam AI-enabled VideoSDK Agents package:

```bash
pip install "videosdk-plugins-sarvamai"
```

## Importing

```python
from videosdk.plugins.sarvamai import SarvamAILLM
```

:::note
When using Sarvam AI as the LLM option, the function tool calls and MCP tool will not work.
:::

## Example Usage

```python
from videosdk.plugins.sarvamai import SarvamAILLM
from videosdk.agents import CascadingPipeline

# Initialize the Sarvam AI LLM model
llm = SarvamAILLM(
    model="sarvam-m",
    # When SARVAMAI_API_KEY is set in .env - DON'T pass api_key parameter
    api_key="your-sarvam-ai-api-key",
    temperature=0.7,
    tool_choice="auto",
    max_completion_tokens=1000
)

#  Add llm to cascading pipeline
pipeline = CascadingPipeline(llm=llm)
```
:::note
When using .env file for credentials, don't pass them as arguments to model instances or context objects. The SDK automatically reads environment variables, so omit `api_key` and other credential parameters from your code.
:::

## Configuration Options

- `model`: (str) The Sarvam AI model to use (default: `"sarvam-m"`).
- `api_key`: (str) Your Sarvam AI API key. Can also be set via the `SARVAMAI_API_KEY` environment variable.
- `temperature`: (float) Sampling temperature for response randomness (default: `0.7`).
- `tool_choice`: (ToolChoice) Tool selection mode (default: `"auto"`).
- `max_completion_tokens`: (int) Maximum number of tokens in the completion response (optional). 

---

---
title: AWS Nova Sonic
hide_title: false
hide_table_of_contents: false
description: "Learn how to use Amazon's Nova Sonic model with the VideoSDK AI Agent SDK. This guide covers model configuration, streaming audio, and integration with your agent pipeline."
pagination_label: "Amazon Nova Sonic"
keywords:
  - Amazon's Nova Sonic
  - AWS Nova Sonic
  - AWS Model
  - Amazon Nova Sonic
  - NovaSonicRealtime
  - NovaSonicLiveConfig
  - Real-time AI
  - VideoSDK Agents
  - Python SDK
image: img/videosdklive-thumbnail.jpg
sidebar_position: 2
sidebar_label: AWS Nova Sonic
slug: aws-nova-sonic
---

# AWS Nova Sonic

The AWS Nova Sonic provider enables your agent to use Amazon's Nova Sonic model for real-time, speech-to-speech AI interactions.

### Prerequisites

Before Start Using AWS Nova Sonic with the VideoSDK AI Agent, ensure the following:

- `AWS Account`: You have an active AWS account with permissions to access Amazon Bedrock.
- `Model Access`: You've requested and obtained access to the Amazon Nova models (Nova Lite and Nova Canvas) via the Amazon Bedrock console.
- `Region Selection`: You're operating in the US East (N. Virginia) (us-east-1) region, as model access is region-specific.
- `AWS Credentials`: Your AWS credentials (aws_access_key_id and aws_secret_access_key) are configured, either through environment variables or your preferred credential management method.

## Installation

Install the Gemini-enabled VideoSDK Agents package:

```bash
pip install "videosdk-plugins-aws"
```

## Importing

```python
from videosdk.plugins.aws import NovaSonicRealtime, NovaSonicConfig
```

## Example Usage

```python
from videosdk.plugins.aws import NovaSonicRealtime, NovaSonicConfig
from videosdk.agents import RealTimePipeline

# Initialize the Nova Sonic real-time model
    model = NovaSonicRealtime(
        model="amazon.nova-sonic-v1:0",
        # When AWS credentials and region are set in .env - DON'T pass credential parameters
        region="us-east-1",  # Currently, only "us-east-1" is supported for Amazon Nova Sonic.
        aws_access_key_id="YOUR_ACCESS_KEY",
        aws_secret_access_key="YOUR_SECRET_KEY", 
        config=NovaSonicConfig(
            voice="tiffany", #  "tiffany","matthew", "amy"
            temperature=0.7,
            top_p=0.9,
            max_tokens=1024
        )
    )

# Create the pipeline with the model
pipeline = RealTimePipeline(model=model)
```
:::note
When using .env file for credentials, don't pass them as arguments to model instances or context objects. The SDK automatically reads environment variables, so omit api_key, videosdk_auth, and other credential parameters from your code.
:::

:::note
To initiate a conversation with Amazon Nova Sonic, the user must speak first. The model listens for user input to begin the interaction.
:::


## Configuration Options

- `model`: The Amazon Nova Sonic model to use (e.g., "amazon.nova-sonic-v1:0").
- `region`: AWS region where the model is hosted (e.g., "us-east-1").
- `aws_access_key_id`: Your AWS access key ID.
- `aws_secret_access_key`: Your AWS secret access key.
- `config`: A NovaSonicConfig object for advanced options:
   - `voice`: (str or None) The voice to use for audio output (e.g., "matthew", "tiffany", "amy").
   - `temperature`: (float or None) Sampling temperature for response randomness.
   - `top_p`: (float or None) Nucleus sampling probability.
   - `max_tokens`: (int or None) Maximum number of tokens in the output

:::tip

Explore and utilize ready-made scripts for integrating AWS Nova Sonic with the VideoSDK AI Agent SDK.
[AWS Nova Sonic Example Script.](https://github.com/videosdk-live/agents-quickstart/tree/main/AWS%20Nova%20Sonic)

:::


---

---
title: Google Gemini (LiveAPI)
hide_title: false
hide_table_of_contents: false
description: "Learn how to use Google's Gemini models with the VideoSDK AI Agent SDK. This guide covers model configuration, streaming audio, and integration with your agent pipeline."
pagination_label: "Google Gemini"
keywords:
  - Google Gemini
  - GeminiRealtime
  - GeminiLiveConfig
  - Real-time AI
  - VideoSDK Agents
  - Python SDK
image: img/videosdklive-thumbnail.jpg
sidebar_position: 2
sidebar_label: Google Gemini (LiveAPI)
slug: google-live-api
---

# Google Gemini (LiveAPI)

The Google Gemini (Live API) provider allows your agent to leverage Google's Gemini models for real-time, multimodal AI interactions.

## Installation

Install the Gemini-enabled VideoSDK Agents package:

```bash
pip install "videosdk-plugins-google"
```

## Importing

```python
from videosdk.plugins.google import GeminiRealtime, GeminiLiveConfig
```

## Example Usage

```python
from videosdk.plugins.google import GeminiRealtime, GeminiLiveConfig
from videosdk.agents import RealTimePipeline

# Initialize the Gemini real-time model
model = GeminiRealtime(
    model="gemini-2.0-flash-live-001",
    # When GOOGLE_API_KEY is set in .env - DON'T pass api_key parameter
    api_key="your-google-api-key", 
    config=GeminiLiveConfig(           
        voice="Leda", # Puck, Charon, Kore, Fenrir, Aoede, Leda, Orus, and Zephyr.
        response_modalities=["AUDIO"]
    )
)

# Create the pipeline with the model
pipeline = RealTimePipeline(model=model)
```
:::note
When using .env file for credentials, don't pass them as arguments to model instances or context objects. The SDK automatically reads environment variables, so omit api_key, videosdk_auth, and other credential parameters from your code.
:::

## Configuration Options

- `model`: The Gemini model to use (e.g., `"gemini-2.0-flash-live-001"`). Other supported models include: `"gemini-2.5-flash-preview-native-audio-dialog"` and `"gemini-2.5-flash-exp-native-audio-thinking-dialog"`.
- `api_key`: Your Google API key (can also be set via environment variable)
- `config`: A `GeminiLiveConfig` object for advanced options:
  - `voice`: (str or None) The voice to use for audio output (e.g., `"Puck"`).
  - `language_code`: (str or None) The language code for the conversation (e.g., `"en-US"`).
  - `temperature`: (float or None) Sampling temperature for response randomness.
  - `top_p`: (float or None) Nucleus sampling probability.
  - `top_k`: (float or None) Top-k sampling for response diversity.
  - `candidate_count`: (int or None) Number of candidate responses to generate.
  - `max_output_tokens`: (int or None) Maximum number of tokens in the output.
  - `presence_penalty`: (float or None) Penalty for introducing new topics.
  - `frequency_penalty`: (float or None) Penalty for repeating tokens.
  - `response_modalities`: (List[str] or None) List of enabled output modalities (e.g., `["TEXT", "AUDIO"]`).
  - `output_audio_transcription`: (`AudioTranscriptionConfig` or None) Configuration for audio output transcription.

:::tip

Explore and utilize ready-made scripts for Gemini(LiveAPI) with the VideoSDK AI Agent SDK.
[Gemini(LiveAPI) Example Script.](https://github.com/videosdk-live/agents-quickstart/tree/main/Google%20Gemini%20(LiveAPI))

:::


---

---
title: OpenAI
hide_title: false
hide_table_of_contents: false
description: "Learn how to use OpenAI's real-time models with the VideoSDK AI Agent SDK. This guide covers model configuration, streaming audio, and integration with your agent pipeline."
pagination_label: "OpenAI"
keywords:
  - OpenAI
  - GPT-4o
  - Real-time AI
  - VideoSDK Agents
  - Python SDK
  - OpenAIRealtime
  - OpenAIRealtimeConfig
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
sidebar_label: OpenAI
slug: openai
---

# OpenAI

The OpenAI provider enables your agent to use OpenAI's real-time models (like GPT-4o) for text and audio interactions.

## Installation

Install the OpenAI-enabled VideoSDK Agents package:

```bash
pip install "videosdk-plugins-openai"
```

## Importing

```python
from videosdk.plugins.openai import OpenAIRealtime, OpenAIRealtimeConfig
```

## Example Usage

```python
from videosdk.plugins.openai import OpenAIRealtime, OpenAIRealtimeConfig
from videosdk.agents import RealTimePipeline
from openai.types.beta.realtime.session import  TurnDetection

# Initialize the OpenAI real-time model
model = OpenAIRealtime(
    model="gpt-4o-realtime-preview",
    # When OPENAI_API_KEY is set in .env - DON'T pass api_key parameter
    api_key="your-openai-api-key",
    config=OpenAIRealtimeConfig(
        voice="alloy", # alloy, ash, ballad, coral, echo, fable, onyx, nova, sage, shimmer, and verse
        modalities=["text", "audio"],
        turn_detection=TurnDetection(
            type="server_vad",
            threshold=0.5,
            prefix_padding_ms=300,
            silence_duration_ms=200,
        ),
        tool_choice="auto"
    )
)

# Create the pipeline with the model
pipeline = RealTimePipeline(model=model)
```
:::note
When using .env file for credentials, don't pass them as arguments to model instances or context objects. The SDK automatically reads environment variables, so omit api_key, videosdk_auth, and other credential parameters from your code.
:::

## Configuration Options

- `model`: The OpenAI model to use (e.g., `"gpt-4o-realtime-preview"`)
- `api_key`: Your OpenAI API key (can also be set via environment variable)
- `config`: An `OpenAIRealtimeConfig` object for advanced options:
  - `voice`: (str) The voice to use for audio output (e.g., `"alloy"`).
  - `temperature`: (float) Sampling temperature for response randomness.
  - `turn_detection`: (`TurnDetection` or None) Configure how the agent detects when a user has finished speaking.
  - `input_audio_transcription`: (`InputAudioTranscription` or None) Configure audio-to-text (e.g., Whisper).
  - `tool_choice`: (str or None) Tool selection mode (e.g., `"auto"`).
  - `modalities`: (list[str]) List of enabled modalities (e.g., `["text", "audio"]`).

:::tip

Explore and utilize ready-made scripts for OpenAI with the VideoSDK AI Agent SDK.
[OpenAI Example Script.](https://github.com/videosdk-live/agents-quickstart/tree/main/OpenAI)

:::


---

---
title: Silero VAD
hide_title: false
hide_table_of_contents: false
description: "Learn how to use Silero's VAD with the VideoSDK AI Agent SDK. This guide covers model configuration, related events."
pagination_label: "Silero VAD"
keywords:
  - Silero
  - VAD
  - Large Language Model
  - VideoSDK Agents
  - Python SDK
  - Text To Speech
  - AI Chat
  - Conversational AI
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
sidebar_label: Silero VAD
slug: silero-vad
---

# Silero VAD

The Silero VAD (Voice Activity Detection) provider enables your agent to detect when users start and stop speaking. When added to a cascading pipeline, it automatically enables interrupt functionality - allowing users to interrupt the agent mid-response.

## Installation

Install the Silero VAD-enabled VideoSDK Agents package:

```bash
pip install "videosdk-plugins-silero"
```

## Importing

```python
from videosdk.plugins.silero import SileroVAD
```

## Example Usage

```python
from videosdk.plugins.silero import SileroVAD
from videosdk.agents import CascadingPipeline

# Initialize the Silero VAD
vad = SileroVAD(
    input_sample_rate=48000,
    model_sample_rate=16000,
    threshold=0.3,
    min_speech_duration=0.1,
    min_silence_duration=0.75,
    prefix_padding_duration=0.3
)

# Add VAD to cascading pipeline - automatically enables interrupts
pipeline = CascadingPipeline(vad=vad)
```

## Configuration Options

- `input_sample_rate`: (int) Sample rate of input audio in Hz (default: `48000`)
- `model_sample_rate`: (Literal[8000, 16000]) Model's expected sample rate (default: `16000`)
- `threshold`: (float) Voice activity detection sensitivity (0.0 to 1.0, default: `0.3`)
- `min_speech_duration`: (float) Minimum speech duration to trigger detection in seconds (default: `0.1`)
- `min_silence_duration`: (float) Minimum silence duration to end speech detection in seconds (default: `0.75`)
- `max_buffered_speech`: (float) Maximum speech buffer duration in seconds (default: `60.0`)
- `force_cpu`: (bool) Force CPU usage instead of GPU acceleration (default: `True`)
- `prefix_padding_duration`: (float) Audio padding before speech detection in seconds (default: `0.3`)

---

---
title: Deepgram STT
hide_title: false
hide_table_of_contents: false
description: "Learn how to use Deepgram's STT models with the VideoSDK AI Agent SDK. This guide covers model configuration, API integration, and implementing speech to text for Deepgram's services"
pagination_label: "Deepgram STT"
keywords:
  - Deepgram
  - nova-2
  - nova-3
  - STT
  - Large Language Model
  - VideoSDK Agents
  - Python SDK
  - Speech To Text
  - AI Chat
  - Conversational AI
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
sidebar_label: Deepgram
slug: deepgram
---

# Deepgram STT

The Deepgram STT provider enables your agent to use Deepgram's advanced speech-to-text models for high-accuracy, real-time audio transcription.

## Installation

Install the Deepgram-enabled VideoSDK Agents package:

```bash
pip install "videosdk-plugins-deepgram"
```

## Importing

```python
from videosdk.plugins.deepgram import DeepgramSTT
```

## Example Usage

```python
from videosdk.plugins.deepgram import DeepgramSTT
from videosdk.agents import CascadingPipeline

# Initialize the Deepgram STT model
stt = DeepgramSTT(
    # When DEEPGRAM_API_KEY is set in .env - DON'T pass api_key parameter
    api_key="your-deepgram-api-key",
    model="nova-2",
    language="en-US",
    interim_results=True,
    punctuate=True,
    smart_format=True
)

#  Add stt to cascading pipeline
pipeline = CascadingPipeline(stt=stt)
```
:::note
When using .env file for credentials, don't pass them as arguments to model instances or context objects. The SDK automatically reads environment variables, so omit api_key, videosdk_auth, and other credential parameters from your code.
:::

## Configuration Options

- `api_key`: Your Deepgram API key (can also be set via environment variable)
- `model`: The Deepgram model to use (e.g., `"nova-2"`, `"nova-3"`, `"whisper-large"`)
- `language`: (str) Language code for transcription (default: `"en-US"`)
- `interim_results`: (bool) Enable real-time partial transcription results (default: `True`)
- `punctuate`: (bool) Add punctuation to transcription (default: `True`)
- `smart_format`: (bool) Apply intelligent formatting to output (default: `True`)
- `sample_rate`: (int) Audio sample rate in Hz (default: `48000`)
- `endpointing`: (int) Silence detection threshold in milliseconds (default: `50`)
- `filler_words`: (bool) Include filler words like "uh", "um" in transcription (default: `True`)
- `base_url`: (str) WebSocket endpoint URL (default: `"wss://api.deepgram.com/v1/listen"`)


---

---
title: Google STT
hide_title: false
hide_table_of_contents: false
description: "Learn how to use Google's STT models with the VideoSDK AI Agent SDK. This guide covers model configuration, API integration, and implementing speech to text for Google's services"
pagination_label: "Google STT"
keywords:
  - Google
  - Speech-to-Text
  - STT
  - Large Language Model
  - VideoSDK Agents
  - Python SDK
  - Speech To Text
  - AI Chat
  - Conversational AI
image: img/videosdklive-thumbnail.jpg
sidebar_position: 2
sidebar_label: Google
slug: google
---

# Google STT

The Google STT provider enables your agent to use Google's advanced speech-to-text models for high-accuracy, real-time audio transcription.

## Installation

Install the Google-enabled VideoSDK Agents package:

```bash
pip install "videosdk-plugins-google"
```

## Importing

```python
from videosdk.plugins.google import GoogleSTT
```

## Setup Credentials

To use Google STT, you need to set up your Google Cloud credentials. You can do this by setting the `GOOGLE_APPLICATION_CREDENTIALS` environment variable to the path of your service account key file.

```bash
export GOOGLE_APPLICATION_CREDENTIALS="/path/to/your/keyfile.json"
```

Alternatively, you can pass the path to the key file directly to the `GoogleSTT` constructor via the `api_key` parameter.

## Example Usage

```python
from videosdk.plugins.google import GoogleSTT
from videosdk.agents import CascadingPipeline

# Initialize the Google STT model
stt = GoogleSTT(
    # If GOOGLE_APPLICATION_CREDENTIALS is set, you can omit api_key
    api_key="/path/to/your/keyfile.json",
    languages="en-US",
    model="latest_long",
    interim_results=True,
    punctuate=True
)

#  Add stt to cascading pipeline
pipeline = CascadingPipeline(stt=stt)
```
:::note
When using an environment variable for credentials, don't pass the `api_key` as an argument to the model instance. The SDK automatically reads the environment variable.
:::

## Configuration Options

- `api_key`: (str) Path to your Google Cloud service account JSON file. This can also be set via the `GOOGLE_APPLICATION_CREDENTIALS` environment variable.
- `languages`: (Union[str, list[str]]) Language code or a list of language codes for transcription (default: `"en-US"`).
- `model`: (str) The Google STT model to use (e.g., `"latest_long"`, `"telephony"`) (default: `"latest_long"`).
- `sample_rate`: (int) The target audio sample rate in Hz for transcription (default: `16000`). The input audio at 48000Hz will be resampled to this rate.
- `interim_results`: (bool) Enable real-time partial transcription results (default: `True`).
- `punctuate`: (bool) Add punctuation to transcription (default: `True`).
- `min_confidence_threshold`: (float) The minimum confidence level for a transcription result to be considered valid (default: `0.1`).
- `location`: (str) The Google Cloud location to use for the STT service (default: `"global"`). 

---

---
title: OpenAI STT
hide_title: false
hide_table_of_contents: false
description: "Learn how to use OpenAI's STT models with the VideoSDK AI Agent SDK. This guide covers model configuration, API integration, and implementing speech to text for OpenAI's services"
pagination_label: "OpenAI STT"
keywords:
  - OpenAI
  - gpt-4o-mini-transcribe
  - whisper-1
  - STT
  - Large Language Model
  - VideoSDK Agents
  - Python SDK
  - Speech To Text
  - AI Chat
  - Conversational AI
image: img/videosdklive-thumbnail.jpg
sidebar_position: 2
sidebar_label: OpenAI
slug: openai
---

# OpenAI STT

The OpenAI STT provider enables your agent to use OpenAI's speech-to-text models (like Whisper) for converting audio input to text.

## Installation

Install the OpenAI-enabled VideoSDK Agents package:

```bash
pip install "videosdk-plugins-openai"
```

## Importing

```python
from videosdk.plugins.openai import OpenAISTT
```

## Example Usage

```python
from videosdk.plugins.openai import OpenAISTT
from videosdk.agents import CascadingPipeline

# Initialize the OpenAI STT model
stt = OpenAISTT(
    # When OPENAI_API_KEY is set in .env - DON'T pass api_key parameter
    api_key="your-openai-api-key",
    model="whisper-1",
    language="en",
    prompt="Transcribe this audio with proper punctuation and formatting."
)

#  Add stt to cascading pipeline
pipeline = CascadingPipeline(stt=stt)
```
:::note
When using .env file for credentials, don't pass them as arguments to model instances or context objects. The SDK automatically reads environment variables, so omit api_key, videosdk_auth, and other credential parameters from your code.
:::

## Configuration Options

- `api_key`: Your OpenAI API key (required, can also be set via environment variable)
- `model`: The OpenAI STT model to use (e.g., `"whisper-1"`, `"gpt-4o-mini-transcribe"`)
- `base_url`: Custom base URL for OpenAI API (optional)
- `prompt`: (str) Custom prompt to guide transcription style and format
- `language`: (str) Language code for transcription (default: `"en"`)
- `turn_detection`: (dict) Configuration for detecting conversation turns


---

---
title: Sarvam AI STT
hide_title: false
hide_table_of_contents: false
description: "Learn how to use Sarvam AI's STT models with the VideoSDK AI Agent SDK. This guide covers model configuration, API integration, and implementing speech to text for Sarvam AI's services"
pagination_label: "Sarvam AI STT"
keywords:
  - Sarvam AI
  - saarika:v2
  - STT
  - Large Language Model
  - VideoSDK Agents
  - Python SDK
  - Speech To Text
  - AI Chat
  - Conversational AI
image: img/videosdklive-thumbnail.jpg
sidebar_position: 3
sidebar_label: Sarvam AI
slug: sarvam-ai
---

# Sarvam AI STT

The Sarvam AI STT provider enables your agent to use Sarvam AI's speech-to-text models for transcription. This provider uses Voice Activity Detection (VAD) to send audio chunks for transcription after a period of silence.

## Installation

Install the Sarvam AI-enabled VideoSDK Agents package:

```bash
pip install "videosdk-plugins-sarvamai"
```

## Importing

```python
from videosdk.plugins.sarvamai import SarvamAISTT
```

## Example Usage

```python
from videosdk.plugins.sarvamai import SarvamAISTT
from videosdk.agents import CascadingPipeline

# Initialize the Sarvam AI STT model
stt = SarvamAISTT(
    # When SARVAMAI_API_KEY is set in .env - DON'T pass api_key parameter
    api_key="your-sarvam-ai-api-key",
    model="saarika:v2",
    language="en-IN"
)

#  Add stt to cascading pipeline
pipeline = CascadingPipeline(stt=stt)
```
:::note
When using .env file for credentials, don't pass them as arguments to model instances or context objects. The SDK automatically reads environment variables, so omit `api_key` and other credential parameters from your code.
:::

## Configuration Options

- `api_key`: (str) Your Sarvam AI API key. Can also be set via the `SARVAMAI_API_KEY` environment variable.
- `model`: (str) The Sarvam AI model to use (default: `"saarika:v2"`).
- `language`: (str) Language code for transcription (default: `"en-IN"`).
- `input_sample_rate`: (int) The sample rate of the audio from the source in Hz (default: `48000`).
- `output_sample_rate`: (int) The sample rate to which the audio is resampled before sending for transcription (default: `16000`).
- `silence_threshold`: (float) The normalized amplitude threshold for silence detection (default: `0.01`).
- `silence_duration`: (float) The duration of silence in seconds that triggers the end of a speech segment for transcription (default: `0.8`). 

---

---
title: ElevenLabs TTS
hide_title: false
hide_table_of_contents: false
description: "Learn how to use ElevenLabs's TTS models with the VideoSDK AI Agent SDK. This guide covers model configuration, API integration, and implementing text to speech for ElevenLabs's services"
pagination_label: "ElevenLabs TTS"
keywords:
  - ElevenLabs
  - eleven_flash_v2_5
  - TTS
  - Large Language Model
  - VideoSDK Agents
  - Python SDK
  - Text To Speech
  - AI Chat
  - Conversational AI
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
sidebar_label: ElevenLabs
slug: eleven-labs
---

# ElevenLabs TTS

The ElevenLabs TTS provider enables your agent to use ElevenLabs' high-quality text-to-speech models for generating natural, expressive voice output with advanced voice cloning capabilities.

## Installation

Install the ElevenLabs-enabled VideoSDK Agents package:

```bash
pip install "videosdk-plugins-elevenlabs"
```

## Importing

```python
from videosdk.plugins.elevenlabs import ElevenLabsTTS, VoiceSettings
```

## Example Usage

```python
from videosdk.plugins.elevenlabs import ElevenLabsTTS, VoiceSettings
from videosdk.agents import CascadingPipeline

# Configure voice settings
voice_settings = VoiceSettings(
    stability=0.71,
    similarity_boost=0.5,
    style=0.0,
    use_speaker_boost=True
)

# Initialize the ElevenLabs TTS model
tts = ElevenLabsTTS(
    # When ELEVENLABS_API_KEY is set in .env - DON'T pass api_key parameter
    api_key="your-elevenlabs-api-key",
    model="eleven_flash_v2_5",
    voice="your-voice-id",
    speed=1.0,
    response_format="pcm_24000",
    voice_settings=voice_settings,
    enable_streaming=True
)

# Add tts to cascading pipeline
pipeline = CascadingPipeline(tts=tts)
```
:::note
When using .env file for credentials, don't pass them as arguments to model instances or context objects. The SDK automatically reads environment variables, so omit api_key, videosdk_auth, and other credential parameters from your code.
:::

## Configuration Options

- `model`: The ElevenLabs model to use (e.g., `"eleven_flash_v2_5"`, `"eleven_multilingual_v2"`)
- `voice`: (str) Voice ID to use for audio output (get from ElevenLabs dashboard)
- `speed`: (float) Speed of the generated audio (default: 1.0)
- `api_key`: Your ElevenLabs API key (can also be set via environment variable)
- `response_format`: (str) Audio format for output (default: `"pcm_24000"`)
- `voice_settings`: (`VoiceSettings`) Advanced voice configuration options:
  - `stability`: (float) Voice stability (0.0 to 1.0, default: 0.71)
  - `similarity_boost`: (float) Voice similarity enhancement (0.0 to 1.0, default: 0.5)
  - `style`: (float) Voice style exaggeration (0.0 to 1.0, default: 0.0)
  - `use_speaker_boost`: (bool) Enable speaker boost for clarity (default: `True`)
- `base_url`: (str) Custom base URL for ElevenLabs API (optional)
- `enable_streaming`: (bool) Enable real-time audio streaming (default: `False`)

---

---
title: Google TTS
hide_title: false
hide_table_of_contents: false
description: "Learn how to use Google's TTS models with the VideoSDK AI Agent SDK. This guide covers model configuration, API integration, and implementing text to speech for Google's services"
pagination_label: "Google TTS"
keywords:
  - Google
  - Text-to-Speech
  - TTS
  - Large Language Model
  - VideoSDK Agents
  - Python SDK
  - Text To Speech
  - AI Chat
  - Conversational AI
image: img/videosdklive-thumbnail.jpg
sidebar_position: 2
sidebar_label: Google
slug: google-tts
---

# Google TTS

The Google TTS provider enables your agent to use Google's high-quality text-to-speech models for generating natural-sounding voice output.

## Installation

Install the Google-enabled VideoSDK Agents package:

```bash
pip install "videosdk-plugins-google"
```

## Importing

```python
from videosdk.plugins.google import GoogleTTS, GoogleVoiceConfig
```

## Example Usage

```python
from videosdk.plugins.google import GoogleTTS, GoogleVoiceConfig
from videosdk.agents import CascadingPipeline

# Configure voice settings
voice_config = GoogleVoiceConfig(
    languageCode="en-US",
    name="en-US-Chirp3-HD-Aoede",
    ssmlGender="FEMALE"
)

# Initialize the Google TTS model
tts = GoogleTTS(
    # When GOOGLE_API_KEY is set in .env - DON'T pass api_key parameter
    api_key="your-google-api-key",
    speed=1.0,
    pitch=0.0,
    voice_config=voice_config
)

# Add tts to cascading pipeline
pipeline = CascadingPipeline(tts=tts)
```
:::note
When using .env file for credentials, don't pass them as arguments to model instances or context objects. The SDK automatically reads environment variables, so omit `api_key` and other credential parameters from your code.
:::

## Configuration Options

- `api_key`: (str) Your Google Cloud TTS API key. Can also be set via the `GOOGLE_API_KEY` environment variable.
- `speed`: (float) The speaking rate of the generated audio (default: `1.0`).
- `pitch`: (float) The pitch of the generated audio. Can be between -20.0 and 20.0 (default: `0.0`).
- `response_format`: (str) The format of the audio response. Currently only supports `"pcm"` (default: `"pcm"`).
- `voice_config`: (`GoogleVoiceConfig`) Configuration for the voice to be used.
  - `languageCode`: (str) The language code of the voice (e.g., `"en-US"`, `"en-GB"`) (default: `"en-US"`).
  - `name`: (str) The name of the voice to use (e.g., `"en-US-Chirp3-HD-Aoede"`, `"en-US-News-N"`) (default: `"en-US-Chirp3-HD-Aoede"`).
  - `ssmlGender`: (str) The gender of the voice (`"MALE"`, `"FEMALE"`, `"NEUTRAL"`) (default: `"FEMALE"`). 

---

---
title: OpenAI TTS
hide_title: false
hide_table_of_contents: false
description: "Learn how to use OpenAI's TTS models with the VideoSDK AI Agent SDK. This guide covers model configuration, API integration, and implementing text to speech for OpenAI's services"
pagination_label: "OpenAI TTS"
keywords:
  - OpenAI
  - gpt-4o-mini-tts
  - TTS
  - Large Language Model
  - VideoSDK Agents
  - Python SDK
  - Text To Speech
  - AI Chat
  - Conversational AI
image: img/videosdklive-thumbnail.jpg
sidebar_position: 2
sidebar_label: OpenAI
slug: openai
---

# OpenAI TTS

The OpenAI TTS provider enables your agent to use OpenAI's text-to-speech models for converting text responses to natural-sounding audio output.

## Installation

Install the OpenAI-enabled VideoSDK Agents package:

```bash
pip install "videosdk-plugins-openai"
```

## Importing

```python
from videosdk.plugins.openai import OpenAITTS
```

## Example Usage

```python
from videosdk.plugins.openai import OpenAITTS
from videosdk.agents import CascadingPipeline

# Initialize the OpenAI TTS model
tts = OpenAITTS(
    # When OPENAI_API_KEY is set in .env - DON'T pass api_key parameter
    api_key="your-openai-api-key",
    model="tts-1",
    voice="alloy",
    speed=1.0,
    response_format="pcm"
)

#  Add tts to cascading pipeline
pipeline = CascadingPipeline(tts=tts)
```
:::note
When using .env file for credentials, don't pass them as arguments to model instances or context objects. The SDK automatically reads environment variables, so omit api_key, videosdk_auth, and other credential parameters from your code.
:::

## Configuration Options

- `model`: The OpenAI TTS model to use (e.g., `"tts-1"`, `"tts-1-hd"`)
- `voice`: (str) Voice to use for audio output (e.g., `"alloy"`, `"echo"`, `"fable"`, `"onyx"`, `"nova"`, `"shimmer"`)
- `speed`: (float) Speed of the generated audio (0.25 to 4.0, default: 1.0)
- `instructions`: (str) Custom instructions to guide speech synthesis style
- `api_key`: Your OpenAI API key (can also be set via environment variable)
- `base_url`: Custom base URL for OpenAI API (optional)
- `response_format`: (str) Audio format for output (default: `"pcm"`)

---

---
title: Sarvam AI TTS
hide_title: false
hide_table_of_contents: false
description: "Learn how to use Sarvam AI's TTS models with the VideoSDK AI Agent SDK. This guide covers model configuration, API integration, and implementing text to speech for Sarvam AI's services"
pagination_label: "Sarvam AI TTS"
keywords:
  - Sarvam AI
  - bulbul:v2
  - TTS
  - Large Language Model
  - VideoSDK Agents
  - Python SDK
  - Text To Speech
  - AI Chat
  - Conversational AI
image: img/videosdklive-thumbnail.jpg
sidebar_position: 3
sidebar_label: Sarvam AI
slug: sarvam-ai-tts
---

# Sarvam AI TTS

The Sarvam AI TTS provider enables your agent to use Sarvam AI's text-to-speech models for generating voice output.

## Installation

Install the Sarvam AI-enabled VideoSDK Agents package:

```bash
pip install "videosdk-plugins-sarvamai"
```

## Importing

```python
from videosdk.plugins.sarvamai import SarvamAITTS
```

## Example Usage

```python
from videosdk.plugins.sarvamai import SarvamAITTS
from videosdk.agents import CascadingPipeline

# Initialize the Sarvam AI TTS model
tts = SarvamAITTS(
    # When SARVAMAI_API_KEY is set in .env - DON'T pass api_key parameter
    api_key="your-sarvam-ai-api-key",
    model="bulbul:v2",
    speaker="anushka",
    target_language_code="en-IN",
    pitch=0.0,
    pace=1.0,
    loudness=1.2
)

# Add tts to cascading pipeline
pipeline = CascadingPipeline(tts=tts)
```
:::note
When using .env file for credentials, don't pass them as arguments to model instances or context objects. The SDK automatically reads environment variables, so omit `api_key` and other credential parameters from your code.
:::

## Configuration Options

- `api_key`: (str) Your Sarvam AI API key. Can also be set via the `SARVAMAI_API_KEY` environment variable.
- `model`: (str) The Sarvam AI model to use (default: `"bulbul:v2"`).
- `speaker`: (str) The speaker voice to use (default: `"anushka"`).
- `target_language_code`: (str) The language code for the generated audio (default: `"en-IN"`).
- `pitch`: (float) The pitch of the generated audio (default: `0.0`).
- `pace`: (float) The pace or speed of the generated audio (default: `1.0`).
- `loudness`: (float) The loudness of the generated audio (default: `1.2`).
- `enable_preprocessing`: (bool) Whether to enable text preprocessing on the server (default: `True`). 

---

---
title: Turn Detector
hide_title: false
hide_table_of_contents: false
description: "Learn how to use TurnDetector model with the VideoSDK AI Agent SDK. This guide covers model configuration."
pagination_label: "Turn Detector"
keywords:
  - Turn Detection
  - Turn Detector
  - Large Language Model
  - VideoSDK Agents
  - Python SDK
  - Text To Speech
  - AI Chat
  - Conversational AI
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
sidebar_label: Turn Detector
slug: turn-detector
---

# Turn Detector

The Turn Detector uses a Hugging Face model to determine whether a user's turn is completed or not, enabling precise conversation flow management in cascading pipelines.

## Installation

Install the Turn Detector-enabled VideoSDK Agents package:

```bash
pip install "videosdk-plugins-turn-detector"
```

## Importing

```python
from videosdk.plugins.turn_detector import TurnDetector
```

## Example Usage

```python
from videosdk.plugins.turn_detector import TurnDetector, pre_download_model
from videosdk.agents import CascadingPipeline

# Pre-download the model (optional but recommended)
pre_download_model()

# Initialize the Turn Detector
turn_detector = TurnDetector(
    threshold=0.7
)

# Add Turn Detector to cascading pipeline
pipeline = CascadingPipeline(turn_detector=turn_detector)
```

## Configuration Options

- `threshold`: (float) Confidence threshold for turn completion detection (0.0 to 1.0, default: `0.7`)

## Pre-downloading Model

To avoid delays during agent initialization, you can pre-download the Hugging Face model:

```python
from videosdk.plugins.turn_detector import pre_download_model

# Download model before running the agent
pre_download_model()
```

---

---
title: Running Multiple Agents
hide_title: false
hide_table_of_contents: false
description: "Learn how to run multiple AI agent instances concurrently using the Worker system in the VideoSDK AI Agent SDK. Understand WorkerJob and Worker components for parallel task execution and managing multiple voice agent sessions."
pagination_label: "Running Multiple Agents"
keywords:
  - Multiple Agents
  - Worker System
  - VideoSDK Agents
  - AI Agent SDK
  - Python
  - Multiprocessing
  - Parallel Execution
  - WorkerJob
  - Worker
  - Voice Agent Sessions
image: img/videosdklive-thumbnail.jpg
sidebar_position: 4
sidebar_label: Running Multiple Agents
slug: running-multiple-agents
---

The worker system provides a way to run multiple tasks in parallel using Python's multiprocessing. It's particularly useful for running multiple instances of the same task concurrently, such as handling multiple voice agent sessions.

<img src="https://cdn.videosdk.live/website-resources/docs-resources/ai_agents_worker_diagram.png" />

## Key Components

### 1. WorkerJob

`WorkerJob` is the main class that defines a task to be executed. It takes two parameters:

- `job_func`: The function to be executed
- `jobctx`: Context data for the job (can be static or a callable)

```python
job = WorkerJob(job_func=my_function, jobctx=my_context)
```

### 2. Worker

`Worker` manages the execution of jobs and provides a command-line interface to control them. It supports the following commands:

- `n`: Start a new worker process
- `l`: List all running worker processes
- `q <pid>`: Stop a specific process
- `q`: Stop all running processes
- `x`: Exit the worker interface

## Usage Example

Here's a complete example of how to use the worker system with a voice agent:

```python
import asyncio
from videosdk.plugins.openai import OpenAIRealtime, OpenAIRealtimeConfig
from videosdk.agents import Agent, AgentSession, RealTimePipeline, WorkerJob

class VoiceAgent(Agent):
    def __init__(self):
        super().__init__(
            instructions="You are a helpful voice assistant that can answer questions and help with tasks.",
        )

    async def on_enter(self) -> None:
        await self.session.say("Hi there! How can I help you today?")

async def start_session(jobctx):
    model = OpenAIRealtime(
        model="gpt-4o-realtime-preview",
    )
    pipeline = RealTimePipeline(model=model)
    session = AgentSession(
        agent=VoiceAgent(),
        pipeline=pipeline,
        context=jobctx
    )

    try:
        await session.start()
        await asyncio.Event().wait()
    finally:
        await session.close()

def entryPoint(jobctx):
    asyncio.run(start_session(jobctx))

# Create job context
def make_context():
    return {"meetingId": "<Meeting-ID>", "name": "<Agent-Name>"}

# Start a worker job
job = WorkerJob(job_func=entryPoint, jobctx=make_context)
job.start()
```


---

---
title: Custom Tracks
hide_title: true
hide_table_of_contents: false
description: Custom Video Track features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Custom Tracks
pagination_label: Custom Tracks
keywords:
  - custom Track
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
---

## Custom Video Track - Android

- You can create a Video Track using `createCameraVideoTrack()` method of `VideoSDK`.
- This method can be used to create video track using different encoding parameters, camera facing mode, and optimization mode.

### Parameters

- **encoderConfig**:

  - type: `String`
  - required: `true`
  - default: `h480p_w720p`
  - You can chose from the below mentioned list of values for the encoder config.

| Encoder Config | Resolution | Frame Rate |   Bitrate    |
| -------------- | :--------: | :--------: | :----------: |
| h144p_w176p    |  176x144   |   15 fps   | 120000 kbps  |
| h240p_w320p    |  320x240   |   15 fps   | 150000 kbps  |
| h480p_w640p    |  640x480   |   25 fps   | 300000 kbps  |
| h480p_w720p    |  720x480   |   30 fps   | 450000 kbps  |
| h720p_w960p    |  720x960   |   30 fps   | 1500000 kbps |
| h1080p_w1440p  | 1080x1440  |   30 fps   | 2500000 kbps |
| h720p_w1280p   |  720x1280  |   30 fps   | 2000000 kbps |
| h360p_w640p    |  360x640   |   30 fps   | 400000 kbps  |  

:::note

Above mentioned encoder configurations are valid for both, landscape as well as portrait mode.

:::

- **facingMode**:

  - type: `String`
  - required: `true`
  - Allowed values : `front` | `back`
  - It will specify wheater to use front or back camera for the video track.

- **optimizationMode**

  - type: `CustomStreamTrack.VideoMode`
  - required: `true`
  - Allowed values: `motion` | `text` | `detail`
  - It will specify the optimization mode for the video track being generated.

- **multiStream**:

  - type: `boolean`
  - required: `true`
  - It will specify if the stream should send multiple resolution layers or single resolution layer.

- **context**:

  - type: `Context`
  - required: `true`
  - Pass the Android Context for this parameter.

- **observer**:

  - type: `CapturerObserver`
  - required: `false`
  - If you want to use video filter from external SDK(e.g., [Banuba](https://www.banuba.com/)) then pass instance of `CapturerObserver` in this parameter.

- **videoDeviceInfo**:

  - type: `VideoDeviceInfo`
  - required: `false`
  - If you want to specify a camera device to be used in the meeting.

:::note

For Banuba integraion with VideoSDK, please visit [Banuba Intergation with VideoSDK](/android/guide/video-and-audio-calling-api-sdk/video-processor/banuba-integration)

:::

:::info

- To learn more about optimizations and best practices for using custom video tracks, [follow this guide](/android/guide/video-and-audio-calling-api-sdk/render-media/optimize-video-track).

:::

#### Returns

- `CustomStreamTrack`

### Example

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
val videoCustomTrack: CustomStreamTrack = VideoSDK.createCameraVideoTrack("h720p_w960p", "front", CustomStreamTrack.VideoMode.MOTION, false, this)
```

</TabItem>

<TabItem value="Java">

```javascript
CustomStreamTrack customStreamTrack = VideoSDK.createCameraVideoTrack("h720p_w960p", "front", CustomStreamTrack.VideoMode.MOTION, false, this);
```

</TabItem>

</Tabs>

## Custom Audio Track - Android

- You can create a Audio Track using `createAudioTrack()` method of `VideoSDK`.
- This method can be used to create audio track using different encoding parameters.

### Parameters

- **encoderConfig**:

  - type: `String`
  - required: `true`
  - default: `speech_standard`
  - You can chose from the below mentioned list of values for the encoder config.

| Encoder Config      | Bitrate  | Auto Gain | Echo Cancellation | Noise Suppression |
| ------------------- | :------: | :-------: | :---------------: | :---------------: |
| speech_low_quality  | 16 kbps  |   TRUE    |       TRUE        |       TRUE        |
| speech_standard     | 24 kbps  |   TRUE    |       TRUE        |       TRUE        |
| music_standard      | 32 kbps  |   FALSE   |       FALSE       |       FALSE       |
| standard_stereo     | 64 kbps  |   FALSE   |       FALSE       |       FALSE       |
| high_quality        | 128 kbps |   FALSE   |       FALSE       |       FALSE       |
| high_quality_stereo | 192 kbps |   FALSE   |       FALSE       |       FALSE       |

- **context**

  - type: `Context`
  - required: `true`
  - Pass the Android Context for this parameter.

#### Returns

- `CustomStreamTrack`

### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
val audioCustomTrack: CustomStreamTrack = VideoSDK.createAudioTrack("speech_standard",this)
```

</TabItem>

<TabItem value="Java">

```js
CustomStreamTrack audioCustomTrack=VideoSDK.createAudioTrack("speech_standard", this);
```

</TabItem>

</Tabs>

## Custom Screen Share Track - Android

- You can create a Screen Share track using `createScreenShareVideoTrack()` method of `VideoSDK`.
- This method can be used to create screen share track using different encoding parameters.

### Parameters

- **encoderConfig**:

  - type: `String`
  - required: `true`
  - default: `h720p_15fps`
  - You can chose from the below mentioned list of values for the encoder config.

| Encoder Config | Resolution | Frame Rate |   Bitrate    |
| -------------- | :--------: | :--------: | :----------: |
| h360p_30fps    |  640x360   |   3 fps    | 200000 kbps  |
| h720p_5fps     |  1280x720  |   5 fps    | 400000 kbps  |
| h720p_15fps    |  1280x720  |   15 fps   | 1000000 kbps |
| h1080p_15fps   | 1920x1080  |   15 fps   | 1500000 kbps |
| h1080p_30fps   | 1920x1080  |   15 fps   | 1000000 kbps |

:::note

Above mentioned encoder configurations are valid for both, landscape as well as portrait mode.

:::

- **data**

  - type: `Intent`
  - required: `true`
  - It is Intent received from onActivityResult when user provide permission for ScreenShare.

- **context**

  - type: `Context`
  - required: `true`
  - Pass the Android Context for this parameter.

- **listener**
  - type: `CustomTrackListener`
  - required: `true`
  - Callback to this listener will be made when track is ready with CustomTrack as parameter.

### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
// data is received from onActivityResult method.
VideoSDK.createScreenShareVideoTrack("h720p_15fps", data, this) { track ->
    meeting!!.enableScreenShare(track)
}
```

</TabItem>

<TabItem value="Java">

```javascript
// data is received from onActivityResult method.
VideoSDK.createScreenShareVideoTrack("h720p_15fps", data, this, (track)->{
    meeting.enableScreenShare(track);
});
```

</TabItem>

</Tabs>


---

---
sidebar_position: 2
sidebar_label: Meeting Error Codes
pagination_label: Meeting Error Codes
title: Meeting Error Codes
---

# Meeting Error Codes - Android

If you encounter any of the errors listed below, refer to the [Developer Experience Guide](../../guide/best-practices/developer-experience.md#listen-for-error-events), which offers recommended solutions based on common error categories.

import ServerErrorCodes from '../../../mdx/\_server-error-codes.mdx'
import SDKErrorCodes from '../../data/\_sdk-error-codes.mdx'

<ServerErrorCodes />

<SDKErrorCodes/>





---

---
sidebar_position: 2
sidebar_label: Initializing a Meeting
pagination_label: Initializing a Meeting
title: Initializing a Meeting
---

# Initializing a Meeting - Android

<div class="sdk-api-ref">

## initialize()

To initialize the meeting, first you have to initialize the `VideoSDK`.
You can initialize the `VideoSDK` using `initialize()` method provided by the SDK.

#### Parameters

- **context**: Context

#### Returns

- _`void`_

```js title="initialize"
  VideoSDK.initialize(Context context)
```

---

## config()

Now, you have to set `token` property of `VideoSDK` class.
By using `config()` method, you can set the `token` property of `VideoSDK` class.

Please refer this [documentation](/api-reference/realtime-communication/intro/) to generate a token.

#### Parameters

- **token**: String

#### Returns

- _`void`_

```js title="config"
 VideoSDK.config(String token)
```

---

## initMeeting()

- Now, you can initialize the meeting using a factory method provided by the SDK called `initMeeting()`.
- `initMeeting()` will generate a new [`Meeting`](./meeting-class/introduction.md) class and the initiated meeting will be returned.

```js title="initMeeting"
   VideoSDK.initMeeting(
        Context context,
        String meetingId,
        String name,
        boolean micEnabled,
        boolean webcamEnabled,
        String participantId,
        String mode,
        boolean multiStream,
        Map<String, CustomStreamTrack> customTracks
        JSONObject metaData,
        String signalingBaseUrl,
        PreferredProtocol preferredProtocol
      )
```

## Parameters

### context

- Context of activity.

  - type : Context
  - `REQUIRED`

### meetingId

- Unique Id of the meeting where that participant will be joining.

  - type : `String`
  - `REQUIRED`

Please refer this [documentation](/api-reference/realtime-communication/create-room) to create a room.

### name

- Name of the participant who will be joining the meeting, this name will be displayed to other participants in the same meeting.

  - type : String
  - `REQUIRED`

### micEnabled

- Whether `mic` of the participant will be on while joining the meeting. If it is set to `false`, then mic of that participant will be `disabled` by default, but can be `enabled` or `disabled` later.

  - type: `Boolean`
  - `REQUIRED`

### webcamEnabled

- Whether `webcam` of the participant will be on while joining the meeting. If it is set to `false`, then webcam of that participant will be `disabled` by default, but can be `enabled` or `disabled` later.

  - type: `Boolean`
  - `REQUIRED`

### participantId

- Unique Id of the participant. If you passed `null` then SDK will create an Id by itself and will use that id.

  - type : `String` or `null`
  - `REQUIRED`

### Modes

There are three modes available:

- **`SEND_AND_RECV`**: In this mode, both audio and video streams will be produced and consumed.

- **`SIGNALLING_ONLY`**: In this mode, no audio or video streams will be produced or consumed. It is used solely for signaling.

- **`RECV_ONLY`**: This mode allows only the consumption of audio and video streams without producing any.

**Type**: `String` or `null`  
**Default Value**: `SEND_AND_RECV`

import CautionMessage from '@site/src/theme/CautionMessage';

<CautionMessage sdk="Android SDK" version="v0.2.0" />

### multiStream

- It will specify if the stream should send multiple resolution layers or single resolution layer.

  - type: `boolean`
  - `REQUIRED`

### customTracks

- If you want to use custom tracks from start of the meeting, you can pass map of custom tracks in this paramater.

  - type : `Map<String, CustomStreamTrack>` or `null`
  - `REQUIRED`

Please refer this [documentation](../../guide/video-and-audio-calling-api-sdk/features/custom-track/custom-video-track) to know more about CustomTrack.

### metaData

- If you want to provide additional details about a user joining a meeting, such as their profile image, you can pass that information in this parameter.

  - type: `JSONObject`
  - `REQUIRED`

### signalingBaseUrl

- If you want to use a proxy server with the VideoSDK, you can specify your baseURL here.

  - type: `String`
  - `OPTIONAL`

:::note

If you intend to use a proxy server with the VideoSDK, priorly inform us at support@videosdk.live

:::

### preferredProtocol

- If you want to provide a preferred network protocol for communication, you can specify that in `PreferredProtocol`, with options including `UDP_ONLY`, `UDP_OVER_TCP`, and `TCP_ONLY`.

  - type: `PreferredProtocol`
  - `OPTIONAL`

## Returns

### meeting

- After initializing the meeting, `initMeeting()` will return a new [`Meeting`](./meeting-class/introduction.md) instance.

---

## Example

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js title="initMeeting"

VideoSDK.initialize(applicationContext)

// Configure the token
VideoSDK.config(token) // pass the token generated from VideoSDK Dashboard

// Initialize the meeting
var meeting = VideoSDK.initMeeting(
  arrayOf(
    this@MainActivity,
    "abc-1234-xyz",
    "John Doe",
    true,
    true,
    null,
    null,
    false,
    null,
    null
  )
)
```

</TabItem>

<TabItem value="Java">

```js title="initMeeting"

VideoSDK.initialize(getApplicationContext());

// Configure the token
VideoSDK.config(token);  // pass the token generated from VideoSDK Dashboard

// Initialize the meeting
Meeting meeting = VideoSDK.initMeeting({
  MainActivity.this,
  "abc-1234-xyz",
  "John Doe",
  true,
  true,
  null,
  null,
  false,
  null,
  null,
  null
});
```

</TabItem>

</Tabs>

</div>


---

---
title: MediaEffects library
hide_title: true
hide_table_of_contents: false
description: The MediaEffects library enhances video applications by providing advanced media effects, including virtual backgrounds.
sidebar_label: MediaEffects library
pagination_label: MediaEffects library
keywords:
  - Apply Virtual Background
  - Remove Virtual Background
  - Change Virtual Background
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
---

# MediaEffects library - Android

<div id="tailwind" class="sdk-api-ref">

## Introduction

- The `MediaEffects` library enhances video applications with advanced media effects, including virtual backgrounds. It supports real-time processing and is optimized for Android devices.

- The `MediaEffects` library offers three classes to customize your video background: using a custom image, applying a blur effect, or choosing a solid color.

:::info

The Virtual Background feature in VideoSDK can be utilized regardless of the meeting environment, including the pre-call screen.

:::

## 1. BackgroundImageProcessor

- `BackgroundImageProcessor` sets a specified image as the background in a video stream, allowing you to customize the visual appearance of the video.
- `BackgroundImageProcessor` class provides following method.

  - `setBackgroundSource()` method updates the virtual background by setting a new image as the background that the user wants to switch to.
  
     - **Parameters**: `Uri`: An image URI for the background image.

     - **Return Type**: `void`
  
import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
val uri = Uri.parse("https://st.depositphotos.com/2605379/52364/i/450/depositphotos_523648932-stock-photo-concrete-rooftop-night-city-view.jpg")
val backgroundImageProcessor = BackgroundImageProcessor(uri) // Sets the background image

val newUri = Uri.parse("https://img.freepik.com/free-photo/plant-against-blue-wall-mockup_53876-96052.jpg?size=626&ext=jpg&ga=GA1.1.2008272138.1723420800&semt=ais_hybrid")
backgroundImageProcessor.setBackgroundSource(newUri) // Changed background image
```

</TabItem>

<TabItem value="Java">

```java
Uri uri = Uri.parse("https://st.depositphotos.com/2605379/52364/i/450/depositphotos_523648932-stock-photo-concrete-rooftop-night-city-view.jpg");
BackgroundImageProcessor backgroundImageProcessor= new BackgroundImageProcessor(uri); // Sets the background image

Uri uri = Uri.parse("https://img.freepik.com/free-photo/plant-against-blue-wall-mockup_53876-96052.jpg?size=626&ext=jpg&ga=GA1.1.2008272138.1723420800&semt=ais_hybrid");
backgroundImageProcessor.setBackgroundSource(uri); //Changed background image
```
</TabItem>

</Tabs>


## 2. BackgroundBlurProcessor
- `BackgroundBlurProcessor` applies a blur effect to the video background, with the intensity controlled by a float value, creating a softened visual effect.
- `BackgroundBlurProcessor` class provides following method.

  - `setBlurRadius()` method adjusts the blur effect on the video background, with the blur strength controlled by the specified float value.
  

     - **Parameters**: `Float`: representing the blur strength; higher values mean stronger blur. The supported range is 0 to 25.

     - **Return Type**: `void`


<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
val backgroundBlurProcessor = BackgroundBlurProcessor(25, this) // Applies a blur with intensity 25
backgroundBlurProcessor.setBlurRadius(17) // Changes the blur intensity to 17
```

</TabItem>

<TabItem value="Java">

```java
BackgroundBlurProcessor backgroundBlurProcessor = new BackgroundBlurProcessor(25, this);// Applies a blur with intensity 25
backgroundBlurProcessor.setBlurRadius(17); // changes the blur intensity to 17
```
</TabItem>

</Tabs>

## 3. BackgroundColorProcessor
- `BackgroundColorProcessor` sets a solid color as the video background using a `Color` object, enabling you to create a uniform color backdrop for your video.
- `BackgroundColorProcessor` class provides following method.

  - `setBackgroundColor()` method sets the color that user wants to switch to, for virtual background effect.

     - **Parameters**: `Integer`: Specifies the color for the virtual background.
     - **Return Type**: `void`

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
val backgroundColorProcessor = BackgroundColorProcessor(Color.BLUE) // Sets the background color to blue
backgroundColorProcessor.setBackgroundColor(Color.CYAN) // Changes the background color to CYAN
```

</TabItem>

<TabItem value="Java">

```java
BackgroundColorProcessor backgroundColorProcessor = new BackgroundColorProcessor(Color.BLUE);// Sets the background color to blue
backgroundColorProcessor.setBackgroundColor(Color.CYAN); // changed the background color to CYAN
```
</TabItem>

</Tabs>

</div>

---

---
sidebar_position: 1
sidebar_label: Introduction
pagination_label: Intro to Video SDK Meeting Class
title: Video SDK Meeting Class
---

# Video SDK Meeting Class - Android

<div class="sdk-api-ref">

## Introduction

The `Meeting` class includes properties, methods and meeting-event-listener-class for managing a meeting, participants, video, audio and share streams, messaging and UI customization.

import LinksGrid from "../../../../src/theme/LinksGrid";
import properties from "./../data/meeting-class/properties.json";
import methods from "./../data/meeting-class/methods.json";
import events from "./../data/meeting-class/events.json";

## Meeting Properties

<div class="row">

<div class="col col--4 margin-bottom--sm" >

- [getmeetingId()](/android/api/sdk-reference/meeting-class/properties#getmeetingid)

</div>
<div class="col col--4 margin-bottom--sm" >

- [getLocalParticipant()](./properties#getlocalparticipant)

</div>
<div class="col col--4 margin-bottom--sm" >

- [getParticipants()](./properties#getparticipants)

</div>
<div class="col col--4 margin-bottom--sm" >

- [pubSub](./properties#pubsub)

</div>

</div>

## Meeting Methods

<div class="row">

<div class="col col--4 margin-bottom--sm" >

- [join()](./methods#join)

</div>
<div class="col col--4 margin-bottom--sm" >

- [leave()](./methods#leave)

</div>
<div class="col col--4 margin-bottom--sm" >

- [end()](./methods#end)

</div>
<div class="col col--4 margin-bottom--sm" >

- [enableWebcam()](./methods#enablewebcam)

</div>
<div class="col col--4 margin-bottom--sm" >

- [disableWebcam()](./methods#disablewebcam)

</div>
<div class="col col--4 margin-bottom--sm" >

- [unmuteMic()](./methods#unmutemic)

</div>
<div class="col col--4 margin-bottom--sm" >

- [muteMic()](./methods#mutemic)

</div>
<div class="col col--4 margin-bottom--sm" >

- [enableScreenShare()](./methods#enablescreenshare)

</div>
<div class="col col--4 margin-bottom--sm" >

- [disableScreenShare()](./methods#disablescreenshare)

</div>
<div class="col col--4 margin-bottom--sm" >

- [startRecording()](./methods#startrecording)

</div>
<div class="col col--4 margin-bottom--sm" >

- [stopRecording()](./methods#stoprecording)

</div>
<div class="col col--4 margin-bottom--sm" >

- [startLiveStream()](./methods#startlivestream)

</div>
<div class="col col--4 margin-bottom--sm" >

- [stopLiveStream()](./methods#stoplivestream)

</div>
<div class="col col--4 margin-bottom--sm" >

- [startHls()](./methods#starthls)

</div>
<div class="col col--4 margin-bottom--sm" >

- [stopHls()](./methods#stophls)

</div>
<div class="col col--4 margin-bottom--sm" >

- [startTranscription()](./methods#starttranscription)

</div>
<div class="col col--4 margin-bottom--sm" >

- [stopTranscription()](./methods#stoptranscription)

</div>
<div class="col col--4 margin-bottom--sm" >

- [changeMode()](./methods#changemode)

</div>
<div class="col col--4 margin-bottom--sm" >

- [getMics()](./methods#getmics)

</div>
<div class="col col--4 margin-bottom--sm" >

- [changeMic()](./methods#changemic)

</div>
<div class="col col--4 margin-bottom--sm" >

- [setAudioDeviceChangeListener()](./methods#setaudiodevicechangelistener)

</div>
<div class="col col--4 margin-bottom--sm" >

- [changeWebcam()](./methods#changewebcam)

</div>
<div class="col col--4 margin-bottom--sm" >

- [uploadBase64File()](./methods#uploadbase64file)

</div>
<div class="col col--4 margin-bottom--sm" >

- [fetchBase64File()](./methods#fetchbase64file)

</div>
<div class="col col--4 margin-bottom--sm" >

- [addEventListener()](./methods#addeventlistener)

</div>
<div class="col col--4 margin-bottom--sm" >

- [removeEventListener()](./methods#removeeventlistener)

</div>
<div class="col col--4 margin-bottom--sm" >

- [removeAllListeners()](./methods#removealllisteners)

</div>
<div class="col col--4 margin-bottom--sm" >

- [startWhiteboard()](./methods#startwhiteboard)

</div>
<div class="col col--4 margin-bottom--sm" >

- [stopWhiteboard()](./methods#stopwhiteboard)

</div>

</div>

## Meeting Events

<div class="row">

<div class="col col--4 margin-bottom--sm" >

- [onMeetingJoined](./meeting-event-listener-class#onmeetingjoined)

</div>
<div class="col col--4 margin-bottom--sm" >

- [onMeetingLeft](./meeting-event-listener-class#onmeetingleft)

</div>
<div class="col col--4 margin-bottom--sm" >

- [onParticipantJoined](./meeting-event-listener-class#onparticipantjoined)

</div>
<div class="col col--4 margin-bottom--sm" >

- [onParticipantLeft](./meeting-event-listener-class#onparticipantleft)

</div>
<div class="col col--4 margin-bottom--sm" >

- [onSpeakerChanged](./meeting-event-listener-class#onspeakerchanged)

</div>
<div class="col col--4 margin-bottom--sm" >

- [onPresenterChanged](./meeting-event-listener-class#onpresenterchanged)

</div>
<div class="col col--4 margin-bottom--sm" >

- [onEntryRequested](./meeting-event-listener-class#onentryrequested)

</div>
<div class="col col--4 margin-bottom--sm" >

- [onEntryResponded](./meeting-event-listener-class#onentryresponded)

</div>
<div class="col col--4 margin-bottom--sm" >

- [onWebcamRequested](./meeting-event-listener-class#onwebcamrequested)

</div>
<div class="col col--4 margin-bottom--sm" >

- [onMicRequested](./meeting-event-listener-class#onmicrequested)

</div>
<div class="col col--4 margin-bottom--sm" >

- [onRecordingStateChanged](./meeting-event-listener-class#onrecordingstatechanged)

</div>
<div class="col col--4 margin-bottom--sm" >

- [onRecordingStarted](./meeting-event-listener-class#onrecordingstarted)

</div>
<div class="col col--4 margin-bottom--sm" >

- [onRecordingStopped](./meeting-event-listener-class#onrecordingstopped)

</div>
<div class="col col--4 margin-bottom--sm" >

- [onLivestreamStateChanged](./meeting-event-listener-class#onlivestreamstatechanged)

</div>
<div class="col col--4 margin-bottom--sm" >

- [onLivestreamStarted](./meeting-event-listener-class#onlivestreamstarted)

</div>
<div class="col col--4 margin-bottom--sm" >

- [onLivestreamStopped](./meeting-event-listener-class#onlivestreamstopped)

</div>
<div class="col col--4 margin-bottom--sm" >

- [onHlsStateChanged](./meeting-event-listener-class#onhlsstatechanged)

</div>
<div class="col col--4 margin-bottom--sm" >

- [onTranscriptionStateChanged](./meeting-event-listener-class#ontranscriptionstatechanged)

</div>
<div class="col col--4 margin-bottom--sm" >

- [onTranscriptionText](./meeting-event-listener-class#ontranscriptiontext)

</div>
<div class="col col--4 margin-bottom--sm" >

- [onExternalCallStarted](./meeting-event-listener-class#onexternalcallstarted)

</div>
<div class="col col--4 margin-bottom--sm" >

- [onMeetingStateChanged](./meeting-event-listener-class#onmeetingstatechanged)

</div>
<div class="col col--4 margin-bottom--sm" >

- [onParticipantModeChanged](./meeting-event-listener-class#onparticipantmodechanged)

</div>
<div class="col col--4 margin-bottom--sm" >

- [onPinStateChanged()](./meeting-event-listener-class#onpinstatechanged)

</div>

<div class="col col--4 margin-bottom--sm" >

- [onWhiteboardStarted()](./meeting-event-listener-class#onwhiteboardstarted)

</div>

<div class="col col--4 margin-bottom--sm" >

- [onWhiteboardStopped()](./meeting-event-listener-class#onwhiteboardstopped)

</div>

</div>

</div>


---

---
sidebar_position: 1
sidebar_label: MeetingEventListener Class
pagination_label: MeetingEventListener Class
title: MeetingEventListener Class
---

# MeetingEventListener Class - Android

<div class="sdk-api-ref-only-h4">

---

### implementation

- You can implement all the methods of `MeetingEventListener` abstract Class and add the listener to `Meeting` class using the `addEventListener()` method of `Meeting` Class.

#### Example

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
private final MeetingEventListener meetingEventListener = new MeetingEventListener() {
  override fun onMeetingJoined() {
    Log.d("#meeting", "onMeetingJoined()")
  }
}
```

</TabItem>

<TabItem value="Java">

```javascript
private final MeetingEventListener meetingEventListener = new MeetingEventListener() {
  @Override
  public void onMeetingJoined() {
    Log.d("#meeting", "onMeetingJoined()");
  }
}
```

</TabItem>

</Tabs>

---

### onMeetingJoined()

- This event will be emitted when a [localParticipant](./properties#getlocalparticipant) successfully joined the meeting.

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
 override fun onMeetingJoined() {
    Log.d("#meeting", "onMeetingJoined()")
 }
```

</TabItem>

<TabItem value="Java">

```javascript
 @Override
 public void onMeetingJoined() {
     Log.d("#meeting", "onMeetingJoined()");
 }
```

</TabItem>

</Tabs>

---

### onMeetingLeft()

- This event will be emitted when a [localParticipant](./properties#getlocalparticipant) left the meeting.

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
 override fun onMeetingLeft() {
    Log.d("#meeting", "onMeetingLeft()")
 }
```

</TabItem>

<TabItem value="Java">

```javascript
 @Override
 public void onMeetingLeft() {
    Log.d("#meeting", "onMeetingLeft()");
 }
```

</TabItem>

</Tabs>

---

### onParticipantJoined()

- This event will be emitted when a new [participant](../participant-class/introduction) joined the meeting.

#### Event callback parameters

- **participant**: [Participant](../participant-class/introduction)

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
 override fun onParticipantJoined(participant: Participant) {
    Log.d("#meeting", participant.displayName + " joined");
 }
```

</TabItem>

<TabItem value="Java">

```javascript
 @Override
 public void onParticipantJoined(Participant participant) {
    Log.d("#meeting", participant.getDisplayName() + " joined");
 }
```

</TabItem>

</Tabs>

---

### onParticipantLeft

- This event will be emitted when a joined [participant](../participant-class/introduction) left the meeting.

#### Event callback parameters

- **participant**: [Participant](../participant-class/introduction)

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
 override fun onParticipantLeft(participant: Participant) {
    Log.d("#meeting", participant.displayName + " left");
 }
```

</TabItem>

<TabItem value="Java">

```javascript
 @Override
 public void onParticipantLeft(Participant participant) {
    Log.d("#meeting", participant.getDisplayName() + " left");
 }
```

</TabItem>

</Tabs>

---

### onSpeakerChanged()

- This event will be emitted when a active speaker changed.
- If you want to know which participant is actively speaking, then this event will be used.
- If no participant is actively speaking, then this event will pass `null` as en event callback parameter.

#### Event callback parameters

- **participantId**: String

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
 override fun onSpeakerChanged(participantId: String?) {
  //
 }
```

</TabItem>

<TabItem value="Java">

```javascript
 @Override
 public void onSpeakerChanged(String participantId) {
  //
 }
```

</TabItem>

</Tabs>

---

### onPresenterChanged()

- This event will be emitted when any [participant](../participant-class/introduction) starts or stops screen sharing.
- It will pass `participantId` as an event callback parameter.
- If a participant stops screensharing, then this event will pass `null` as en event callback parameter.

#### Event callback parameters

- **participantId**: String

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
 override fun onPresenterChanged(participantId: String) {
  //
 }
```

</TabItem>

<TabItem value="Java">

```javascript
 @Override
 public void onPresenterChanged(String participantId) {
  //
 }
```

</TabItem>

</Tabs>

---

### onEntryRequested()

- This event will be emitted when a new [participant](../participant-class/introduction) who is trying to join the meeting, is having permission **`ask_join`** in token.
- This event will only be emitted to the [participants](./properties#getparticipants) in the meeting, who is having the permission **`allow_join`** in token.
- This event will pass following parameters as an event parameters, `participantId` and `name` of the new participant who is trying to join the meeting, `allow()` and `deny()` to take required actions.

#### Event callback parameters

- **peerId**: String
- **name**: String

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
 override fun onEntryRequested(id: String?, name: String?) {
    //
}
```

</TabItem>

<TabItem value="Java">

```javascript
 @Override
 public void onEntryRequested(String id, String name) {
    //
}
```

</TabItem>

</Tabs>

---

### onEntryResponded()

- This event will be emitted when the `join()` request is responded.
- This event will be emitted to the [participants](./properties#getparticipants) in the meeting, who is having the permission **`allow_join`** in token.
- This event will be also emitted to the [participant](../participant-class/introduction) who requested to join the meeting.

#### Event callback parameters

- **participantId**: _String_
- **decision**: _"allowed"_ | _"denied"_

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
 override fun onEntryResponded(id: String?, decision: String?) {
    //
  }
```

</TabItem>

<TabItem value="Java">

```javascript
 @Override
 public void onEntryResponded(String id, String decision) {
    //
  }
```

</TabItem>

</Tabs>

---

### onWebcamRequested()

- This event will be emitted to the participant `B` when any other participant `A` requests to enable webcam of participant `B`.
- On accepting the request, webcam of participant `B` will be enabled.

#### Event callback parameters

- **participantId**: String
- **listener**: WebcamRequestListener \{ **accept**: Method; **reject**: Method }

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
  override fun onWebcamRequested(participantId: String, listener: WebcamRequestListener) {
     // if accept request
     listener.accept()

     // if reject request
     listener.reject()
 }
```

</TabItem>

<TabItem value="Java">

```javascript
  @Override
 public void onWebcamRequested(String participantId, WebcamRequestListener listener) {
     // if accept request
     listener.accept();

     // if reject request
     listener.reject();
 }
```

</TabItem>

</Tabs>

### onMicRequested()

- This event will be emitted to the participant `B` when any other participant `A` requests to enable mic of participant `B`.
- On accepting the request, mic of participant `B` will be enabled.

#### Event callback parameters

- **participantId**: String
- **listener**: MicRequestListener \{ **accept**: Method; **reject**: Method }

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
 override fun onMicRequested(participantId: String, listener: MicRequestListener) {
     // if accept request
     listener.accept()

     // if reject request
     listener.reject()
 }
```

</TabItem>

<TabItem value="Java">

```javascript
 @Override
 public void onMicRequested(String participantId, MicRequestListener listener) {
     // if accept request
     listener.accept();

     // if reject request
     listener.reject();
 }
```

</TabItem>

</Tabs>

---

### onRecordingStateChanged()

- This event will be emitted when the meeting's recording status changed.

#### Event callback parameters

- **recordingState**: String

`recordingState` has following values

- `RECORDING_STARTING` - Recording is in starting phase and hasn't started yet.
- `RECORDING_STARTED` - Recording has started successfully.
- `RECORDING_STOPPING` - Recording is in stopping phase and hasn't stopped yet.
- `RECORDING_STOPPED` - Recording has stopped successfully.

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
  override fun onRecordingStateChanged(recordingState: String) {
    when (recordingState) {
        "RECORDING_STARTING" -> {
            Log.d("onRecordingStateChanged", "Meeting recording is starting")
        }
        "RECORDING_STARTED" -> {
            Log.d("onRecordingStateChanged", "Meeting recording is started")
        }
        "RECORDING_STOPPING" -> {
            Log.d("onRecordingStateChanged", "Meeting recording is stopping")
        }
        "RECORDING_STOPPED" -> {
            Log.d("onRecordingStateChanged", "Meeting recording is stopped")
        }
    }
  }
```

</TabItem>

<TabItem value="Java">

```javascript
  @Override
  public void onRecordingStateChanged(String recordingState) {
      switch (recordingState) {
          case "RECORDING_STARTING":
              Log.d("onRecordingStateChanged", "Meeting recording is starting");
              break;
          case "RECORDING_STARTED":
              Log.d("onRecordingStateChanged", "Meeting recording is started");
              break;
          case "RECORDING_STOPPING":
              Log.d("onRecordingStateChanged", "Meeting recording is stopping");
              break;
          case "RECORDING_STOPPED":
              Log.d("onRecordingStateChanged", "Meeting recording is stopped");
              break;
      }
  }
```

</TabItem>

</Tabs>

---

### onRecordingStarted()

_`This event will be deprecated soon`_

- This event will be emitted when recording of the meeting is started.

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
 override fun onRecordingStarted() {
   //
 }
```

</TabItem>

<TabItem value="Java">

```javascript
 @Override
 public void onRecordingStarted() {
   //
 }
```

</TabItem>

</Tabs>

---

### onRecordingStopped()

_`This event will be deprecated soon`_

- This event will be emitted when recording of the meeting is stopped.

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
 override fun onRecordingStopped() {
   //
 }
```

</TabItem>

<TabItem value="Java">

```javascript
 @Override
 public void onRecordingStopped() {
   //
 }
```

</TabItem>

</Tabs>

---

### onLivestreamStateChanged()

- This event will be emitted when the meeting's livestream status changed.

#### Event callback parameters

- **livestreamState**: String

`livestreamState` has following values

- `LIVESTREAM_STARTING` - Livestream is in starting phase and hasn't started yet.
- `LIVESTREAM_STARTED` - Livestream has started successfully.
- `LIVESTREAM_STOPPING` - Livestream is in stopping phase and hasn't stopped yet.
- `LIVESTREAM_STOPPED` - Livestream has stopped successfully.

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
  override fun onLivestreamStateChanged(livestreamState: String?) {
    when (livestreamState) {
        "LIVESTREAM_STARTING" -> Log.d( "LivestreamStateChanged",
            "Meeting livestream is starting"
        )
        "LIVESTREAM_STARTED" -> Log.d( "LivestreamStateChanged",
            "Meeting livestream is started"
        )
        "LIVESTREAM_STOPPING" -> Log.d("LivestreamStateChanged",
            "Meeting livestream is stopping"
        )
        "LIVESTREAM_STOPPED" -> Log.d("LivestreamStateChanged",
            "Meeting livestream is stopped"
        )
    }
  }
```

</TabItem>

<TabItem value="Java">

```javascript
  @Override
  public void onLivestreamStateChanged(String livestreamState) {
      switch (livestreamState) {
          case "LIVESTREAM_STARTING":
              Log.d("LivestreamStateChanged", "Meeting livestream is starting");
              break;
          case "LIVESTREAM_STARTED":
              Log.d("LivestreamStateChanged", "Meeting livestream is started");
              break;
          case "LIVESTREAM_STOPPING":
              Log.d("LivestreamStateChanged", "Meeting livestream is stopping");
              break;
          case "LIVESTREAM_STOPPED":
              Log.d("LivestreamStateChanged", "Meeting livestream is stopped");
              break;
      }
  }
```

</TabItem>

</Tabs>

---

### onLivestreamStarted()

_`This event will be deprecated soon`_

- This event will be emitted when `RTMP` live stream of the meeting is started.

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
 override fun onLivestreamStarted() {
   //
 }
```

</TabItem>

<TabItem value="Java">

```javascript
 @Override
 public void onLivestreamStarted() {
   //
 }
```

</TabItem>

</Tabs>

---

### onLivestreamStopped()

_`This event will be deprecated soon`_

- This event will be emitted when `RTMP` live stream of the meeting is stopped.

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
 override fun onLivestreamStopped() {
   //
 }
```

</TabItem>

<TabItem value="Java">

```javascript
 @Override
 public void onLivestreamStopped() {
   //
 }
```

</TabItem>

</Tabs>

---

### onHlsStateChanged()

- This event will be emitted when the meeting's HLS(Http Livestreaming) status changed.

#### Event callback parameters

- **HlsState**: \{ **status**: String}

  - `status` has following values :
    - `HLS_STARTING` - HLS is in starting phase and hasn't started yet.
    - `HLS_STARTED` - HLS has started successfully.
    - `HLS_PLAYABLE` - HLS can be playable now.
    - `HLS_STOPPING` - HLS is in stopping phase and hasn't stopped yet.
    - `HLS_STOPPED` - HLS has stopped successfully.

- when you receive `HLS_PLAYABLE` status you will receive 2 urls in response
  - `playbackHlsUrl` - Live HLS with playback support
  - `livestreamUrl` - Live HLS without playback support

:::note
`downstreamUrl` is now depecated. Use `playbackHlsUrl` or `livestreamUrl` in place of `downstreamUrl`
:::

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
  override fun onHlsStateChanged(HlsState: JSONObject) {
    when (HlsState.getString("status")) {
        "HLS_STARTING" -> Log.d("onHlsStateChanged", "Meeting hls is starting")
        "HLS_STARTED" -> Log.d("onHlsStateChanged", "Meeting hls is started")
        "HLS_PLAYABLE" -> {
            Log.d("onHlsStateChanged", "Meeting hls is playable now")
            // on hls playable you will receive playbackHlsUrl and livestreamUrl
            val playbackHlsUrl = HlsState.getString("playbackHlsUrl")
            val livestreamUrl = HlsState.getString("livestreamUrl")

        }
        "HLS_STOPPING" -> Log.d("onHlsStateChanged", "Meeting hls is stopping")
        "HLS_STOPPED" -> Log.d("onHlsStateChanged", "Meeting hls is stopped")
    }
  }
```

</TabItem>

<TabItem value="Java">

```javascript
  @Override
  public void onHlsStateChanged(JSONObject HlsState) {
      switch (HlsState.getString("status")) {
          case "HLS_STARTING":
              Log.d("onHlsStateChanged", "Meeting hls is starting");
              break;
          case "HLS_STARTED":
              Log.d("onHlsStateChanged", "Meeting hls is started");
              break;
          case "HLS_PLAYABLE":
              Log.d("onHlsStateChanged", "Meeting hls is playable now");
              // on hls started you will receive playbackHlsUrl and livestreamUrl
              String playbackHlsUrl = HlsState.getString("playbackHlsUrl");
              String livestreamUrl = HlsState.getString("livestreamUrl");
              break;
          case "HLS_STOPPING":
              Log.d("onHlsStateChanged", "Meeting hls is stopping");
              break;
          case "HLS_STOPPED":
              Log.d("onHlsStateChanged", "Meeting hls is stopped");
              break;
      }
  }
```

</TabItem>

</Tabs>

---

### onTranscriptionStateChanged()

- This event will be triggered whenever state of realtime transcription is changed.

#### Event callback parameters

- **data**: \{ **status**: String, **id**: String }
  - **status**: String
  - **id**: String

`status` has following values

- `TRANSCRIPTION_STARTING` - Realtime Transcription is in starting phase and hasn't started yet.
- `TRANSCRIPTION_STARTED` - Realtime Transcription has started successfully.
- `TRANSCRIPTION_STOPPING` - Realtime Transcription is in stopping phase and hasn't stopped yet.
- `TRANSCRIPTION_STOPPED` - Realtime Transcription has stopped successfully.

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
override fun onTranscriptionStateChanged(data: JSONObject) {
  //Status can be :: TRANSCRIPTION_STARTING
  //Status can be :: TRANSCRIPTION_STARTED
  //Status can be :: TRANSCRIPTION_STOPPING
  //Status can be :: TRANSCRIPTION_STOPPED
  val status = data.getString("status")
  Log.d("MeetingActivity", "Transcription status: $status")
}
```

</TabItem>

<TabItem value="Java">

```javascript
@Override
public void onTranscriptionStateChanged(JSONObject data) {
  //Status can be :: TRANSCRIPTION_STARTING
  //Status can be :: TRANSCRIPTION_STARTED
  //Status can be :: TRANSCRIPTION_STOPPING
  //Status can be :: TRANSCRIPTION_STOPPED
  String status = data.getString("status");
  Log.d("MeetingActivity", "Transcription status: " + status);
}
```

</TabItem>

</Tabs>

---

### onTranscriptionText()

- This event will be emitted when text for running realtime transcription received.

#### Event callback parameters

- **data**: TranscriptionText
  - **TranscriptionText.participantId**: String
  - **TranscriptionText.participantName**: String
  - **TranscriptionText.text**: String
  - **TranscriptionText.timestamp**: int
  - **TranscriptionText.type**: String

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
override fun onTranscriptionText(data: TranscriptionText) {
  val participantId = data.participantId
  val participantName = data.participantName
  val text = data.text
  val timestamp = data.timestamp
  val type = data.type

  Log.d("MeetingActivity", "$participantName: $text $timestamp")
}
```

</TabItem>

<TabItem value="Java">

```javascript
@Override
public void onTranscriptionText(TranscriptionText data) {
  String participantId = data.getParticipantId();
  String participantName = data.getParticipantName();
  String text = data.getText();
  int timestamp = data.getTimestamp();
  String type = data.getType();

  Log.d("MeetingActivity", participantName + ": " + text + " " + timestamp);
}
```

</TabItem>

</Tabs>

---

### onWhiteboardStarted()

- This event will be triggered when the whiteboard is successfully started.

#### Event callback parameters

**url**: String

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
override fun onWhiteboardStarted(url: String) {
    super.onWhiteboardStarted(url)
    //...
}
```

</TabItem>

<TabItem value="Java">

```java
@Override
public void onWhiteboardStarted(String url) {
    super.onWhiteboardStarted(url);
    //...
}
```

</TabItem>

</Tabs>

---

### onWhiteboardStopped()

- This event will be triggered when the whiteboard session is successfully terminated.

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
override fun onWhiteboardStopped() {
    super.onWhiteboardStopped()
    //...
}
```

</TabItem>

<TabItem value="Java">

```java
@Override
public void onWhiteboardStopped() {
    super.onWhiteboardStopped();
    //...
}
```

</TabItem>

</Tabs>

---

### onExternalCallStarted()

- This event will be emitted when local particpant receive incoming call.

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
 override fun onExternalCallStarted() {
   //
 }
```

</TabItem>

<TabItem value="Java">

```javascript
 @Override
 public void onExternalCallStarted() {
   //
 }
```

</TabItem>

</Tabs>

---

### onMeetingStateChanged()

- This event will be emitted when state of meeting changes.
- It will pass **`state`** as an event callback parameter which will indicate current state of the meeting.
- All available states are `CONNECTING`, `CONNECTED`, `FAILED`, `DISCONNECTED`, `CLOSING`, `CLOSED`.

#### Event callback parameters

- **state**: String

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
 override fun onMeetingStateChanged(state: String?) {
    when (state) {
      "CONNECTING" -> Log.d("onMeetingStateChanged: ", "Meeting is Connecting")
      "CONNECTED" -> Log.d("onMeetingStateChanged: ", "Meeting is Connected")
      "FAILED" -> Log.d("onMeetingStateChanged: ", "Meeting connection failed")
      "DISCONNECTED" -> Log.d("onMeetingStateChanged: ","Meeting connection disconnected abruptly")
      "CLOSING" -> Log.d("onMeetingStateChanged: ", "Meeting is closing")
      "CLOSED" -> Log.d("onMeetingStateChanged: ", "Meeting connection closed")
    }
  }
```

</TabItem>

<TabItem value="Java">

```javascript
@Override
  public void onMeetingStateChanged(String state) {
    switch (state) {
        case "CONNECTING":
          Log.d("onMeetingStateChanged: ", "Meeting is Connecting");
          break;
        case "CONNECTED":
          Log.d("onMeetingStateChanged: ", "Meeting is Connected");
          break;
        case "FAILED":
          Log.d("onMeetingStateChanged: ", "Meeting connection failed");
          break;
        case "DISCONNECTED":
          Log.d("onMeetingStateChanged: ", "Meeting connection disconnected abruptly");
          break;
        case "CLOSING":
          Log.d("onMeetingStateChanged: ", "Meeting is closing");
          break;
        case "CLOSED":
          Log.d("onMeetingStateChanged: ", "Meeting connection closed");
          break;
    }
  }

```

</TabItem>

</Tabs>

---
### onParticipantModeChanged()

This event is triggered when a participant's mode is updated.

It passes `data` as an event callback parameter, which includes the following:

- **`SEND_AND_RECV`**: Both audio and video streams will be produced and consumed.

- **`SIGNALLING_ONLY`**: Audio and video streams will not be produced or consumed. It is used solely for signaling.

- **`RECV_ONLY`**: Only audio and video streams will be consumed without producing any.
This event is triggered when a participant's mode is updated.

#### Event Callback Parameters

- **data**: `{ mode: String, participantId: String }`
  - **mode**: `String`
  - **participantId**: `String`

import CautionMessage from '@site/src/theme/CautionMessage';


<CautionMessage sdk="Android SDK" version="v0.2.0" />


#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
 override fun onParticipantModeChanged(data: JSONObject?) {
   //
  }
```

</TabItem>

<TabItem value="Java">

```javascript
@Override
  public void onParticipantModeChanged(JSONObject data) {
    //
  }

```

</TabItem>

</Tabs>

---

### onPinStateChanged()

- This event will be triggered when any participant got pinned or unpinned by any participant got pinned or unpinned by any participant.

#### Event callback parameters

- **pinStateData**: \{ **peerId**: String, **state**: JSONObject, **pinnedBy**: String }
  - **peerId**: String
  - **state**: JSONObject
  - **pinnedBy**: String

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
 override fun onPinStateChanged(pinStateData: JSONObject?) {
   Log.d("onPinStateChanged: ", pinStateData.getString("peerId")) // id of participant who were pinned
   Log.d("onPinStateChanged: ", pinStateData.getJSONObject("state")) // { cam: true, share: true }
   Log.d("onPinStateChanged: ", pinStateData.getString("pinnedBy")) // id of participant who pinned that participant
  }
```

</TabItem>

<TabItem value="Java">

```javascript
@Override
  public void onPinStateChanged(JSONObject pinStateData) {
    Log.d("onPinStateChanged: ", pinStateData.getString("peerId")); // id of participant who were pinned
    Log.d("onPinStateChanged: ", pinStateData.getJSONObject("state")); // { cam: true, share: true }
    Log.d("onPinStateChanged: ", pinStateData.getString("pinnedBy")); // id of participant who pinned that participant
  }

```

</TabItem>

</Tabs>

</div>


---

---
sidebar_position: 1
sidebar_label: Methods
pagination_label: Meeting Class Methods
title: Meeting Class Methods
---

# Meeting Class Methods - Android

<div class="sdk-api-ref-only-h4">

### join()

- It is used to join a meeting.
- After meeting initialization by [`initMeeting()`](../initMeeting) it returns a new instance of [Meeting](./introduction). However by default, it will not automatically join the meeting. Hence, to join the meeting you should call `join()`.

#### Events associated with `join()`:

- Local Participant will receive a [`onMeetingJoined`](./meeting-event-listener-class#onmeetingjoined) event, when successfully joined.
- Remote Participant will receive a [`onParticipantJoined`](./meeting-event-listener-class#onparticipantjoined) event with the newly joined [`Participant`](../participant-class/introduction) object from the event callback.

#### Participant having `ask_join` permission inside token

- If a token contains the permission `ask_join`, then the participant will not join the meeting directly after calling `join()`, but an event will be emitted to the participant having the permission `allow_join` called [`onEntryRequested`](./meeting-event-listener-class#onentryrequested).

- After the decision from the remote participant, an event will be emitted to participant called [`onEntryResponded`](./meeting-event-listener-class#onentryresponded). This event will contain the decision made by the remote participant.

#### Participant having `allow_join` permission inside token

- If a token containing the permission `allow_join`, then the participant will join the meeting directly after calling `join()`.

#### Returns

- _`void`_

---

### leave()

- It is used to leave the current meeting.

#### Events associated with `leave()`:

- Local participant will receive a [`onMeetingLeft`](./meeting-event-listener-class#onmeetingleft) event.
- All remote participants will receive a [`onParticipantLeft`](./meeting-event-listener-class#onparticipantleft) event with `participantId`.

#### Returns

- _`void`_

---

### end()

- It is used to end the current running session.
- By calling `end()`, all joined [participants](properties#getparticipants) including [localParticipant](./properties.md#getlocalparticipant) of that session will leave the meeting.

#### Events associated with `end()`:

- All [participants](./properties.md#getparticipants) and [localParticipant](./properties.md#getlocalparticipant), will be emitted [`onMeetingLeft`](./meeting-event-listener-class#onmeetingleft) event.

#### Returns

- _`void`_

---

### enableWebcam()

- It is used to enable self camera.
- [`onStreamEnabled`](../participant-class/participant-event-listener-class#onstreamenabled) event of `ParticipantEventListener` will be emitted with [`stream`](../stream-class/introduction) object from the event callback.

#### Returns

- _`void`_

---

### disableWebcam()

- It is used to disable self camera.
- [`onStreamDisabled`](../participant-class/participant-event-listener-class#onstreamdisabled) event of `ParticipantEventListener` will be emitted with [`stream`](../stream-class/introduction) object from the event callback.

#### Returns

- _`void`_

---

### unmuteMic()

- It is used to enable self microphone.
- [`onStreamEnabled`](../participant-class/participant-event-listener-class#onstreamenabled) event of `ParticipantEventListener` will be emitted with [`stream`](../stream-class/introduction) object from the event callback.

#### Returns

- _`void`_

---

### muteMic()

- It is used to disable self microphone.
- [`onStreamDisabled`](../participant-class/participant-event-listener-class#onstreamdisabled) event of `ParticipantEventListener` will be emitted with [`stream`](../stream-class/introduction) object from the event callback.

#### Returns

- _`void`_

---

### enableScreenShare()

- it is used to enable screen-sharing.

- [`onStreamEnabled`](../participant-class/participant-event-listener-class#onstreamenabled) event of `ParticipantEventListener` will be emitted with [`stream`](../stream-class/introduction) object from the event callback.

- [`onPresenterChanged()`](./meeting-event-listener-class#onpresenterchanged) event will be trigget to all participant with `participantId`.

#### Parameters

- **data**: Intent

#### Returns

- _`void`_

---

### disableScreenShare()

- It is used to disable screen-sharing.

- [`onStreamDisabled`](../participant-class/participant-event-listener-class#onstreamdisabled) event of `ParticipantEventListener` will be emitted with [`stream`](../stream-class/introduction) object from the event callback.

- [`onPresenterChanged()`](./meeting-event-listener-class#onpresenterchanged) event will be trigget to all participant with `null`.

#### Returns

- _`void`_

---

### uploadBase64File()

- It is used to upload your file to Videosdk's Temporary storage.

- `base64Data` convert your file to base64 and pass here.
- `token` pass your videosdk token. Read more about token [here](/android/guide/video-and-audio-calling-api-sdk/authentication-and-token)
- `fileName` provide your fileName with extension.
- `TaskCompletionListener` will handle the result of the upload operation.

  - When the upload is complete, the `onComplete()` method of `TaskCompletionListener` will provide the corresponding `fileUrl`, which can be used to retrieve the uploaded file.

  - If an error occurs during the upload process, the `onError()` method of `TaskCompletionListener` will provide the error details.

#### Parameters

- **base64Data**: String
- **token**: String
- **fileName**: String
- **listener**: TaskCompletionListener

#### Returns

- _`void`_

#### Example

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
private fun uploadFile() {
  val base64Data = "<Your File's base64>" // Convert your file to base64 and pass here
  val token = "<VIDEOSDK_TOKEN>"
  val fileName = "myImage.jpeg" // Provide name with extension here
  meeting!!.uploadBase64File(
    base64Data,
    token,
    fileName,
    object : TaskCompletionListener<String?, String?> {
      override fun onComplete(data: String?) {
          Log.d("VideoSDK", "Uploaded file url: $data")
      }

      override fun onError(error: String?) {
          Log.d("VideoSDK", "Error in upload file: $error")
      }
    }
  )
}
```

</TabItem>

<TabItem value="Java">

```js
private void uploadFile() {
  String base64Data = "<Your File's base64>"; // Convert your file to base64 and pass here
  String token = "<VIDEOSDK_TOKEN>";
  String fileName = "myImage.jpeg"; // Provide name with extension here
  meeting.uploadBase64File(base64Data, token, fileName, new TaskCompletionListener<String, String>() {
    @Override
    public void onComplete(@Nullable String data) {
        Log.d("VideoSDK", "Uploaded file url: " + data);
    }

    @Override
    public void onError(@Nullable String error) {
        Log.d("VideoSDK", "Error in upload file: " + error);
    }
  });
}
```

</TabItem>

</Tabs>

---

### fetchBase64File()

- It is used to retrieve your file from the Videosdk's Temporary storage.

- `url` pass fileUrl which is returned by `uploadBase64File()`
- `token` pass your videosdk token. Read more about token [here](/android/guide/video-and-audio-calling-api-sdk/authentication-and-token)
- `TaskCompletionListener` will handle the result of the fetch operation.

  - When the fetch operation is complete, the `onComplete()` method of `TaskCompletionListener` will provide the file in `base64` format.

  - If an error occurs during the fetch operation, the `onError()` method of `TaskCompletionListener` will provide the error details.

#### Parameters

- **url**: String
- **token**: String
- **listener**: TaskCompletionListener

#### Returns

- _`void`_

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
private fun fetchFile() {
  val url = "<Your FileUrl>"  // Provide fileUrl which is returned by uploadBase64File()
  val token = "<VIDEOSDK_TOKEN>"
  meeting.fetchBase64File(url, token, object : TaskCompletionListener<String?, String?> {
      override fun onComplete(data: String?) {
          Log.d("VideoSDK", "Fetched file in base64:$data")
      }

      override fun onError(error: String?) {
          Log.d("VideoSDK", "Error in fetch file: $error")
      }
  })
}
```

</TabItem>

<TabItem value="Java">

```js
private void fetchFile() {
  String url = "<Your FileUrl>";  // Provide fileUrl which is returned by uploadBase64File()
  String token = "<VIDEOSDK_TOKEN>";
  meeting.fetchBase64File(url, token, new TaskCompletionListener<String, String>() {
      @Override
      public void onComplete(@Nullable String data) {
          Log.d("VideoSDK", "Fetched file in base64:" + data);
      }

      @Override
      public void onError(@Nullable String error) {
          Log.d("VideoSDK", "Error in fetch file: " + error);
      }
  });
}
```

</TabItem>

</Tabs>

---

### startRecording()

- `startRecording` is used to start meeting recording.

- `webhookUrl` will be triggered when the recording is completed and stored into server. Read more about webhooks [here](https://en.wikipedia.org/wiki/Webhook).

- `awsDirPath` will be the path for the your S3 bucket where you want to store recordings to. To allow us to store recording in your S3 bucket, you will need to fill this form by providing the required values. [VideoSDK AWS S3 Integration](https://zfrmz.in/RVlFLFiturVJ7Q97fr23)

- `config: mode` is used to either record video-and-audio both or only audio. And by default it will be video-and-audio.

- `config: quality` is only applicable to video-and-audio.

- `transcription` This parameter lets you start post transcription for the recording.

#### Parameters

- **webhookUrl**: String
- **awsDirPath**: String
- **config**:

  - **layout**:
    - **type**: _"GRID"_ | _"SPOTLIGHT"_ | _"SIDEBAR"_
    - **priority**: _"SPEAKER"_ | _"PIN"_
    - **gridSize**: Number _`max 4`_
  - **theme**: _"DARK"_ | _"LIGHT"_ | _"DEFAULT"_
  - **mode**: _"video-and-audio"_ | _"audio"_
  - **quality**: _"low"_ | _"med"_ | _"high"_
  - **orientation**: _"landscape"_ | _"portrait"_

- **transcription**: **PostTranscriptionConfig**
  - **PostTranscriptionConfig.enabled**: boolean
  - **PostTranscriptionConfig.modelId**: String
  - **PostTranscriptionConfig.summary**: SummaryConfig
    - **SummaryConfig.enabled**: boolean
    - **SummaryConfig.prompt**: String

#### Returns

- _`void`_

#### Events associated with `startRecording()`:

- Every participant will receive a callback on [`onRecordingStateChanged()`](./meeting-event-listener-class#onrecordingstatechanged)

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
val webhookUrl = "https://webhook.your-api-server.com"
var config = JSONObject()
var layout = JSONObject()
JsonUtils.jsonPut(layout, "type", "SPOTLIGHT")
JsonUtils.jsonPut(layout, "priority", "PIN")
JsonUtils.jsonPut(layout, "gridSize", 9)
JsonUtils.jsonPut(config, "layout", layout)
JsonUtils.jsonPut(config, "theme", "DARK")

val prompt = "Write summary in sections like Title, Agenda, Speakers, Action Items, Outlines, Notes and Summary"
val summaryConfig = SummaryConfig(true, prompt)
val modelId = "raman_v1"
val transcription = PostTranscriptionConfig(true, summaryConfig, modelId)

meeting!!.startRecording(webhookUrl,null,config,transcription)
```

</TabItem>

<TabItem value="Java">

```js
String webhookUrl = "https://webhook.your-api-server.com";
JSONObject config = new JSONObject();
JSONObject layout = new JSONObject();
JsonUtils.jsonPut(layout, "type", "SPOTLIGHT");
JsonUtils.jsonPut(layout, "priority", "PIN");
JsonUtils.jsonPut(layout, "gridSize", 9);
JsonUtils.jsonPut(config, "layout", layout);
JsonUtils.jsonPut(config, "theme", "DARK");

String prompt = "Write summary in sections like Title, Agenda, Speakers, Action Items, Outlines, Notes and Summary";
SummaryConfig summaryConfig = new SummaryConfig(true, prompt);
String modelId = "raman_v1";
PostTranscriptionConfig transcription = new PostTranscriptionConfig(true, summaryConfig, modelId);

meeting.startRecording(webhookUrl,null,config,transcription);
```

</TabItem>

</Tabs>

---

### stopRecording()

- It is used to stop meeting recording.

#### Returns

- _`void`_

#### Events associated with `stopRecording()`:

- Every participant will receive a callback on [`onRecordingStateChanged()`](./meeting-event-listener-class#onrecordingstatechanged)

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
meeting!!.stopRecording()
```

</TabItem>

<TabItem value="Java">

```javascript
meeting.stopRecording();
```

</TabItem>

</Tabs>

---

### startLivestream()

- `startLiveStream()` is used to start meeting livestreaming.

- You will be able to start live stream meetings to other platforms such as Youtube, Facebook, etc. that support `RTMP` streaming.

#### Parameters

- **outputs**: `List<LivestreamOutput>`
- **config**:
  - **layout**:
    - **type**: _"GRID"_ | _"SPOTLIGHT"_ | _"SIDEBAR"_
    - **priority**: _"SPEAKER"_ | _"PIN"_
    - **gridSize**: Number _`max 25`_
  - **theme**: _"DARK"_ | _"LIGHT"_ | _"DEFAULT"_

#### Returns

- _`void`_

#### Events associated with `startLiveStream()`:

- Every participant will receive a callback on [`onLivestreamStateChanged()`](./meeting-event-listener-class#onlivestreamstatechanged)

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
val YOUTUBE_RTMP_URL = "rtmp://a.rtmp.youtube.com/live2"
val YOUTUBE_RTMP_STREAM_KEY = "<STREAM_KEY>"

val outputs: MutableList<LivestreamOutput> = ArrayList()
outputs.add(LivestreamOutput(YOUTUBE_RTMP_URL, YOUTUBE_RTMP_STREAM_KEY))

var config = JSONObject()
var layout = JSONObject()
JsonUtils.jsonPut(layout, "type", "SPOTLIGHT")
JsonUtils.jsonPut(layout, "priority", "PIN")
JsonUtils.jsonPut(layout, "gridSize", 9)
JsonUtils.jsonPut(config, "layout", layout)
JsonUtils.jsonPut(config, "theme", "DARK")

meeting!!.startLivestream(outputs,config)
```

</TabItem>

<TabItem value="Java">

```javascript
final String YOUTUBE_RTMP_URL = "rtmp://a.rtmp.youtube.com/live2";
final String YOUTUBE_RTMP_STREAM_KEY = "<STREAM_KEY>";

List<LivestreamOutput> outputs = new ArrayList<>();
outputs.add(new LivestreamOutput(YOUTUBE_RTMP_URL, YOUTUBE_RTMP_STREAM_KEY));

JSONObject config = new JSONObject();
JSONObject layout = new JSONObject();
JsonUtils.jsonPut(layout, "type", "SPOTLIGHT");
JsonUtils.jsonPut(layout, "priority", "PIN");
JsonUtils.jsonPut(layout, "gridSize", 9);
JsonUtils.jsonPut(config, "layout", layout);
JsonUtils.jsonPut(config, "theme", "DARK");

meeting.startLivestream(outputs,config);
```

</TabItem>

</Tabs>

---

### stopLivestream()

- It is used to stop meeting livestreaming.

#### Returns

- _`void`_

#### Events associated with `stopLivestream()`:

- Every participant will receive a callback on [`onLivestreamStateChanged()`](./meeting-event-listener-class#onlivestreamstatechanged)

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
meeting!!.stopLivestream()
```

</TabItem>

<TabItem value="Java">

```javascript
meeting.stopLivestream();
```

</TabItem>

</Tabs>

---

### startHls()

- `startHls()` will start HLS streaming of your meeting.

- You will be able to start HLS and watch the live stream of meeting over HLS.

- `mode` is used to either start hls streaming of video-and-audio both or only audio. And by default it will be video-and-audio.

- `quality` is only applicable to video-and-audio.

- `transcription` This parameter lets you start post transcription for the recording.

#### Parameters

- **config**:

  - **layout**:
    - **type**: _"GRID"_ | _"SPOTLIGHT"_ | _"SIDEBAR"_
    - **priority**: _"SPEAKER"_ | _"PIN"_
    - **gridSize**: Number _`max 25`_
  - **theme**: _"DARK"_ | _"LIGHT"_ | _"DEFAULT"_
  - **mode**: _"video-and-audio"_ | _"audio"_
  - **quality**: _"low"_ | _"med"_ | _"high"_

- **transcription**: **PostTranscriptionConfig**
  - **PostTranscriptionConfig.enabled**: boolean
  - **PostTranscriptionConfig.modelId**: String
  - **PostTranscriptionConfig.summary**: SummaryConfig
    - **SummaryConfig.enabled**: boolean
    - **SummaryConfig.prompt**: String

#### Returns

- _`void`_

#### Events associated with `startHls()`:

- Every participant will receive a callback on [`onHlsStateChanged()`](./meeting-event-listener-class#onhlsstatechanged)

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
var config = JSONObject()
var layout = JSONObject()
JsonUtils.jsonPut(layout, "type", "SPOTLIGHT")
JsonUtils.jsonPut(layout, "priority", "PIN")
JsonUtils.jsonPut(layout, "gridSize", 9)
JsonUtils.jsonPut(config, "layout", layout)
JsonUtils.jsonPut(config, "orientation", "portrait")
JsonUtils.jsonPut(config, "theme", "DARK")

val prompt = "Write summary in sections like Title, Agenda, Speakers, Action Items, Outlines, Notes and Summary"
val summaryConfig = SummaryConfig(true, prompt)
val modelId = "raman_v1"
val transcription = PostTranscriptionConfig(true, summaryConfig,modelId)

meeting!!.startHls(config, transcription)
```

</TabItem>

<TabItem value="Java">

```javascript
JSONObject config = new JSONObject();
JSONObject layout = new JSONObject();
JsonUtils.jsonPut(layout, "type", "SPOTLIGHT");
JsonUtils.jsonPut(layout, "priority", "PIN");
JsonUtils.jsonPut(layout, "gridSize", 9);
JsonUtils.jsonPut(config, "layout", layout);
JsonUtils.jsonPut(config, "orientation", "portrait");
JsonUtils.jsonPut(config, "theme", "DARK");

String prompt = "Write summary in sections like Title, Agenda, Speakers, Action Items, Outlines, Notes and Summary";
SummaryConfig summaryConfig = new SummaryConfig(true, prompt);
String modelId = "raman_v1";
PostTranscriptionConfig transcription = new PostTranscriptionConfig(true, summaryConfig,modelId);

meeting.startHls(config,transcription);
```

</TabItem>

</Tabs>

---

### stopHls()

- `stopHls()` is used to stop the HLS streaming.

#### Returns

- _`void`_

#### Events associated with `stopHls()`:

- Every participant will receive a callback on [`onHlsStateChanged()`](./meeting-event-listener-class#onhlsstatechanged)

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
meeting!!.stopHls()
```

</TabItem>

<TabItem value="Java">

```javascript
meeting.stopHls();
```

</TabItem>

</Tabs>

---

### startTranscription()

- `startTranscription()` It is used to start realtime transcription.

#### Parameters

#### config

- type : `TranscriptionConfig`

- This specifies the configurations for realtime transcription. You can specify following properties.
  - `TranscriptionConfig.webhookUrl`: Webhooks will be triggered when the state of realtime transcription is changed. Read more about webhooks [here](https://en.wikipedia.org/wiki/Webhook)
  - `TranscriptionConfig.summary`: `SummaryConfig`
    - `enabled`: Indicates whether realtime transcription summary generation is enabled. Summary will be available after realtime transcription stopped. Default: `false`
    - `prompt`: provides guidelines or instructions for generating a custom summary based on the realtime transcription content.

#### Returns

- _`void`_

#### Events associated with `startTranscription()`:

- Every participant will receive a callback on [`onTranscriptionStateChanged()`](./meeting-event-listener-class#ontranscriptionstatechanged)

- Every participant will receive a callback on [`onTranscriptionText()`](./meeting-event-listener-class#ontranscriptiontext)

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
// Realtime Transcription Configuration
val webhookUrl = "https://www.example.com"

val summaryConfig = SummaryConfig(
    true,
    "Write summary in sections like Title, Agenda, Speakers, Action Items, Outlines, Notes and Summary"
)
val transcriptionConfig = TranscriptionConfig(
    webhookUrl,
    summaryConfig
)

meeting!!.startTranscription(transcriptionConfig)
```

</TabItem>

<TabItem value="Java">

```javascript
// Realtime Transcription Configuration
final String webhookUrl = "https://www.example.com";

SummaryConfig summaryConfig = new SummaryConfig(
    true,
    "Write summary in sections like Title, Agenda, Speakers, Action Items, Outlines, Notes and Summary"
);
TranscriptionConfig transcriptionConfig = new TranscriptionConfig(
    webhookUrl,
    summaryConfig
);

meeting.startTranscription(transcriptionConfig);
```

</TabItem>

</Tabs>

---

### stopTranscription()

- `stopTranscription()` It is used to stop realtime transcription.

#### Returns

- _`void`_

#### Events associated with `startTranscription()`:

- Every participant will receive a callback on [`onTranscriptionStateChanged()`](./meeting-event-listener-class#ontranscriptionstatechanged)

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
meeting!!.stopTranscription()
```

</TabItem>

<TabItem value="Java">

```javascript
meeting.stopTranscription();
```

</TabItem>

</Tabs>

---

### startWhiteboard()

- It is used to initilize a whiteboard session.

#### Returns

- _`void`_

---

### stopWhiteboard()

- It is used to end a whiteboard session.

#### Returns

- _`void`_

---

### changeMode()

- It is used to change the mode.
- You can toggle between the following modes:

  - **`SEND_AND_RECV`**: Both audio and video streams will be produced and consumed.

  - **`SIGNALLING_ONLY`**: Audio and video streams will not be produced or consumed. It is used solely for signaling.

  - **`RECV_ONLY`**: Only audio and video streams will be consumed without producing any.

import CautionMessage from '@site/src/theme/CautionMessage';

<CautionMessage sdk="Android SDK" version="v0.2.0" />

#### Parameters

- **mode**: `String`
- **mode**: `String`

#### Returns

- _`void`_

#### Events associated with `changeMode()`:

- Every participant will receive a callback on [`onParticipantModeChanged()`](./meeting-event-listener-class#onparticipantmodechanged)

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
meeting!!.changeMode("SIGNALLING_ONLY")
meeting!!.changeMode("SIGNALLING_ONLY")
```

</TabItem>

<TabItem value="Java">

```javascript
meeting!!.changeMode("SIGNALLING_ONLY")
meeting!!.changeMode("SIGNALLING_ONLY")
```

</TabItem>

</Tabs>

---

### getMics()

- It will return all connected mic devices.

#### Returns

- `Set<AppRTCAudioManager.AudioDevice>`

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
val mics = meeting!!.mics
var mic: String
for (i in mics.indices) {
  mic = mics.toTypedArray()[i].toString()
  Toast.makeText(this, "Mic : $mic", Toast.LENGTH_SHORT).show()
}
```

</TabItem>

<TabItem value="Java">

```javascript
Set<AppRTCAudioManager.AudioDevice> mics = meeting.getMics();
String mic;
for (int i = 0; i < mics.size(); i++) {
    mic=mics.toArray()[i].toString();
    Toast.makeText(this, "Mic : " + mic, Toast.LENGTH_SHORT).show();
}
```

</TabItem>

</Tabs>

---

### changeMic()

- It is used to change the mic device.
- If multiple mic devices are connected, by using `changeMic()` one can change the mic device.

#### Parameters

- **device**: AppRTCAudioManager.AudioDevice

#### Returns

- _`void`_

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
meeting!!.changeMic(AppRTCAudioManager.AudioDevice.BLUETOOTH)
```

</TabItem>

<TabItem value="Java">

```javascript
meeting.changeMic(AppRTCAudioManager.AudioDevice.BLUETOOTH);
```

</TabItem>

</Tabs>

---

### changeWebcam()

- It is used to change the camera device.
- If multiple camera devices are connected, by using `changeWebcam()`, one can change the camera device with its respective device id.
- You can get a list of connected video devices using [`VideoSDK.getVideoDevices()`](../videosdk-class/methods#getvideodevices)

#### Parameters

- **deviceId**:

  - The `deviceId` represents the unique identifier of the camera device you wish to switch to. If no deviceId is provided, the facing mode will toggle, from the back camera to the front camera if the back camera is currently in use, or from the front camera to the back camera if the front camera is currently in use.

    - type : String
    - `OPTIONAL`

#### Returns

- _`void`_

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
meeting!!.changeWebcam()
```

</TabItem>

<TabItem value="Java">

```javascript
meeting.changeWebcam();
```

</TabItem>

</Tabs>

---

### setAudioDeviceChangeListener()

- When a Local participant changes the Mic, `AppRTCAudioManager.AudioManagerEvents()` is triggered which can be set by using `setAudioDeviceChangeListener()` method.

#### Parameters

- **audioManagerEvents**: AppRTCAudioManager.AudioManagerEvents

#### Returns

- _`void`_

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
    meeting!!.setAudioDeviceChangeListener(object : AudioManagerEvents {
      override fun onAudioDeviceChanged(
        selectedAudioDevice: AppRTCAudioManager.AudioDevice,
        availableAudioDevices: Set<AppRTCAudioManager.AudioDevice>
      ) {
          when (selectedAudioDevice) {
            AppRTCAudioManager.AudioDevice.BLUETOOTH ->
              Toast.makeText(this@MainActivity, "Selected AudioDevice: BLUETOOTH", Toast.LENGTH_SHORT).show()

            AppRTCAudioManager.AudioDevice.WIRED_HEADSET ->
              Toast.makeText(this@MainActivity, "Selected AudioDevice: WIRED_HEADSET", Toast.LENGTH_SHORT).show()

            AppRTCAudioManager.AudioDevice.SPEAKER_PHONE ->
              Toast.makeText(this@MainActivity, "Selected AudioDevice: SPEAKER_PHONE", Toast.LENGTH_SHORT).show()

            AppRTCAudioManager.AudioDevice.EARPIECE ->
              Toast.makeText(this@MainActivity, "Selected AudioDevice: EARPIECE", Toast.LENGTH_SHORT).show()
          }
        }
    })
```

</TabItem>

<TabItem value="Java">

```javascript
    meeting.setAudioDeviceChangeListener(new AppRTCAudioManager.AudioManagerEvents() {
         @Override
        public void onAudioDeviceChanged(AppRTCAudioManager.AudioDevice selectedAudioDevice, Set<AppRTCAudioManager.AudioDevice> availableAudioDevices) {
            switch (selectedAudioDevice) {
                case BLUETOOTH:
                  Toast.makeText(MainActivity.this, "Selected AudioDevice: BLUETOOTH", Toast.LENGTH_SHORT).show();
                  break;
                case WIRED_HEADSET:
                  Toast.makeText(MainActivity.this, "Selected AudioDevice: WIRED_HEADSET", Toast.LENGTH_SHORT).show();
                  break;
                case SPEAKER_PHONE:
                  Toast.makeText(MainActivity.this, "Selected AudioDevice: SPEAKER_PHONE", Toast.LENGTH_SHORT).show();
                  break;
                case EARPIECE:
                  Toast.makeText(MainActivity.this, "Selected AudioDevice: EARPIECE", Toast.LENGTH_SHORT).show();
                  break;
               }
        }
    });
```

</TabItem>

</Tabs>

---

### addEventListener()

#### Parameters

- **listener**: MeetingEventListener

#### Returns

- _`void`_

---

### removeEventListener()

#### Parameters

- **listener**: MeetingEventListener

#### Returns

- _`void`_

---

### removeAllListeners()

#### Returns

- _`void`_
</div>


---

---
sidebar_position: 1
sidebar_label: Properties
pagination_label: Meeting Class Properties
title: Meeting Class Properties
---

# Meeting Class Properties - Android

<div class="sdk-api-ref-only-h4">

### getmeetingId()

- type: `String`

- `getmeetingId()` will return `meetingId`, which is unique id of the meeting where the participant has joined.

---

### getLocalParticipant()

- type: [Participant](../participant-class/introduction)

- It will be the instance of [Participant](../participant-class/introduction) class for the local participant(You) who joined the meeting.

---

### getParticipants()

- type: [`Map`](https://developer.android.com/reference/java/util/Map) of [Participant](../participant-class/introduction)

- `Map<String, Participant>`

  - Map{'<'}`participantId`, [Participant](../participant-class/introduction)>

- It will contain all joined participants in the meeting except the `localParticipant`.

- This will be the [`Map`](https://developer.android.com/reference/java/util/Map) what will container all participants attached with the key as id of that participant.

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
val remoteParticipantId = "ajf897"

val participant = meeting!!.participants[remoteParticipantId]
```

</TabItem>

<TabItem value="Java">

```javascript
String remoteParticipantId = "ajf897";

Participant participant = meeting.getParticipants().get(remoteParticipantId);
```

</TabItem>

</Tabs>

---

### pubSub

- type: [`PubSub`](../pubsub-class/introduction)
- It is used to enable Publisher-Subscriber feature in [`meeting`](introduction) class.

Learn more about `PubSub`, [here](../pubsub-class/introduction)

</div>


---

---
title: Meeting class for android SDK.
hide_title: false
hide_table_of_contents: false
description: RTC Meeting Class provides features to implement custom meeting layout in your application.
sidebar_label: Meeting Class
pagination_label: Meeting Class
keywords:
  - RTC Android
  - Meeting Class
  - Video API
  - Video Conferencing
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: meeting-class
---

import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>

# Meeting Class

## using Meeting Class

The `Meeting Class` includes methods and events for managing meetings, participants, video & audio streams, data channels and UI customization.

import MethodListGroup from '@theme/MethodListGroup';
import MethodListItemLabel from '@theme/MethodListItemLabel';
import MethodListHeading from '@theme/MethodListHeading';

## Constructor

### Meeting(String meetingId, Participant localParticipant)

- return type : `void`

## Properties

### getmeetingId()

- `getmeetingId()` will return `meetingId`, which represents the meetingId for the current meeting
- return type : `void`

### getLocalParticipant()

- `getLocalParticipant()` will return Local participant
- return type :`Participant`

### getParticipants()

- `getParticipants()` will return all Remote participant
- return type : `void`

### pubSub()

- `pubSub()` will return object of `PubSub` class
- return type : `PubSub`

### Events

<MethodListGroup>
  <MethodListItemLabel name="__events" >
    <MethodListGroup>
      <MethodListHeading heading="Events" />
      <MethodListItemLabel name="addEventListener(MeetingEventListener listener)"  type={"void"} />
      <MethodListItemLabel name="removeEventListener(MeetingEventListener listener)"  type={"void"} />
      <MethodListItemLabel name="removeAllListeners()"  type={"void"} />
    </MethodListGroup>
  </MethodListItemLabel>
</MethodListGroup>

### Methods

<MethodListGroup>
  <MethodListItemLabel name="__methods" >
    <MethodListGroup>
      <MethodListHeading heading="Methods" />
      <MethodListItemLabel description={"join the meeting"} name="join()"  type={"void"} />
      <MethodListItemLabel description={"leave the meeting"} name="leave()"  type={"void"} />
      <MethodListItemLabel description={"end the meeting"} name="end()"  type={"void"} />
      <MethodListItemLabel description={"enable self mic"} name="muteMic()"  type={"void"} />
      <MethodListItemLabel description={"disable self mic"} name="unmuteMic()"  type={"void"} />
      <MethodListItemLabel description={"enable self webcam"} name="enableWebcam()"  type={"void"} />
      <MethodListItemLabel description={"disable self webcam"} name="disableWebcam()"  type={"void"} />
      <MethodListItemLabel description={"start meeting recording"} name="startRecording(String webhookUrl)"  type={"void"} />
      <MethodListItemLabel description={"stop meeting recording"} name="stopRecording()"  type={"void"} />
      <MethodListItemLabel description={"start meeting live streaming"} name="startLivestream(List<LivestreamOutput> outputs)"  type={"void"} />
      <MethodListItemLabel description={"stop meeting live streaming"} name="stopLivestream()"  type={"void"} />
      <MethodListItemLabel description={"get all mic devices"} name="getMics()"  type={"Set<AppRTCAudioManager.AudioDevice>"} />
      <MethodListItemLabel description={"change self mic"} name="changeMic()"  type={"void"} />
      <MethodListItemLabel description={"When a Local participant changes the Mic, `AppRTCAudioManager.AudioManagerEvents()` is triggered which can be set by using this method"} name="setAudioDeviceChangeListener(AppRTCAudioManager.AudioManagerEvents audioManagerEvents)"  type={"void"} />
      <MethodListItemLabel description={"change self webcam"} name="changeWebcam()"  type={"void"} />
      <MethodListItemLabel description={"start sharing phone screen"} name="enableScreenShare(Intent data)"  type={"void"} />
      <MethodListItemLabel description={"stop sharing phone screen"} name="disableScreenShare()"  type={"void"} />
    </MethodListGroup>
  </MethodListItemLabel>
</MethodListGroup>


---

---
title: MeetingEventListener Class for android SDK.
hide_title: false
hide_table_of_contents: false
description: The `MeetingEventListener Class` includes list of events which can be useful for the design custom user interface.
sidebar_label: MeetingEventListener Class
pagination_label: MeetingEventListener Class
keywords:
  - RTC Android
  - MeetingEventListener Class
  - Video API
  - Video Conferencing
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: meeting-event-listener-class
---

import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>

# MeetingEventListener Class

## using MeetingEventListener Class

The `MeetingEventListener Class` is responsible for listening to all the events that are related to `Meeting Class`.

import MethodListGroup from '@theme/MethodListGroup';
import MethodListItemLabel from '@theme/MethodListItemLabel';
import MethodListHeading from '@theme/MethodListHeading';

### Listeners

<MethodListGroup>
  <MethodListItemLabel name="__listeners" >
    <MethodListGroup>
      <MethodListHeading heading="Listeners" />
      <MethodListItemLabel description={"emitted when local participant joined the meeting successfully"} name="onMeetingJoined()"  type={"void"} />
      <MethodListItemLabel description={"emitted when local participant left the meeting"} name="onMeetingLeft()"  type={"void"} />
      <MethodListItemLabel description={"emitted when new participant joined the meeting"} name="onParticipantJoined(Participant participant)"  
      type={"void"} />
      <MethodListItemLabel description={"emitted when any participant left the meeting"} name="onParticipantLeft(Participant participant)"  type={"void"} />
      <MethodListItemLabel description={"emitted when remote participant requested for entry in the meeting"} name="onEntryRequested(String id, String name)"  type={"void"} />
      <MethodListItemLabel description={"emitted when meeting host responded to participant's joining request"} 
      name="onEntryResponded(String id, String decision)"  type={"void"} />
      <MethodListItemLabel description={"emitted when any participant shared the screen"} name="onPresenterChanged(String participantId)"  type={"void"} />
      <MethodListItemLabel description={"emitted when active speaker is changed"} name="onSpeakerChanged(String participantId)"  type={"void"} />
      <MethodListItemLabel description={"emitted when the meeting's recording status changed"} name="onRecordingStateChanged(String recordingState)"  type={"void"} />
      <MethodListItemLabel description={"emitted when recording of the meeting is started successfully"} name="onRecordingStarted()"  type={"void"} />
      <MethodListItemLabel description={"emitted when recording of the meeting is stopped"} name="onRecordingStopped()"  type={"void"} />
      <MethodListItemLabel description={"emitted when the meeting's livestream status changed"} name="onLivestreamStateChanged(String livestreamState)"  type={"void"} />
      <MethodListItemLabel description={"emitted when live streaming of the meeting in social media is started successfully"} name="onLivestreamStarted()"  type={"void"} />
      <MethodListItemLabel description={"emitted when live streaming of the meeting is stopped"} name="onLivestreamStopped()"  type={"void"} />
      <MethodListItemLabel description={"emitted when remote participant asked you to toggle the Mic"} name="onMicRequested(String participantId, MicRequestListener listener)"  type={"void"} />
      <MethodListItemLabel description={"emitted when remote participant asked you to toggle the Webcam"} name="onWebcamRequested(String participantId, WebcamRequestListener listener)"  type={"void"} />
      <MethodListItemLabel description={"emitted when local participant answer/dial the phone call"} name="onExternalCallStarted()"  type={"void"} />
    </MethodListGroup>
  </MethodListItemLabel>
</MethodListGroup>


---

---
title: Video SDK Participant Class
sidebar_position: 1
sidebar_label: Introduction
pagination_label: Video SDK Participant Class
---

# Video SDK Participant Class - Android

<div class="sdk-api-ref">

import properties from './../data/participant-class/properties.json'
import methods from './../data/participant-class/methods.json'
import events from './../data/participant-class/events.json'
import LinksGrid from '../../../../src/theme/LinksGrid'

Participant class includes all the properties, methods and events related to all the participants joined in a particular meeting.

## Get local and remote participants

You can get the local streams and participant meta from `meeting.getLocalParticipant()`. And a Map of joined participants is always available via `meeting.getParticipants()`

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js title="Javascript"
val localParticipant = meeting!!.getLocalParticipant()
val participants = meeting!!.getParticipants()
```

</TabItem>

<TabItem value="Java">

```js title="Javascript"
Participant localParticipant = meeting.getLocalParticipant();
Map<String, Participant> participants = meeting.getParticipants();
```

</TabItem>

</Tabs>

## Participant Properties

<div class="row">

<div class="col col--4 margin-bottom--sm" >

- [getId()](./properties#getid)

</div>
<div class="col col--4 margin-bottom--sm" >

- [getDisplayName()](./properties#getdisplayname)

</div>
<div class="col col--4 margin-bottom--sm" >

- [getQuality()](./properties#getquality)

</div>

<div class="col col--4 margin-bottom--sm" >

- [isLocal()](./properties#islocal)

</div>

<div class="col col--4 margin-bottom--sm" >

- [getStreams()](./properties#getstreams)

</div>

<div class="col col--4 margin-bottom--sm" >

- [getMode()](./properties#getmode)

</div>

<div class="col col--4 margin-bottom--sm" >

- [getMetaData()](./properties#getmetadata)

</div>

</div>

## Participant Methods

<div class="row">

<div class="col col--4 margin-bottom--sm" >

- [enableWebcam()](./methods#enablewebcam)

</div>
<div class="col col--4 margin-bottom--sm" >

- [disableWebcam()](./methods#disablewebcam)

</div>
<div class="col col--4 margin-bottom--sm" >

- [enableMic()](./methods#enablemic)

</div>
<div class="col col--4 margin-bottom--sm" >

- [disableMic()](./methods#disablemic)

</div>
<div class="col col--4 margin-bottom--sm" >

- [remove()](./methods#remove)

</div>
<div class="col col--4 margin-bottom--sm" >

- [setQuality()](./methods#setquality)

</div>
<div class="col col--4 margin-bottom--sm" >

- [setViewPort()](./methods#setviewport)

</div>
<div class="col col--4 margin-bottom--sm" >

- [captureImage()](./methods#captureimage)

</div>

</div>

## Participant Events

<div class="row">

<div class="col col--4 margin-bottom--sm" >

- [onStreamEnabled](./participant-event-listener-class#onstreamenabled)

</div>
<div class="col col--4 margin-bottom--sm" >

- [onStreamDisabled](./participant-event-listener-class#onstreamdisabled)

</div>

</div>

</div>


---

---
title: Participant Class Methods
sidebar_position: 1
sidebar_label: Methods
pagination_label: Participant Class Methods
---

# Participant Class Methods - Android

<div class="sdk-api-ref-only-h4">

### enableWebcam()

- `enableWebcam()` is used to enable participant's camera.

#### Events associated with `enableWebcam()` :

- First the participant will get a callback on [onWebcamRequested()](../meeting-class/meeting-event-listener-class#onwebcamrequested) and once the participant accepts the request, webcam will be enabled.

- Every Participant will receive a `streamEnabled` event of `ParticipantEventListener` Class with `stream` object.

#### Returns

- `void`

---

### disableWebcam()

- `disableWebcam()` is used to disable participant camera.

#### Events associated with `disableWebcam()` :

- Every Participant will receive a `streamDisabled` event of `ParticipantEventListener` Class with `stream` object.

#### Returns

- `void`

---

### enableMic()

- `enableMic()` is used to enable participant microphone.

#### Events associated with `enableMic()` :

- First the participant will get a callback on [onMicRequested()](../meeting-class/meeting-event-listener-class#onmicrequested) and once the participant accepts the request, mic will be enabled.

- Every Participant will receive a `streamEnabled` event of `ParticipantEventListener` Class with `stream` object.

#### Returns

- `void`

---

### disableMic()

- `disableMic()` is used to disable participant microphone.

#### Events associated with `disableMic()`:

- Every Participant will receive a `streamDisabled` event of `ParticipantEventListener` Class with `stream` object.

#### Returns

- `void`

---

### pin()

- It is used to set pin state of the participant. You can use it to pin the screen share, camera or both of the participant. It accepts a paramter of type `String`. Default `SHARE_AND_CAM`

#### Parameters

- **pinType**: `SHARE_AND_CAM` | `CAM` | `SHARE`

---

### unpin()

- It is used to unpin participant. You can use it to unpin the screen share, camera or both of the participant. It accepts a paramter of type `String`. Default is `SHARE_AND_CAM`

#### Parameters

- **pinType**: `SHARE_AND_CAM` | `CAM` | `SHARE`

---

### remove()

- It is used to remove a participant from the meeting

---

### setQuality()

- `setQuality()` is used to set the quality of the participant's video stream.

#### Parameters

- `quality`: low | med | high

#### Returns

- `void`

---

### setViewPort()

- `setViewPort()` is used to set the quality of the participant's video stream based on the viewport height and width.

#### Parameters

- **width**: int
- **height**: int

#### Returns

- `void`

---

:::info

MultiStream is not supported by the Android SDK. Use `customTrack` rather than `setQuality()` and `setViewPort()` if you want to change participant's quality who joined using our Android SDK.

To know more about customTrack visit [here](/android/guide/video-and-audio-calling-api-sdk/features/custom-track/custom-video-track)

:::

### remove()

- `remove()` is used to remove the participant from the meeting.

#### Events associated with `remove()` :

- Local participant will receive a [`onMeetingLeft`](../meeting-class/meeting-event-listener-class.md#onmeetingleft) event.
- All remote participants will receive a [`onParticipantLeft`](../meeting-class/meeting-event-listener-class.md#onparticipantleft) event with `participantId`.

#### Returns

- `void`

---

### captureImage()

- It is used to capture image of local participant's current videoStream.

- You need to pass an implementation of `TaskCompletionListener` as a parameter. This listener will handle the result of the image capture task.

- When the image capture task is complete, the `onComplete()` method will provide the image in the form of a `base64` string. If an error occurs, the `onError()` method will provide the error details.

#### Parameters

- **height**: int
- **width**: int
- **listener**: TaskCompletionListener

#### Returns

- _`void`_

---

### getVideoStats()

- `getVideoStats()` will return an JSONObject which will contain details regarding the participant's critical video metrics such as **Jitter**, **Packet Loss**, **Quality Score** etc.

#### Returns

- `JSONObject`
  - `jitter` : It represents the distortion in the stream.
  - `bitrate` : It represents the bitrate of the stream which is being transmitted.
  - `totalPackets` : It represents the total packet count which were transmitted for that particiular stream.
  - `packetsLost` : It represents the total packets lost during the transimission of the stream.
  - `rtt` : It represents the time between the stream being reached to client from the server in milliseconds(ms).
  - `codec`: It represents the codec used for the stream.
  - `network`: It represents the network used to transmit the stream
  - `size`: It is object containing the height, width and frame rate of the stream.

:::note

getVideoStats() will return the metrics for the participant at that given point of time and not average data of the complete meeting.

To view the metrics for the complete meeting using the stats API documented [here](/api-reference/realtime-communication/fetch-session-quality-stats).

:::

:::info

If you are getting `rtt` greater than 300ms, try using a different region which is nearest to your user. To know more about changing region [visit here](/api-reference/realtime-communication/create-room).

If you are getting high packet loss, try using the `customTrack` for better experience. To know more about customTrack [visit here](/android/guide/video-and-audio-calling-api-sdk/features/custom-track/custom-video-track)

:::

---

### getAudioStats()

- `getAudioStats()` will return an JSONObject which will contain details regarding the participant's critical audio metrics such as **Jitter**, **Packet Loss**, **Quality Score** etc.

#### Returns

- `JSONObject`
  - `jitter` : It represents the distortion in the stream.
  - `bitrate` : It represents the bitrate of the stream which is being transmitted.
  - `totalPackets` : It represents the total packet count which were transmitted for that particiular stream.
  - `packetsLost` : It represents the total packets lost during the transimission of the stream.
  - `rtt` : It represents the time between the stream being reached to client from the server in milliseconds(ms).
  - `codec`: It represents the codec used for the stream.
  - `network`: It represents the network used to transmit the stream

:::note

getAudioStats() will return the metrics for the participant at that given point of time and not average data of the complete meeting.

To view the metrics for the complete meeting using the stats API documented [here](/api-reference/realtime-communication/fetch-session-quality-stats).

:::

:::info

If you are getting `rtt` greater than 300ms, try using a different region which is nearest to your user. To know more about changing region [visit here](/api-reference/realtime-communication/create-room).

:::

### getShareStats()

- `getShareStats()` will return an JSONObject which will contain details regarding the participant's critical video metrics such as **Jitter**, **Packet Loss**, **Quality Score** etc.

#### Returns

- `JSONObject`
  - `jitter` : It represents the distortion in the stream.
  - `bitrate` : It represents the bitrate of the stream which is being transmitted.
  - `totalPackets` : It represents the total packet count which were transmitted for that particiular stream.
  - `packetsLost` : It represents the total packets lost during the transimission of the stream.
  - `rtt` : It represents the time between the stream being reached to client from the server in milliseconds(ms).
  - `codec`: It represents the codec used for the stream.
  - `network`: It represents the network used to transmit the stream
  - `size`: It is object containing the height, width and frame rate of the stream.

:::note

getShareStats() will return the metrics for the participant at that given point of time and not average data of the complete meeting.

To view the metrics for the complete meeting using the stats API documented [here](/api-reference/realtime-communication/fetch-session-quality-stats).

:::

:::info

If you are getting `rtt` greater than 300ms, try using a different region which is nearest to your user. To know more about changing region [visit here](/api-reference/realtime-communication/create-room).

:::

### addEventListener()

#### Parameters

- **listener**: ParticipantEventListener

#### Returns

- _`void`_

---

### removeEventListener()

#### Parameters

- **listener**: ParticipantEventListener

#### Returns

- _`void`_

---

### removeAllListeners()

#### Returns

- _`void`_

</div>


---

---
title: ParticipantEventListener Class
sidebar_position: 1
sidebar_label: ParticipantEventListener
pagination_label: ParticipantEventListener Class
---

# ParticipantEventListener Class - Android

<div class="sdk-api-ref-only-h4">

### Implementation

- You can implement all the methods of `ParticipantEventListener` abstract Class and add the listener to `Participant` class using the `addEventListener()` method of `Participant` Class.

---

### onStreamEnabled()

- `onStreamEnabled()` is a callback which gets triggered whenever a participant's video, audio or screen share stream is enabled.

#### Event callback parameters

- **stream**: [Stream](../stream-class/introduction.md)

---

### onStreamDisabled()

- `onStreamDisabled()` is a callback which gets triggered whenever a participant's video, audio or screen share stream is disabled.

#### Event callback parameters

- **stream**: [Stream](../stream-class/introduction.md)

---

### Example

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
  meeting!!.localParticipant.addEventListener(object : ParticipantEventListener() {
    override fun onStreamEnabled(stream: Stream) {
        //
    }

    override fun onStreamDisabled(stream: Stream) {
        //
    }
  });
```

</TabItem>

<TabItem value="Java">

```js
  participant.addEventListener(new ParticipantEventListener() {
    @Override
    public void onStreamEnabled(Stream stream) {
        //
    }

    @Override
    public void onStreamDisabled(Stream stream) {
        //
    }
  });
```

</TabItem>

</Tabs>

</div>


---

---
title: Participant Class Properties
sidebar_position: 1
sidebar_label: Properties
pagination_label: Participant Class Properties
---

# Participant Class Properties - Android

<div class="sdk-api-ref-only-h4">

### getId()

- type: `String`

- `getId` will return unique id of the participant who has joined the meeting.

---

### getDisplayName()

- type: `String`

- It will return the `displayName` of the participant who has joined the meeting.

---

### getQuality()

- type: `String`

- `getQuality()` will return quality of participant's stream. Stream could be `audio` , `video` or `share`.

---

### isLocal()

- type: `boolean`

- `isLocal()` will return `true` if participant is Local,`false` otherwise.

---

### getStreams()

- type: `Map<String,name>`

- It will represents the stream for that particular participant who has joined the meeting. Streams could be `audio` , `video` or `share`.

---

### getMode()

- type : `string`

- ` getMode()` will return mode of the Participant.

---

### getMetaData()

- type : `JSONObject`

- `getMetaData()` will return additional information, that you have passed in `initMeeting()`.

</div>


---

---
title: Participant class for android SDK.
hide_title: false
hide_table_of_contents: false
description: The `Participant Class` includes methods and events for participants and their associated video & audio streams, data channels and UI customization.
sidebar_label: Participant Class
pagination_label: Participant Class
keywords:
  - RTC Android
  - Participant Class
  - Video API
  - Video Conferencing
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: participant-class
---

import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>

# Participant Class

## Introduction

The `Participant Class` includes methods and events for participants and their associated video & audio streams, data channels and UI customization.

import MethodListGroup from '@theme/MethodListGroup';
import MethodListItemLabel from '@theme/MethodListItemLabel';
import MethodListHeading from '@theme/MethodListHeading';

## Properties

### getId()

- `getId()` will return participant's Id
- return type : `String`

### getDisplayName()

- `getDisplayName()` will return name of participant
- return type : `String`

### getQuality()

- `getQuality()` will return quality of participant's video stream
- return type : `String`

### isLocal()

- `isLocal()` will return `true` if participant is Local,`false` otherwise
- return type : `boolean`

### getStreams()

- `getStreams()` will return streams of participant
- return type : `Map<String, Stream>`
- Map contains `streamId` as key and `stream` as value

## Events

### addEventListener(ParticipantEventListener listener)

- By using `addEventListener(ParticipantEventListener listener)`, we can add listener to the List of `ParticipantEventListener`
- return type : `void`

### removeEventListener(ParticipantEventListener listener)

- By using `removeEventListener(ParticipantEventListener listener)`, we can remove listener from List of `ParticipantEventListener`
- return type : `void`

### removeAllListeners()

- By using `removeAllListeners()`, we can remove all listener from List
- return type : `void`

## Methods

### enableMic()

- By using `enableMic()` function, a participant can enable the Mic of any particular Remote Participant
- When `enableMic()` is called,
  - Local Participant will receive a callback on `streamEnabled()` of `ParticipantEventListener` class
  - Remote Participant will receive a callback for `onMicRequested()` and once the remote participant accepts the request, mic will be enabled for that participant
- return type : `void`

### disableMic()

- By using `disableMic()` function, a participant can disable the Mic of any particular Remote Participant
- When `enableMic()` is called,
  - Local Participant will receive a callback on `streamDisabled()` of `ParticipantEventListener` class
  - Remote Participant will receive a callback on `streamDisabled()` of `ParticipantEventListener` class
- return type : `void`

### enableWebcam()

- By using `enableWebcam()` function, a participant can enable the Webcam of any particular Remote Participant
- When `enableWebcam()` is called,
  - Local Participant will receive a callback on `streamEnabled()` of `ParticipantEventListener` class
  - Remote Participant will receive a callback for `webcamRequested()` and once the remote participant accepts the request, webcam will be enabled for that participant
- return type : `void`

### disableWebcam()

- By using `disableWebcam()` function, a participant can disable the Webcam of any particular Remote Participant
- When `disableWebcam()` is called,
  - Local Participant will receive a callback on `streamDisabled()` of `ParticipantEventListener` class
  - Remote Participant will receive a callback on `streamDisabled()` of `ParticipantEventListener` class
- return type : `void`

### remove()

- By using `remove()` function, a participant can remove any particular Remote Participant
- When `remove()` is called,
  - Local Participant will receive a callback on `meetingLeft()`
  - Remote Participant will receive a callback on `participantLeft()`
- return type : `void`

### setQuality()

- By using `setQuality()`,you can set quality of participant's video stream
- return type : `void`


---

---
title: ParticipantEventListener Class for android SDK.
hide_title: false
hide_table_of_contents: false
description: The `ParticipantEventListener Class` includes list of events which can be useful for the design custom user interface.
sidebar_label: ParticipantEventListener Class
pagination_label: ParticipantEventListener Class
keywords:
  - RTC Android
  - ParticipantEventListener Class
  - Video API
  - Video Conferencing
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: participant-event-listener-class
---

# ParticipantEventListener Class

## using ParticipantEventListener Class

The `ParticipantEventListener Class` is responsible for listening to all the events that are related to `Participant Class`.

import MethodListGroup from '@theme/MethodListGroup';
import MethodListItemLabel from '@theme/MethodListItemLabel';
import MethodListHeading from '@theme/MethodListHeading';

### Listeners

<MethodListGroup>
  <MethodListItemLabel name="__listeners" >
    <MethodListGroup>
      <MethodListHeading heading="Listeners" />
      <MethodListItemLabel name="onStreamEnabled(Stream stream)"  type={"void"} />
      <MethodListItemLabel name="onStreamDisabled(Stream stream)"  type={"void"} />
    </MethodListGroup>
  </MethodListItemLabel>
</MethodListGroup>


---

---
title: Video SDK PubSub Class
sidebar_position: 1
sidebar_label: Introduction
pagination_label: Video SDK PubSub Class
---

# Video SDK PubSub Class - Android

<div class="sdk-api-ref">

## Introduction

PubSub class provides the methods to implement Publisher-Subscriber feature in your Application.

## PubSub Methods

<div class="row">

<div  class="col col--4 margin-bottom--sm" >

- [publish()](methods#publish)

</div>

<div  class="col col--4 margin-bottom--sm" >

- [subscribe()](methods#subscribe)

</div>

<div  class="col col--4 margin-bottom--sm" >

- [unsubscribe()](methods#unsubscribe)

</div>
</div>
</div>


---

---
sidebar_position: 1
sidebar_label: Methods
pagination_label: PubSub Class Methods
title: PubSub Class Methods
---

# PubSub Class Methods - Android

<div class="sdk-api-ref-only-h4">

### publish()

- `publish()` is used to publish messages on a specified topic in the meeting.

#### Parameters

- topic

  - type: `String`
  - This is the name of the topic, for which message will be published.

- message

  - type: `String`
  - This is the actual message.

- options
  - type: [`PubSubPublishOptions`](pubsub-publish-options-class)
  - This specifies the options for publish.

- payload

  - type: `JSONObject`
  - `OPTIONAL`
  - If you need to include additional information along with a message, you can pass here as `JSONObject`. 

#### Returns

- _`void`_

#### Example

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
// Publish message for 'CHAT' topic
val publishOptions = PubSubPublishOptions()
publishOptions.isPersist = true

meeting!!.pubSub.publish("CHAT", "Hello from Android", publishOptions)
```

</TabItem>

<TabItem value="Java">

```js
// Publish message for 'CHAT' topic
PubSubPublishOptions publishOptions = new PubSubPublishOptions();
publishOptions.setPersist(true);

meeting.pubSub.publish("CHAT", "Hello from Android", publishOptions);
```

</TabItem>

</Tabs>

---

### subscribe()

- `subscribe()` is used to subscribe a particular topic to get all the messages of that particular topic in the meeting.

#### Parameters

- topic:

  - type: `String`
  - Participants can listen to messages on that particular topic.

- listener:

  - type: [`PubSubMessageListener`](pubsub-message-listener-class)

#### Returns

- [_`List<PubSubMessage>`_](pubsub-message-class)

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
var pubSubMessageListener: ubSubMessageListener =
  PubSubMessageListener { message ->
    Log.d("#message","onMessageReceived: " + message.message)
  }

  // Subscribe for 'CHAT' topic
  val pubSubMessageList = meeting!!.pubSub.subscribe("CHAT", pubSubMessageListener)
```

</TabItem>

<TabItem value="Java">

```js
PubSubMessageListener pubSubMessageListener = new PubSubMessageListener() {
    @Override
    public void onMessageReceived(PubSubMessage message) {
        Log.d("#message", "onMessageReceived: " + message.getMessage());
    }
};

 // Subscribe for 'CHAT' topic
 List<PubSubMessage> pubSubMessageList = meeting.pubSub.subscribe("CHAT", pubSubMessageListener);
```

</TabItem>

</Tabs>

---

### unsubscribe()

- `unsubscribe()` is used to unsubscribe a particular topic on which you have subscribed priviously.

#### Parameters

- topic:

  - type: `String`
  - This is the name of the topic to be unsubscribed.

- listener:

  - type: [`PubSubMessageListener`](pubsub-message-listener-class)

#### Returns

- _`void`_

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
// Unsubscribe for 'CHAT' topic
meeting!!.pubSub.unsubscribe("CHAT", pubSubMessageListener)
```

</TabItem>

<TabItem value="Java">

```js
// Unsubscribe for 'CHAT' topic
meeting.pubSub.unsubscribe("CHAT", pubSubMessageListener);
```

</TabItem>

</Tabs>

</div>


---

---
sidebar_position: 1
sidebar_label: Properties
pagination_label: Properties
title: Properties
---

# Properties - Android

<div class="sdk-api-ref-only-h4">

### getId()

- type: `String`

- `getId()` will return unique id of the pubsub message.

---

### getMessage()

- type: `String`

- `getMessage()` will return message that has been published on the specific topic.

---

### getTopic()

- type: `String`

- `getTopic()` will return name of the message topic.

---

### getSenderId()

- type: `String`

- `getSenderId()` will return id of the participant, who has sent the message.

---

### getSenderName()

- type: `String`

- `getSenderName()` will return name of the participant, who has sent the pubsub message.

---

### getTimestamp()

- type: `long`

- `getTimestamp()` will return timestamp at which, the pubsub message was sent.

---

### getPayload()

- type: `JSONObject`

- `getPayload()` will return data that you have send with message.

</div>


---

---
sidebar_position: 1
sidebar_label: PubSubMessageListener Class
pagination_label: PubSubMessageListener Class
title: PubSubMessageListener Class
---

# PubSubMessageListener Class - Android

<div class="sdk-api-ref-only-h4">

---

#### onMessageReceived()

- This event will be emitted whenever any pubsub message received.

#### Example

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
var pubSubMessageListener = PubSubMessageListener { message ->
    Log.d("#message", "onMessageReceived: " + message.message)
}
```

</TabItem>

<TabItem value="Java">

```javascript
PubSubMessageListener pubSubMessageListener = new PubSubMessageListener() {
    @Override
    public void onMessageReceived(PubSubMessage message) {
        Log.d("#message", "onMessageReceived: " + message.getMessage());
    }
};
```

</TabItem>

</Tabs>

</div>


---

---
sidebar_position: 1
sidebar_label: PubSubPublishOptions Class
pagination_label: PubSubPublishOptions Class
title: PubSubPublishOptions Class
---

# PubSubPublishOptions Class - Android

<div class="sdk-api-ref-only-h4">


## Properties

### persist

- type: `boolean`

- defaultValue: `false`

- This property specifies whether to store messages on server for upcoming participants.

- If the value of this property is true, then server will store pubsub messages for the upcoming participants.

---

### sendOnly

- type: `String[]`

- defaultValue: `null`

- If you want to send a message to specific participants, you can pass their respective `participantId` here. If you don't provide any IDs or pass a `null` value, the message will be sent to all participants by default.

:::note
Make sure that participantId present in the array must be subscribe to that specific topic.
:::

</div>


---

---
title: PubSub class for android SDK.
hide_title: false
hide_table_of_contents: false
description: PubSub Class
sidebar_label: PubSub Class
pagination_label: PubSub Class
keywords:
  - RTC Android
  - Publisher-Subscriber
  - PubSub
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: pubsub-class
---

# PubSub Class

## using PubSub Class

The `PubSub` includes methods for pubsub.

import MethodListGroup from '@theme/MethodListGroup';
import MethodListItemLabel from '@theme/MethodListItemLabel';
import MethodListHeading from '@theme/MethodListHeading';

### Methods

<MethodListGroup>
  <MethodListItemLabel name="__methods" >
    <MethodListGroup>
      <MethodListHeading heading="Methods" />
      <MethodListItemLabel name="publish(String topic, String message, PubSubPublishOptions options)"  type={"void"} />
      <MethodListItemLabel name="subscribe(String topic, PubSubMessageListener listener)"  type={"List<PubSubMessage>"} />
      <MethodListItemLabel name="unsubscribe(String topic, PubSubMessageListener listener)"  type={"void"} />
    </MethodListGroup>
  </MethodListItemLabel>
</MethodListGroup>


---

---
title: PubSubMessage class for android SDK.
hide_title: false
hide_table_of_contents: false
description: PubSubMessage Class
sidebar_label: PubSubMessage Class
pagination_label: PubSubMessage Class
keywords:
  - RTC Android
  - Publisher-Subscriber
  - PubSub
  - PubSubMessage
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: pubsub-message-class
---

# PubSubMessage Class

## using PubSubMessage Class

The `PubSubMessage` includes properties of PubSub message.

import MethodListGroup from '@theme/MethodListGroup';
import MethodListItemLabel from '@theme/MethodListItemLabel';
import MethodListHeading from '@theme/MethodListHeading';

### Properties

<MethodListGroup>
  <MethodListItemLabel name="__properties"  >
    <MethodListGroup>
      <MethodListHeading heading="Properties" />
      <MethodListItemLabel name="id" type={"String"} />
      <MethodListItemLabel name="message" type={"String"} />
      <MethodListItemLabel name="senderId" type={"String"} />
      <MethodListItemLabel name="senderName" type={"String?"} />
      <MethodListItemLabel name="timestamp" type={"DateTime"} />
      <MethodListItemLabel name="topic" type={"String"} />
      <MethodListItemLabel name="payload" type={"JSONObject"} />
    </MethodListGroup>
  </MethodListItemLabel>
</MethodListGroup>


---

---
title: PubSubPublishOptions class for android SDK.
hide_title: false
hide_table_of_contents: false
description: PubSubPublishOptions Class
sidebar_label: PubSubPublishOptions Class
pagination_label: PubSubPublishOptions Class
keywords:
  - RTC Android
  - PubSub
  - PubSubPublishOptions
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: pubsub-publish-options-class
---

# PubSubPublishOptions Class

## using PubSubPublishOptions Class

The `PubSubPublishOptions` includes properties of PubSub options.

import MethodListGroup from '@theme/MethodListGroup';
import MethodListItemLabel from '@theme/MethodListItemLabel';
import MethodListHeading from '@theme/MethodListHeading';

### Properties

<MethodListGroup>
  <MethodListItemLabel name="__properties"  >
    <MethodListGroup>
      <MethodListHeading heading="Properties" />
      <MethodListItemLabel name="persist" type={"bool"} description={"Specifies whether to store messages on server for upcoming participants"} />
      <MethodListItemLabel name="sendOnly" type={"String[]"} description={"Sends a message to only those participants which are present in array"} />
    </MethodListGroup>
  </MethodListItemLabel>
</MethodListGroup>

### Methods

<MethodListGroup>
  <MethodListItemLabel name="__methods" >
    <MethodListGroup>
      <MethodListHeading heading="Methods" />
      <MethodListItemLabel name="toJSONObject()"  type={"JSONObject"} />
    </MethodListGroup>
  </MethodListItemLabel>
</MethodListGroup>


---

---
id: setup
title: Installation steps for RTC Android SDK
hide_title: false
hide_table_of_contents: false
description: RTC Android SDK provides client for almost all Android devices. it takes less amount of cpu and memory.
sidebar_label: Setup
pagination_label: Setup
keywords:
  - RTC Android
  - Android SDK
  - Kotlin SDK
  - Java SDK
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: setup
---

# Setup - Android

## Setting up android sdk

Android SDK is client for real-time communication for android devices. It inherits the same terminology as all other SDKs does.

## Minimum OS/SDK versions

It supports the following OS/SDK versions.

### Android: minSdkVersion >= 21

## Installation

1. If your Android Studio Version is older than Android Studio Bumblebees, add the repository to project's `build.gradle` file. <br/>
   If your are using Android Studio Bumblebees or newer Version, add the repository to `settings.gradle` file.

:::note

You can use imports with Maven Central after rtc-android-sdk version `0.1.12`.

Whether on Maven or Jitpack, the same version numbers always refer to the same SDK.

:::

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Maven Central"
groupId={"android-repositories"}
values={[{label: 'Maven Central', value: 'Maven Central'},{label: 'Jitpack', value: 'Jitpack'},]}>

<TabItem value="Maven Central">

```js title="build.gradle"
allprojects {
  repositories {
    // ...
    google()
    mavenCentral()
    maven { url "https://maven.aliyun.com/repository/jcenter" }
  }
}
```

```js title="settings.gradle"
dependencyResolutionManagement{
  repositories {
    // ...
    google()
    mavenCentral()
    maven { url "https://maven.aliyun.com/repository/jcenter" }
  }
}

```

</TabItem>

<TabItem value="Jitpack">

```js title="build.gradle"
allprojects {
  repositories {
    // ...
    google()
    maven { url 'https://jitpack.io' }
    mavenCentral()
    maven { url "https://maven.aliyun.com/repository/jcenter" }
  }
}
```

```js title="settings.gradle"
dependencyResolutionManagement{
  repositories {
    // ...
    google()
    maven { url 'https://jitpack.io' }
    mavenCentral()
    maven { url "https://maven.aliyun.com/repository/jcenter" }
  }
}

```

</TabItem>

</Tabs>

### Step 2: Add the following dependency in your app's `app/build.gradle`.

```js title="app/build.gradle"
dependencies {
  implementation 'live.videosdk:rtc-android-sdk:0.1.38'

  // library to perform Network call to generate a meeting id
  implementation 'com.amitshekhar.android:android-networking:1.0.2'

  // other app dependencies
  }
```

:::important

Android SDK compatible with armeabi-v7a, arm64-v8a, x86_64 architectures. If you want to run the application in an emulator, choose ABI x86_64 when creating a device.

:::

## Integration

### Step 1: Add the following permissions in `AndroidManifest.xml`.

```xml title="AndroidManifest.xml"
<uses-permission android:name="android.permission.RECORD_AUDIO" />
<uses-permission android:name="android.permission.MODIFY_AUDIO_SETTINGS" />
<uses-permission android:name="android.permission.INTERNET" />
<uses-permission android:name="android.permission.READ_PHONE_STATE" />
<uses-permission android:name="android.permission.CAMERA" />

<uses-permission android:name="android.permission.BLUETOOTH" />
<uses-permission android:name="android.permission.BLUETOOTH_ADMIN" />
<uses-permission android:name="android.permission.BLUETOOTH_CONNECT" />

```

### Step 2: Create `MainApplication` class which will extend the `android.app.Application`.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js title="MainApplication.kt"
package live.videosdk.demo;

import live.videosdk.android.VideoSDK

class MainApplication : Application() {
    override fun onCreate() {
        super.onCreate()
        VideoSDK.initialize(applicationContext)
    }
}
```

</TabItem>

<TabItem value="Java">

```js title="MainApplication.java"
package live.videosdk.demo;

import android.app.Application;

import live.videosdk.android.VideoSDK;

public class MainApplication extends Application {
    @Override
    public void onCreate() {
        super.onCreate();
        VideoSDK.initialize(getApplicationContext());
    }
}
```

</TabItem>

</Tabs>

### Step 3: Add `MainApplication` to `AndroidManifest.xml`.

```js title="AndroidManifest.xml"
<application
        android:name=".MainApplication"
				...
>
  <!-- ... -->
</application>
```

### Step 4: In your `JoinActivity` add the following code in `onCreate()` method.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js title="JoinActivity.kt"
override fun onCreate(savedInstanceState: Bundle?) {
  super.onCreate(savedInstanceState)
  setContentView(R.layout.activity_join)

  val meetingId = "<meeting-id>"
  val participantName = "John Doe"

  var micEnabled = true
  var webcamEnabled = true

  // generate the jwt token from your api server and add it here
  VideoSDK.config("JWT TOKEN GENERATED FROM SERVER")

  // create a new meeting instance
  meeting = VideoSDK.initMeeting(
      this@MeetingActivity, meetingId, participantName,
      micEnabled, webcamEnabled, null, null, false, null, null)

  // get permissions and join the meeting with meeting.join();
  // checkPermissionAndJoinMeeting();
}
```

</TabItem>

<TabItem value="Java">

```js title="JoinActivity.java"
@Override
protected void onCreate(Bundle savedInstanceState) {
  super.onCreate(savedInstanceState);
  setContentView(R.layout.activity_join);

  final String meetingId = "<meeting-id>";
  final String participantName = "John Doe";

  final boolean micEnabled = true;
  final boolean webcamEnabled = true;

  // generate the jwt token from your api server and add it here
  VideoSDK.config("JWT TOKEN GENERATED FROM SERVER");

  // create a new meeting instance
  Meeting meeting = VideoSDK.initMeeting(
          MainActivity.this, meetingId, participantName,
          micEnabled, webcamEnabled, null, null, false, null, null
  );

  // get permissions and join the meeting with meeting.join();
  // checkPermissionAndJoinMeeting();
}
```

</TabItem>

</Tabs>

All set! Here is the link to the complete sample code on [Github](https://github.com/videosdk-live/videosdk-rtc-android-java-sdk-example). Please refer to the [documentation](initMeeting) for a full list of available methods, events and features of the SDK.


---

---
title: Video SDK Stream Class
sidebar_position: 1
sidebar_label: Introduction
pagination_label: Video SDK Stream Class
---

# Video SDK Stream Class - Android

<div id="tailwind" class="sdk-api-ref">

import properties from './../data/stream-class/properties.json'
import methods from './../data/stream-class/methods.json'
import LinksGrid from '../../../../src/theme/LinksGrid'

Stream class is responsible for handling audio, video and screen sharing streams.

Stream class defines instance of audio, video and shared screen stream of participants.

## Stream Properties

<div class="row">

<div class="col col--4 margin-bottom--sm" >

- [getId()](./properties#getid)

</div>
<div class="col col--4 margin-bottom--sm" >

- [getKind()](./properties#getkind)

</div>
<div class="col col--4 margin-bottom--sm" >

- [getTrack()](./properties#gettrack)

</div>

</div>

## Stream Methods

<div class="row">

<div class="col col--4 margin-bottom--sm" >

- [resume()](methods#resume)

</div>
<div class="col col--4 margin-bottom--sm" >

- [pause()](./methods#pause)

</div>

</div>

</div>


---

---
title: Stream Class Methods
sidebar_position: 1
sidebar_label: Methods
pagination_label: Stream Class Methods
---

# Stream Class Methods - Android

<div class="sdk-api-ref-only-h4">

### resume()

- By using `resume()`, a participant can resume the stream of Remote Participant.

#### Returns

- `void`

---

### pause()

- By using `pause()`, a participant can pause the stream of Remote Participant.

#### Returns

- `void`

</div>


---

---
title: Stream Class Properties
sidebar_position: 1
sidebar_label: Properties
pagination_label: Stream Class Properties
---

# Stream Class Properties - Android

<div class="sdk-api-ref-only-h4">

### getId()

- type: `String`

- `getId()` will return id for that stream .

---

### getKind()

- type: `String`

- `getKind()` will return `kind`, which represents the type of stream which could be `audio` | `video` or `share` .

---

### getTrack()

- type: `MediaStreamTrack`

- `getTrack()` will return a MediaStreamTrack object stored in the MediaStream object.

</div>


---

---
title: Stream class for android SDK.
hide_title: false
hide_table_of_contents: false
description: RTC Stream Class enables opportunity to .
sidebar_label: Stream Class
pagination_label: Stream Class
keywords:
  - RTC Android
  - Stream Class
  - Video API
  - Video Conferencing
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: stream-class
---

# Stream Class

## Introduction

The `Stream Class` includes methods and events of video & audio streams.

import MethodListGroup from '@theme/MethodListGroup';
import MethodListItemLabel from '@theme/MethodListItemLabel';
import MethodListHeading from '@theme/MethodListHeading';

## Properties

### getId()

- `getId()` will return Id of stream
- return type : `String`

### getKind()

- `getKind()` will return kind of stream, which can `audio`,`video` or `share`
- return type : `String`

### getTrack()

- `getTrack()` will return a MediaStreamTrack object stored in the MediaStream object
- return type : `MediaStreamTrack`

## Methods

### pause()

- By using `pause()` function, a participant can pause the stream of Remote Participant
- return type : `void`

### resume()

- By using `resume()` function, a participant can resume the stream of Remote Participant
- return type : `void`


---

---
title: Terminology - Video SDK Documentation
hide_title: true
hide_table_of_contents: false
description: Video SDK enables the opportunity to integrate native IOS, Android & Web SDKs to add live video & audio conferencing to your applications.
sidebar_label: Terminology
pagination_label: Terminology
keywords:
  - audio calling
  - video calling
  - real-time communication
  - collaboration
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: terminology
---

import Terminology from '../../../mdx/introduction/\_terminology.mdx';

<Terminology title="Terms related to VideoSDK - Android" />


---

---
title: Video SDK Class for android SDK.
hide_title: false
hide_table_of_contents: false
description: Video SDK Class is a factory for initialize, configure and init meetings.
sidebar_label: VideoSDK Class
pagination_label: VideoSDK Class
keywords:
  - RTC Android
  - VideoSDK Class
  - Video API
  - Video Conferencing
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: videosdk-class
---

# VideoSDK Class

The entry point into real-time communication SDK.

## using VideoSDK Class

The `VideoSDK Class` includes methods and events to initialize and configure the SDK. It is a factory class.

import MethodListGroup from '@theme/MethodListGroup';
import MethodListItemLabel from '@theme/MethodListItemLabel';
import MethodListHeading from '@theme/MethodListHeading';

### Parameters

<MethodListGroup>
  <MethodListItemLabel name="__namedParameters" option={"required"} type={"object"} >
    <MethodListGroup>
      <MethodListHeading heading="Properties" />
      <MethodListItemLabel description={"set meeting id"} name="meetingId" option={"required"} type={"string"} />
      <MethodListItemLabel description={"set local participant's name"} name="name" option={"required"} type={"string"} />
      <MethodListItemLabel description={"set local participant's mic state"} name="micEnabled" option={"required"} type={"bool"} />
      <MethodListItemLabel description={"set local participant's webcam state"} name="webcamEnabled" option={"required"} type={"bool"}/>
      <MethodListItemLabel description={"set local participant's Id"} name="paricipantId" option={"required"} type={"string"}/>
    </MethodListGroup>
  </MethodListItemLabel>
</MethodListGroup>

### Methods

<MethodListGroup>
  <MethodListItemLabel name="__methods" >
    <MethodListGroup>
      <MethodListHeading heading="Methods" />
      <MethodListItemLabel description={"initialize the MediasoupClient"} name="initialize(Context context)"  type={"void"} />
      <MethodListItemLabel description={"configure the token"} name="config(String token)"  type={"void"} />
      <MethodListItemLabel description={"initialize the meeting"} 
      name="initMeeting(
        Context context, 
        String meetingId, 
        String name, 
        boolean micEnabled,
        boolean webcamEnabled,
        String participantId
      )"  type={"Meeting"} />
    </MethodListGroup>
  </MethodListItemLabel>
</MethodListGroup>

## Example

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js title="initMeeting"
// Configure the token
VideoSDK.config(token)

// Initialize the meeting
Meeting meeting = VideoSDK.initMeeting(
      context,
      meetingId, // required
      name, // required
      micEnabled, // required
      webcamEnabled, // required
      null, // required
      null, // required
      null // required
      )
});
```

</TabItem>

<TabItem value="Java">

```js title="initMeeting"
// Configure the token
VideoSDK.config(token)

// Initialize the meeting
Meeting meeting = VideoSDK.initMeeting({
  context,
  meetingId, // required
  name, // required
  micEnabled, // required
  webcamEnabled, // required
  null, // required
  null // required
  null // required
});
```

</TabItem>

</Tabs>


---

---
sidebar_position: 1
sidebar_label: Events
pagination_label: VideoSDK Class Events
title: VideoSDK Class Events
---

# VideoSDK Class Events - Android

<div class="sdk-api-ref-only-h4">


### onAudioDeviceChanged()

- This event will be emitted when an audio device, is connected to or removed from the device.

#### Example

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
VideoSDK.setAudioDeviceChangeListener(object : VideoSDK.AudioDeviceChangeEvent {
    override fun onAudioDeviceChanged(
        selectedAudioDevice: AudioDeviceInfo?,
        audioDevices: MutableSet<AudioDeviceInfo>?
    ) {
        Log.d(
            "VideoSDK",
            "Selected Audio Device: " + selectedAudioDevice.label
        )
        for (audioDevice in audioDevices) {
            Log.d("VideoSDK", "Audio Devices" + audioDevice.label)
        }
    }
})
```

</TabItem>

<TabItem value="Java">

```javascript
VideoSDK.setAudioDeviceChangeListener(new VideoSDK.AudioDeviceChangeEvent() {
    @Override
    public void onAudioDeviceChanged(AudioDeviceInfo selectedAudioDevice, Set<AudioDeviceInfo> audioDevices) {
        Log.d("VideoSDK", "Selected Audio Device: " + selectedAudioDevice.getLabel());
        for (AudioDeviceInfo audioDevice :
                audioDevices) {
            Log.d("VideoSDK", "Audio Devices" + audioDevice.getLabel());
        }
    }
});
```

</TabItem>

</Tabs>

---

</div>


---

---
sidebar_position: 1
sidebar_label: Introduction
pagination_label: Intro to VideoSDK Class
title: VideoSDK Class
---

# VideoSDK Class - Android 

<div class="sdk-api-ref">

## Introduction

The `VideoSDK` class includes properties, methods and events for creating and configuring a meeting, and managing media devices.

import LinksGrid from "../../../../src/theme/LinksGrid";
//import properties from "./../data/meeting-class/properties.json";
import methods from "./../data/meeting-class/methods.json";
import events from "./../data/meeting-class/events.json";

## VideoSDK Properties

<div class="row">

<div class="col col--4 margin-bottom--sm" >

- [getSelectedAudioDevice()](./properties.md#getselectedaudiodevice)

</div>
<div class="col col--4 margin-bottom--sm" >

- [getSelectedVideoDevice()](./properties#getselectedvideodevice)

</div>

</div>

## VideoSDK Methods

<div class="row">

<div class="col col--4 margin-bottom--sm" >

- [initialize()](./methods#initialize)

</div>

<div class="col col--4 margin-bottom--sm" >

- [config()](./methods#config)

</div>
<div class="col col--4 margin-bottom--sm" >

- [initMeeting()](./methods#initmeeting)

</div>
<div class="col col--4 margin-bottom--sm" >

- [getDevices()](./methods#getdevices)

</div>
<div class="col col--4 margin-bottom--sm" >

- [getVideoDevices()](./methods#getvideodevices)

</div>
<div class="col col--4 margin-bottom--sm" >

- [getAudioDevices()](./methods#getaudiodevices)

</div>
<div class="col col--4 margin-bottom--sm" >

- [checkPermissions()](./methods#checkpermissions)

</div>

<div class="col col--4 margin-bottom--sm" >

- [setAudioDeviceChangeListener()](./methods#setaudiodevicechangelistener)

</div>
<div class="col col--4 margin-bottom--sm" >

- [setSelectedAudioDevice()](./methods#setselectedaudiodevice)

</div>
<div class="col col--4 margin-bottom--sm" >

- [setSelectedVideoDevice()](./methods#setselectedvideodevice)

</div>

</div>

## VideoSDK Events

<div class="row">

<div class="col col--4 margin-bottom--sm" >

- [onAudioDeviceChanged](./events.md#onaudiodevicechanged)

</div>

</div>

</div>


---

---
sidebar_position: 1
sidebar_label: Methods
pagination_label: VideoSDK Class Methods
title: VideoSDK Class Methods
---

# VideoSDK Class Methods - Android

<div class="sdk-api-ref-only-h4">

### initialize()

To initialize the meeting, first you have to initialize the `VideoSDK`.
You can initialize the `VideoSDK` using `initialize()` method provided by the SDK.

#### Parameters

- **context**: Context

#### Returns

- _`void`_

```js title="initialize"
  VideoSDK.initialize(Context context)
```

---

### config()

By using `config()` method, you can set the `token` property of `VideoSDK` class.

Please refer this [documentation](/api-reference/realtime-communication/intro/) to generate a token.

#### Parameters

- **token**: String

#### Returns

- _`void`_

```js title="config"
 VideoSDK.config(String token)
```

---

### initMeeting()

- Initialize the meeting using a factory method provided by the SDK called `initMeeting()`.
- `initMeeting()` will generate a new [`Meeting`](../meeting-class/introduction.md) class and the initiated meeting will be returned.

```js title="initMeeting"
   VideoSDK.initMeeting(
        Context context,
        String meetingId,
        String name,
        boolean micEnabled,
        boolean webcamEnabled,
        String participantId,
        String mode,
        boolean multiStream,
        Map<String, CustomStreamTrack> customTracks
        JSONObject metaData,
        String signalingBaseUrl
        PreferredProtocol preferredProtocol
      )
```
- Please refer this [documentation](../initMeeting.md#initmeeting) to know more about `initMeeting()`.

---

### getDevices()

- The `getDevices()` method returns a list of the currently available media devices, such as microphones, cameras, headsets, and so forth. The method returns a list of `DeviceInfo` objects describing the devices.

- `DeviceInfo` class has four properties :

  1. `DeviceInfo.deviceId`

     - Returns a string that is an identifier for the represented device, persisted across sessions.

  2. `DeviceInfo.label`

     - Returns a string describing this device (for example `BLUETOOTH`).

  3. `DeviceInfo.kind`

     - Returns an enumerated value that is either `video` or `audio`.

  4. `DeviceInfo.FacingMode`

     - Returns a value of type `FacingMode` indicating which camera device is in use (front or back).

#### Returns

- `Set<DeviceInfo>`

#### Example

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
val devices: Set<DeviceInfo> = VideoSDK.getDevices()
for (deviceInfo in devices) {
    Log.d("VideoSDK", "Device's DeviceId " + deviceInfo.deviceId)
    Log.d("VideoSDK", "Device's Label " + deviceInfo.label)
    Log.d("VideoSDK", "Device's Kind " + deviceInfo.kind)
    Log.d("VideoSDK", "Device's Facing Mode " + deviceInfo.facingMode) //Value will be null for Audio Devices
}
```

</TabItem>

<TabItem value="Java">

```javascript
Set<DeviceInfo> devices = VideoSDK.getDevices();
for (DeviceInfo deviceInfo :
        devices) {
    Log.d("VideoSDK", "Device's DeviceId " + deviceInfo.getDeviceId());
    Log.d("VideoSDK", "Device's Label " + deviceInfo.getLabel());
    Log.d("VideoSDK", "Device's Kind " + deviceInfo.getKind());
    Log.d("VideoSDK", "Device's Facing Mode " + deviceInfo.getFacingMode()) //Value will be null for Audio Devices
}
```

</TabItem>

</Tabs>

---

### getVideoDevices()

- The `getVideoDevices` method returns a list of currently available video devices. The method returns a list of `VideoDeviceInfo` objects describing the video devices.

- `VideoDeviceInfo` class has four properties :

  1. `VideoDeviceInfo.deviceId`

     - Returns a string that is an identifier for the represented device, persisted across sessions.

  2. `VideoDeviceInfo.label`

     - Returns a string describing this device (for example `BLUETOOTH`).

  2. `VideoDeviceInfo.kind`

     - Returns an enumerated value that is `video` .

  4. `VideoDeviceInfo.FacingMode`

     - Returns a value of type `FacingMode` indicating which camera device is in use (front or back).


#### Returns

- `Set<VideoDeviceInfo>`

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
val videoDevices: Set<VideoDeviceInfo> = VideoSDK.getVideoDevices()
for (videoDevice in videoDevices) {
    Log.d("VideoSDK", "Video Device's DeviceId " + videoDevice.deviceId)
    Log.d("VideoSDK", "Video Device's Label " + videoDevice.label)
    Log.d("VideoSDK", "Video Device's Kind " + videoDevice.kind)
}
```

</TabItem>

<TabItem value="Java">

```js
Set<VideoDeviceInfo> videoDevices = VideoSDK.getVideoDevices();
for (VideoDeviceInfo videoDevice:
        videoDevices) {
    Log.d("VideoSDK", "Video Device's DeviceId " + videoDevice.getDeviceId());
    Log.d("VideoSDK", "Video Device's Label " + videoDevice.getLabel());
    Log.d("VideoSDK", "Video Device's Kind " + videoDevice.getKind());
}
```

</TabItem>

</Tabs>

---

### getAudioDevices()

- The `getAudioDevices` method returns a list of currently available audio devices. The method returns a list of `AudioDeviceInfo` objects describing the audio devices.

- `AudioDeviceInfo` class has three properties :

  1. `AudioDeviceInfo.deviceId`

     - Returns a string that is an identifier for the represented device, persisted across sessions.

  2. `AudioDeviceInfo.label`

     - Returns a string describing this device (for example `BLUETOOTH`).

  3. `AudioDeviceInfo.kind`

     - Returns an enumerated value that is `audio`.

#### Returns

- `Set<AudioDeviceInfo>`

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
val audioDevices: Set<AudioDeviceInfo> = VideoSDK.getAudioDevices()
for (audioDevice in audioDevices) {
    Log.d("VideoSDK", "Audio Device's DeviceId " + audioDevice.deviceId)
    Log.d("VideoSDK", "Audio Device's Label " + audioDevice.label)
    Log.d("VideoSDK", "Audio Device's Kind " + audioDevice.kind)
}
```

</TabItem>

<TabItem value="Java">

```js
Set<AudioDeviceInfo> audioDevices = VideoSDK.getAudioDevices();
for (AudioDeviceInfo audioDevice:
     audioDevices) {
    Log.d("VideoSDK", "Audio Device's DeviceId " + audioDevice.getDeviceId());
    Log.d("VideoSDK", "Audio Device's Label " + audioDevice.getLabel());
    Log.d("VideoSDK", "Audio Device's Kind " + audioDevice.getKind());
}
```

</TabItem>

</Tabs>

---

### setAudioDeviceChangeListener()

- The `AudioDeviceChangeEvent` is emitted when an audio device, is connected to or removed from the device. This event can be set by using `setAudioDeviceChangeListener()` method.

#### Parameters

- **audioDeviceChangeEvent**: AudioDeviceChangeEvent

#### Returns

- _`void`_

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
VideoSDK.setAudioDeviceChangeListener { selectedAudioDevice: AudioDeviceInfo, audioDevices: Set<AudioDeviceInfo> ->
    Log.d(
        "VideoSDK",
        "Selected Audio Device: " + selectedAudioDevice.label
    )
    for (audioDevice in audioDevices) {
        Log.d("VideoSDK", "Audio Devices" + audioDevice.label)
    }
}
```

</TabItem>

<TabItem value="Java">

```javascript
VideoSDK.setAudioDeviceChangeListener((selectedAudioDevice, audioDevices) -> {
    Log.d("VideoSDK", "Selected Audio Device: " + selectedAudioDevice.getLabel());
    for (AudioDeviceInfo audioDevice :
            audioDevices) {
        Log.d("VideoSDK", "Audio Devices" + audioDevice.getLabel());
    }
});
```

</TabItem>

</Tabs>

---

### checkPermissions()

- The `checkPermissions()` method verifies whether permissions to access camera and microphone devices have been granted. If the required permissions are not granted, the method will proceed to request these permissions from the user.

#### Parameters

- context

  - type: `Context`
  - `REQUIRED`
  - The android context.

- permission

  - type: `List<Permission>`
  - `REQUIRED`
  - The permission to be requested.

- permissionHandler

  - type: `PermissionHandler`
  - `REQUIRED`
  - The permission handler object for handling callbacks of various user actions such as permission granted, permission denied, etc.

- rationale

  - type: `String`
  - `OPTIONAL`
  - Explanation to be shown to user if they have denied permission earlier. If this parameter is not provided, permissions will be requested without showing the rationale dialog.

- options

  - type: `Permissions.Options`
  - `OPTIONAL`
  - The options object for setting title and description of dialog box that prompts users to manually grant permissions by navigating to device settings. If this parameter is not provided,the default title and decription will be used for the dialog box.

#### Returns

- _`void`_

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
private val permissionHandler: PermissionHandler = object : PermissionHandler() {
    override fun onGranted() {}
    override fun onBlocked(
        context: Context,
        blockedList: java.util.ArrayList<Permission>
    ): Boolean {
        for (blockedPermission in blockedList) {
            Log.d("VideoSDK Permission", "onBlocked: $blockedPermission")
        }
        return super.onBlocked(context, blockedList)
    }

    override fun onDenied(
        context: Context,
        deniedPermissions: java.util.ArrayList<Permission>
    ) {
        for (deniedPermission in deniedPermissions) {
            Log.d("VideoSDK Permission", "onDenied: $deniedPermission")
        }
        super.onDenied(context, deniedPermissions)
    }

    override fun onJustBlocked(
        context: Context,
        justBlockedList: java.util.ArrayList<Permission>,
        deniedPermissions: java.util.ArrayList<Permission>
    ) {
        for (justBlockedPermission in justBlockedList) {
            Log.d("VideoSDK Permission", "onJustBlocked: $justBlockedPermission")
        }
        super.onJustBlocked(context, justBlockedList, deniedPermissions)
    }
}
val permissionList: MutableList<Permission> = ArrayList()
permissionList.add(Permission.audio)
permissionList.add(Permission.video)
permissionList.add(Permission.bluetooth)
val rationale = "Please provide permissions"
val options =
    Permissions.Options().setRationaleDialogTitle("Info").setSettingsDialogTitle("Warning")
//If you wish to disable the dialog box that prompts 
//users to manually grant permissions by navigating to device settings, 
//you can set options.sendDontAskAgainToSettings(false)
VideoSDK.checkPermissions(this, permissionList, rationale, options, permissionHandler)
```

</TabItem>

<TabItem value="Java">

```js
private final PermissionHandler permissionHandler = new PermissionHandler() {
    @Override
    public void onGranted() {
    }

    @Override
    public boolean onBlocked(Context context, ArrayList<Permission> blockedList) {
        for (Permission blockedPermission :
                blockedList) {
            Log.d("VideoSDK Permission", "onBlocked: " + blockedPermission);
        }
        return super.onBlocked(context, blockedList);
    }

    @Override
    public void onDenied(Context context, ArrayList<Permission> deniedPermissions) {
        for (Permission deniedPermission :
                deniedPermissions) {
            Log.d("VideoSDK Permission", "onDenied: " + deniedPermission);
        }
        super.onDenied(context, deniedPermissions);
    }

    @Override
    public void onJustBlocked(Context context, ArrayList<Permission> justBlockedList, ArrayList<Permission> deniedPermissions) {
        for (Permission justBlockedPermission :
                justBlockedList) {
            Log.d("VideoSDK Permission", "onJustBlocked: " + justBlockedPermission);
        }
        super.onJustBlocked(context, justBlockedList, deniedPermissions);
    }
};
List<Permission> permissionList = new ArrayList<>();
permissionList.add(Permission.audio);
permissionList.add(Permission.video);
permissionList.add(Permission.bluetooth);
String rationale = "Please provide permissions";
Permissions.Options options =
        new Permissions.Options().setRationaleDialogTitle("Info").setSettingsDialogTitle("Warning");
//If you wish to disable the dialog box that prompts 
//users to manually grant permissions by navigating to device settings, 
//you can set options.sendDontAskAgainToSettings(false)
VideoSDK.checkPermissions(this, permissionList, rationale, options, permissionHandler);
```

</TabItem>

</Tabs>

---

### setSelectedAudioDevice()

- It sets the selected audio device, allowing the user to specify which audio device to use in the meeting.

#### Parameters

- **selectedAudioDevice**: AudioDeviceInfo

#### Returns

- _`void`_

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
val audioDevices: Set<AudioDeviceInfo> = VideoSDK.getAudioDevices()
val audioDeviceInfo: AudioDeviceInfo = audioDevices.toTypedArray().get(0) as AudioDeviceInfo
VideoSDK.setSelectedAudioDevice(audioDeviceInfo)
```

</TabItem>

<TabItem value="Java">

```js
Set<AudioDeviceInfo> audioDevices = VideoSDK.getAudioDevices();
AudioDeviceInfo audioDeviceInfo = (AudioDeviceInfo) audioDevices.toArray()[0];
VideoSDK.setSelectedAudioDevice(audioDeviceInfo);
```

</TabItem>

</Tabs>

---

### setSelectedVideoDevice()

- It sets the selected video device, allowing the user to specify which video device to use in the meeting.

#### Parameters

- **selectedVideoDevice**: VideoDeviceInfo

#### Returns

- _`void`_

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
val videoDevices: Set<VideoDeviceInfo> = VideoSDK.getVideoDevices()
val videoDeviceInfo: VideoDeviceInfo = videoDevices.toTypedArray().get(1) as VideoDeviceInfo
VideoSDK.setSelectedVideoDevice(videoDeviceInfo)
```

</TabItem>

<TabItem value="Java">

```js
Set<VideoDeviceInfo> videoDevices = VideoSDK.getVideoDevices();
VideoDeviceInfo videoDeviceInfo = (VideoDeviceInfo) videoDevices.toArray()[1];
VideoSDK.setSelectedVideoDevice(videoDeviceInfo);
```

</TabItem>

</Tabs>

---

### applyVideoProcessor()

- This method allows users to dynamically apply virtual background to their video stream during a live session.

#### Parameters

- videoFrameProcessor

  - type: `VideoFrameProcessor`
  - This is an object of the `VideoFrameProcessor` class, which overrides the `onFrameCaptured(VideoFrame videoFrame)` method.

#### Returns

- _`void`_

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
val uri = Uri.parse("https://st.depositphotos.com/2605379/52364/i/450/depositphotos_523648932-stock-photo-concrete-rooftop-night-city-view.jpg")
val backgroundImageProcessor = BackgroundImageProcessor(uri)
VideoSDK.applyVideoProcessor(backgroundImageProcessor)
```

</TabItem>

<TabItem value="Java">

```java
Uri uri = Uri.parse("https://st.depositphotos.com/2605379/52364/i/450/depositphotos_523648932-stock-photo-concrete-rooftop-night-city-view.jpg");
BackgroundImageProcessor backgroundImageProcessor = new BackgroundImageProcessor(uri)
VideoSDK.applyVideoProcessor(backgroundColorProcessor);
```

</TabItem>

</Tabs>

---

### removeVideoProcessor()

- This method provides users with a convenient way to revert their video background to its original state, removing any previously applied virtual background.

   - **Returns:**
      - _`void`_

#### Example

```js
VideoSDK.removeVideoProcessor();
```


</div>


---

---
sidebar_position: 1
sidebar_label: Properties
pagination_label: VideoSDK Class Properties
title: VideoSDK Class Properties
---

# VideoSDK Class Properties - Android

<div class="sdk-api-ref-only-h4">

### getSelectedAudioDevice()

- type: `AudioDeviceInfo`

- The `getSelectedAudioDevice()` method will return the object of the audio device, which is currently in use.

---

### getSelectedVideoDevice()

- type: `VideoDeviceInfo`

- The `getSelectedVideoDevice()` method will return the object of the video device, which is currently in use.



</div>


---

### 5.Errors associated with Media

These errors involve media access, device availability, or permission-related issues affecting camera, microphone, and screen sharing.

### Device access-related errors

| Type                                      | Code  | Message                                          |
|-------------------------------------------|-------|--------------------------------------------------|
| ERROR_CAMERA_ACCESS  | 3002  | Something went wrong. Unable to access camera. |
| ERROR_MIC_ACCESS_DENIED  | 3003  | It seems like microphone access was denied or dismissed. To proceed, kindly grant access through your device's settings. |
| ERROR_CAMERA_ACCESS_DENIED | 3004 | It seems like camera access was denied or dismissed. To proceed, kindly grant access through your device's settings. |

### 6.Errors associated with Track

These errors occur when there are issues with video or audio tracks, such as disconnections or invalid custom tracks.

| Type                        | Code  | Message                                          |
|-----------------------------|-------|--------------------------------------------------|
| ERROR_CUSTOM_SCREEN_SHARE_TRACK_ENDED      | 3005  | The provided custom track is in an ended state. Please try again with new custom track. |
| ERROR_CUSTOM_SCREEN_SHARE_TRACK_DISPOSED      | 3006  | The provided custom track was disposed. Please try again with new custom track. |
| ERROR_CHANGE_WEBCAM      | 3007  | Something went wrong, and the camera could not be changed. Please try again. |

### 7.Errors associated with Actions

Below error is triggered when an action is attempted before joining a meeting.

| Type                        | Code  | Message                                          |
|-----------------------------|-------|--------------------------------------------------|
| ERROR_ACTION_PERFORMED_BEFORE_MEETING_JOINED     | 3001  | Oops! Something went wrong. The room was in a connecting state, and during that time, an action encountered an issue. Please try again after joining a meeting. |

---

---
sidebar_label: App Size Optimization
pagination_label: App Size Optimization
---

# App Size Optimization - Android

This guide is designed to help developers optimize app size, enhancing performance and efficiency across different devices. By following these best practices, you can reduce load times, minimize storage requirements, and deliver a more seamless experience to users, all while preserving essential functionality.

### Deliver Leaner Apps with App Bundles

Using Android App Bundles (AAB) is an effective way to optimize the size of your application, making it lighter and more efficient for users to download and install. App Bundles allow Google Play to dynamically generate APKs tailored to each device, so users only download the resources and code relevant to their specific configuration. This approach reduces app size significantly, leading to faster installs and conserving storage space on users’ devices.

Recommended Practices:

- `Enable App Bundles`: Configure your build to use the App Bundle format instead of APKs. This will allow Google Play to optimize your app for each device type automatically.

- `Organize Resources by Device Type`: Ensure that resources (like images and layouts) are organized by device type (such as screen density or language) to maximize the benefits of App Bundles.

- `Test Modularization`: If your app contains large, optional features, use dynamic feature modules to let users download them on demand. This reduces the initial download size and provides features only as needed.

- `Monitor Size Reductions`: Regularly analyze your app size to see where the most savings occur, and make sure that App Bundle optimizations are effectively reducing your app size across different device configurations.

### Optimize Libraries for a Leaner App Experience

Managing dependencies carefully is essential for minimizing app size and improving performance. Every library or dependency included in your app adds to its overall size, so it’s crucial to only incorporate what’s necessary. Optimizing dependencies helps streamline your app, reduce load times, and enhance maintainability.

Recommended Practices:

- `Use Only Essential Libraries`: Review all libraries and dependencies, removing any that are not critical to your app’s functionality. This helps avoid unnecessary bloat.

- `Leverage Lightweight Alternatives`: Whenever possible, choose lightweight libraries or modularized versions of larger ones. For example, opt for a specific feature module rather than including an entire library.

- `Monitor Library Updates`: Regularly update your dependencies to take advantage of any optimizations or size reductions made by the library maintainers. Newer versions are often more efficient.

- `Minimize Native Libraries`: If your app uses native libraries, ensure they’re essential and compatible across platforms, as they can significantly increase app size.

- `Analyze Dependency Tree`: Use tools like Gradle’s dependency analyzer to identify unnecessary or redundant dependencies, ensuring your app’s dependency tree is as lean as possible.


### Optimize with ProGuard

ProGuard is a powerful tool for shrinking, optimizing, and obfuscating your code, which can significantly reduce your app's size and improve performance. By removing unused code and reducing the size of classes, fields, and methods, ProGuard helps to minimize the footprint of your app without sacrificing functionality. Additionally, ProGuard’s obfuscation feature enhances security by making reverse engineering more difficult. You can refer to the official [documentation](https://developer.android.com/build/shrink-code) for more information.

Recommended Practices:

- `Enable ProGuard`: To enable ProGuard in your project, ensure that your `proguard-rules.pro` file is properly configured, and add the following lines to your `build.gradle` file:

```js title="build.gradle"
buildTypes {
    release {
        minifyEnabled true
        proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'
    }
}
```

- `Customize ProGuard Rules`: Carefully review and customize ProGuard rules in the proguard-rules.pro file to avoid stripping essential code. For example, to keep a specific class, add:

```js
-keep class com.example.myapp.MyClass { *; }
```

If you encounter an issue after enabling ProGuard rules, refer to our [known issues section](https://docs.videosdk.live/android/guide/video-and-audio-calling-api-sdk/known-issues).

---

---
sidebar_label: Developer Experience Guidelines
pagination_label: Developer Experience Guidelines
---

# Developer Experience Guidelines - Android

This section provides best practices for creating a smooth and efficient development process when working with VideoSDK. From handling errors gracefully to managing resources and event subscriptions, these guidelines help developers build more reliable and maintainable applications. Following these practices can simplify troubleshooting, prevent common pitfalls, and improve overall application performance.

### Initiate Key Features After Meeting Join Event

To provide a seamless and reliable meeting experience, initiate specific features **only** after the [onMeetingJoined()](https://docs.videosdk.live/android/api/sdk-reference/meeting-class/meeting-event-listener-class#onmeetingjoined) event has been triggered.

- **Trigger Key Actions After Joining the Meeting** : Initiating crucial actions after the `onMeetingJoined()` event helps avoid errors and optimizes the meeting setup, ensuring a smoother experience for participants. If your application utilizes any of the following features or you want to perform any action as soon as meeting joins, it's recommended to call them only after the meeting has successfully started:

    - `Chat Subscription`: To enable in-meeting chat functionality, subscribe to the chat topic after the `onMeetingJoined()` event is triggered. This ensures that messages are reliably received by participants.

    <br/>
    <div style={{textAlign: 'center'}}>

    <img src="https://cdn.videosdk.live/docs/best-practices/mobile/android_chat_correct_incorrect_code.png" />

    </div>

    - `Device Management`: If you need users to use specific audio or video devices when the meeting is first joined, you can utilize the [`setSelectedAudioDevice()`](https://docs.videosdk.live/android/api/sdk-reference/videosdk-class/methods#setselectedaudiodevice) and [`setSelectedVideoDevice()`](https://docs.videosdk.live/android/api/sdk-reference/videosdk-class/methods#setselectedvideodevice) methods of `VideoSDK` class.

    - `Recording and Transcription`: To automatically start recording or transcription as soon as the meeting begins, configure the `autoStartConfig` in the `createMeeting` API. For detailed information, refer to the documentation [here](https://docs.videosdk.live/api-reference/realtime-communication/create-room#autoCloseConfig).

### Dispose Custom Tracks When Necessary

Proper disposal of custom tracks is essential for managing system resources and ensuring a smooth experience. In most scenarios, tracks are automatically disposed of by the SDK, ensuring efficient resource management. However, in specific cases outlined below, you will need to dispose of custom tracks explicitly:

1. **When Enabling/Disabling the Camera on a Precall Screen**:
    - If your application includes a precall screen and you want to ensure that the device's camera is not used when the camera is disabled, you must dispose of the custom video track. Otherwise, the device’s camera will continue to be used even when the camera is off.
    - Additionally, remember to create a new track when the user enables the camera again.
    - If you don’t need to manage the camera's usage on the device level (i.e., you’re okay with the camera being used whether it’s enabled or disabled), you can skip this step.
    - Here's how you can manage customTrack on a precall screen :

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
import live.videosdk.rtc.android.CustomStreamTrack
import live.videosdk.rtc.android.VideoSDK
import live.videosdk.rtc.android.VideoView

class JoinActivity : AppCompatActivity() {
    private var videoTrack: CustomStreamTrack? = null
    private var joinView: VideoView? = null

    private fun toggleWebcam(videoDevice: VideoDeviceInfo?) {
        if (isWebcamEnabled) {
            // check the track state is LIVE
            if(videoTrack?.track?.state()?.equals("LIVE") == true){
                videoTrack?.track?.dispose()  // Dispose the current video track
                videoTrack?.track?.setEnabled(false) // Disable the track
            }
            videoTrack = null
            joinView!!.removeTrack() // Remove the video track from the view
            joinView!!.releaseSurfaceViewRenderer()
            joinView!!.visibility = View.INVISIBLE;
        } else {
            // Re-enabling the webcam by creating a new track
            videoTrack = VideoSDK.createCameraVideoTrack(
                "h720p_w960p",
                "front",
                CustomStreamTrack.VideoMode.TEXT,
                true,
                this,
                videoDevice  // Passes the VideoDeviceInfo object of the user's selected device
            )
            // display in localView
            joinView!!.addTrack(videoTrack!!.track as VideoTrack?)
            joinView!!.visibility = View.VISIBLE
        }
        isWebcamEnabled = !isWebcamEnabled // Toggle webcam state
    }
}
```

</TabItem>

<TabItem value="Java">

```js
import live.videosdk.rtc.android.CustomStreamTrack
import live.videosdk.rtc.android.VideoSDK
import live.videosdk.rtc.android.VideoView

public class JoinActivity extends AppCompatActivity {
    private CustomStreamTrack videoTrack = null;
    private VideoView joinView = null;
    private boolean isWebcamEnabled = false;

    private void toggleWebcam(VideoDeviceInfo videoDevice) {
        if (isWebcamEnabled) {
            // Check if the track state is LIVE
            if (videoTrack != null && "LIVE".equals(videoTrack.getTrack().state())) {
                videoTrack.getTrack().dispose(); // Dispose the current video track
                videoTrack.getTrack().setEnabled(false); // Disable the track
            }
            videoTrack = null;
            joinView.removeTrack(); // Remove the video track from the view
            joinView.releaseSurfaceViewRenderer();
            joinView.setVisibility(View.INVISIBLE);
        } else {
            // Re-enabling the webcam by creating a new track
            videoTrack = VideoSDK.createCameraVideoTrack(
                "h720p_w960p",
                "front",
                CustomStreamTrack.VideoMode.TEXT,
                true,
                this,
                videoDevice // Passes the VideoDeviceInfo object of the user's selected device
            );
            // Display in the local view
            joinView.addTrack((VideoTrack) videoTrack.getTrack());
            joinView.setVisibility(View.VISIBLE);
        }
        isWebcamEnabled = !isWebcamEnabled; // Toggle webcam state
    }
}
```
</TabItem>

</Tabs>


### Listen for Error Events

Listening to error events enables your application to handle unexpected issues efficiently, providing users with clear feedback and potential solutions. Error codes pinpoint specific problems, whether from configuration settings, account restrictions, permission limitations, or device constraints. Here are recommended solutions based on common error categories:

1. [Errors associated with Organization](../../api/sdk-reference/error-codes.md#1-errors-associated-with-organization): If you encounter errors related to your organization (e.g., account status or participant limits), reach out to support at support@videosdk.live or reach out to us on [Discord](https://discord.com/invite/Qfm8j4YAUJ) for assistance.

2. [Errors associated with Token](../../api/sdk-reference/error-codes#2-errors-associated-with-token): For errors related to authentication tokens, ensure the token is valid and hasn’t expired, then try the request again.

3. [Errors associated with Meeting and Participant](../../api/sdk-reference/error-codes#3-errors-associated-with-meeting-and-participant): Check that meetingId and participantId are correctly passed and valid. Also, ensure each participant has a unique participantId to avoid duplicate entries.

4. [Errors associated with Add-on Service](../../api/sdk-reference/error-codes#4-errors-associated-with-add-on-service): If you encounter errors with add-on services (such as recording or streaming), try restarting the service after receiving a failure event. For example, if a `START_RECORDING_FAILED` error event occurs, attempt to call the `startRecording()` method again. If you're using webhooks, you can also retry on [recording-failed](https://docs.videosdk.live/api-reference/realtime-communication/user-webhooks#recording-failed) hook.

5. [Errors associated with Media](../../api/sdk-reference/error-codes#5errors-associated-with-media): Inform the user about media access issues, such as microphone or camera permissions. Design the UI to clearly indicate what is preventing the mic or camera from enabling, helping the user understand the problem.

6. [Errors associated with Track](../../api/sdk-reference/error-codes#6errors-associated-with-track): Ensure that the track you’ve created and passed to enable the mic or camera methods meets the required specifications.

7. [Errors associated with Actions](../../api/sdk-reference/error-codes#7errors-associated-with-actions): If you need to perform actions as soon as a meeting joins, only initiate them after receiving the [onMeetingJoined()](https://docs.videosdk.live/android/api/sdk-reference/meeting-class/meeting-event-listener-class#onmeetingjoined) event, otherwise it will not work well.

- Here's how to listen for the error event:

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
private val meetingEventListener: MeetingEventListener = object : MeetingEventListener() {
  //..
  override fun onError(error: JSONObject) {
  try {
      val errorCodes: JSONObject = VideoSDK.getErrorCodes()
      val code = error.getInt("code")
      Log.d("#error", "Error is: " + error["message"])
  } catch (e: Exception) {
          e.printStackTrace()
      }
  }
}
```

</TabItem>

<TabItem value="Java">

```js
private final MeetingEventListener meetingEventListener = new MeetingEventListener() {
  //..
  @Override
  public void onError(JSONObject error) {
      try {
          JSONObject errorCodes = VideoSDK.getErrorCodes();
          int code = error.getInt("code");
          Log.d("#error", "Error is: " + error.get("message"));
      } catch (Exception e) {
          e.printStackTrace();
      }
  }
};
```

</TabItem>

</Tabs>

---

---
sidebar_label: Handle Large Rooms
pagination_label: Handle Large Rooms
---

# Handle Large Rooms - Android

Managing large meetings requires specific strategies to ensure performance, stability, and a seamless user experience. This section provides best practices for optimizing VideoSDK applications to handle high participant volumes effectively. By implementing these recommendations, you can reduce lag, maintain video and audio quality, and provide a smooth experience even in large rooms.

### User Interface Optimization

When hosting large meetings, an optimized UI helps manage participant visibility and ensures smooth performance.

Recommended Practices:

- `Limit Visible Participants`: Display only a limited number of participants on screen at any given time, adapting the view based on screen size. Use pagination to allow users to browse or switch between additional participants seamlessly. For example, you could display only users whose video stream is enabled, or you could choose to display all active speakers. This approach helps manage screen space efficiently, ensuring that the most relevant participants are visible without overwhelming the interface.
- `Prioritize Active Speakers`: Ensure all active speakers are displayed on the screen to highlight who is currently talking, helping participants stay engaged and aware of ongoing discussions. To identify which participant is speaking, you can use the [onSpeakerChanged()](https://docs.videosdk.live/android/api/sdk-reference/meeting-class/meeting-event-listener-class#onspeakerchanged) event.

### Optimizing Media Streams 

In large video calls, it’s important to manage media streams effectively to optimize system resources while maintaining a smooth user experience. 

Recommended Practices:

- `Pause Streams for Non-Visible Participants`: To optimize performance, pause the video and/or audio streams of participants who are not currently visible on the screen. This reduces unnecessary resource consumption.
- `Resume Streams When Visible`: Once a participant comes into view, resume their stream to provide an uninterrupted experience as they appear on the screen.

For detailed setup instructions on how to achieve this, check out our in-depth documentation [here](https://docs.videosdk.live/android/guide/video-and-audio-calling-api-sdk/render-media/layout-and-grid-management#pauseresume-stream).

### Media Stream Quality Adjustment

In large meetings, managing media stream quality is essential to balance performance and user experience. 

Recommended Practices:

- `High Quality for Active Speakers`: For all active speakers, set the video stream quality to a higher level using the setQuality method (e.g., `setQuality("high")`). This ensures that participants will receive higher-quality video for active speakers, providing a clearer and more engaging experience.
- `Lower Quality for Non-Speaking Participants`: For other participants who are not actively speaking, set their video stream quality to a lower level (e.g., `setQuality("low")`). This helps conserve bandwidth and system resources while maintaining overall meeting performance.

Checkout the documentation for `setQuality()` method [here](https://docs.videosdk.live/android/api/sdk-reference/participant-class/methods#setquality) 

---

---
sidebar_label: User Experience Guidelines
pagination_label: User Experience Guidelines
---

# User Experience Guidelines - Android

This guide aims to help developers optimize the user experience and functionality of video conferencing applications with VideoSDK. By following these best practices, you can create smoother interactions, minimize common issues, and deliver a more reliable experience for users.

Here are our recommended best practices to enhance the user experience in your application:

| **Section**                          | **Description**                                                                                                                                                      |
|--------------------------------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| [Configure Precall for Effortless Meeting Join](#configure-precall-for-effortless-meeting-join) | Users may enter meetings unprepared due to device or connection issues. A Precall setup can help them configure devices and settings beforehand for a smooth start. |
| [Listen Key Events for Optimal User Experience](#listen-key-events-for-optimal-user-experience) | Users can feel lost without real-time updates on meeting status, events, and errors. Event monitoring and notifications keep them informed and engaged.              |
| [Handling Media Devices](#handling-media-devices)                                             | Users may want to change their audio or video setup mid-meeting but struggle to manage device controls. Providing easy device switching enhances control and flexibility. |
| [Monitoring Real-Time Participant Statistics](#monitoring-real-time-participant-statistics)   | Poor video or audio quality without real-time feedback leaves users frustrated. Real-time stats let them assess connection quality and troubleshoot issues actively.    |

### Configure Precall for Effortless Meeting Join

A Precall step is crucial for ensuring users are set up correctly and have no device before joining a meeting. This step allows users to configure their devices and settings before entering a meeting, leading to a smoother experience and minimizing technical issues once the call begins.

Recommended Practices:

- `Request Permissions`: Prompt users to grant microphone, and camera permissions before entering the meeting, ensuring seamless access to their devices.
- `Device Selection`: Allow users to select their preferred camera, and microphone giving them control over their setup from the start.
- `Entry Preferences`: Provide options to join with the microphone and camera either on or off, letting users choose their level of engagement upon entry.
- `Camera Preview`: Show a live camera preview, allowing users to adjust angles and lighting to ensure they appear clearly and professionally.
- `Virtual Backgrounds`: Allow users to choose from different virtual backgrounds or enter with a virtual background enabled, enhancing privacy and creating a more polished appearance.

For detailed setup instructions on each of these features, check out our in-depth documentation [here](https://docs.videosdk.live/android/guide/video-and-audio-calling-api-sdk/setup-call/precall).

<div style={{textAlign: 'center'}}>

<img height="400" src="https://cdn.videosdk.live/docs/best-practices/mobile/mobile_precall.gif" />

</div>

### Monitor Key Events for Optimal User Experience

Listening for crucial events is vital for providing users with a responsive and engaging experience in your application. By effectively managing state changes and user notifications, you can keep participants informed and enhance their overall experience during meetings.

Recommended Practices:

- `Monitor State Change Events`: Listen for state change events, such as `onMeetingStateChanged` and `onRecordingStateChanged`, and notify users promptly about these transitions. Keeping users informed helps them understand the current state of the meeting.

<div style={{textAlign: 'center'}}>

<img height="400" src="https://cdn.videosdk.live/docs/best-practices/mobile/mobile_meeting_state.jpg" />

</div>

- `UI Handling on Event Trigger`: Update the user interface only in response to specific events. For instance, display that the meeting is recording only when the `onRecordingStateChanged` event with the status `RECORDING_STARTED` is received, rather than when the record button is clicked. This ensures users receive accurate and timely updates.

<div style={{textAlign: 'center'}}>

<img height="400" src="https://cdn.videosdk.live/docs/best-practices/mobile/mobile_recording.gif" />

</div>

- `Notify Participants of Join/Leave Events`: Keep users informed about participant activity by notifying them when someone joins or leaves the meeting. This fosters a sense of presence and awareness of who is currently available to engage.
- `Listen for Error Events`: It is crucial to monitor error events and notify users promptly when issues arise. Clear communication about errors can help users troubleshoot and address problems quickly, minimizing disruptions to the meeting.


### Handling Media Devices

Providing seamless control over devices enhances user convenience and allows participants to adjust their setup for the best meeting experience. Proper device management within the UI also helps users stay informed about their current settings and troubleshoot issues effectively.

Recommended Practices:

- `Allow Device Switching`: Provide users with the option to switch between available microphone, and camera devices during the meeting. This flexibility is essential, especially if users want to adjust their setup mid-call.
- `Display Selected Devices`: Ensure the UI shows users which microphone, and camera devices are currently selected. Clear device labeling in the interface can reduce confusion and help users verify their setup at a glance.

<div style={{textAlign: 'center'}}>

<img height="400" src="https://cdn.videosdk.live/docs/best-practices/mobile/mobile_audio_selected_device.jpg" />

</div>

### Monitoring Real-Time Participant Statistics

Providing real-time insights into stream quality allows participants to monitor and optimize their connection for the best experience. With detailed metrics on video, audio, and screen sharing, users can assess and troubleshoot quality issues, ensuring smooth and uninterrupted meetings. To display these statistics, you can use the [getVideoStats()](https://docs.videosdk.live/android/api/sdk-reference/participant-class/methods#getvideostats), [getAudioStats()](https://docs.videosdk.live/android/api/sdk-reference/participant-class/methods#getaudiostats), and [getShareStats()](https://docs.videosdk.live/android/api/sdk-reference/participant-class/methods#getsharestats) methods.

import ReactPlayer from 'react-player'

<div style={{textAlign: 'center'}}>

<ReactPlayer autoplay muted loop playing url='https://cdn.videosdk.live/docs/best-practices/mobile/mobile_call-stats.mp4' width={"100%"}/>

</div>

<br/>

:::note
To show the popup dialog for the participant's realtime stats, you can [refer to this function](https://github.com/videosdk-live/videosdk-rtc-android-kotlin-sdk-example/blob/main/app/src/main/java/live/videosdk/rtc/android/kotlin/Common/Utils/HelperClass.kt#L91).
:::



---

---
sidebar_label: Face Match API
pagination_label: Face Match API
---

# Face Match API

import FaceMatchApi from '../../../mdx/\_api-face-match.mdx';

<FaceMatchApi/>






---

---
sidebar_label: Face Spoof Detection API
pagination_label: Face Spoof Detection API
---

# Face Spoof Detection

import FaceSpoofDetection from '../../../mdx/\_api-spoof-detection.mdx';

<FaceSpoofDetection/>

---

---
sidebar_label: Number of Face Detection API
pagination_label: Number of Face Detection API
---

# Number of Face Detection

import NoOfFaceDetectionApi from '../../../mdx/\_api-number-of-face-detection.mdx';

<NoOfFaceDetectionApi/>






---

---
sidebar_label: OCR API
pagination_label: OCR API
---

# OCR API

import OcrApi from '../../../mdx/\_api-ocr.mdx';

<OcrApi/>






---

---
title: Customized Live Stream
sidebar_position: 1
sidebar_label: Customized Live Stream
hide_table_of_contents: false
---

# Customized Live Stream - Android

VideoSDK is a platform that offers a range of video streaming tools and solutions for content creators, publishers, and developers.

### Custom Template

- Custom template is template for live stream, which allows users to add real-time graphics to their streams.
- With custom templates, users can create unique and engaging video experiences by overlaying graphics, text, images, and animations onto their live streams. These graphics can be customized to match the branding.
- Custom templates enable users to create engaging video content with real-time graphics, with live scoreboards, social media feeds, and other customizations, users can easily create unique and visually appealing streams that stands out from the crowd.

:::note

Custom templates can be used with recordings and RTMP service provided by VideoSDK as well.

:::

### What you can do with Custom Template

Using a custom template, you may create a variety of various modes. Here are a few of the more well-known modes that you can create.

- **`PK Host:`** Host can organise player vs player battle. Below image is example of gaming battle.

- **`Watermark:`** Host can add & update watermark anywhere in the template. In below image we have added VideoSDK watermark on top right side of the screen.

- **`News Mode:`** Host can add dynamic text in lower third banner. in below image we have added some sample text in bottom left of the screen.

![Mobile Custom Template ](https://cdn.videosdk.live/website-resources/docs-resources/mobile_custom_template.png)

### Custom template with VideoSDK

In this section, we will discuss how Custom Templates work with VideoSDK.

- **`Host`**: The host is responsible for starting the live streaming by passing the `templateURL`. The `templateURL` is the URL of the hosted template webpage. The host is also responsible for managing the template, such as changing text, logos, and switching template layout, among other things.

- **`VideoSDK Template Engine`** : The VideoSDK Template Engine accepts and opens the templateURL in the browser. It listens to all the events performed by the Host and enables customization of the template according to the Host's preferences.

- **`Viewer`**: The viewer can stream the content. They can watch the live stream with the added real-time graphics, which makes for a unique and engaging viewing experience.

![custom template](https://cdn.videosdk.live/website-resources/docs-resources/custom_template.png)

### Understanding Template URL

The template URL is the webpage that VideoSDK Template Engine will open while composing the live stream.

The template URL will appear as shown below.

![template url](https://cdn.videosdk.live/website-resources/docs-resources/custom_template_url.png)

The Template URL consists of two parts:

- Your actual page URL, which will look something like `https://example.com/videosdk-template`.
- Query parameters, which will allow the VideoSDK Template Engine to join the meeting when the URL is opened. There are a total of three query parameters:
  - `token`: This will be your token, which will be used to join the meeting.
  - `meetingId`: This will be the meeting ID that will be joined by the VideoSDK Template Engine.
  - `participantId`: This will be the participant ID of the VideoSDK Template Engine, which should be passed while joining the template engine in your template so that the tempalte engine participant is not visible to other participants. **This parameter will be added by the** **VideoSDK**.

:::info

Above mentioned query parameters are mandatory. Apart from these parameters, you can pass any other extra parameters which are required according to your use-case.

:::

### **Creating Template**

**`Step 1:`** Create a new React App using the below command

```js
npx create-react-app videosdk-custom-template
```

:::note

You can use VideoSDK's React or JavaScript SDK to create custom template. Following is the example of building custom template with React SDK.

:::

**`Step 2:`** Install the VideoSDK using the below-mentioned npm command.

Make sure you are in your react app directory before you run this command.

```js
npm install "@videosdk.live/react-sdk"

//For the Participants Video
npm install "react-player"
```

###### App Architecture

![template architechture](https://cdn.videosdk.live/website-resources/docs-resources/custom_template_arch.png)

###### Structure of the Project

```jsx title="Project Structure"
   root
   ├── node_modules
   ├── public
   ├── src
   │    ├── components
   │          ├── MeetingContainer.js
   │          ├── ParticipantsAudioPlayer.js
   │          ├── ParticipantsView.js
   │          ├── Notification.js
   │    ├── icons
   │    ├── App.js
   │    ├── index.js
   ├── package.json
   .
```

**`Step 3:`** Next we will fetch the query parameters, from the URL which we will later use to initialize the meeting

```js title=App.js
function App() {
  const { meetingId, token, participantId } = useMemo(() => {
    //highlight-start
    const location = window.location;

    const urlParams = new URLSearchParams(location.search);

    const paramKeys = {
      meetingId: "meetingId",
      token: "token",
      participantId: "participantId",
    };

    Object.keys(paramKeys).forEach((key) => {
      paramKeys[key] = urlParams.get(key)
        ? decodeURIComponent(urlParams.get(key))
        : null;
    });

    return paramKeys;
    //highlight-end
  }, []);
}
```

**`Step 4:`** Now we will initialize the meeting with the parameters we extracted from the URL. Make sure `joinWithoutUserInteraction` is specified, so that the template engine is able to join directly into the meeting, on the page load.

```js title=App.js
function App(){
//highlight-next-line
...

return meetingId && token && participantId ? (
  <div>
    <MeetingProvider
      //highlight-start
      config={{
        meetingId,
        micEnabled: false,
        webcamEnabled: false,
        name: "recorder",
        participantId,
      }}
      token={token}
      joinWithoutUserInteraction
      //highlight-end
    >
      {/* We will create this in upcoming steps */}
      <MeetingContainer />
    </MeetingProvider>
  </div>
) : null;

}
```

**`Step 5:`** Let us create the `MeetingContainer` which will render the meeting view for us.

- It will also listen to the PubSub messages from the `CHANGE_BACKGROUND` topic, which will change the background color of the meeting.
- It will have `Notification` component which will show any messages share by Host

:::note

We will be using the PubSub mechanism to communicate with the template. You can learn more about [PubSub from here](../video-and-audio-calling-api-sdk/collaboration-in-meeting/pubsub).

:::

import CautionMessage from '@site/src/theme/CautionMessage';

<CautionMessage sdk="Android SDK" version="v0.2.0" />

```js title=MeetingContainer.js
import { Constants, useMeeting, usePubSub } from "@videosdk.live/react-sdk";
import { Notification } from "./Notification";
import { ParticipantsAudioPlayer } from "./ParticipantsAudioPlayer";
import { ParticipantView } from "./ParticipantView";

export const MeetingContainer = () => {
  const { isMeetingJoined, participants, localParticipant } = useMeeting();
  //highlight-next-line
  const { messages } = usePubSub("CHANGE_BACKGROUND");

  const remoteSpeakers = [...participants.values()].filter((participant) => {
    return (
      participant.mode == Constants.modes.SEND_AND_RECV && !participant.local
    );
  });

  return isMeetingJoined ? (
    <div
      style={{
        display: "flex",
        flexDirection: "column",
        height: "100vh",
        //highlight-start
        backgroundColor:
          messages.length > 0
            ? messages.at(messages.length - 1).message
            : "#fff",
        //highlight-end
      }}
    >
      //highlight-next-line
      <ParticipantsAudioPlayer />
      <div
        style={{
          display: "grid",
          gridTemplateColumns: remoteSpeakers?.length > 1 ? "1fr 1fr" : "1fr",
          flex: 1,
          maxHeight: `100vh`,
          overflowY: "auto",
          gap: "20px",
          padding: "20px",
          alignItems: "center",
          justifyItems: "center",
        }}
      >
        {[...remoteSpeakers].map((participant) => {
          return (
            //highlight-start
            <ParticipantView
              key={participant.id}
              participantId={participant.id}
            />
            //highlight-end
          );
        })}
      </div>
      //highlight-next-line
      <Notification />
    </div>
  ) : (
    <div
      style={{
        display: "flex",
        justifyContent: "center",
        alignItems: "center",
        height: "100vh",
      }}
    >
      <div class="loader"></div>
    </div>
  );
};
```

**`Step 6:`** Let us create the `ParticipantView` and `ParticipantsAudioPlayer` which will render the video and audio of the participants respectively.

```js title=ParticipantView.js
import { useParticipant } from "@videosdk.live/react-sdk";
import { useMemo } from "react";
import ReactPlayer from "react-player";
import MicOffIcon from "../icons/MicOffIcon";

export const ParticipantView = (props) => {
  const { webcamStream, webcamOn, displayName, micOn } = useParticipant(
    props.participantId
  );

  const videoStream = useMemo(() => {
    if (webcamOn && webcamStream) {
      const mediaStream = new MediaStream();
      mediaStream.addTrack(webcamStream.track);
      return mediaStream;
    }
  }, [webcamStream, webcamOn]);

  return (
    <div
      style={{
        width: "100%",
        height: "400px",
        maxWidth: "600px",
        display: "flex",
        flex: 1,
        alignItems: "center",
        justifyContent: "center",
        position: "relative",
        backgroundColor: "#1A1C22",
        borderRadius: "10px",
        overflow: "hidden",
      }}
      class="video-cover"
    >
      {webcamOn && webcamStream ? (
        <ReactPlayer
          //
          playsinline // extremely crucial prop
          pip={false}
          light={false}
          controls={false}
          muted={true}
          playing={true}
          //
          url={videoStream}
          //
          height={"100%"}
          width={"100%"}
          onError={(err) => {
            console.log(err, "participant video error");
          }}
        />
      ) : (
        <div
          style={{
            fontSize: "50px",
            color: "#fff",
          }}
        >
          {String(displayName).charAt(0).toUpperCase()}
        </div>
      )}
      <div
        style={{
          position: "absolute",
          left: "10px",
          bottom: "10px",
          backgroundColor: "#050A0E",
          color: "#fff",
          padding: "4px",
          borderRadius: "4px",
          alignItems: "center",
          justifyItems: "center",
          display: "flex",
        }}
      >
        {displayName}{" "}
        {!micOn && <MicOffIcon fillcolor="#fff" height="18" width="18" />}
      </div>
    </div>
  );
};
```

```js title=ParticipantsAudioPlayer.js
import { useMeeting, useParticipant } from "@videosdk.live/react-sdk";
import { useEffect, useRef } from "react";

const ParticipantAudio = ({ participantId }) => {
  const { micOn, micStream, isLocal } = useParticipant(participantId);
  const audioPlayer = useRef();

  useEffect(() => {
    if (!isLocal && audioPlayer.current && micOn && micStream) {
      const mediaStream = new MediaStream();
      mediaStream.addTrack(micStream.track);

      audioPlayer.current.srcObject = mediaStream;
      audioPlayer.current.play().catch((err) => {});
    } else {
      audioPlayer.current.srcObject = null;
    }
  }, [micStream, micOn, isLocal, participantId]);

  return <audio autoPlay playsInline controls={false} ref={audioPlayer} />;
};

export const ParticipantsAudioPlayer = () => {
  const mMeeting = useMeeting();

  const participants = mMeeting?.participants;

  return participants ? (
    [...participants.keys()].map((participantId) => (
      <ParticipantAudio
        key={`participant_audio_${participantId}`}
        participantId={participantId}
      />
    ))
  ) : (
    <></>
  );
};
```

**`Step 7:`** Let us create the `Notification` component which will listen to PubSub messages for the topic `SIGNALLING_ONLY_MESSAGE` and show a notification on the lower left corner.

```js title=Notification.js
import { usePubSub } from "@videosdk.live/react-sdk";
import { useEffect, useRef, useState } from "react";

export const Notification = () => {
  const timeoutRef = useRef(null);
  const handleChatMessage = (msg) => {
    if (timeoutRef.current) {
      clearTimeout(timeoutRef.current);
    }
    setMessage(msg);
    timeoutRef.current = setTimeout(() => {
      setMessage(null);
    }, 3200);
  };
  const [message, setMessage] = useState(null);
  const { publish } = usePubSub("SIGNALLING_ONLY_MESSAGE", {
    onMessageReceived: handleChatMessage,
  });
  useEffect(() => {
    return () => {
      if (timeoutRef.current) {
        clearTimeout(timeoutRef.current);
      }
    };
  }, []);
  return message ? (
    <div
      style={{
        backgroundColor: "#232830",
        padding: "10px",
        textAlign: "center",
        color: "#fff",
        position: "absolute",
        bottom: "50px",
        left: "30px",
        borderRadius: "10px",
        animation: "fadein 0.5s",
      }}
    >
      <strong>
        {message.senderName} says {message.message}
      </strong>
    </div>
  ) : null;
};
```

:::note

For the CSS stylings and animations used in the project, please [refer to this file](https://github.com/videosdk-live/quickstart/blob/main/react-custom-template-manager/src/index.css).

:::

**`Step 9:`** Once tested, you can deploy it using your backend or host it on services like [firebase](https://www.geeksforgeeks.org/how-to-deploy-react-project-on-firebase/) or vercel.

:::tip

You can checkout the github repository for sample custom template we just [created here](https://github.com/videosdk-live/videosdk-custom-recording-template-react-example).

:::

### Setup Livestream Using Custom Template

- To use Custom Template, you will need Host and Viewer setup from where the host will start the livestream and viewer can watch them.

![Android Custom Template Example](https://cdn.videosdk.live/website-resources/docs-resources/android_custom_template.png)

- You can clone this example and run it on your system.

```bash
git clone https://github.com/videosdk-live/quickstart.git
```

- The cloned example will contain two directories under the `android-custom-template-manager` directory which has to runned.

  - **For Kotlin** : `Videosdk_android_kotlin_hls_quickstart`
  - **For Java** : `Videosdk_android_java_hls_quickstart`

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
cd android-custom-template-manager
cd Videosdk_android_kotlin_hls_quickstart
```

</TabItem>

<TabItem value="Java">

```js
cd android-custom-template-manager
cd Videosdk_android_java_hls_quickstart
```

</TabItem>

</Tabs>

- To use the custom template which we just deployed, we will call the [Start HLS API](https://docs.videosdk.live/api-reference/realtime-communication/start-hlsStream) instead of the `startHls` method from the `Meeting` class. This code has already been added in the example you cloned.

:::note
`downstreamUrl` is now depecated. Use `playbackHlsUrl` or `livestreamUrl` in place of `downstreamUrl`
:::

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
btnHls!!.setOnClickListener {
  //Update your Custom Template URL here if you have deployed your own, if not deployed you can use this template from our URL.
  //highlight-start
  val templateUrl =
      "https://lab.videosdk.live/react-custom-template-demo?meetingId=" + meeting!!.meetingId + "&token=" + token
  //highlight-end

  val bodyJson = JSONObject()
  JsonUtils.jsonPut(bodyJson, "roomId", meeting!!.meetingId)
  JsonUtils.jsonPut(bodyJson, "templateUrl", templateUrl)

  val config= new JSONObject()
  JsonUtils.jsonPut(config,"orientation","portrait")
  JsonUtils.jsonPut(bodyJson,"config",config)

  AndroidNetworking.post("https://api.videosdk.live/v2/hls/start")
    .addHeaders(
        "Authorization",
        token
    ) //we will pass the token in the Headers
    .addJSONObjectBody(bodyJson)
    .build()
    .getAsJSONObject(object : JSONObjectRequestListener {
        override fun onResponse(response: JSONObject) {
            try {
                Log.d("TAG", "onResponse: $response") // result will have playbackHlsUrl and livestreamUrl
            } catch (e: Exception) {
                e.printStackTrace()
            }
        }
        override fun onError(anError: ANError) {
            anError.printStackTrace()
            Toast.makeText(
                mContext,
                anError.message,
                Toast.LENGTH_SHORT
            ).show()
        }
    })
}
```

</TabItem>

<TabItem value="Java">

```js
btnHls.setOnClickListener(v -> {
  //Update your Custom Template URL here if you have deployed your own, if not deployed you can use this template from our URL.
  //highlight-start
  final String templateUrl =
  "https://lab.videosdk.live/react-custom-template-demo?meetingId=" + meeting.getMeetingId() + "&token=" + token;
  //highlight-end

  JSONObject bodyJson = new JSONObject();
  JsonUtils.jsonPut(bodyJson, "roomId", meeting.getMeetingId());
  JsonUtils.jsonPut(bodyJson, "templateUrl", templateUrl);

  JSONObject config= new JSONObject();
  JsonUtils.jsonPut(config,"orientation","portrait");
  JsonUtils.jsonPut(bodyJson,"config",config);

  AndroidNetworking.post("https://api.videosdk.live/v2/hls/start")
    .addHeaders("Authorization", token) //we will pass the token in the Headers
    .addJSONObjectBody(bodyJson)
    .build()
    .getAsJSONObject(new JSONObjectRequestListener() {
        @Override
        public void onResponse(JSONObject response) {
            try {
                Log.d("TAG", "onResponse: " + response.toString()); // result will have playbackHlsUrl and livestreamUrl
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        @Override
        public void onError(ANError anError) {
            anError.printStackTrace();
            Toast.makeText(mContext, anError.getMessage(), Toast.LENGTH_SHORT).show();
        }
    });
});
```

</TabItem>

</Tabs>

- This example has two option on the Host side which will allow them to change the background and send the messages to the viewer.

- Let's give this example a test run.

import ReactPlayer from 'react-player'

<div style={{textAlign: 'center'}}>

<ReactPlayer autoplay muted loop playing controls url="https://cdn.videosdk.live/website-resources/docs-resources/android_custom_template_video.mp4" height="500px" width={"100%"} />

</div>

### API Reference

The API references for all the methods utilized in this guide are provided below.

- [Start HLS API](/api-reference/realtime-communication/start-hlsStream)
- [onHlsStateChanged](/android/api/sdk-reference/meeting-class/meeting-event-listener-class#onhlsstatechanged)


---

---
title: Display Attendees Count - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: Interactive Livestream features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Display Attendees Count
pagination_label: Display Attendees Count
keywords:
  - Start HLS meeting
  - Stop HLS meeting
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: display-attendees-count
---

# Display Attendees Count - Android

In this guide, we will see how you can display the number of attendees in realtime.

:::note
Before going forward in this guide, do make sure all the attendees join the meeting with mode as `SIGNALLING_ONLY`
:::

- We will get the all the `participants` except local participant using `getParticipants()` method of the the `Meeting` class. With all the participants, we will filter out participants who have joined as a `SIGNALLING_ONLY` and then display that count.

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
private fun showViewerCount() {
    var viewerCount = 1  // start with 1 to count local participant
    val participants = meeting!!.participants
    for (entry: Map.Entry<String, Participant> in participants.entries) {
        val participant = entry.value
        if (participant.mode == "SIGNALLING_ONLY") {
            viewerCount++
        }
    }
    this.viewerCount!!.text = viewerCount.toString()
}
```

</TabItem>

<TabItem value="Java">

```js
private void showViewerCount() {
    int viewerCount = 1; // start with 1 to count local participant
    Map<String, Participant> participants = meeting.getParticipants();
    for (Map.Entry<String, Participant> entry : participants.entrySet()) {
        Participant participant = entry.getValue();
        if (participant.getMode().equals("SIGNALLING_ONLY")) {
            viewerCount++;
        }
    }
    this.viewerCount.setText(String.valueOf(viewerCount));
}
```

</TabItem>

</Tabs>

## API Reference

The API references for all the methods utilized in this guide are provided below.

- [getparticipants()](/android/api/sdk-reference/meeting-class/properties#getparticipants)


---

---
title: Invite Guest on Stage - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: Interactive Livestream features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Invite Guest on Stage
pagination_label: Invite Guest on Stage
keywords:
  - Start HLS meeting
  - Stop HLS meeting
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: invite-guest-on-stage
---

# Invite Guest on Stage - Android

In this guide, we will see how you can request a viewer to join your livestream by using the `changeMode()`.

import CautionMessage from '@site/src/theme/CautionMessage';

<CautionMessage sdk="Android SDK" version="v0.2.0" />

Let's first have a look at how we will be using the `PubSub` mechanism to acheive the requesting and switching of the participant's mode.

![invite-guest-pubsub](https://cdn.videosdk.live/website-resources/docs-resources/invite_guest_pubsub.png)

:::note
Before going forward in this guide, do make sure all the attendees join the meeting with mode as `SIGNALLING_ONLY` and the host joins with mode as `SEND_AND_RECV`
:::

### Step 1: Loading Viewer List

The host will see a list of participants who have joined as `SIGNALLING_ONLY` along with a button that, when selected, will invite that user to join the livestream.

Here we are using `RecyclerView` to display viewer list with button.

```xml title="layout_viewers_list_view.xml"
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical"
    android:background="#2B3034"
    android:id="@+id/layout_participants">

    <TextView
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_gravity="center"
        android:paddingVertical="15sp"
        android:text="Viewer List"
        android:textSize="20sp"
        android:textColor="@color/white"/>

    <androidx.recyclerview.widget.RecyclerView
        android:id="@+id/rvViewersLinearView"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:paddingHorizontal="15sp" />

</LinearLayout>
```

```xml title="item_viewer_list_layout.xml"
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="wrap_content"
    android:layout_marginBottom="10dp"
    android:gravity="center"
    android:orientation="horizontal"
    android:padding="12dp">


    <TextView
        android:id="@+id/viewerName"
        android:layout_width="0dp"
        android:layout_height="wrap_content"
        android:layout_weight="1"
        android:textSize="20sp"
        android:textColor="@color/white"/>

    <Button
        android:id="@+id/btnRequest"
        android:layout_width="0dp"
        android:layout_height="wrap_content"
        android:layout_weight="1"
        android:text="Request to join Stage"
        android:textAllCaps="false" />


</LinearLayout>
```

- Create a recycler view adapter named `ViewerListAdapter` which will show the viewer list. Create `PeerViewHolder` in the adapter which will extend `RecyclerView.ViewHolder`.

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
class ViewerListAdapter(items: ArrayList<Participant?>?, private val meeting: Meeting) :
    RecyclerView.Adapter<ViewerListAdapter.ViewHolder?>() {
    private var viewers = ArrayList<Participant?>()

    init {
      viewers.addAll(items!!)

      //highlight-next-line
      // adding Meeting Event listener to get the participant join/leave and panticipant mode change event in the meeting.
      meeting.addEventListener(object : MeetingEventListener() {
        override fun onParticipantJoined(participant: Participant) {
            super.onParticipantJoined(participant)
            viewers = ArrayList()
            viewers.addAll(allViewers)
            notifyDataSetChanged()
        }

        override fun onParticipantLeft(participant: Participant) {
            super.onParticipantLeft(participant)
            viewers = ArrayList()
            viewers.addAll(allViewers)
            notifyDataSetChanged()
        }

        override fun onParticipantModeChanged(data: JSONObject) {
            viewers = ArrayList()
            viewers.addAll(allViewers)
            notifyDataSetChanged()
        }
      })
    }

    private val allViewers: ArrayList<Participant?>
        private get() {
            val viewerList: ArrayList<Participant?> = ArrayList()
            val participants: Iterator<Participant> = meeting.participants.values.iterator()
            for (i in 0 until meeting.participants.size) {
                val participant = participants.next()
                //highlight-start
                if (participant.mode == "SIGNALLING_ONLY") {
                    viewerList.add(participant)
                }
                //highlight-end
            }
            return viewerList
        }

    override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): ViewHolder {
        return ViewHolder(
            LayoutInflater.from(parent.context)
                .inflate(R.layout.item_viewer_list_layout, parent, false)
        )
    }

    override fun onBindViewHolder(holder: ViewHolder, position: Int) {
        val participant = viewers[position]
        holder.viewerName.text = viewers[position]!!.displayName
    }

    override fun getItemCount(): Int {
        return viewers.size
    }

    class ViewHolder(itemView: View) : RecyclerView.ViewHolder(itemView) {
        var viewerName: TextView
        var btnRequest: Button

        init {
            viewerName = itemView.findViewById(R.id.viewerName)
            btnRequest = itemView.findViewById(R.id.btnRequest)
        }
    }
}
```

</TabItem>

<TabItem value="Java">

```js
public class ViewerListAdapter extends RecyclerView.Adapter<ViewerListAdapter.ViewHolder> {
    private ArrayList<Participant> viewers = new ArrayList<>();
    private Meeting meeting;

    public ViewerListAdapter(ArrayList<Participant> items, Meeting meeting) {
      this.meeting = meeting;
      viewers.addAll(items);

      //highlight-next-line
      // adding Meeting Event listener to get the participant join/leave and panticipant mode change event in the meeting.
      meeting.addEventListener(new MeetingEventListener() {
        @Override
        public void onParticipantJoined(Participant participant) {
            super.onParticipantJoined(participant);
            viewers = new ArrayList<>();
            viewers.addAll(getAllViewers());
            notifyDataSetChanged();
        }

        @Override
        public void onParticipantLeft(Participant participant) {
            super.onParticipantLeft(participant);
            viewers = new ArrayList<>();
            viewers.addAll(getAllViewers());
            notifyDataSetChanged();
        }

        @Override
        public void onParticipantModeChanged(JSONObject data) {
            viewers = new ArrayList<>();
            viewers.addAll(getAllViewers());
            notifyDataSetChanged();
        }
      });

    }

    private ArrayList<Participant> getAllViewers() {
        ArrayList<Participant> viewerList = new ArrayList();
        Iterator<Participant> participants = meeting.getParticipants().values().iterator();

        for (int i = 0; i < meeting.getParticipants().size(); i++) {
            //highlight-start
            final Participant participant = participants.next();
            if (participant.getMode().equals("SIGNALLING_ONLY")) {
                viewerList.add(participant);
            }
            //highlight-end
        }
        return viewerList;
    }

    @NonNull
    @Override
    public ViewHolder onCreateViewHolder(@NonNull ViewGroup parent, int viewType) {
        return new ViewHolder(LayoutInflater.from(parent.getContext()).inflate(R.layout.item_viewer_list_layout, parent, false));
    }

    @Override
    public void onBindViewHolder(@NonNull ViewHolder holder, int position) {
        final Participant participant = viewers.get(position);
        holder.viewerName.setText(viewers.get(position).getDisplayName());
    }

    @Override
    public int getItemCount() {
        return viewers.size();
    }

    static class ViewHolder extends RecyclerView.ViewHolder {
        TextView viewerName;
        Button btnRequest;

        public ViewHolder(@NonNull View itemView) {
            super(itemView);
            viewerName = itemView.findViewById(R.id.viewerName);
            btnRequest = itemView.findViewById(R.id.btnRequest);
        }
    }

}
```

</TabItem>

</Tabs>

- Set this adapter to `RecyclerView`

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
btnViewerList.setOnClickListener { openViewerList() }

fun openViewerList() {
  val viewerListView: RecyclerView
  val bottomSheetDialog = BottomSheetDialog(mContext!!)
  val layout_participants = findViewById(R.id.layout_participants)
  val v3 = LayoutInflater.from(mContext)
      .inflate(R.layout.layout_viewers_list_view, layout_participants)
  bottomSheetDialog.setContentView(v3)
  viewerListView = v3.findViewById(R.id.rvViewersLinearView)
  viewerListView.minimumHeight = 400
  bottomSheetDialog.show()
  val viewerList: ArrayList<*> = ArrayList<Any?>()
  val participants: Iterator<Participant> = meeting!!.participants.values.iterator()
  for (i in 0 until meeting!!.participants.size) {
      val participant = participants.next()
      //highlight-start
      if (participant.mode == "SIGNALLING_ONLY")
        viewerList.add(participant)
      //highlight-end
  }
  viewerListView.layoutManager = LinearLayoutManager(mContext)
  //highlight-next-line
  viewerListView.adapter = ViewerListAdapter(viewerList, meeting!!)
  viewerListView.setHasFixedSize(true)
}
```

</TabItem>

<TabItem value="Java">

```js
btnViewerList.setOnClickListener(v -> openParticipantList());

public void openViewerList() {
  RecyclerView viewerListView;
  BottomSheetDialog bottomSheetDialog = new BottomSheetDialog(mContext);
  LinearLayout layout_participants = findViewById(R.id.layout_participants);
  View v3 = LayoutInflater.from(mContext).inflate(R.layout.layout_viewers_list_view, layout_participants);
  bottomSheetDialog.setContentView(v3);
  viewerListView = v3.findViewById(R.id.rvViewersLinearView);
  viewerListView.setMinimumHeight(400);
  bottomSheetDialog.show();

  ArrayList viewerList = new ArrayList();
  final Iterator<Participant> participants = meeting.getParticipants().values().iterator();
  for (int i = 0; i < meeting.getParticipants().size(); i++) {
      final Participant participant = participants.next();
      //highlight-start
      if (participant.getMode().equals("SIGNALLING_ONLY"))
          viewerList.add(participant);
      //highlight-end
  }
  viewerListView.setLayoutManager(new LinearLayoutManager(mContext));
  //highlight-next-line
  viewerListView.setAdapter(new ViewerListAdapter(viewerList, meeting));
  viewerListView.setHasFixedSize(true);
}

```

</TabItem>

</Tabs>

<center>

<img style={{height: '450px'}} src="https://cdn.videosdk.live/website-resources/docs-resources/android_stage_request.jpg" />

</center>

### Step 2: Requesting a Viewer to Join Livestream

We have a Viewer list ready. Now, let us handle the click event for the `btnRequest`.

We will be using `CHANGE_MODE_ + participantId` as the topic for PubSub.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
override fun onBindViewHolder(holder: ViewHolder, position: Int) {
  //...

  holder.btnRequest.setOnClickListener { v: View? ->
    val pubSubPublishOptions = PubSubPublishOptions()
    pubSubPublishOptions.isPersist = false
    //highlight-start
    meeting.pubSub.publish(
        "CHANGE_MODE_" + participant!!.id,
        participant.id,
        pubSubPublishOptions
    )
    //highlight-end
  }
}
```

</TabItem>

<TabItem value="Java">

```js
@Override
public void onBindViewHolder(@NonNull ViewHolder holder, int position) {
  //...

  holder.btnRequest.setOnClickListener(v -> {
    PubSubPublishOptions pubSubPublishOptions = new PubSubPublishOptions();
    pubSubPublishOptions.setPersist(false);
    //highloght-next-line
    meeting.pubSub.publish("CHANGE_MODE_"+ participant.getId(), participant.getId(), pubSubPublishOptions);
  });
}
```

</TabItem>

</Tabs>

### Step 3: Showing Viewer Request Dialog

After implementing the Host requesting viewer to join the livestream, let's display the viewer's request dialogue and switch the `SIGNALLING_ONLY` mode to `SEND_AND_RECV`.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
meeting!!.addEventListener(object : MeetingEventListener() {
  override fun onMeetingJoined() {
    val changeModeListener =
      PubSubMessageListener { pubSubMessage: PubSubMessage ->
          if (pubSubMessage.message == meeting!!.localParticipant.id) {
              showRequestDialog(pubSubMessage.senderName)
          }
      }
    //highlight-next-line
    meeting!!.pubSub.subscribe("CHANGE_MODE_" + meeting!!.localParticipant.id, changeModeListener)
  }
})

private fun showRequestDialog(name: String) {
    val builder = AlertDialog.Builder(
        mContext!!
    )
    builder.setMessage("$name has request you to go on stage")
    builder.setTitle("Change mode Request")
    builder.setCancelable(false)
    builder.setPositiveButton("Yes") { dialog: DialogInterface, _: Int ->
        //highlight-next-line
        meeting!!.changeMode("SEND_AND_RECV")
        //...
        dialog.dismiss()
    }
    builder.setNegativeButton(
        "No"
    ) { dialog: DialogInterface, which: Int -> dialog.dismiss() }
    val alertDialog = builder.create()
    alertDialog.show()
}

```

</TabItem>

<TabItem value="Java">

```js
meeting.addEventListener(new MeetingEventListener() {
  @Override
  public void onMeetingJoined() {
    PubSubMessageListener changeModeListener = pubSubMessage -> {
        if (pubSubMessage.getMessage().equals(meeting.getLocalParticipant().getId())) {
            showRequestDialog(pubSubMessage.getSenderName());
        }
    };
    //highlight-next-line
    meeting.pubSub.subscribe("CHANGE_MODE_"+ meeting.getLocalParticipant().getId(), changeModeListener);
  }
}

private void showRequestDialog(String name) {
  AlertDialog.Builder builder = new AlertDialog.Builder(mContext);
  builder.setMessage(name + " has request you to go on stage");
  builder.setTitle("Change mode Request");
  builder.setCancelable(false);

  builder.setPositiveButton("Yes", (dialog, which) -> {
      //highlight-next-line
      meeting.changeMode("SEND_AND_RECV");
      //...
      dialog.dismiss();
  });

  builder.setNegativeButton("No", (dialog, which) -> {
      dialog.dismiss();
  });

  AlertDialog alertDialog = builder.create();
  alertDialog.show();
}
```

</TabItem>

</Tabs>

<center>

<img style={{height: '450px'}} src="https://cdn.videosdk.live/website-resources/docs-resources/android_stage_request_dialog.jpg" />

</center>

### Step 4: Pin the participant

We need to pin the participant so that he/she can appears on the livestream. To achieve this, we will listen to the callback on the `onParticipantModeChanged` of `Meeting` class.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
class ParticipantListAdapter(
    items: ArrayList<Participant?>?,
    private val meeting: Meeting,
    private val context: Context
) : RecyclerView.Adapter<ParticipantListAdapter.ViewHolder>() {
  // ...

 init {
    //...
    meeting.addEventListener(object : MeetingEventListener() {
      override fun onParticipantJoined(participant: Participant) {
          //...
      }

      override fun onParticipantLeft(participant: Participant) {
         // ...
      }

      //highlight-start
      override fun onParticipantModeChanged(data: JSONObject) {
        //...
         val participant = meeting.participants[data.getString("participantId")]
          if (data.getString("mode") == "SEND_AND_RECV") {
              participant!!.pin("SHARE_AND_CAM")
          } else {
              participant!!.unpin("SHARE_AND_CAM")
          }
      }
      //highlight-end
    })
  }

  //...
  class ViewHolder(itemView: View) : RecyclerView.ViewHolder(itemView) {
      //...
  }
}
```

</TabItem>

<TabItem value="Java">

```js
public class ParticipantListAdapter extends RecyclerView.Adapter<ParticipantListAdapter.ViewHolder> {
    // ...

  public ParticipantListAdapter(ArrayList<Participant> items, Meeting meeting, Context context) {
    //...
    meeting.addEventListener(new MeetingEventListener() {
      @Override
      public void onParticipantJoined(Participant participant) {
        //...
      }

      @Override
      public void onParticipantLeft(Participant participant) {
        //...
      }

      //highlight-start
      @Override
      public void onParticipantModeChanged(JSONObject data) {
        //...
        Participant participant = meeting.getParticipants().get(data.getString("participantId"));
        if (data.getString("mode").equals("SEND_AND_RECV"))
        {
          participant.pin("SHARE_AND_CAM");
        }else
        {
          participant.unpin("SHARE_AND_CAM");
        }
      }
      //highlight-end
    });

  }

  //...
  static class ViewHolder extends RecyclerView.ViewHolder {
      //...
  }
}
```

</TabItem>

</Tabs>

import ReactPlayer from 'react-player'

<div style={{textAlign: 'center'}}>

<ReactPlayer muted controls url="https://cdn.videosdk.live/website-resources/docs-resources/android_stage_request_demo.mp4" height="500px" width={"100%"} />

</div>

<br/>

## API Reference

The API references for all the methods utilized in this guide are provided below.

- [Meeting](/android/api/sdk-reference/meeting-class/introduction)
- [pubSub](/android/guide/video-and-audio-calling-api-sdk/collaboration-in-meeting/pubsub)
- [onParticipantModeChanged()](/android/api/sdk-reference/meeting-class/meeting-event-listener-class#onparticipantmodechanged)


---

---
title: Manage On-Screen Participants - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: Interactive Livestream features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Manage On-Screen Participants
pagination_label: Manage On-Screen Participants
keywords:
  - Start HLS meeting
  - Stop HLS meeting
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: manage-on-screen-participants
---

# Manage On-Screen Participants - Android

It is important that only the necessary person are present on the screen when livestream is on. To handle this, we will be using the `pin` and `unpin` methods of the `Participant` class.

:::note
To ensure only the hosts/speakers are shown in the grid, you should use the `SPOTLIGHT` layout and `pin` as the priority when starting the interactive livestream.
:::

Let us first explore two methods that we will be using to manage on-screen participants.

### `pin()`

With these method you can pin any participant's Camera, Screen Share or both. This can be useful to identify the participants based on which you can perform rendering participant grid.

### `unpin()`

With these methods you can unpin any participant's Camera, Screen Share or both. This can be useful to reset pin state of the participant.

import CautionMessage from '@site/src/theme/CautionMessage';


<CautionMessage sdk="Android SDK" version="v0.2.0" />

### Managing On-Screen Participants

1. If you want to pin all the hosts/speakers automatically, you can do it by listenting to the `onMeetingJoined` callback and `onParticipantModeChanged`, where you can `pin` and `unpin` based on the mode.

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
private val meetingEventListener: MeetingEventListener = object : MeetingEventListener() {
  override fun onMeetingJoined() {
        //highlight-start
        val localParticipant = meeting!!.localParticipant
        //We will pin the participant if mode is SEND_AND_RECV
        if (localParticipant.mode == "SEND_AND_RECV") {
            localParticipant.pin()
        } else {
            localParticipant.unpin()
        }
        //highlight-end
   }

  override fun onParticipantModeChanged(data: JSONObject) {
    //highlight-start
    val localParticipant = meeting!!.localParticipant
    //We will pin the participant if mode is SEND_AND_RECV else unpin him
    if(localParticipant.id.equals(data.getString("peerId"))
    {
        if(localParticipant.mode == "SEND_AND_RECV")
        {
            localParticipant.pin()
        }else{
            localParticipant.unpin()
        }
    }
    //highlight-end
  }
}

override fun onCreate(savedInstanceState: Bundle?) {
  //...

  // add listener to meeting
  //highlight-next-line
  meeting!!.addEventListener(meetingEventListener)
}
```

</TabItem>

<TabItem value="Java">

```js
private final MeetingEventListener meetingEventListener = new MeetingEventListener() {
  @Override
  public void onMeetingJoined() {
    //highlight-start
    Participant localParticipant = meeting.getLocalParticipant();
    //We will pin the participant if mode is SEND_AND_RECV
    if (localParticipant.getMode() == "SEND_AND_RECV") {
        localParticipant.pin();
    } else {
        localParticipant.unpin();
    }
    //highlight-end
  }

  @Override
  public void onParticipantModeChanged(JSONObject data) {
    //highlight-start
    Participant localParticipant = meeting.getLocalParticipant();
    //We will pin the participant if mode is SEND_AND_RECV else unpin him
    if(localParticipant.getId().equals(data.getString("peerId"))
    {
        if(localParticipant.getMode() == "SEND_AND_RECV")
        {
            localParticipant.pin();
        }else{
            localParticipant.unpin();
        }
    }
    //highlight-end
  }
};

@Override
protected void onCreate(Bundle savedInstanceState) {
  //...

  // add listener to meeting
  //highlight-next-line
  meeting.addEventListener(meetingEventListener);
}
```

</TabItem>

</Tabs>

2. When rendering the participant grid on the Speaker side, make sure to show only the participants who are in `SEND_AND_RECV` mode. You can filter the participants as shown in below example.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
 private fun getSpeakerList(): List<Participant?>? {
    val speakerList: MutableList<Participant?> = ArrayList()
    val participants = meeting!!.participants
    for (entry: Map.Entry<String, Participant> in participants.entries) {
        val participant = entry.value
        if (participant.mode == "SEND_AND_RECV") {
            speakerList.add(participant)
        }
    }
    return speakerList
}
```

</TabItem>

<TabItem value="Java">

```js
private List<Participant> getSpeakerList() {
    List<Participant> speakerList = new ArrayList();
    Map<String, Participant> participants = meeting.getParticipants();
    for (Map.Entry<String, Participant> entry : participants.entrySet()) {
        Participant participant = entry.getValue();
        if (participant.getMode().equals("SEND_AND_RECV")) {
            speakerList.add(participant);
        }
    }
    return speakerList;
}
```

</TabItem>

</Tabs>

## API Reference

The API references for all the methods utilized in this guide are provided below.

- [pin](/android/api/sdk-reference/participant-class/methods#pin)
- [unpin](/android/api/sdk-reference/participant-class/methods#unpin)


---

---
title: Manage Roles - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: Interactive Livestream features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Manage Roles
pagination_label: Manage Roles
keywords:
  - Start HLS meeting
  - Stop HLS meeting
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: manage-roles
---

# Manage Roles - Android

## Roles with VideoSDK

When doing interactive live streaming maintaining the role of users is quite important. To help manage these roles better, VideoSDK allows a participant with two types of modes:

**`1. SEND_AND_RECV`** When a participant is joining with mode set to `SEND_AND_RECV`, we will be able to **publish and consume the media** of other participants and also interact with them using the features like chat, poll etc.

**`2. SIGNALLING_ONLY`** When a participant is joining with mode set to `SIGNALLING_ONLY`, that participant is **not allowed to publish or consume any media** from other participants. Although they can interact with other participants using chat, polls etc.

import CautionMessage from '@site/src/theme/CautionMessage';


<CautionMessage sdk="Android SDK" version="v0.2.0" />

**_This image is for education purpose_**

![manage-roles](https://cdn.videosdk.live/website-resources/docs-resources/meeting_modes.jpg)

## When to use the Roles?

##### 1. Simple Adaptive Streaming

- Simple Adaptive Streaming (SAS) is a type of livestreaming that requires minimal interaction between the host and viewers.

- It is particularly useful for events with a large number of viewers who prefer not to engage with the host.

- In SAS, each speaker attends a VideoSDK meeting in `SEND_AND_RECV` mode, while viewers can simply watch the livestream using the `playbackHlsUrl` or `livestreamUrl`. Unlike the speakers, viewers do not need to join the meeting in `SEND_AND_RECV` or `SIGNALLING_ONLY` mode. This allows for a seamless streaming experience without any unnecessary interruptions or distractions.
  - `playbackHlsUrl` - Live HLS with playback support
  - `livestreamUrl` - Live HLS without playback support

:::note
`downstreamUrl` is now depecated. Use `playbackHlsUrl` or `livestreamUrl` in place of `downstreamUrl`
:::

**_This video is for education purpose_**

import ReactPlayer from 'react-player'

<div style={{textAlign: 'center'}}>

<ReactPlayer autoplay muted loop playing controls url="https://cdn.videosdk.live/website-resources/docs-resources/react_simple_ils.mp4" height="500px" width={"100%"} />

</div>

##### 2. Adaptive Streaming with increased engagement

- If you're looking to increase engagement with your audience during a live streaming event, consider using Adaptive Streaming technology. With this approach, you can incorporate interactive features such as polls and conversations, and give viewers the ability to join and leave the livestream as the host decides.

- To set this up, have all speakers join as `SEND_AND_RECV` mode participants, while the audience joins as `SIGNALLING_ONLY` mode participants. This way, everyone can participate in the interactive elements of the live stream and create a more dynamic and engaging experience for all.

**_This video is for education purpose_**

<div style={{textAlign: 'center'}}>

<ReactPlayer autoplay muted loop playing controls url="https://cdn.videosdk.live/website-resources/docs-resources/react_livestream_interaction_1.mp4" height="500px" width={"100%"} />

</div>

## Using roles

When you initialize the meeting, you can set the mode of Participant.

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
class MainActivity : AppCompatActivity() {

  fun getToken(): String? {
    //highlight-next-line
    ...
  }

  fun getMeetingId(token: String?): String? {
    //highlight-next-line
    ...
  }

 override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    setContentView(R.layout.activity_main)

    //We will fetch token and meetingId and store it in local variables
    val token: String = getToken()
    val meetingId = getMeetingId(token)

    // initialize the VideoSDK
    VideoSDK.initialize(this@MainActivity)

    // set token property of VideoSDK
    VideoSDK.config(token)

    // highlight-start
    // create a new meeting instance
    val meeting: Meeting = VideoSDK.initMeeting(
        this@MainActivity, meetingId, "NAME HERE",
        true, true, null,
        //highlight-next-line
        "SEND_AND_RECV", // allowed: SEND_AND_RECV | SIGNALLING_ONLY | RECV_ONLY
        false,
        null,
        null
    )
    // highlight-end

    Log.d("VideoSDK", "onCreate: $meetingId")
  }
}
```

</TabItem>

<TabItem value="Java">

```java
public class MainActivity extends AppCompatActivity {

  public String getToken()
  {
    //highlight-next-line
    ...
  }

  public String getMeetingId(String token) {
    //highlight-next-line
    ...
  }

  @Override
  protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);

    //We will fetch token and meetingId and store it in local variables
    String token = getToken();
    String meetingId = getMeetingId(token);

    // initialize the VideoSDK
    VideoSDK.initialize(MainActivity.this);

    // set token property of VideoSDK
    VideoSDK.config(token);

    // highlight-start
    // create a new meeting instance
    Meeting meeting = VideoSDK.initMeeting(
            MainActivity.this, meetingId, "NAME HERE",
            true, true, null,
            //highlight-next-line
            "SEND_AND_RECV", // allowed: SEND_AND_RECV | SIGNALLING_ONLY | RECV_ONLY
            false,
            null,
            null,
    );
    // highlight-end

    Log.d("VideoSDK", "onCreate: " + meetingId);
  }
}
```

</TabItem>

</Tabs>

## Getting Participant Mode

You can identify the participants role by using `mode` property from `Participant` class.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
override fun onCreate(savedInstanceState: Bundle?) {
  //...

  val localParticipant = meeting!!.localParticipant
  //highlight-next-line
  Log.d("VideoSDK", "Participant mode : " + localParticipant.mode)
}
```

</TabItem>

<TabItem value="Java">

```js
@Override
protected void onCreate(Bundle savedInstanceState) {
  //...

  Participant localParticipant = meeting.getLocalParticipant();
  //highlight-next-line
  Log.d("VideoSDK", "Participant mode : " + participant.getMode());
}
```

</TabItem>

</Tabs>

## Changing Participant's Mode

Let's say you are hosting a livestream and you want one of your viewer to join the livestream with you. In this case you can change the mode of the participant using the `changeMode()` of the `Meeting` class.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
findViewById<View>(R.id.btnConferenceMode).setOnClickListener { view: View? ->
    // change mode to SEND_AND_RECV
    //highlight-next-line
    meeting!!.changeMode("SEND_AND_RECV")
}

findViewById<View>(R.id.btnViewerMode).setOnClickListener { view: View? ->
    // change mode to SIGNALLING_ONLY
    //highlight-next-line
    meeting!!.changeMode("SIGNALLING_ONLY")
}
```

</TabItem>

<TabItem value="Java">

```js
findViewById(R.id.btnConferenceMode).setOnClickListener(view -> {
    // change mode to SEND_AND_RECV
    //highlight-next-line
    meeting.changeMode("SEND_AND_RECV");
});

findViewById(R.id.btnViewerMode).setOnClickListener(view -> {
    // change mode to SIGNALLING_ONLY
    //highlight-next-line
   meeting.changeMode("SIGNALLING_ONLY");
});
```

</TabItem>

</Tabs>

## API Reference

The API references for all the methods utilized in this guide are provided below.

- [Meeting](/android/api/sdk-reference/meeting-class/introduction)
- [Participant](/android/api/sdk-reference/participant-class/introduction)
- [changeMode()](/android/api/sdk-reference/meeting-class/methods#changemode)


---

---
title: Interactive Livestream - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: Interactive Livestream features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Overview
pagination_label: Overview
keywords:
  - Start HLS meeting
  - Stop HLS meeting
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: overview
---

# Interactive Livestream (HLS) - Android

### What is Interactive Livestream (HLS)?

Interactive live streaming (HLS) refers to a type of live streaming where viewers can actively engage with the content being streamed and with other viewers in real-time.

In an interactive live stream (HLS), viewers can take part in a variety of activities like live polling, Q&A sessions, and even sending virtual gifts to the content creator or each other.

### What is Adaptive Live Streaming?

Livestream experience is important while undertaking interactive live streaming in order to increase audience. To do this, the livestream should be able to respond to the viewer's network bandwidth, and change the stream's resolution as necessary. Therefore, adaptive live streaming refers to a feed that automatically adjusts to a lower or higher resolution dependent on the user's preferences.

### What is Latency?

Latency is the delay between capturing video content and its playback. Key factors that affecting latency :

- **Buffering**: Balance buffer size for smoother playback against latency.
- **Network Conditions**: Efficient servers and network health contribute to lower latency.

Standard HLS has a latency around 5-6 seconds.

### HLS Architecture of VideoSDK

<center>

<img src='https://cdn.videosdk.live/website-resources/docs-resources/mobile_hls.png' />

</center>

When a host starts the interactive live stream, VideoSDK will use a default theme or user specified template to compose and encode a live stream which will be delivered to the viewers through a `M3U8` video file which can be played directly on the viewer end which will adapt to the viewer's network bandwidth.

When using VideoSDK for interactive live stream, you get multiple types of URLs which you can use based on your requirements.

**`1. Standard Streaming:`** This type of streaming is where the user is not allowed to go back in the live and can just stream it.

**`2. Rolling Playback:`** This type of streaming is where the user is allowed to do rewind and do a playback of the complete stream.

**`3. VoD Playback`** With this, users can playback the complete live stream on demand whenever needed.

### Using HLS with VideoSDK

You can use HLS with VideoSDK in two different ways.

#### 1. Simple Adaptive Streaming

When we talk about simple adaptive streaming, we imply that there is hardly any interaction between the hosts and the viewers.

These livestreams are helpful when there are a lot of viewers, and they don't want to engage with the host. In this scenario, every presenter attends a VideoSDK meeting, while every viewer only watches the livestream.

**_This video is for education purpose_**

import ReactPlayer from 'react-player'

<div style={{textAlign: 'center'}}>

<ReactPlayer autoplay muted loop playing controls url="https://cdn.videosdk.live/website-resources/docs-resources/react_simple_ils.mp4" height="500px" width={"100%"} />

</div>

#### 2. Adaptive Streaming with increased engagement

When you want to communicate with your audience by enabling polls, conversations, and the ability for viewers to join and leave the livestream based on the host's decision, adaptive streaming with enhanced engagement will be the best fit for you.

In this scenario, both the host and the viewer will have to join a VideoSDK meeting with different roles. To learn more about the roles [follow these guide.](../handling-participants/manage-roles)

**_This video is for education purpose_**

<div style={{textAlign: 'center'}}>

<ReactPlayer autoplay muted loop playing controls url="https://cdn.videosdk.live/website-resources/docs-resources/react_livestream_interaction_2.mp4" height="500px" width={"100%"} />

</div>


---

---
title: Setup HLS Player | Video SDK
hide_title: true
hide_table_of_contents: false
description: Using VideoSDK to do the interactive livestreaming.
sidebar_label: Setup HLS Player
pagination_label: Setup HLS Player
keywords:
  - audio calling
  - video calling
  - real-time communication
  - interactive live streaming
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: setup-hls-player
---

# Setup HLS Player - Android

In this guide, we will add player which will be responsible for playing the HLS stream.
Before starting this guide, make sure you have a VideoSDK meetings setup allowing you to join the room. To learn more about setting up a VideoSDK meeting, follow this [quick start guide](/android/guide/video-and-audio-calling-api-sdk/quick-start).

To play the HLS stream we will be using the [Exoplayer](https://github.com/google/ExoPlayer) library.

### `1. Setup player into your project`

**`Step 1:`** Let's first add ExoPlayer module dependency into the project.

```js title="app/build.gradle"
dependencies {
  implementation 'com.google.android.exoplayer:exoplayer:2.18.5'
  // other app dependencies
  }
```

**`Step 2:`** Now let's add the `StyledPlayerView` which will display livestreaming. And also add the `TextView` which will be shown when there is no active HLS. For these, we will use the `onHlsStateChanged` event from the `MeetingEventListener` abstract class to identify if there is an active HLS.

```xml title="activity_viewer.xml"
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent">

    <TextView
        android:id="@+id/waitingLayout"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:text="Waiting for host \n to start the live streaming"
        android:textFontWeight="700"
        android:textSize="20sp"
        android:gravity="center"/>

    <com.google.android.exoplayer2.ui.StyledPlayerView
        android:id="@+id/player_view"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:visibility="gone"
        app:resize_mode="fixed_width"
        app:show_buffering="when_playing"
        app:show_subtitle_button="false"
        app:use_artwork="false"
        app:show_next_button="false"
        app:show_previous_button="false"
        app:use_controller="true"/>

</LinearLayout>
```

### `2. Initialize player and Playing HLS stream`

**`Step 1:`** Now that player is setup, let's initialize player and play the HLS once it becomes playable. For these, we will get the `playbackHlsUrl` and `livestreamUrl` when the `onHlsStateChanged` event of `MeetingEventListener` state changes to `HLS_PLAYABLE`.

- when you receive `HLS_PLAYABLE` status you will receive 2 urls
  - `playbackHlsUrl` - Live HLS with playback support
  - `livestreamUrl` - Live HLS without playback support

:::note
`downstreamUrl` is now depecated. Use `playbackHlsUrl` or `livestreamUrl` in place of `downstreamUrl`
:::

**`Step 2:`** We also need to release player and show `TextView` which shows there is no active HLS. We will release player when the `onHlsStateChanged` event of `MeetingEventListener` state changes to `HLS_STOPPED`.

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js title="ViewerActivity.kt"
class ViewerActivity : AppCompatActivity() {
    private val meeting: Meeting? = null
    private var playerView: StyledPlayerView? = null
    private var waitingLayout: TextView? = null
    private var player: ExoPlayer? = null
    private var dataSourceFactory: DefaultHttpDataSource.Factory? = null
    private val startAutoPlay = true
    private var playbackHlsUrl: String? = ""


    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_meeting)
        playerView = findViewById(R.id.player_view)
        waitingLayout = findViewById(R.id.waitingLayout)

        // setup meeting
        //...

        //highlight-next-line
        // add listener to the meeting
        meeting!!.addEventListener(meetingEventListener)
    }

    private val meetingEventListener: MeetingEventListener = object : MeetingEventListener() {
        override fun onMeetingJoined() {
            Log.d("VideoSDK", "onMeetingJoined: ")
        }

        override fun onMeetingLeft() {
            Log.d("VideoSDK", "onMeetingLeft: ")
        }

        //highlight-start
        @RequiresApi(api = Build.VERSION_CODES.P)
        override fun onHlsStateChanged(HlsState: JSONObject) {
            if (HlsState.has("status")) {
                try {
                    if (HlsState.getString("status") == "HLS_PLAYABLE" && HlsState.has("playbackHlsUrl")) {
                        playbackHlsUrl = HlsState.getString("playbackHlsUrl")
                        waitingLayout!!.visibility = View.GONE
                        playerView!!.visibility = View.VISIBLE
                        // initialize player
                        initializePlayer()
                    }
                    if (HlsState.getString("status") == "HLS_STOPPED") {
                        // release the player
                        releasePlayer()
                        playbackHlsUrl = null
                        waitingLayout!!.text = "Host has stopped \n the live streaming"
                        waitingLayout!!.visibility = View.VISIBLE
                        playerView!!.visibility = View.GONE
                    }
                } catch (e: JSONException) {
                    e.printStackTrace()
                }
            }
            //highlight-end
        }
    }

    private fun initializePlayer() {
        if (player == null) {
            dataSourceFactory = DefaultHttpDataSource.Factory()
            val mediaSource = HlsMediaSource.Factory(dataSourceFactory!!).createMediaSource(
                MediaItem.fromUri(Uri.parse(playbackHlsUrl))
            )
            val playerBuilder = ExoPlayer.Builder( /* context= */this@ViewerActivity)
            player = playerBuilder.build()
            // auto play when player is ready
            player!!.playWhenReady = startAutoPlay
            player!!.setMediaSource(mediaSource)
            // if you want display setting for player then remove this line
            playerView!!.findViewById<View>(com.google.android.exoplayer2.ui.R.id.exo_settings).visibility =
                View.GONE
            playerView!!.player = player
        }
        player!!.prepare()
    }

    private fun releasePlayer() {
        if (player != null) {
            player!!.release()
            player = null
            dataSourceFactory = null
            playerView!!.player = null
        }
    }
}
```

</TabItem>

<TabItem value="Java">

```java title="ViewerFragment.java"
public class ViewerActivity extends AppCompatActivity {
    private Meeting meeting;
    protected StyledPlayerView playerView;
    private TextView waitingLayout;
    protected @Nullable
    ExoPlayer player;

    private DefaultHttpDataSource.Factory dataSourceFactory;
    private boolean startAutoPlay = true;
    private String playbackHlsUrl = "";

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_meeting);
        playerView = findViewById(R.id.player_view);
        waitingLayout = findViewById(R.id.waitingLayout);

        // setup meeting
        //...

        //highlight-next-line
        // add listener to the meeting
        meeting.addEventListener(meetingEventListener);
    }

    private final MeetingEventListener meetingEventListener = new MeetingEventListener() {
        @Override
        public void onMeetingJoined() {
            Log.d("VideoSDK", "onMeetingJoined: ");
        }

        @Override
        public void onMeetingLeft() {
            Log.d("VideoSDK", "onMeetingLeft: ");
        }

        //highlight-start
        @RequiresApi(api = Build.VERSION_CODES.P)
        @Override
        public void onHlsStateChanged(JSONObject HlsState) {
            if (HlsState.has("status")) {
                try {
                    if (HlsState.getString("status").equals("HLS_PLAYABLE") && HlsState.has("playbackHlsUrl")) {
                        playbackHlsUrl = HlsState.getString("playbackHlsUrl");
                        waitingLayout.setVisibility(View.GONE);
                        playerView.setVisibility(View.VISIBLE);
                        // initialize player
                        initializePlayer();
                    }
                    if (HlsState.getString("status").equals("HLS_STOPPED")) {
                        // release the player
                        releasePlayer();
                        playbackHlsUrl = null;
                        waitingLayout.setText("Host has stopped \n the live streaming");
                        waitingLayout.setVisibility(View.VISIBLE);
                        playerView.setVisibility(View.GONE);
                    }
                } catch (JSONException e) {
                    e.printStackTrace();
                }
            }
            //highlight-end
        }
    };

    protected void initializePlayer() {
        if (player == null) {
            dataSourceFactory = new DefaultHttpDataSource.Factory();
            HlsMediaSource mediaSource = new HlsMediaSource.Factory(dataSourceFactory).createMediaSource(
                    MediaItem.fromUri(Uri.parse(this.playbackHlsUrl)));

            ExoPlayer.Builder playerBuilder =
                    new ExoPlayer.Builder(/* context= */ ViewerActivity.this);
            player = playerBuilder.build();
            // auto play when player is ready
            player.setPlayWhenReady(startAutoPlay);
            player.setMediaSource(mediaSource);
            // if you want display setting for player then remove this line
            playerView.findViewById(com.google.android.exoplayer2.ui.R.id.exo_settings).setVisibility(View.GONE);
            playerView.setPlayer(player);
        }
        player.prepare();
    }

    protected void releasePlayer() {
        if (player != null) {
            player.release();
            player = null;
            dataSourceFactory = null;
            playerView.setPlayer(/* player= */ null);
        }
    }
}
```

</TabItem>

</Tabs>

With this, the player is setup to play the HLS.

<center>

<img style={{height: '450px',marginRight:'15px'}} src="https://cdn.videosdk.live/website-resources/docs-resources/android_ils_quickstart_viewer_screen_waiting.jpg" />

<img style={{height: '450px'}} src="https://cdn.videosdk.live/website-resources/docs-resources/android_ils_quickstart_viewer_screen.jpg" />

</center>

## API Reference

The API references for all the methods utilized in this guide are provided below.

- [onHlsStateChanged](/android/api/sdk-reference/meeting-class/meeting-event-listener-class#onhlsstatechanged)


---

---
title: Start HLS | Video SDK
hide_title: true
hide_table_of_contents: false
description: Using VideoSDK to do the interactive livestreaming.
sidebar_label: Start HLS
pagination_label: Start HLS
keywords:
  - audio calling
  - video calling
  - real-time communication
  - interactive live streaming
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: start-hls
---

# Start HLS - Android

Before starting the HLS, the prequisite steps require you to have a VideoSDK Meeting running which you want to use for interactive livestream. To learn more about setting up a interactive live streaming, you can follow the steps [here in the quick start guide.](/android/guide/video-and-audio-calling-api-sdk/quick-start-ILS)

## Starting HLS

Once the user has joined the meeting, `startHls()` can be used to start a interactive livestream of the meeting which can be accessed from the `Meeting` class. This method accepts one parameter:

- `config`: This parameter will define how the interactive livestream layout should look like.

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
val config = JSONObject()

//highlight-next-line
// Layout Configuration
val layout = JSONObject()
JsonUtils.jsonPut(layout, "type", "GRID") // "SPOTLIGHT" | "SIDEBAR",  Default : "GRID"
JsonUtils.jsonPut(layout, "priority", "SPEAKER") // "PIN", Default : "SPEAKER"
JsonUtils.jsonPut(layout, "gridSize", 4) // MAX : 25
JsonUtils.jsonPut(config, "layout", layout)

//highlight-next-line
// Theme of interactive livestream layout
JsonUtils.jsonPut(config, "theme", "DARK") //  "LIGHT" | "DEFAULT"

//highlight-next-line
// `mode` is used to either interactive livestream video & audio both or only audio.
JsonUtils.jsonPut(config, "mode", "video-and-audio") // "audio", Default : "video-and-audio"

//highlight-next-line
// Quality of interactive livestream and is only applicable to `video-and-audio` type mode.
JsonUtils.jsonPut(config, "quality", "high") // "low" | "med",  Default : "med"

//highlight-start
// This mode refers to orientation of interactive livestream.
// landscape : Start interactive livestream of the meeting in horizontally
// portrait : Start interactive livestream of the meeting in vertically (Best for mobile view)
//highlight-end
JsonUtils.jsonPut(config, "orientation", "portrait") // "landscape",  Default : "landscape"

meeting!!.startHls(config)
```

</TabItem>

<TabItem value="Java">

```js
JSONObject config = new JSONObject();

//highlight-next-line
// Layout Configuration
JSONObject layout = new JSONObject();
JsonUtils.jsonPut(layout, "type", "GRID"); // "SPOTLIGHT" | "SIDEBAR",  Default : "GRID"
JsonUtils.jsonPut(layout, "priority", "SPEAKER");  // "PIN", Default : "SPEAKER"
JsonUtils.jsonPut(layout, "gridSize", 4); // MAX : 25
JsonUtils.jsonPut(config, "layout", layout);

//highlight-next-line
// Theme of interactive livestream layout
JsonUtils.jsonPut(config, "theme", "DARK"); //  "LIGHT" | "DEFAULT"

//highlight-next-line
// `mode` is used to either interactive livestream video & audio both or only audio.
JsonUtils.jsonPut(config, "mode", "video-and-audio"); // "audio", Default : "video-and-audio"

//highlight-next-line
// Quality of interactive livestream and is only applicable to `video-and-audio` type mode.
JsonUtils.jsonPut(config, "quality", "high"); // "low" | "med",  Default : "med"

//highlight-start
// This mode refers to orientation of interactive livestream.
// landscape : Start interactive livestream of the meeting in horizontally
// portrait : Start interactive livestream of the meeting in vertically (Best for mobile view)
//highlight-end
JsonUtils.jsonPut(config, "orientation", "portrait"); // "landscape",  Default : "landscape"

meeting.startHls(config);
```

</TabItem>

</Tabs>

:::note
If you want only the SEND_AND_RECV participants to be seen in the livestream, you can `pin` all the participants in the SEND_AND_RECV mode and start the livestream with the `SPOTLIGHT` layout and `pin` as the `PRIORITY`.

Deprecated: Use SEND_AND_RECV instead of CONFERENCE
:::

### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
// keep track of hls
findViewById<View>(R.id.btnStartHls).setOnClickListener { view: View? ->
    //highlight-start
    val config = JSONObject()
    val layout = JSONObject()
    JsonUtils.jsonPut(layout, "type", "SPOTLIGHT")
    JsonUtils.jsonPut(layout, "priority", "PRIORITY")
    JsonUtils.jsonPut(layout, "gridSize", 4)
    JsonUtils.jsonPut(config, "layout", layout)
    JsonUtils.jsonPut(config, "theme", "DARK")
    JsonUtils.jsonPut(config, "mode", "video-and-audio")
    JsonUtils.jsonPut(config, "quality", "high")
    JsonUtils.jsonPut(config, "orientation", "portrait")
    //highlight-end

    // Start Hls
    //highlight-next-line
    meeting!!.startHls(config)
}
```

</TabItem>

<TabItem value="Java">

```js
findViewById(R.id.btnStartHls).setOnClickListener(view -> {
    //highlight-start
    JSONObject config = new JSONObject();
    JSONObject layout = new JSONObject();
    JsonUtils.jsonPut(layout, "type", "SPOTLIGHT");
    JsonUtils.jsonPut(layout, "priority", "PRIORITY");
    JsonUtils.jsonPut(layout, "gridSize", 4);
    JsonUtils.jsonPut(config, "layout", layout);
    JsonUtils.jsonPut(config, "theme", "DARK");
    JsonUtils.jsonPut(config, "mode", "video-and-audio");
    JsonUtils.jsonPut(config, "quality", "high");
    JsonUtils.jsonPut(config, "orientation", "portrait");
    //highlight-end

    // Start Hls
    //highlight-next-line
    meeting.startHls(config);
});
```

</TabItem>

</Tabs>

## Understanding Layouts

##### 1. GRID Layout

This layout is default layout if no participants are pinned, it will look same as a normal meeting grid layout, when any participant is pinned that participant will be moved on top of the main screen grid above all non pinned participants

While screenshare as well the main view will contain only screenshare media but the side panel view of participant grid will maintain same order of pinned and unpinned participants.

|                       Grid                        |                     Grid with Screenshare                     |
| :-----------------------------------------------: | :-----------------------------------------------------------: |
| ![prebuilt-grid](/img/prebuilt/prebuilt-grid.png) | ![prebuilt-grid-share](/img/prebuilt/prebuilt-grid-share.png) |

##### 2. SIDEBAR Layout

This layout will have one main screen view and other sidebar grid layout. Only pinned participant will be visible in this layout, all unpinned participants will not be visible in this layout. If more than one participant is pinned then the first participant who was pinned will appear in main screen layout and all other remaining pinned particiapants will be visible in sidebar.

If any pinned participant started screenshare then the screenshare media will be visible in main screen layout and all other pinned participants webcam view will be visible in sidebar

|                         Sidebar                         |                      Sidebar with Screenshare                       |
| :-----------------------------------------------------: | :-----------------------------------------------------------------: |
| ![prebuilt-sidebar](/img/prebuilt/prebuilt-sidebar.png) | ![prebuilt-sidebar-share](/img/prebuilt/prebuilt-sidebar-share.png) |

##### 3. SPOTLIGHT Layout

This layout will only contain main screen layout, multiple pinned participants will be visible in main screen view. Same as `SIDEBAR` layout only pinned participants will be visible in main screen.

If any pinned participant started screenshare then only screenshare view will be visible in main screen, no webcam view will be visible when any pinned participant started screenshare.

|                          Spotlight                          |                       Spotlight with Screenshare                        |
| :---------------------------------------------------------: | :---------------------------------------------------------------------: |
| ![prebuilt-spotlight](/img/prebuilt/prebuilt-spotlight.png) | ![prebuilt-spotlight-share](/img/prebuilt/prebuilt-spotlight-share.png) |

## Event associated with HLS

- **onHlsStateChanged** - Whenever meeting HLS state changes, then `onHlsStateChanged` event will trigger.

- You can get the `livestreamUrl` and `playbackHlsUrl` of the HLS to play it on the Viewer side when the state changes to `HLS_PLAYABLE`.
  - `playbackHlsUrl` - Live HLS with playback support
  - `livestreamUrl` - Live HLS without playback support

:::note
`downstreamUrl` is now depecated. Use `playbackHlsUrl` or `livestreamUrl` in place of `downstreamUrl`
:::

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
private val meetingEventListener: MeetingEventListener = object : MeetingEventListener() {
  override fun onHlsStateChanged(HlsState: JSONObject) {
    when (HlsState.getString("status")) {
        "HLS_STARTING" -> Log.d("onHlsStateChanged", "Meeting hls is starting")
        "HLS_STARTED" -> Log.d("onHlsStateChanged", "Meeting hls is started")
        "HLS_PLAYABLE" -> {
            Log.d("onHlsStateChanged", "Meeting hls is playable now")
            //highlight-start
            // on hls playable you will receive playbackHlsUrl and livestreamUrl
            val playbackHlsUrl = HlsState.getString("playbackHlsUrl")
            val livestreamUrl = HlsState.getString("livestreamUrl")
            //highlight-end
        }
        "HLS_STOPPING" -> Log.d("onHlsStateChanged", "Meeting hls is stopping")
        "HLS_STOPPED" -> Log.d("onHlsStateChanged", "Meeting hls is stopped")
    }
  }
}

override fun onCreate(savedInstanceState: Bundle?) {
  //...

  // add listener to meeting
  //highlight-next-line
  meeting!!.addEventListener(meetingEventListener)
}
```

</TabItem>

<TabItem value="Java">

```js
private final MeetingEventListener meetingEventListener = new MeetingEventListener() {
  @Override
  public void onHlsStateChanged(JSONObject HlsState) {
      switch (HlsState.getString("status")) {
          case "HLS_STARTING":
              Log.d("onHlsStateChanged", "Meeting hls is starting");
              break;
          case "HLS_STARTED":
              Log.d("onHlsStateChanged", "Meeting hls is started");
              break;
          case "HLS_PLAYABLE":
              Log.d("onHlsStateChanged", "Meeting hls is playable now");
              //highlight-start
              // on hls started you will receive playbackHlsUrl and livestreamUrl
              String playbackHlsUrl = HlsState.getString("playbackHlsUrl");
              String livestreamUrl = HlsState.getString("livestreamUrl");
              //highlight-end
              break;
          case "HLS_STOPPING":
              Log.d("onHlsStateChanged", "Meeting hls is stopping");
              break;
          case "HLS_STOPPED":
              Log.d("onHlsStateChanged", "Meeting hls is stopped");
              break;
      }
  }
}

@Override
protected void onCreate(Bundle savedInstanceState) {
  //...

  // add listener to meeting
  //highlight-next-line
  meeting.addEventListener(meetingEventListener);
}
```

</TabItem>

</Tabs>

## Custom Template

With VideoSDK, you can also use your own custom designed layout template to livestream the meetings. In order to use the custom template, you need to create a template for which you can [follow this guide](/react/guide/interactive-live-streaming/custom-template). Once you have setup the template, you can use the [REST API to start](/api-reference/realtime-communication/start-livestream) the livestream with the `templateURL` parameter.

## API Reference

The API references for all the methods utilized in this guide are provided below.

- [startHls()](/android/api/sdk-reference/meeting-class/methods#starthls)
- [stopHls()](/android/api/sdk-reference/meeting-class/methods#stophls)
- [onHlsStateChanged](/android/api/sdk-reference/meeting-class/meeting-event-listener-class#onhlsstatechanged)


---

---
title: Stop HLS | Video SDK
hide_title: true
hide_table_of_contents: false
description: Using VideoSDK to do the interactive livestreaming.
sidebar_label: Stop HLS
pagination_label: Stop HLS
keywords:
  - audio calling
  - video calling
  - real-time communication
  - interactive live streaming
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: stop-hls
---

# Stop HLS - Android

This could refer to stopping the transmission of an ongoing HLS stream, which would mean the stream is no longer available to viewers.

## Stopping HLS

- `stopHls()` is used to stop interactive livestream of the meeting which can be accessed from the `Meeting` class.

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
findViewById<View>(R.id.btnStopHls).setOnClickListener { view: View? ->
    // Stop Hls
    //highlight-next-line
    meeting!!.stopHls()
}
```

</TabItem>

<TabItem value="Java">

```js
findViewById(R.id.btnStopHls).setOnClickListener(view -> {
    // Stop Hls
    //highlight-next-line
    meeting.stopHls();
});
```

</TabItem>

</Tabs>

## Event associated with HLS

- **onHlsStateChanged** - Whenever meeting HLS state changes, then `onHlsStateChanged` event will trigger.

- You will get `HLS_STOPPING` and `HLS_STOPPED` status on calling `stopHls()`.

:::note
`downstreamUrl` is now depecated. Use `playbackHlsUrl` or `livestreamUrl` in place of `downstreamUrl`
:::

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
private val meetingEventListener: MeetingEventListener = object : MeetingEventListener() {
  override fun onHlsStateChanged(HlsState: JSONObject) {
    when (HlsState.getString("status")) {
        "HLS_STARTING" -> Log.d("onHlsStateChanged", "Meeting hls is starting")
        "HLS_STARTED" -> Log.d("onHlsStateChanged", "Meeting hls is started")
        "HLS_PLAYABLE" -> {
            Log.d("onHlsStateChanged", "Meeting hls is playable now")
             // on hls playable you will receive playbackHlsUrl and livestreamUrl
            val playbackHlsUrl = HlsState.getString("playbackHlsUrl")
            val livestreamUrl = HlsState.getString("livestreamUrl")
        }
            //highlight-start
        "HLS_STOPPING" -> Log.d("onHlsStateChanged", "Meeting hls is stopping")
        "HLS_STOPPED" -> Log.d("onHlsStateChanged", "Meeting hls is stopped")
            //highlight-end

    }
  }
}

override fun onCreate(savedInstanceState: Bundle?) {
  //...

  // add listener to meeting
  //highlight-next-line
  meeting!!.addEventListener(meetingEventListener)
}
```

</TabItem>

<TabItem value="Java">

```js
private final MeetingEventListener meetingEventListener = new MeetingEventListener() {
  @Override
  public void onHlsStateChanged(JSONObject HlsState) {
      switch (HlsState.getString("status")) {
          case "HLS_STARTING":
              Log.d("onHlsStateChanged", "Meeting hls is starting");
              break;
          case "HLS_STARTED":
              Log.d("onHlsStateChanged", "Meeting hls is started");
              break;
          case "HLS_PLAYABLE":
              Log.d("onHlsStateChanged", "Meeting hls is playable now");
              // on hls started you will receive playbackHlsUrl and livestreamUrl
              String playbackHlsUrl = HlsState.getString("playbackHlsUrl");
              String livestreamUrl = HlsState.getString("livestreamUrl");
              break;
              //highlight-start
          case "HLS_STOPPING":
              Log.d("onHlsStateChanged", "Meeting hls is stopping");
              break;
          case "HLS_STOPPED":
              Log.d("onHlsStateChanged", "Meeting hls is stopped");
              break;
              //highlight-end

      }
  }
}

@Override
protected void onCreate(Bundle savedInstanceState) {
  //...

  // add listener to meeting
  //highlight-next-line
  meeting.addEventListener(meetingEventListener);
}
```

</TabItem>

</Tabs>

## API Reference

The API references for all the methods utilized in this guide are provided below.

- [startHls()](/android/api/sdk-reference/meeting-class/methods#starthls)
- [stopHls()](/android/api/sdk-reference/meeting-class/methods#stophls)
- [onHlsStateChanged](/android/api/sdk-reference/meeting-class/meeting-event-listener-class#onhlsstatechanged)


---

---
title: Chat messages with PubSub - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: PubSub features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Chat using PubSub
pagination_label: Chat using PubSub
keywords:
  - Chat in meeting
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: chat-using-pubsub
---

# Chat using PubSub - Android

For the communication or any kind of messaging in between the participants, VideoSDK provides `pubSub` class which use Publish-Subscribe mechanism and can be used to develope wide varitey of functionalities. For example, participants could use it to send chat messages to each other, share files or other media, or even trigger actions like muting or unmuting audio or video.

Now we will see, how we can use PubSub to implement Chat functionality. If you are not familiar with the PubSub mechanism and `pubSub` class, you can [follow this guide](/android/guide/video-and-audio-calling-api-sdk/collaboration-in-meeting/pubsub).

## Implementing Chat

### `Group Chat`

1. First step in creating a group chat is choosing the topic which all the participants will publish and subscribe to send and receive the messages. We will be using `CHAT` as the topic for this one.
2. On the send button, publish the message that the sender typed in the `EditText` field.

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle
import android.view.View
import android.widget.EditText
import android.widget.Toast
import androidx.appcompat.widget.Toolbar
import live.videosdk.rtc.android.Meeting
import live.videosdk.rtc.android.listeners.PubSubMessageListener
import live.videosdk.rtc.android.model.PubSubPublishOptions

class ChatActivity : AppCompatActivity() {
  // Meeting
  var meeting: Meeting? = null

  override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    setContentView(R.layout.activity_chat)

    /**
     * Here, we have created 'MainApplication' class, which extends android.app.Application class.
     * It has Meeting property and getter and setter methods of Meeting property.
     * In your android manifest, you must declare the class implementing android.app.Application
     * (add the android:name=".MainApplication" attribute to the existing application tag):
     * In MainActivity.kt, we have set Meeting property.
     *
     * For Example: (MainActivity.kt)
     * var meeting = VideoSDK.initMeeting(context, meetingId, ParticipantName, micEnabled, webcamEnabled, paricipantId, mode, multiStream, customTrack, metaData, signalingBaseUrl)
     * (this.application as MainApplication).meeting = meeting
    */

    // Get Meeting
    meeting = (this.application as MainApplication).meeting

    findViewById(R.id.btnSend).setOnClickListener(view -> sendMessage());
  }

  private fun sendMessage() {
    // get message from EditText
    val message: String = etmessage.getText().toString()
    if (!TextUtils.isEmpty(message)) {
        val publishOptions = PubSubPublishOptions()
        publishOptions.setPersist(true)

        // Sending the Message using the publish method
        //highlight-next-line
        meeting!!.pubSub.publish("CHAT", message, publishOptions)

        // Clearing the message input
        etmessage.setText("")
    } else {
        Toast.makeText(
            this@ChatActivity, "Please Enter Message",
            Toast.LENGTH_SHORT
        ).show()
    }
  }
}
```

</TabItem>

<TabItem value="Java">

```js
import androidx.appcompat.app.AppCompatActivity;
import android.os.Bundle;
import java.util.List;
import live.videosdk.rtc.android.Meeting;
import live.videosdk.rtc.android.lib.PubSubMessage;
import live.videosdk.rtc.android.listeners.PubSubMessageListener;
import live.videosdk.rtc.android.model.PubSubPublishOptions;

public class ChatActivity extends AppCompatActivity {
  // Meeting
  Meeting meeting;

  @Override
  protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_chat);

    /**
     * Here, we have created 'MainApplication' class, which extends android.app.Application class.
     * It has Meeting property and getter and setter methods of Meeting property.
     * In your android manifest, you must declare the class implementing android.app.Application
     * (add the android:name=".MainApplication" attribute to the existing application tag):
     * In MainActivity.java, we have set Meeting property.
     *
     * For Example: (MainActivity.java)
     * Meeting meeting = VideoSDK.initMeeting(context, meetingId, ParticipantName, micEnabled, webcamEnabled, participantId, mode, mutliStream, customTrack,metaData, signalingBaseUrl, preferredProtocol);
     * ((MainApplication) this.getApplication()).setMeeting(meeting);
    */

    // Get Meeting
    meeting = ((MainApplication) this.getApplication()).getMeeting();

    findViewById(R.id.btnSend).setOnClickListener(view -> sendMessage());
  }

  private void sendMessage()
  {
    // get message from EditText
    String message = etmessage.getText().toString();
    if (!message.equals("")) {
        PubSubPublishOptions publishOptions = new PubSubPublishOptions();
        publishOptions.setPersist(true);

        // Sending the Message using the publish method
        //highlight-next-line
        meeting.pubSub.publish("CHAT", message, publishOptions);

        // Clearing the message input
        etmessage.setText("");
    } else {
        Toast.makeText(ChatActivity.this, "Please Enter Message",
                Toast.LENGTH_SHORT).show();
    }
  }
}
```

</TabItem>

</Tabs>

3. Next step would be to display the messages others send. For this we have to `subscribe` to that topic i.e `CHAT` and display all the messages.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
class ChatActivity : AppCompatActivity() {

  // PubSubMessageListener
  //highlight-start
  var pubSubMessageListener =
    PubSubMessageListener { message ->
      // New message
      Toast.makeText(
            this@ChatActivity, message.senderName + " says : " + message.message,
            Toast.LENGTH_SHORT
        ).show()
  }
  //highlight-end

  override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    setContentView(R.layout.activity_chat)

    //...

    // Subscribe for 'CHAT' topic
    //highlight-next-line
    val pubSubMessageList = meeting!!.pubSub.subscribe("CHAT", pubSubMessageListener)

    for (message in pubSubMessageList) {
      // Persisted messages
      Toast.makeText(
            this@ChatActivity, message.senderName + " says : " + message.message,
            Toast.LENGTH_SHORT
        ).show()
    }
  }
}
```

</TabItem>

<TabItem value="Java">

```js
public class ChatActivity extends AppCompatActivity {

  // PubSubMessageListener
  //highlight-start
  private PubSubMessageListener pubSubMessageListener = new PubSubMessageListener() {
    @Override
    public void onMessageReceived(PubSubMessage message) {
        // New message
        Toast.makeText(
          ChatActivity.this, message.senderName + " says : "+ message.getMessag(),
          Toast.LENGTH_SHORT
        ).show();
    }
  };
  //highlight-end

  @Override
  protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_chat);

    //..

    // Subscribe for 'CHAT' topic
    //highlight-next-line
    List<PubSubMessage> pubSubMessageList = meeting.pubSub.subscribe("CHAT", pubSubMessageListener);

    for(PubSubMessage message : pubSubMessageList){
        // Persisted messages
        Toast.makeText(
          ChatActivity.this, message.senderName + " says : "+ message.getMessag(),
          Toast.LENGTH_SHORT
        ).show();
    }
  }
}
```

</TabItem>

</Tabs>

4. Final step in the group chat would be `unsubscribe` to that topic, which you had previously subscribed but no longer needed. Here we are `unsubscribe` to `CHAT` topic on activity destroy.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
class ChatActivity : AppCompatActivity() {
  override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    setContentView(R.layout.activity_chat)

    //...
  }

  override fun onDestroy() {
    // Unsubscribe for 'CHAT' topic
    //highlight-next-line
    meeting!!.pubSub.unsubscribe("CHAT", pubSubMessageListener)
    super.onDestroy()
  }
}
```

</TabItem>

<TabItem value="Java">

```js
public class ChatActivity extends AppCompatActivity {
  @Override
  protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_chat);

    //..
  }

  @Override
  protected void onDestroy() {
    // Unsubscribe for 'CHAT' topic
    //highlight-next-line
    meeting.pubSub.unsubscribe("CHAT", pubSubMessageListener);
    super.onDestroy();
  }
}
```

</TabItem>

</Tabs>

### `Private Chat`

In the above example, if you want to convert into the private chat between two participants, then all you have to do is pass `sendOnly` parameter in `PubSubPublishOptions`.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
class ChatActivity : AppCompatActivity() {

  //..
  
  private fun sendMessage() {
    // get message from EditText
    val message: String = etmessage.getText().toString()
    if (!TextUtils.isEmpty(message)) {
        val publishOptions = PubSubPublishOptions()
        publishOptions.setPersist(true)
        //highlight-start
        // Pass the participantId of the participant to whom you want to send the message.
        var sendOnly: Array<String> = arrayOf("xyz")
        publishOptions.setSendOnly(sendOnly);
        //highlight-end

        // Sending the Message using the publish method
        //highlight-next-line
        meeting!!.pubSub.publish("CHAT", message, publishOptions)

        // Clearing the message input
        etmessage.setText("")
    } else {
        Toast.makeText(
            this@ChatActivity, "Please Enter Message",
            Toast.LENGTH_SHORT
        ).show()
    }
  }
}
```

</TabItem>

<TabItem value="Java">

```js
public class ChatActivity extends AppCompatActivity {
 
  //...

  private void sendMessage()
  {
    // get message from EditText
    String message = etmessage.getText().toString();
    if (!message.equals("")) {
        PubSubPublishOptions publishOptions = new PubSubPublishOptions();
        publishOptions.setPersist(true);
        //highlight-start
        // Pass the participantId of the participant to whom you want to send the message.
        String[] sendOnly = {
          "xyz" 
        };
        publishOptions.setSendOnly(sendOnly);
        //highlight-end

        // Sending the Message using the publish method
        //highlight-next-line
        meeting.pubSub.publish("CHAT", message, publishOptions);

        // Clearing the message input
        etmessage.setText("");
    } else {
        Toast.makeText(ChatActivity.this, "Please Enter Message",
                Toast.LENGTH_SHORT).show();
    }
  }
}
```

</TabItem>

</Tabs>

### Downloading Chat Messages

All the messages from the PubSub which where published with `persist : true` and can be downloaded as an `.csv` file. This file will be available in the VideoSDK dashboard as well as throught the [Sessions API](/api-reference/realtime-communication/fetch-session-using-sessionid).

### API Reference

The API references for all the methods and events utilised in this guide are provided below.

- [pubSub()](/android/api/sdk-reference/pubsub-class/introduction)


---

---
title: Notify Attendees with PubSub - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: PubSub features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Notify Attendees in Realtime
pagination_label: Notify Attendees in Realtime
keywords:
  - Start Livestream meeting
  - Stop Livestream meeting
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: notify-attendees
---

# Notify Attendees in Realtime - Android

When doing livestream, you may want to broadcast message to all the viewers at once.

Let us see, how we can use PubSub to implement this functionality. If you are not familiar with the PubSub mechanism, you can [follow this guide](/android/guide/video-and-audio-calling-api-sdk/collaboration-in-meeting/pubsub).

### Notifying Attendees

1. We will be publish the message that the sender typed in the `EditText` field to the topic `NOTIFY_ATTENDEES`.

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js

class SpeakerActivity : AppCompatActivity() {
  override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    //...
    findViewById(R.id.btnSend).setOnClickListener(view -> sendMessage());
  }

  private fun sendMessage() {
    // get message from EditText
    val message: String = etmessage.getText().toString()
    if (!TextUtils.isEmpty(message)) {
        val publishOptions = PubSubPublishOptions()
        publishOptions.setPersist(true)

        // Sending the Message using the publish method
        //highlight-next-line
        meeting!!.pubSub.publish("NOTIFY_ATTENDEES", message, publishOptions)

        // Clearing the message input
        etmessage.setText("")
    } else {
        Toast.makeText(
            this@SpeakerActivity, "Please Enter Message",
            Toast.LENGTH_SHORT
        ).show()
    }
  }
}
```

</TabItem>

<TabItem value="Java">

```js
public class SpeakerActivity extends AppCompatActivity {
  @Override
  protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    //...
    findViewById(R.id.btnSend).setOnClickListener(view -> sendMessage());
  }

  private void sendMessage()
  {
    // get message from EditText
    String message = etmessage.getText().toString();
    if (!message.equals("")) {
        PubSubPublishOptions publishOptions = new PubSubPublishOptions();
        publishOptions.setPersist(true);

        // Sending the Message using the publish method
        //highlight-next-line
        meeting.pubSub.publish("NOTIFY_ATTENDEES", message, publishOptions);

        // Clearing the message input
        etmessage.setText("");
    } else {
        Toast.makeText(SpeakerActivity.this, "Please Enter Message",
                Toast.LENGTH_SHORT).show();
    }
  }
}
```

</TabItem>

</Tabs>

2. Now let us show an alert to all the viewers displaying the message posted by the speaker.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
class ViewerActivity : AppCompatActivity() {

  // PubSubMessageListener
  //highlight-start
  var pubSubMessageListener =
    PubSubMessageListener { message ->
      if(meeting!!.localparticipant.mode == "SIGNALLING_ONLY"){
        Toast.makeText(
                this@ViewerActivity, message.message,
                Toast.LENGTH_SHORT
            ).show()
      }
  }
  //highlight-end

  override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    setContentView(R.layout.activity_chat)

    //...

    // Subscribe for 'NOTIFY_ATTENDEES' topic
    //highlight-next-line
    val pubSubMessageList = meeting!!.pubSub.subscribe("NOTIFY_ATTENDEES", pubSubMessageListener)

    for (message in pubSubMessageList) {
      // Persisted messages
      if(meeting!!.localparticipant.mode == "SIGNALLING_ONLY"){
        Toast.makeText(
                this@ViewerActivity, message.message,
                Toast.LENGTH_SHORT
            ).show()
      }
    }
  }
}
```

</TabItem>

<TabItem value="Java">

```js
public class ViewerActivity extends AppCompatActivity {

  // PubSubMessageListener
  //highlight-start
  private PubSubMessageListener pubSubMessageListener = new PubSubMessageListener() {
    @Override
    public void onMessageReceived(PubSubMessage message) {
        if(meeting.getLocalParticipant().getMode() == "SIGNALLING_ONLY"){
            Toast.makeText(
                ViewerActivity.this, message.getMessage(),
                Toast.LENGTH_SHORT
                ).show();
        }
    }
  };
  //highlight-end

  @Override
  protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);

    //..

    // Subscribe for 'NOTIFY_ATTENDEES' topic
    //highlight-next-line
    List<PubSubMessage> pubSubMessageList = meeting.pubSub.subscribe("NOTIFY_ATTENDEES", pubSubMessageListener);

    for(PubSubMessage message : pubSubMessageList){
        // Persisted messages
        if(meeting.getLocalParticipant().getMode() == "SIGNALLING_ONLY"){
            Toast.makeText(
            ViewerActivity.this, message.getMessage(),
            Toast.LENGTH_SHORT
            ).show();
        }
    }
  }
}
```

</TabItem>

</Tabs>

### API Reference

The API references for all the methods and events utilised in this guide are provided below.

- [pubSub()](/android/api/sdk-reference/pubsub-class/introduction)


---

---
title: Raise Hand with PubSub - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: PubSub features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Raise Hand using PubSub
pagination_label: Raise Hand using PubSub
keywords:
  - Raise Hand
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: raise-hand-using-pubsub
---

# Raise Hand using PubSub - Android

Let us see, how we can use PubSub to implement Raise Hand functionality. If you are not familiar with the PubSub mechanism and `pubSub` class, you can [follow this guide](/android/guide/video-and-audio-calling-api-sdk/collaboration-in-meeting/pubsub).

## Implementing Raise Hand

1. First step in raise hand is choosing the topic which all the participants will publish and subscribe to know some participant raise their hand. We will be using `RAISE_HAND` as the topic for this one.
2. On the raiseHand button, publish any message to that specific topic.

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
class MainActivity : AppCompatActivity() {

  override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    setContentView(R.layout.activity_main)

    //...

    findViewById(R.id.btnRaiseHand).setOnClickListener(view -> sendRaiseHandMessage());
  }

  private fun sendRaiseHandMessage() {
    val publishOptions = PubSubPublishOptions()
    publishOptions.setPersist(false)

    // Sending the Message using the publish method
    //highlight-next-line
    meeting!!.pubSub.publish("RAISE_HAND", "Raise Hand", publishOptions)
  }
}
```

</TabItem>

<TabItem value="Java">

```js
public class MainActivity extends AppCompatActivity {
  @Override
  protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_chat);

    //...

    findViewById(R.id.btnRaiseHand).setOnClickListener(view -> sendRaiseHandMessage());
  }

  private void sendRaiseHandMessage()
  {
    PubSubPublishOptions publishOptions = new PubSubPublishOptions();
    publishOptions.setPersist(false);

    // Sending the Message using the publish method
    //highlight-next-line
    meeting.pubSub.publish("RAISE_HAND", "Raise Hand", publishOptions);
  }
}
```

</TabItem>

</Tabs>

3. Now let us show an alert to all the participants showing who raised the hand.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
class MainActivity : AppCompatActivity() {

  // PubSubMessageListener
  //highlight-start
  var pubSubMessageListener =
    PubSubMessageListener { message ->
      // Participant raise hand
      Toast.makeText(
            this@MainActivity, message.senderName + " raise hand",
            Toast.LENGTH_SHORT
        ).show()
  }
  //highlight-end

  override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    setContentView(R.layout.activity_chat)

    //...

    // Subscribe for 'RAISE_HAND' topic
    //highlight-next-line
    val pubSubMessageList = meeting!!.pubSub.subscribe("RAISE_HAND", pubSubMessageListener)
  }
}
```

</TabItem>

<TabItem value="Java">

```js
public class MainActivity extends AppCompatActivity {

  // PubSubMessageListener
  //highlight-start
  private PubSubMessageListener pubSubMessageListener = new PubSubMessageListener() {
    @Override
    public void onMessageReceived(PubSubMessage message) {
        // Participant raise hand
        Toast.makeText(
          MainActivity.this, message.senderName + " raise hand",
          Toast.LENGTH_SHORT
        ).show();
    }
  };
  //highlight-end

  @Override
  protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);

    //..

    // Subscribe for 'RAISE_HAND' topic
    //highlight-next-line
    List<PubSubMessage> pubSubMessageList = meeting.pubSub.subscribe("RAISE_HAND", pubSubMessageListener);
  }
}
```

</TabItem>

</Tabs>

### API Reference

The API references for all the methods and events utilised in this guide are provided below.

- [pubSub()](/android/api/sdk-reference/pubsub-class/introduction)


---

---
title: Reactions with PubSub - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: PubSub features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Reactions
pagination_label: Reactions
keywords:
  - Start Livestream meeting
  - Stop Livestream meeting
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: reactions
---

# Reactions - Android

When doing a livestream, one of the way to increase the interaction in between the viewer and speaker is by showing the viewers reaction to all. You might have seen emojis flying around during the livestream happening on instagram.

Lets create a similar flying emoji by using the VideoSDK PubSub mechanism.

### Step 1: Creating a button to send reaction

When `btnReaction` is clicked we will send the emoji name to all the participants using the VideoSDK PubSub mechanism and also shows emoji to localParticipant.

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
class ILSViewActivity : AppCompatActivity() {

  override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    //...
    findViewById(R.id.btnReaction).setOnClickListener { v: View? ->
        showEmoji(resources.getDrawable(R.drawable.love_eyes_emoji))
        meeting!!.pubSub.publish("REACTION", "love_eyes", pubSubPublishOptions)
    }
  }

  private fun showEmoji(drawable: Drawable?) {
    // we will implement this method in step 2
  }
}
```

</TabItem>

<TabItem value="Java">

```js
public class ILSViewActivity extends AppCompatActivity {
  @Override
  protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    //...
    findViewById(R.id.loveEyes).setOnClickListener(v -> {
        showEmoji(getResources().getDrawable(R.drawable.love_eyes_emoji));
        meeting.pubSub.publish("REACTION", "love_eyes", pubSubPublishOptions);
    });
  }

  public void showEmoji(Drawable drawable) {
    // we will implement this method in step 2
  }
}
```

</TabItem>

</Tabs>

### Step 2: Displaying the Reactions to all the users

Here we will listen to the `onMessageReceived` event of `PubSubMessageListener` to know someone send the reactions, and show the flying emoji whenever it triggered.

To Display flyingEmoji, we are using `DirectionGenerator` class to specify direction and `ZeroGravityAnimation` class to give animation to the flyingEmoji.

Copy `DirectionGenerator` and `ZeroGravityAnimation` classes from our [code sample](https://github.com/videosdk-live/videosdk-hls-android-kotlin-example/tree/main/app/src/main/java/live/videosdk/android/hlsdemo/common/reactions).

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
class ILSViewActivity : AppCompatActivity() {

  override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    //...
    var emojiListener =
    PubSubMessageListener { pubSubMessage ->
        when (pubSubMessage.message) {
            //Showing other participants reactions
            "loveEyes" -> showEmoji(resources.getDrawable(R.drawable.love_eyes_emoji))
        }
    }
    //Subscribing to the PubSub topic REACTION to recive other participants reactions.
    //highlight-start
    meeting!!.pubSub.subscribe("REACTION", emojiListener)
  }
}
```

</TabItem>

<TabItem value="Java">

```js
public class ILSViewActivity extends AppCompatActivity {
  @Override
  protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    //...
    private PubSubMessageListener pubSubMessageListener = new PubSubMessageListener() {
    @Override
    public void onMessageReceived(PubSubMessage pubSubMessage) {
            switch (pubSubMessage.getMessage()) {
                case "loveEyes":
                    //Showing other participants reactions
                    showEmoji(getResources().getDrawable(R.drawable.love_eyes_emoji));
                    break;
            }

        }
    };
    //Subscribing to the PubSub topic REACTION to recive other participants reactions.
    //highlight-start
    meeting.pubSub.subscribe("REACTION", emojiListener);
  }
}
```

</TabItem>

</Tabs>

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
private fun showEmoji(drawable: Drawable?) {
    // You can change the number of emojis that will be flying on screen
    for (i in 0..4) {
        flyObject(
            drawable,
            3000,
            DirectionGenerator.Direction.BOTTOM,
            DirectionGenerator.Direction.TOP,
            1f
        )
    }
}

private fun flyObject(
    drawable: Drawable?,
    duration: Int,
    from: DirectionGenerator.Direction?,
    to: DirectionGenerator.Direction?,
    scale: Float
) {
    val animation = ZeroGravityAnimation()
    animation.setCount(1)
    animation.setScalingFactor(scale)
    animation.setOriginationDirection((from)!!)
    animation.setDestinationDirection((to)!!)
    animation.setImage(drawable)
    animation.setDuration(duration)
    animation.setAnimationListener(object : Animation.AnimationListener {
        override fun onAnimationStart(animation: Animation) {}
        override fun onAnimationEnd(animation: Animation) {}
        override fun onAnimationRepeat(animation: Animation) {}
    })
    viewerEmojiHolder!!.bringToFront()
    animation.play(mActivity, viewerEmojiHolder)
}
```

</TabItem>

<TabItem value="Java">

```js
public void showEmoji(Drawable drawable) {
    // You can change the number of emojis that will be flying on screen
    for (int i = 0; i < 5; i++) {
        flyObject(drawable, 3000, DirectionGenerator.Direction.BOTTOM, DirectionGenerator.Direction.TOP, 1);
    }
}

public void flyObject(final Drawable drawable, final int duration, final DirectionGenerator.Direction from, final DirectionGenerator.Direction to, final float scale) {
    ZeroGravityAnimation animation = new ZeroGravityAnimation();
    animation.setCount(1);
    animation.setScalingFactor(scale);
    animation.setOriginationDirection(from);
    animation.setDestinationDirection(to);
    animation.setImage(drawable);
    animation.setDuration(duration);
    animation.setAnimationListener(new Animation.AnimationListener() {
        @Override
        public void onAnimationStart(Animation animation) {

        }

        @Override
        public void onAnimationEnd(Animation animation) {
        }

        @Override
        public void onAnimationRepeat(Animation animation) {

        }
    });
    viewerEmojiHolder.bringToFront();
    animation.play(mActivity, viewerEmojiHolder);
}

```

</TabItem>

</Tabs>

:::note
Here `viewerEmojiHolder` is FrameLayout, you can change recording to your requirement.
:::

<center>

<img style={{height: '450px',marginRight:'15px'}} src="https://cdn.videosdk.live/website-resources/docs-resources/android_emoji_viewer.gif" />

<img style={{height: '450px'}} src="https://cdn.videosdk.live/website-resources/docs-resources/android_emoji_speaker.gif"/>

</center>

### API Reference

The API references for all the methods and events utilised in this guide are provided below.

- [pubSub()](/android/api/sdk-reference/pubsub-class/introduction)


---

---
sidebar_label: Overview
pagination_label: Overview
---

# Overview of SIP with VideoSDK - Android

import SipConnect from '../../../mdx/\_sip-connect.mdx';
import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>

<SipConnect title="SIP Connect with VideoSDK - Android"/>


---

---
sidebar_label: Quick Start
pagination_label: Quick Start
---

# Build a SIP Integration: VideoSDK & Twilio for Inbound Outbound Calls! Step-by-Step

import SipQuickStart from '../../../mdx/\_sip-connect-quick-start.mdx';

<SipQuickStart/>


---

---
title: SIP Connect
hide_title: false
hide_table_of_contents: false
description: Interactive Livestream features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: SIP Connect
pagination_label: SIP Connect
keywords:
  - SIP connect
  - PSTN connect
  - sip videosdk
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: sip-connect
---

# SIP Connect - Android

import SipConnect from '../../mdx/\_sip-connect.mdx';
import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>

<SipConnect title="SIP Connect with VideoSDK - Android"/>


---

---
title: Start a Video & Audio Call in Android SDK - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: Build customizable real-time video & audio calling applications in Android SDK using Video SDK add live Video & Audio conferencing to your applications.
sidebar_label: "Client Setup for Android"
pagination_label: "Client Setup for Android"
keywords:
  - android sdk
  - java sdk
  - kotlin sdk
  - chromebook sdk
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: android-sdk
---

import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>

# Getting Started - Android SDK

Android SDK is natively written SDK using Java. It is compatible with both Java and Kotlin.

## Install an Android SDK

The easiest way to get started is by installing the sdk in your app.

### Step 1: Add the repositories into your project.

- If your Android Studio Version is older than Android Studio Bumblebees, add the repository to project's `build.gradle` file.
- If your are using Android Studio Bumblebees or newer Version, add the repository to `settings.gradle` file.

:::note

You can use imports with Maven Central after rtc-android-sdk version `0.1.12`.

Whether on Maven or Jitpack, the same version numbers always refer to the same SDK.

:::

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Maven Central"
groupId={"android-repositories"}
values={[{label: 'Maven Central', value: 'Maven Central'},{label: 'Jitpack', value: 'Jitpack'},]}>

<TabItem value="Maven Central">

```js title="build.gradle"
allprojects {
  repositories {
    // ...
    google()
    mavenCentral()
    maven { url "https://maven.aliyun.com/repository/jcenter" }
  }
}
```

```js title="settings.gradle"
dependencyResolutionManagement{
  repositories {
    // ...
    google()
    mavenCentral()
    maven { url "https://maven.aliyun.com/repository/jcenter" }
  }
}

```

</TabItem>

<TabItem value="Jitpack">

```js title="build.gradle"
allprojects {
  repositories {
    // ...
    google()
    maven { url 'https://jitpack.io' }
    mavenCentral()
    maven { url "https://maven.aliyun.com/repository/jcenter" }
  }
}
```

```js title="settings.gradle"
dependencyResolutionManagement{
  repositories {
    // ...
    google()
    maven { url 'https://jitpack.io' }
    mavenCentral()
    maven { url "https://maven.aliyun.com/repository/jcenter" }
  }
}

```

</TabItem>

</Tabs>

### Step 2: Add the dependency in `app/build.gradle`:

```js title="app/build.gradle"
dependencies {
		implementation 'live.videosdk:rtc-android-sdk:0.1.38'

		// other app dependencies
}
```

:::important

Android SDK compatible with armeabi-v7a, arm64-v8a, x86_64 architectures. If you want to run the application in an emulator, choose ABI x86_64 when creating a device.

:::

### Step 3: Add all the following permissions to AndroidManifest.xml

```js title="AndroidManifest.xml"
<uses-permission android:name="android.permission.RECORD_AUDIO" />
<uses-permission android:name="android.permission.MODIFY_AUDIO_SETTINGS" />
<uses-permission android:name="android.permission.INTERNET" />
<uses-permission android:name="android.permission.READ_PHONE_STATE" />
<uses-permission android:name="android.permission.CAMERA" />

<uses-permission android:name="android.permission.BLUETOOTH" />
<uses-permission android:name="android.permission.BLUETOOTH_ADMIN" />
<uses-permission android:name="android.permission.BLUETOOTH_CONNECT" />

```

### Step 4: Create MainApplication class with the following code

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js title="MainApplication.kt"
package live.videosdk.demo;

import live.videosdk.rtc.android.VideoSDK;

class MainApplication : Application() {
  override fun onCreate() {
    super.onCreate()
    
    VideoSDK.initialize(applicationContext)
  }
}
```

</TabItem>

<TabItem value="Java">

```js title="MainApplication.java"
package live.videosdk.demo;

import android.app.Application;

import live.videosdk.rtc.android.VideoSDK;

public class MainApplication extends Application {
    @Override
    public void onCreate() {
        super.onCreate();

        VideoSDK.initialize(getApplicationContext());
    }
}
```

</TabItem>

</Tabs>

### Step 5: Add MainApplication to AndroidManifest.xml

```js title="AndroidManifest.xml"
<application
    android:name=".MainApplication"
>
  <!-- ... -->
</application>
```

:::note

Check out official example of Android SDK implementation for Java and Kotlin as mentioned below: 

- For **Java** Code Sample [Click here](https://github.com/videosdk-live/videosdk-rtc-android-java-sdk-example)<br />
- For **Kotlin** Code Sample [Click here](https://github.com/videosdk-live/videosdk-rtc-android-kotlin-sdk-example)

:::


---

---
title: Authentication and Token | Video SDK
hide_title: true
hide_table_of_contents: false
description: Video SDK and Audio SDK, developers need to implement a token server. This requires efforts on both the front-end and backend.
sidebar_label: Authentication and Tokens
pagination_label: Authentication and Tokens
keywords:
  - audio calling
  - video calling
  - real-time communication
  - collaboration
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: authentication-and-token
---

import ServerSetup from '../../../mdx/introduction/\_server-setup.mdx';

<ServerSetup title="Authentication and Tokens for VideoSDK - Android" />


---

---
title: Authentication in Video & Audio Calling SDK
hide_title: false
hide_table_of_contents: false
description: This guide will explain authentication and token flow for video & audio calling SDK.
sidebar_label: Authentication and Tokens
pagination_label: Authentication and Tokens
keywords:
  - authentication audio calling
  - authentication video calling
  - authentication real-time communication
  - tokens
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: authentication-and-tokens
---

import Mermaid from '@theme/Mermaid';
import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>

# Authentication and Token

VideoSDK uses access tokens for authentication. Using our dashboard ([app.videosdk.live](https://app.videosdk.live/)), anyone can generate access tokens tokens with an API key and secret pair.

- Your backend server will generate access tokens using API Key and secret.
- Your client obtains token from your backend server.
- Your client will pass the token to VideoSDK server.
- VideoSDK client sdk will conncts to the VideoSDK server with available token.
- VideoSDK server will validate the token and accpets your incoming connection.

Here is the simple sequence diagram represents the authentication.
<Mermaid chart={`sequenceDiagram Your App Client->>Your App Server: Request for token; activate Your App Server; Note left of Your App Server: Generate token; Your App Server-->>Your App Client: Received token; deactivate Your App Server; Your App Client->>VideoSDK Server: Request to establish connection; activate VideoSDK Server; Note left of VideoSDK Server: Validates Token; VideoSDK Server-->>Your App Client: Connection established; deactivate VideoSDK Server;`}/>

## Generate API Key and Secret

Visit, [app.videosdk.live](https://app.videosdk.live/) to gererate API Key and secret.

![Generate API Key from Dashboard](/img/tutorial/generate-api-key.jpg)

## Generate Access Token

For security, every participant that connects to meeting needs a access token. By substituting `apikey` and `permissions` in it.

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="node"
groupId={"server-group-id"}
values={[
{label: 'Node.js', value: 'node'},
{label: 'Python', value: 'python'},
{label: 'Java', value: 'java'},
{label: 'Ruby', value: 'ruby'},
{label: 'PHP', value: 'php'},
]}>
<TabItem value="node">

```js
var jwt = require("jsonwebtoken");
var uuid4 = require("uuid4");

// Need to generate from app.videosdk.live
const API_KEY = "API_KEY_GENERATED";
const SECRET_KEY = "API_SECRET_KEY_GENERATED";

jwt.sign(
  {
    apikey: API_KEY,
    permissions: ["allow_join"], // Permission to join the meeting
  },
  SECRET_KEY,
  {
    algorithm: "HS256",
    expiresIn: "24h",
    jwtid: uuid4(),
  },
  function (err, token) {
    console.log(token);
  }
);
```

</TabItem>
<TabItem value="python">

```python
#!/usr/bin/env python3
import jwt
import uuid
import datetime

api_key = 'api_key_generated'
secret_key = 'secret_key_generated'


def generateToken():
    expires = 24 * 3600
    now = datetime.datetime.utcnow()
    exp = now + datetime.timedelta(seconds=expires)
    return jwt.encode(payload={
          'apikey': api_key,
          permissions: ["allow_join"]
        }, key=secret_key).decode('utf-8')

if __name__ == '__main__':
    print(generateToken())
```

</TabItem>
<TabItem value="java">

```js
import java.time.Instant;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;
import java.util.UUID;
import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.SignatureAlgorithm;

private void generateManagementToken() {
    Map<String, Object> payload = new HashMap<>();
    payload.put("apikey", "<api_key_generated>");
    payload.put("permissions", ["allow_join"]);
    String token = Jwts.builder().setClaims(payload).setId(UUID.randomUUID().toString())
        .setExpiration(new Date(System.currentTimeMillis() + 86400 * 1000))
        .setIssuedAt(Date.from(Instant.ofEpochMilli(System.currentTimeMillis() - 60000)))
        .setNotBefore(new Date(System.currentTimeMillis()))
        .signWith(SignatureAlgorithm.HS256, "<secret_key_generated>".getBytes()).compact();
  }
```

</TabItem>
<TabItem value="ruby">

```js
require 'jwt'
require 'securerandom'

$api_key = "api_key_generated"
$secret_key = "secret_key_generated"

def generateToken()
    payload = {
      apikey: $api_key,
      permissions: ["allow_join"]
    }
token = JWT.encode(payload, $secret_key, 'HS256')
return token
end

puts generateToken
```

</TabItem>
<TabItem value="php">

```js
<?php

use Firebase\JWT\JWT;
use Ramsey\Uuid\Uuid;

$api_key = "api_key_generated";
$secret_key = "secret_key_generated"

$payload = [
    'apikey' => api_key,
    'permissions': ["allow_join"],
];

$token = JWT::encode($payload, $secret_key, 'HS256');
?>
```

</TabItem>
</Tabs>

Available permissions are:

- **allow_join**: The participant will be permitted entry without request.
- **ask_join**: The participant will not be permitted entry without request.
- **allow_mod**: Allow participant to enable/disable other participant's mic/webcam.


---

---
title: Chat messages with PubSub - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: PubSub features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Chat using PubSub
pagination_label: Chat using PubSub
keywords:
  - Chat in meeting
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: chat-using-pubsub
---

# Chat using PubSub - Android

For the communication or any kind of messaging in between the participants, VideoSDK provides `pubSub` class which use Publish-Subscribe mechanism and can be used to develope wide varitey of functionalities. For example, participants could use it to send chat messages to each other, share files or other media, or even trigger actions like muting or unmuting audio or video.

Now we will see, how we can use PubSub to implement Chat functionality. If you are not familiar with the PubSub mechanism and `pubSub` class, you can [follow this guide](./pubsub).

## Implementing Chat

### `Group Chat`

1. First step in creating a group chat is choosing the topic which all the participants will publish and subscribe to send and receive the messages. We will be using `CHAT` as the topic for this one.
2. On the send button, publish the message that the sender typed in the `EditText` field.

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle
import android.view.View
import android.widget.EditText
import android.widget.Toast
import androidx.appcompat.widget.Toolbar
import live.videosdk.rtc.android.Meeting
import live.videosdk.rtc.android.listeners.PubSubMessageListener
import live.videosdk.rtc.android.model.PubSubPublishOptions

class ChatActivity : AppCompatActivity() {
  // Meeting
  var meeting: Meeting? = null

  override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    setContentView(R.layout.activity_chat)

    /**
     * Here, we have created 'MainApplication' class, which extends android.app.Application class.
     * It has Meeting property and getter and setter methods of Meeting property.
     * In your android manifest, you must declare the class implementing android.app.Application
     * (add the android:name=".MainApplication" attribute to the existing application tag):
     * In MainActivity.kt, we have set Meeting property.
     *
     * For Example: (MainActivity.kt)
     * var meeting = VideoSDK.initMeeting(context, meetingId, ParticipantName, micEnabled, webcamEnabled, paricipantId, mode, multiStream, customTrack, metaData, signalingBaseUrl,preferredProtocol)
     * (this.application as MainApplication).meeting = meeting
    */

    // Get Meeting
    meeting = (this.application as MainApplication).meeting

    findViewById(R.id.btnSend).setOnClickListener(view -> sendMessage());
  }

  private fun sendMessage() {
    // get message from EditText
    val message: String = etmessage.getText().toString()
    if (!TextUtils.isEmpty(message)) {
        val publishOptions = PubSubPublishOptions()
        publishOptions.setPersist(true)

        // Sending the Message using the publish method
        //highlight-next-line
        meeting!!.pubSub.publish("CHAT", message, publishOptions)

        // Clearing the message input
        etmessage.setText("")
    } else {
        Toast.makeText(
            this@ChatActivity, "Please Enter Message",
            Toast.LENGTH_SHORT
        ).show()
    }
  }
}
```

</TabItem>

<TabItem value="Java">

```js
import androidx.appcompat.app.AppCompatActivity;
import android.os.Bundle;
import java.util.List;
import live.videosdk.rtc.android.Meeting;
import live.videosdk.rtc.android.lib.PubSubMessage;
import live.videosdk.rtc.android.listeners.PubSubMessageListener;
import live.videosdk.rtc.android.model.PubSubPublishOptions;

public class ChatActivity extends AppCompatActivity {
  // Meeting
  Meeting meeting;

  @Override
  protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_chat);

    /**
     * Here, we have created 'MainApplication' class, which extends android.app.Application class.
     * It has Meeting property and getter and setter methods of Meeting property.
     * In your android manifest, you must declare the class implementing android.app.Application
     * (add the android:name=".MainApplication" attribute to the existing application tag):
     * In MainActivity.java, we have set Meeting property.
     *
     * For Example: (MainActivity.java)
     * Meeting meeting = VideoSDK.initMeeting(context, meetingId, ParticipantName, micEnabled, webcamEnabled, participantId, mode, multiStream, customTrack,metaData, signalingBaseUrl,preferredProtocol);
     * ((MainApplication) this.getApplication()).setMeeting(meeting);
    */

    // Get Meeting
    meeting = ((MainApplication) this.getApplication()).getMeeting();

    findViewById(R.id.btnSend).setOnClickListener(view -> sendMessage());
  }

  private void sendMessage()
  {
    // get message from EditText
    String message = etmessage.getText().toString();
    if (!message.equals("")) {
        PubSubPublishOptions publishOptions = new PubSubPublishOptions();
        publishOptions.setPersist(true);

        // Sending the Message using the publish method
        //highlight-next-line
        meeting.pubSub.publish("CHAT", message, publishOptions);

        // Clearing the message input
        etmessage.setText("");
    } else {
        Toast.makeText(ChatActivity.this, "Please Enter Message",
                Toast.LENGTH_SHORT).show();
    }
  }
}
```

</TabItem>

</Tabs>

3. Next step would be to display the messages others send. For this we have to `subscribe` to that topic i.e `CHAT` and display all the messages.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
class ChatActivity : AppCompatActivity() {

  // PubSubMessageListener
  //highlight-start
  var pubSubMessageListener =
    PubSubMessageListener { message ->
      // New message
      Toast.makeText(
            this@ChatActivity, message.senderName + " says : " + message.message,
            Toast.LENGTH_SHORT
        ).show()
  }
  //highlight-end

  override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    setContentView(R.layout.activity_chat)

    //...

    // Subscribe for 'CHAT' topic
    //highlight-next-line
    val pubSubMessageList = meeting!!.pubSub.subscribe("CHAT", pubSubMessageListener)

    for (message in pubSubMessageList) {
      // Persisted messages
      Toast.makeText(
            this@ChatActivity, message.senderName + " says : " + message.message,
            Toast.LENGTH_SHORT
        ).show()
    }
  }
}
```

</TabItem>

<TabItem value="Java">

```js
public class ChatActivity extends AppCompatActivity {

  // PubSubMessageListener
  //highlight-start
  private PubSubMessageListener pubSubMessageListener = new PubSubMessageListener() {
    @Override
    public void onMessageReceived(PubSubMessage message) {
        // New message
        Toast.makeText(
          ChatActivity.this, message.senderName + " says : "+ message.getMessage(),
          Toast.LENGTH_SHORT
        ).show();
    }
  };
  //highlight-end

  @Override
  protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_chat);

    //..

    // Subscribe for 'CHAT' topic
    //highlight-next-line
    List<PubSubMessage> pubSubMessageList = meeting.pubSub.subscribe("CHAT", pubSubMessageListener);

    for(PubSubMessage message : pubSubMessageList){
        // Persisted messages
        Toast.makeText(
          ChatActivity.this, message.senderName + " says : "+ message.getMessage(),
          Toast.LENGTH_SHORT
        ).show();
    }
  }
}
```

</TabItem>

</Tabs>

4. Final step in the group chat would be `unsubscribe` to that topic, which you had previously subscribed but no longer needed. Here we are `unsubscribe` to `CHAT` topic on activity destroy.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
class ChatActivity : AppCompatActivity() {
  override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    setContentView(R.layout.activity_chat)

    //...
  }

  override fun onDestroy() {
    // Unsubscribe for 'CHAT' topic
    //highlight-next-line
    meeting!!.pubSub.unsubscribe("CHAT", pubSubMessageListener)
    super.onDestroy()
  }
}
```

</TabItem>

<TabItem value="Java">

```js
public class ChatActivity extends AppCompatActivity {
  @Override
  protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_chat);

    //..
  }

  @Override
  protected void onDestroy() {
    // Unsubscribe for 'CHAT' topic
    //highlight-next-line
    meeting.pubSub.unsubscribe("CHAT", pubSubMessageListener);
    super.onDestroy();
  }
}
```

</TabItem>

</Tabs>

### `Private Chat`

In the above example, if you want to convert into the private chat between two participants, then all you have to do is pass `sendOnly` parameter in `PubSubPublishOptions`.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
class ChatActivity : AppCompatActivity() {

  //..
  
  private fun sendMessage() {
    // get message from EditText
    val message: String = etmessage.getText().toString()
    if (!TextUtils.isEmpty(message)) {
        val publishOptions = PubSubPublishOptions()
        publishOptions.setPersist(true)
        //highlight-start
        // Pass the participantId of the participant to whom you want to send the message.
        var sendOnly: Array<String> = arrayOf("xyz")
        publishOptions.setSendOnly(sendOnly);
        //highlight-end

        // Sending the Message using the publish method
        //highlight-next-line
        meeting!!.pubSub.publish("CHAT", message, publishOptions)

        // Clearing the message input
        etmessage.setText("")
    } else {
        Toast.makeText(
            this@ChatActivity, "Please Enter Message",
            Toast.LENGTH_SHORT
        ).show()
    }
  }
}
```

</TabItem>

<TabItem value="Java">

```js
public class ChatActivity extends AppCompatActivity {
 
  //...

  private void sendMessage()
  {
    // get message from EditText
    String message = etmessage.getText().toString();
    if (!message.equals("")) {
        PubSubPublishOptions publishOptions = new PubSubPublishOptions();
        publishOptions.setPersist(true);
        //highlight-start
        // Pass the participantId of the participant to whom you want to send the message.
        String[] sendOnly = {
          "xyz" 
        };
        publishOptions.setSendOnly(sendOnly);
        //highlight-end

        // Sending the Message using the publish method
        //highlight-next-line
        meeting.pubSub.publish("CHAT", message, publishOptions);

        // Clearing the message input
        etmessage.setText("");
    } else {
        Toast.makeText(ChatActivity.this, "Please Enter Message",
                Toast.LENGTH_SHORT).show();
    }
  }
}
```

</TabItem>

</Tabs>

### Downloading Chat Messages

All the messages from the PubSub which where published with `persist : true` and can be downloaded as an `.csv` file. This file will be available in the VideoSDK dashboard as well as throught the [Sessions API](/api-reference/realtime-communication/fetch-session-using-sessionid).

### API Reference

The API references for all the methods and events utilised in this guide are provided below.

- [pubSub()](/android/api/sdk-reference/pubsub-class/introduction)


---

---
title: PubSub - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: PubSub features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: PubSub
pagination_label: PubSub
keywords:
  - Start Livestream meeting
  - Stop Livestream meeting
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: pubsub
---

# PubSub - Android

PubSub is a short acronym for Publish-Subscribe mechanism. This mechanism is used to send and recieve messages from a particular topic. As the name suggests, for someone to send a message, they have to specify the topic and the message which should be published and for someone to receive a message, they should be subscribed to that topic.

Here is a visual to better understand publish-subscribe mechanism.

![pubsub](/img/pubsub.png)

## pubSub

In order to use PubSub in meeting, VideoSDK provides a class `pubSub` which allows you to subscribe to any topic and publish to any topic allowing to pass on messages and instructions during the meeting easily.

### `publish()`

- This method is used for publishing message of specific topic.
- This method can be accessed from the `pubSub` class, which is subclass of `Meeting` class.
- This method will accept following parameters as input:
  - `topic`: This will be the topic for which you are publishing a message.
  - `message`: This will be the actual message to be published. It has to be in `String` format.
  - `options`: This is an object of `PubSubPublishOptions` which specifies the options for publish. `PubSubPublishOptions` has 2 properties.
    - `persist` : `persist` offered the option of keeping the message around for the duration of the session. When `persist` is set to `true`, that message will be retained for upcoming participants and will be available in [VideoSDK Session Dashboard](https://app.videosdk.live/meetings/sessions) with `.CSV` format after completion of session.
    - `sendOnly`: If you want to send a message to specific participants, you can pass their respective `participantId` in form of `String[]`. If you don't provide any IDs or pass a `null` value, the message will be sent to all participants by default. This is optional parameter.
  - `payload`: If you need to include additional information along with a message, you can pass here as `JSONObject`. This is optional parameter.

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
private fun sendMessage() {
  // publish message
  val options = PubSubPublishOptions()
  options.isPersist = true
  //highlight-next-line
  meeting!!.pubSub.publish("CHAT", "Hello Everyone!", options)
}
```

</TabItem>

<TabItem value="Java">

```js
protected void sendMessage() {
  // publish message
  PubSubPublishOptions options = new PubSubPublishOptions();
  options.setPersist(true);
  //highlight-next-line
  meeting.pubSub.publish("CHAT", "Hello Everyone!", options);
}
```

</TabItem>

</Tabs>

### `subscribe()`

- This method is used to subscribe for particular topic.
- This method will accept two parameters as input:

  - `topic`: This will be the topic to be subscribed.
  - `listener`: This is an object of `PubSubMessageListener`, which listens for upcoming messages and calls `onMessageReceived` function, when new message received.

- This method will return `List<PubSubMessage>` which is a list of messages which were sent earlier.

The object of `PubSubMessage` contains following properties:

- `senderId`: This represents the `participantId` of the participant who send the message.
- `senderName`: This represents the `displayName` of the participant who send the message.
- `message`: This will be the actual message that was send.
- `timestamp`: This wil the timestamp for when the message was published.
- `topic`: This will be the name of the topic message was published to.
- `payload`: This will be the data that you have send with message.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
//highlight-start
var pubSubMessageListener =
  PubSubMessageListener { message ->
    // New message
    Log.v("New Message Received", message.senderName + " says : " + message.message)
  }
//highlight-end

@Override
protected void onCreate(Bundle savedInstanceState) {
  //...

  // Subscribe for 'CHAT' topic
  //highlight-next-line
  val pubSubMessageList = meeting!!.pubSub.subscribe("CHAT", pubSubMessageListener)

  // Persisted message list
  for (message in pubSubMessageList) {
    Log.v("Message List: ", message.senderName + " says : " + message.message)
  }
}
```

</TabItem>

<TabItem value="Java">

```js
//highlight-start
PubSubMessageListener pubSubMessageListener = new PubSubMessageListener() {
  @Override
  public void onMessageReceived(PubSubMessage message) {
    // New message
    Log.v("New Message Received", message.senderName + " says : " + message.getMessage());
  }
};
//highlight-end

@Override
protected void onCreate(Bundle savedInstanceState) {
  //...

  // Subscribe for 'CHAT' topic
  //highlight-next-line
  List<PubSubMessage> pubSubMessageList = meeting.pubSub.subscribe("CHAT",pubSubMessageListener);

  // Persisted message list
  for(PubSubMessage message : pubSubMessageList){
    Log.v("Message List: ", message.senderName + " says : " + message.getMessage());
  }
}
```

</TabItem>

</Tabs>

### `unsubscribe()`

- This method is used to unsubscribe for particular topic.
- This method will accept two parameters as input:

  - `topic`: This will be the topic to be unsubscribed.
  - `listener`: This is an object of `PubSubMessageListener`, which was passed in `subscribe()`.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
fun unsubscribe() {
  // Unsubscribe 'CHAT' topic
  meeting!!.pubSub.unsubscribe("CHAT", pubSubMessageListener)
}
```

</TabItem>

<TabItem value="Java">

```js
public void unsubscribe(){
  // Unsubscribe 'CHAT' topic
  meeting.pubSub.unsubscribe("CHAT", pubSubMessageListener);
}
```

</TabItem>

</Tabs>

## Applications of usePubSub

PubSub is a very powerful mechanism which can be used to do alot of things which can make your meeting experience much more interactive. Some of the most common usecase that we have come across for the PubSub during a meeting are listed below:

1. [`Chat`](./chat-using-pubsub): You can utilise this to develop various Chat features, such as Private Chat and Group Chat. You can follow our chat [integration guide here](./chat-using-pubsub).
2. `Raise Hand`: You can allow attendees to raise their hands at any time during the meeting, informing everyone else that someone has done so.
3. `Poll`: You may make polls, let users respond to them, and display the results at the end of a poll.
4. `Question Answer Session`: You can also design interactive functionality that is question-and-answer based.

### Downloading PubSub Messages

All the messages from the PubSub which were published with `persist : true` and can be downloaded as an `.csv` file. This file will be available in the VideoSDK dashboard as well as throught the [Sessions API](/api-reference/realtime-communication/fetch-session-using-sessionid).

### API Reference

The API references for all the methods and events utilised in this guide are provided below.

- [pubSub()](/android/api/sdk-reference/pubsub-class/introduction)


---

---
title: Raise Hand with PubSub - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: PubSub features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Raise Hand using PubSub
pagination_label: Raise Hand using PubSub
keywords:
  - Raise Hand
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: raise-hand-using-pubsub
---

# Raise Hand using PubSub - Android

Let us see, how we can use PubSub to implement Raise Hand functionality. If you are not familiar with the PubSub mechanism and `pubSub` class, you can [follow this guide](./pubsub).

## Implementing Raise Hand

1. First step in raise hand is choosing the topic which all the participants will publish and subscribe to know some participant raise their hand. We will be using `RAISE_HAND` as the topic for this one.
2. On the raiseHand button, publish any message to that specific topic.

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
class MainActivity : AppCompatActivity() {

  override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    setContentView(R.layout.activity_main)

    //...

    findViewById(R.id.btnRaiseHand).setOnClickListener(view -> sendRaiseHandMessage());
  }

  private fun sendRaiseHandMessage() {
    val publishOptions = PubSubPublishOptions()
    publishOptions.setPersist(false)

    // Sending the Message using the publish method
    //highlight-next-line
    meeting!!.pubSub.publish("RAISE_HAND", "Raise Hand", publishOptions)
  }
}
```

</TabItem>

<TabItem value="Java">

```js
public class MainActivity extends AppCompatActivity {
  @Override
  protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_chat);

    //...

    findViewById(R.id.btnRaiseHand).setOnClickListener(view -> sendRaiseHandMessage());
  }

  private void sendRaiseHandMessage()
  {
    PubSubPublishOptions publishOptions = new PubSubPublishOptions();
    publishOptions.setPersist(false);

    // Sending the Message using the publish method
    //highlight-next-line
    meeting.pubSub.publish("RAISE_HAND", "Raise Hand", publishOptions);
  }
}
```

</TabItem>

</Tabs>

3. Now let us show an alert to all the participants showing who raised the hand.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
class MainActivity : AppCompatActivity() {

  // PubSubMessageListener
  //highlight-start
  var pubSubMessageListener =
    PubSubMessageListener { message ->
      // Participant raise hand
      Toast.makeText(
            this@MainActivity, message.senderName + " raise hand",
            Toast.LENGTH_SHORT
        ).show()
  }
  //highlight-end

  override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    setContentView(R.layout.activity_chat)

    //...

    // Subscribe for 'RAISE_HAND' topic
    //highlight-next-line
    val pubSubMessageList = meeting!!.pubSub.subscribe("RAISE_HAND", pubSubMessageListener)
  }
}
```

</TabItem>

<TabItem value="Java">

```js
public class MainActivity extends AppCompatActivity {

  // PubSubMessageListener
  //highlight-start
  private PubSubMessageListener pubSubMessageListener = new PubSubMessageListener() {
    @Override
    public void onMessageReceived(PubSubMessage message) {
        // Participant raise hand
        Toast.makeText(
          MainActivity.this, message.senderName + " raise hand",
          Toast.LENGTH_SHORT
        ).show();
    }
  };
  //highlight-end

  @Override
  protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);

    //..

    // Subscribe for 'RAISE_HAND' topic
    //highlight-next-line
    List<PubSubMessage> pubSubMessageList = meeting.pubSub.subscribe("RAISE_HAND", pubSubMessageListener);
  }
}
```

</TabItem>

</Tabs>

### API Reference

The API references for all the methods and events utilised in this guide are provided below.

- [pubSub()](/android/api/sdk-reference/pubsub-class/introduction)


---

---
title: Render Whiteboard - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: Whiteboard is a digital canvas that allows users to collaborate in real-time by drawing, writing, and sharing ideas visually, making it ideal for brainstorming, presentations, and teamwork.
sidebar_label: Render Whiteboard
pagination_label: Render Whiteboard
keywords:
  - Start Livestream meeting
  - Stop Livestream meeting
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg2
sidebar_position: 1
slug: render-whiteboard
---

# Render Whiteboard - Android

This guide explains how to dynamically render a whiteboard in your Android application.

## Setup WebView

- The whiteboard is rendered using a `WebView` component.
- You can configure the required XML style using the following code

```js
<WebView
    android:id="@+id/webView"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    />
```

## Render the Whiteboard

You can start the whiteboard with `meeting.startWhiteboard()` method, which triggers the `onWhiteboardStarted()` event. The event provides the URL to load in the WebView for rendering. To stop it, call `meeting.stopWhiteboard()`, which triggers the `onWhiteboardStopped()` event.

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
class MeetingActivity : AppCompatActivity() {

    private lateinit var meeting: Meeting
    private lateinit var webView: WebView

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_meeting)

        webView = findViewById(R.id.webView)

        // Init and config meeting
        // meeting = ...

        meeting.addEventListener(meetingEventListener);

        val meetingEventListener = object : MeetingEventListener() {
            override fun onWhiteboardStarted(url: String) {
                super.onWhiteboardStarted(url)
                webView.loadUrl(url)
                webView.settings.javaScriptEnabled = true
                webView.webViewClient = WebViewClient()
            }

            override fun onWhiteboardStopped() {
                super.onWhiteboardStopped()
                //...
            }
        }

        findViewById<View>(R.id.btnStartWhiteboard).setOnClickListener {
            meeting.startWhiteboard()
        }

        findViewById<View>(R.id.btnStopWhiteboard).setOnClickListener {
            meeting.stopWhiteboard()
        }
    }
}
```

</TabItem>

<TabItem value="Java">

```js
public class MeetingActivity extends AppCompatActivity {
    
    private Meeting meeting;
    private WebView webView ;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        //...

        webView = findViewById(R.id.webView);
        /* 
        init and config meeting ...
        meeting = //...
        */
        meeting.addEventListener(meetingEventListener);
        
        final MeetingEventListener meetingEventListener = new MeetingEventListener() {
            //...
            @Override
            public void onWhiteboardStarted(String url) {
                super.onWhiteboardStarted(url);
                webView.loadUrl(url);
                webView.getSettings().setJavaScriptEnabled(true);
                webView.setWebViewClient(new WebViewClient());
            }

            @Override
            public void onWhiteboardStopped() {
                super.onWhiteboardStopped();
                //...
            }
        };

        findViewById(R.id.btnStartWhiteboard).setOnClickListener(v -> {
            meeting.startWhiteboard();
        });

        findViewById(R.id.btnStopWhiteboard).setOnClickListener(v -> {
            meeting.stopWhiteboard();
        });
    }
}
```

</TabItem>

</Tabs>


## API Reference

- [startWhiteboard()](/android/api/sdk-reference/meeting-class/methods#startwhiteboard)
- [stopWhiteboard()](/android/api/sdk-reference/meeting-class/methods#stopwhiteboard)
- [onWhiteboardStarted()](/android/api/sdk-reference/meeting-class/meeting-event-listener-class#onwhiteboardstarted)
- [onWhiteboardStopped()](/android/api/sdk-reference/meeting-class/meeting-event-listener-class#onwhiteboardstopped)




---

---
title: Upload & Fetch Temporary File | Video SDK
hide_title: true
hide_table_of_contents: false
description: Upload & Fetch Temporary File.
sidebar_label: Upload-Fetch Temporary File
pagination_label: Upload-Fetch Temporary File
keywords:
  - upload temporary file
  - fetch temporary file
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: upload-fetch-temporary-file
--- 

# Upload and Retrieve the Temporary File - Android

This guide demonstrates how to upload and retrieve files from VideoSDK's temporary file storage system.

### `uploadBase64File()`

- By using the `uploadBase64File()` method of the [`Meeting`](/android/api/sdk-reference/meeting-class/introduction) class, you can upload your file to Videosdk's Temporary storage.

- The `uploadBase64File()` method only works with `base64`. Therefore, it is necessary to convert your file into `base64` format.

- You have to pass `base64Data`,`token`,`fileName` and implementation of `TaskCompletionListener` as parameter in `uploadBase64File()` method.

- When the upload is complete, the `onComplete()` method of `TaskCompletionListener` will provide the corresponding `fileUrl`, which can be used to retrieve the uploaded file.

- If an error occurs during the upload process, the `onError()` method of `TaskCompletionListener` will provide the error details.

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
private fun uploadFile() {
  val base64Data = "<Your File's base64>" // Convert your file to base64 and pass here
  val token = "<VIDEOSDK_TOKEN>"
  val fileName = "myImage.jpeg" // Provide name with extension here
  meeting!!.uploadBase64File(
    base64Data,
    token,
    fileName,
    object : TaskCompletionListener<String?, String?> {
      override fun onComplete(data: String?) {
          Log.d("VideoSDK", "Uploaded file url: $data")
      }

      override fun onError(error: String?) {
          Log.d("VideoSDK", "Error in upload file: $error")
      }
    }
  )
}
```

</TabItem>

<TabItem value="Java">

```js
private void uploadFile() {
  String base64Data = "<Your File's base64>"; // Convert your file to base64 and pass here
  String token = "<VIDEOSDK_TOKEN>";
  String fileName = "myImage.jpeg"; // Provide name with extension here
  meeting.uploadBase64File(base64Data, token, fileName, new TaskCompletionListener<String, String>() {
    @Override
    public void onComplete(@Nullable String data) {
        Log.d("VideoSDK", "Uploaded file url: " + data);
    }

    @Override
    public void onError(@Nullable String error) {
        Log.d("VideoSDK", "Error in upload file: " + error);
    }
  });
}
```

</TabItem>

</Tabs>


### `fetchBase64File()`

- By using the `fetchBase64File()` method of the [`Meeting`](/android/api/sdk-reference/meeting-class/introduction) class, you can retrieve your file from Videosdk's Temporary storage.

- To retrieve a file, you need to pass the `fileUrl` (which is returned by the `uploadBase64File()` method), the `token`, and an implementation of the `TaskCompletionListener` as parameters.

- When the fetch operation is complete, the `onComplete()` method of `TaskCompletionListener` will provide the file in `base64` format.

- If an error occurs during the fetch operation, the `onError()` method of `TaskCompletionListener` will provide the error details.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
private fun fetchFile() {
  val url = "<Your FileUrl>"  // Provide fileUrl which is returned by uploadBase64File()
  val token = "<VIDEOSDK_TOKEN>"
  meeting.fetchBase64File(url, token, object : TaskCompletionListener<String?, String?> {
      override fun onComplete(data: String?) {
          Log.d("VideoSDK", "Fetched file in base64:$data")
      }

      override fun onError(error: String?) {
          Log.d("VideoSDK", "Error in fetch file: $error")
      }
  })
}
```

</TabItem>

<TabItem value="Java">

```js
private void fetchFile() {
  String url = "<Your FileUrl>";  // Provide fileUrl which is returned by uploadBase64File()
  String token = "<VIDEOSDK_TOKEN>";
  meeting.fetchBase64File(url, token, new TaskCompletionListener<String, String>() {
      @Override
      public void onComplete(@Nullable String data) {
          Log.d("VideoSDK", "Fetched file in base64:" + data);
      }

      @Override
      public void onError(@Nullable String error) {
          Log.d("VideoSDK", "Error in fetch file: " + error);
      }
  });
}
```

</TabItem>

</Tabs>


:::note

The file stored in the system will be automatically deleted once the current room/meeting comes to an end.

:::

### API Reference

The API references for all the methods and events utilised in this guide are provided below.

- [uploadBase64File()](/android/api/sdk-reference/meeting-class/methods#uploadbase64file)
- [fetchBase64File()](/android/api/sdk-reference/meeting-class/methods#fetchbase64file)

---

---
title: Whiteboard - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: Whiteboard is a digital canvas that allows users to collaborate in real-time by drawing, writing, and sharing ideas visually, making it ideal for brainstorming, presentations, and teamwork.
sidebar_label: Start/Stop Whiteboard
pagination_label: Start/Stop Whiteboard
keywords:
  - Start Livestream meeting
  - Stop Livestream meeting
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg2
sidebar_position: 1
slug: whiteboard
---

# Whiteboard - Android

The Whiteboard is an interactive, shared canvas that enables users to collaborate in real-time within your Android application. It allows multiple participants to draw, write, and add annotations simultaneously, making it ideal for meetings, presentations, brainstorming sessions, and other collaborative activities.

This documentation will guide you on how to start and stop the whiteboard, and handle the necessary events to ensure a smooth user experience.

## `startWhiteboard()`

- To start the whiteboard session, you can call the `startWhiteboard()` method of the `meeting` class, which initializes the whiteboard and makes it available for user interaction.

### Events associated with startWhiteboard

- All participants will receive the `onWhiteboardStarted` event from the `MeetingEventListener` when the whiteboard starts successfully. This event provides a URL that can be used to render and interact with the whiteboard within the app.

- The whiteboard URL can be displayed using a `WebView` component, allowing participants to interact seamlessly within the app. For detailed instructions on rendering the whiteboard, refer to this [guide](/android/guide/video-and-audio-calling-api-sdk/collaboration-in-meeting/render-whiteboard).


import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
val meetingEventListener = object : MeetingEventListener() {
    override fun onWhiteboardStarted(url: String) {
        super.onWhiteboardStarted(url)
        //...
    }
    //...
    meeting!!.addEventListener(meetingEventListener)
}
```

</TabItem>

<TabItem value="Java">

```js
final MeetingEventListener meetingEventListener = new MeetingEventListener() {
    @Override
    public void onWhiteboardStarted(String url) {
        super.onWhiteboardStarted(url);
        //...
    }
    //...
    meeting!!.addEventListener(meetingEventListener)
};
```

</TabItem>

</Tabs>

## `stopWhiteboard()`

- To end the whiteboard session, you can call the `stopWhiteboard()` method of the `meeting` class, which terminates the active whiteboard and cleans up any resources associated with it.

### Events associated with stopWhiteboard

- All participants will receive the `onWhiteboardStopped` event from the `MeetingEventListener` when the whiteboard session is successfully terminated. This event signals that the whiteboard is no longer available for interaction within the app.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
val meetingEventListener = object : MeetingEventListener() {
    override fun onWhiteboardStopped() {
        super.onWhiteboardStopped()
        //...
    }
    //...
    meeting!!.addEventListener(meetingEventListener)
}
```

</TabItem>

<TabItem value="Java">

```js
final MeetingEventListener meetingEventListener = new MeetingEventListener() {
    @Override
    public void onWhiteboardStopped() {
        super.onWhiteboardStopped();
        //...
    }
    //...
    meeting!!.addEventListener(meetingEventListener)
};
```

</TabItem>

</Tabs>


## API Reference

- [startWhiteboard()](/android/api/sdk-reference/meeting-class/methods#startwhiteboard)
- [stopWhiteboard()](/android/api/sdk-reference/meeting-class/methods#stopwhiteboard)
- [onWhiteboardStarted()](/android/api/sdk-reference/meeting-class/meeting-event-listener-class#onwhiteboardstarted)
- [onWhiteboardStopped()](/android/api/sdk-reference/meeting-class/meeting-event-listener-class#onwhiteboardstopped)




---

---
title: VideoView Video & Audio Call - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: VideoView component quick integrate in Android with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: VideoView
pagination_label: VideoView
keywords:
  - SurfaceViewRender
  - VideoView
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: videoView
---

import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>

# What is SurfaceViewRender ?

`SurfaceViewRender` is a very powerful component of `WebRTC` since it is used to display the video stream on a SurfaceView. You can use `SurfaceViewRender` to show video of participant in your screen.

Here's the lifecycle of a SurfaceViewRenderer:

<div style={{textAlign: 'center'}}>

<img style={{height: '200px'}} src="/img/android/VideoView/life-cycle.png" />

</div>

Which means:

1. The SurfaceViewRenderer must be first initialised after being created and before it can be use at all. It starts a render thread.

2. `addSink()` needs to be called when you are having VideoTrack to render. addSink is method of `VideoTrack` that you want to add to it. You have to pass `surfaceViewRender` as parameter.

3. `removeSink()` should only be called when you're done showing the video. Another method of `VideoTrack`, and it takes the `surfaceViewRenderer` as a parameter.

4. Release at last to allow the render thread to terminate. This function should be called before the activity is destroyed and/or before init it again.

#### Mistakes you might make and stuck :

###### 1. Not initialised surfaceViewRender

The video never appears since a render thread was never start and you will see black view.

###### 2. Init it again before releasing it.

If you are not releasing surfaceViewRender before calling `init()` again, you will get this error.

```js
java.lang.IllegalStateException: svrParticipant Already initialized
        at org.webrtc.EglRenderer.init(EglRenderer.java:212)
```

###### 3. Two videos render on same SurfaceViewRender

If you called `addSink()` on the same `SurfaceViewRenderer` for two different tracks and did not call `removeSink` before that, then you will see two different videos on same SurfaceViewRenderer with flickers which would look like this :

import ReactPlayer from 'react-player'

<div style={{textAlign: 'center'}}>

<ReactPlayer controls url="/img/android/VideoView/android-flicker.mp4" height="500px" width={"100%"} />

</div>

<br/>

Too complicated right? However, VideoSDK makes it simple for you. You can use `VideoView` instead of `SurfaceViewRenderer`.

:::info

- If you want to use `VideoView`, please update SDK version to `0.1.13` or higher.

:::

### VideoView

`VideoView` provides a better abstraction to render live video and handles edge cases like managing init state, render more than one videos on same surfaceViewRender.

### Methods

1. **addTrack(VideoTrack videoTrack)** - `addTrack` will initialised SurfaceViewRender for you and render videoTrack that you provided.

2. **removeTrack()** - `removeTrack` should only be called when you're done showing the video.

3. **releaseSurfaceViewRenderer()** - `releaseSurfaceViewRenderer` should be called before the activity is destroyed.

#### How to use VideoView ?

##### Layout

```js
// <org.webrtc.SurfaceViewRenderer
//        android:id="@+id/svrParticipant"
//        android:layout_width="match_parent"
//        android:layout_height="match_parent" />

<live.videosdk.rtc.android.VideoView
  android:id="@+id/participantView"
  android:layout_width="match_parent"
  android:layout_height="match_parent"
/>
```

##### Initalising and adding video track

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
// svrParticipant.init(PeerConnectionUtils.getEglContext(), null)
// var track = stream.getTrack() as VideoTrack
// track!!.addSink(svrParticipant)

val track = stream.track as VideoTrack
participantView!!.addTrack(track);
```

</TabItem>

<TabItem value="Java">

```js
// svrParticipant.init(PeerConnectionUtils.getEglContext(), null);
// VideoTrack track = (VideoTrack) stream.getTrack();
// track.addSink(svrParticipant);

VideoTrack track = (VideoTrack) stream.getTrack();
participantView.addTrack(track);
```

</TabItem>

</Tabs>

##### removeTrack

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
// var track = stream.track as VideoTrack
// track!!.removeSink(svrParticipant);

participantView.removeTrack();
```

</TabItem>

<TabItem value="Java">

```js
// VideoTrack track = (VideoTrack) stream.getTrack();
// if (track != null) track.removeSink(svrParticipant);

participantView.removeTrack();
```

</TabItem>

</Tabs>

#### release

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
override fun onDestroy() {
        participantView.releaseSurfaceViewRenderer()
        super.onDestroy()
}
```

</TabItem>

<TabItem value="Java">

```js
@Override
protected void onDestroy() {
    participantView.releaseSurfaceViewRenderer();
    super.onDestroy();
}
```

</TabItem>

</Tabs>


---

---
sidebar_label: Concept And Architecture
pagination_label: Concept And Architecture
---

# Concept and Architecture - Android

Before diving into the concept, let's understand the VideoSDK, VideoSDK is a software development kit that offers tools and APIs for creating apps that are based on video and audio. It typically includes features such as video and audio calls, chat, cloud recording, simulcasting (RTMP), interactive live streaming (HLS), and many more across a wide range of platforms and devices.

## Concepts

![img.png](/img/room-concept.png)

### `1. Meeting / Room`

- Meeting or Room object in the VideoSDK provide a virtual place for participants to interact and engage in real-time voice, video, and screen-sharing sessions. The object is in charge of handling media streams and participant communication.

- Meeting or Room can be uniquely identified by `meetingId` or `roomId`.

### `2. Participant`

- Participant is a VideoSDK object that represents each user/client in the meeting or room and allows them to share audio/video assets.

- `2.1 Local Participant` :
  The local participant is the one that runs on the user's device. The local participant has control over their own media streams, including the ability to start and stop audio and video.

  - The local participant in a meeting/room can also connect with other participants by transmitting and receiving audio and video streams, exchanging chat messages, and more.

- `2.2 Remote Participant` :
  The remote participant receives audio and video streams from the local participant and other remote participants and also has the ability to exchange audio, video, and chat messages with the local participant.

- Each participant in VideoSDK can be uniquely identified by `participantId`.

### `3. MediaStream & Track`

- A mediastream is a collection of audio & video tracks that can be transmitted between participants in real-time.

- A track is a continuous flow of audio or video data and can be thought of as a stream of media frames.

- A mediastream can contain multiple tracks. One video track for the video feed from the camera and one audio track for the audio feed from the microphone. These tracks can be transmitted between participants in VideoSDK Meeting / Room.

### `4. Events / Notifications`

- Events / Notifications can be used to inform users about various activities happening in a Meeting / Room, including participant join/leave and new messages. They can also be used to alert users about any SDK-level errors that occur during a call.

### `5. Session`

- A Session is the instance of an ongoing meeting/room which has one or more participants in it. A single room or meeting can have multiple sessions.
- Each session can be uniquely identified by `sessionId`.

![img.png](/img/meeting-session.jpg)

---

![img.png](/img/recording-hls-rtmp.png)

### `6. Cloud Recording`

- Cloud recording in VideoSDK refers to the process of recording audio or video content and storing it on a remote server or VideoSDK server.

### `7. Simulcasting (RTMP)`

- RTMP is a popular protocol for live streaming video content from a VideoSDK to platforms such as YouTube, Twitch, Facebook, and others.
- By providing the platform-specific `stream key` and `stream URL`, the VideoSDK can connect to the platform's RTMP server and transmit the live video stream.

### `8. Http Live Streaming (HLS)`

- Interactive live streaming (HLS) refers to a type of live streaming where viewers can actively engage with the content being streamed and with other viewers in real-time.

- In an interactive live stream (HLS), viewers can take part in a variety of activities like live polling, Q&A sessions, and even sending virtual gifts to the content creator or each other.

## Architecture

This diagram demonstrates end-to-end flow to implement video & audio calls, record calls, and go live on social media.

![Video-sdk-architecture!](/img/video-sdk-archietecture.svg)


---

---
title: Mute All Participants | Video SDK
hide_title: true
hide_table_of_contents: false
description: Video SDK and Audio SDK, developers need to implement a token server. This requires efforts on both the front-end and backend.
sidebar_label: Mute All Participants
pagination_label: Mute All Participants
keywords:
  - audio calling
  - video calling
  - real-time communication
  - collaboration
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: mute-all-participants
---

# Mute All Participants - Android

If you are the host or moderator of a video conference, you may want to mute all the participants at once. This can be useful in various scenarios, such as when you want to deliver a presentation or when there is background noise that is causing distractions.

- To achieve this, you have to iterate over the list of participants from the `Meeting` class and call `disableMic` method from `Participant` class.

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
btnMuteAllParticipant!!.setOnClickListener { _: View? ->
  var participants: Iterator<Participant> = meeting.participants.values.iterator()
  for (i in 0 until meeting.participants.size) {
      val participant = participants.next()
      participant.disableMic()
  }
}
```

</TabItem>

<TabItem value="Java">

```js
btnMuteAllParticipant.setOnClickListener(new View.OnClickListener() {
  @Override
  public void onClick(View v) {
    final Iterator<Participant> participants = meeting.getParticipants().values().iterator();
    for (int i = 0; i < meeting.getParticipants().size(); i++) {
      final Participant participant = participants.next();
      participant.disableMic();
    }
  }
});
```

</TabItem>

</Tabs>

:::note
Participant who will be muting other participants should have permission **`allow_mod`** passed in the token. To know more about permissions [**visit here**](/android/guide/video-and-audio-calling-api-sdk/authentication-and-token).
:::

### API Reference

The API references for all the methods and events utilised in this guide are provided below.

- [disableMic()](/android/api/sdk-reference/participant-class/methods#disablemic)


---

---
title: Toggle Remote Participant Media | Video SDK
hide_title: true
hide_table_of_contents: false
description: Video SDK and Audio SDK, developers need to implement a token server. This requires efforts on both the front-end and backend.
sidebar_label: Toggle Remote Participant Media
pagination_label: Toggle Remote Participant Media
keywords:
  - audio calling
  - video calling
  - real-time communication
  - collaboration
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: remote-participant-media
---

# Toggle Remote Participant Media - Android

When hosting a meeting, it's important that the host of the meeting should be able to request someone's Mic or Camera to be turned on or should be able to turn them off.

:::note
Participant who will be controlling other participant's mic and camera should have permission **`allow_mod`** passed in the token. To know more about permissions [**visit here**](/android/guide/video-and-audio-calling-api-sdk/authentication-and-token).
:::

Before we discuss the methods and events associated with this functionality, here is how the flow would look like.

![img1](../../../../static/img/toggle-remote-media.png)

## Methods

### `enableMic()`

- If you wish to turn **on** the microphone of a participant, you will be calling the `enableMic()` from the `Participant` class.

- When this method is called, the participant whose microphone is requested will receive the `onMicRequested` event with the `participantId` of the participant who requested it and two callback functions `accept` and `reject` which should be called based on decision made by the user.

- **Example:** Meeting is running with **Participant A** and **Participant B**. Now **Participant A** wants to Enable Mic of **Participant B**, so **Participant A** will use `enableMic()` function to request **Participant B**, after that **Participant B** recieve the `onMicRequested` event, from there user can either accept or reject the incoming request.

### `enableWebcam()`

- If you wish to turn **on** the camera of a participant, you will be calling the `enableWebcam()` from the `Participant` class.

- When this method is called, the participant whose camera is requested will receive the `onWebcamRequested` event with the `participantId` of the participant who requested it and two callback functions `accept` and `reject` which should be called based on decision made by the user.

- **Example:** Meeting is running with **Participant A** and **Participant B**. Now **Participant A** wants to Enable Webcam of **Participant B**, so **Participant A** will use `enableWebcam()` function to request **Participant B**, after that **Participant B** recieve the `onWebcamRequested` event, from there user can either accept or reject the incoming request.

### `disableMic()`

- If you wish to turn **off** the microphone of a participant, you will be calling the `disableMic()` from the `Participant` class.
- This will disable the microphone of the participant.

### `disableWebcam()`

- If you wish to turn **off** the camera of a participant, you will be calling the `disableWebcam()` from the `Participant` class.
- This will disable the camera of the participant.

#### Example

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
btnEnableWebcam!!.setOnClickListener { _: View? ->
  // This will emit an event called "onWebcamRequested" to that particular participant
  participant!!.enableWebcam()
}

btnEnableMic!!.setOnClickListener { _: View? ->
  // This will emit an event called "onMicRequested" to that particular participant
  participant!!.enableMic()
}

btnDisableWebcam!!.setOnClickListener { _: View? ->
  // This will disable the webcam of that particular participant
  participant.disableWebcam()
}

btnDisableWebcam!!.setOnClickListener { _: View? ->
  // This will disable the mic of that particular participant
  participant.disableMic()
}
```

</TabItem>

<TabItem value="Java">

```js
btnEnableWebcam.setOnClickListener(new View.OnClickListener() {
    @Override
    public void onClick(View v) {
      // This will emit an event called "onWebcamRequested" to that particular participant
      participant.enableWebcam();
    }
});

btnEnableMic.setOnClickListener(new View.OnClickListener() {
    @Override
    public void onClick(View v) {
      // This will emit an event called "onMicRequested" to that particular participant
      participant.enableMic();
    }
});

btnDisableWebcam.setOnClickListener(new View.OnClickListener() {
    @Override
    public void onClick(View v) {
      // This will disable the webcam of that particular participant
      participant.disableWebcam();
    }
});

btnDisableMic.setOnClickListener(new View.OnClickListener() {
    @Override
    public void onClick(View v) {
      // This will disable the mic of that particular participant
      participant.disableMic();
    }
});
```

</TabItem>

</Tabs>

## Events

### `onWebcamRequested`

This event will be emitted to the `Participant B` when any other `Participant A` requests to enable webcam of that participant (`Participant B`). This event handler will receieve following two arguments:

- `participantId` - ParticipantId of the requesting participant
- `listener`: MicRequestListener \{ accept: Method; reject: Method }

### `onMicRequested`

This event will be emitted to the `Participant B` when any other `Participant A` requests to enable mic of that participant (`Participant B`). This event handler will receieve following two arguments:

- `participantId` - ParticipantId of the requesting participant
- `listener`: MicRequestListener \{ accept: Method; reject: Method }

###### Usage

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
override fun onMicRequested(participantId: String, listener: MicRequestListener) {
  // callback function to accept the request
  listener.accept()

  // callback function to reject the request
  listener.reject()
}

override fun onWebcamRequested(participantId: String, listener: WebcamRequestListener) {
  // callback function to accept the request
  listener.accept()

  // callback function to reject the request
  listener.reject()
}
```

</TabItem>

<TabItem value="Java">

```javascript
@Override
public void onMicRequested(String participantId, MicRequestListener listener) {
  // callback function to accept the request
  listener.accept();

  // callback function to reject the request
  listener.reject();
}

@Override
public void onWebcamRequested(String participantId, WebcamRequestListener listener) {
  // callback function to accept the request
  listener.accept();

  // callback function to reject the request
  listener.reject();
}
```

</TabItem>

</Tabs>

## API Reference

The API references for all the methods and events utilised in this guide are provided below.

- [enableMic()](/android/api/sdk-reference/participant-class/methods#enablemic)
- [disableMic()](/android/api/sdk-reference/participant-class/methods#disablemic)
- [enableWebcam()](/android/api/sdk-reference/participant-class/methods#enablewebcam)
- [disableWebcam()](/android/api/sdk-reference/participant-class/methods#disablewebcam)
- [onMicRequested()](/android/api/sdk-reference/meeting-class/meeting-event-listener-class#onmicrequested)
- [onWebcamRequested()](/android/api/sdk-reference/meeting-class/meeting-event-listener-class#onwebcamrequested)


---

---
title: Remove participant from the meeting - React JS SDK
hide_title: false
hide_table_of_contents: false
description: Remove a participant or a peer from the meeting while it is still in progress. It helps in meeting moderation.
sidebar_label: Remove Participant
pagination_label: Remove Participant
keywords:
  - remove participant
  - block participant
  - react js
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: remove-participant
---

# Remove Participant - Android

This feature in a meeting allows the meeting host or organizer to remove a participant from the meeting. This can be helpful in situations where a participant is causing a disturbance, is behaving inappropriately, or is not following meeting guidelines.

VideoSDK provide three ways to remove participant from meeting.

1. [Using SDK](#1-using-sdk)
2. [Using VideoSDK Dashboard](#2-using-videosdk-dashboard)
3. [Using Rest API](#3-using-rest-api)

## 1. Using SDK

### `remove()`

Remove participant allows removing participant while session is on-going. This can be helpful when moderation in particular meeting is required.

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
btnRemoveParticipant!!.setOnClickListener { _: View? ->
  val remoteParticipantId = "<participant-id>"
  // Get specific participant instance
  val participant = meeting!!.participants[remoteParticipantId]
  // Remove participant from active session
  // This will emit an event called "onParticipantLeft" for that particular participant
  participant!!.remove()
}
```

</TabItem>

<TabItem value="Java">

```js
btnRemoveParticipant.setOnClickListener(new View.OnClickListener() {
  @Override
  public void onClick(View v) {
    String remoteParticipantId = "<participant-id>";
    // Get specific participant instance
    Participant participant = meeting.getParticipants().get(remoteParticipantId);
    // Remove participant from active session
    // This will emit an event called "onParticipantLeft" for that particular participant
    participant.remove();
  }
});
```

</TabItem>

</Tabs>

### Events associated with remove

Following callbacks are received when a participant is removed from the meeting.

- Participant who was removed from the meeting will receive a callback on[`onMeetingLeft`](/android/api/sdk-reference/meeting-class/meeting-event-listener-class#onmeetingleft).
- All other [remote participants](../concept-and-architecture#2-participant) will receive a callback [`onParticipantLeft`](/android/api/sdk-reference/meeting-class/meeting-event-listener-class#onparticipantleft) with Participant object.

## 2. Using VideoSDK Dashboard

- You can go the session page on [VideoSDK Dashboard](https://app.videosdk.live/meetings/sessions) and select the meeting you can to remove a participant from.
- And then from the participants list you can remove any participant you want.

import ReactPlayer from 'react-player'

<div style={{textAlign: 'center'}}>

<ReactPlayer autoplay muted loop playing url='/video/kickout-user.mp4' width={"100%"}/>

</div>

## 3. Using Rest API

- You can also remove the particular participant from the meeting [using the REST API](/api-reference/realtime-communication/remove-participant).
- To use this method, you should have the `sessionId` of the meeting and `participantId` of the participant who is supposed to be removed.

## API Reference

The API references for all the methods and events utilised in this guide are provided below.

- [remove()](/android/api/sdk-reference/participant-class/methods#remove)
- [onMeetingLeft()](/android/api/sdk-reference/meeting-class/meeting-event-listener-class#onmeetingleft)
- [onParticipantLeft()](/android/api/sdk-reference/meeting-class/meeting-event-listener-class#onparticipantleft)


---

---
title: Integrate Banuba SDK with Android SDK - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: Describes how to integrate Banuba SDK with videosdk.live using Android SDK to enhance video calls with real-time face filters and virtual backgrounds.
sidebar_label: "Banuba Integration"
pagination_label: "Banuba Integration"
keywords:
  - android sdk
  - java sdk
  - kotlin sdk
  - banuba
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: banuba-integration
---

import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>

# How to intergrate Banuba SDK with Android Video SDK?

Use Banuba SDK with Android SDK to enhance video calls with real-time face filters and virtual backgrounds.

### Step 1: Banuba Token

- To start working with the Banuba SDK into your project, you need to have the client token. To receive the client token please fill form on [banuba.com](https://www.banuba.com/)

### Step 2: Add Banuba SDK dependencies

- With the client token, you will also receive the Banuba SDK archive for Android which contains Banuba Effect Player (compiled Android library project with .aar extension), Banuba SDK (compiled Android library project with .aar extension) and example filters located under effects folder.

- Create `libs` directory in your project and add `banuba_effect_player.aar`, `banuba_sdk.aar` files.

<div style={{textAlign: 'center'}}>

![Banuba SDK dependency .aar files](/img/android/banuba/banuba_dependency.png)

</div>

- Open build.gradle (Module: app) and add Banuba SDK dependencies.

```js title="app/build.gradle"
dependencies {
  // Banuba SDK dependencies
   implementation fileTree(dir: 'libs', include: ['*.aar'])

  // other app dependencies
  }
```

### Step 3: Add effects into your project

- Create `effects` folder under `assets` directory in your project and add filters that you want to use in the `effects` folder.You can download test effects here: [Effects](https://docs.banuba.com/face-ar-sdk-v1/overview/demo_face_filters)

<div style={{textAlign: 'center'}}>

![Banuba SDK effects folder](/img/android/banuba/banuba_effects.png)

</div>

### Step 4: Integrate Banuba

1. Create one interface named `IVideoFrameProcessor` and a class named `BanubaProcessor` in your project and copy paste code from the [example](https://github.com/videosdk-live/videosdk-rtc-android-sdk-banuba-example).

2. Update your Banuba client token into `BanubaProcessor.java` file.

```js title="BanubaProcessor.java"
public class BanubaProcessor implements IVideoFrameProcessor {
    //...
    public static final String KEY = "place_your_token_here";
    //...
}
```

3. Create instance of `CapturerObserver` class and pass into VideoSDK.createCameraVideoTrack() method. To know more about createCameraVideoTrack() method please visit [CustomVideoTrack](../features/custom-track/custom-video-track.md).

4. Copy paste method named `initVideoFrameProcessor(VideoSource videosource,CustomStreamTrack videoCustomTrack)` from the [example](https://github.com/videosdk-live/videosdk-rtc-android-sdk-banuba-example). into your Activity and call it after creating `CustomStreamTrack` for video.

### Step 5: Use filters in Meeting

- If you want to use video filters from start of the meeting, you can pass `CustomStreamTrack` in the `initMeeting`.

- Also you can use video filters during the meeting by passing the `CustomStreamTrack` in the `enableWebcam()` method of Meeting.

:::tip

Stuck anywhere? Check out this [Code Sample of Banuba Intergation with Android-SDK](https://github.com/videosdk-live/videosdk-rtc-android-sdk-banuba-example.git) on GitHub

:::


---

---
title: Camera Controls Video & Audio Call - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: Camera Controls features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Camera Controls
pagination_label: Camera Controls
keywords:
  - Camera on
  - Camera off
  - Webcam on
  - Webcam off
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: camera-controls
---

import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>

# Camera Controls - Android

Whenever any participant wants to start/stop broadcasting their video to other participant in a meeting, they can simply do it with VideoSDK Meeting.

This guide will provide an overview of how to implement enable, disable and switch webcam features in a meeting.

1. **Enable Camera** - By using `enableWebcam()` function, a participant can publish camera stream to other participants.
2. **Disable Camera** - By using `disableWebcam()` function, a participant can stop publishing camera stream to other participants.
3. **Switch Camera** - By using `changeWebcam()` function, a participant can stream from front / rear camera during the meeting.This function is only applicable for Mobile devices.

### Enable, Disable And Switch Webcam

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
  btnWebcam!!.setOnClickListener {

    // Toggle participant webcam in meeting
    if (webcamEnabled) {
      meeting!!.disableWebcam()
    } else {
      meeting!!.enableWebcam()
    }

    // Change Webcam in Meeting
    meeting!!.changeWebcam()
  }
```

</TabItem>

<TabItem value="Java">

```js
  btnWebcam.setOnClickListener(new View.OnClickListener() {
      @Override
      public void onClick(View v) {

        // Toggle participant webcam in meeting
        if (webcamEnabled) {
          meeting.disableWebcam();
        } else {
          meeting.enableWebcam();
        }

         // Change Webcam in Meeting
        meeting.changeWebcam();
      }
  });
```

</TabItem>

</Tabs>

### Events

**Event associated with `enableWebcam()`:**

- Every Participant will receive a callback on [`onStreamEnabled()`](../../../api/sdk-reference/participant-class/participant-event-listener-class.md#onstreamenabled) of the [`Participant`](../../../api/sdk-reference/participant-class//introduction.md) with `Stream` object.

**Event associated with `disableWebcam()`:**

- Every Participant will receive a callback on [`onStreamDisabled()`](../../../api/sdk-reference/participant-class/participant-event-listener-class.md#onstreamenabled) of the [`Participant`](../../../api/sdk-reference/participant-class//introduction.md) with `Stream` object.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
  meeting!!.localParticipant.addEventListener(object : ParticipantEventListener() {
    override fun onStreamEnabled(stream: Stream) {
        //

        if(stream.getKind().equals("video")){
          //participant turned on video
          //Render participant video
        }
    }

    override fun onStreamDisabled(stream: Stream) {
        //

        if(stream.getKind().equals("video")){
          //participant turned off video
          //remove participant video
        }
    }
  });
```

</TabItem>

<TabItem value="Java">

```js
  participant.addEventListener(new ParticipantEventListener() {
    @Override
    public void onStreamEnabled(Stream stream) {
        //
        if(stream.getKind().equals("video")){
          //participant turned on video
          //Render participant video
        }
    }

    @Override
    public void onStreamDisabled(Stream stream) {
        //
        if(stream.getKind().equals("video")){
          //participant turned off video
          //remove participant video
        }
    }
  });
```

</TabItem>

</Tabs>


---

---
title: Custom Audio Track
hide_title: false
hide_table_of_contents: false
description: Custom Audio Track features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Custom Audio Track
pagination_label: Custom Audio Track
keywords:
  - Camera on
  - Camera off
  - Webcam on
  - Webcam off
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
---

import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>

# Custom Audio Track - React Native

We have introduced the ability to pass a custom Audio track for the Audio of the participants with different encoder configuration.

## Creating a Custom Audio Track

- You can create a Audio Track using `createAudioTrack()` method of `VideoSDK`.
- This method can be used to create audio track using different encoding parameters.

### Parameters

- **encoderConfig**:

  - type: `String`
  - required: `true`
  - default: `speech_standard`
  - Allowed values : `speech_low_quality` | `speech_standard` | `music_standard` | `standard_stereo` | `high_quality` | `high_quality_stereo`
  - It will be the encoder configuration you want to use for Audio Track.

- **context**

  - type: `Context`
  - required: `true`
  - Pass the Android Context for this parameter.

#### Returns

- `CustomStreamTrack`

### Example

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
try {
  val audioCustomTrack: CustomStreamTrack = VideoSDK.createAudioTrack("high_quality",this)
} catch (e: JSONException) {
   e.printStackTrace()
}
```

</TabItem>

<TabItem value="Java">

```js
try {
  CustomStreamTrack audioCustomTrack=VideoSDK.createAudioTrack("high_quality", this);
}catch (JSONException e) {
  e.printStackTrace();
}
```

</TabItem>

</Tabs>

## Using Custom Audio Track

### Custom Track while initializing the meeting

If you are passing `micEnabled: true` in the `initMeeting` of `VideoSDK` and want to use custom tracks from start of the meeting, you can pass custom track in the `initMeeting` as shown below.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
override fun onCreate(savedInstanceState: Bundle?) {
    //..

    val customTracks: MutableMap<String, CustomStreamTrack> = HashMap()

    val audioCustomTrack: CustomStreamTrack = VideoSDK.createAudioTrack("high_quality", this)
    customTracks["mic"] = audioCustomTrack  //Key must be "mic"

    // create a new meeting instance
    val meeting = VideoSDK.initMeeting(
      this@MainActivity,meetingId,participantName,
      //MicEnabled , If true, it will use the passed custom track to turn mic on
      true,
      //WebcamEnabled
      true,
      //ParticipantId
      null,
      //Mode
      null,
      //Pass the custom tracks here
      customTracks
    )
}
```

</TabItem>

<TabItem value="Java">

```js
@Override
protected void onCreate(Bundle savedInstanceState) {
    //..

    Map<String, CustomStreamTrack> customTracks = new HashMap<>();

    CustomStreamTrack audioCustomTrack = VideoSDK.createAudioTrack("high_quality", this);
    customTracks.put("mic", audioCustomTrack);  //Key must be "mic"

    // create a new meeting instance
    Meeting meeting = VideoSDK.initMeeting(
        MainActivity.this, meetingId, participantName,
       //MicEnabled , If true, it will use the passed custom track to turn mic on
        true,
        //WebcamEnabled
        true,
        //ParticipantId
        null,
        //Mode
        null,
        //Pass the custom tracks here
        customTracks
    );

}
```

</TabItem>

</Tabs>

### Custom Track with `unmuteMic()`

In order to switch tracks during the meeting, you have to pass the `CustomStreamTrack` in the `unmuteMic()` method of `Meeting`.

You can also pass custom track in `changeMic()` method of `Meeting`.

:::note

Make sure to call `muteMic()` before you create a new track as it may lead to unexpected behavior.

:::

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
try {
  val audioCustomTrack: CustomStreamTrack = VideoSDK.createAudioTrack("high_quality", this)
  meeting!!.unmuteMic(audioCustomTrack)

  //or
  meeting!!.changeMic(AppRTCAudioManager.AudioDevice.BLUETOOTH, audioCustomTrack)
} catch (e: JSONException) {
  e.printStackTrace()
}

```

</TabItem>

<TabItem value="Java">

```js
try {
  CustomStreamTrack audioCustomTrack = VideoSDK.createAudioTrack("high_quality", this);
  meeting.unmuteMic(audioCustomTrack);

  //or
  meeting.changeMic(AppRTCAudioManager.AudioDevice.BLUETOOTH,audioCustomTrack);
}catch (JSONException e) {
  e.printStackTrace();
}

```

</TabItem>

</Tabs>


---

---
title: Custom Screen Share Track
hide_title: false
hide_table_of_contents: false
description: Custom Screen Share Track features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Custom Screen Share Track
pagination_label: Custom Screen Share Track
keywords:
  - Camera on
  - Camera off
  - Webcam on
  - Webcam off
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
---

import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>

# Custom Screen Share Track - React Native

We have introduced the ability to pass a custom Screen Share track while sharing the screen of participants. This feature can be used to add custom video encoder config,background removal & video filter from external SDK(e.g., [Banuba](https://www.banuba.com/)) and send it to other participants.

## Creating a Custom Screen Share Track

- You can create a Screen Share track using `createScreenShareVideoTrack()` method of `VideoSDK`.
- This method can be used to create screen share track using different encoding parameters.

### Parameters

- **encoderConfig**:

  - type: `String`
  - required: `true`
  - default: `h720p_15fps`
  - Allowed values : `h360p_30fps` | `h720p_5fps` | `h720p_15fps` | `h1080p_15fps` | `h1080p_30fps`
  - It will be the encoderConfigs you can want to use for the Screen Share Track.

:::note

Above mentioned encoder configurations are valid for both, landscape as well as portrait mode.

:::

- **data**

  - type: `Intent`
  - required: `true`
  - It is Intent received from onActivityResult when user provide permission for ScreenShare.

- **context**

  - type: `Context`
  - required: `true`
  - Pass the Android Context for this parameter.

- **listener**
  - type: `CustomTrackListener`
  - required: `true`
  - Callback to this listener will be made when track is ready with CustomTrack as parameter.

### Example

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
// data is received from onActivityResult method.
VideoSDK.createScreenShareVideoTrack("h720p_5fps", data, this) { track ->
    meeting!!.enableScreenShare(track)
}
```

</TabItem>

<TabItem value="Java">

```javascript
// data is received from onActivityResult method.
VideoSDK.createScreenShareVideoTrack("h720p_5fps", data, this, (track)->{
    meeting.enableScreenShare(track);
});
```

</TabItem>

</Tabs>

## Using Custom Screen Share Track

### Custom Track with `enableScreenShare()`

In order to switch tracks during the meeting, you have to pass the `CustomStreamTrack` in the `enableScreenShare()` method of `Meeting`.

:::note

Make sure to call `disableScreenShare()` before you create a new track as it may lead to unexpected behavior.

:::

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
@TargetApi(21)
private fun askPermissionForScreenShare() {
    val mediaProjectionManager = application.getSystemService<Any>(
        Context.MEDIA_PROJECTION_SERVICE
    ) as MediaProjectionManager
    startActivityForResult(
        mediaProjectionManager.createScreenCaptureIntent(), CAPTURE_PERMISSION_REQUEST_CODE
    )
}

@RequiresApi(api = Build.VERSION_CODES.LOLLIPOP)
override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) {
    super.onActivityResult(requestCode, resultCode, data)
    if (requestCode != CAPTURE_PERMISSION_REQUEST_CODE) return
    if (resultCode == RESULT_OK) {
        VideoSDK.createScreenShareVideoTrack("h720p_5fps", data, this) { track ->
            meeting!!.enableScreenShare(track)
        }
    }
}

```

</TabItem>

<TabItem value="Java">

```javascript
@TargetApi(21)
private void askPermissionForScreenShare() {
    MediaProjectionManager mediaProjectionManager =
        (MediaProjectionManager) getApplication().getSystemService(
            Context.MEDIA_PROJECTION_SERVICE);
    startActivityForResult(
        mediaProjectionManager.createScreenCaptureIntent(), CAPTURE_PERMISSION_REQUEST_CODE);
}

@RequiresApi(api = Build.VERSION_CODES.LOLLIPOP)
@Override
public void onActivityResult(int requestCode, int resultCode, Intent data) {
    super.onActivityResult(requestCode, resultCode, data);
    if (requestCode != CAPTURE_PERMISSION_REQUEST_CODE)
        return;
    if (resultCode == Activity.RESULT_OK) {
        VideoSDK.createScreenShareVideoTrack("h720p_5fps", data, this, (track)->{
            meeting.enableScreenShare(track);
        });
    }
}

```

</TabItem>

</Tabs>


---

---
title: Custom Video Track
hide_title: false
hide_table_of_contents: false
description: Custom Video Track features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Custom Video Track
pagination_label: Custom Video Track
keywords:
  - Camera on
  - Camera off
  - Webcam on
  - Webcam off
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
---

import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>

# Custom Video Track - React Native

We have introduced the ability to pass a custom video track for the video of the participants. This feature can be used to add custom video encoder config, optimization mode (whether you want to focus on **motion**, **text** or **detail** of the video) and background removal & video filter from external SDK(e.g., [Banuba](https://www.banuba.com/))and send it to other participants.

## Creating a Custom Video Track

- You can create a Video Track using `createCameraVideoTrack()` method of `VideoSDK`.
- This method can be used to create video track using different encoding parameters & camera facing mode.

### Parameters

- **encoderConfig**:

  - type: `String`
  - required: `true`
  - default: `h480p_w640p`
  - Allowed values : `h144p_w176p` | `h240p_w320p` | `h480p_w640p` | `h480p_w720p` | `h720p_w960p` | `h1080p_w1440p` | `h720p_w1280p`
  - It will be the encoderConfigs you can want to use for the Video Track.

:::note

Above mentioned encoder configurations are valid for both, landscape as well as portrait mode.

:::

- **facingMode**:

  - type: `String`
  - required: `true`
  - Allowed values : `front` | `back`
  - It will specify wheater to use front or back camera for the video track.

- **optimizationMode**

  - type: `CustomStreamTrack.VideoMode`
  - required: `true`
  - Allowed values: `motion` | `text` | `detail`
  - It will specify the optimization mode for the video track being generated.

- **context**:

  - type: `Context`
  - required: `true`
  - Pass the Android Context for this parameter.

- **observer**:

  - type: `CapturerObserver`
  - required: `false`
  - If you want to use video filter from external SDK(e.g., [Banuba](https://www.banuba.com/)) then pass instance of `CapturerObserver` in this parameter.

:::note

For Banuba integraion with VideoSDK, please visit [Banuba Intergation with VideoSDK](../../video-processor/banuba-integration.md)

:::

#### Returns

- `CustomStreamTrack`

### Example

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
val videoCustomTrack: CustomStreamTrack = VideoSDK.createCameraVideoTrack("h240p_w320p", "front", CustomStreamTrack.VideoMode.MOTION, this)
```

</TabItem>

<TabItem value="Java">

```javascript
CustomStreamTrack customStreamTrack = VideoSDK.createCameraVideoTrack("h240p_w320p", "front", CustomStreamTrack.VideoMode.MOTION, this);
```

</TabItem>

</Tabs>

## Using Custom Video Track

### Custom Track while initializing the meeting

If you are passing `webcamEnabled: true` in the `initMeeting` of `VideoSDK` and want to use custom tracks from start of the meeting, you can pass custom track in the `initMeeting` as shown below.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
override fun onCreate(savedInstanceState: Bundle?) {
    //..

    val customTracks: MutableMap<String, CustomStreamTrack> = HashMap()
    val videoCustomTrack: CustomStreamTrack =
    VideoSDK.createCameraVideoTrack("h240p_w320p", "back", false, CustomStreamTrack.VideoMode.MOTION, this)
    customTracks["video"] = videoCustomTrack  //Key must be "video"

     // create a new meeting instance
    val meeting = VideoSDK.initMeeting(
      this@MainActivity, meetingId, participantName,
      //MicEnabled
      true,
      //WebcamEnabled , If true, it will use the passed custom track to turn webcam on
      true,
      // ParticipantId
      null,
      // Mode
      null,
      //Pass the custom tracks here
      customTracks
    )
}
```

</TabItem>

<TabItem value="Java">

```js
@Override
protected void onCreate(Bundle savedInstanceState) {
    //..

    Map<String, CustomStreamTrack> customTracks = new HashMap<>();

    CustomStreamTrack videoCustomTrack = VideoSDK.createCameraVideoTrack("h240p_w320p", "back", CustomStreamTrack.VideoMode.MOTION, this);
    customTracks.put("video", videoCustomTrack);  //Key must be "video"

    // create a new meeting instance
    Meeting meeting = VideoSDK.initMeeting(
        MainActivity.this, meetingId, participantName,
       //MicEnabled
        true,
        //WebcamEnabled , If true, it will use the passed custom track to turn webcam on
        true,
        // ParticipantId
        null,
        // Mode
        null,
        //Pass the custom tracks here
        customTracks
        );
}
```

</TabItem>

</Tabs>

### Custom Track with `enableWebcam()`

In order to switch tracks during the meeting, you have to pass the `CustomStreamTrack` in the `enableWebcam()` method of `Meeting`.

:::note

Make sure to call `disableWebcam()` before you create a new track as it may lead to unexpected behavior.

:::

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
val customStreamTrack: CustomStreamTrack = VideoSDK.createCameraVideoTrack("h240p_w320p", "back", CustomStreamTrack.VideoMode.MOTION, this)
meeting!!.enableWebcam(customStreamTrack)
```

</TabItem>

<TabItem value="Java">

```javascript
CustomStreamTrack customStreamTrack=VideoSDK.createCameraVideoTrack("h240p_w320p", "back", CustomStreamTrack.VideoMode.MOTION, this);
meeting.enableWebcam(customStreamTrack);
```

</TabItem>

</Tabs>


---

---
sidebar_label: Error Event
pagination_label: Error Event
---

import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>

# Error Event - Android

This event is helpful for development level troubleshooting while integrating SDK.

Whenever any invalid configuration provided or server/network errors arise, this event will trigger with a specific error code and message.

This event can ease your development process.

We have depicted a specific constant with code and message in the below table.

| Constant                              | Code | Message                                                                                                                     |
| ------------------------------------- | ---- | --------------------------------------------------------------------------------------------------------------------------- |
| **INVALID_API_KEY**                   | 4001 | `apikey` provided in the token is empty or invalid, please verify it on the dashboard.                                      |
| **INVALID_TOKEN**                     | 4002 | `token` is empty or invalid or might have expired.                                                                          |
| **INVALID_MEETING_ID**                | 4003 | `meetingId` is empty or invalid, please verify it or generate new meetingId using the API.                                  |
| **INVALID_PARTICIPANT_ID**            | 4004 | `participantId` is empty or invalid, it shouldn't contain any whitespaces.                                                  |
| **DUPLICATE_PARTICIPANT**             | 4005 | Leaving meeting, since this `participantId` joined from another device.                                                     |
| **ACCOUNT_DEACTIVATED**               | 4006 | It seems your account is deactivated by VideoSDK for some reason, you can reach out to us at `support@videosdk.live`.       |
| **ACCOUNT_DISCONTINUED**              | 4007 | Server will respond you with specific message.\_                                                                            |
| **INVALID_PERMISSIONS**               | 4008 | `permissions` provided in the token are invalid, please don't use `allow_join` or `allow_mod` with `ask_join`.              |
| **START_RECORDING_FAILED**            | 4011 | Recording start request failed due to an unknown error.                                                                     |
| **STOP_RECORDING_FAILED**             | 4012 | Recording stop request failed due to an unknown error.                                                                      |
| **START_LIVESTREAM_FAILED**           | 4013 | Livestream start request failed due to an unknown error.                                                                    |
| **STOP_LIVESTREAM_FAILED**            | 4014 | Livestream stop request failed due to an unknown error.                                                                     |
| **MAX_SPEAKER_LIMIT_REACHED_ON_ORGANIZATION**    | 4026 | You have reached max speaker limit on organization. To increase contact at support@videosdk.live".                                                               |
| **MAX_VIEWER_LIMIT_REACHED_ON_ORGANIZATION**    | 4027 | You have reached max viewer limit on organization. To increase contact at support@videosdk.live".                                                               |
| **MAX_RECORDING_LIMIT_REACHED_ON_ORGANIZATION**    | 4028 | You have reached max limit of recording on organization. To increase contact at support@videosdk.live.                                                               |
| **MAX_HLS_LIMIT_REACHED_ON_ORGANIZATION**    | 4029 | You have reached max limit of hls on organization. To increase contact at support@videosdk.live.                                                               |
| **MAX_LIVESTREAM_LIMIT_REACHED_ON_ORGANIZATION**    | 4030 | You have reached max limit of livestream on organization. To increase contact at support@videosdk.live.                                                               |
| **INVALID_LIVESTREAM_CONFIG**         | 4015 | Livestream 'outputs' configuration provided was invalid.                                                                    |
| **PREV_RECORDING_PROCESSING**         | 4018 | Previous recording session is being processed, please try again after few seconds.                                          |
| **RECORDING_FAILED**                  | 5001 | Recording stopped due to an unknown error.                                                                                  |
| **LIVESTREAM_FAILED**                 | 5002 | Livestream stopped due to an unknown error.                                                                                 |
| **RECORDING_DURATION_LIMIT_REACHED**  | 5004 | Recording has been automatically stopped by the system, due to max duration limit of 2 hours reached for a single Recording |
| **LIVESTREAM_DURATION_LIMIT_REACHED** | 5005 | Livestream has been automatically stopped by the system, due to max duration limit of 2 hours reached for a single RTMP     |
| **HLS_DURATION_LIMIT_REACHED**        | 5006 | Hls has been automatically stopped by the system, due to max duration limit of 2 hours reached for a single HLS             |

### Event Code

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
private val meetingEventListener: MeetingEventListener = object : MeetingEventListener() {
    //..
    override fun onError(error: JSONObject) {
    try {
        val errorCodes: JSONObject = VideoSDK.getErrorCodes()
        val code = error.getInt("code")
        if (code == errorCodes.getInt("START_LIVESTREAM_FAILED")) {
            Log.d("#error", "Error is: " + error["message"])
        } else if (code == errorCodes.getInt("START_RECORDING_FAILED")) {
            Log.d("#error", "Error is: " + error["message"])
        }
    } catch (e: Exception) {
            e.printStackTrace()
        }
    }
}
```

</TabItem>

<TabItem value="Java">

```js
private final MeetingEventListener meetingEventListener = new MeetingEventListener() {
    //..
    @Override
    public void onError(JSONObject error) {
        try {
            JSONObject errorCodes = VideoSDK.getErrorCodes();
            int code = error.getInt("code");
            if (code == errorCodes.getInt("START_LIVESTREAM_FAILED")) {
                Log.d("#error", "Error is: " + error.get("message"));
            }else if(code == errorCodes.getInt("START_RECORDING_FAILED"))
            {
                Log.d("#error", "Error is: " + error.get("message"));
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
};
```

</TabItem>

</Tabs>


---

---
title: External Call Detection Video & Audio Call - Video SDK Docs
hide_title: false
hide_table_of_contents: false
sidebar_label: External Call Detection
pagination_label: External Call Detection
keywords:
  - External Call Detection
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: external-call-detection
---

import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>

# External Call Detection - Android

External call detection feature in VideoSDK let you know, participant is on the call during meeting.

Whenever local participant accept the incoming call or place outgoing call, `externalcall-started` event will trigger.`externalcall-started` event only received by localParticipant.

For example, the meeting is running with **Alice** and **Bob**. Whenever **Alice** receives the call or she call someone, **Alice** will receive `externalcall-started` event.

We can access `externalcall-started` event through [meeting object](/android/guide/video-and-audio-calling-api-sdk/features/start-join-meeting).

### externalcall-started Event

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
private val meetingEventListener: MeetingEventListener = object : MeetingEventListener() {
     // ...
    override fun onExternalCallStarted() {
      Log.d("#meeting", "onExternalCallAnswered")
    }
};
```

</TabItem>

<TabItem value="Java">

```js
private final MeetingEventListener meetingEventListener = new MeetingEventListener() {
     // ...
    @Override
    public void onExternalCallStarted() {
        Log.d("#meeting", "onExternalCallStarted");
    }
};
```

</TabItem>

</Tabs>


---

---
title: RTMP Live Social Media Video & Audio Call - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: RTMP Live Social Media features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Go Live On Social Media
pagination_label: Go Live On Social Media
keywords:
  - Facebook Live
  - Youtube Live
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: go-live-social-media
---

import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>

# Go Live On Social Media - Android

This feature allows participant to broadcast meeting on various social media platforms such as Facebook or Youtube.
This guide will provide an overview of how participant can start and stop broadcasting meeting.

1. **Start LiveStream** - By using `startLivestream()` function, a participant can start broadcasting meeting on various platforms by provding url and stream keys as an argument.
2. **Stop LiveStream** - By using `stopLivestream()` function, a participant can stop broadcasting on all platforms.

### Start And Stop Live Stream

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
private val YOUTUBE_RTMP_URL: String? = null
private val YOUTUBE_RTMP_STREAM_KEY: String? = null

//
findViewById<View>(R.id.btnLivestream).setOnClickListener {
    if (!livestreaming) {
        if (YOUTUBE_RTMP_URL == null || YOUTUBE_RTMP_STREAM_KEY == null) {
            throw Error("RTMP url or stream key missing.")
        }
        val outputs: MutableList<LivestreamOutput> = ArrayList()
        outputs.add(LivestreamOutput(YOUTUBE_RTMP_URL, YOUTUBE_RTMP_STREAM_KEY))

        meeting!!.startLivestream(outputs)
    } else {
        meeting!!.stopLivestream()
    }
}
```

</TabItem>

<TabItem value="Java">

```js
private static final String YOUTUBE_RTMP_URL = null;
private static final String YOUTUBE_RTMP_STREAM_KEY = null;

//
findViewById(R.id.btnLivestream).setOnClickListener(view -> {
    if (!livestreaming) {
        if (YOUTUBE_RTMP_URL == null || YOUTUBE_RTMP_STREAM_KEY == null) {
            throw new Error("RTMP url or stream key missing.");
        }

        List<LivestreamOutput> outputs = new ArrayList<>();
        outputs.add(new LivestreamOutput(YOUTUBE_RTMP_URL, YOUTUBE_RTMP_STREAM_KEY));

        meeting.startLivestream(outputs);
    } else {
        meeting.stopLivestream();
    }
});
```

</TabItem>

</Tabs>

### Events

- **onLiveStreamStateChanged** - A `onLiveStreamStateChanged` event will be triggered any time the broadcasting state of a meeting changes.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
object : MeetingEventListener() {
  override fun onLivestreamStateChanged(livestreamState: String?) {
    when (livestreamState) {
        "LIVESTREAM_STARTING" -> Log.d( "LivestreamStateChanged",
            "Meeting livestream is starting"
        )
        "LIVESTREAM_STARTED" -> Log.d( "LivestreamStateChanged",
            "Meeting livestream is started"
        )
        "LIVESTREAM_STOPPING" -> Log.d("LivestreamStateChanged",
            "Meeting livestream is stopping"
        )
        "LIVESTREAM_STOPPED" -> Log.d("LivestreamStateChanged",
            "Meeting livestream is stopped"
        )
    }
  }

}
```

</TabItem>

<TabItem value="Java">

```js
new MeetingEventListener() {
  @Override
  public void onLivestreamStateChanged(String livestreamState) {
      switch (livestreamState) {
          case "LIVESTREAM_STARTING":
              Log.d("LivestreamStateChanged", "Meeting livestream is starting");
              break;
          case "LIVESTREAM_STARTED":
              Log.d("LivestreamStateChanged", "Meeting livestream is started");
              break;
          case "LIVESTREAM_STOPPING":
              Log.d("LivestreamStateChanged", "Meeting livestream is stopping");
              break;
          case "LIVESTREAM_STOPPED":
              Log.d("LivestreamStateChanged", "Meeting livestream is stopped");
              break;
      }
  }
}
```

</TabItem>

</Tabs>


---

---
title: Leave End Meeting Video & Audio Call - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: Leave or End Meeting features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Leave or End Meeting
pagination_label: Leave or End Meeting
keywords:
  - Exit Meeting
  - Leave Meeting
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: leave-end-meeting
---

import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>

# Leave or End Meeting - Android

Whenever participant wishes to end their communication in the meeting, they can simply leave the meeting.

This guide will provide an overview of how to implement leave or end feature in VideoSDK meetings.

1. **Leave** - By using `leave()` function, only a participant will leave/exit the meeting, the rest of the meeting will continue with other participants.
2. **End** - By using `end()` function, meeting will end for each and every participant. So, use this function according to your use cases.

### Leave And End Meeting

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
  btnLeave!!.setOnClickListener { _: View? ->
    meeting!!.leave()
  }

  btnEnd!!.setOnClickListener { _: View? ->
    meeting!!.end()
  }
```

</TabItem>

<TabItem value="Java">

```js
  btnLeave.setOnClickListener(new View.OnClickListener() {
      @Override
      public void onClick(View v) {
        meeting.leave();
      }
  });

  btnEnd.setOnClickListener(new View.OnClickListener() {
      @Override
      public void onClick(View v) {
        meeting.end();
      }
  });
```

</TabItem>

</Tabs>

### Events

**Events associated with `leave()`:**

- Local participant will receive a callback on[`onMeetingLeft`](../../../api/sdk-reference/meeting-class/meeting-event-listener-class.md#onmeetingleft) of `Meeting`.
- All remote participants will receive a callback [`onParticipantLeft`](../../../api/sdk-reference/meeting-class/meeting-event-listener-class.md#onparticipantleft) with Participant object.

**Event associated with `end()`:**

- All remote participants and local participant will receive a callback on [`onParticipantLeft`](../../../api/sdk-reference/meeting-class/meeting-event-listener-class.md#onparticipantleft) with Participant object.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
private final MeetingEventListener meetingEventListener = new MeetingEventListener() {
  override fun onMeetingLeft() {
    Log.d("#meeting", "onMeetingleft()")
  }

  override fun onParticipantLeft(participant: Participant) {
    Log.d("#meeting", participant.displayName + " left");
  }
}
```

</TabItem>

<TabItem value="Java">

```javascript
private final MeetingEventListener meetingEventListener = new MeetingEventListener() {
  @Override
  public void onMeetingLeft() {
    Log.d("#meeting", "onMeetingleft()")
  }

  @Override
  public void onParticipantLeft(Participant participant) {
    Log.d("#meeting", participant.getDisplayName() + " left");
  }
}
```

</TabItem>

</Tabs>


---

---
title: Manage Participants Video & Audio Call - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: Manage Participants features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Manage Participants
pagination_label: Manage Participants
keywords:
  - Exit Meeting
  - Leave Meeting
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: manage-participants
---

import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>

# Manage Participants - Android

## 1. Local Participant (self)

Local participant is used to consume your video & audio streams.
it contains information about local participant such as displayName, id, quality and streams Map.

You can acces localParticipant from the [meeting object](/android/guide/video-and-audio-calling-api-sdk/features/start-join-meeting#2-initialization).

### Participant object properties

| Property Name | Type          | Description                                            |
| ------------- | ------------- | ------------------------------------------------------ |
| id            | string        | Unique id of the participant.                          |
| displayName   | string        | The name you define during the meeting initialization. |
| local         | boolean       | Indicates the participant is local or not.             |
| quality       | string        | Indicates the participant streams quality.             |
| Streams       | Map of Stream | Returns Video & Audio Streams.                         |

### Stream Object properties

| Property Name | Type   | Description        |
| ------------- | ------ | ------------------ |
| id            | string | Unique id          |
| codec         | string | Video/Audio codec. |
| kind          | string | Stream Kind.       |
| track         | string | MediaStreamTrack   |

## 2. Other Participants (Except You)

Other participants Map is used to get all the participants (except you) in the meeting at any given time.

Other participants Map contains same properties as [LocalParticipant](/android/guide/video-and-audio-calling-api-sdk/features/manage-participants#participant-object-properties).

### Local And Other Participants

```xml title="activity_main.xml"
  <live.videosdk.rtc.android.VideoView
      android:id="@+id/localView"
      android:layout_width="80dp"
      android:layout_height="100dp"
      android:layout_gravity="end" />

  <androidx.recyclerview.widget.RecyclerView
      android:id="@+id/rvParticipants"
      android:layout_width="match_parent"
      android:layout_height="match_parent" />
```

:::info

- Here the participant's video is displayed using `VideoView`, but you may also use `SurfaceViewRender` for the same.
- For `VideoView`, SDK version should be `0.1.13` or higher.
- To know more about `VideoView`, please visit [here](/android/guide/video-and-audio-calling-api-sdk/components/videoView)

:::

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js title="MainActivity.kt"
  import live.videosdk.rtc.android.VideoView
  import org.webrtc.VideoTrack

  private fun displayLocalParticipant() {
    var localView: VideoView = findViewById(R.id.localView)

    // display local video when stream available
    meeting!!.localParticipant.addEventListener(
       object : ParticipantEventListener() {
         override fun onStreamEnabled(stream: Stream) {
           if (stream.kind.equals("video", ignoreCase = true)) {
             val videoTrack = stream.track as VideoTrack
             localView.addTrack(videoTrack)
            }
         }
      }
    )
  }

  private fun displayRemoteParticipants() {
    val rvParticipants = findViewById<RecyclerView>(R.id.rvParticipants)
    rvParticipants.layoutManager = GridLayoutManager(this, 2)
    rvParticipants.adapter = ParticipantAdapter(meeting!!)
  }

```

</TabItem>

<TabItem value="Java">

```js title="MainActivity.java"
  import live.videosdk.rtc.android.VideoView;
  import org.webrtc.VideoTrack;

  private void displayLocalParticipant() {
    final VideoView localView = findViewById(R.id.localView);

    // display local video when stream available
    meeting.getLocalParticipant().addEventListener(
        new ParticipantEventListener() {
          @Override
          public void onStreamEnabled(Stream stream) {
            if (stream.getKind().equalsIgnoreCase("video")) {
              VideoTrack track = (VideoTrack) stream.getTrack();
              localView.addTrack(track);
            }
          }
        }
      );
  }

  private void displayRemoteParticipants() {
    final RecyclerView rvParticipants = findViewById(R.id.rvParticipants);
    rvParticipants.setLayoutManager(new GridLayoutManager(this, 2));
    rvParticipants.setAdapter(new ParticipantAdapter(meeting));
  }

```

</TabItem>

</Tabs>

```xml title="item_remote_peer.xml"
<?xml version="1.0" encoding="utf-8"?>
<FrameLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="wrap_content">

    <live.videosdk.rtc.android.VideoView
        android:id="@+id/participantView"
        android:layout_width="match_parent"
        android:layout_height="match_parent" />

</FrameLayout>
```

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js title="ParticipantAdapter.kt"

class ParticipantAdapter(meeting: Meeting) : RecyclerView.Adapter<ParticipantAdapter.PeerViewHolder>() {
    private val participants: MutableList<Participant> = ArrayList()
    private var containerHeight = 0

    init {
        participants.add(meeting.localParticipant)
        meeting.addEventListener(object : MeetingEventListener() {
            override fun onParticipantJoined(participant: Participant) {
                participants.add(participant)
                notifyItemInserted(participants.size - 1)
            }

            override fun onParticipantLeft(participant: Participant) {
                // remove participant from grid
            }
        })
    }

    override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): PeerViewHolder {
        containerHeight = parent.height
        return PeerViewHolder(
            LayoutInflater.from(parent.context)
                .inflate(R.layout.item_remote_peer, parent, false)
        )
    }

    override fun onBindViewHolder(holder: PeerViewHolder, position: Int) {
        val participant = participants[position]

        val layoutParams = holder.itemView.layoutParams
        layoutParams.height = containerHeight / 3
        holder.itemView.layoutParams = layoutParams

        for ((_, stream) in participant.streams) {
            if (stream.kind.equals("video", ignoreCase = true)) {
                val videoTrack = stream.track as VideoTrack
                holder.participantView.addTrack(videoTrack)
                break
            }
        }

        participant.addEventListener(object : ParticipantEventListener() {
            override fun onStreamEnabled(stream: Stream) {
                if (stream.kind.equals("video", ignoreCase = true)) {
                    val videoTrack = stream.track as VideoTrack
                    holder.participantView.addTrack(videoTrack)
                }
            }
        })
    }

    override fun getItemCount(): Int {
        return participants.size
    }

    class PeerViewHolder(view: View) : RecyclerView.ViewHolder(view) {
        var participantView: VideoView = view.findViewById(R.id.participantView)
    }
}

```

Please refer the [example code](https://github.com/videosdk-live/videosdk-rtc-android-kotlin-sdk-example) on Github for more details.

</TabItem>

<TabItem value="Java">

```js title="ParticipantAdapter.java"

public class ParticipantAdapter extends RecyclerView.Adapter<ParticipantAdapter.PeerViewHolder> {

    private final List<Participant> participants = new ArrayList<>();
    private int containerHeight;

    public ParticipantAdapter(Meeting meeting) {
        Handler mHandler = new Handler(Looper.getMainLooper());

        meeting.addEventListener(new MeetingEventListener() {
            @Override
            public void onParticipantJoined(Participant participant) {
                participants.add(participant);
                mHandler.post(() -> notifyItemInserted(participants.size() - 1));
            }

            @Override
            public void onParticipantLeft(Participant participant) {
                // remove participant from grid
            }
        });
    }

    @NonNull
    @Override
    public PeerViewHolder onCreateViewHolder(@NonNull ViewGroup parent, int viewType) {
        containerHeight = parent.getHeight();

        return new PeerViewHolder(LayoutInflater.from(parent.getContext())
                .inflate(R.layout.item_remote_peer, parent, false));
    }

    @Override
    public void onBindViewHolder(@NonNull PeerViewHolder holder, int position) {
        final Participant participant = participants.get(position);

        ViewGroup.LayoutParams layoutParams = holder.itemView.getLayoutParams();
        layoutParams.height = containerHeight / 3;
        holder.itemView.setLayoutParams(layoutParams);

        for (Map.Entry<String, Stream> entry : participant.getStreams().entrySet()) {
            Stream stream = entry.getValue();
            if (stream.getKind().equalsIgnoreCase("video")) {
                VideoTrack videoTrack = (VideoTrack) stream.getTrack();
                holder.participantView.addTrack(videoTrack);
                break;
            }
        }

        participant.addEventListener(new ParticipantEventListener() {
            @Override
            public void onStreamEnabled(Stream stream) {
                if (stream.getKind().equalsIgnoreCase("video")) {
                    VideoTrack videoTrack = (VideoTrack) stream.getTrack();
                    holder.participantView.addTrack(videoTrack);
                }
            }
        });

    }

    @Override
    public int getItemCount() {
        return participants.size();
    }

    static class PeerViewHolder extends RecyclerView.ViewHolder {
        public VideoView participantView;
        public View itemView;

        PeerViewHolder(@NonNull View view) {
            super(view);

            itemView = view;

            participantView = view.findViewById(R.id.participantView);
        }
    }
}
```

Please refer the [example code](https://github.com/videosdk-live/videosdk-rtc-android-java-sdk-example/blob/master/app/src/main/java/live/videosdk/rtc/android/java) on Github for more details.

</TabItem>

</Tabs>

## 3. Participant Related Events

1. **onParticipantJoined** - Whenever any new participant join the meeting, `onParticipantJoined` event will trigger. For example, the meeting is running with **Alice** and **Bob**, then **Eve** join that meeting, after that `onParticipantJoined` event trigger and return the [participant object](/android/guide/video-and-audio-calling-api-sdk/features/manage-participants#participant-object-properties).

2. **onParticipantLeft** - Whenever any participant leave/exit the meeting, `onParticipantLeft` event will trigger.For example, the meeting is running with **Alice** and **Bob**, then **Bob** leave that meeting, after that `onParticipantLeft` event trigger and return the [participant object](/android/guide/video-and-audio-calling-api-sdk/features/manage-participants#participant-object-properties)

3. **onPresenterChanged** - Whenever any participant present/screenshare their screen/window in meeting, `onPresenterChanged` event will trigger and return the presenter `participantId`.

4. **onStreamEnabled** - Whenever any participant enabled mic/webcam in meeting, `onStreamEnabled` event will trigger and return [Stream](/android/guide/video-and-audio-calling-api-sdk/features/manage-participants#stream-object-properties).

5. **onStreamDisabled** - Whenever any participant disabled mic/webcam in meeting, `onStreamDisabled` event will trigger and return [Stream](/android/guide/video-and-audio-calling-api-sdk/features/manage-participants#stream-object-properties).

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
 meeting.addEventListener(object : MeetingEventListener() {
    override fun onParticipantJoined(participant: Participant) {
        participant.addEventListener(object : ParticipantEventListener() {
                override fun onStreamEnabled(stream: Stream) {
                    if (stream.kind.equals("video", ignoreCase = true)) {
                         // participant video enabled
                    } else if (stream.kind.equals("audio", ignoreCase = true)) {
                         // participant mic enabled
                    }
                }
                override fun onStreamDisabled(stream: Stream) {
                    if (stream.kind.equals("video", ignoreCase = true)) {
                         // participant video disabled
                    } else if (stream.kind.equals("audio", ignoreCase = true)) {
                        // participant mic disabled
                    }
                }
        })
    }

    override fun onParticipantLeft(participant: Participant) {
        Toast.makeText(this@MainActivity, participant.displayName + " left", Toast.LENGTH_SHORT).show()
    }

    override fun onPresenterChanged(presenterId: String) {
        Toast.makeText(this@MainActivity, presenterId + " started presenting", Toast.LENGTH_SHORT).show()
    }
 })
```

</TabItem>

<TabItem value="Java">

```js
 meeting.addEventListener(new MeetingEventListener() {
    @Override
    public void onParticipantJoined(Participant participant) {
      participant.addEventListener(new ParticipantEventListener() {
          @Override
          public void onStreamEnabled(Stream stream) {
              if (stream.getKind().equalsIgnoreCase("video")) {
                  // participant video enabled
              } else if (stream.getKind().equalsIgnoreCase("audio")) {
                  // participant mic enabled
              }
          }

          @Override
          public void onStreamDisabled(Stream stream) {
              if (stream.getKind().equalsIgnoreCase("video")) {
                  // participant video disabled
              } else if (stream.getKind().equalsIgnoreCase("audio")) {
                  // participant mic disabled
              }
          }
      });
    }

    @Override
    public void onParticipantLeft(Participant participant) {
      Toast
        .makeText(
          MainActivity.this,
          participant.getDisplayName() + " left",
          Toast.LENGTH_SHORT
        )
        .show();
    }
    @Override
    public void onPresenterChanged(String presenterId) {
      Toast
        .makeText(
          MainActivity.this,
          presenterId + " started presenting",
          Toast.LENGTH_SHORT
        )
        .show();
    }
 });
```

</TabItem>

</Tabs>


---

---
title: Mic Controls Video & Audio Call - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: Mic Controls features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Mic Controls
pagination_label: Mic Controls
keywords:
  - Mic on
  - Mic off
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: mic-controls
---

import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>

# Mic Controls - Android

Whenever any participant wants to start / stop broadcasting their audio to other participant in meeting, they can simply do it with VideoSDK Meeting.

This guide will provide an overview of how to use enable and disable Mic in a meeting.

1. **Enable Mic** - By using `unmuteMic()` function, a participant can publish audio to other participants.
2. **Disable Mic** - By using `muteMic()` function, a participant can stop publishing audio to other participants.

### 1. Enable, Disable Mic

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
  private var micEnabled = false

  btnMic!!.setOnClickListener { _: View? ->
    // Toggle participant mic in meeting
     if (micEnabled) {
       meeting!!.muteMic()
       micEnabled=false
     } else {
      meeting!!.unmuteMic()
      micEnabled=true
     }
  }
```

</TabItem>

<TabItem value="Java">

```js
  private boolean micEnabled = false;

  btnMic.setOnClickListener(new View.OnClickListener() {
      @Override
      public void onClick(View v) {
          // Toggle participant mic in meeting
          if (micEnabled) {
              meeting.muteMic();
              micEnabled = false;
          } else {
              meeting.unmuteMic();
              micEnabled = true;
          }
      }
  });
```

</TabItem>

</Tabs>

### Events

**Event associated with `unmuteMic()`:**

- Every Participant will receive a callback on [`onStreamEnabled()`](../../../api/sdk-reference/participant-class/participant-event-listener-class.md#onstreamenabled) of the [`Participant`](../../../api/sdk-reference/participant-class//introduction.md) with `Stream` object.

**Event associated with `muteMic()`:**

- Every Participant will receive a callback on [`onStreamDisabled()`](../../../api/sdk-reference/participant-class/participant-event-listener-class.md#onstreamenabled) of the [`Participant`](../../../api/sdk-reference/participant-class//introduction.md) with `Stream` object.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
  meeting!!.localParticipant.addEventListener(object : ParticipantEventListener() {
    override fun onStreamEnabled(stream: Stream) {
        //
        if(stream.getKind().equals("audio")){
          //participant turned on audio
        }
    }

    override fun onStreamDisabled(stream: Stream) {
        //
        if(stream.getKind().equals("audio")){
          //participant turned off audio
        }
    }
  });
```

</TabItem>

<TabItem value="Java">

```js
  participant.addEventListener(new ParticipantEventListener() {
    @Override
    public void onStreamEnabled(Stream stream) {
        //
        if(stream.getKind().equals("audio")){
          //participant turned on audio
        }
    }

    @Override
    public void onStreamDisabled(Stream stream) {
        //
        if(stream.getKind().equals("audio")){
          //participant turned off audio
        }
    }
  });
```

</TabItem>

</Tabs>

### 2. Change Audio Device

#### Get all audio Devices

- By using `meeting.getMics()` function, a participant can get all the connected mics.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
  private fun getMics(): MutableSet<AppRTCAudioManager.AudioDevice>? {
    val mics= meeting!!.mics
    return mics  // returns all mics
  }
```

</TabItem>

<TabItem value="Java">

```js
  private Set<AppRTCAudioManager.AudioDevice> getMics() {
    Set<AppRTCAudioManager.AudioDevice> mics = meeting.getMics();
    return mics; // returns all mics
  }
```

</TabItem>

</Tabs>

#### Select audio Device

- Local participant can change the audio device using `changeMic(AppRTCAudioManager.AudioDevice device)` method of meeting class.

- Parameters that can be passed to `changeMic` are

  | Audio Devices                                | Usage                        |
  | -------------------------------------------- | ---------------------------- |
  | AppRTCAudioManager.AudioDevice.BLUETOOTH     | For Bluetooth Device.        |
  | AppRTCAudioManager.AudioDevice.WIRED_HEADSET | For Wired Handset Device.    |
  | AppRTCAudioManager.AudioDevice.SPEAKER_PHONE | For Inbuilt - Speaker Device |
  | AppRTCAudioManager.AudioDevice.EARPIECE      | For Earpiece Device          |

- When a Local participant changes the Mic, `AppRTCAudioManager.AudioManagerEvents()` is triggered which can be set to `Meeting` class by using `meeting.setAudioDeviceChangeListener()`

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js

  btnChangeMic!!.setOnClickListener { _: View? ->
  // Change Mic in Meeting
    meeting!!.changeMic(AppRTCAudioManager.AudioDevice.BLUETOOTH)
  }

  private fun setAudioDeviceListeners() {
    meeting!!.setAudioDeviceChangeListener(object : AudioManagerEvents {
      override fun onAudioDeviceChanged(
        selectedAudioDevice: AppRTCAudioManager.AudioDevice,
        availableAudioDevices: Set<AppRTCAudioManager.AudioDevice>
      ) {
          when (selectedAudioDevice) {
            AppRTCAudioManager.AudioDevice.BLUETOOTH ->
              Toast.makeText(this@MainActivity, "Selected AudioDevice: BLUETOOTH", Toast.LENGTH_SHORT).show()

            AppRTCAudioManager.AudioDevice.WIRED_HEADSET ->
              Toast.makeText(this@MainActivity, "Selected AudioDevice: WIRED_HEADSET", Toast.LENGTH_SHORT).show()

            AppRTCAudioManager.AudioDevice.SPEAKER_PHONE ->
              Toast.makeText(this@MainActivity, "Selected AudioDevice: SPEAKER_PHONE", Toast.LENGTH_SHORT).show()

            AppRTCAudioManager.AudioDevice.EARPIECE ->
              Toast.makeText(this@MainActivity, "Selected AudioDevice: EARPIECE", Toast.LENGTH_SHORT).show()
          }
        }
    })
  }

  override fun onCreate(savedInstanceState: Bundle?) {
       // ...
       setAudioDeviceListeners()
  }
```

</TabItem>

<TabItem value="Java">

```js

  btnChangeMic.setOnClickListener(new View.OnClickListener() {
      @Override
      public void onClick(View v) {
        // Change Mic in Meeting
        meeting.changeMic(AppRTCAudioManager.AudioDevice.BLUETOOTH);
      }
  });

  private void setAudioDeviceListeners() {
    meeting.setAudioDeviceChangeListener(new AppRTCAudioManager.AudioManagerEvents() {
         @Override
        public void onAudioDeviceChanged(AppRTCAudioManager.AudioDevice selectedAudioDevice, Set<AppRTCAudioManager.AudioDevice> availableAudioDevices) {
            switch (selectedAudioDevice) {
                case BLUETOOTH:
                  Toast.makeText(MainActivity.this, "Selected AudioDevice: BLUETOOTH", Toast.LENGTH_SHORT).show();
                  break;
                case WIRED_HEADSET:
                  Toast.makeText(MainActivity.this, "Selected AudioDevice: WIRED_HEADSET", Toast.LENGTH_SHORT).show();
                  break;
                case SPEAKER_PHONE:
                  Toast.makeText(MainActivity.this, "Selected AudioDevice: SPEAKER_PHONE", Toast.LENGTH_SHORT).show();
                  break;
                case EARPIECE:
                  Toast.makeText(MainActivity.this, "Selected AudioDevice: EARPIECE", Toast.LENGTH_SHORT).show();
                  break;
               }
        }
    });
  }

  @Override
    protected void onCreate(Bundle savedInstanceState) {
       // ...
       setAudioDeviceListeners();
    }
```

</TabItem>

</Tabs>

- To use Bluetooth device, you must declare `BLUETOOTH` permission in `AndroidManifest.xml` file.

```js
<manifest ... >

<!-- Needed to communicate with already-paired Bluetooth devices. (Legacy up to Android 11) -->
<uses-permission android:name="android.permission.BLUETOOTH" />
<uses-permission android:name="android.permission.BLUETOOTH_ADMIN" />
<uses-permission android:name="android.permission.BLUETOOTH_CONNECT" />
//...
</manifest>
```


---

---
title: Pause/Resume Video Stream - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: Pause/Resume Video Stream features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Pause/Resume Video Stream
pagination_label: Pause/Resume Video Stream
keywords:
  - pause/resume video stream
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: pause-resume-video-stream
---

import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>

# Pause/Resume Video Stream - Android

Whenver you wish to stop/resume downlaod stream(webcam, screenShare and mic) of participant, you can simply do it by using `pause`, `resume` methods.

## Pause video stream

- `pause()` method is used for pause stream(webcam, screenShare and mic) of a particular participant.

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
  btnPause!!.setOnClickListener { _: View? ->
    for ((_, stream) in participant.streams) {
      stream.pause()
    }
  }
```

</TabItem>

<TabItem value="Java">

```js
  btnPause.setOnClickListener(new View.OnClickListener() {
      @Override
      public void onClick(View v) {
        for (Map.Entry<String, Stream> entry : participant.getStreams().entrySet()) {
                Stream stream = entry.getValue();
                stream.pause();
        }
      }
  });
```

</TabItem>

</Tabs>

## Resume video stream

- `resume()` method is used to resume stream(webcam, screenShare and mic) of a particular participant.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
  btnResume!!.setOnClickListener { _: View? ->
    for ((_, stream) in participant.streams) {
      stream.resume()
    }
  }
```

</TabItem>

<TabItem value="Java">

```js
  btnResume.setOnClickListener(new View.OnClickListener() {
      @Override
      public void onClick(View v) {
        for (Map.Entry<String, Stream> entry : participant.getStreams().entrySet()) {
            Stream stream = entry.getValue();
            stream.resume();
        }
      }
  });
```

</TabItem>

</Tabs>


---

---
title: Pin Participants Video & Audio Call - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: Pin Participant features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Pin Participants
pagination_label: Pin Participants
keywords:
  - pin
  - unpin
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: pin-participants
---

import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>

# Pin Participants - Android

In any meeting with large number of participants, if you want to show only one or two participant(s) on main screen then you can pin that perticipants so that viewers can only focus upon that participants only.

This guide will provide an overview of how to pin or unpin any participants in a meeting.

:::note
`pin()` and `unpin()` functions will take `string` or `null` as an argument. Pin will be effective for both webcam and screenshare of that participant.

Suppose you want to pin or unpin only webcam of that participant then you can pass `CAM`, else if you want to pin or unpin only screenshare of that participant then you can pass `SHARE`.

You can also pass `SHARE_AND_CAM` if you want to `pin` or `unpin` both webcam and screenshare media of that user, or passing `null` or nothing as an argument will also work in the same way.

If any participant's webcam is pinned but not screenshare, then calling `pin("SHARE")` the new pinState of that participant will be `{ cam: true, share: true }`.  
:::

### Pin And Unpin a Participant

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
  // Pin both webcam and screenshare of that participant
  meeting!!.participants[participantId].pin("SHARE_AND_CAM")

  // Pin webcam of that participant
  meeting!!.participants[participantId].pin("CAM")

  // Pin screenshare of that participant
  meeting!!.participants[participantId].pin("SHARE")

  //
  // Unpin both webcam and screenshare of that participant
  meeting!!.participants[participantId].unpin("SHARE_AND_CAM");

  // Unpin webcam of that participant
  meeting!!.participants[participantId].unpin("CAM");

  // Unpin screenshare of that participant
  meeting!!.participants[participantId].unpin("SHARE");
```

</TabItem>

<TabItem value="Java">

```js
// Pin both webcam and screenshare of that participant
meeting.getParticipants().get(participantId).pin("SHARE_AND_CAM");

// Pin webcam of that participant
meeting.getParticipants().get(participantId).pin("CAM");

// Pin screenshare of that participant
meeting.getParticipants().get(participantId).pin("SHARE");

//
// Unpin both webcam and screenshare of that participant
meeting.getParticipants().get(participantId).unpin(null);

// Unpin webcam of that participant
meeting.getParticipants().get(participantId).unpin("CAM");

// Unpin screenshare of that participant
meeting.getParticipants().get(participantId).unpin("SHARE");
```

</TabItem>

</Tabs>

### onPinStateChanged Event

Whenever any participant got pinned or unpinned by any participant, `onPinStateChanged` event will be triggered.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
 override fun onPinStateChanged(pinStateData: JSONObject?) {
   Log.d("onPinStateChanged: ", pinStateData.getString("peerId")) // id of participant who were pinned
   Log.d("onPinStateChanged: ", pinStateData.getJSONObject("state")) // { cam: true, share: true }
   Log.d("onPinStateChanged: ", pinStateData.getString("pinnedBy")) // id of participant who pinned that participant
  }
```

</TabItem>

<TabItem value="Java">

```javascript
@Override
  public void onPinStateChanged(JSONObject pinStateData) {
    Log.d("onPinStateChanged: ", pinStateData.getString("peerId")); // id of participant who were pinned
    Log.d("onPinStateChanged: ", pinStateData.getJSONObject("state")); // { cam: true, share: true }
    Log.d("onPinStateChanged: ", pinStateData.getString("pinnedBy")); // id of participant who pinned that participant
  }

```

</TabItem>

</Tabs>


---

---
sidebar_label: Send Message using PubSub
pagination_label: PubSub
---

import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>

# PubSub - Android

PubSub feature allows the participant to send and receive messages of the topics which he has subscribed.

## Methods

### publish()

This method is use for publishing message of specific topic.

#### Syntax

```js
public void publish(String topic, String message, PubSubPublishOptions options)
```

| Parameter Name | Type                 | Description                                                                                                                                       |
| -------------- | -------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------- |
| topic          | String               | This should be the topic for which you are publishing a message.                                                                                  |
| message        | String               | This is the actual message, which will be published to participants, who had subscribed to a particular topic.                                    |
| options        | PubSubPublishOptions | This is an object of PubSubPublishOptions, which provides an option, such as `persist`, which persists message history for upcoming participants. |

#### Example

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
private fun sendMessage() {
  val options = PubSubPublishOptions()
  options.isPersist = true
  meeting!!.pubSub.publish("CHAT", "Hello from Android", options)
}
```

</TabItem>

<TabItem value="Java">

```js
protected void sendMessage() {
  PubSubPublishOptions options = new PubSubPublishOptions();
  options.setPersist(true);
  meeting.pubSub.publish("CHAT", "Hello from Android", options);
}
```

</TabItem>

</Tabs>

### subscribe()

This method is used to subscribe for particular topic. This method returns a list of messages which were sent earlier.

#### Syntax

```js
public List<PubSubMessage> subscribe(String topic, PubSubMessageListener listener)
```

| Parameter Name | Type                  | Description                                                                                                                                      |
| -------------- | --------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------ |
| topic          | String                | This should be the topic to be subscribed.                                                                                                       |
| listener       | PubSubMessageListener | This is an object of PubSubMessageListener, which listens for upcoming messages and calls onMessageReceived function, when new message received. |

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
var pubSubMessageListener =
  PubSubMessageListener { message ->
    // Logs new message
    Log.v("New Message Received", "Message : " + message.message)
  }

@Override
protected void onCreate(Bundle savedInstanceState) {
  //...

  // Subscribe for 'CHAT' topic
  val pubSubMessageList = meeting!!.pubSub.subscribe("CHAT", pubSubMessageListener)

  // Logs persisted message list
  for (message in pubSubMessageList) {
    Log.v("Message List: ", "Message : " + message.message)
  }
}
```

</TabItem>

<TabItem value="Java">

```js
PubSubMessageListener pubSubMessageListener = new PubSubMessageListener() {
  @Override
  public void onMessageReceived(PubSubMessage message) {
    // Logs new message
    Log.v("New Message Received", "Message : " + message.getMessage());
  }
};

@Override
protected void onCreate(Bundle savedInstanceState) {
  //...

  // Subscribe for 'CHAT' topic
  List<PubSubMessage> pubSubMessageList = meeting.pubSub.subscribe("CHAT",pubSubMessageListener);

  // Logs persisted message list
  for(PubSubMessage message : pubSubMessageList){
    Log.v("Message List: ", "Message : " + message.getMessage());
  }
}
```

</TabItem>

</Tabs>

### unsubscribe()

This method is used to unsubscribe the message topic.

#### Syntax

```js
public void unsubscribe(String topic, PubSubMessageListener listener)
```

| Parameter Name | Type                  | Description                                                                    |
| -------------- | --------------------- | ------------------------------------------------------------------------------ |
| topic          | String                | This should be the topic to be unsubscribed.                                   |
| listener       | PubSubMessageListener | This is an object of PubSubMessageListener, which was passed in `subscribe()`. |

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
fun unsubscribe() {
  // Unsubscribe 'CHAT' topic
  meeting!!.pubSub.unsubscribe("CHAT", pubSubMessageListener)
}
```

</TabItem>

<TabItem value="Java">

```js
public void unsubscribe(){
  // Unsubscribe 'CHAT' topic
  meeting.pubSub.unsubscribe("CHAT", pubSubMessageListener);
}
```

</TabItem>

</Tabs>

## Sample Code

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
package live.videosdk.rtc.android.kotlin

import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle
import android.view.View
import android.widget.EditText
import android.widget.Toast
import androidx.appcompat.widget.Toolbar
import androidx.recyclerview.widget.LinearLayoutManager
import androidx.recyclerview.widget.RecyclerView
import live.videosdk.rtc.android.Meeting
import live.videosdk.rtc.android.listeners.PubSubMessageListener
import live.videosdk.rtc.android.model.PubSubPublishOptions

class ChatActivity : AppCompatActivity() {

    // Meeting
    var meeting: Meeting? = null

    // PubSubMessageListener
    var pubSubMessageListener =
      PubSubMessageListener { message ->
        // Logs new message
        Log.v("New Message Received", "Message : " + message.message)
    }

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_chat)

        /**
         * Here, we have created 'MainApplication' class, which extends android.app.Application class.
         * It has Meeting property and getter and setter methods of Meeting property.
         * In your android manifest, you must declare the class implementing android.app.Application (add the android:name=".MainApplication" attribute to the existing application tag):
         * In MainActivity.kt, we have set Meeting property.
         *
         * For Example: (MainActivity.kt)
         * var meeting = VideoSDK.initMeeting(context, meetingId, ParticipantName, micEnabled, webcamEnabled, paricipantId, mode, customTrack, metaData,signalingBaseUrl,preferredProtocol)
         * (this.application as MainApplication).meeting = meeting
        */

        // Get Meeting
        meeting = (this.application as MainApplication).meeting

        // Subscribe for 'CHAT' topic
        val pubSubMessageList = meeting!!.pubSub.subscribe("CHAT", pubSubMessageListener)

        for (message in pubSubMessageList) {
          // Logs persisted messages
           Log.v("Message List: ", "Message : " + message.message)
        }

        sendMessage()
    }

    private fun sendMessage() {
      val options = PubSubPublishOptions()
      options.isPersist = true
      meeting!!.pubSub.publish("CHAT", "Hello from Android", options)
    }

    override fun onDestroy() {
      // Unsubscribe for 'CHAT' topic
      meeting!!.pubSub.unsubscribe("CHAT", pubSubMessageListener)
      super.onDestroy()
    }
}
```

</TabItem>

<TabItem value="Java">

```js
package live.videosdk.rtc.android.java;

import androidx.appcompat.app.AppCompatActivity;
import android.os.Bundle;
import android.util.Log;
import java.util.List;
import live.videosdk.rtc.android.Meeting;
import live.videosdk.rtc.android.lib.PubSubMessage;
import live.videosdk.rtc.android.listeners.PubSubMessageListener;
import live.videosdk.rtc.android.model.PubSubPublishOptions;

public class ChatActivity extends AppCompatActivity {

    // Meeting
    Meeting meeting;

    // PubSubMessageListener
    private PubSubMessageListener pubSubMessageListener = new PubSubMessageListener() {
      @Override
      public void onMessageReceived(PubSubMessage message) {
          // Logs new message
          Log.v("New Message Received : ", "Message : " + message.getMessage());
      }
    };

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_chat);

        /**
         * Here, we have created 'MainApplication' class, which extends android.app.Application class.
         * It has Meeting property and getter and setter methods of Meeting property.
         * In your android manifest, you must declare the class implementing android.app.Application (add the android:name=".MainApplication" attribute to the existing application tag):
         * In MainActivity.java, we have set Meeting property.
         *
         * For Example: (MainActivity.java)
         * Meeting meeting = VideoSDK.initMeeting(context, meetingId, ParticipantName, micEnabled, webcamEnabled, participantId, mode, customTrack, metaData, signalingBaseUrl,preferredProtocol);
         * ((MainApplication) this.getApplication()).setMeeting(meeting);
        */

        // Get Meeting
        meeting = ((MainApplication) this.getApplication()).getMeeting();

        // Subscribe for 'CHAT' topic
        List<PubSubMessage> pubSubMessageList = meeting.pubSub.subscribe("CHAT", pubSubMessageListener);
        for(PubSubMessage message : pubSubMessageList){
            // Logs persisted messages
            Log.v("Message List : ", "Message : " + message.getMessage());
        }

        sendMessage();
    }

    protected void sendMessage() {
      PubSubPublishOptions publishOptions = new PubSubPublishOptions();
      publishOptions.setPersist(true);
      meeting.pubSub.publish("CHAT", "Hello from Android", publishOptions);
    }

    @Override
    protected void onDestroy() {
      // Unsubscribe for 'CHAT' topic
      meeting.pubSub.unsubscribe("CHAT", pubSubMessageListener);
      super.onDestroy();
    }
}
```

</TabItem>

</Tabs>


---

---
title: Record Meeting Video & Audio Call - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: Record Meeting features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Record Meeting
pagination_label: Record Meeting
keywords:
  - Start Recording meeting
  - Stop Recording meeting
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: recording-meeting
---

import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>

# Record Meeting - Android

Record meeting allows participants to record video & audio during the meeting. The recording files are available in developer dashboard.
Any participant can start / stop recording any time during the meeting.

This guide will provide an overview of how to implement start and stop Meeting Recording.

1. **Start Recording** - By using `startRecording()` function, a participant can start meeting recording.
2. **Stop Recording** - By using `stopRecording()` function, a participant can stop meeting recording.

### Start And Stop Recording

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
// TODO: change webhookUrl
val webhookUrl = "<webhook-url-here>"

// keep track of recording
val recording = false

findViewById<View>(R.id.btnRecording).setOnClickListener { view: View? ->
    if (!recording) {
        meeting!!.startRecording(webhookUrl)
    } else {
        meeting!!.stopRecording()
    }
}
```

</TabItem>

<TabItem value="Java">

```js
// TODO: change webhookUrl
String webhookUrl = "<webhook-url-here>";

// keep track of recording
boolean recording = false;

findViewById(R.id.btnRecording).setOnClickListener(view -> {
    if (!recording) {
        meeting.startRecording(webhookUrl);
    } else {
        meeting.stopRecording();
    }
});
```

</TabItem>

</Tabs>

### Events

- **onRecordingStateChanged** - A `onRecordingStateChanged` event will be triggered any time the recording state of a meeting changes.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
object : MeetingEventListener() {
  override fun onRecordingStateChanged(recordingState: String) {
    when (recordingState) {
        "RECORDING_STARTING" -> {
            Log.d("onRecordingStateChanged", "Meeting recording is starting")
        }
        "RECORDING_STARTED" -> {
            Log.d("onRecordingStateChanged", "Meeting recording is started")
        }
        "RECORDING_STOPPING" -> {
            Log.d("onRecordingStateChanged", "Meeting recording is stopping")
        }
        "RECORDING_STOPPED" -> {
            Log.d("onRecordingStateChanged", "Meeting recording is stopped")
        }
    }
  }
}
```

</TabItem>

<TabItem value="Java">

```js
new MeetingEventListener() {
  @Override
  public void onRecordingStateChanged(String recordingState) {
      switch (recordingState) {
          case "RECORDING_STARTING":
              Log.d("onRecordingStateChanged", "Meeting recording is starting");
              break;
          case "RECORDING_STARTED":
              Log.d("onRecordingStateChanged", "Meeting recording is started");
              break;
          case "RECORDING_STOPPING":
              Log.d("onRecordingStateChanged", "Meeting recording is stopping");
              break;
          case "RECORDING_STOPPED":
              Log.d("onRecordingStateChanged", "Meeting recording is stopped");
              break;
      }
  }
}
```

</TabItem>

</Tabs>


---

---
title: Remove participant from the meeting - Android SDK
hide_title: false
hide_table_of_contents: false
description: Remove a participant or a peer from the meeting while it is still in progress. It helps in meeting moderation.
sidebar_label: Remove Participant
pagination_label: Remove Participant
keywords:
  - remove participant
  - block participant
  - android
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: remove-participant
---

import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>

# Remove Participant - Android

Remove participant allows removing participant while session is on-going. This can be helpful when moderation in particular meeting is required.

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
val participant = meeting!!.participants.get("<participant-id>")

// This will emit an event called "onParticipantLeft" to that particular participant
participant.remove()
```

</TabItem>

<TabItem value="Java">

```js
Participant participant = meeting.getParticipants().get("<participant-id>");

// Remove participant from active session
// This will emit an event called "onParticipantLeft" to that particular participant
participant.remove();
```

</TabItem>

</Tabs>

### Events

**onParticipantLeft** - Removing participant will trigger `onParticipantLeft` event.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
private final MeetingEventListener meetingEventListener = new MeetingEventListener() {

  override fun onParticipantLeft(participant: Participant) {
    // Triggers when a participant is removed or leaves the meeting.
    Log.d("#meeting", participant.displayName + " left");
  }
}
```

</TabItem>

<TabItem value="Java">

```javascript
private final MeetingEventListener meetingEventListener = new MeetingEventListener() {
  @Override
  public void onParticipantLeft(Participant participant) {
    // Triggers when a participant is removed or leaves the meeting.
    Log.d("#meeting", participant.getDisplayName() + " left");
  }
}
```

</TabItem>

</Tabs>


---

---
title: Share your Screen Video & Audio Call - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: Share your Screen features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Share Your Screen
pagination_label: Share Your Screen
keywords:
  - Start Screen share
  - Stop Screen share
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: screenshare
---

import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>

# Share Your Screen - Android

- Whenever any participant wants to share a complete screen of mobile, they can simply do it with VideoSDK Meeting.

- This guide will provide an overview of how to enable or disable Screen Share in a meeting.

## How Screen share works?

- The following diagram shows flow of the screen sharing in android using VideoSDK:

<div style={{textAlign: 'center'}}>

![VideoSDK Android Screenshare Flow Diagram](/img/android/screenshare/flow_diagram.png)

</div>

## Enable Screen Share

- A participant’s Screen share stream is provided via the `MediaProjection` API. This API is only compatible with `Build.VERSION_CODES.LOLLIPOP` or higher.

- Get an instance of the `MediaProjectionManager` and Call the `createScreenCaptureIntent()` method in an activity. This initiates a prompt dialog for the user to confirm screen projection.

- One will get a prompt dialog like this:

<div style={{textAlign: 'center'}}>

<img
src={require('/img/android/screenshare/user_permission.jpg').default}
alt="user permission"
width="450"
/>

</div>

<br/>

- After permission is received from the user, call `meeting.enableScreenShare()` method.

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
private fun enableScreenShare() {
    val mediaProjectionManager = application.getSystemService(
        MEDIA_PROJECTION_SERVICE
    ) as MediaProjectionManager
    startActivityForResult(
        mediaProjectionManager.createScreenCaptureIntent(), CAPTURE_PERMISSION_REQUEST_CODE
    )
}

public override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) {
    super.onActivityResult(requestCode, resultCode, data)
    if (requestCode != CAPTURE_PERMISSION_REQUEST_CODE) return
    if (resultCode == RESULT_OK) {
        meeting!!.enableScreenShare(data)
    }
}
```

</TabItem>

<TabItem value="Java">

```js
private void enableScreenShare() {
    MediaProjectionManager mediaProjectionManager =
        (MediaProjectionManager) getApplication().getSystemService(
            Context.MEDIA_PROJECTION_SERVICE);
    startActivityForResult(
        mediaProjectionManager.createScreenCaptureIntent(), CAPTURE_PERMISSION_REQUEST_CODE);
}

@Override
public void onActivityResult(int requestCode, int resultCode, Intent data) {
    super.onActivityResult(requestCode, resultCode, data);
    if (requestCode != CAPTURE_PERMISSION_REQUEST_CODE)
        return;
    if (resultCode == Activity.RESULT_OK) {
        meeting.enableScreenShare(data);
    }
}
```

</TabItem>

</Tabs>

### Customise notification

- When a presenter starts screen share, presenter will receive a notification with a pre-defined title and message.

- Notification with pre-defined title and message will look like this:

<div style={{textAlign: 'center'}}>

<img
src={require('/img/android/screenshare/notification.jpg').default}
alt="notification"
width="450"
/>

</div>

- You can Customise those title, message and icon as per your requirements using `<meta-data>` specified in `app/src/main/AndroidManifest.xml`.

```js
<application>
  <meta-data
    android:name="notificationTitle"
    android:value="@string/notificationTitle"
  />
  <meta-data
    android:name="notificationContent"
    android:value="@string/notificationContent"
  />
  <meta-data
    android:name="notificationIcon"
    android:resource="@mipmap/ic_launcher_round"
  />
</application>
```

## Disable Screen Share

By using `meeting.disableScreenShare()` function, a participant can stop publishing screen stream to other participants.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
private fun disableScreenShare() {
    meeting!!.disableScreenShare()
}
```

</TabItem>

<TabItem value="Java">

```js
private void disableScreenShare(){
    meeting.disableScreenShare();
}
```

</TabItem>

</Tabs>

## Display Screen Share Stream

#### Local Participant

When a Local participant share the screen, `onStreamEnabled()` of `ParticipantEventListener` is triggered with the `Stream` which can be added to a `VideoView`.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
private fun setLocalListeners() {
    meeting!!.localParticipant.addEventListener(object : ParticipantEventListener() {
        override fun onStreamEnabled(stream: Stream) {
           if (stream.kind.equals("share", ignoreCase = true)) {
                // display share video
                val videoTrack = stream.track as VideoTrack
                shareView!!.addTrack(videoTrack)
            }
        }
        override fun onStreamDisabled(stream: Stream) {
            if (stream.kind.equals("share", ignoreCase = true)) {
               shareView!!.removeTrack()
            }
        }
    });
}
```

</TabItem>

<TabItem value="Java">

```js
private void setLocalListeners() {
    meeting.getLocalParticipant().addEventListener(new ParticipantEventListener() {
        @Override
        public void onStreamEnabled(Stream stream) {
            if (stream.getKind().equalsIgnoreCase("share")) {
                // display share video
                VideoTrack videoTrack = (VideoTrack) stream.getTrack();
                shareView.addTrack(videoTrack);
            }
        }
        @Override
        public void onStreamDisabled(Stream stream) {
            if (stream.getKind().equalsIgnoreCase("share")) {
                shareView.removeTrack();
            }
        }
    });
}
```

</TabItem>

</Tabs>

#### Other Participants

When other participant(Except you) share their screen, `onPresenterChanged()` in the `MeetingEventListener` is triggered with the `participantId` of the screen share.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
private val meetingEventListener: MeetingEventListener = object : MeetingEventListener() {
    override fun onPresenterChanged(participantId: String) {
        updatePresenter(participantId)
    }
}

//Getting the stream from the participantId
private fun updatePresenter(participantId: String?) {
    // find participant
    val participant = meeting!!.participants.get(participantId) ?: return

    // find share stream in participant
    var shareStream: Stream? = null
    for (stream: Stream in participant.streams.values) {
        if ((stream.kind == "share")) {
            shareStream = stream
            break
        }
    }
    if (shareStream == null) return

    // display share video
    val videoTrack = shareStream.track as VideoTrack
    shareView!!.addTrack(videoTrack)

    // listen for share stop event
    participant.addEventListener(object : ParticipantEventListener() {
        override fun onStreamDisabled(stream: Stream) {
            if ((stream.kind == "share")) {
                shareView!!.removeTrack()
            }
        }
    })
}
```

</TabItem>

<TabItem value="Java">

```js
private final MeetingEventListener meetingEventListener = new MeetingEventListener() {
    //Triggered when Presenter changes
    @Override
    public void onPresenterChanged(String participantId) {
        updatePresenter(participantId);
    }
};

//Getting the stream from the participantId
private void updatePresenter(String participantId) {
    // find participant
    Participant participant = meeting.getParticipants().get(participantId);
    if (participant == null) return;

    // find share stream in participant
    Stream shareStream = null;
    for (Stream stream: participant.getStreams().values()) {
        if (stream.getKind().equals("share")) {
            shareStream = stream;
            break;
        }
    }
    if (shareStream == null) return;

    // display share video
    VideoTrack videoTrack = (VideoTrack) shareStream.getTrack();
    shareView.addTrack(videoTrack)

    // listen for share stop event
    participant.addEventListener(new ParticipantEventListener() {
        @Override
        public void onStreamDisabled(Stream stream) {
            if (stream.getKind().equals("share")) {
                shareView.removeTrack();
            }
        }
    });
}
```

</TabItem>

</Tabs>

:::info

- Here screenShare stream is displayed using `VideoView`, but you may also use `SurfaceViewRender` for the same.
- For `VideoView`, SDK version should be `0.1.13` or higher.
- To know more about `VideoView`, please visit [here](/android/guide/video-and-audio-calling-api-sdk/components/videoView)

:::


---

---
title: Set Participant Video Quality - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: Set Participant Video Quality features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Set Participant Video Quality
pagination_label: Set Participant Video Quality
keywords:
  - set video quality
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: set-participant-video-quality
---

import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>

# Set Participant Video Quality - Android

This feature allows participants to set other participant's video quality during the meeting.

:::info

MultiStream is not supported by the Android SDK. Use `customTrack` instead of `setQuality()` if you want to change participant's quality who joined using our Android SDK.

To know more about customTrack visit [here](/android/guide/video-and-audio-calling-api-sdk/features/custom-track/custom-video-track)

:::

## Set Quality

- `setQuality` method will accept `low`, `med` or `high` as string parameter.

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
private fun setQuality()
{
  val participants: Iterator<Participant> = meeting!!.participants.values.iterator()
  for (i in 0 until meeting!!.participants.size) {
    val participant = participants.next()

    participant.quality = "low"
    //or
    participant.quality = "med"
    //or
    participant.quality = "high"
  }
}
```

</TabItem>

<TabItem value="Java">

```js
private void setQuality() {
  final Iterator<Participant> participants = meeting.getParticipants().values().iterator();

  for (int i = 0; i < meeting.getParticipants().size(); i++) {
    Participant participant = participants.next();

    participant.setQuality("low");
    //or
    participant.setQuality("med");
    //or
    participant.setQuality("high");
  }
}
```

</TabItem>

</Tabs>


---

---
title: Set Viewport
hide_title: false
hide_table_of_contents: false
sidebar_label: Set Viewport
pagination_label: Set Viewport
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: set-viewport
---

import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>

# Set Viewport - Android

When you are working with Video Calling, video quality is the most important part of communication. When a participant is shown on the screen, consuming multiple high quality although not required, will result in more memory and CPU usage of the device, eventually degrading quality.

The way to optimze around these situation is to consume the video quality which is required to fit the view of a particular participant, resulting in better quality, less usage of network bandwith and providing a better experience.

Viewport is the size of window or visible area in which video for the participant is shown. We can optimize the consuming video quality based on the viewport size of the participant. For example if the viewport size of a particular participant view is `480x360`, VideoSDK will download a `480x360` stream. If a participant on screen is present in bigger size, VideoSDK will provide a higher quality video for that particular participant only.

import ReactPlayer from 'react-player'

<div style={{textAlign: 'center'}}>

<ReactPlayer autoplay muted loop playing url='/img/viewport_illustration.mp4' width={"100%"}/>

</div>

<br/>

:::info

MultiStream is not supported by the Android SDK. Use `customTrack` instead of `setViewPort()` if you want to change participant's quality who joined using our Android SDK.

To know more about customTrack visit [here](/android/guide/video-and-audio-calling-api-sdk/features/custom-track/custom-video-track)

:::

### setViewPort()

`setViewPort()` can be used to achieve the best optimization of the video. This method is called with the `width` and `height` of the participant view on the `Participant` object and VideoSDK will handle the rest.

##### Parameters

- `width`

  - type: `int`
  - Width of the participant view for which the quliaty of video is to be adjusted.

- `height`
  - type: `int`
  - Height of the participant view for which the quliaty of video is to be adjusted.

### Example

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
class ParticipantAdapter(meeting: Meeting) : RecyclerView.Adapter<ParticipantAdapter.PeerViewHolder() {

  //Your variables here

  override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): PeerViewHolder {
    containerHeight = parent.height
    return PeerViewHolder(
      LayoutInflater.from(parent.context)
        .inflate(R.layout.item_remote_peer, parent, false)
    )
  }

  override fun onBindViewHolder(holder: PeerViewHolder, position: Int) {
    val participant = participants[position]

    //View updates here

    //Update Consuming quality using setViewPort
    participant.setViewPort(holder.itemView.getWidth(), holder.itemView.getHeight());
  }
}

```

</TabItem>

<TabItem value="Java">

```js

public class ParticipantAdapter extends RecyclerView.Adapter<ParticipantAdapter.PeerViewHolder> {

  //Your variables here

  @NonNull
  @Override
  public PeerViewHolder onCreateViewHolder(@NonNull ViewGroup parent, int viewType) {
    containerHeight = parent.getHeight();

    return new PeerViewHolder(LayoutInflater.from(parent.getContext())
            .inflate(R.layout.item_remote_peer, parent, false));
  }

  @Override
  public void onBindViewHolder(@NonNull PeerViewHolder holder, int position) {
    final Participant participant = participants.get(position);

    //View updates here

    //Update Consuming quality using setViewPort
    participant.setViewPort(holder.itemView.getWidth(), holder.itemView.getHeight());
  }
}

```

</TabItem>

</Tabs>

The complete usage of this method can be seen here in the [code sample](https://github.com/videosdk-live/videosdk-rtc-android-java-sdk-example/blob/master/app/src/main/java/live/videosdk/rtc/android/java/ParticipantAdapter.java#L134)


---

---
title: Speaker Indication Video & Audio Call - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: Speaker Indication features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Speaker Indication
pagination_label: Speaker Indication
keywords:
  - Active Speaker
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: speaker-indication
---

import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>

# Speaker Indication - Android

Speaker indication feature in VideoSDK let you know, which participant is active speaker in a meeting.

Whenever any participant speaks in meeting, `onSpeakerChanged` event will trigger.

For example, the meeting is running with **Alice** and **Bob**. Whenever any of them speaks, `onSpeakerChanged` event will trigger and return the speaker `participantId`.

We can access `onSpeakerChanged` event through [meeting object](../../../api/sdk-reference/meeting-class/introduction.md).

### onSpeakerChanged Event

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
private val meetingEventListener: MeetingEventListener = object : MeetingEventListener() {
     // ...
    override fun onSpeakerChanged(participantId: String?) {
        Toast.makeText(this@MainActivity, "active Speaker Id" + participantId, Toast.LENGTH_SHORT).show();
        super.onSpeakerChanged(participantId)
    }
};
```

</TabItem>

<TabItem value="Java">

```js
private final MeetingEventListener meetingEventListener = new MeetingEventListener() {
     // ...
    @Override
    public void onSpeakerChanged(String participantId) {
        Toast.makeText(MainActivity.this, "active Speaker Id" + participantId, Toast.LENGTH_SHORT).show();
        super.onSpeakerChanged(participantId);
    }
};
```

</TabItem>

</Tabs>


---

---
title: Start join Meeting Video & Audio Call - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: Start or join Meeting features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Start or Join Meeting
pagination_label: Start or Join Meeting
keywords:
  - Join audio calling
  - Join video calling
  - Join real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: start-join-meeting
---

import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>

# Start or Join Meeting - Android

<div style={{display:'flex',flexDirection:'row',alignItems:'stretch',}}>
<div style={{}}>
<p>After the successful installation of VideoSDK, the next step is to integrate VideoSDK features with your webApp/MobileApp.</p>

<p>To Communicate with other participant's audio or video call, you will need to join the meeting.</p>

<p>This guide will provide an overview of how to configure, initialize and join a VideoSDK meeting.</p>

</div>
<div>
<img src="/img/gif/new-meeting.gif"/>
</div>

</div>

## 1. Configuration

To configure a meeting, you will need [generated token](/android/guide/video-and-audio-calling-api-sdk/server-setup) and [meetingId](/api-reference/realtime-communication/create-room), we had discussed in [Server Setup](/android/guide/video-and-audio-calling-api-sdk/server-setup).
This code snippet calls API from local server

**Scenario 1** - Suppose you **don't have** any meetingId, you can simply generate meetingId by invoking `create-meeting` API.

**Scenario 2** - Suppose you **have** meetingId, now you don't have to call `create-meeting` API to generate meetingId, instead you can call `validate-meeting` API to validate meetingId.

**Token generation API is necessary for both scenario.**

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
package live.videosdk.rtc.android.java;

import com.androidnetworking.AndroidNetworking;
import com.androidnetworking.error.ANError;
import com.androidnetworking.interfaces.JSONObjectRequestListener;
import org.json.JSONException;
import org.json.JSONObject;

class JoinActivity : AppCompatActivity() {
  private val apiServerUrl = "http://localhost:9000"

  // ...
  // onCreate() and other methods
  private fun getToken(@Nullable meetingId: String?) {
    AndroidNetworking
      .get("$apiServerUrl/get-token")
      .build()
      .getAsJSONObject(
        object : JSONObjectRequestListener {
          override fun onResponse(response: JSONObject) {
            try
            {
              token = response.getString("token")
              if (meetingId == null) {
                createMeeting(token)
              } else {
                joinMeeting(token, meetingId)
              }
            } catch (e: JSONException) {
              e.printStackTrace()
            }
          }

          override fun onError(anError: ANError) {
            anError.printStackTrace()
          }
        }
      )
  }

  private fun createMeeting(token: String) {
    AndroidNetworking
      .post("$apiServerUrl/create-meeting")
      .addBodyParameter("token", token)
      .build()
      .getAsJSONObject(
        object : JSONObjectRequestListener {
          override fun onResponse(response: JSONObject) {
            try {
              // final String meetingId = response.getString("meetingId");

              // Intent intent = new Intent(JoinActivity.this, MainActivity.class);
              // intent.putExtra("token", token);
              // intent.putExtra("meetingId", meetingId);

              // startActivity(intent);
            } catch (e: JSONException) {
                e.printStackTrace()
            }
          }

          override fun onError(anError: ANError) {
            anError.printStackTrace()
          }
        }
      )
  }

  private fun joinMeeting(token: String, meetingId: String) {
    AndroidNetworking
      .post("$apiServerUrl/validate-meeting/{meetingId}")
      .addPathParameter("meetingId", meetingId)
      .addBodyParameter("token", token)
      .build()
      .getAsJSONObject(
        object : JSONObjectRequestListener {
          override fun onResponse(response: JSONObject) {
            // Intent intent = new Intent(JoinActivity.this, MainActivity.class);
            // intent.putExtra("token", token);
            // intent.putExtra("meetingId", meetingId);

            // startActivity(intent);
          }

          override fun onError(anError: ANError) {
            anError.printStackTrace()
          }
        }
      )
  }
}

```

</TabItem>

<TabItem value="Java">

```js
package live.videosdk.rtc.android.java;

import com.androidnetworking.AndroidNetworking;
import com.androidnetworking.error.ANError;
import com.androidnetworking.interfaces.JSONObjectRequestListener;
import org.json.JSONException;
import org.json.JSONObject;

public class JoinActivity extends AppCompatActivity {
  private String apiServerUrl = "http://localhost:9000";

  // ...
  // onCreate() and other methods

  private void getToken(@Nullable String meetingId) {
    AndroidNetworking
      .get(apiServerUrl + "/get-token")
      .build()
      .getAsJSONObject(
        new JSONObjectRequestListener() {
          @Override
          public void onResponse(JSONObject response) {
            try {
              String token = response.getString("token");

              if (meetingId == null) {
                createMeeting(token);
              } else {
                joinMeeting(token, meetingId);
              }
            } catch (JSONException e) {
              e.printStackTrace();
            }
          }

          @Override
          public void onError(ANError anError) {
            anError.printStackTrace();
          }
        }
      );
  }

  private void createMeeting(String token) {
    AndroidNetworking
      .post(apiServerUrl + "/create-meeting")
      .addBodyParameter("token", token)
      .build()
      .getAsJSONObject(
        new JSONObjectRequestListener() {
          @Override
          public void onResponse(JSONObject response) {
            try {
              // final String meetingId = response.getString("meetingId");

              // Intent intent = new Intent(JoinActivity.this, MainActivity.class);
              // intent.putExtra("token", token);
              // intent.putExtra("meetingId", meetingId);

              // startActivity(intent);
            } catch (JSONException e) {
              e.printStackTrace();
            }
          }

          @Override
          public void onError(ANError anError) {
            anError.printStackTrace();
          }
        }
      );
  }

  private void joinMeeting(String token, String meetingId) {
    AndroidNetworking
      .post(apiServerUrl + "/validate-meeting/{meetingId}")
      .addPathParameter("meetingId", meetingId)
      .addBodyParameter("token", token)
      .build()
      .getAsJSONObject(
        new JSONObjectRequestListener() {
          @Override
          public void onResponse(JSONObject response) {
            // Intent intent = new Intent(JoinActivity.this, MainActivity.class);
            // intent.putExtra("token", token);
            // intent.putExtra("meetingId", meetingId);

            // startActivity(intent);
          }

          @Override
          public void onError(ANError anError) {
            anError.printStackTrace();
          }
        }
      );
  }
}

```

</TabItem>

</Tabs>

## 2. Initialization

import CautionMessage from '@site/src/theme/CautionMessage';


<CautionMessage sdk="Android SDK" version="v0.2.0" />

<div style={{display:'flex',flexDirection:'row',alignItems:'stretch',}}>
<div style={{}}>
<p>
After configuration, you will have to Initialize 
<p>
meeting by providing name, meetingId, micEnabled, webcamEnabled & maxResolution.
</p>
</p>

<p>
NOTE : For React & React native developer, you have

<p>to be familiar with hooks concept. You can understand hooks concept on <a href={'https://reactjs.org/docs/hooks-intro.html'}>React Hooks</a>.</p>

</p>
</div>
<div>
<img src="/img/gif/add-participant.gif"/>
</div>

</div>

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
import live.videosdk.rtc.android.VideoSDK;
import live.videosdk.rtc.android.Meeting;

class MainActivity : AppCompatActivity() {
  private var meeting: Meeting? = null

  override fun onCreate(savedInstanceState: Bundle?) {
    // Configure parameters
    val token = intent.getStringExtra("token")
    val meetingId = intent.getStringExtra("meetingId")
    val participantName = "John Doe"
    val micEnabled = true
    val webcamEnabled = true
    val paticipantId="demo@123"  // If you passed `null` then SDK will create an Id by itself and will use that id.
    val mode="SEND_AND_RECV"

    // Configure authentication token
    VideoSDK.config(token)

    // create a new meeting instance
    meeting = VideoSDK.initMeeting(
      this@MainActivity,
      meetingId,
      participantName,
      micEnabled,
      webcamEnabled,
      paticipantId,
      mode,
      null
    )
  }
}

```

</TabItem>

<TabItem value="Java">

```js
import live.videosdk.rtc.android.VideoSDK;
import live.videosdk.rtc.android.Meeting;

public class MainActivity extends AppCompatActivity {
    private Meeting meeting;

    @Override
    protected void onCreate(Bundle savedInstanceState) {

        // Configure parameters
        final String token = getIntent().getStringExtra("token");
        final String meetingId = getIntent().getStringExtra("meetingId");
        final String participantName = "John Doe";
        final boolean micEnabled = true;
        final boolean webcamEnabled = true;
        final String participantId = "demo@123"; // If you passed `null` then SDK will create an Id by itself and will use that id.
        final String mode="SEND_AND_RECV";

        // Configure authentication token
        VideoSDK.config(token);

        // create a new meeting instance
        meeting = VideoSDK.initMeeting(
                MainActivity.this,
                meetingId,
                participantName,
                micEnabled,
                webcamEnabled,
                participantId,
                mode,
                null
        );
    }
}

```

</TabItem>

</Tabs>

## 3. Join

<div style={{display:'flex',flexDirection:'row',alignItems:'stretch',}}>
<div style={{}}>
<p>
After configuration & initialization, the third step is to call join() to join a meeting.
</p>

<p>
After joining, you will be able to Manage Participant in a meeting.
</p>

</div>
<div>
<img src="/img/gif/join-meeting.gif"/>
</div>

</div>

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
// After receiving mic and webcam access permissions
// join the meeting
meeting!!.join()
```

</TabItem>

<TabItem value="Java">

```js
// After receiving mic and webcam access permissions
// join the meeting
meeting.join();
```

</TabItem>

</Tabs>

## Events

Following events are emitted on the `meeting` when it is successfully joined.

- Local Participant will receive a [`onMeetingJoined`](../../../api/sdk-reference/meeting-class/meeting-event-listener-class.md#onmeetingjoined) event when successfully joined.
- Remote Participant will receive a [`onParticipantJoined`](../../../api/sdk-reference/meeting-class/meeting-event-listener-class.md#onparticipantjoined) event with the newly joined [`Participant`](../../../api/sdk-reference/participant-class/introduction.md) object from the event callback.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
private final MeetingEventListener meetingEventListener = new MeetingEventListener() {
  override fun onMeetingJoined() {
    Log.d("#meeting", "onMeetingJoined()")
  }

  override fun onParticipantJoined(participant: Participant) {
    Log.d("#meeting", participant.displayName + " left");
  }
}
```

</TabItem>

<TabItem value="Java">

```javascript
private final MeetingEventListener meetingEventListener = new MeetingEventListener() {

  @Override
  public void onMeetingJoined() {
    Log.d("#meeting", "onMeetingJoined()");
  }

  @Override
  public void onParticipantJoined(Participant participant) {
    Log.d("#meeting", participant.getDisplayName() + " left");
  }
}
```

</TabItem>

</Tabs>


---

---
title: Toggle Participant Media
hide_title: false
hide_table_of_contents: false
description: Camera Controls features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Toggle Participant Media
pagination_label: Toggle Participant Media
keywords:
  - Camera on
  - Camera off
  - Webcam on
  - Webcam off
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: toggle-participant-media
---

import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>

# Toggle Participant Media - Android

Control other participant's webcam and mic.
For better idea, let's understand this with a real case scenario

**Scenario 1 (Online Class)** - In this scenario, the lecturer(Local Participant) will control the student's(Other Participant) webcam and mic as per his/her needs.

**Scenario 2 (Online Events)** - In this scenario, the event hosts will control the audience webcam and mic when someone wants to speak.

This guide will provide an overview of how to control other participant webcam and mic in a meeting.

1. **Enable Webcam of Participant** - By using `enableWebcam()` function, a `onWebcamRequested` event will trigger on requested participant side.

   **Example** : Meeting is running with **User A** and **User B**. Now **User A** wants to Enable Webcam of **User B**, so **User A** will use `enableWebcam()` function to request **User B**, after that **User B** recieve the `onWebcamRequested` event, from there user can either accept or reject the incoming request.

2. **Disable Webcam of Participant** - By using `disableWebcam()` function, webcam of that participant will be turned off.

   **Example** : **User A** wants to Disable Webcam of **User B**, so **User A** will use `disableWebcam()` function to Disable it without any request.

3. **Enable Mic of Participant** - By using `enableMic()` function, a `onMicRequested` event will trigger on requested participant side.

   **Example** : Meeting is running with **User A** and **User B**. Now **User A** wants to Enable Mic of **User B**, so **User A** will use `enableMic()` function to request **User B**, after that **User B** will receive the `onMicRequested` event, from there user can either accept or reject the incoming request.

4. **Disable Mic of Participant** - By using `disableMic()` function, Mic of that participant will disable.

   **Example** : **User A** wants to Disable Mic of **User B**, so **User A** will use `disableMic()` function to Disable it without any request.

:::note

To achieve this feature, you need to pass `allow_join` persmission while genearting token for meeting initialization. After that you will be able to access participant media methods.

[How to apply permission while generating token?](/android/guide/video-and-audio-calling-api-sdk/server-setup)

:::

### Request Media Methods

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
val participant = meeting!!.participants.get("<participant-id>")

// This will emit an event called "onWebcamRequested" to that particular participant
participant.enableWebcam()

// This will directly disable webcam of particular participant
participant.disableWebcam()

// This will emit an event called "onMicRequested" to that particular participant
participant.enableMic()

// This will directly disable mic of particular participant
participant.disableMic()
```

</TabItem>

<TabItem value="Java">

```js
Participant participant = meeting.getParticipants().get("<participant-id>");

// This will emit an event called "onWebcamRequested" to that particular participant
participant.enableWebcam();

// This will directly disable webcam of particular participant
participant.disableWebcam();

// This will emit an event called "onMicRequested" to that particular participant
participant.enableMic();

// This will directly disable mic of particular participant
participant.disableMic();
```

</TabItem>

</Tabs>

### Manage Requested Media Events

1. **onWebcamRequested** - This event will be emitted to the participant `B` when any other participant `A` requests to enable webcam of that participant `B`. This event handler will receieve following three arguments:

   - `accept()` - Callback function to accept the request.
   - `reject()` - Callback function to reject the request.

<div style={{height: "10px"}}></div>

2. **onMicRequested** - This event will be emitted to the participant `B` when any other participant `A` requests to enable mic of that participant `B`. This event handler will receieve following three arguments:

   - `accept()` - Callback function to accept the request.
   - `reject()` - Callback function to reject the request.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
object : MeetingEventListener() {
  override fun onMicRequested(participantId: String, listener: MicRequestListener) {
      // TODO: show dialog before accepting request
      listener.accept()
  }

  override fun onWebcamRequested(participantId: String, listener: WebcamRequestListener) {
      // TODO: show dialog before accepting request
      listener.accept()
  }
}
```

</TabItem>

<TabItem value="Java">

```js
new MeetingEventListener() {
  @Override
  public void onMicRequested(String participantId, MicRequestListener listener) {
      // TODO: show dialog before accepting request
      listener.accept();
  }

  @Override
  public void onWebcamRequested(String participantId, WebcamRequestListener listener) {
      // TODO: show dialog before accepting request
      listener.accept();
  }
}
```

</TabItem>

</Tabs>


---

---
title: Cloud Proxy | Secure and Manage Streaming Traffic | Video SDK
hide_title: true
hide_table_of_contents: false
description: Leverage Video SDK's Cloud Proxy to securely manage and optimize your video streaming traffic. Ideal for enhancing performance and securing data.
sidebar_label: Cloud Proxy
pagination_label: Cloud Proxy
keywords:
  - cloud proxy
  - secure streaming
  - video SDK security
  - traffic management
image: img/videosdklive-thumbnail.jpg
sidebar_position: 2
slug: cloud-proxy
---

# Cloud Proxy - Android

import CloudProxy from '../../../../mdx/\_cloud-proxy.mdx';

<CloudProxy/>

## Implementation

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
val meeting: Meeting = VideoSDK.initMeeting(
      this@MainActivity, "meetingId", "John Due", true,
      true, null, null, false, null, null,"proxy.yourwebsite.com", VideoSDK.PreferredProtocol.UDP_ONLY
);
```

</TabItem>

<TabItem value="Java">

```java
Meeting meeting = VideoSDK.initMeeting(
      MainActivity.this, "meetingId", "John Due",true,
      true, null, null, false, null,null,"proxy.yourwebsite.com", VideoSDK.PreferredProtocol.UDP_ONLY
);
```

</TabItem>

</Tabs>
### Parameters
- preferredProtocol:
    - UDP_OVER_TCP (default): Initially the server attempts to establish a connection using UDP, if that fails it automatically switches to TCP protocol.
    - UDP_ONLY: Force UDP protocol
    - TCP_ONLY: Force TCP protocol
- signalingBaseUrl: Proxy URL to origin signaling and media.

## API Reference

The API references for all the methods and events utilized in this guide are provided below.

- [initMeeting()](/android/api/sdk-reference/initMeeting)


---

---
title: Geo Fencing | Location based Restrictions | Video SDK
hide_title: true
hide_table_of_contents: false
description: Implement geographic content restrictions with Video SDK's Geo Fencing feature. Essential for compliance and tailored content delivery based on user location.
sidebar_label: Geo Fencing
pagination_label: Geo Fencing
keywords:
- geo fencing
- geographic restrictions
- location based restrictions
- regional access
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: geo-fencing
---

# Geo Fencing - Android

import GeoFencing from '../../../../mdx/\_geo-fencing.mdx';

<GeoFencing/>



---

---
title: Geo IP Restriction | Location Based Access Control | Video SDK
hide_title: true
hide_table_of_contents: false
description: Utilize Video SDK’s Geo IP Restriction to enforce access based on user geography. This feature is crucial for adhering to location-specific regulations and ensuring content is appropriately localized.
sidebar_label: Geo IP Restriction
pagination_label: Geo IP Restriction
keywords:
- geo ip restriction
- geographic access control
- location based security
- regional compliance
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: geo-ip-restriction
---

# Geo IP Restrictions  - Android

import GeoIpRestriction from '../../../../mdx/\_geo-ip-restriction.mdx';

<GeoIpRestriction/>



---

---
title: Error Events | Video SDK
hide_title: true
hide_table_of_contents: false
description: Video SDK and Audio SDK, developers need to implement a token server. This requires efforts on both the front-end and backend.
sidebar_label: Error Events
pagination_label: Error Events
keywords:
  - audio calling
  - video calling
  - real-time communication
  - collaboration
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: error-events
---

import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>

# Error Events - Android

VideoSDK provides `onError` event which will notify you of any error happening during the meeting.

### onError

- This event will be triggered whenever any invalid configuration provided or server/network errors arise, this event will trigger with a specific error code and message.
- This event is helpful for development level troubleshooting while integrating SDK.
- You can implement this method of the abstract Class `MeetingEventListener` and add the listener to `Meeting` class using the `addEventListener()` method of `Meeting` Class.

### Example

Here is the usage of the event mentioned in this page.

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
private val meetingEventListener: MeetingEventListener = object : MeetingEventListener() {
  //..
  override fun onError(error: JSONObject) {
  try {
      val errorCodes: JSONObject = VideoSDK.getErrorCodes()
      val code = error.getInt("code")
      Log.d("#error", "Error is: " + error["message"])
  } catch (e: Exception) {
          e.printStackTrace()
      }
  }
}
```

</TabItem>

<TabItem value="Java">

```js
private final MeetingEventListener meetingEventListener = new MeetingEventListener() {
  //..
  @Override
  public void onError(JSONObject error) {
      try {
          JSONObject errorCodes = VideoSDK.getErrorCodes();
          int code = error.getInt("code");
          Log.d("#error", "Error is: " + error.get("message"));
      } catch (Exception e) {
          e.printStackTrace();
      }
  }
};
```

</TabItem>

</Tabs>

### Error Codes

We have depicted a specific constant with code and message in the below table.

import ServerErrorCodes from '../../../../mdx/\_server-error-codes.mdx'
import SDKErrorCodes from '../../../data/\_sdk-error-codes.mdx'

<ServerErrorCodes />

<SDKErrorCodes/>

### API Reference

The API references for all the methods and events utilised in this guide are provided below.

- [onError()](/android/api/sdk-reference/error-codes)


---

---
title: External Call Detection Video & Audio Call - Video SDK Docs
hide_title: false
hide_table_of_contents: false
sidebar_label: External Call Detection Event
pagination_label: External Call Detection Event
keywords:
  - External Call Detection
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: external-call-detection-event
---

# External Call Detection Event - Android

External call detection event in VideoSDK let you know, participant is on the call during meeting.

Whenever local participant accept the incoming call or place outgoing call, `externalcall-started` event will trigger.`externalcall-started` event only received by localParticipant.

For example, the meeting is running with **Alice** and **Bob**. Whenever **Alice** receives the call or she call someone, **Alice** will receive `externalcall-started` event.

We can access `externalcall-started` event through `Meeting` class.

### externalcall-started Event

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
private val meetingEventListener: MeetingEventListener = object : MeetingEventListener() {
     // ...
    override fun onExternalCallStarted() {
      Log.d("#VideoSDK", "onExternalCallAnswered")
    }
};

override fun onCreate(savedInstanceState: Bundle?) {
  //...

  // add listener to meeting
  //highlight-next-line
  meeting!!.addEventListener(meetingEventListener)
}
```

</TabItem>

<TabItem value="Java">

```js
private final MeetingEventListener meetingEventListener = new MeetingEventListener() {
     // ...
    @Override
    public void onExternalCallStarted() {
        Log.d("#VideoSDK", "onExternalCallStarted");
    }
};

@Override
protected void onCreate(Bundle savedInstanceState) {
  //...

  // add listener to meeting
  //highlight-next-line
  meeting.addEventListener(meetingEventListener);
}
```

</TabItem>

</Tabs>


---

---
title: HLS Events | Video SDK
hide_title: true
hide_table_of_contents: false
description: Video SDK and Audio SDK, developers need to implement a token server. This requires efforts on both the front-end and backend.
sidebar_label: HLS Events
pagination_label: HLS Events
keywords:
  - audio calling
  - video calling
  - real-time communication
  - collaboration
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: hls-events
---

# HLS Events - Android

VideoSDK provides `onHlsStateChanged` event which will notify you of the current state of HLS for the meeting.

### onHlsStateChanged

- This event will be triggered when the meeting's HLS status changed.
- You can implement this method of the abstract Class `MeetingEventListener` and add the listener to `Meeting` class using the `addEventListener()` method of `Meeting` Class.
- when you receive `HLS_PLAYABLE` status you will receive 2 urls in response
  - `playbackHlsUrl` - Live HLS with playback support
  - `livestreamUrl` - Live HLS without playback support

:::note
`downstreamUrl` is now depecated. Use `playbackHlsUrl` or `livestreamUrl` in place of `downstreamUrl`
:::

### Example

Here is the usage of the event mentioned in this page.

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
private val meetingEventListener: MeetingEventListener = object : MeetingEventListener() {
  override fun onHlsStateChanged(HlsState: JSONObject) {
    when (HlsState.getString("status")) {
        "HLS_STARTING" -> Log.d("onHlsStateChanged", "Meeting hls is starting")
        "HLS_STARTED" -> Log.d("onHlsStateChanged", "Meeting hls is started")
        "HLS_PLAYABLE" -> {
            Log.d("onHlsStateChanged", "Meeting hls is playable now")
            // on hls playable you will receive playbackHlsUrl and livestreamUrl
            val playbackHlsUrl = HlsState.getString("playbackHlsUrl")
            val livestreamUrl = HlsState.getString("livestreamUrl")
        }
        "HLS_STOPPING" -> Log.d("onHlsStateChanged", "Meeting hls is stopping")
        "HLS_STOPPED" -> Log.d("onHlsStateChanged", "Meeting hls is stopped")
    }
  }
}

override fun onCreate(savedInstanceState: Bundle?) {
  //...

  // add listener to meeting
  //highlight-next-line
  meeting!!.addEventListener(meetingEventListener)
}
```

</TabItem>

<TabItem value="Java">

```js
private final MeetingEventListener meetingEventListener = new MeetingEventListener() {
  @Override
  public void onHlsStateChanged(JSONObject HlsState) {
      switch (HlsState.getString("status")) {
          case "HLS_STARTING":
              Log.d("onHlsStateChanged", "Meeting hls is starting");
              break;
          case "HLS_STARTED":
              Log.d("onHlsStateChanged", "Meeting hls is started");
              break;
          case "HLS_PLAYABLE":
              Log.d("onHlsStateChanged", "Meeting hls is playable now");
              // on hls started you will receive playbackHlsUrl and livestreamUrl
              String playbackHlsUrl = HlsState.getString("playbackHlsUrl");
              String livestreamUrl = HlsState.getString("livestreamUrl");
              break;
          case "HLS_STOPPING":
              Log.d("onHlsStateChanged", "Meeting hls is stopping");
              break;
          case "HLS_STOPPED":
              Log.d("onHlsStateChanged", "Meeting hls is stopped");
              break;
      }
  }
}

@Override
protected void onCreate(Bundle savedInstanceState) {
  //...

  // add listener to meeting
  //highlight-next-line
  meeting.addEventListener(meetingEventListener);
}
```

</TabItem>

</Tabs>

### API Reference

The API references for all the methods and events utilised in this guide are provided below.

- [onHlsStateChanged()](/android/api/sdk-reference/meeting-class/meeting-event-listener-class#onhlsstatechanged)


---

---
title: Media Events | Video SDK
hide_title: true
hide_table_of_contents: false
description: Video SDK and Audio SDK, developers need to implement a token server. This requires efforts on both the front-end and backend.
sidebar_label: Media Events
pagination_label: Media Events
keywords:
  - audio calling
  - video calling
  - real-time communication
  - collaboration
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: media-events
---

# Media Events - Android

VideoSDK provides multiple types of events which can be listened to know the about the participant's media status in the meeting.

You can implement all the methods of `ParticipantEventListener` abstract Class and add the listener to `Participant` class using the `addEventListener()` method of `Participant` Class.

Here are the events which specifically relate to the stream.

### onStreamEnabled

- This event is triggered whenever a participant's video, audio or screen share stream is enabled.

### onStreamDisabled

- This event is triggered whenever a participant's video, audio or screen share stream is disabled.

### Example

Here is the usage of all the events mentioned in this page.

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
participant.addEventListener(object : ParticipantEventListener() {
  override fun onStreamEnabled(stream: Stream) {
    Log.d("VideoSDK","onStreamEnabled $stream");
  }

  override fun onStreamDisabled(stream: Stream) {
    Log.d("VideoSDK","onStreamDisabled $stream");
  }
});
```

</TabItem>

<TabItem value="Java">

```js
participant.addEventListener(new ParticipantEventListener() {
  @Override
  public void onStreamEnabled(Stream stream) {
    Log.d("VideoSDK","onStreamEnabled" + stream);
  }

  @Override
  public void onStreamDisabled(Stream stream) {
    Log.d("VideoSDK","onStreamDisabled" + stream);
  }
});
```

</TabItem>

</Tabs>

### API Reference

The API references for all the methods and events utilised in this guide are provided below.

- [onStreamEnabled()](/android/api/sdk-reference/participant-class/participant-event-listener-class#onstreamenabled)
- [onStreamDisabled()](/android/api/sdk-reference/participant-class/participant-event-listener-class#onstreamdisabled)


---

---
title: Meeting Connection Events | Video SDK
hide_title: true
hide_table_of_contents: false
description: Video SDK and Audio SDK, developers need to implement a token server. This requires efforts on both the front-end and backend.
sidebar_label: Meeting Connection Events
pagination_label: Meeting Connection Events
keywords:
  - audio calling
  - video calling
  - real-time communication
  - collaboration
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: meeting-connection-events
---

# Meeting Connection Events - Android

VideoSDK provides `onMeetingStateChanged` event which will notify you of the current connection state of the meeting.

### onMeetingStateChanged

- This event will be triggered when state of meeting changes.
- It will pass **`state`** as an event callback parameter which will indicate current state of the meeting.
- All available states are `CONNECTING`, `CONNECTED`, `FAILED`, `DISCONNECTED`, `CLOSING`, `CLOSED`.
- You can implement this method of the abstract Class `MeetingEventListener` and add the listener to `Meeting` class using the `addEventListener()` method of `Meeting` Class.

### Example

Here is the usage of the event mentioned in this page.

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
private val meetingEventListener: MeetingEventListener = object : MeetingEventListener() {
  override fun onMeetingStateChanged(state: String?) {
      when (state) {
        "CONNECTING" -> Log.d("onMeetingStateChanged: ", "Meeting is Connecting")
        "CONNECTED" -> Log.d("onMeetingStateChanged: ", "Meeting is Connected")
        "FAILED" -> Log.d("onMeetingStateChanged: ", "Meeting connection failed")
        "DISCONNECTED" -> Log.d("onMeetingStateChanged: ","Meeting connection disconnected abruptly")
        "CLOSING" -> Log.d("onMeetingStateChanged: ", "Meeting is closing")
        "CLOSED" -> Log.d("onMeetingStateChanged: ", "Meeting connection closed")
      }
  }
}

override fun onCreate(savedInstanceState: Bundle?) {
  //...

  // add listener to meeting
  //highlight-next-line
  meeting!!.addEventListener(meetingEventListener)
}
```

</TabItem>

<TabItem value="Java">

```javascript
private final MeetingEventListener meetingEventListener = new MeetingEventListener() {
  @Override
  public void onMeetingStateChanged(String state) {
    switch (state) {
        case "CONNECTING":
          Log.d("onMeetingStateChanged: ", "Meeting is Connecting");
          break;
        case "CONNECTED":
          Log.d("onMeetingStateChanged: ", "Meeting is Connected");
          break;
        case "FAILED":
          Log.d("onMeetingStateChanged: ", "Meeting connection failed");
          break;
        case "DISCONNECTED":
          Log.d("onMeetingStateChanged: ", "Meeting connection disconnected abruptly");
          break;
        case "CLOSING":
          Log.d("onMeetingStateChanged: ", "Meeting is closing");
          break;
        case "CLOSED":
          Log.d("onMeetingStateChanged: ", "Meeting connection closed");
          break;
    }
  }
}

@Override
protected void onCreate(Bundle savedInstanceState) {
  //...

  // add listener to meeting
  //highlight-next-line
  meeting.addEventListener(meetingEventListener);
}
```

</TabItem>

</Tabs>

### API Reference

The API references for all the methods and events utilised in this guide are provided below.

- [onMeetingStateChanged()](/android/api/sdk-reference/meeting-class/meeting-event-listener-class#onmeetingstatechanged)


---

---
title: Meeting Events | Video SDK
hide_title: true
hide_table_of_contents: false
description: Video SDK and Audio SDK, developers need to implement a token server. This requires efforts on both the front-end and backend.
sidebar_label: Meeting Events
pagination_label: Meeting Events
keywords:
  - audio calling
  - video calling
  - real-time communication
  - collaboration
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: meeting-events
---

# Meeting Events - Android

VideoSDK provides multiple types of events which can be listened to know the current state of the meeting.

You can implement all the methods of `MeetingEventListener` abstract Class and add the listener to `Meeting` class using the `addEventListener()` method of `Meeting` Class.

Here are the events which specifically relate to the meeting.

### onMeetingJoined

- This event is triggered when the meeting is successfully joined.

### onMeetingLeft

- This event is triggered when the meeting is left.

### onSpeakerChanged

- This event is triggered when the active speaker in the meeting gets changed.

### onPresenterChanged

- This event is triggered when the presenter in the meeting gets changed.

### Example

Here is the usage of all the events mentioned in this page.

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
private val meetingEventListener: MeetingEventListener = object : MeetingEventListener() {
  override fun onMeetingJoined() {
      Log.d("VideoSDK", "onMeetingJoined: ")
  }

  override fun onMeetingLeft() {
      Log.d("VideoSDK", "onMeetingLeft: ")
  }

  override fun onSpeakerChanged(participantId: String) {
      Log.d("VideoSDK", "onSpeakerChanged: $participantId")
  }

  override fun onPresenterChanged(participantId: String) {
      Log.d("VideoSDK", "onPresenterChanged: $participantId")
  }
}

override fun onCreate(savedInstanceState: Bundle?) {
  //...

  // add listener to meeting
  //highlight-next-line
  meeting!!.addEventListener(meetingEventListener)
}
```

</TabItem>

<TabItem value="Java">

```js
private final MeetingEventListener meetingEventListener = new MeetingEventListener() {
  @Override
  public void onMeetingJoined() {
    Log.d("VideoSDK", "onMeetingJoined: ");
  }

  @Override
  public void onMeetingLeft() {
    Log.d("VideoSDK", "onMeetingLeft: ");
  }

  @Override
  public void onSpeakerChanged(String participantId) {
    Log.d("VideoSDK", "onSpeakerChanged: " + participantId);
  }

  @Override
  public void onPresenterChanged(String participantId) {
    Log.d("VideoSDK", "onPresenterChanged: " + participantId);
  }
};

@Override
protected void onCreate(Bundle savedInstanceState) {
  //...

  // add listener to meeting
  //highlight-next-line
  meeting.addEventListener(meetingEventListener);
}
```

</TabItem>

</Tabs>

### API Reference

The API references for all the methods and events utilised in this guide are provided below.

- [onMeetingJoined()](/android/api/sdk-reference/meeting-class/meeting-event-listener-class#onmeetingjoined)
- [onMeetingLeft()](/android/api/sdk-reference/meeting-class/meeting-event-listener-class#onmeetingleft)
- [onSpeakerChanged()](/android/api/sdk-reference/meeting-class/meeting-event-listener-class#onspeakerchanged)
- [onPresenterChanged()](/android/api/sdk-reference/meeting-class/meeting-event-listener-class#onpresenterchanged)


---

---
title: Participant Events | Video SDK
hide_title: true
hide_table_of_contents: false
description: Video SDK and Audio SDK, developers need to implement a token server. This requires efforts on both the front-end and backend.
sidebar_label: Participant Events
pagination_label: Participant Events
keywords:
  - audio calling
  - video calling
  - real-time communication
  - collaboration
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: participant-events
---

# Participant Events - Android

VideoSDK provides multiple types of events which can be listened to know the about the participants in the meeting.

You can implement all the methods of `MeetingEventListener` abstract Class and add the listener to `Meeting` class using the `addEventListener()` method of `Meeting` Class.

Here are the events which specifically relate to the participants.

### onParticipantJoined

- This event is triggered when someone joins the meeting and return the `Participant` object as parameter.

### onParticipantLeft

- This event is triggered when the someone leaves the meeting.

### onWebcamRequested

- This event will be triggered to the participant `B` when any other participant `A` requests to enable webcam of participant `B`.
- On accepting the request, webcam of participant `B` will be enabled.

### onMicRequested

- This event will be triggered to the participant `B` when any other participant `A` requests to enable mic of participant `B`.
- On accepting the request, mic of participant `B` will be enabled.
- This event can be subscribed from the `useMeeting` hook.

### Example

Here is the usage of all the events mentioned in this page.

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
private val meetingEventListener: MeetingEventListener = object : MeetingEventListener() {
  override fun onParticipantJoined(participant: Participant) {
    Log.d("VideoSDK", participant.displayName + " joined");
  }

  override fun onParticipantLeft(participant: Participant) {
    Log.d("VideoSDK", participant.displayName + " left");
  }

  override fun onWebcamRequested(participantId: String, listener: WebcamRequestListener) {

    // participantId, will be the id of participant who requested to enable mic

    // if accept request
    listener.accept()

    // if reject request
    listener.reject()
  }

  override fun onMicRequested(participantId: String, listener: MicRequestListener) {

    // participantId, will be the id of participant who requested to enable mic

    // if accept request
    listener.accept()

    // if reject request
    listener.reject()
  }
}

override fun onCreate(savedInstanceState: Bundle?) {
  //...

  // add listener to meeting
  //highlight-next-line
  meeting!!.addEventListener(meetingEventListener)
}
```

</TabItem>

<TabItem value="Java">

```javascript
private final MeetingEventListener meetingEventListener = new MeetingEventListener() {
  @Override
  public void onParticipantJoined(Participant participant) {
      Log.d("VideoSDK", participant.getDisplayName() + " joined");
  }

  @Override
  public void onParticipantLeft(Participant participant) {
      Log.d("VideoSDK", participant.getDisplayName() + " left");
  }

  @Override
  public void onWebcamRequested(String participantId, WebcamRequestListener listener) {

    // participantId, will be the id of participant who requested to enable webcam

    // if accept request
    listener.accept();

    // if reject request
    listener.reject();
  }

  @Override
  public void onMicRequested(String participantId, MicRequestListener listener) {

    // participantId, will be the id of participant who requested to enable mic

    // if accept request
    listener.accept();

    // if reject request
    listener.reject();
 }
}

@Override
protected void onCreate(Bundle savedInstanceState) {
  //...

  // add listener to meeting
  //highlight-next-line
  meeting.addEventListener(meetingEventListener);
}
```

</TabItem>

</Tabs>

### API Reference

The API references for all the methods and events utilised in this guide are provided below.

- [onParticipantJoined()](/android/api/sdk-reference/meeting-class/meeting-event-listener-class#onparticipantjoined)
- [onParticipantLeft()](/android/api/sdk-reference/meeting-class/meeting-event-listener-class#onparticipantleft)
- [onWebcamRequested()](/android/api/sdk-reference/meeting-class/meeting-event-listener-class#onwebcamrequested)
- [onMicRequested()](/android/api/sdk-reference/meeting-class/meeting-event-listener-class#onmicrequested)


---

---
title: Recording Events | Video SDK
hide_title: true
hide_table_of_contents: false
description: Video SDK and Audio SDK, developers need to implement a token server. This requires efforts on both the front-end and backend.
sidebar_label: Recording Events
pagination_label: Recording Events
keywords:
  - audio calling
  - video calling
  - real-time communication
  - collaboration
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: recording-events
---

# Recording Events - Android

VideoSDK provides `onRecordingStateChanged` event which will notify you of the current state of recording for the meeting.

### onRecordingStateChanged

- This event will be triggered when the meeting's recording status changed.
- You can implement this method of the abstract Class `MeetingEventListener` and add the listener to `Meeting` class using the `addEventListener()` method of `Meeting` Class.

### Example

Here is the usage of the event mentioned in this page.

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
private val meetingEventListener: MeetingEventListener = object : MeetingEventListener() {
  override fun onRecordingStateChanged(recordingState: String) {
    when (recordingState) {
        "RECORDING_STARTING" -> {
            Log.d("onRecordingStateChanged", "Meeting recording is starting")
        }
        "RECORDING_STARTED" -> {
            Log.d("onRecordingStateChanged", "Meeting recording is started")
        }
        "RECORDING_STOPPING" -> {
            Log.d("onRecordingStateChanged", "Meeting recording is stopping")
        }
        "RECORDING_STOPPED" -> {
            Log.d("onRecordingStateChanged", "Meeting recording is stopped")
        }
    }
  }
}

override fun onCreate(savedInstanceState: Bundle?) {
  //...

  // add listener to meeting
  //highlight-next-line
  meeting!!.addEventListener(meetingEventListener)
}
```

</TabItem>

<TabItem value="Java">

```js
private final MeetingEventListener meetingEventListener = new MeetingEventListener() {
  @Override
  public void onRecordingStateChanged(String recordingState) {
      switch (recordingState) {
          case "RECORDING_STARTING":
              Log.d("onRecordingStateChanged", "Meeting recording is starting");
              break;
          case "RECORDING_STARTED":
              Log.d("onRecordingStateChanged", "Meeting recording is started");
              break;
          case "RECORDING_STOPPING":
              Log.d("onRecordingStateChanged", "Meeting recording is stopping");
              break;
          case "RECORDING_STOPPED":
              Log.d("onRecordingStateChanged", "Meeting recording is stopped");
              break;
      }
  }
}

@Override
protected void onCreate(Bundle savedInstanceState) {
  //...

  // add listener to meeting
  //highlight-next-line
  meeting.addEventListener(meetingEventListener);
}
```

</TabItem>

</Tabs>

### API Reference

The API references for all the methods and events utilised in this guide are provided below.

- [onRecordingStateChanged()](/android/api/sdk-reference/meeting-class/meeting-event-listener-class#onrecordingstatechanged)


---

---
title: RTMP Events | Video SDK
hide_title: true
hide_table_of_contents: false
description: Video SDK and Audio SDK, developers need to implement a token server. This requires efforts on both the front-end and backend.
sidebar_label: RTMP Events
pagination_label: RTMP Events
keywords:
  - audio calling
  - video calling
  - real-time communication
  - collaboration
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: rtmp-events
---

# RTMP Events - Android

VideoSDK provides `onLivestreamStateChanged` event which will notify you of the current state of livestream for the meeting.

### onLivestreamStateChanged

- This event will be triggered when the meeting's livestream status changed.
- You can implement this method of the abstract Class `MeetingEventListener` and add the listener to `Meeting` class using the `addEventListener()` method of `Meeting` Class.

### Example

Here is the usage of the event mentioned in this page.

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
private val meetingEventListener: MeetingEventListener = object : MeetingEventListener() {
  override fun onLivestreamStateChanged(livestreamState: String?) {
    when (livestreamState) {
      "LIVESTREAM_STARTING" -> Log.d( "LivestreamStateChanged",
          "Meeting livestream is starting"
      )
      "LIVESTREAM_STARTED" -> Log.d( "LivestreamStateChanged",
          "Meeting livestream is started"
      )
      "LIVESTREAM_STOPPING" -> Log.d("LivestreamStateChanged",
          "Meeting livestream is stopping"
      )
      "LIVESTREAM_STOPPED" -> Log.d("LivestreamStateChanged",
          "Meeting livestream is stopped"
      )
    }
  }
}

override fun onCreate(savedInstanceState: Bundle?) {
  //...

  // add listener to meeting
  //highlight-next-line
  meeting!!.addEventListener(meetingEventListener)
}
```

</TabItem>

<TabItem value="Java">

```js
private final MeetingEventListener meetingEventListener = new MeetingEventListener() {
  @Override
  public void onLivestreamStateChanged(String livestreamState) {
    switch (livestreamState) {
      case "LIVESTREAM_STARTING":
          Log.d("LivestreamStateChanged", "Meeting livestream is starting");
          break;
      case "LIVESTREAM_STARTED":
          Log.d("LivestreamStateChanged", "Meeting livestream is started");
          break;
      case "LIVESTREAM_STOPPING":
          Log.d("LivestreamStateChanged", "Meeting livestream is stopping");
          break;
      case "LIVESTREAM_STOPPED":
          Log.d("LivestreamStateChanged", "Meeting livestream is stopped");
          break;
    }
  }
}

@Override
protected void onCreate(Bundle savedInstanceState) {
  //...

  // add listener to meeting
  //highlight-next-line
  meeting.addEventListener(meetingEventListener);
}
```

</TabItem>

</Tabs>

### API Reference

The API references for all the methods and events utilised in this guide are provided below.

- [onLivestreamStateChanged()](/android/api/sdk-reference/meeting-class/meeting-event-listener-class#onlivestreamstatechanged)


---

---
title: Get Started with Video & Audio Call - Video SDK Documentation
hide_title: true
hide_table_of_contents: false
description: Video SDK enables the opportunity to integrate native IOS, Android & Web SDKs to add live video & audio conferencing to your applications.
sidebar_label: Getting Started
pagination_label: Getting Started
keywords:
  - audio calling
  - video calling
  - real-time communication
  - collaboration
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: getting-started
---

import Mermaid from '@theme/Mermaid';
import GettingStarted from '/mdx/introduction/\_getting-started.mdx';
import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>
<GettingStarted title="Get Started with Android" />

## Steps

import Card from '@theme/Card';

<div class="container guide-steps-block">
  <div class="row ">
    <div class="col col--6">
      <Card heading="1. Get your API key and Secret" link="/android/guide/video-and-audio-calling-api-sdk/signup-and-create-api" description="Generate your API key and Secret from Video SDK." />
    </div>
     <div class="col col--6">
      <Card heading="2. Client Setup for Android" link="/android/guide/video-and-audio-calling-api-sdk/android-sdk" description="Easy to integrate SDK with cross-channel support." />
    </div>
  </div>
  <div class="row ">
   <div class="col col--6" >
      <Card heading="3. Authentication and Tokens" link="/android/guide/video-and-audio-calling-api-sdk/server-setup" description="Setup secured server authentication and authorization."  />
    </div>
    <div class="col col--6">
      <Card heading="4. Start a Audio / Video Call" link="/android/guide/video-and-audio-calling-api-sdk/quick-start" description="Get started with step by step guide of integrating Video SDK." />
    </div>
  </div>
  <div class="row ">
   <div class="col col--6" >
      <Card heading="5. Basic Features" link="/android/guide/video-and-audio-calling-api-sdk/features/start-join-meeting" description="Explore basic features such as join, leave and customise sessions."  />
    </div>
    <div class="col col--6">
      <Card heading="6. Advanced Features" link="/android/guide/video-and-audio-calling-api-sdk/features/error-event" description="Explore advanced features such as screen sharing, recording and live streaming." />
    </div>
  </div>
</div>

## Architecture

This diagram demonstrates end-to-end flow to implement video & audio calling, record calls and go-live on social media.

![Video-sdk-architecture!](/img/video-sdk-archietecture.svg)


---

---
title: Active Speaker Indication | Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: Speaker Indication features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Active Speaker Indication
pagination_label: Active Speaker Indication
keywords:
  - Active Speaker
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: active-speaker-indication
---

# Active Speaker Indication - Android

Active Speaker indication feature in VideoSDK let you know, which participant in a meeting is active speaker. This feature can be particularly useful in larger meetings or webinars, where there may be many participants and it can be difficult to tell who is speaking.

Whenever any participant speaks in meeting, `onSpeakerChanged` event will trigger with the participant id of the active speaker.

For example, the meeting is running with **Alice** and **Bob**. Whenever any of them speaks, `onSpeakerChanged` event will trigger and return the speaker `participantId`.

### Event

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
private val meetingEventListener: MeetingEventListener = object : MeetingEventListener() {
    override fun onSpeakerChanged(participantId: String?) {
        Toast.makeText(this@MainActivity, "Active Speaker participantId" + participantId, Toast.LENGTH_SHORT).show();
        super.onSpeakerChanged(participantId)
    }
};
```

</TabItem>

<TabItem value="Java">

```js
private final MeetingEventListener meetingEventListener = new MeetingEventListener() {
    @Override
    public void onSpeakerChanged(String participantId) {
        Toast.makeText(MainActivity.this, "Active Speaker participantId" + participantId, Toast.LENGTH_SHORT).show();
        super.onSpeakerChanged(participantId);
    }
};
```

</TabItem>

</Tabs>

### API Reference

The API references for all the methods and events utilised in this guide are provided below.

- [onSpeakerChanged()](/android/api/sdk-reference/meeting-class/meeting-event-listener-class#onspeakerchanged)


---

---
title: Change Input/Output Device | Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: Speaker Indication features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Change Input/Output Device
pagination_label: Change Input/Output Device
keywords:
  - Active Speaker
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: change-input-output-device
---

# Change Input/Output Device - Android

During the meeting at any point a participant wishes to switch his/her audio or video device, it can be done using the below mentioned methods.

## Changing Input/Output Audio Device

### `getMics()`

- The `getMics()` method will return a list of all available microphones that are connected to the mobile device.

- This method will return a Set of `AppRTCAudioManager.AudioDevice`.

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
  private fun getMics(): MutableSet<AppRTCAudioManager.AudioDevice>? {
    //highlight-next-line
    val mics= meeting!!.mics
    return mics  // returns all connected mics
  }
```

</TabItem>

<TabItem value="Java">

```js
  private Set<AppRTCAudioManager.AudioDevice> getMics() {
    //highlight-next-line
    Set<AppRTCAudioManager.AudioDevice> mics = meeting.getMics();
    return mics; // returns all connected mics
  }
```

</TabItem>

</Tabs>

### `changeMic()`

- Participant can change the audio device using `changeMic(AppRTCAudioManager.AudioDevice device)` method of `Meeting` class.

- Parameters that can be passed to `changeMic` are

  | Audio Devices                                | Usage                        |
  | -------------------------------------------- | ---------------------------- |
  | AppRTCAudioManager.AudioDevice.BLUETOOTH     | For Bluetooth Device.        |
  | AppRTCAudioManager.AudioDevice.WIRED_HEADSET | For Wired Handset Device.    |
  | AppRTCAudioManager.AudioDevice.SPEAKER_PHONE | For Inbuilt - Speaker Device |
  | AppRTCAudioManager.AudioDevice.EARPIECE      | For Earpiece Device          |

- When participant changes the Mic, `AppRTCAudioManager.AudioManagerEvents()` is triggered which can be set to `Meeting` class by using `setAudioDeviceChangeListener()`.

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js

  btnChangeMic!!.setOnClickListener { _: View? ->
  // Change Mic during Meeting
  //highlight-next-line
    meeting!!.changeMic(AppRTCAudioManager.AudioDevice.BLUETOOTH)
  }

  private fun setAudioDeviceListeners() {
    //highlight-start
    meeting!!.setAudioDeviceChangeListener(object : AudioManagerEvents {
      override fun onAudioDeviceChanged(
        selectedAudioDevice: AppRTCAudioManager.AudioDevice,
        availableAudioDevices: Set<AppRTCAudioManager.AudioDevice>
      ) {
          when (selectedAudioDevice) {
            AppRTCAudioManager.AudioDevice.BLUETOOTH ->
              Toast.makeText(this@MainActivity, "Selected AudioDevice: BLUETOOTH", Toast.LENGTH_SHORT).show()

            AppRTCAudioManager.AudioDevice.WIRED_HEADSET ->
              Toast.makeText(this@MainActivity, "Selected AudioDevice: WIRED_HEADSET", Toast.LENGTH_SHORT).show()

            AppRTCAudioManager.AudioDevice.SPEAKER_PHONE ->
              Toast.makeText(this@MainActivity, "Selected AudioDevice: SPEAKER_PHONE", Toast.LENGTH_SHORT).show()

            AppRTCAudioManager.AudioDevice.EARPIECE ->
              Toast.makeText(this@MainActivity, "Selected AudioDevice: EARPIECE", Toast.LENGTH_SHORT).show()
          }
        }
    })
    //highlight-end
  }

  override fun onCreate(savedInstanceState: Bundle?) {
       // ...
       setAudioDeviceListeners()
  }
```

</TabItem>

<TabItem value="Java">

```js
  btnChangeMic.setOnClickListener(new View.OnClickListener() {
      @Override
      public void onClick(View v) {
        // Change Mic during Meeting
        //highlight-next-line
        meeting.changeMic(AppRTCAudioManager.AudioDevice.BLUETOOTH);
      }
  });

  private void setAudioDeviceListeners() {
    //highlight-start
    meeting.setAudioDeviceChangeListener(new AppRTCAudioManager.AudioManagerEvents() {
         @Override
        public void onAudioDeviceChanged(AppRTCAudioManager.AudioDevice selectedAudioDevice, Set<AppRTCAudioManager.AudioDevice> availableAudioDevices) {
            switch (selectedAudioDevice) {
                case BLUETOOTH:
                  Toast.makeText(MainActivity.this, "Selected AudioDevice: BLUETOOTH", Toast.LENGTH_SHORT).show();
                  break;
                case WIRED_HEADSET:
                  Toast.makeText(MainActivity.this, "Selected AudioDevice: WIRED_HEADSET", Toast.LENGTH_SHORT).show();
                  break;
                case SPEAKER_PHONE:
                  Toast.makeText(MainActivity.this, "Selected AudioDevice: SPEAKER_PHONE", Toast.LENGTH_SHORT).show();
                  break;
                case EARPIECE:
                  Toast.makeText(MainActivity.this, "Selected AudioDevice: EARPIECE", Toast.LENGTH_SHORT).show();
                  break;
               }
        }
    });
    //highlight-end
  }

  @Override
    protected void onCreate(Bundle savedInstanceState) {
       // ...
       setAudioDeviceListeners();
    }
```

</TabItem>

</Tabs>

- To use Bluetooth device, you must declare `BLUETOOTH` permission in `AndroidManifest.xml` file.

```js
<manifest ... >
//...
<uses-permission android:name="android.permission.BLUETOOTH" />
<uses-permission android:name="android.permission.BLUETOOTH_ADMIN" />
<uses-permission android:name="android.permission.BLUETOOTH_CONNECT" />
</manifest>
```

## Changing Camera Input Device

### `changeWebcam()`

- By using `changeWebcam()` function, a participant can stream from front / rear camera during the meeting.

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
  btnWebcam!!.setOnClickListener {
    // Change Webcam during Meeting
    //highlight-next-line
    meeting!!.changeWebcam()
  }
```

</TabItem>

<TabItem value="Java">

```js
  btnWebcam.setOnClickListener(new View.OnClickListener() {
      @Override
      public void onClick(View v) {
        // Change Webcam during Meeting
        //highlight-next-line
        meeting.changeWebcam();
      }
  });
```

</TabItem>

</Tabs>

### API Reference

The API references for all the methods and events utilised in this guide are provided below.

- [getMics()](/android/api/sdk-reference/meeting-class/methods#getmics)
- [changeMic()](/android/api/sdk-reference/meeting-class/methods#changemic)
- [changeWebcam()](/android/api/sdk-reference/meeting-class/methods#changewebcam)


---

---
title: Image Capturer | Video SDK
hide_title: true
hide_table_of_contents: false
description: Stream Image Capturer.
sidebar_label: Image Capturer
pagination_label: Image Capturer
keywords:
  - image capturer
  - stream image capturer
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: image-capturer
--- 

# Image Capturer - Android

This guide provides instructions on capturing images of participants from a video stream. 

This capability proves particularly valuable in Video KYC scenarios, enabling the capture of images where users can hold up their identity for verification.

### `captureImage()`

- By using the `captureImage()` method of the `Participant` class, you can capture image of a local participant from their video stream.
- You have the option to specify the desired height and width in the `captureImage()` method; however, these parameters are optional. If not provided, the VideoSDK will automatically use the dimensions of the local participant's webcamStream. 
- You need to pass an implementation of `TaskCompletionListener` as a parameter in the `captureImage()` method. This listener will handle the result of the image capture task.
- When the image capture task is complete, the `onComplete()` method will provide the image in the form of a `base64` string. If an error occurs, the `onError()` method will provide the error details.

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
private fun imageCapture() {
  meeting!!.localParticipant.
    .captureImage(400, 400, object : TaskCompletionListener<String?, String?> {
      override fun onComplete(data: String?) {
          Log.d("VideoSDK", "capturedImage in base64 format: $data")
      }

      override fun onError(error: String?) {
          Log.d("VideoSDK", "Error in imageCapture $error")
      }
  })
}
```

</TabItem>

<TabItem value="Java">

```js
private void imageCapture() {
  meeting.getLocalParticipant().captureImage(400, 400, new TaskCompletionListener<String,String>() {
    @Override
    public void onComplete(@Nullable String data) {
        Log.d("VideoSDK", "capturedImage in base64 format: " + data);
    }

    @Override
    public void onError(@Nullable String error) {
        Log.d("VideoSDK", "Error in imageCapture " + error);
    }
  });
}
```

</TabItem>

</Tabs>


:::note

You can only capture an image of the local participant. If you called `captureImage()` method on a remote participant, you will receive an error. To capture an image of a remote participant, refer to the documentation below.

:::

### How to capture image of a remote participant ?

- Before proceeding, it's crucial to understand [VideoSDK's temporary file storage system](/android/guide/video-and-audio-calling-api-sdk/collaboration-in-meeting/upload-fetch-temporary-file) and the underlying [pubsub mechanism](/android/guide/video-and-audio-calling-api-sdk/collaboration-in-meeting/pubsub).

- Here's a break down of the steps, using the names Participant A and Participant B for clarity:

#### Step 1 : Initiate Image Capture Request

- In this step, you have to first send a request to Participant B, whose image you want to capture, using pubsub.
- In order to do that, you have to publish a message. Here, `IMAGE_CAPTURE` pubsub topic is used.
- Also, you will be using the `sendOnly` property of the `PubSubPublishOptions` class. Therefore, the request will be sent to that participant only.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
class MainActivity : AppCompatActivity() {

  //..
  
  private fun sendRequest(participantId: String) {
    if (participantId != meeting.localParticipant.id) {
      val publishOptions = PubSubPublishOptions()
      publishOptions.isPersist = false
      //highlight-start
      // Pass the participantId of the participant whose image you want to capture
      // Here, it will be Participant B's id, as you want to capture the the image of Participant B
      val sendOnly = arrayOf(participantId)
      publishOptions.setSendOnly(sendOnly)
      //highlight-end

      // send request to participant using the publish method
      //highlight-next-line
      meeting.pubSub.publish("IMAGE_CAPTURE", "Sending request to capture image", publishOptions)
    }
  }
}
```

</TabItem>

<TabItem value="Java">

```js
public class MainActivity extends AppCompatActivity {
 
  //...

  private void sendRequest(String participantId) {
    if (!participantId.equals(meeting.getLocalParticipant().getId())) {
      PubSubPublishOptions publishOptions = new PubSubPublishOptions();
      publishOptions.setPersist(false);
      //highlight-start
      // Pass the participantId of the participant whose image you want to capture
      // Here, it will be Participant B's id, as you want to capture the the image of Participant B
      String[] sendOnly = {participantId};
      publishOptions.setSendOnly(sendOnly);
      //highlight-end

      // send request to participant using the publish method
      //highlight-next-line
      meeting.pubSub.publish("IMAGE_CAPTURE", "Sending request to capture image", publishOptions);
    }
  }
}
```

</TabItem>

</Tabs>

#### Step 2 : Capture and Upload File

- To capture an image from a remote participant [Participant B], you will filter out the request from the `onMessageReceived` event of the `PubSubMessageListener`. For that, you need to subscribe to a topic called `IMAGE_CAPTURE`. When you receive an image capture request, you will capture the image using the `captureImage()` method of the `Participant` class.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
class MainActivity : AppCompatActivity() {
  override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    setContentView(R.layout.activity_main)

    //...

    // add listener to meeting
    //highlight-next-line
    meeting!!.addEventListener(meetingEventListener) 
  }

  private val meetingEventListener: MeetingEventListener = object : MeetingEventListener() {

    override fun onMeetingJoined() {
      Log.d("#meeting", "onMeetingJoined()")
      val pubSubMessageListener =
        PubSubMessageListener { message ->
          if (message.senderId != meeting!!.localParticipant.id) {
            //highlight-start
            // capture and store image when message received
            captureAndStoreImage(message.senderId)
            //highlight-end
          }
        }
      // subscribe for 'IMAGE_CAPTURE' topic to receive request
      //highlight-next-line
      meeting!!.pubSub.subscribe("IMAGE_CAPTURE", pubSubMessageListener)
    }

    //...
  }

  private fun captureAndStoreImage(senderId: String) {
    //highlight-start
    // capture image
    meeting!!.localParticipant
      .captureImage(object : TaskCompletionListener<String?, String?> {
        override fun onComplete(@Nullable base64Data: String?) {
            Log.d("VideoSDK", "capturedImage in base64 format: $base64Data")
        }

        override fun onError(@Nullable error: String?) {
            Log.d("VideoSDK", "Error in image capture: $error")
        }
    })
    //highlight-end
  }
}
```

</TabItem>

<TabItem value="Java">

```js
public class MainActivity extends AppCompatActivity {
 @Override
  protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);

    //...

    // add listener to meeting
    //highlight-next-line
    meeting.addEventListener(meetingEventListener);
  }

   private final MeetingEventListener meetingEventListener = new MeetingEventListener() {
      @Override
      public void onMeetingJoined() {
        Log.d("#meeting", "onMeetingJoined()");

        PubSubMessageListener pubSubMessageListener = new PubSubMessageListener() {
          @Override
          public void onMessageReceived(PubSubMessage message) {
            if (!message.getSenderId().equals(meeting.getLocalParticipant().getId())) 
            {
              //highlight-start
              // capture and store image when message received
              captureAndStoreImage(message.getSenderId());
              //highlight-end
            }
          }
        }  
        // subscribe for 'IMAGE_CAPTURE' topic to receive request
        //highlight-next-line
        meeting.pubSub.subscribe("IMAGE_CAPTURE", pubSubMessageListener);
      }

      //...
    };

  private void captureAndStoreImage(String senderId) {
    //highlight-start
    // capture image
    meeting.getLocalParticipant().captureImage(new TaskCompletionListener<String, String>() {
      @Override
      public void onComplete(@Nullable String base64Data) {   
        Log.d("VideoSDK", "capturedImage in base64 format: " + base64Data);    
      }

      @Override
      public void onError(@Nullable String error) {
          Log.d("VideoSDK", "Error in image capture: " + error);
      }
    });
    //highlight-end
  }
}
```

</TabItem>

</Tabs>

- After capturing the image of the remote participant, you need to store this image in VideoSDK's temporary file storage system. This will allow you to send the image to the participant who initiated the request.
- Utilize the `uploadBase64File()` method of the `Meeting` class to store the captured image in VideoSDK's temporary file storage system.
- When the upload is complete, the `onComplete()` method of `TaskCompletionListener` will provide the corresponding `fileUrl`, which can be used to retrieve the uploaded file.
- If an error occurs during the upload process, the `onError()` method of `TaskCompletionListener` will provide the error details.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
class MainActivity : AppCompatActivity() {
  override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    setContentView(R.layout.activity_main)
    //...
  }

  private fun captureAndStoreImage(senderId: String) {
    // listener for file-upload
    val fileUploadListener: TaskCompletionListener<String, String> =
      object : TaskCompletionListener<String?, String?> {
        override fun onComplete(@Nullable fileUrl: String?) {
          //highlight-next-line
          Log.d("VideoSDK", "Uploaded file url: $fileUrl")
        }

        override fun onError(@Nullable error: String?) {
          Log.d("VideoSDK", "Error in upload file: $error")
        }
    }

    // capture image
    meeting!!.localParticipant
      .captureImage(object : TaskCompletionListener<String?, String?> {
        override fun onComplete(@Nullable base64Data: String?) {
          Log.d("VideoSDK", "capturedImage in base64 format: $base64Data")
          val token = "<VIDEOSDK_TOKEN>"
          val fileName = "myCapture.jpeg" // specify a name for image file with extension
          //highlight-start
          // upload image to videosdk storage system
          meeting!!.uploadBase64File(base64Data, token, fileName, fileUploadListener)
          //highlight-end
        }

        override fun onError(@Nullable error: String?) {
            Log.d("VideoSDK", "Error in image capture: $error")
        }
      })
  }
}
```

</TabItem>

<TabItem value="Java">

```js
public class MainActivity extends AppCompatActivity {
  @Override
  protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);
    //...
  }

  private void captureAndStoreImage(String senderId) {
    // listener for file-upload
    TaskCompletionListener<String, String> fileUploadListener = new TaskCompletionListener<>() {
      @Override
      public void onComplete(@Nullable String fileUrl) {
        //highlight-next-line
        Log.d("VideoSDK", "Uploaded file url: " + fileUrl);
      }

      @Override
      public void onError(@Nullable String error) {
        Log.d("VideoSDK", "Error in upload file: " + error);
      }
    };

    // capture image
    meeting.getLocalParticipant().captureImage(new TaskCompletionListener<String, String>() {
        @Override
        public void onComplete(@Nullable String base64Data) {   
          Log.d("VideoSDK", "capturedImage in base64 format: " + base64Data); 
          String token = "<VIDEOSDK_TOKEN>";
          String fileName = "myCapture.jpeg"; // specify a name for image file with extension
          //highlight-start
          // upload image to videosdk storage system
          meeting.uploadBase64File(base64Data, token, fileName, fileUploadListener); 
          //highlight-end 
        }

        @Override
        public void onError(@Nullable String error) {
            Log.d("VideoSDK", "Error in image capture: " + error);
        }
    });
  }
}
```

</TabItem>

</Tabs>


- Next, the `fileUrl` is sent back to the participant who initiated the request using the `IMAGE_TRANSFER` topic.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
class MainActivity : AppCompatActivity() {

  //..
  
  private fun captureAndStoreImage(senderId: String) {
    // listener for file-upload
    val fileUploadListener: TaskCompletionListener<String, String> =
      object : TaskCompletionListener<String?, String?> {
        override fun onComplete(@Nullable fileUrl: String?) {
          //highlight-start
          Log.d("VideoSDK", "Uploaded file url: $fileUrl")
          imageTransfer(fileUrl, senderId)
          //highlight-end
        }

        override fun onError(@Nullable error: String?) {
          Log.d("VideoSDK", "Error in upload file: $error")
        }
    }

    //...
  }

  private fun imageTransfer(fileUrl: String?, senderId: String) {
    val publishOptions = PubSubPublishOptions()
    publishOptions.isPersist = false
    //highlight-start
    // Pass the participantId who initiated the request
    val sendOnly = arrayOf(senderId)
    publishOptions.setSendOnly(sendOnly)
    //highlight-end

    // send fileUrl to the participant who request for image using the publish method
    //highlight-next-line
    meeting!!.pubSub.publish("IMAGE_TRANSFER", fileUrl, publishOptions)
  }
}
```

</TabItem>

<TabItem value="Java">

```js
public class MainActivity extends AppCompatActivity {

  //...

  private void captureAndStoreImage(String senderId) {
      // listener for file-upload
      TaskCompletionListener<String, String> fileUploadListener = new TaskCompletionListener<>() {
          @Override
          public void onComplete(@Nullable String fileUrl) {
            //highlight-start
            Log.d("VideoSDK", "Uploaded file url: " + fileUrl);
            imageTransfer(fileUrl, senderId);
            //highlight-end
          }

          @Override
          public void onError(@Nullable String error) {
            Log.d("VideoSDK", "Error in upload file: " + error);
          }
      };

      //...

    }

    private void imageTransfer(String fileUrl,String senderId) {
      PubSubPublishOptions publishOptions = new PubSubPublishOptions();
      publishOptions.setPersist(false);
      //highlight-start
      // Pass the participantId who initiated the request
      String[] sendOnly = {senderId};
      publishOptions.setSendOnly(sendOnly);
      //highlight-end

      // send fileUrl to the participant who request for image using the publish method
      //highlight-next-line
      meeting.pubSub.publish("IMAGE_TRANSFER", fileUrl, publishOptions);
    }
}
```

</TabItem>

</Tabs>

#### Step 3 : Fetch and Display Image

- To display a captured image, the `showCapturedImage()` method is used. Here's how it works:

- Within the `showCapturedImage()` method, subscribe to the `IMAGE_TRANSFER` topic to receive the `fileUrl` associated with the captured image.

- Once the `fileUrl` is obtained, use the `fetchBase64File()` method from the `Meeting` class to retrieve the file in `base64` format from VideoSDK's temporary storage.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
class MainActivity : AppCompatActivity() {

  @Override
  protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);
    
    showCapturedImage()
  }
  
  private fun showCapturedImage() {
    val pubSubMessageListener =
      PubSubMessageListener { message: PubSubMessage ->
        if (message.senderId != meeting!!.localParticipant.id) {
          // fetch the image when message received
          val url = message.message
          val token = "<VIDEOSDK_TOKEN>"
          meeting!!.fetchBase64File(
            url,
            token,
            object : TaskCompletionListener<String?, String?> {
              override fun onComplete(@Nullable base64Data: String?) {
                  // here is your image in the form of base64
                  Log.d("VideoSDK", "Fetched file in base64:$base64Data")
                  // coverting base64 to bitmap to display an image in the imageView
                  val capturedImage =
                      findViewById<ImageView>(R.id.capturedImage)
                  val decodedString: ByteArray =
                      Base64.decode(base64Data, Base64.DEFAULT)
                  val decodedByte =
                      BitmapFactory.decodeByteArray(
                          decodedString,
                          0,
                          decodedString.size
                      )
                  capturedImage.setImageBitmap(decodedByte)
              }

              override fun onError(@Nullable error: String?) {
                  Log.d("VideoSDK", "Error in fetch file: $error")
              }
            }
          )
        }
      }

    // Subscribe for 'IMAGE_TRANSFER' topic to receive fileUrl
    meeting!!.pubSub.subscribe("IMAGE_TRANSFER", pubSubMessageListener)
  }
}
```

</TabItem>

<TabItem value="Java">

```js
public class MainActivity extends AppCompatActivity {
  @Override
  protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);

    //...
    
    showCapturedImage();
  }

  private void showCapturedImage(){
    PubSubMessageListener pubSubMessageListener = message -> {
      if (!message.getSenderId().equals(meeting.getLocalParticipant().getId())) {
        // fetch the image when message received
        String url = message.getMessage();
        String token = "<VIDEOSDK_TOKEN>";
        meeting.fetchBase64File(url, token, new TaskCompletionListener<String, String>() {
          @Override
          public void onComplete(@Nullable String base64Data) {
            // here is your image in the form of base64
            Log.d("VideoSDK", "Fetched file in base64:" + base64Data); 
            // coverting base64 to bitmap to display an image in the imageView
            ImageView capturedImage = findViewById(R.id.capturedImage);
            byte[] decodedString = Base64.decode(base64Data, Base64.DEFAULT);
            Bitmap decodedByte = BitmapFactory.decodeByteArray(decodedString, 0, decodedString.length);
            capturedImage.setImageBitmap(decodedByte);
          }

          @Override
          public void onError(@Nullable String error) {
              Log.d("VideoSDK", "Error in fetch file: " + error);
          }
        });
      }
    };

    // Subscribe for 'IMAGE_TRANSFER' topic to receive fileUrl
    meeting.pubSub.subscribe("IMAGE_TRANSFER", pubSubMessageListener);
  }
}
```

</TabItem>

</Tabs>

:::note

The file stored in the [VideoSDK's temporary file storage system](/react/guide/video-and-audio-calling-api-sdk/collaboration-in-meeting/upload-fetch-temporary-file) will be automatically deleted once the current room/meeting comes to an end.

:::

## API Reference

The API references for all the methods utilized in this guide are provided below.

- [captureImage()](/android/api/sdk-reference/participant-class/methods#captureimage)
- [pubSub()](/android/api/sdk-reference/pubsub-class/introduction)
- [uploadBase64File()](/android/api/sdk-reference/meeting-class/methods#uploadbase64file)
- [fetchBase64File()](/android/api/sdk-reference/meeting-class/methods#fetchbase64file)


---

---
title: Mute / Unmute Mic | Video SDK
hide_title: true
hide_table_of_contents: false
description: Mic Controls features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Mute / Unmute Mic
pagination_label: Mute / Unmute Mic
keywords:
  - audio calling
  - video calling
  - real-time communication
  - collaboration
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: mute-unmute-mic
---

# Mute / Unmute Mic - Android

Muting and Unmuting your microphone refers to turning your microphone off and on, respectively.

When you mute your microphone, you prevent any sound from your microphone from being transmitted to other meeting participants, while unmuting it allows others to hear you.

### `unmuteMic()`

- By using `unmuteMic()` function of `Meeting` class, local participant can publish audio to other participants.

  - You can call this method when the local participant is not broadcasting any audio to others.

- You can pass customised audio track in `unmuteMic()` by using [Custom Audio Track](/android/guide/video-and-audio-calling-api-sdk/render-media/optimize-audio-track).

- Audio stream of the participant can be accessed from the `onStreamEnabled` event of `ParticipantEventListener`.

### `muteMic()`

- By using `muteMic()` function of `Meeting` class, local participant can stop publish audio to other participants.

- You can call this method when the local participant is broadcasting any audio to others.

#### Example

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
  private var micEnabled = false

  btnMic!!.setOnClickListener { _: View? ->
     if (micEnabled) {
      // Muting Mic
      //highlight-next-line
       meeting!!.muteMic()
       micEnabled=false
     } else {
      // Unmuting Mic
      //highlight-next-line
      meeting!!.unmuteMic()
      micEnabled=true
     }
  }
```

</TabItem>

<TabItem value="Java">

```js
  private boolean micEnabled = false;

  btnMic.setOnClickListener(new View.OnClickListener() {
      @Override
      public void onClick(View v) {
          if (micEnabled) {
              // Muting Mic
              //highlight-next-line
              meeting.muteMic();
              micEnabled = false;
          } else {
            // Unmuting Mic
            //highlight-next-line
              meeting.unmuteMic();
              micEnabled = true;
          }
      }
  });
```

</TabItem>

</Tabs>

### Events associated with `unmuteMic`

- Every Participant will receive a callback on [`onStreamEnabled()`](/android/api/sdk-reference/participant-class/participant-event-listener-class#onstreamenabled) of the [`Participant`](/android/api/sdk-reference/participant-class/introduction) with `Stream` object.

### Events associated with `muteMic`

- Every Participant will receive a callback on [`onStreamDisabled()`](/android/api/sdk-reference/participant-class/participant-event-listener-class#onstreamdisabled) of the [`Participant`](/android/api/sdk-reference/participant-class/introduction) with `Stream` object.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
  meeting!!.localParticipant.addEventListener(object : ParticipantEventListener() {
    //Callback for when the participant starts a stream
    //highlight-start
    override fun onStreamEnabled(stream: Stream) {
        if(stream.getKind().equals("audio")){
          Log.d("VideoSDK","Audio Stream On: onStreamEnabled $stream");
        }
    }
    //highlight-end

    //Callback for when the participant stops a stream
    //highlight-start
    override fun onStreamDisabled(stream: Stream) {
        if(stream.getKind().equals("audio")){
          Log.d("VideoSDK","Audio Stream On: onStreamDisabled $stream");
        }
    }
    //highlight-end
  });
```

</TabItem>

<TabItem value="Java">

```js
  participant.addEventListener(new ParticipantEventListener() {
    //Callback for when the participant starts a stream
    //highlight-start
    @Override
    public void onStreamEnabled(Stream stream) {
        if(stream.getKind().equals("audio")){
          Log.d("VideoSDK","Audio Stream On: onStreamEnabled" + stream);
        }
    }
    //highlight-end

    //Callback for when the participant stops a stream
    //highlight-start
    @Override
    public void onStreamDisabled(Stream stream) {
        if(stream.getKind().equals("audio")){
          Log.d("VideoSDK","Audio Stream Off: onStreamDisabled" + stream);
        }
    }
    //highlight-end
  });
```

</TabItem>

</Tabs>

### Audio Permissions

- To use the microphone in a meeting, you need to add permission in `app/src/main/AndroidManifest.xml` after `</application>`.

```xml title="AndroidManifest.xml"
<uses-permission android:name="android.permission.RECORD_AUDIO" />
```

- You need to set up a permission request that provides this access.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
import android.Manifest
import android.content.pm.PackageManager
import android.os.Bundle
import android.widget.Toast
import androidx.appcompat.app.AppCompatActivity
import androidx.core.app.ActivityCompat
import androidx.core.content.ContextCompat

class MainActivity : AppCompatActivity() {
    private val PERMISSION_REQUEST_CODE: Int = 1;

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        //highlight-start
        if (checkPermission()) {
            // . write your main code to execute, It will execute if the permission is already given.
        } else {
            requestPermission()
        }
        //highlight-end
    }
    private fun checkPermission(): Boolean {
        //highlight-next-line
        return ContextCompat.checkSelfPermission(this, Manifest.permission.RECORD_AUDIO) == PackageManager.PERMISSION_GRANTED
    }

    private fun requestPermission() {
      //highlight-start
        ActivityCompat.requestPermissions(
            this, arrayOf(Manifest.permission.RECORD_AUDIO),
            PERMISSION_REQUEST_CODE
        )
      //highlight-end
    }

    override
    fun onRequestPermissionsResult(
        requestCode: Int,
        permissions: Array<out String>,
        grantResults: IntArray
    ) {
        super.onRequestPermissionsResult(requestCode, permissions, grantResults)
        when (requestCode) {
            PERMISSION_REQUEST_CODE -> if (grantResults.isNotEmpty() && grantResults[0] == PackageManager.PERMISSION_GRANTED) {
                Toast.makeText(applicationContext, "Permission Granted", Toast.LENGTH_SHORT).show()
                // main logic
            } else {
                Toast.makeText(applicationContext, "Permission Denied", Toast.LENGTH_SHORT).show()
            }
        }
    }
}
```

</TabItem>

<TabItem value="Java">

```js
import androidx.annotation.NonNull;
import androidx.appcompat.app.AppCompatActivity;
import androidx.core.app.ActivityCompat;
import androidx.core.content.ContextCompat;

import android.Manifest;
import android.content.pm.PackageManager;
import android.os.Bundle;
import android.widget.Toast;

import java.util.ArrayList;
import java.util.List;

public class MainActivity extends AppCompatActivity {

    private static final int PERMISSION_REQUEST_CODE = 1;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        //highlight-start
        if (checkPermission()) {
            // . write your main code to execute, It will execute if the permission is already given.
        } else {
            requestPermission();
        }
        //highlight-end
    }

    private boolean checkPermission() {
        //highlight-next-line
        return ContextCompat.checkSelfPermission(this, Manifest.permission.RECORD_AUDIO) == PackageManager.PERMISSION_GRANTED;
    }

    private void requestPermission() {
        List<String> permissionList = new ArrayList<String>();
        String[] permissions = {};
        permissionList.add(Manifest.permission.RECORD_AUDIO);
        //highlight-start
        ActivityCompat.requestPermissions(
                this, permissionList.toArray(permissions),
                PERMISSION_REQUEST_CODE
        );
        //highlight-end
    }

    @Override
    public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
        super.onRequestPermissionsResult(requestCode, permissions, grantResults);
        switch (requestCode) {
            case PERMISSION_REQUEST_CODE:
                if (grantResults.length > 0 && grantResults[0] == PackageManager.PERMISSION_GRANTED) {
                    Toast.makeText(MainActivity.this, "Permission Granted", Toast.LENGTH_SHORT).show();
                    // main logic
                } else {
                    Toast.makeText(MainActivity.this, "Permission Denied", Toast.LENGTH_SHORT).show();
                }
                break;
        }
    }
}
```

</TabItem>

</Tabs>

### API Reference

The API references for all the methods and events utilised in this guide are provided below.

- [unmuteMic()](/android/api/sdk-reference/meeting-class/methods#unmutemic)
- [muteMic()](/android/api/sdk-reference/meeting-class/methods#mutemic)
- [onStreamEnabled()](/android/api/sdk-reference/participant-class/participant-event-listener-class#onstreamenabled)
- [onStreamDisabled()](/android/api/sdk-reference/participant-class/participant-event-listener-class#onstreamdisabled)


---

---
title: On / Off Camera | Video SDK
hide_title: true
hide_table_of_contents: false
description: Camera Controls features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: On / Off Camera
pagination_label: On / Off Camera
keywords:
  - audio calling
  - video calling
  - real-time communication
  - collaboration
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: on-off-camera
---

# On / Off Camera - Android

Any participant can turn on or off his camera in the meeting using below methods.

### `enableWebcam()`

- By using `enableWebcam()` function of `Meeting` class, local participant can publish video to other participants.

- You can call this method when the local participant is not broadcasting any video to others.

- You can pass customised video track in `enableWebcam()` by using [Custom Video Track](/android/guide/video-and-audio-calling-api-sdk/render-media/optimize-video-track#custom-video-track).

- Video stream of the participant can be accessed from the `onStreamEnabled` event of `ParticipantEventListener`.

### `disableWebcam()`

- By using `disableWebcam()` function of `Meeting` class, local participant can stop publish video to other participants.

- You can call this method when the local participant is broadcasting any video to others.

#### Example

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
  btnWebcam!!.setOnClickListener {
    if (webcamEnabled) {
      // Disabling camera
      //highlight-next-line
      meeting!!.disableWebcam()
    } else {
      // Enabling camera
      //highlight-next-line
      meeting!!.enableWebcam()
    }
    webcamEnabled=!webcamEnabled
  }
```

</TabItem>

<TabItem value="Java">

```js
  btnWebcam.setOnClickListener(new View.OnClickListener() {
      @Override
      public void onClick(View v) {
        if (webcamEnabled) {
          // Disabling camera
          //highlight-next-line
          meeting.disableWebcam();
        } else {
          // Enabling camera
          //highlight-next-line
          meeting.enableWebcam();
        }
        webcamEnabled=!webcamEnabled;
      }
  });
```

</TabItem>

</Tabs>

:::important
To learn, how to render video in the meeting, [follow this](/android/guide/video-and-audio-calling-api-sdk/render-media/display-video/render-participant) detailed guide.
:::

### Events associated with `enableWebcam`

- Every Participant will receive a callback on [`onStreamEnabled()`](/android/api/sdk-reference/participant-class/participant-event-listener-class#onstreamenabled) of the [`Participant`](/android/api/sdk-reference/participant-class/introduction) with `Stream` object.

### Events associated with `disableWebcam`

- Every Participant will receive a callback on [`onStreamDisabled()`](/android/api/sdk-reference/participant-class/participant-event-listener-class#onstreamdisabled) of the [`Participant`](/android/api/sdk-reference/participant-class/introduction) with `Stream` object.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
  meeting!!.localParticipant.addEventListener(object : ParticipantEventListener() {
    //Callback for when the participant starts a stream
    //highlight-start
    override fun onStreamEnabled(stream: Stream) {
        if(stream.getKind().equals("video")){
          Log.d("VideoSDK","Video Stream On: onStreamEnabled $stream");
        }
    }
    //highlight-end

    //Callback for when the participant stops a stream
    //highlight-start
    override fun onStreamDisabled(stream: Stream) {
        if(stream.getKind().equals("video")){
          Log.d("VideoSDK","Video Stream On: onStreamDisabled $stream");
        }
    }
    //highlight-end
  });
```

</TabItem>

<TabItem value="Java">

```js
  participant.addEventListener(new ParticipantEventListener() {
    //Callback for when the participant starts a stream
    //highlight-start
    @Override
    public void onStreamEnabled(Stream stream) {
        if(stream.getKind().equals("video")){
          Log.d("VideoSDK","Video Stream On: onStreamEnabled" + stream);
        }
    }
    //highlight-end

    //Callback for when the participant stops a stream
    //highlight-start
    @Override
    public void onStreamDisabled(Stream stream) {
        if(stream.getKind().equals("video")){
          Log.d("VideoSDK","Video Stream Off: onStreamDisabled" + stream);
        }
    }
    //highlight-end
  });
```

</TabItem>

</Tabs>

### Video Permissions

- To use the camera in a meeting, you need to add permission in `app/src/main/AndroidManifest.xml` after `</application>`.

```xml title="AndroidManifest.xml"
<uses-permission android:name="android.permission.CAMERA" />
```

- You need to set up a permission request that provides this access.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
import android.Manifest
import android.content.pm.PackageManager
import android.os.Bundle
import android.widget.Toast
import androidx.appcompat.app.AppCompatActivity
import androidx.core.app.ActivityCompat
import androidx.core.content.ContextCompat

class MainActivity : AppCompatActivity() {
    private val PERMISSION_REQUEST_CODE: Int = 1;

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        //highlight-start
        if (checkPermission()) {
            // . write your main code to execute, It will execute if the permission is already given.
        } else {
            requestPermission()
        }
        //highlight-end
    }
    private fun checkPermission(): Boolean {
        //highlight-next-line
        return ContextCompat.checkSelfPermission(this, Manifest.permission.CAMERA) == PackageManager.PERMISSION_GRANTED
    }

    private fun requestPermission() {
      //highlight-start
        ActivityCompat.requestPermissions(
            this, arrayOf(Manifest.permission.CAMERA),
            PERMISSION_REQUEST_CODE
        )
      //highlight-end
    }

    override
    fun onRequestPermissionsResult(
        requestCode: Int,
        permissions: Array<out String>,
        grantResults: IntArray
    ) {
        super.onRequestPermissionsResult(requestCode, permissions, grantResults)
        when (requestCode) {
            PERMISSION_REQUEST_CODE -> if (grantResults.isNotEmpty() && grantResults[0] == PackageManager.PERMISSION_GRANTED) {
                Toast.makeText(applicationContext, "Permission Granted", Toast.LENGTH_SHORT).show()
                // main logic
            } else {
                Toast.makeText(applicationContext, "Permission Denied", Toast.LENGTH_SHORT).show()
            }
        }
    }
}
```

</TabItem>

<TabItem value="Java">

```js
import androidx.annotation.NonNull;
import androidx.appcompat.app.AppCompatActivity;
import androidx.core.app.ActivityCompat;
import androidx.core.content.ContextCompat;

import android.Manifest;
import android.content.pm.PackageManager;
import android.os.Bundle;
import android.widget.Toast;

import java.util.ArrayList;
import java.util.List;

public class MainActivity extends AppCompatActivity {

    private static final int PERMISSION_REQUEST_CODE = 1;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        //highlight-start
        if (checkPermission()) {
            // . write your main code to execute, It will execute if the permission is already given.
        } else {
            requestPermission();
        }
        //highlight-end
    }

    private boolean checkPermission() {
        //highlight-next-line
        return ContextCompat.checkSelfPermission(this, Manifest.permission.CAMERA) == PackageManager.PERMISSION_GRANTED;
    }

    private void requestPermission() {
        List<String> permissionList = new ArrayList<String>();
        String[] permissions = {};
        permissionList.add(Manifest.permission.CAMERA);
        //highlight-start
        ActivityCompat.requestPermissions(
                this, permissionList.toArray(permissions),
                PERMISSION_REQUEST_CODE
        );
        //highlight-end
    }

    @Override
    public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
        super.onRequestPermissionsResult(requestCode, permissions, grantResults);
        switch (requestCode) {
            case PERMISSION_REQUEST_CODE:
                if (grantResults.length > 0 && grantResults[0] == PackageManager.PERMISSION_GRANTED) {
                    Toast.makeText(MainActivity.this, "Permission Granted", Toast.LENGTH_SHORT).show();
                    // main logic
                } else {
                    Toast.makeText(MainActivity.this, "Permission Denied", Toast.LENGTH_SHORT).show();
                }
                break;
        }
    }
}
```

</TabItem>

</Tabs>

:::important
If the app goes to the background, VideoSDK detectes this event based on activity lifecycle and release the camera so that it can be used by other apps. In order to make sure this functionality works properly use  `VideoSDK.setActivityForLifeCycle(activity)` to specify which activity VideoSDK should monitor for lifecycle changes.
:::

### API Reference

The API references for all the methods and events utilised in this guide are provided below.

- [enableWebcam()](/android/api/sdk-reference/meeting-class/methods#enablewebcam)
- [disableWebcam()](/android/api/sdk-reference/meeting-class/methods#disablewebcam)
- [onStreamEnabled()](/android/api/sdk-reference/participant-class/participant-event-listener-class#onstreamenabled)
- [onStreamDisabled()](/android/api/sdk-reference/participant-class/participant-event-listener-class#onstreamdisabled)


---

---
title: Screen Share | Video SDK
hide_title: true
hide_table_of_contents: false
description: Share your Screen features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Screen Share
pagination_label: Screen Share
keywords:
  - audio calling
  - video calling
  - real-time communication
  - collaboration
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: screen-share
---

# Screen Share - Android

Screen sharing in a meeting is the process of sharing your mobile screen with other participants in the meeting. It allows everyone in the meeting to see exactly what you are seeing on your screen, which can be helpful for presentations, demonstrations, or collaborations.

## How Screen share works?

- The following diagram shows flow of the screen sharing in android using VideoSDK :

<div style={{textAlign: 'center'}}>

![VideoSDK Android Screenshare Flow Diagram](/img/android/screenshare/flow_diagram.png)

</div>

### `enableScreenShare()`

- By using `enableScreenShare()` function of `Meeting` class, local participant can share his/her mobile screen to other participants.

- You can pass customised screenshare track in `enableScreenShare()` by using [Custom Screen Share Track](/android/guide/video-and-audio-calling-api-sdk/render-media/optimize-video-track#custom-screen-share-track).

- Screen Share stream of the participant can be accessed from the `onStreamEnabled` event of `ParticipantEventListener`.

### Screenshare permission

- A participant’s Screen share stream is provided via the `MediaProjection` API. This API is only compatible with `Build.VERSION_CODES.LOLLIPOP` or higher.

- Get an instance of the `MediaProjectionManager` and Call the `createScreenCaptureIntent()` method in an activity. This initiates a prompt dialog for the user to confirm screen projection.

- One will get a prompt dialog like this:

<div style={{textAlign: 'center'}}>

<img
src={require('/img/android/screenshare/user_permission.jpg').default}
alt="user permission"
width="450"
/>

</div>

<br/>

- After permission is received from the user, you can call `enableScreenShare()` method.

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
private fun enableScreenShare() {
    val mediaProjectionManager = application.getSystemService(
        MEDIA_PROJECTION_SERVICE
    ) as MediaProjectionManager
    startActivityForResult(
        mediaProjectionManager.createScreenCaptureIntent(), CAPTURE_PERMISSION_REQUEST_CODE
    )
}

public override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) {
    super.onActivityResult(requestCode, resultCode, data)
    if (requestCode != CAPTURE_PERMISSION_REQUEST_CODE) return
    if (resultCode == RESULT_OK) {
        // Enabling screen share
        //highlight-next-line
        meeting!!.enableScreenShare(data)
    }
}
```

</TabItem>

<TabItem value="Java">

```js
private void enableScreenShare() {
    MediaProjectionManager mediaProjectionManager =
        (MediaProjectionManager) getApplication().getSystemService(
            Context.MEDIA_PROJECTION_SERVICE);
    startActivityForResult(
        mediaProjectionManager.createScreenCaptureIntent(), CAPTURE_PERMISSION_REQUEST_CODE);
}

@Override
public void onActivityResult(int requestCode, int resultCode, Intent data) {
    super.onActivityResult(requestCode, resultCode, data);
    if (requestCode != CAPTURE_PERMISSION_REQUEST_CODE)
        return;
    if (resultCode == Activity.RESULT_OK) {
        // Enabling screen share
        //highlight-next-line
        meeting.enableScreenShare(data);
    }
}
```

</TabItem>

</Tabs>

### Customise notification

- When a presenter starts screen share, presenter will receive a notification with a pre-defined title and message.

- Notification with pre-defined title and message will look like this:

<div style={{textAlign: 'center'}}>

<img
src={require('/img/android/screenshare/notification.jpg').default}
alt="notification"
width="450"
/>

</div>

- You can Customise those title, message and icon as per your requirements using `<meta-data>` specified in `app/src/main/AndroidManifest.xml`.

```js
<application>
  <meta-data
    android:name="notificationTitle"
    //highlight-next-line
    android:value="@string/notificationTitle"
  />
  <meta-data
    android:name="notificationContent"
    //highlight-next-line
    android:value="@string/notificationContent"
  />
  <meta-data
    android:name="notificationIcon"
    //highlight-next-line
    android:resource="@mipmap/ic_launcher_round"
  />
</application>
```

### `disableScreenShare()`

- By using `disableScreenShare()` function of `Meeting` class, local participant can stop sharing his/her mobile screen to other participants.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
private fun disableScreenShare() {
    // Disabling screen share
    //highlight-next-line
    meeting!!.disableScreenShare()
}
```

</TabItem>

<TabItem value="Java">

```js
private void disableScreenShare(){
    // Disabling screen share
    //highlight-next-line
    meeting.disableScreenShare();
}
```

</TabItem>

</Tabs>

### Events associated with enableScreenShare

- Participant who share their mobile screen will receive a callback on [`onStreamEnabled()`](/android/api/sdk-reference/participant-class/participant-event-listener-class#onstreamenabled) of the [`Participant`](/android/api/sdk-reference/participant-class/introduction) with `Stream` object.

- While other Participants will receive [`onPresenterChanged()`](/android/api/sdk-reference/meeting-class/meeting-event-listener-class#onpresenterchanged) callback of the [`Meeting`](/android/api/sdk-reference/meeting-class/introduction) class with the participantId as `presenterId` who started the screen share.

### Events associated with disableScreenShare

- Participant who shared their mobile screen will receive a callback on [`onStreamDisabled()`](/android/api/sdk-reference/participant-class/participant-event-listener-class#onstreamdisabled) of the [`Participant`](/android/api/sdk-reference/participant-class/introduction) with `Stream` object.

- While other Participants will receive [`onPresenterChanged()`](/android/api/sdk-reference/meeting-class/meeting-event-listener-class#onpresenterchanged) callback of the [`Meeting`](/android/api/sdk-reference/meeting-class/introduction) class with the `presenterId` as `null` indicating there is no presenter.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
private fun setLocalListeners() {
    meeting!!.localParticipant.addEventListener(object : ParticipantEventListener() {
        //Callback for when the participant starts a stream
        //highlight-start
        override fun onStreamEnabled(stream: Stream) {
           if (stream.kind.equals("share", ignoreCase = true)) {
              Log.d("VideoSDK","Share Stream On: onStreamEnabled $stream");
            }
        }
        //highlight-end

        //Callback for when the participant stops a stream
        //highlight-start
        override fun onStreamDisabled(stream: Stream) {
            if (stream.kind.equals("share", ignoreCase = true)) {
               Log.d("VideoSDK","Share Stream On: onStreamDisabled $stream");
            }
        }
        //highlight-end
    });
}

private val meetingEventListener: MeetingEventListener = object : MeetingEventListener() {
    //Callback for when the presenter changes
    //highlight-start
    override fun onPresenterChanged(participantId: String) {
        if(!TextUtils.isEmpty(participantId))
        {
          Log.d("VideoSDK","$participantId started screen share");
        }else{
          Log.d("VideoSDK","some one stopped screen share");
        }
    }
    //highlight-end
}
```

</TabItem>

<TabItem value="Java">

```js
private void setLocalListeners() {
    meeting.getLocalParticipant().addEventListener(new ParticipantEventListener() {
        //Callback for when the participant starts a stream
        //highlight-start
        @Override
        public void onStreamEnabled(Stream stream) {
            if (stream.getKind().equalsIgnoreCase("share")) {
                Log.d("VideoSDK","Share Stream On: onStreamEnabled" + stream);
            }
        }
        //highlight-end

        //Callback for when the participant stops a stream
        //highlight-start
        @Override
        public void onStreamDisabled(Stream stream) {
            if (stream.getKind().equalsIgnoreCase("share")) {
                Log.d("VideoSDK","Share Stream Off: onStreamDisabled" + stream);
            }
        }
        //highlight-end
    });
}

private final MeetingEventListener meetingEventListener = new MeetingEventListener() {
    //Callback for when the presenter changes
    //highlight-start
    @Override
    public void onPresenterChanged(String participantId) {
      if(participantId != null){
        Log.d("VideoSDK",participantId + "started screen share");
      }else{
        Log.d("VideoSDK","some one stopped screen share");
      }
    }
    //highlight-end
};
```

</TabItem>

</Tabs>

### Rendering Screen Share Stream

- When a local participant shares their screen, the `onStreamEnabled()` function of the `ParticipantEventListener` is triggered, allowing the `Stream` to be added to a `VideoView`.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
private fun setLocalListeners() {
    meeting!!.localParticipant.addEventListener(object : ParticipantEventListener() {
        override fun onStreamEnabled(stream: Stream) {
           if (stream.kind.equals("share", ignoreCase = true)) {
                // display share video
                val videoTrack = stream.track as VideoTrack
                shareView!!.addTrack(videoTrack)
            }
        }
        override fun onStreamDisabled(stream: Stream) {
            if (stream.kind.equals("share", ignoreCase = true)) {
               shareView!!.removeTrack()
            }
        }
    });
}
```

</TabItem>

<TabItem value="Java">

```js
private void setLocalListeners() {
    meeting.getLocalParticipant().addEventListener(new ParticipantEventListener() {
        @Override
        public void onStreamEnabled(Stream stream) {
            if (stream.getKind().equalsIgnoreCase("share")) {
                // display share video
                VideoTrack videoTrack = (VideoTrack) stream.getTrack();
                shareView.addTrack(videoTrack);
            }
        }
        @Override
        public void onStreamDisabled(Stream stream) {
            if (stream.getKind().equalsIgnoreCase("share")) {
                shareView.removeTrack();
            }
        }
    });
}
```

</TabItem>

</Tabs>


- When another participant (excluding the local participant) shares their screen, the `onPresenterChanged()` function in the `MeetingEventListener` is triggered, providing the `participantId` of the screen sharer.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
private val meetingEventListener: MeetingEventListener = object : MeetingEventListener() {
    override fun onPresenterChanged(participantId: String) {
        updatePresenter(participantId)
    }
}

//Getting the stream from the participantId
private fun updatePresenter(participantId: String?) {
    // find participant
    val participant = meeting!!.participants.get(participantId) ?: return

    // find share stream in participant
    var shareStream: Stream? = null
    for (stream: Stream in participant.streams.values) {
        if ((stream.kind == "share")) {
            shareStream = stream
            break
        }
    }
    if (shareStream == null) return

    // display share video
    val videoTrack = shareStream.track as VideoTrack
    shareView!!.addTrack(videoTrack)

    // listen for share stop event
    participant.addEventListener(object : ParticipantEventListener() {
        override fun onStreamDisabled(stream: Stream) {
            if ((stream.kind == "share")) {
                shareView!!.removeTrack()
            }
        }
    })
}
```

</TabItem>

<TabItem value="Java">

```js
private final MeetingEventListener meetingEventListener = new MeetingEventListener() {
    //Triggered when Presenter changes
    @Override
    public void onPresenterChanged(String participantId) {
        updatePresenter(participantId);
    }
};

//Getting the stream from the participantId
private void updatePresenter(String participantId) {
    // find participant
    Participant participant = meeting.getParticipants().get(participantId);
    if (participant == null) return;

    // find share stream in participant
    Stream shareStream = null;
    for (Stream stream: participant.getStreams().values()) {
        if (stream.getKind().equals("share")) {
            shareStream = stream;
            break;
        }
    }
    if (shareStream == null) return;

    // display share video
    VideoTrack videoTrack = (VideoTrack) shareStream.getTrack();
    shareView.addTrack(videoTrack)

    // listen for share stop event
    participant.addEventListener(new ParticipantEventListener() {
        @Override
        public void onStreamDisabled(Stream stream) {
            if (stream.getKind().equals("share")) {
                shareView.removeTrack();
            }
        }
    });
}
```

</TabItem>

</Tabs>

:::info

- Here screenShare stream is displayed using `VideoView`, but you may also use `SurfaceViewRender` for the same.
- For `VideoView`, SDK version should be `0.1.13` or higher.
- To know more about `VideoView`, please visit [here](/android/guide/video-and-audio-calling-api-sdk/render-media/display-video/understand-videoView-component)

:::

### API Reference

The API references for all the methods and events utilised in this guide are provided below.

- [enableScreenShare()](/android/api/sdk-reference/meeting-class/methods#enablescreenshare)
- [disableScreenShare()](/android/api/sdk-reference/meeting-class/methods#disablescreenshare)
- [onStreamEnabled()](/android/api/sdk-reference/participant-class/participant-event-listener-class#onstreamenabled)
- [onStreamDisabled()](/android/api/sdk-reference/participant-class/participant-event-listener-class#onstreamdisabled)
- [onPresenterChanged()](/android/api/sdk-reference/meeting-class/meeting-event-listener-class#onpresenterchanged)


---

---
title: Integrating Android SDK - Video SDK
hide_title: false
hide_table_of_contents: false
description: Create customizable real-time video & audio calling applications with Android SDK with Video SDK add live Video & Audio conferencing to your applications.
sidebar_label: "Integrate Android SDK"
pagination_label: "Integrate Android SDK"
keywords:
  - android sdk
  - video call
  - audio call
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: integrate-sdk
---

Android SDK is a Java-based native SDK. It is compatible with both Java and Kotlin. It makes it extremely simple to integrate video and audio calls into your app.

### Installing Android SDK

#### Step 1: Add the repositories into your project

You can install our Android SDK by using Maven Central or [Jitpack](https://central.sonatype.com/artifact/live.videosdk/rtc-android-sdk/0.1.14) package repositories.

Add the repository to `settings.gradle` file in your project.

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Maven Central"
groupId={"android-repositories"}
values={[{label: 'Maven Central', value: 'Maven Central'},{label: 'Jitpack', value: 'Jitpack'},]}>

<TabItem value="Maven Central">

```js title="settings.gradle"
dependencyResolutionManagement{
  repositories {
    // ...
    google()
    mavenCentral()
    maven { url "https://maven.aliyun.com/repository/jcenter" }
  }
}
```

</TabItem>

<TabItem value="Jitpack">

```js title="settings.gradle"
dependencyResolutionManagement{
  repositories {
    // ...
    google()
    maven { url 'https://jitpack.io' }
    mavenCentral()
    maven { url "https://maven.aliyun.com/repository/jcenter" }
  }
}
```

</TabItem>

</Tabs>

:::note
You can use imports with Maven Central after rtc-android-sdk version `0.1.12`.

Whether on Maven or Jitpack, the same version numbers always refer to the same SDK.
:::

#### Step 2: Add the dependency in `app/build.gradle`

```js title="app/build.gradle"
dependencies {
		implementation 'live.videosdk:rtc-android-sdk:0.1.38'
		// other app dependencies
}
```


:::important

- Android SDK compatible with armeabi-v7a, arm64-v8a, x86_64 architectures. If you want to run the application in an emulator, choose ABI x86_64 when creating a device.

:::


---

---
sidebar_label: Known Issues
pagination_label: Known Issues
---

# Known Issues - Android

This page will let you updated with Android SDK known issues with better solution.

## Issue : 1

```
Missing Class kotlin.jvm.internal.SourceDebugExtension (referenced from: io.github.crow_misia.mediasoup.Consumer and 8 other contexts)
```

### Solution

To resolve the issue related to the missing class `kotlin.jvm.internal.SourceDebugExtension` when building an APK with ProGuard, you can follow these steps:

#### Step 1: Update Kotlin Version (Optional)

If you are using Kotlin version 1.7.20, consider upgrading it to version 1.8.0. This update may resolve the error you're facing. Check if your project is compatible with Kotlin 1.8.0 and update the Kotlin version in your project configuration accordingly.

#### Step 2: Modify proguard-rules.pro

Open the proguard-rules.pro file in your project and add the following rule:

```java
-dontwarn kotlin.jvm.internal.SourceDebugExtension
```

This rule tells ProGuard to suppress warnings related to the missing class "kotlin.jvm.internal.SourceDebugExtension". By adding this rule, the build process will no longer show the error associated with this class.


---

---
title: Custom Template
sidebar_position: 1
sidebar_label: Custom Template
hide_table_of_contents: false
---

import CustomTemplate from '../../../../mdx/\_custom-template.mdx';

<CustomTemplate title="Custom Template With LiveStreaming"/>


---

---
title: Interactive Livestream - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: Interactive Livestream features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Interactive Livestream (HLS)
pagination_label: Interactive Livestream (HLS)
keywords:
  - Start HLS meeting
  - Stop HLS meeting
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: interactive-livestream
---

# Interactive Livestream (HLS) - Android

Interactive live streaming (HLS) refers to a type of live streaming where viewers can actively engage with the content being streamed and with other viewers in real-time.

In an interactive live stream (HLS), viewers can take part in a variety of activities like live polling, Q&A sessions, and even sending virtual gifts to the content creator or each other.

<center>

<img src='https://cdn.videosdk.live/website-resources/docs-resources/mobile_hls.png' />

</center>

VideoSDK also allows you to configure the interactive livestream layouts in numerous ways like by simply setting different prebuilt layouts in the configuration or by providing your own custom template to do the livestream according to your layout choice.

This guide will provide an overview of how to implement start and stop Interactive live streaming (HLS).

:::important

To initiate automatic Interactive live streaming (HLS) at the beginning of a `session`, simply provide the `autoStartConfig` feature `hls` during `room` creation. For more information on configuring the `autoStartConfig`, please refer to the provided documentation **[<u>here</u>](/api-reference/realtime-communication/create-room#autoStartConfig)**.

:::

### `startHls()`

`startHls()` can be used to start a interactive livestream of the meeting which can be accessed from the `Meeting` class. This method accepts two parameter:

- `config`: This parameter will define how the interactive livestream layout should look like.

- `transcription`: This parameter lets you start post transcription for the Livestreaming.

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
val config = JSONObject()

//highlight-next-line
// Layout Configuration
val layout = JSONObject()
JsonUtils.jsonPut(layout, "type", "GRID") // "SPOTLIGHT" | "SIDEBAR",  Default : "GRID"
JsonUtils.jsonPut(layout, "priority", "SPEAKER") // "PIN", Default : "SPEAKER"
JsonUtils.jsonPut(layout, "gridSize", 4) // MAX : 25
JsonUtils.jsonPut(config, "layout", layout)

//highlight-next-line
// Theme of interactive livestream layout
JsonUtils.jsonPut(config, "theme", "DARK") //  "LIGHT" | "DEFAULT"

//highlight-next-line
// `mode` is used to either interactive livestream video & audio both or only audio.
JsonUtils.jsonPut(config, "mode", "video-and-audio") // "audio", Default : "video-and-audio"

//highlight-next-line
// Quality of interactive livestream and is only applicable to `video-and-audio` type mode.
JsonUtils.jsonPut(config, "quality", "high") // "low" | "med",  Default : "med"

//highlight-start
// This mode refers to orientation of interactive livestream.
// landscape : Start interactive livestream of the meeting in horizontally
// portrait : Start interactive livestream of the meeting in vertically (Best for mobile view)
//highlight-end
JsonUtils.jsonPut(config, "orientation", "portrait") // "landscape",  Default : "landscape"

//highlight-next-line
// Post Transcription Configuration
val prompt = "Write summary in sections like Title, Agenda, Speakers, Action Items, Outlines, Notes and Summary"
val summaryConfig = SummaryConfig(true, prompt)
val modelId = "raman_v1"
val transcription = PostTranscriptionConfig(true, summaryConfig, modelId)

meeting.startHls(config, transcription)
```

</TabItem>

<TabItem value="Java">

```js
JSONObject config = new JSONObject();

//highlight-next-line
// Layout Configuration
JSONObject layout = new JSONObject();
JsonUtils.jsonPut(layout, "type", "GRID"); // "SPOTLIGHT" | "SIDEBAR",  Default : "GRID"
JsonUtils.jsonPut(layout, "priority", "SPEAKER");  // "PIN", Default : "SPEAKER"
JsonUtils.jsonPut(layout, "gridSize", 4); // MAX : 25
JsonUtils.jsonPut(config, "layout", layout);

//highlight-next-line
// Theme of interactive livestream layout
JsonUtils.jsonPut(config, "theme", "DARK"); //  "LIGHT" | "DEFAULT"

//highlight-next-line
// `mode` is used to either interactive livestream video & audio both or only audio.
JsonUtils.jsonPut(config, "mode", "video-and-audio"); // "audio", Default : "video-and-audio"

//highlight-next-line
// Quality of interactive livestream and is only applicable to `video-and-audio` type mode.
JsonUtils.jsonPut(config, "quality", "high"); // "low" | "med",  Default : "med"

//highlight-start
// This mode refers to orientation of interactive livestream.
// landscape : Start interactive livestream of the meeting in horizontally
// portrait : Start interactive livestream of the meeting in vertically (Best for mobile view)
//highlight-end
JsonUtils.jsonPut(config, "orientation", "portrait"); // "landscape",  Default : "landscape"

//highlight-next-line
// Post Transcription Configuration
String prompt = "Write summary in sections like Title, Agenda, Speakers, Action Items, Outlines, Notes and Summary";
SummaryConfig summaryConfig = new SummaryConfig(true, prompt);
String modelId = "raman_v1";
PostTranscriptionConfig transcription = new PostTranscriptionConfig(true, summaryConfig, modelId);

meeting.startHls(config, transcription);
```

</TabItem>

</Tabs>

### `stopHls()`

- `stopHls()` is used to stop interactive livestream of the meeting which can be accessed from the `Meeting` class.

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
// keep track of hls
val hls = false

findViewById<View>(R.id.btnHls).setOnClickListener { view: View? ->
  if (!hls) {
    //highlight-start
    val config = JSONObject()
    val layout = JSONObject()
    JsonUtils.jsonPut(layout, "type", "GRID")
    JsonUtils.jsonPut(layout, "priority", "SPEAKER")
    JsonUtils.jsonPut(layout, "gridSize", 4)
    JsonUtils.jsonPut(config, "layout", layout)
    JsonUtils.jsonPut(config, "theme", "DARK")
    JsonUtils.jsonPut(config, "mode", "video-and-audio")
    JsonUtils.jsonPut(config, "quality", "high")
    JsonUtils.jsonPut(config, "orientation", "portrait")
    //highlight-end

    //highlight-next-line
    // Post Transcription Configuration
    val prompt = "Write summary in sections like Title, Agenda, Speakers, Action Items, Outlines, Notes and Summary"
    val summaryConfig = SummaryConfig(true, prompt)
    val modelId = "raman_v1"
    val transcription = PostTranscriptionConfig(true, summaryConfig, modelId)

    // Start Hls
    //highlight-next-line
    meeting!!.startHls(config)
  } else {
    // Stop Hls
    //highlight-next-line
    meeting!!.stopHls()
  }
}
```

</TabItem>

<TabItem value="Java">

```js
// keep track of hls
boolean hls = false;

findViewById(R.id.btnHls).setOnClickListener(view -> {
  if (!hls) {
    //highlight-start
    JSONObject config = new JSONObject();
    JSONObject layout = new JSONObject();
    JsonUtils.jsonPut(layout, "type", "GRID");
    JsonUtils.jsonPut(layout, "priority", "SPEAKER");
    JsonUtils.jsonPut(layout, "gridSize", 4);
    JsonUtils.jsonPut(config, "layout", layout);
    JsonUtils.jsonPut(config, "theme", "DARK");
    JsonUtils.jsonPut(config, "mode", "video-and-audio");
    JsonUtils.jsonPut(config, "quality", "high");
    JsonUtils.jsonPut(config, "orientation", "portrait");
    //highlight-end

    //highlight-next-line
    // Post Transcription Configuration
    String prompt = "Write summary in sections like Title, Agenda, Speakers, Action Items, Outlines, Notes and Summary";
    SummaryConfig summaryConfig = new SummaryConfig(true, prompt);
    String modelId = "raman_v1";
    PostTranscriptionConfig transcription = new PostTranscriptionConfig(true, summaryConfig, modelId);

    // Start Hls
    //highlight-next-line
    meeting.startHls(config);
  } else {
    // Stop Hls
    //highlight-next-line
    meeting.stopHls();
  }
});
```

</TabItem>

</Tabs>

:::tip
If you want to learn more about the Interactive Livestream and how you can implement it in your own platform, you can checkout this [guide](/android/guide/interactive-live-streaming/integrate-hls/overview).
:::

### Event associated with HLS

- **onHlsStateChanged** - Whenever meeting HLS state changes, then `onHlsStateChanged` event will trigger.

- You can get the `playbackHlsUrl` and `livestreamUrl` of the HLS to play it on the Viewer side when the state changes to `HLS_PLAYABLE`.
  - `playbackHlsUrl` - Live HLS with playback support
  - `livestreamUrl` - Live HLS without playback support

:::note
`downstreamUrl` is now depecated. Use `playbackHlsUrl` or `livestreamUrl` in place of `downstreamUrl`
:::

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
private val meetingEventListener: MeetingEventListener = object : MeetingEventListener() {
  override fun onHlsStateChanged(HlsState: JSONObject) {
    when (HlsState.getString("status")) {
        "HLS_STARTING" -> Log.d("onHlsStateChanged", "Meeting hls is starting")
        "HLS_STARTED" -> Log.d("onHlsStateChanged", "Meeting hls is started")
        "HLS_PLAYABLE" -> {
            Log.d("onHlsStateChanged", "Meeting hls is playable now")
            //highlight-start
             // on hls playable you will receive playbackHlsUrl and livestreamUrl
            val playbackHlsUrl = HlsState.getString("playbackHlsUrl")
            val livestreamUrl = HlsState.getString("livestreamUrl")
            //highlight-end
        }
        "HLS_STOPPING" -> Log.d("onHlsStateChanged", "Meeting hls is stopping")
        "HLS_STOPPED" -> Log.d("onHlsStateChanged", "Meeting hls is stopped")
    }
  }
}

override fun onCreate(savedInstanceState: Bundle?) {
  //...

  // add listener to meeting
  //highlight-next-line
  meeting!!.addEventListener(meetingEventListener)
}
```

</TabItem>

<TabItem value="Java">

```js
private final MeetingEventListener meetingEventListener = new MeetingEventListener() {
  @Override
  public void onHlsStateChanged(JSONObject HlsState) {
      switch (HlsState.getString("status")) {
          case "HLS_STARTING":
              Log.d("onHlsStateChanged", "Meeting hls is starting");
              break;
          case "HLS_STARTED":
              Log.d("onHlsStateChanged", "Meeting hls is started");
              break;
          case "HLS_PLAYABLE":
              Log.d("onHlsStateChanged", "Meeting hls is playable now");
              //highlight-start
              // on hls started you will receive playbackHlsUrl and livestreamUrl
              String playbackHlsUrl = HlsState.getString("playbackHlsUrl");
              String livestreamUrl = HlsState.getString("livestreamUrl");
              //highlight-end
              break;
          case "HLS_STOPPING":
              Log.d("onHlsStateChanged", "Meeting hls is stopping");
              break;
          case "HLS_STOPPED":
              Log.d("onHlsStateChanged", "Meeting hls is stopped");
              break;
      }
  }
}

@Override
protected void onCreate(Bundle savedInstanceState) {
  //...

  // add listener to meeting
  //highlight-next-line
  meeting.addEventListener(meetingEventListener);
}
```

</TabItem>

</Tabs>

### API Reference

The API references for all the methods utilised in this guide are provided below.

- [startHls()](/android/api/sdk-reference/meeting-class/methods#starthls)
- [stopHls()](/android/api/sdk-reference/meeting-class/methods#stophls)
- [onHlsStateChanged](/android/api/sdk-reference/meeting-class/meeting-event-listener-class#onhlsstatechanged)
- [autoStartConfig](/api-reference/realtime-communication/create-room#autoStartConfig)


---

---
title: RTMP Livestream - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: RTMP Livestream features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: RTMP Livestream
pagination_label: RTMP Livestream
keywords:
  - Start Livestream meeting
  - Stop Livestream meeting
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: rtmp-livestream
---

# RTMP Livestream - Android

RTMP is a popular protocol for live streaming video content from a VideoSDK to platforms such as YouTube, Twitch, Facebook, and others.

By providing the platform-specific stream key and stream URL, the VideoSDK can connect to the platform's RTMP server and transmit the live video stream.

VideoSDK allows you to livestream your meeting to platform which support RTMP ingestion just by providing the platform-specific stream key and stream URL, we can connect to the platform's RTMP server and transmit the live video stream.

VideoSDK also allows you to configure the livestream layouts in numerous ways like by simply setting different prebuilt layouts in the configuration or by providing your own custom template to do the livestream according to your layout choice.

This guide will provide an overview of how to implement start and stop RTMP Livestreaming.

### `startLivestream()`

`startLivestream()` can be used to start a RTMP livestream of the meeting which can be accessed from the `Meeting` class. This method accepts two parameters:

- `1. outputs`: This parameter accepts a list of `LivestreamOutput` objects which contains the RTMP `url` and `streamKey` of the platforms you want to start the livestream.

- `2. config`: This parameter will define how the livestream layout should look like. You can pass `null` for default layout.

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
val config = JSONObject()

//highlight-next-line
// Layout Configuration
val layout = JSONObject()
JsonUtils.jsonPut(layout, "type", "GRID") // "SPOTLIGHT" | "SIDEBAR",  Default : "GRID"
JsonUtils.jsonPut(layout, "priority", "SPEAKER") // "PIN", Default : "SPEAKER"
JsonUtils.jsonPut(layout, "gridSize", 4) // MAX : 4
JsonUtils.jsonPut(config, "layout", layout)

//highlight-next-line
// Theme of livestream layout
JsonUtils.jsonPut(config, "theme", "DARK") //  "LIGHT" | "DEFAULT"

val outputs: MutableList<LivestreamOutput> = ArrayList()
outputs.add(LivestreamOutput(RTMP_URL, RTMP_STREAM_KEY))

meeting!!.startLivestream(outputs,config)
```

</TabItem>

<TabItem value="Java">

```js
JSONObject config = new JSONObject();

//highlight-next-line
// Layout Configuration
JSONObject layout = new JSONObject();
JsonUtils.jsonPut(layout, "type", "GRID"); // "SPOTLIGHT" | "SIDEBAR",  Default : "GRID"
JsonUtils.jsonPut(layout, "priority", "SPEAKER");  // "PIN", Default : "SPEAKER"
JsonUtils.jsonPut(layout, "gridSize", 4); // MAX : 4
JsonUtils.jsonPut(config, "layout", layout);

//highlight-next-line
// Theme of livestream layout
JsonUtils.jsonPut(config, "theme", "DARK"); //  "LIGHT" | "DEFAULT"

List<LivestreamOutput> outputs = new ArrayList<>();
outputs.add(new LivestreamOutput(RTMP_URL, RTMP_STREAM_KEY));

meeting.startLivestream(outputs,config);
```

</TabItem>

</Tabs>

### `stopLivestream()`

- `stopLivestream()` is used to stop the meeting livestream which can be accessed from the `Meeting` class.

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
// keep track of livestream status
val liveStream = false

findViewById<View>(R.id.btnLiveStream).setOnClickListener { view: View? ->
  if (!liveStream) {
    //highlight-start
    val config = JSONObject()
    val layout = JSONObject()
    JsonUtils.jsonPut(layout, "type", "GRID")
    JsonUtils.jsonPut(layout, "priority", "SPEAKER")
    JsonUtils.jsonPut(layout, "gridSize", 4)
    JsonUtils.jsonPut(config, "layout", layout)
    JsonUtils.jsonPut(config, "theme", "DARK")
    //highlight-end

    val outputs: MutableList<LivestreamOutput> = ArrayList()
    //highlight-next-line
    outputs.add(LivestreamOutput(RTMP_URL, RTMP_STREAM_KEY))

    // Start LiveStream
    //highlight-next-line
    meeting!!.startLivestream(outputs,config)
  } else {
    // Stop LiveStream
    //highlight-next-line
    meeting!!.stopLivestream()
  }
}
```

</TabItem>

<TabItem value="Java">

```js
// keep track of livestream status
boolean liveStream = false;

findViewById(R.id.btnLiveStream).setOnClickListener(view -> {
  if (!liveStream) {
    //highlight-start
    JSONObject config = new JSONObject();
    JSONObject layout = new JSONObject();
    JsonUtils.jsonPut(layout, "type", "GRID");
    JsonUtils.jsonPut(layout, "priority", "SPEAKER");
    JsonUtils.jsonPut(layout, "gridSize", 4);
    JsonUtils.jsonPut(config, "layout", layout);
    JsonUtils.jsonPut(config, "theme", "DARK");
    //highlight-end

    List<LivestreamOutput> outputs = new ArrayList<>();
    //highlight-next-line
    outputs.add(new LivestreamOutput(RTMP_URL, RTMP_STREAM_KEY));

    // Start LiveStream
    //highlight-next-line
    meeting.startLivestream(outputs,config);
  } else {
    // Stop LiveStream
    //highlight-next-line
    meeting.stopLivestream();
  }
});
```

</TabItem>

</Tabs>

### Event associated with Livestream

- **onLivestreamStateChanged** - Whenever meeting livestream state changes, then `onLivestreamStateChanged` event will trigger.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
private val meetingEventListener: MeetingEventListener = object : MeetingEventListener() {
  override fun onLivestreamStateChanged(livestreamState: String?) {
    when (livestreamState) {
      "LIVESTREAM_STARTING" -> Log.d( "LivestreamStateChanged",
          "Meeting livestream is starting"
      )
      "LIVESTREAM_STARTED" -> Log.d( "LivestreamStateChanged",
          "Meeting livestream is started"
      )
      "LIVESTREAM_STOPPING" -> Log.d("LivestreamStateChanged",
          "Meeting livestream is stopping"
      )
      "LIVESTREAM_STOPPED" -> Log.d("LivestreamStateChanged",
          "Meeting livestream is stopped"
      )
    }
  }
}

override fun onCreate(savedInstanceState: Bundle?) {
  //...

  // add listener to meeting
  //highlight-next-line
  meeting!!.addEventListener(meetingEventListener)
}
```

</TabItem>

<TabItem value="Java">

```js
private final MeetingEventListener meetingEventListener = new MeetingEventListener() {
  @Override
  public void onLivestreamStateChanged(String livestreamState) {
    switch (livestreamState) {
      case "LIVESTREAM_STARTING":
          Log.d("LivestreamStateChanged", "Meeting livestream is starting");
          break;
      case "LIVESTREAM_STARTED":
          Log.d("LivestreamStateChanged", "Meeting livestream is started");
          break;
      case "LIVESTREAM_STOPPING":
          Log.d("LivestreamStateChanged", "Meeting livestream is stopping");
          break;
      case "LIVESTREAM_STOPPED":
          Log.d("LivestreamStateChanged", "Meeting livestream is stopped");
          break;
    }
  }
}

@Override
protected void onCreate(Bundle savedInstanceState) {
  //...

  // add listener to meeting
  //highlight-next-line
  meeting.addEventListener(meetingEventListener);
}
```

</TabItem>

</Tabs>

### API Reference

The API references for all the methods utilised in this guide are provided below.

- [startLivestream()](/android/api/sdk-reference/meeting-class/methods#startlivestream)
- [stopLivestream()](/android/api/sdk-reference/meeting-class/methods#stoplivestream)
- [onLivestreamStateChanged](/android/api/sdk-reference/meeting-class/meeting-event-listener-class#onlivestreamstatechanged)


---

---
title: Quick Start With Http Live Streaming
hide_title: true
hide_table_of_contents: false
description: Video SDK enables the opportunity to integrate native IOS, Android & Web SDKs to add live video & audio conferencing to your applications.
sidebar_label: Start With Http Live Streaming(HLS)
pagination_label: Quick Start With Interactive Live Streaming
keywords:
  - audio calling
  - video calling
  - real-time communication
  - collaboration
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: quick-start-ILS
---

# Quick Start for Http Live Streaming(HLS) in Android

<ReactPlayer controls url="https://www.youtube.com/watch?v=KdiXs9w7qVE" height="500px" width={"100%"} />

VideoSDK empowers you to seamlessly integrate the Http Live Streaming(HLS) feature into your React Native application within minutes.

In this quickstart, you'll explore this feature of VideoSDK. Follow the step-by-step guide to integrate it within your application.

:::info

For low-latency interactive live streaming (under 100ms), follow this [documentation](./quick-start-android-ils.md).
:::

## Prerequisites

Before proceeding, ensure that your development environment meets the following requirements:

- Java Development Kit.
- Android Studio 3.0 or later.
- Android SDK API Level 21 or higher.
- A mobile device that runs Android 5.0 or later.

:::important

One should have a VideoSDK account to generate token.
Visit VideoSDK **[dashboard](https://app.videosdk.live/api-keys)** to generate token

:::

## Getting Started with the Code!

Follow the steps to create the environment necessary to add video calls into your app. Also you can find the code sample for [quickstart here](https://github.com/videosdk-live/quickstart/tree/main/android-hls).

import CautionMessage from '@site/src/theme/CautionMessage';

<CautionMessage sdk="Android SDK" version="v0.2.0" />

### Create new Android Project

For a new project in **Android Studio**, create a **Phone and Tablet** Android project with an **Empty Activity**.

![VideoSDK Android Quick Start New Project](/img/quick-start/android_newProject.png)

:::caution
After creating the project, Android Studio automatically starts gradle sync. Ensure that the sync succeeds before you continue.
:::

### Integrate Video SDK

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Maven Central"
groupId={"android-repositories"}
values={[{label: 'Maven Central', value: 'Maven Central'},{label: 'Jitpack', value: 'Jitpack'},]}>

<TabItem value="Maven Central">

```js title="settings.gradle"
dependencyResolutionManagement{
  repositories {
    // ...
    google()
    mavenCentral()
    maven { url "https://maven.aliyun.com/repository/jcenter" }
  }
}
```

</TabItem>

<TabItem value="Jitpack">

```js title="settings.gradle"
dependencyResolutionManagement{
  repositories {
    // ...
    google()
    maven { url 'https://jitpack.io' }
    mavenCentral()
    maven { url "https://maven.aliyun.com/repository/jcenter" }
  }
}
```

</TabItem>

</Tabs>

:::note

You can use imports with Maven Central after rtc-android-sdk version `0.1.12`.

Whether on Maven or Jitpack, the same version numbers always refer to the same SDK.

:::

- Add the following dependency in your app's `app/build.gradle`.

```js title="app/build.gradle"
dependencies {
  implementation 'live.videosdk:rtc-android-sdk:0.1.38'

  // library to perform Network call to generate a meeting id
  implementation 'com.amitshekhar.android:android-networking:1.0.2'

  // other app dependencies
  }
```

:::important

Android SDK compatible with armeabi-v7a, arm64-v8a, x86_64 architectures. If you want to run the application in an emulator, choose ABI x86_64 when creating a device.

:::

### Add permissions into your project

- In `/app/Manifests/AndroidManifest.xml`, add the following permissions after `</application>`.

```xml title="AndroidManifest.xml"
<uses-permission android:name="android.permission.RECORD_AUDIO" />
<uses-permission android:name="android.permission.MODIFY_AUDIO_SETTINGS" />
<uses-permission android:name="android.permission.INTERNET" />
<uses-permission android:name="android.permission.CAMERA" />
```

:::note

If your project has set `android.useAndroidX=true`, then set `android.enableJetifier=true` in the `gradle.properties` file to migrate your project to AndroidX and avoid duplicate class conflict.

:::

### Structure of the project

Your project structure should look like this.

```jsx title="Project Structure"
   app
   ├── java
   │    ├── packagename
   │         ├── JoinActivity
   │         ├── MeetingActivity
   │         ├── SpeakerAdapter
   │         ├── SpeakerFragment
   |         ├── ViewerFragment
   ├── res
   │    ├── layout
   │    │    ├── activity_join.xml
   │    │    ├── activity_meeting.xml
   |    |    ├── fragment_speaker.xml
   |    |    ├── fragment_viewer.xml
   │    │    ├── item_remote_peer.xml
```

:::note

You have to set JoinActivity as Launcher activity.

:::

### App Architecture

<center>

<img src='https://cdn.videosdk.live/website-resources/docs-resources/android_ils_quickstart_app_structure.png' />

</center>

### Step 1: Creating Joining Screen

Create a new Activity named `JoinActivity`.

#### Creating UI

The Joining screen will include :

1. **Create Button** - This button will create a new meeting for you.
2. **TextField for Meeting Id** - This text field will contain the meeting Id you want to join.
3. **Join as Host Button** - This button will join the meeting as **host** with `meetingId` you provided.
4. **Join as Viewer Button** - This button will join the meeting as **viewer** with `meetingId` you provided.

In `/app/res/layout/activity_join.xml` file, replace the content with the following.

```xml title="activity_join.xml"
<?xml version="1.0" encoding="utf-8"?>

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:id="@+id/createorjoinlayout"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:background="@color/black"
    android:gravity="center"
    android:orientation="vertical">

    <Button
        android:id="@+id/btnCreateMeeting"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Create Meeting"
        android:textAllCaps="false" />

    <TextView
        android:id="@+id/tvText"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:paddingVertical="5sp"
        android:text="OR"
        android:textColor="@color/white"
        android:textSize="20sp" />

    <EditText
        android:id="@+id/etMeetingId"
        android:theme="@android:style/Theme.Holo"
        android:layout_width="250dp"
        android:layout_height="wrap_content"
        android:hint="Enter Meeting Id"
        android:textColor="@color/white"
        android:textColorHint="@color/white" />

    <Button
        android:id="@+id/btnJoinHostMeeting"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_marginTop="8sp"
        android:text="Join as Host"
        android:textAllCaps="false" />

    <Button
        android:id="@+id/btnJoinViewerMeeting"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Join as Viewer"
        android:textAllCaps="false" />

</LinearLayout>
```

#### Integration of Create Meeting API

1. Create field `sampleToken` in `JoinActivity` which will hold the generated token from the [VideoSDK dashboard](https://app.videosdk.live/api-keys). This token will use in VideoSDK config as well as in generating meetingId.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js title="JoinActivity.kt"
class JoinActivity : AppCompatActivity() {

  //highlight-next-line
  //Replace with the token you generated from the VideoSDK Dashboard
  private var sampleToken = ""

  override fun onCreate(savedInstanceState: Bundle?) {
    //...
  }
}
```

</TabItem>

<TabItem value="Java">

```java title="JoinActivity.java"
public class JoinActivity extends AppCompatActivity {

  //highlight-next-line
  //Replace with the token you generated from the VideoSDK Dashboard
  private String sampleToken ="";

  @Override
  protected void onCreate(Bundle savedInstanceState) {
    //...
  }
}
```

</TabItem>

</Tabs>

2. On **Join Button as Host** `onClick` events, we will naviagte to `MeetingActivity` with token, meetingId and mode as `SEND_AND_RECV`.

3. On **Join Button as Viewer** `onClick` events, we will naviagte to `MeetingActivity` with token, meetingId and mode as `Viewer`.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js title="JoinActivity.kt"
class JoinActivity : AppCompatActivity() {

   //Replace with the token you generated from the VideoSDK Dashboard
   private var sampleToken = "";

   override fun onCreate(savedInstanceState: Bundle?) {
      super.onCreate(savedInstanceState)
      setContentView(R.layout.activity_join)

      val btnCreate = findViewById<Button>(R.id.btnCreateMeeting)
      val btnJoinHost = findViewById<Button>(R.id.btnJoinHostMeeting)
      val btnJoinViewer = findViewById<Button>(R.id.btnJoinViewerMeeting)
      val etMeetingId = findViewById<EditText>(R.id.etMeetingId)

      //highlight-next-line
      // create meeting and join as Host
      btnCreate.setOnClickListener {
          createMeeting(
              sampleToken
          )
      }

      //highlight-next-line
      // Join as Host
      btnJoinHost.setOnClickListener {
          val intent = Intent(this@JoinActivity, MeetingActivity::class.java)
          intent.putExtra("token", sampleToken)
          intent.putExtra("meetingId", etMeetingId.text.toString().trim { it <= ' ' })
          //highlight-next-line
          intent.putExtra("mode", "SEND_AND_RECV")
          startActivity(intent)
      }

      //highlight-next-line
      // Join as Viewer
      btnJoinViewer.setOnClickListener {
          val intent = Intent(this@JoinActivity, MeetingActivity::class.java)
          intent.putExtra("token", sampleToken)
          intent.putExtra("meetingId", etMeetingId.text.toString().trim { it <= ' ' })
          //highlight-next-line
          intent.putExtra("mode", "SIGNALLING_ONLY")
          startActivity(intent)
      }
    }

    private fun createMeeting(token: String) {
      // we will explore this method in the next step
    }
}
```

</TabItem>

<TabItem value="Java">

```java title="JoinActivity.java"
public class JoinActivity extends AppCompatActivity {

  //Replace with the token you generated from the VideoSDK Dashboard
  private String sampleToken ="";

  @Override
  protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_join);

    final Button btnCreate = findViewById(R.id.btnCreateMeeting);
    final Button btnJoinHost = findViewById(R.id.btnJoinHostMeeting);
    final Button btnJoinViewer = findViewById(R.id.btnJoinViewerMeeting);
    final EditText etMeetingId = findViewById(R.id.etMeetingId);

    //highlight-next-line
    // create meeting and join as Host
    btnCreate.setOnClickListener(v -> createMeeting(sampleToken));

    //highlight-next-line
    // Join as Host
    btnJoinHost.setOnClickListener(v -> {
        Intent intent = new Intent(JoinActivity.this, MeetingActivity.class);
        intent.putExtra("token", sampleToken);
        intent.putExtra("meetingId", etMeetingId.getText().toString().trim());
        //highlight-next-line
        intent.putExtra("mode", "SEND_AND_RECV");
        startActivity(intent);
    });

    //highlight-next-line
    // Join as Viewer
    btnJoinViewer.setOnClickListener(v -> {
        Intent intent = new Intent(JoinActivity.this, MeetingActivity.class);
        intent.putExtra("token", sampleToken);
        intent.putExtra("meetingId", etMeetingId.getText().toString().trim());
        //highlight-next-line
        intent.putExtra("mode", "SIGNALLING_ONLY");
        startActivity(intent);
    });
  }

  private void createMeeting(String token) {
    // we will explore this method in the next step
  }
}
```

</TabItem>

</Tabs>

4. For **Create Button**, under `createMeeting` method we will generate meetingId by calling API and navigate to `MeetingActivity` with token, generated meetingId and mode as `SEND_AND_RECV`.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js title="JoinActivity.kt"
class JoinActivity : AppCompatActivity() {
  //...onCreate
 private fun createMeeting(token: String) {
  // we will make an API call to VideoSDK Server to get a roomId
  AndroidNetworking.post("https://api.videosdk.live/v2/rooms")
      .addHeaders("Authorization", token) //we will pass the token in the Headers
      .build()
      .getAsJSONObject(object : JSONObjectRequestListener {
          override fun onResponse(response: JSONObject) {
            try {
              // response will contain `roomId`
              val meetingId = response.getString("roomId")

              // starting the MeetingActivity with received roomId and our sampleToken
              val intent = Intent(this@JoinActivity, MeetingActivity::class.java)
              intent.putExtra("token", sampleToken)
              intent.putExtra("meetingId", meetingId)
              //highlight-next-line
              intent.putExtra("mode", "SEND_AND_RECV")
              startActivity(intent)
            } catch (e: JSONException) {
                e.printStackTrace()
            }
          }

          override fun onError(anError: ANError) {
            anError.printStackTrace()
            Toast.makeText(this@JoinActivity, anError.message, Toast.LENGTH_SHORT)
                .show()
          }
      })
  }
}
```

</TabItem>

<TabItem value="Java">

```java title="JoinActivity.java"
public class JoinActivity extends AppCompatActivity {
  //...onCreate

  private void createMeeting(String token) {
    // we will make an API call to VideoSDK Server to get a roomId
    AndroidNetworking.post("https://api.videosdk.live/v2/rooms")
          .addHeaders("Authorization", token) //we will pass the token in the Headers
          .build()
          .getAsJSONObject(new JSONObjectRequestListener() {
              @Override
              public void onResponse(JSONObject response) {
                try {
                  // response will contain `roomId`
                  final String meetingId = response.getString("roomId");

                  // starting the MeetingActivity with received roomId and our sampleToken
                  Intent intent = new Intent(JoinActivity.this, MeetingActivity.class);
                  intent.putExtra("token", sampleToken);
                  intent.putExtra("meetingId", meetingId);
                  //highlight-next-line
                  intent.putExtra("mode", "SEND_AND_RECV");
                  startActivity(intent);
                } catch (JSONException e) {
                    e.printStackTrace();
                }
              }

              @Override
              public void onError(ANError anError) {
                anError.printStackTrace();
                Toast.makeText(JoinActivity.this, anError.getMessage(), Toast.LENGTH_SHORT).show();
              }
          });
  }
}
```

</TabItem>

</Tabs>

:::note

Don't confuse with Room and Meeting keyword, both are same thing 😃

:::

5. Our App is completely based on audio and video communicatation, that's why we need to ask for runtime permissions `RECORD_AUDIO` and `CAMERA`. So, we will implement permission logic on `JoinActivity`.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js title="JoinActivity.kt"
class JoinActivity : AppCompatActivity() {
  companion object {
    private const val PERMISSION_REQ_ID = 22
    private val REQUESTED_PERMISSIONS = arrayOf(
        Manifest.permission.RECORD_AUDIO,
        Manifest.permission.CAMERA
    )
  }

  private fun checkSelfPermission(permission: String, requestCode: Int) {
    if (ContextCompat.checkSelfPermission(this, permission) !=
        PackageManager.PERMISSION_GRANTED
    ) {
        ActivityCompat.requestPermissions(this, REQUESTED_PERMISSIONS, requestCode)
    }
  }

  override fun onCreate(savedInstanceState: Bundle?) {
    //... button listeneres
    //highlight-start
    checkSelfPermission(REQUESTED_PERMISSIONS[0], PERMISSION_REQ_ID)
    checkSelfPermission(REQUESTED_PERMISSIONS[1], PERMISSION_REQ_ID)
    //highlight-end
  }
}
```

</TabItem>

<TabItem value="Java">

```java title="JoinActivity.java"
public class JoinActivity extends AppCompatActivity {
  private static final int PERMISSION_REQ_ID = 22;

  private static final String[] REQUESTED_PERMISSIONS = {
    Manifest.permission.RECORD_AUDIO,
    Manifest.permission.CAMERA
  };

  private void checkSelfPermission(String permission, int requestCode) {
    if (ContextCompat.checkSelfPermission(this, permission) !=
            PackageManager.PERMISSION_GRANTED) {
      ActivityCompat.requestPermissions(this, REQUESTED_PERMISSIONS, requestCode);
    }
  }

  @Override
  protected void onCreate(Bundle savedInstanceState) {
    //... button listeneres
   //highlight-start
   checkSelfPermission(REQUESTED_PERMISSIONS[0], PERMISSION_REQ_ID);
   checkSelfPermission(REQUESTED_PERMISSIONS[1], PERMISSION_REQ_ID);
   //highlight-end
  }
}
```

</TabItem>

</Tabs>

#### Output

<center>

<img style={{height: '450px'}} src="https://cdn.videosdk.live/website-resources/docs-resources/android_ils_quickstart_join_screen.jpg" />

</center>

### Step 2: Creating Meeting Screen

Create a new Activity named `MeetingActivity`.

#### Creating the UI for Meeting Screen

In `/app/res/layout/activity_meeting.xml` file, replace the content with the following.

```xml title="activty_meeting.xml"
<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:id="@+id/mainLayout"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:background="@color/black"
    tools:context=".MeetingActivity">

    <TextView
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:gravity="center"
        android:text="Creating a meeting for you"
        android:textColor="@color/white"
        android:textFontWeight="700"
        android:textSize="20sp" />

</RelativeLayout>
```

#### Initializing the Meeting

After getting token, meetigId and mode from `JoinActivity`,

1. Initialize **VideoSDK**.
2. Configure **VideoSDK** with token.
3. Initialize the meeting with required params such as `meetingId`, `participantName`, `micEnabled`, `webcamEnabled` , `mode` and more.
4. Join the room with `meeting.join()` method.
5. Add `MeetingEventListener` for listening **Meeting Join** event.
6. Check mode of `localParticipant`, If mode is **SEND_AND_RECV** than we will replace mainLayout with `SpeakerFragment` otherwise replace with `ViewerFragment`.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js title="MeetingActivity.kt"
class MeetingActivity : AppCompatActivity() {
  var meeting: Meeting? = null
      private set

  override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    setContentView(R.layout.activity_meeting)

    val meetingId = intent.getStringExtra("meetingId")
    val token = intent.getStringExtra("token")
    val mode = intent.getStringExtra("mode")
    val localParticipantName = "John Doe"
    val streamEnable = mode == "SEND_AND_RECV"

    //highlight-next-line
    // initialize VideoSDK
    VideoSDK.initialize(applicationContext)

    //highlight-next-line
    // Configuration VideoSDK with Token
    VideoSDK.config(token)

    //highlight-next-line
    // Initialize VideoSDK Meeting
    meeting = VideoSDK.initMeeting(
        this@MeetingActivity, meetingId, localParticipantName,
        streamEnable, streamEnable, null, mode, false, null, null
    )

    //highlight-next-line
    // join Meeting
    meeting!!.join()

    //highlight-next-line
    // if mode is SEND_AND_RECV than replace mainLayout with SpeakerFragment otherwise with ViewerFragment
    meeting!!.addEventListener(object : MeetingEventListener() {
      override fun onMeetingJoined() {
          if (meeting != null) {
            if (mode == "SEND_AND_RECV") {
              //highlight-next-line
              //pin the local participant
              meeting!!.localParticipant.pin("SHARE_AND_CAM")
              supportFragmentManager
                  .beginTransaction()
                  .replace(R.id.mainLayout, SpeakerFragment(), "MainFragment")
                  .commit()
              } else if (mode == "SIGNALLING_ONLY") {
                supportFragmentManager
                    .beginTransaction()
                    .replace(R.id.mainLayout, ViewerFragment(), "viewerFragment")
                    .commit()
              }
          }
      }
    })
  }
}
```

</TabItem>

<TabItem value="Java">

```java title="MeetingActivity.java"
public class MeetingActivity extends AppCompatActivity {
  private Meeting meeting;

  @Override
  protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_meeting);

    final String meetingId = getIntent().getStringExtra("meetingId");
    String token = getIntent().getStringExtra("token");
    String mode = getIntent().getStringExtra("mode");
    String localParticipantName = "John Doe";
    boolean streamEnable = mode.equals("SEND_AND_RECV");

    //highlight-next-line
    // initialize VideoSDK
    VideoSDK.initialize(getApplicationContext());

    //highlight-next-line
    // Configuration VideoSDK with Token
    VideoSDK.config(token);

    //highlight-next-line
    // Initialize VideoSDK Meeting
    meeting = VideoSDK.initMeeting(
            MeetingActivity.this, meetingId, localParticipantName,
            streamEnable, streamEnable, null, mode, false, null, null);

    //highlight-next-line
    // join Meeting
    meeting.join();

    //highlight-next-line
    // if mode is SEND_AND_RECV than replace mainLayout with SpeakerFragment otherwise with ViewerFragment
    meeting.addEventListener(new MeetingEventListener() {
        @Override
        public void onMeetingJoined() {
          if (meeting != null) {
            if (mode.equals("SEND_AND_RECV")) {
              //highlight-next-line
              //pin the local participant
              meeting.getLocalParticipant().pin("SHARE_AND_CAM");
              getSupportFragmentManager()
                  .beginTransaction()
                  .replace(R.id.mainLayout, new SpeakerFragment(), "MainFragment")
                  .commit();
            } else if (mode.equals("SIGNALLING_ONLY")) {
              getSupportFragmentManager()
                  .beginTransaction()
                  .replace(R.id.mainLayout, new ViewerFragment(), "viewerFragment")
                  .commit();
            }
          }
        }
      });
  }
  public Meeting getMeeting() {
      return meeting;
  }
}
```

</TabItem>

</Tabs>

#### Output

<center>

<img style={{height: '450px'}} src="https://cdn.videosdk.live/website-resources/docs-resources/android_ils_quickstart_meeting_screen.jpg" />

</center>

### Step 3: Implement SpeakerView

After successfully enter into the meeting, it's time to render speaker's view and manage controls such as toggle webcam/mic,start/stop HLS and leave the meeting.

1. Create a new fragment named `SpeakerFragment`.

2. In `/app/res/layout/fragment_speaker.xml` file, replace the content with the following.

```xml title="fragment_speaker.xml"
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:background="@color/black"
    android:gravity="center"
    android:orientation="vertical"
    tools:context=".SpeakerFragment">

    <LinearLayout
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:layout_marginVertical="8sp"
        android:paddingHorizontal="10sp">

        <TextView
            android:id="@+id/tvMeetingId"
            android:layout_width="0dp"
            android:layout_height="wrap_content"
            android:text="Meeting Id : "
            android:textColor="@color/white"
            android:textSize="18sp"
            android:layout_weight="3"/>

        <Button
            android:id="@+id/btnLeave"
            android:layout_width="0dp"
            android:layout_height="wrap_content"
            android:text="Leave"
            android:textAllCaps="false"
            android:layout_weight="1"/>

    </LinearLayout>

    <TextView
        android:id="@+id/tvHlsState"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Current HLS State : NOT_STARTED"
        android:textColor="@color/white"
        android:textSize="18sp" />

    <androidx.recyclerview.widget.RecyclerView
        android:id="@+id/rvParticipants"
        android:layout_width="match_parent"
        android:layout_height="0dp"
        android:layout_marginVertical="10sp"
        android:layout_weight="1" />

    <LinearLayout
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:gravity="center">

        <Button
            android:id="@+id/btnHLS"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:text="Start HLS"
            android:textAllCaps="false" />

        <Button
            android:id="@+id/btnWebcam"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:layout_marginHorizontal="5sp"
            android:text="Toggle Webcam"
            android:textAllCaps="false" />

        <Button
            android:id="@+id/btnMic"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:text="Toggle Mic"
            android:textAllCaps="false" />

    </LinearLayout>

</LinearLayout>
```

3. Now, let's set listener for buttons which will allow the participant to toggle media.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js title="SpeakerFragment.kt"
class SpeakerFragment : Fragment() {
  private var micEnabled = true
  private var webcamEnabled = true
  private var hlsEnabled = false
  private var btnMic: Button? = null
  private var btnWebcam: Button? = null
  private var btnHls: Button? = null
  private var btnLeave: Button? = null
  private var tvMeetingId: TextView? = null
  private var tvHlsState: TextView? = null
  override fun onAttach(context: Context) {
    super.onAttach(context)
    mContext = context
    if (context is Activity) {
      mActivity = context
      //highlight-next-line
      // getting meeting object from Meeting Activity
      meeting = (mActivity as MeetingActivity?)!!.meeting
    }
  }

  override fun onCreateView(
      inflater: LayoutInflater, container: ViewGroup?,
      savedInstanceState: Bundle?
  ): View? {
    // Inflate the layout for this fragment
    val view = inflater.inflate(R.layout.fragment_speaker, container, false)
    btnMic = view.findViewById(R.id.btnMic)
    btnWebcam = view.findViewById(R.id.btnWebcam)
    btnHls = view.findViewById(R.id.btnHLS)
    btnLeave = view.findViewById(R.id.btnLeave)
    tvMeetingId = view.findViewById(R.id.tvMeetingId)
    tvHlsState = view.findViewById(R.id.tvHlsState)
    if (meeting != null) {
      tvMeetingId!!.text = "Meeting Id : " + meeting!!.meetingId
      //highlight-next-line
      setActionListeners()
    }
    return view
  }

  private fun setActionListeners() {
    btnMic!!.setOnClickListener {
      if (micEnabled) {
        //highlight-next-line
        meeting!!.muteMic()
        Toast.makeText(mContext, "Mic Muted", Toast.LENGTH_SHORT).show()
      } else {
        //highlight-next-line
        meeting!!.unmuteMic()
        Toast.makeText(
            mContext,
            "Mic Enabled",
            Toast.LENGTH_SHORT
        ).show()
      }
      micEnabled = !micEnabled
    }
    btnWebcam!!.setOnClickListener {
      if (webcamEnabled) {
        //highlight-next-line
        meeting!!.disableWebcam()
        Toast.makeText(
            mContext,
            "Webcam Disabled",
            Toast.LENGTH_SHORT
        ).show()
      } else {
        //highlight-next-line
        meeting!!.enableWebcam()
        Toast.makeText(
            mContext,
            "Webcam Enabled",
            Toast.LENGTH_SHORT
        ).show()
      }
      webcamEnabled = !webcamEnabled
    }
    //highlight-next-line
    btnLeave!!.setOnClickListener { meeting!!.leave() }
    btnHls!!.setOnClickListener {
      if (!hlsEnabled) {
        //highlight-start
        val config = JSONObject()
        val layout = JSONObject()
        JsonUtils.jsonPut(layout, "type", "SPOTLIGHT")
        JsonUtils.jsonPut(layout, "priority", "PIN")
        JsonUtils.jsonPut(layout, "gridSize", 4)
        JsonUtils.jsonPut(config, "layout", layout)
        JsonUtils.jsonPut(config, "orientation", "portrait")
        JsonUtils.jsonPut(config, "theme", "DARK")
        JsonUtils.jsonPut(config, "quality", "high")
        meeting!!.startHls(config)
        //highlight-end
      } else {
        //highlight-next-line
        meeting!!.stopHls()
      }
    }
  }

  companion object {
    private var mActivity: Activity? = null
    private var mContext: Context? = null
    private var meeting: Meeting? = null
  }
}
```

</TabItem>

<TabItem value="Java">

```java title="SpeakerFragment.java"
public class SpeakerFragment extends Fragment {

  private static Activity mActivity;
  private static Context mContext;
  private static Meeting meeting;
  private boolean micEnabled = true;
  private boolean webcamEnabled = true;
  private boolean hlsEnabled = false;
  private Button btnMic, btnWebcam, btnHls, btnLeave;
  private TextView tvMeetingId, tvHlsState;

  public SpeakerFragment() {
    // Required empty public constructor
  }

  @Override
  public void onAttach(@NonNull Context context) {
    super.onAttach(context);
    mContext = context;
    if (context instanceof Activity) {
      mActivity = (Activity) context;
      //highlight-next-line
      // getting meeting object from Meeting Activity
      meeting = ((MeetingActivity) mActivity).getMeeting();
    }
  }

  @Override
  public View onCreateView(LayoutInflater inflater, ViewGroup container,
                            Bundle savedInstanceState) {
    // Inflate the layout for this fragment
    View view = inflater.inflate(R.layout.fragment_speaker, container, false);
    btnMic = view.findViewById(R.id.btnMic);
    btnWebcam = view.findViewById(R.id.btnWebcam);
    btnHls = view.findViewById(R.id.btnHLS);
    btnLeave = view.findViewById(R.id.btnLeave);

    tvMeetingId = view.findViewById(R.id.tvMeetingId);
    tvHlsState = view.findViewById(R.id.tvHlsState);

    if (meeting != null) {
        tvMeetingId.setText("Meeting Id : " + meeting.getMeetingId());
        //highlight-next-line
        setActionListeners();
    }
    return view;
  }

  private void setActionListeners() {
    btnMic.setOnClickListener(v -> {
        if (micEnabled) {
          //highlight-next-line
          meeting.muteMic();
          Toast.makeText(mContext,"Mic Muted",Toast.LENGTH_SHORT).show();
        } else {
          //highlight-next-line
          meeting.unmuteMic();
          Toast.makeText(mContext,"Mic Enabled",Toast.LENGTH_SHORT).show();
        }
        micEnabled=!micEnabled;
    });

    btnWebcam.setOnClickListener(v -> {
        if (webcamEnabled) {
          //highlight-next-line
          meeting.disableWebcam();
          Toast.makeText(mContext,"Webcam Disabled",Toast.LENGTH_SHORT).show();
        } else {
          //highlight-next-line
          meeting.enableWebcam();
          Toast.makeText(mContext,"Webcam Enabled",Toast.LENGTH_SHORT).show();
        }
        webcamEnabled=!webcamEnabled;
    });

    //highlight-next-line
    btnLeave.setOnClickListener(v -> meeting.leave());

    btnHls.setOnClickListener(v -> {
      if (!hlsEnabled) {
        //highlight-start
        JSONObject config = new JSONObject();
        JSONObject layout = new JSONObject();
        JsonUtils.jsonPut(layout, "type", "SPOTLIGHT");
        JsonUtils.jsonPut(layout, "priority", "PIN");
        JsonUtils.jsonPut(layout, "gridSize", 4);
        JsonUtils.jsonPut(config, "layout", layout);
        JsonUtils.jsonPut(config, "orientation", "portrait");
        JsonUtils.jsonPut(config, "theme", "DARK");
        JsonUtils.jsonPut(config, "quality", "high");
        meeting.startHls(config);
        //highlight-end
      } else {
        //highlight-next-line
        meeting.stopHls();
      }
    });
  }
}
```

</TabItem>

</Tabs>

4. After adding listners for buttons, let's add `MeetingEventListener` to the meeting and remove all listners in `onDestroy()` method.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js title="SpeakerFragment.kt"
class SpeakerFragment : Fragment() {

  override fun onCreateView(
      inflater: LayoutInflater, container: ViewGroup?,
      savedInstanceState: Bundle?
  ): View? {
    //...
    if (meeting != null) {
      //...
      //highlight-next-line
      // add Listener to the meeting
      meeting!!.addEventListener(meetingEventListener)
    }
    return view
  }

  private val meetingEventListener: MeetingEventListener = object : MeetingEventListener() {
      override fun onMeetingLeft() {
        //highlight-next-line
        // unpin the local participant
        meeting!!.localParticipant.unpin("SHARE_AND_CAM")
        if (isAdded) {
          val intents = Intent(mContext, JoinActivity::class.java)
          intents.addFlags(
              Intent.FLAG_ACTIVITY_NEW_TASK
                      or Intent.FLAG_ACTIVITY_CLEAR_TOP or Intent.FLAG_ACTIVITY_CLEAR_TASK
          )
          startActivity(intents)
          mActivity!!.finish()
        }
      }

      @RequiresApi(api = Build.VERSION_CODES.P)
      override fun onHlsStateChanged(HlsState: JSONObject) {
        if (HlsState.has("status")) {
          try {
              tvHlsState!!.text = "Current HLS State : " + HlsState.getString("status")
              //highlight-next-line
              if (HlsState.getString("status") == "HLS_STARTED") {
                hlsEnabled = true
                btnHls!!.text = "Stop HLS"
              }
              //highlight-next-line
              if (HlsState.getString("status") == "HLS_STOPPED") {
                hlsEnabled = false
                btnHls!!.text = "Start HLS"
              }
            } catch (e: JSONException) {
                e.printStackTrace()
            }
        }
      }
  }

  override fun onDestroy() {
      mContext = null
      mActivity = null
      if (meeting != null) {
          meeting!!.removeAllListeners()
          meeting = null
      }
      super.onDestroy()
  }
}
```

</TabItem>

<TabItem value="Java">

```java title="SpeakerFragment.java"
public class SpeakerFragment extends Fragment {

  @Override
  public View onCreateView(LayoutInflater inflater, ViewGroup container,
                            Bundle savedInstanceState) {
    //...
    if (meeting != null) {
        //...
        //highlight-next-line
        // add Listener to the meeting
        meeting.addEventListener(meetingEventListener);
    }
    return view;
  }

  private final MeetingEventListener meetingEventListener = new MeetingEventListener() {
    @Override
    public void onMeetingLeft() {
      //highlight-next-line
      //unpin local participant
      meeting.getLocalParticipant().unpin("SHARE_AND_CAM");
      if (isAdded()) {
        Intent intents = new Intent(mContext, JoinActivity.class);
        intents.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK
                | Intent.FLAG_ACTIVITY_CLEAR_TOP | Intent.FLAG_ACTIVITY_CLEAR_TASK);
        startActivity(intents);
        mActivity.finish();
      }
    }

    @RequiresApi(api = Build.VERSION_CODES.P)
    @Override
    public void onHlsStateChanged(JSONObject HlsState) {
        if (HlsState.has("status")) {
          try {
            tvHlsState.setText("Current HLS State : " + HlsState.getString("status"));
            //highlight-next-line
            if (HlsState.getString("status").equals("HLS_STARTED")) {
                hlsEnabled=true;
                btnHls.setText("Stop HLS");
            }
            //highlight-next-line
            if (HlsState.getString("status").equals("HLS_STOPPED")) {
                hlsEnabled = false;
                btnHls.setText("Start HLS");
            }
          } catch (JSONException e) {
              e.printStackTrace();
          }
        }
    }
  };

  @Override
  public void onDestroy() {
    mContext = null;
    mActivity = null;
    if (meeting != null) {
        meeting.removeAllListeners();
        meeting = null;
    }
    super.onDestroy();
  }

}
```

</TabItem>

</Tabs>

5. Next step is to render speaker's view. With `RecyclerView`, we will be display list of participant who joined the meeting as a `host`.

:::info

- Here the participant's video is displayed using `VideoView`, but you may also use `SurfaceViewRender` for the same.
- For `VideoView`, SDK version should be `0.1.13` or higher.
- To know more about `VideoView`, please visit [here](/android/guide/video-and-audio-calling-api-sdk/render-media/display-video/understand-videoView-component)

:::

- Create a new layout for the participant view named `item_remote_peer.xml` in the `res/layout` folder.

```xml title="item_remote_peer.xml"
<?xml version="1.0" encoding="utf-8"?>
<FrameLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="200dp"
    android:background="@color/cardview_dark_background"
    tools:layout_height="200dp">

    <live.videosdk.rtc.android.VideoView
        android:id="@+id/participantView"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:visibility="gone" />

    <LinearLayout
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:layout_gravity="bottom"
        android:background="#99000000"
        android:orientation="horizontal">

        <TextView
            android:id="@+id/tvName"
            android:layout_width="0dp"
            android:layout_height="wrap_content"
            android:layout_weight="1"
            android:gravity="center"
            android:padding="4dp"
            android:textColor="@color/white" />

    </LinearLayout>

</FrameLayout>
```

- Create a recycler view adapter named `SpeakerAdapter` which will show the participant list. Create `PeerViewHolder` in the adapter which will extend `RecyclerView.ViewHolder`.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js title="SpeakerAdapter.kt"
class SpeakerAdapter(private val meeting: Meeting) :
    RecyclerView.Adapter<SpeakerAdapter.PeerViewHolder?>() {
    private var participantList: MutableList<Participant> = ArrayList()

    init {
      updateParticipantList()
      //highlight-next-line
      // adding Meeting Event listener to get the participant join/leave event in the meeting.
      meeting.addEventListener(object : MeetingEventListener() {
        override fun onParticipantJoined(participant: Participant) {
          //highlight-next-line
          // check participant join as Host/Speaker or not
          if (participant.mode == "SEND_AND_RECV") {
              //highlight-next-line
              // pin the participant
              participant.pin("SHARE_AND_CAM")
              //highlight-next-line
              // add participant in participantList
              participantList.add(participant)
          }
          notifyDataSetChanged()
        }

        override fun onParticipantLeft(participant: Participant) {
          var pos = -1
          for (i in participantList.indices) {
              if (participantList[i].id == participant.id) {
                  pos = i
                  break
              }
          }
          if (participantList.contains(participant)) {
              //highlight-next-line
              // unpin participant who left the meeting
              participant.unpin("SHARE_AND_CAM")
              //highlight-next-line
              // remove participant from participantList
              participantList.remove(participant)
          }
          if (pos >= 0) {
              notifyItemRemoved(pos)
          }
        }
      })
    }

    private fun updateParticipantList() {
      //highlight-next-line
      // adding the local participant(You) to the list
      participantList.add(meeting.localParticipant)

      //highlight-next-line
      // adding participants who join as Host/Speaker
      val participants: Iterator<Participant> = meeting.participants.values.iterator()
      for (i in 0 until meeting.participants.size) {
        val participant = participants.next()
        if (participant.mode == "SEND_AND_RECV") {
            //highlight-next-line
            // pin the participant
            participant.pin("SHARE_AND_CAM")
            //highlight-next-line
            // add participant in participantList
            participantList.add(participant)
        }
      }
    }

    override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): PeerViewHolder {
      return PeerViewHolder(
          LayoutInflater.from(parent.context).inflate(R.layout.item_remote_peer, parent, false)
      )
    }

    override fun onBindViewHolder(holder: PeerViewHolder, position: Int) {
      val participant = participantList[position]
      holder.tvName.text = participant.displayName

      // adding the initial video stream for the participant into the 'VideoView'
      for ((_, stream) in participant.streams) {
        if (stream.kind.equals("video", ignoreCase = true)) {
          holder.participantView.visibility = View.VISIBLE
          val videoTrack = stream.track as VideoTrack
          //highlight-next-line
          holder.participantView.addTrack(videoTrack)
          break
        }
      }

      // add Listener to the participant which will update start or stop the video stream of that participant
      participant.addEventListener(object : ParticipantEventListener() {
        override fun onStreamEnabled(stream: Stream) {
          if (stream.kind.equals("video", ignoreCase = true)) {
            holder.participantView.visibility = View.VISIBLE
            val videoTrack = stream.track as VideoTrack
            //highlight-next-line
            holder.participantView.addTrack(videoTrack)
          }
        }

        override fun onStreamDisabled(stream: Stream) {
          if (stream.kind.equals("video", ignoreCase = true)) {
            //highlight-next-line
            holder.participantView.removeTrack()
            holder.participantView.visibility = View.GONE
          }
        }
      })
    }

    override fun getItemCount(): Int {
      //highlight-next-line
      return participantList.size
    }

    class PeerViewHolder(view: View) : RecyclerView.ViewHolder(view) {
      // 'VideoView' to show Video Stream
      var participantView: VideoView
      var tvName: TextView

      init {
        tvName = view.findViewById(R.id.tvName)
        participantView = view.findViewById(R.id.participantView)
      }
    }
}
```

</TabItem>

<TabItem value="Java">

```java title="SpeakerAdapter.java"
public class SpeakerAdapter extends RecyclerView.Adapter<SpeakerAdapter.PeerViewHolder> {
  private List<Participant> participantList = new ArrayList<>();
  private final Meeting meeting;
  public SpeakerAdapter(Meeting meeting) {
    this.meeting = meeting;

    updateParticipantList();

    //highlight-next-line
    // adding Meeting Event listener to get the participant join/leave event in the meeting.
    meeting.addEventListener(new MeetingEventListener() {
      @Override
      public void onParticipantJoined(Participant participant) {
        //highlight-next-line
        // check participant join as Host/Speaker or not
        if (participant.getMode().equals("SEND_AND_RECV")) {
          //highlight-next-line
          // pin the participant
          participant.pin("SHARE_AND_CAM");
          //highlight-next-line
          // add participant in participantList
          participantList.add(participant);
        }
        notifyDataSetChanged();
      }

      @Override
      public void onParticipantLeft(Participant participant) {
        int pos = -1;
        for (int i = 0; i < participantList.size(); i++) {
          if (participantList.get(i).getId().equals(participant.getId())) {
            pos = i;
            break;
          }
        }
        if(participantList.contains(participant)) {
          //highlight-next-line
          // unpin participant who left the meeting
          participant.unpin("SHARE_AND_CAM");
          //highlight-next-line
          // remove participant from the list
          participantList.remove(participant);
        }
        if (pos >= 0) {
            notifyItemRemoved(pos);
        }
      }
    });
  }

  private void updateParticipantList() {
    participantList = new ArrayList<>();

    //highlight-next-line
    // adding the local participant(You) to the list
    participantList.add(meeting.getLocalParticipant());

    //highlight-next-line
    // adding participants who join as Host/Speaker
    Iterator<Participant> participants = meeting.getParticipants().values().iterator();
    for (int i = 0; i < meeting.getParticipants().size(); i++) {
      final Participant participant = participants.next();
      if (participant.getMode().equals("SEND_AND_RECV")) {
        //highlight-next-line
        // pin the participant
        participant.pin("SHARE_AND_CAM");
        //highlight-next-line
        // add participant in participantList
        participantList.add(participant);
      }
    }
  }

  @NonNull
  @Override
  public PeerViewHolder onCreateViewHolder(@NonNull ViewGroup parent, int viewType) {
    return new PeerViewHolder(LayoutInflater.from(parent.getContext()).inflate(R.layout.item_remote_peer, parent, false));
  }

  @Override
  public void onBindViewHolder(@NonNull PeerViewHolder holder, int position) {
    Participant participant = participantList.get(position);

    holder.tvName.setText(participant.getDisplayName());

    // adding the initial video stream for the participant into the 'VideoView'
    for (Map.Entry<String, Stream> entry : participant.getStreams().entrySet()) {
      Stream stream = entry.getValue();
      if (stream.getKind().equalsIgnoreCase("video")) {
        holder.participantView.setVisibility(View.VISIBLE);
        VideoTrack videoTrack = (VideoTrack) stream.getTrack();
        //highlight-next-line
        holder.participantView.addTrack(videoTrack);
        break;
      }
    }

    // add Listener to the participant which will update start or stop the video stream of that participant
    participant.addEventListener(new ParticipantEventListener() {
        @Override
        public void onStreamEnabled(Stream stream) {
          if (stream.getKind().equalsIgnoreCase("video")) {
            holder.participantView.setVisibility(View.VISIBLE);
            VideoTrack videoTrack = (VideoTrack) stream.getTrack();
            //highlight-next-line
            holder.participantView.addTrack(videoTrack);
          }
        }

        @Override
        public void onStreamDisabled(Stream stream) {
          if (stream.getKind().equalsIgnoreCase("video")) {
            //highlight-next-line
            holder.participantView.removeTrack();
            holder.participantView.setVisibility(View.GONE);
          }
        }
    });
  }

  @Override
  public int getItemCount() {
    //highlight-next-line
    return participantList.size();
  }

  static class PeerViewHolder extends RecyclerView.ViewHolder {
    // 'VideoView' to show Video Stream
    public VideoView participantView;
    public TextView tvName;
    public View itemView;

    PeerViewHolder(@NonNull View view) {
        super(view);
        itemView = view;
        tvName = view.findViewById(R.id.tvName);
        participantView = view.findViewById(R.id.participantView);
    }
  }
}
```

</TabItem>

</Tabs>

6. Add this adapter to the `SpeakerFragment`

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js title="SpeakerFragment.kt"
 override fun onCreateView(
      inflater: LayoutInflater, container: ViewGroup?,
      savedInstanceState: Bundle?
  ): View? {
    //...
    if (meeting != null) {
      //...
      val rvParticipants = view.findViewById<RecyclerView>(R.id.rvParticipants)
      rvParticipants.layoutManager = GridLayoutManager(mContext, 2)
      rvParticipants.adapter = SpeakerAdapter(meeting!!)
  }
}
```

</TabItem>

<TabItem value="Java">

```java title="SpeakerFragment.java"
 @Override
  public View onCreateView(LayoutInflater inflater, ViewGroup container,
                            Bundle savedInstanceState) {
    //...
    if (meeting != null) {
      //...
      final RecyclerView rvParticipants = view.findViewById(R.id.rvParticipants);
      rvParticipants.setLayoutManager(new GridLayoutManager(mContext, 2));
      rvParticipants.setAdapter(new SpeakerAdapter(meeting));
    }
}
```

</TabItem>

</Tabs>

#### Output

<center>

<img style={{height: '450px'}} src="https://cdn.videosdk.live/website-resources/docs-resources/android_ils_quickstart_speaker_screen.jpg" />

</center>

### Step 4: Implement ViewerView

When host start the live streaming, viewer will be able to see the live streaming.

To implement player view, we are going to use `ExoPlayer`. It will be helpful to play hls stream.

Let's first add dependency into the project.

```js title="app/build.gradle"
dependencies {
  implementation 'com.google.android.exoplayer:exoplayer:2.18.5'
  // other app dependencies
  }
```

Create a new Fragment named `ViewerFragment`

#### Creating UI

The Viewer Fragment will include :

1. **TextView for Meeting Id** - The meeting Id that you joined will be displayed in this text view.
2. **Leave Button** - This button will leave the meeting.
3. **waitingLayout** - This is textView that will be shown when there is no active HLS.
4. **StyledPlayerView** - This is mediaplayer which will display livestreaming.

In `/app/res/layout/fragment_viewer.xml` file, replace the content with the following.

```xml title="fragment_viewer.xml"
<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:background="@color/black"
    tools:context=".ViewerFragment">

    <LinearLayout
        android:id="@+id/meetingLayout"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:paddingHorizontal="12sp"
        android:paddingVertical="5sp">

        <TextView
            android:id="@+id/meetingId"
            android:layout_width="0dp"
            android:layout_height="wrap_content"
            android:layout_weight="3"
            android:text="Meeting Id : "
            android:textColor="@color/white"
            android:textSize="20sp" />

        <Button
            android:id="@+id/btnLeave"
            android:layout_width="0dp"
            android:layout_height="wrap_content"
            android:layout_weight="1"
            android:text="Leave" />

    </LinearLayout>

    <TextView
        android:id="@+id/waitingLayout"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:text="Waiting for host \n to start the live streaming"
        android:textColor="@color/white"
        android:textFontWeight="700"
        android:textSize="20sp"
        android:gravity="center"/>

    <com.google.android.exoplayer2.ui.StyledPlayerView
        android:id="@+id/player_view"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:visibility="gone"
        app:resize_mode="fixed_width"
        app:show_buffering="when_playing"
        app:show_subtitle_button="false"
        app:use_artwork="false"
        app:show_next_button="false"
        app:show_previous_button="false"
        app:use_controller="true"
        android:layout_below="@id/meetingLayout"/>

</RelativeLayout>
```

#### Initialize player and Playing HLS stream

1. Initialize player and play the HLS when the meeting HLS state is `HLS_PLAYABLE`, and release it when the HLS state is `HLS_STOPPED`. Whenever the meeting HLS state changes, the event `onHlsStateChanged` will be triggered.

- when you receive `HLS_PLAYABLE` status you will receive 2 urls
  - `playbackHlsUrl` - Live HLS with playback support
  - `livestreamUrl` - Live HLS without playback support

:::note
`downstreamUrl` is now depecated. Use `playbackHlsUrl` or `livestreamUrl` in place of `downstreamUrl`
:::

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js title="ViewerFragment.kt"
class ViewerFragment : Fragment() {
  private var meeting: Meeting? = null
  private var playerView: StyledPlayerView? = null
  private var waitingLayout: TextView? = null
  private var player: ExoPlayer? = null
  private var dataSourceFactory: DefaultHttpDataSource.Factory? = null
  private val startAutoPlay = true
  private var playbackHlsUrl: String? = ""


  override fun onCreateView(
    inflater: LayoutInflater, container: ViewGroup?,
    savedInstanceState: Bundle?
  ): View? {
    // Inflate the layout for this fragment
    val view = inflater.inflate(R.layout.fragment_viewer, container, false)
    playerView = view.findViewById(R.id.player_view)
    waitingLayout = view.findViewById(R.id.waitingLayout)
    if (meeting != null) {
        //highlight-next-line
        // set MeetingId to TextView
        (view.findViewById<View>(R.id.meetingId) as TextView).text =
            "Meeting Id : " + meeting!!.meetingId
        //highlight-next-line
        // leave the meeting on btnLeave click
        (view.findViewById<View>(R.id.btnLeave) as Button).setOnClickListener { meeting!!.leave() }
        //highlight-next-line
        // add listener to meeting
        meeting!!.addEventListener(meetingEventListener)
    }
    return view
  }

  override fun onAttach(context: Context) {
      super.onAttach(context)
      mContext = context
      if (context is Activity) {
        mActivity = context
        //highlight-next-line
        // get meeting object from MeetingActivity
        meeting = (mActivity as MeetingActivity?)!!.meeting
      }
  }

  private val meetingEventListener: MeetingEventListener = object : MeetingEventListener() {
      override fun onMeetingLeft() {
        if (isAdded) {
          val intents = Intent(mContext, JoinActivity::class.java)
          intents.addFlags(
              Intent.FLAG_ACTIVITY_NEW_TASK
                      or Intent.FLAG_ACTIVITY_CLEAR_TOP or Intent.FLAG_ACTIVITY_CLEAR_TASK
          )
          startActivity(intents)
          mActivity!!.finish()
        }
      }

      //highlight-start
      @RequiresApi(api = Build.VERSION_CODES.P)
      override fun onHlsStateChanged(HlsState: JSONObject) {
        if (HlsState.has("status")) {
            try {
              if (HlsState.getString("status") == "HLS_PLAYABLE" && HlsState.has("playbackHlsUrl")) {
                playbackHlsUrl = HlsState.getString("playbackHlsUrl")
                waitingLayout!!.visibility = View.GONE
                playerView!!.visibility = View.VISIBLE
                // initialize player
                initializePlayer()
              }
              if (HlsState.getString("status") == "HLS_STOPPED") {
                // release the player
                releasePlayer()
                playbackHlsUrl = null
                waitingLayout!!.text = "Host has stopped \n the live streaming"
                waitingLayout!!.visibility = View.VISIBLE
                playerView!!.visibility = View.GONE
              }
            } catch (e: JSONException) {
                e.printStackTrace()
            }
          }
      }
      //highlight-end
  }

  private fun initializePlayer() {
    if (player == null) {
      dataSourceFactory = DefaultHttpDataSource.Factory()
      val mediaSource = HlsMediaSource.Factory(dataSourceFactory!!).createMediaSource(
          MediaItem.fromUri(Uri.parse(playbackHlsUrl))
      )
      val playerBuilder = ExoPlayer.Builder( /* context = */mContext!!)
      player = playerBuilder.build()
      // auto play when player is ready
      player!!.playWhenReady = startAutoPlay
      player!!.setMediaSource(mediaSource)
      // if you want display setting for player then remove this line
      playerView!!.findViewById<View>(com.google.android.exoplayer2.ui.R.id.exo_settings).visibility =
          View.GONE
      playerView!!.player = player
    }
    player!!.prepare()
  }

  private fun releasePlayer() {
    if (player != null) {
      player!!.release()
      player = null
      dataSourceFactory = null
      playerView!!.player = null
    }
  }

  override fun onDestroy() {
    mContext = null
    mActivity = null
    playbackHlsUrl = null
    releasePlayer()
    if (meeting != null) {
        meeting!!.removeAllListeners()
        meeting = null
    }
    super.onDestroy()
  }

  companion object {
    private var mActivity: Activity? = null
    private var mContext: Context? = null
  }
}
```

</TabItem>

<TabItem value="Java">

```java title="ViewerFragment.java"
public class ViewerFragment extends Fragment {

  private Meeting meeting;
  protected StyledPlayerView playerView;
  private TextView waitingLayout;
  protected @Nullable
  ExoPlayer player;

  private DefaultHttpDataSource.Factory dataSourceFactory;
  private boolean startAutoPlay=true;
  private String playbackHlsUrl = "";
  private static Activity mActivity;
  private static Context mContext;

  public ViewerFragment() {
      // Required empty public constructor
  }

  @Override
  public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
  }

  @Override
  public View onCreateView(LayoutInflater inflater, ViewGroup container,
                            Bundle savedInstanceState) {
    // Inflate the layout for this fragment
    View view = inflater.inflate(R.layout.fragment_viewer, container, false);

    playerView = view.findViewById(R.id.player_view);

    waitingLayout = view.findViewById(R.id.waitingLayout);
    if(meeting != null) {
      //highlight-next-line
      // set MeetingId to TextView
      ((TextView) view.findViewById(R.id.meetingId)).setText("Meeting Id : " + meeting.getMeetingId());
      //highlight-next-line
      // leave the meeting on btnLeave click
      ((Button) view.findViewById(R.id.btnLeave)).setOnClickListener(v -> meeting.leave());
      //highlight-next-line
      // add listener to meeting
      meeting.addEventListener(meetingEventListener);
    }
    return view;
  }


  @Override
  public void onAttach(@NonNull Context context) {
    super.onAttach(context);
    mContext = context;
    if (context instanceof Activity) {
      mActivity = (Activity) context;
      //highlight-next-line
      // get meeting object from MeetingActivity
      meeting = ((MeetingActivity) mActivity).getMeeting();
    }
  }

  private final MeetingEventListener meetingEventListener = new MeetingEventListener() {

      @Override
      public void onMeetingLeft() {
        if (isAdded()) {
          Intent intents = new Intent(mContext, JoinActivity.class);
          intents.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK
                  | Intent.FLAG_ACTIVITY_CLEAR_TOP | Intent.FLAG_ACTIVITY_CLEAR_TASK);
          startActivity(intents);
          mActivity.finish();
        }
      }

      //highlight-start
      @RequiresApi(api = Build.VERSION_CODES.P)
      @Override
      public void onHlsStateChanged(JSONObject HlsState) {
        if (HlsState.has("status")) {
          try {
            if (HlsState.getString("status").equals("HLS_PLAYABLE") && HlsState.has("playbackHlsUrl")) {
              playbackHlsUrl = HlsState.getString("playbackHlsUrl");
              waitingLayout.setVisibility(View.GONE);
              playerView.setVisibility(View.VISIBLE);
              // initialize player
              initializePlayer();
            }
            if (HlsState.getString("status").equals("HLS_STOPPED")) {
              // release the player
              releasePlayer();
              playbackHlsUrl = null;
              waitingLayout.setText("Host has stopped \n the live streaming");
              waitingLayout.setVisibility(View.VISIBLE);
              playerView.setVisibility(View.GONE);
            }
          } catch (JSONException e) {
              e.printStackTrace();
          }
        }
    }
    //highlight-end
  };

  protected void initializePlayer() {
    if (player == null) {
      dataSourceFactory = new DefaultHttpDataSource.Factory();
      HlsMediaSource mediaSource = new HlsMediaSource.Factory(dataSourceFactory).createMediaSource(
              MediaItem.fromUri(Uri.parse(this.playbackHlsUrl)));
      ExoPlayer.Builder playerBuilder =
              new ExoPlayer.Builder(/* context= */ mContext);
      player = playerBuilder.build();
      // auto play when player is ready
      player.setPlayWhenReady(startAutoPlay);
      player.setMediaSource(mediaSource);
      // if you want display setting for player then remove this line
      playerView.findViewById(com.google.android.exoplayer2.ui.R.id.exo_settings).setVisibility(View.GONE);
      playerView.setPlayer(player);
    }
    player.prepare();
  }

  protected void releasePlayer() {
    if (player != null) {
      player.release();
      player = null;
      dataSourceFactory = null;
      playerView.setPlayer(/* player= */ null);
    }
  }

  @Override
  public void onDestroy() {
    mContext = null;
    mActivity = null;
    playbackHlsUrl = null;
    releasePlayer();
    if (meeting != null) {
      meeting.removeAllListeners();
      meeting = null;
    }
    super.onDestroy();
  }

}
```

</TabItem>

</Tabs>

#### Output

<center>

<img style={{height: '450px',marginRight:'15px'}} src="https://cdn.videosdk.live/website-resources/docs-resources/android_ils_quickstart_viewer_screen_waiting.jpg" />

<img style={{height: '450px'}} src="https://cdn.videosdk.live/website-resources/docs-resources/android_ils_quickstart_viewer_screen.jpg" />

</center>

<br/>

## Final Output

We are done with implementation of customised video calling app in Android using Video SDK. To explore more features go through Basic and Advanced features.

import ReactPlayer from 'react-player'

<div style={{textAlign: 'center'}}>

<ReactPlayer muted controls url="https://cdn.videosdk.live/website-resources/docs-resources/android_ils_quickstart.mp4" height="500px" width={"100%"} />

</div>

<br/>

:::tip
You can checkout the complete [quick start example here](https://github.com/videosdk-live/quickstart/tree/main/android-hls).
:::


---

---
title: Quick Start With Interactive Live Streaming | VideoSDK Android
hide_title: true
hide_table_of_contents: false
description: Learn how to quickly integrate interactive live streaming features using VideoSDK's Android SDK. Step-by-step guide for implementing real-time video & audio streaming in mobile applications with code examples.
sidebar_label: Start With Interactive Live Streaming
pagination_label: Start With Interactive Live Streaming
keywords:
  - android sdk
  - live streaming api
  - webrtc streaming
  - interactive livestream
  - video streaming
  - audio streaming
  - real-time communication
  - video conferencing
  - streaming tutorial
  - web sdk
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: quick-start-android-ils
---

import CautionMessage from '@site/src/theme/CautionMessage';

# Quick Start for Interactive Live Streaming in Android

**VideoSDK** empowers you to seamlessly integrate **interactive live streaming** features into your Android application in minutes. While built for meetings, the SDK is easily adaptable for live streaming with support for up to **100 hosts/co-hosts** and **2,000 viewers** in **real-time**. Perfect for social use cases, this guide will walk you through integrating live streaming into your app.

:::info

For standard live streaming with 6-7 second latency and playback support, follow this [documentation](./quick-start-ILS.md).
:::

## Prerequisites

Before proceeding, ensure that your development environment meets the following requirements:

- Android Studio Arctic Fox (2020.3.1) or later.
- Android SDK API Level 21 or higher.
- A mobile device that runs Android 5.0 or later.

## Getting Started with the Code!

Follow the steps to create the environment necessary to add video calls into your app. Also you can find the code sample for [quickstart here](https://github.com/videosdk-live/quickstart/tree/main/interactive-live-streaming/android-ils).

<CautionMessage sdk="Android SDK" version="v0.2.0" />

### Create new Android Project

For a new project in **Android Studio**, create a **Phone and Tablet** Android project with an **Empty Activity**.

![VideoSDK Android Quick Start New Project](https://cdn.videosdk.live/docs/images/android/quickstart/android_compose_newProject.jpg)

:::caution
After creating the project, Android Studio automatically starts gradle sync. Ensure that the sync succeeds before you continue.
:::

### Integrate Video SDK

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Maven Central"
groupId={"android-repositories"}
values={[{label: 'Maven Central', value: 'Maven Central'},{label: 'Jitpack', value: 'Jitpack'},]}>

<TabItem value="Maven Central">

```js title="settings.gradle"
dependencyResolutionManagement {
    repositories {
    google()
    mavenCentral()
    maven {url= uri("https://maven.aliyun.com/repository/jcenter")}
  }
}
```

</TabItem>

<TabItem value="Jitpack">

```js title="settings.gradle"
dependencyResolutionManagement{
  repositories {
    google()
    maven { url = uri("https://www.jitpack.io") }
    mavenCentral()
    maven {url= uri("https://maven.aliyun.com/repository/jcenter")}
  }
}
```

</TabItem>

</Tabs>

:::note

You can use imports with Maven Central after rtc-android-sdk version `0.1.12`.

Whether on Maven or Jitpack, the same version numbers always refer to the same SDK.

:::

- Add the following dependency in your app's `app/build.gradle`.

```js title="app/build.gradle"
dependencies {
  implementation ("live.videosdk:rtc-android-sdk:0.1.38")

  // library to perform Network call to generate a stream id
  implementation ("com.amitshekhar.android:android-networking:1.0.2")

  // other app dependencies
  }
```

:::important

Android SDK compatible with armeabi-v7a, arm64-v8a, x86_64 architectures. If you want to run the application in an emulator, choose ABI x86_64 when creating a device.

:::

### Add permissions into your project

- In `/app/Manifests/AndroidManifest.xml`, add the following permissions.

```xml title="AndroidManifest.xml"
<uses-feature android:name="android.hardware.camera" android:required="false" />
<uses-permission android:name="android.permission.INTERNET"/>
<uses-permission android:name="android.permission.CAMERA"/>
<uses-permission android:name="android.permission.RECORD_AUDIO"/>
<uses-permission android:name="android.permission.MODIFY_AUDIO_SETTINGS"/>
```

:::note

If your project has set `android.useAndroidX=true`, then set `android.enableJetifier=true` in the `gradle.properties` file to migrate your project to AndroidX and avoid duplicate class conflict.

:::

### Structure of the project

Your project structure should look like this.

```jsx title="Project Structure"
app/
├── src/main/
│   ├── java/com/example/app/
│   │   ├── components/
│   │   ├── screens/
│   │   ├── ui/
│   │   │   └── theme/
│   │   ├── model/
│   │   ├── MainApplication.kt
│   │   ├── MainActivity.kt
│   │   └── NetworkClass.kt
|   |   └── StreamingMode.kt
│   ├── res/
│   └── AndroidManifest.xml
├── build.gradle
└── settings.gradle
```

### App Architecture

<center>

<img src='https://cdn.videosdk.live/website-resources/docs-resources/ils_qs_android_app_ architecture.png' />

</center>

### Step 1: Initialize VideoSDK

1. Create `MainApplication` class which will extend the `android.app.Application`.

- Create field `sampleToken` in `MainApplication` which will hold the generated token from the [VideoSDK dashboard](https://app.videosdk.live/api-keys). This token will use in VideoSDK config as well as generating meetingId.

```js title="MainApplication.kt"
import android.app.Application
import live.videosdk.rtc.android.VideoSDK

class MainApplication: Application() {

    val sampleToken = "YOUR_TOKEN" //paste your token here

    override fun onCreate() {
        super.onCreate()
        VideoSDK.initialize(applicationContext)
    }
}
```

2. Add `MainApplication` to `AndroidManifest.xml`

```xml title="AndroidManifest.xml"
<application
    android:name=".MainApplication"
   <!-- ... -->
</application>
```

### Step 2: Managing Permissions and Setting Up Navigation

The `MainActivity` handles permission requests for the camera and microphone and sets up navigation using Jetpack Compose.

Upon creation, it checks for required permissions (RECORD_AUDIO and CAMERA). If not granted, it requests them. Once permissions are granted, the MyApp composable is initialized, which contains the navigation logic through the NavigationGraph.

The NavigationGraph defines two screens:

- JoinScreen: For joining or create stream.
- StreamingScreen: For participating in a stream, passing meetingId and mode as arguments.

```js title="MainActivity.kt"
class MainActivity : ComponentActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        checkSelfPermission(REQUESTED_PERMISSIONS[0], PERMISSION_REQ_ID)
        checkSelfPermission(REQUESTED_PERMISSIONS[1], PERMISSION_REQ_ID)

        setContent {
            Videosdk_android_modes_quickstartTheme {
                MyApp(this) } }
    }

    private fun checkSelfPermission(permission: String, requestCode: Int): Boolean {
        if (ContextCompat.checkSelfPermission(this, permission) != PackageManager.PERMISSION_GRANTED) {
            ActivityCompat.requestPermissions(this, REQUESTED_PERMISSIONS, requestCode)
            return false
        }
        return true
    }

    companion object {
        private const val PERMISSION_REQ_ID = 22
        private val REQUESTED_PERMISSIONS = arrayOf(Manifest.permission.RECORD_AUDIO, Manifest.permission.CAMERA)
    }
}

@Composable
fun MyApp(context: Context) {
    NavigationGraph(context = context)
}

@Composable
fun NavigationGraph(navController: NavHostController = rememberNavController(), context: Context) {
    NavHost(navController = navController, startDestination = "join_screen") {
        composable("join_screen") { JoinScreen(navController, context) }
        composable("stream_screen?streamId={streamId}&mode={mode}") { backStackEntry ->
            val streamId = backStackEntry.arguments?.getString("streamId")
            val modeStr = backStackEntry.arguments?.getString("mode")
            val mode = StreamingMode.valueOf(modeStr ?: StreamingMode.SendAndReceive.name)

            streamId?.let {
                StreamingScreen(viewModel = StreamViewModel(), navController, streamId, mode, context)
            }
        }
    }
}
```

### Step 3: Creating Reusable Components

- Before building the individual screens, it's essential to develop reusable composable components that will be used throughout the project.

1. Create a `ReusableComponents.kt` file to organize all reusable components for the project, such as buttons, spacers, and customizable text.

```js title="ReusableComponents.kt"
@Composable
fun MyAppButton(task: () -> Unit, buttonName: String) {
    Button(onClick = task) {
        Text(text = buttonName) }
}

@Composable
fun MySpacer() {
    Spacer(modifier = Modifier.fillMaxWidth()
            .height(1.dp)
            .background(color = Color.Gray)) }

@Composable
fun MyText(text: String, fontSize: TextUnit = 23.sp) {
    Text(text = text,
        fontSize = fontSize,
        fontWeight = FontWeight.Normal,
        modifier = Modifier.padding(4.dp),
        style = MaterialTheme.typography.bodyMedium.copy(fontSize = 16.sp),
        color = MaterialTheme.colorScheme.onSurface.copy(alpha = 0.7f))
}
```

2. Create a `ParticipantVideoView.kt` file that includes two composable functions: `ParticipantVideoView` for rendering individual participant video streams, and `ParticipantsGrid` for displaying a grid of participant videos.

:::info

- Here the participant's video is displayed using `VideoView`. To know more about `VideoView`, please visit [here](/android/guide/video-and-audio-calling-api-sdk/render-media/display-video/understand-videoView-component)
- `VideoView` is a custom View. Since Jetpack Compose does not natively support traditional `View` objects, we need to integrate the `VideoView` into the Compose layout using the `AndroidView` wrapper.
- `AndroidView()` is a composable that can be used to add Android views inside a @Composable function.

:::

```js title="ParticipantVideoView.kt"
@Composable
fun ParticipantVideoView(
    participant: Participant
) {
        var isVideoEnabled by remember { mutableStateOf(false) }
        // Remember the event listener to prevent recreation on each recomposition
        val eventListener = remember(participant) {
            object : ParticipantEventListener() {
                override fun onStreamEnabled(stream: Stream) {
                    if (stream.kind.equals("video", ignoreCase = true)) {
                        val videoTrack = stream.track as VideoTrack
                        isVideoEnabled = true
                    }
                }
                override fun onStreamDisabled(stream: Stream) {
                    if (stream.kind.equals("video", ignoreCase = true)) {
                        isVideoEnabled = false
                    }
                }
            }
        }

        // Add and remove the event listener using side effects
        DisposableEffect(participant, eventListener) {
            participant.addEventListener(eventListener)
            onDispose { participant.removeEventListener(eventListener) }
        }

        // Initial video state check
        LaunchedEffect(participant) {
            val hasVideoStream = participant.streams.any { (_, stream) ->
                stream.kind.equals("video", ignoreCase = true) && stream.track != null
            }
            isVideoEnabled = hasVideoStream
        }

        Box(
            modifier = Modifier.fillMaxWidth()
                .height(200.dp)
                .background(if (isVideoEnabled) Color.DarkGray else Color.Gray)
        ) {
            AndroidView(
                factory = { context ->
                    VideoView(context).apply {
                        for ((_, stream) in participant.streams) {
                            if (stream.kind.equals("video", ignoreCase = true)) {
                                val videoTrack = stream.track as VideoTrack
                                addTrack(videoTrack)
                                isVideoEnabled = true
                            }
                        }
                    }
                },
                update = { videoView ->
                    // Handle video track updates only
                    // The event listener is now managed separately
                    for ((_, stream) in participant.streams) {
                        if (stream.kind.equals(
                                "video",
                                ignoreCase = true
                            ) && stream.track != null
                        ) {
                            val videoTrack = stream.track as VideoTrack
                            videoView.addTrack(videoTrack)
                        }
                    }
                },
                modifier = Modifier.fillMaxSize()
            )

            if (!isVideoEnabled) {
                Box(
                    modifier = Modifier.fillMaxSize()
                        .background(Color.DarkGray),
                    contentAlignment = Alignment.Center
                ) {
                    Text(text = "Camera Off", color = Color.White)
                }
            }

            Box(
                modifier = Modifier.align(Alignment.BottomCenter)
                    .fillMaxWidth()
                    .background(Color(0x99000000))
                    .padding(4.dp)
            ) {
                Text(
                    text = participant.displayName,
                    color = Color.White,
                    modifier = Modifier.align(Alignment.Center)
                )
            }
        }
}

@Composable
fun ParticipantsGrid(
    participants: List<Participant>,
    modifier: Modifier = Modifier
) {
    LazyVerticalGrid(columns = GridCells.Fixed(2),
        verticalArrangement = Arrangement.spacedBy(16.dp),
        horizontalArrangement = Arrangement.spacedBy(16.dp),
        modifier = modifier.fillMaxWidth()
            .padding(8.dp)
    ) {
        items(participants.size) { index ->
            ParticipantVideoView(participant = participants[index])
        }
    }
}
```

Before proceeding, let's understand the two modes of a Live Stream:

<div style={{textAlign: 'center'}}>
<img
  src="https://cdn.videosdk.live/website-resources/docs-resources/ils_mode_demonstration-compressed.jpg"
  alt="ILS Mode Demonstration"
  width="550"
  height="450"
/>
</div>

1. SEND_AND_RECV:

- Designed primarily for the Host or Co-host.
- Allows sending and receiving media.
- Hosts can broadcast their audio/video and interact directly with the audience.

2. RECV_ONLY:

- Tailored for the Audience.
- Enables receiving media shared by the Host.
- Audience members can view and listen but cannot share their own media.

```js title="StreamingMode"
enum class StreamingMode {
    SendAndReceive,
    ReceiveOnly
}
```

### Step 4: Creating Joining Screen

Join screen will serve as a medium to either Create a new Live Stream or join an existing one as a host or a audience.

We will create a simple UI for the Join screen that includes three action buttons for joining or creating a Live Stream:

1. **`Create Stream`**: Lets the user initiate a new Live Stream in SEND_AND_RECV mode, granting full host controls.
2. **`Join as Host`**: Allows the user to join an existing Live Stream using the provided meetingId with the SEND_AND_RECV mode, enabling full host privileges.
3. **`Join as Audience`**: Enables the user to join an existing Live Stream using the provided meetingId with the RECV_ONLY mode, allowing view-only access.

```js title="JoinScreen.kt"
@Composable
fun JoinScreen(
    navController: NavController, context: Context
) {
    val app = context.applicationContext as MainApplication
    val token = app.sampleToken
    Box(
        modifier = Modifier.fillMaxSize()
            .padding(8.dp),
        contentAlignment = Alignment.Center
    ) {
        Column(
            modifier = Modifier.padding(4.dp),
            horizontalAlignment = Alignment.CenterHorizontally,
            verticalArrangement = Arrangement.SpaceEvenly
        ) {
            var input by rememberSaveable { mutableStateOf("") }
            CreateStreamBtn(navController, token)
            Text(text = "OR")
            InputMeetingId(input) { updateInput -> input = updateInput }
            JoinHostBtn(navController, input)
            JoinAudienceBtn(navController, input)
        }
    }
}


@Composable
fun JoinHostBtn(navController: NavController, streamId: String) {
    MyAppButton({
        if (streamId.isNotEmpty()) {
            navController.navigate("stream_screen?streamId=$streamId&mode=${StreamingMode.SendAndReceive.name}")
        }
    }, "Join as Host")
}

@Composable
fun JoinAudienceBtn(navController: NavController, streamId: String) {
    MyAppButton({
        if (streamId.isNotEmpty()) {
            navController.navigate("stream_screen?streamId=$streamId&mode=${StreamingMode.ReceiveOnly.name}")
        }
    }, "Join as Audience")
}

@Composable
fun CreateStreamBtn(navController: NavController, token: String) {
    MyAppButton({
        NetworkManager.createStreamId(token) { streamId ->
            navController.navigate("stream_screen?streamId=$streamId&mode=${StreamingMode.SendAndReceive.name}")
        }
    }, "Create Stream")
}

@Composable
fun InputMeetingId(input: String, onInputChange: (String) -> Unit) {
    OutlinedTextField(value = input,
        onValueChange = onInputChange,
        label = { Text(text = "Enter Stream Id") })
}
```

#### Output

<div style={{ textAlign: 'center' }}>
    <img 
        src='https://cdn.videosdk.live/website-resources/docs-resources/ils_qs_android_join_screen.png' 
        alt="VideoSDK Android Quick Start joining Screen" 
         style={{height: '450px'}}
    />
</div>

### Step 5: Creating StreamId

The `NetworkManager` singleton handles stream creation by making a POST request to the [VideoSDK API](https://docs.videosdk.live/api-reference/realtime-communication/create-room):

- stream Creation: Sends a request to the API with an authorization token to create a stream.
- Response Handling: Extracts the roomId from the response and triggers the `onMeetingCreated` callback.

```js title="NetworkManager"
object NetworkManager {
    fun createStreamId(token: String, onStreamIdCreated: (String) -> Unit) {
        AndroidNetworking.post("https://dev-api.videosdk.live/v2/rooms")
            .addHeaders("Authorization", token)
            .build()
            .getAsJSONObject(object : JSONObjectRequestListener {
                override fun onResponse(response: JSONObject) {
                    try {
                        val streamId = response.getString("roomId")
                        onStreamIdCreated(streamId)
                    } catch (e: JSONException) {
                        e.printStackTrace()
                    }
                }
                override fun onError(anError: ANError) {
                    anError.printStackTrace()
                    Log.d("TAG", "onError: $anError")
                }
            })
    }
}
```

:::note

Don't confuse with Room and stream keyword, both are same thing 😃

:::

### Step 6: Creating Streaming Screen

We will create a simple Streaming screen UI with two main sections:

1. `Header`: Displays the stream ID and current streaming mode at the top of the screen for reference.
2. `ParticipantsGrid`: Shows the list of participants in a grid layout, adjusting dynamically.

:::note

In Step 3, we created the ParticipantsGrid component.

:::

```js title="StreamingScreen.kt"
@Composable
fun StreamingScreen(viewModel: StreamViewModel, navController: NavController,
    streamId: String,
    mode: StreamingMode,
    context: Context
) {
    val app = context.applicationContext as MainApplication
    val isStreamLeft = viewModel.isStreamLeft
    val currentMode = viewModel.currentMode
    val isJoined = viewModel.isJoined

    LaunchedEffect(isStreamLeft) {
        if (isStreamLeft) {
            navController.navigate("join_screen") }
    }

    Column(modifier = Modifier.fillMaxSize()) {
        Header(streamId, currentMode)
        MySpacer()
        ParticipantsGrid(
            participants = viewModel.currentParticipants,
            modifier = Modifier.weight(1f)
        )
        MySpacer()
        MediaControlButtons(
            onJoinClick = { viewModel.initStream(context, app.sampleToken, streamId, mode)},
            onMicClick = { viewModel.toggleMic() },
            onCamClick = { viewModel.toggleWebcam()},
            onModeToggleClick = { viewModel.toggleMode() },
            showMediaControls = currentMode == StreamingMode.SendAndReceive,
            currentMode = currentMode,
            onLeaveClick = { viewModel.leaveStream() },
            isJoined = isJoined )
    }
}
@Composable
fun Header(streamId: String, mode: StreamingMode) {
    val context = LocalContext.current
    val clipboardManager = context.getSystemService(Context.CLIPBOARD_SERVICE) as ClipboardManager

    Box(modifier = Modifier.fillMaxWidth()
                        .padding(8.dp),
        contentAlignment = Alignment.TopStart
    ) {
        Row( modifier = Modifier.fillMaxWidth(),
            horizontalArrangement = Arrangement.SpaceBetween,
            verticalAlignment = Alignment.CenterVertically
        ) {
            Column {
                Row(verticalAlignment = Alignment.CenterVertically) {
                    MyText("StreamID: ", 28.sp)
                    MyText(streamId, 25.sp)
                    IconButton( onClick = {
                            val clip = ClipData.newPlainText("Stream ID", streamId)
                            clipboardManager.setPrimaryClip(clip)
                        })
                    {
                        //get baseline_content_copy_24 icon from Vector Asset
                        Icon( painter = painterResource(R.drawable.baseline_content_copy_24),
                            contentDescription = "Copy Stream ID",
                            modifier = Modifier.size(40.dp).padding(start = 8.dp)
                        )
                    }
                }
                Row {
                    MyText("Mode: ", 20.sp)
                    MyText(mode.name, 18.sp)
                }
            }
        }
    }
}
//...
```

### Step 7: Implementing Mode Switch and Media Toggles

Implement interactive controls to leave the stream, toggle microphone and webcam, and switch between Host (SEND_AND_RECV) and Audience (RECV_ONLY) modes for a seamless experience.

```js title="StreamingScreen.kt"
@Composable
fun MediaControlButtons(
    onJoinClick: () -> Unit,
    onMicClick: () -> Unit,
    onCamClick: () -> Unit,
    onModeToggleClick: () -> Unit,
    onLeaveClick: () -> Unit,
    showMediaControls: Boolean = true,
    currentMode: StreamingMode,
    isJoined: Boolean
) {
    Column( modifier = Modifier.fillMaxWidth()
                        .padding(6.dp),
        horizontalAlignment = Alignment.CenterHorizontally,
        verticalArrangement = Arrangement.spacedBy(8.dp)
    ) {
        Row( modifier = Modifier.fillMaxWidth(),
            horizontalArrangement = Arrangement.SpaceEvenly,
            verticalAlignment = Alignment.CenterVertically
        ) {
            if (!isJoined) {
                MyAppButton(onJoinClick, "Join")
            }
            if (showMediaControls && isJoined) {  // Only show media controls if joined
                MyAppButton(onMicClick, "ToggleMic")
                MyAppButton(onCamClick, "ToggleCam")
            }
        }

        Row( modifier = Modifier.fillMaxWidth(),
            horizontalArrangement = Arrangement.SpaceEvenly,
            verticalAlignment = Alignment.CenterVertically
        ) {
            if (isJoined) {
                MyAppButton(onLeaveClick, "Leave")
                MyAppButton(
                    task = onModeToggleClick,
                    buttonName = if (currentMode == StreamingMode.SendAndReceive)
                        "Switch to Audience"
                    else
                        "Switch to Host"
                )
            }
        }
    }
}
```

### Step 8: Setting Up StreamViewModel

The `StreamViewModel` manages the core functionality of Interactive Live Streaming (ILS), serving as the central state manager:

1. **Stream State Management**

   - Handles stream initialization with appropriate mode (Conference/Audience)
   - Tracks stream lifecycle (joined, left, current mode)

2. **Media Control Integration**

   - Provides microphone toggle (mute/unmute)
   - Controls webcam state (enable/disable)

3. **Mode Switching**
   - Enables seamless transitions between Conference and Audience modes

```js title="StreamViewModel"
class StreamViewModel : ViewModel() {
    private var stream: Meeting? = null
    private var micEnabled by mutableStateOf(true)
    private var webcamEnabled by mutableStateOf(true)
    var isConferenceMode by mutableStateOf(true)
    val currentParticipants = mutableStateListOf<Participant>()

    var localParticipantId by mutableStateOf("")
        private set

    var isStreamLeft by mutableStateOf(false)
        private set

    var currentMode by mutableStateOf(StreamingMode.SendAndReceive)
        private set

    var isJoined by mutableStateOf(false)
        private set

    fun initStream(context: Context, token: String, streamId: String, mode: StreamingMode) {
        VideoSDK.config(token)
        currentMode = mode
        if (stream == null) {
            stream = if (mode.name == StreamingMode.SendAndReceive.name) {
                VideoSDK.initMeeting(
                    context,"54dr-h8c5-hsif", "John Doe",
                    micEnabled, webcamEnabled, null, null, true, null, null
                )
            } else {
                VideoSDK.initMeeting(
                    context, "54dr-h8c5-hsif", "John Doe",
                    micEnabled, webcamEnabled, null, "RECV_ONLY", true, null, null
                )
            }
        }
        stream!!.addEventListener(meetingEventListener)
        stream!!.join()
        isJoined = true
    }

    private val meetingEventListener: MeetingEventListener = object : MeetingEventListener() {
        override fun onMeetingJoined() {
            stream?.let {
                if (it.localParticipant.mode != "RECV_ONLY") {
                    if (!currentParticipants.contains(it.localParticipant)) {
                        currentParticipants.add(it.localParticipant)
                    }
                }
                localParticipantId = it.localParticipant.id
            }
        }

        override fun onMeetingLeft() {
            currentParticipants.clear()
            stream = null
            isStreamLeft = true
        }

        override fun onParticipantJoined(participant: Participant) {
            if (participant.mode != "RECV_ONLY") {
                currentParticipants.add(participant)
            }
        }

        override fun onParticipantLeft(participant: Participant) {
            currentParticipants.remove(participant)
        }

        override fun onParticipantModeChanged(data: JSONObject?) {
            try {
                val participantId = data?.getString("peerId")
                val participant = if (stream?.localParticipant?.id == participantId) {
                    stream?.localParticipant
                } else {
                    stream?.participants?.get(participantId)
                }

                participant?.let {
                    when (it.mode) {
                        "RECV_ONLY" -> {
                            currentParticipants.remove(it)
                        }
                        "SEND_AND_RECV" -> {
                            if (!currentParticipants.contains(it)) {
                                currentParticipants.add(it)
                            } else { }
                        }
                        else -> {}
                    }
                }
            } catch (e: JSONException) {
                e.printStackTrace()
            }
        }
    }

    fun toggleMic() {
        if (micEnabled) stream?.muteMic() else stream?.unmuteMic()
        micEnabled = !micEnabled
    }

    fun toggleWebcam() {
        if (webcamEnabled) stream?.disableWebcam() else stream?.enableWebcam()
        webcamEnabled = !webcamEnabled
    }

    fun leaveStream() {
        currentParticipants.clear()
        stream?.leave()
        stream?.removeAllListeners()
        isStreamLeft = true
        isJoined = false
    }

    fun toggleMode() {
        val newMode = if (currentMode == StreamingMode.SendAndReceive) {
            stream?.disableWebcam()
            stream?.changeMode("RECV_ONLY")
            isConferenceMode = false
            StreamingMode.ReceiveOnly
        } else {
            stream?.changeMode("SEND_AND_RECV")
            isConferenceMode = true
            StreamingMode.SendAndReceive
        }

        // Clear all participants first
        currentParticipants.clear()

        // Wait briefly for mode change to complete
        stream?.let { it ->
            // Add back all non-viewer participants
            it.participants.values.forEach { participant ->
                if (participant.mode != "RECV_ONLY") {
                    currentParticipants.add(participant)
                }
            }

            // Add local participant only if in SEND_AND_RECV mode
            if (newMode == StreamingMode.SendAndReceive) {
                it.localParticipant?.let { localParticipant ->
                    if (!currentParticipants.contains(localParticipant)) {
                        currentParticipants.add(localParticipant)
                    }
                }
                // Re-enable webcam if it was enabled before
                if (webcamEnabled) {
                    it.enableWebcam() }
            }
        }
        currentMode = newMode
    }
}
```

<div style={{ textAlign: 'center' }}>
    <img 
        src='https://cdn.videosdk.live/website-resources/docs-resources/ils_qs_android_send_and_receive_screen.png'  
        alt="VideoSDK Android Quick Start Meeting Screen" 
       style={{height: '450px'}}
    />
</div>

## Final Output

We are done with implementation of customised video calling app in Android using Video SDK. To explore more features go through Basic and Advanced features.

#### Final Output

import ReactPlayer from 'react-player'

<div style={{textAlign: 'center'}}>

<ReactPlayer autoplay muted loop playing controls url="https://cdn.videosdk.live/website-resources/docs-resources/ils_qs_android_screen_recording.mp4" playbackRate={1.8} height="500px" width={"100%"} />

</div>

:::tip
You can checkout the complete [quick start example here](https://github.com/videosdk-live/quickstart/tree/main/interactive-live-streaming/android-ils).
:::


---

---
title: ComposeUI Quick Start with Android
hide_title: false
hide_table_of_contents: false
description: Video SDK enables the opportunity to integrate native IOS, Android & Web SDKs to add live video & audio conferencing to your applications.
sidebar_label: Start a Audio / Video Call (Compose)
pagination_label: Quick Start with Android
keywords:
  - audio calling
  - video calling
  - real-time communication
  - collaboration
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: quick-start-compose-ui
---

# Quick Start for Conference in Android

VideoSDK enables you to embed the video calling feature into your Android application in minutes.

In this quickstart, we are going to explore group calling feature of Video SDK. We will go through step by step guide of integrating video calling with Android Video SDK.

This guide will get you running with the VideoSDK video & audio calling in minutes.

## Prerequisites

Before proceeding, ensure that your development environment meets the following requirements:

- Android Studio Arctic Fox (2020.3.1) or later.
- Android SDK API Level 21 or higher.
- A mobile device that runs Android 5.0 or later.

:::important

One should have a VideoSDK account to generate token.
Visit VideoSDK **[dashboard](https://app.videosdk.live/api-keys)** to generate token

:::

## Getting Started with the Code!

Follow the steps to create the environment necessary to add video calls into your app. Also you can find the code sample for [quickstart here](https://github.com/videosdk-live/quickstart/tree/main/android-rtc/Videosdk_android_compose_quickstart/).

### Create new Android Project

For a new project in **Android Studio**, create a **Phone and Tablet** Android project with an **Empty Activity**.

![VideoSDK Android Quick Start New Project](https://cdn.videosdk.live/docs/images/android/quickstart/android_compose_newProject.jpg )

:::caution
After creating the project, Android Studio automatically starts gradle sync. Ensure that the sync succeeds before you continue.
:::

### Integrate Video SDK

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Maven Central"
groupId={"android-repositories"}
values={[{label: 'Maven Central', value: 'Maven Central'},{label: 'Jitpack', value: 'Jitpack'},]}>

<TabItem value="Maven Central">

```js title="settings.gradle"
dependencyResolutionManagement {
    repositories {
    google()
    mavenCentral()
    maven {url= uri("https://maven.aliyun.com/repository/jcenter")}
  }
}
```

</TabItem>

<TabItem value="Jitpack">

```js title="settings.gradle"
dependencyResolutionManagement{
  repositories {
    google()
    maven { url = uri("https://www.jitpack.io") }
    mavenCentral()
    maven {url= uri("https://maven.aliyun.com/repository/jcenter")}
  }
}
```

</TabItem>

</Tabs>

:::note

You can use imports with Maven Central after rtc-android-sdk version `0.1.12`.

Whether on Maven or Jitpack, the same version numbers always refer to the same SDK.

:::

- Add the following dependency in your app's `app/build.gradle`.

```js title="app/build.gradle"
dependencies {
  implementation ("live.videosdk:rtc-android-sdk:0.1.38")

  // library to perform Network call to generate a meeting id
  implementation ("com.amitshekhar.android:android-networking:1.0.2")

  // other app dependencies
  }
```

:::important

Android SDK compatible with armeabi-v7a, arm64-v8a, x86_64 architectures. If you want to run the application in an emulator, choose ABI x86_64 when creating a device.

:::

### Add permissions into your project

- In `/app/Manifests/AndroidManifest.xml`, add the following permissions.

```xml title="AndroidManifest.xml"
<uses-feature android:name="android.hardware.camera" android:required="false" />
<uses-permission android:name="android.permission.INTERNET"/>
<uses-permission android:name="android.permission.CAMERA"/>
<uses-permission android:name="android.permission.RECORD_AUDIO"/>
<uses-permission android:name="android.permission.MODIFY_AUDIO_SETTINGS"/>
```

:::note

If your project has set `android.useAndroidX=true`, then set `android.enableJetifier=true` in the `gradle.properties` file to migrate your project to AndroidX and avoid duplicate class conflict.

:::

### Structure of the project

Your project structure should look like this.

```jsx title="Project Structure"
app/
├── src/main/
│   ├── java/com/example/app/
│   │   ├── components/          
│   │   ├── screens/            
│   │   ├── navigation/          
│   │   ├── ui/                  
│   │   │   └── theme/           
│   │   ├── model/               
│   │   ├── MainApplication.kt   
│   │   ├── MainActivity.kt      
│   │   └── NetworkClass.kt      
│   ├── res/                     
│   └── AndroidManifest.xml      
├── build.gradle
└── settings.gradle
```


### App Architecture

<center>

<img src='https://cdn.videosdk.live/docs/images/android/quickstart/android_compose_quickstart_app_structure.jpg ' />

</center>

### Step 1: Initialize VideoSDK

1. Create `MainApplication` class which will extend the `android.app.Application`.

- Create field `sampleToken` in `MainApplication` which will hold the generated token from the [VideoSDK dashboard](https://app.videosdk.live/api-keys). This token will use in VideoSDK config as well as in generating meetingId.


```js title="MainApplication.kt"
import android.app.Application
import live.videosdk.rtc.android.VideoSDK

class MainApplication: Application() {

    val sampleToken = "YOUR_TOKEN" //paste your token here

    override fun onCreate() {
        super.onCreate()
        VideoSDK.initialize(applicationContext)
    }
}
```

2. Add `MainApplication` to `AndroidManifest.xml`

```xml title="AndroidManifest.xml"
<application
    android:name=".MainApplication" >
   <!-- ... -->
</application>
```

### Step 2: Managing Permissions

The `MainActivity` is the entry point of the application. It handles permission requests for accessing the camera and microphone.

On creation, it checks if the required permissions (RECORD_AUDIO and CAMERA) are granted.

If not, it requests them. Once permissions are granted, it sets the content view using Jetpack Compose and initializes the MyApp composable, which contains the app's navigation and UI logic.

```js title="MainActivity.kt"
class MainActivity : ComponentActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        checkSelfPermission(REQUESTED_PERMISSIONS[0], PERMISSION_REQ_ID)
        checkSelfPermission(REQUESTED_PERMISSIONS[1], PERMISSION_REQ_ID)

        setContent {
            Videosdk_android_compose_quickstartTheme {
                MyApp(this)
            }
        }
    }

    private fun checkSelfPermission(permission: String, requestCode: Int): Boolean {
        if (ContextCompat.checkSelfPermission(this, permission) !=
            PackageManager.PERMISSION_GRANTED
        ) {
            ActivityCompat.requestPermissions(this,
                REQUESTED_PERMISSIONS, requestCode)
            return false
        }
        return true
    }

    companion object {
        private const val PERMISSION_REQ_ID = 22
        private val REQUESTED_PERMISSIONS = arrayOf(
            Manifest.permission.RECORD_AUDIO,
            Manifest.permission.CAMERA
        )
    }
}

@Composable
fun MyApp(context: Context) {
    NavigationGraph(context = context)
}
```



### Step 3: Setting Up Navigation

The `NavigationGraph` composable manages navigation between the `JoinScreen` and `MeetingScreen` using `NavController`.

```js title="NavigationGraph.kt"
@Composable
fun NavigationGraph(navController: NavHostController = rememberNavController(),context: Context) {
    NavHost(navController = navController, startDestination = "join_screen") {
        composable("join_screen") {
            JoinScreen(navController,context)
        }
        composable("meeting_screen?meetingId={meetingId}") { backStackEntry ->
            val meetingId = backStackEntry.arguments?.getString("meetingId")
            meetingId?.let {
                MeetingScreen(viewModel = MeetingViewModel(),navController, meetingId, context)
            }
        }
    }
}
```

### Step 4: Creating Components

- Before building the individual screens, it's essential to develop reusable composable components that will be used throughout the project.

1. Create a `ReusableComponents.kt` file to organize all reusable components for the project, such as buttons, spacers, and customizable text.

```js title="ReusableComponents.kt"
@Composable
fun MyAppButton(task: () -> Unit, buttonName: String) {
    Button(onClick = task) {
        Text(text = buttonName)
    }
}
@Composable
fun MySpacer() {
    Spacer(
        modifier = Modifier
            .fillMaxWidth()
            .height(1.dp)
            .background(color = Color.Gray))}
@Composable
fun MyText(text: String, fontSize: TextUnit = 23.sp) {
    Text(
        text = text,
        fontSize = fontSize,
        fontWeight = FontWeight.Normal,
        modifier = Modifier.padding(4.dp),
        style = MaterialTheme.typography.bodyMedium.copy(fontSize = 16.sp),
        color = MaterialTheme.colorScheme.onSurface.copy(alpha = 0.7f)
    )}
```
2. Create a `ParticipantVideoView.kt` file that includes two composable functions: `ParticipantVideoView` for rendering individual participant video streams, and `ParticipantsGrid` for displaying a grid of participant videos.

:::info

- Here the participant's video is displayed using `VideoView`. To know more about `VideoView`, please visit [here](/android/guide/video-and-audio-calling-api-sdk/render-media/display-video/understand-videoView-component)
- `VideoView` is a custom View. Since Jetpack Compose does not natively support traditional `View` objects, we need to integrate the `VideoView` into the Compose layout using the `AndroidView` wrapper.
- `AndroidView()` is a composable that can be used to add Android views inside a @Composable function.

:::

```js title="ParticipantVideoView.kt"
@Composable
fun ParticipantVideoView(
    participant: Participant
) {
    var isVideoEnabled by remember { mutableStateOf(false) }

    LaunchedEffect(participant) {
        isVideoEnabled = participant.streams.any { (_, stream) ->
            stream.kind.equals("video", ignoreCase = true) && stream.track != null
        }
    }
    Box(
        modifier = Modifier
            .fillMaxWidth()
            .height(200.dp)
            .background(if (isVideoEnabled) Color.DarkGray else Color.Gray)
    ) {
        AndroidView(
            factory = { context ->
                VideoView(context).apply {
                    for ((_, stream) in participant.streams) {
                        if (stream.kind.equals("video", ignoreCase = true)) {
                            val videoTrack = stream.track as VideoTrack
                            addTrack(videoTrack)
                            isVideoEnabled = true
                        }
                    }
                }
            },
            update = { videoView ->
                participant.addEventListener(object : ParticipantEventListener() {
                    override fun onStreamEnabled(stream: Stream) {
                        if (stream.kind.equals("video", ignoreCase = true)) {
                            val videoTrack = stream.track as VideoTrack
                            videoView.addTrack(videoTrack)
                            isVideoEnabled = true
                        }
                    }

                    override fun onStreamDisabled(stream: Stream) {
                        if (stream.kind.equals("video", ignoreCase = true)) {
                            videoView.removeTrack()
                            isVideoEnabled = false
                        }
                    }
                })
            },
            onRelease = { videoView ->
                videoView.releaseSurfaceViewRenderer()
            },
            modifier = Modifier.fillMaxSize()
        )

        if (!isVideoEnabled) {
            Box(
                modifier = Modifier
                    .fillMaxSize()
                    .background(Color.DarkGray),
                contentAlignment = Alignment.Center
            ) {
                Text(
                    text = "Camera Off",
                    color = Color.White
                )
            }
        }

        Box(
            modifier = Modifier
                .align(Alignment.BottomCenter)
                .fillMaxWidth()
                .background(Color(0x99000000))
                .padding(4.dp)
        ) {
            Text(
                text = participant.displayName,
                color = Color.White,
                modifier = Modifier.align(Alignment.Center)
            )
        }
    }
}
@Composable
fun ParticipantsGrid(
    participants: List<Participant>,
    modifier: Modifier = Modifier
) {
    LazyVerticalGrid(
        columns = GridCells.Fixed(2),
        verticalArrangement = Arrangement.spacedBy(16.dp),
        horizontalArrangement = Arrangement.spacedBy(16.dp),
        modifier = modifier
            .fillMaxWidth()
            .padding(8.dp)
    ) {
        items(participants.size) { index ->
            ParticipantVideoView(
                participant = participants[index],
            )
        }
    }
}
```


### Step 5: Creating Joining Screen

We will create a simple Join screen UI that supports two primary roles:

- Create Meeting: Starts a new meeting.
- Join Meeting: Enter a Meeting ID to join an existing meeting.

#### Creating UI

The Joining screen will include :

1. **Create Button** - This button will create a new meeting for you.
2. **TextField for Meeting Id** - This text field will contain the meeting Id you want to join.
3. **Join Button** - This button will join the meeting with `meetingId` you provided.

```js title="JoinScreen.kt"
@Composable
fun JoinScreen(
    navController: NavController, context: Context
) {
    val app = context.applicationContext as MainApplication
    val token = app.sampleToken
    Box(
        modifier = Modifier
            .fillMaxSize()
            .padding(8.dp),
        contentAlignment = Alignment.Center
    ) {
        Column(
            modifier = Modifier.padding(4.dp),
            horizontalAlignment = Alignment.CenterHorizontally,
            verticalArrangement = Arrangement.SpaceEvenly
        ) {
            var input by rememberSaveable { mutableStateOf("") }
            CreateMeetingBtn(navController, token)
            Text(text = "OR")
            InputMeetingId(input) { updateInput ->
                input = updateInput
            }
            JoinMeetingBtn(navController, input)
        }
    }
}

@Composable
fun CreateMeetingBtn(navController: NavController, token: String) {
    MyAppButton({
        NetworkManager.createMeetingId(token) { meetingId ->
            navController.navigate("meeting_screen?meetingId=$meetingId")
        }
    }, "Create Meeting")
}

@Composable
fun InputMeetingId(input: String, onInputChange: (String) -> Unit) {
    OutlinedTextField(value = input,
        onValueChange = onInputChange,
        label = { Text(text = "Enter Meeting Id") })
}

@Composable
fun JoinMeetingBtn(navController: NavController, meetingId: String) {
    MyAppButton({
        if (meetingId.isNotEmpty()) {
            navController.navigate("meeting_screen?meetingId=$meetingId")
        }
    }, "Join Meeting")
}
```

#### Output

<div style={{ textAlign: 'center' }}>
    <img 
        src="https://cdn.videosdk.live/docs/images/android/quickstart/android_compose-join-screen.jpg" 
        alt="VideoSDK Android Quick Start joining Screen" 
         style={{height: '450px'}}
    />
</div>

### Step 6: Creating MeetingId

The `NetworkManager` singleton handles meeting creation by making a POST request to the [VideoSDK API](https://docs.videosdk.live/api-reference/realtime-communication/create-room):

- Meeting Creation: Sends a request to the API with an authorization token to create a meeting.
- Response Handling: Extracts the roomId from the response and triggers the `onMeetingCreated` callback.


```js title="NetworkManager.kt"
object NetworkManager {
    fun createMeetingId(token: String, onMeetingIdCreated: (String) -> Unit) {
        AndroidNetworking.post("https://api.videosdk.live/v2/rooms")
            .addHeaders("Authorization", token)
            .build()
            .getAsJSONObject(object : JSONObjectRequestListener {
                override fun onResponse(response: JSONObject) {
                    try {
                        val meetingId = response.getString("roomId")
                        onMeetingIdCreated(meetingId)
                    } catch (e: JSONException) {
                        e.printStackTrace()
                    }
                }

                override fun onError(anError: ANError) {
                    anError.printStackTrace()
                    Log.d("TAG", "onError: $anError")
                }
            })
    }
}
```

:::note

Don't confuse with Room and Meeting keyword, both are same thing 😃

:::

### Step 7: Creating Meeting Screen

We will create a simple Meeting screen UI with two main sections:

- Participants' Video Streams: Displays video feeds of meeting participants.
- Media Control Buttons: Includes buttons to control the mic, camera, and leave the meeting.

#### Creating UI

The `MeetingScreen` composable is the main UI for a video call meeting, handling meeting details and user actions.

- The `MeetingScreen` composable is organized into three sections, each serving a specific purpose:

1. `Header`: Displays the meeting ID at the top of the screen for reference.
2. `ParticipantsGrid`: Shows the list of participants in a grid layout, adjusting dynamically.
3. `MediaControlButtons`: A set of buttons to control the microphone, camera, and leave the meeting.


```js title="MeetingScreen.kt"
@Composable
fun MeetingScreen(viewModel: MeetingViewModel, navController: NavController, meetingId: String, context: Context) {

    val app = context.applicationContext as MainApplication
    val isMeetingLeft = viewModel.isMeetingLeft

    LaunchedEffect(isMeetingLeft) {
        if (isMeetingLeft) {
            navController.navigate("join_screen")
        }
    }
    Column(modifier = Modifier.fillMaxSize()) {
        Header(meetingId)
        MySpacer()
        ParticipantsGrid(viewModel.participants, Modifier.weight(1f))
        MySpacer()
        MediaControlButtons(
            onJoinClick = {
                viewModel.initMeeting(context, app.sampleToken, meetingId)
            },
            onMicClick = { viewModel.toggleMic() },
            onCamClick = { viewModel.toggleWebcam() },
            onLeaveClick = {
                viewModel.leaveMeeting()
            }
        )
    }
}
@Composable
fun Header(meetingId: String) {
    Box(
        modifier = Modifier
            .fillMaxWidth()
            .padding(8.dp),
        contentAlignment = Alignment.TopStart
    ) {
        Row {
            MyText("MeetingID: ", 28.sp)
            MyText(meetingId, 25.sp)
        }
    }
}
@Composable
fun MediaControlButtons(onJoinClick:()->Unit,onMicClick: () -> Unit, onCamClick: () -> Unit, onLeaveClick: () -> Unit) {
    Row(
        modifier = Modifier
            .fillMaxWidth()
            .padding(6.dp),
        verticalAlignment = Alignment.CenterVertically,
        horizontalArrangement = Arrangement.SpaceAround
    ) {
        MyAppButton(onJoinClick,"Join")
        MyAppButton(onMicClick,"ToggleMic")
        MyAppButton(onCamClick,"ToggleCam")
        MyAppButton(onLeaveClick,"Leave")
    }
}
```

### Step 8: Setting Up MeetingViewModel

The `MeetingViewModel` manages the meeting state, handles participants, and controls microphone and camera settings to ensure a smooth video call experience.

Managing Meeting State and Media Control:

1. Meeting Initialization: Initializes the meeting with the VideoSDK and adds an event listener.
2. Participant Management: Tracks participants, adding/removing them as they join/leave.
3. Media Control: Toggles microphone and webcam states.
4. Leave Meeting: Allows users to leave the meeting.

```js title="MeetingViewModel.kt"
class MeetingViewModel : ViewModel() {

    private var meeting: Meeting? = null
    private var micEnabled by mutableStateOf(true)
    private var webcamEnabled by mutableStateOf(true)
    val participants = mutableStateListOf<Participant>()

    //used in MeetingScreen to handle navigation
    var isMeetingLeft by mutableStateOf(false)
        private set

    fun initMeeting(context: Context, token: String, meetingId: String ) {
        VideoSDK.config(token)
        if(meeting==null){
            meeting = VideoSDK.initMeeting(
                context, meetingId, "John Doe",
                micEnabled, webcamEnabled, null, null, true, null, null)
        }
        meeting!!.addEventListener(meetingEventListener)
        meeting!!.join()
    }

    private val meetingEventListener: MeetingEventListener = object : MeetingEventListener() {
        override fun onMeetingJoined() {
            Log.d("#meeting", "onMeetingJoined()")
            meeting?.let { participants.add(it.localParticipant) }
        }
        override fun onMeetingLeft() {
            Log.d("#meeting", "onMeetingLeft()")
            meeting = null
            isMeetingLeft = true
        }

        override fun onParticipantJoined(participant: Participant) {
                participants.add(participant)
        }

        override fun onParticipantLeft(participant: Participant) {
            participants.remove(participant)
        }
    }

    fun toggleMic() {
        if (micEnabled) {
            meeting?.muteMic()
        } else {
            meeting?.unmuteMic()
        }
        micEnabled = !micEnabled
    }

    fun toggleWebcam() {
        if (webcamEnabled) {
            meeting?.disableWebcam()
        } else {
            meeting?.enableWebcam()
        }
        webcamEnabled = !webcamEnabled
    }

    fun leaveMeeting() {
        meeting?.leave()
    }
}
```

<div style={{ textAlign: 'center' }}>
    <img 
        src="https://cdn.videosdk.live/docs/images/android/quickstart/android_compose-meeting-screen.jpg" 
        alt="VideoSDK Android Quick Start Meeting Screen" 
       style={{height: '450px'}}
    />
</div>



## Final Output

We are done with implementation of customised video calling app in Android using Video SDK. To explore more features go through Basic and Advanced features.

import ReactPlayer from 'react-player'

<div style={{textAlign: 'center'}}>

<ReactPlayer muted controls url="https://cdn.videosdk.live/docs/images/android/quickstart/android_compose_quickstart.mp4 " height="500px" width={"100%"} />

</div>

:::tip
You can checkout the complete [quick start example here](https://github.com/videosdk-live/quickstart/tree/main/android-rtc/Videosdk_android_compose_quickstart/).
:::


---

---
title: Quick Start with Android
hide_title: false
hide_table_of_contents: false
description: Video SDK enables the opportunity to integrate native IOS, Android & Web SDKs to add live video & audio conferencing to your applications.
sidebar_label: Start a Audio / Video Call (XML)
pagination_label: Quick Start with Android
keywords:
  - audio calling
  - video calling
  - real-time communication
  - collaboration
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: quick-start
---

# Quick Start for Conference in Android

<ReactPlayer controls url="https://www.youtube.com/watch?v=Kj7jS3dbJFA" height="500px" width={"100%"} />

VideoSDK enables you to embed the video calling feature into your Android application in minutes.

In this quickstart, we are going to explore group calling feature of Video SDK. We will go through step by step guide of integrating video calling with Android Video SDK.

This guide will get you running with the VideoSDK video & audio calling in minutes.

## Prerequisites

Before proceeding, ensure that your development environment meets the following requirements:

- Java Development Kit.
- Android Studio 3.0 or later.
- Android SDK API Level 21 or higher.
- A mobile device that runs Android 5.0 or later.

:::important

One should have a VideoSDK account to generate token.
Visit VideoSDK **[dashboard](https://app.videosdk.live/api-keys)** to generate token

:::

## Getting Started with the Code!

Follow the steps to create the environment necessary to add video calls into your app. Also you can find the code sample for [quickstart here](https://github.com/videosdk-live/quickstart/tree/main/android-rtc).

### Create new Android Project

For a new project in **Android Studio**, create a **Phone and Tablet** Android project with an **Empty Activity**.

![VideoSDK Android Quick Start New Project](/img/quick-start/android_newProject.png)

:::caution
After creating the project, Android Studio automatically starts gradle sync. Ensure that the sync succeeds before you continue.
:::

### Integrate Video SDK

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Maven Central"
groupId={"android-repositories"}
values={[{label: 'Maven Central', value: 'Maven Central'},{label: 'Jitpack', value: 'Jitpack'},]}>

<TabItem value="Maven Central">

```js title="settings.gradle"
dependencyResolutionManagement{
  repositories {
    // ...
    google()
    mavenCentral()
    maven { url "https://maven.aliyun.com/repository/jcenter" }
  }
}
```

</TabItem>

<TabItem value="Jitpack">

```js title="settings.gradle"
dependencyResolutionManagement{
  repositories {
    // ...
    google()
    maven { url 'https://jitpack.io' }
    mavenCentral()
    maven { url "https://maven.aliyun.com/repository/jcenter" }
  }
}
```

</TabItem>

</Tabs>

:::note

You can use imports with Maven Central after rtc-android-sdk version `0.1.12`.

Whether on Maven or Jitpack, the same version numbers always refer to the same SDK.

:::

- Add the following dependency in your app's `app/build.gradle`.

```js title="app/build.gradle"
dependencies {
  implementation 'live.videosdk:rtc-android-sdk:0.1.38'

  // library to perform Network call to generate a meeting id
  implementation 'com.amitshekhar.android:android-networking:1.0.2'

  // other app dependencies
  }
```

:::important

Android SDK compatible with armeabi-v7a, arm64-v8a, x86_64 architectures. If you want to run the application in an emulator, choose ABI x86_64 when creating a device.

:::

### Add permissions into your project

- In `/app/Manifests/AndroidManifest.xml`, add the following permissions after `</application>`.

```xml title="AndroidManifest.xml"
<uses-permission android:name="android.permission.RECORD_AUDIO" />
<uses-permission android:name="android.permission.MODIFY_AUDIO_SETTINGS" />
<uses-permission android:name="android.permission.INTERNET" />
<uses-permission android:name="android.permission.CAMERA" />
```

:::note

If your project has set `android.useAndroidX=true`, then set `android.enableJetifier=true` in the `gradle.properties` file to migrate your project to AndroidX and avoid duplicate class conflict.

:::

### Structure of the project

Your project structure should look like this.

```jsx title="Project Structure"
   app
   ├── java
   │    ├── packagename
   │         ├── JoinActivity
   │         ├── MainApplication
   │         ├── MeetingActivity
   │         ├── ParticipantAdapter
   ├── res
   │    ├── layout
   │    │    ├── activity_join.xml
   │    │    ├── activity_meeting.xml
   │    │    ├── item_remote_peer.xml
```

:::note

You have to set JoinActivity as Launcher activity.

:::

### App Architecture

<center>

<img src='https://cdn.videosdk.live/website-resources/docs-resources/android_quickstart_app_structure.png' />

</center>

### Step 1: Initialize VideoSDK

1. Create `MainApplication` class which will extend the `android.app.Application`.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js title="MainApplication.kt"
import live.videosdk.rtc.android.VideoSDK

class MainApplication : Application() {
  override fun onCreate() {
      super.onCreate()
      //highlight-next-line
      VideoSDK.initialize(applicationContext)
  }
}
```

</TabItem>

<TabItem value="Java">

```java title="MainApplication.java"
import android.app.Application;
import live.videosdk.rtc.android.VideoSDK;

public class MainApplication extends Application {
  @Override
  public void onCreate() {
    super.onCreate();
    //highlight-next-line
    VideoSDK.initialize(getApplicationContext());
  }
}
```

</TabItem>

</Tabs>

2. Add `MainApplication` to `AndroidManifest.xml`

```xml title="AndroidManifest.xml"
<application
    android:name=".MainApplication" >
   <!-- ... -->
</application>
```

### Step 2: Creating Joining Screen

Create a new Activity named `JoinActivity`.

#### Creating UI

The Joining screen will include :

1. **Create Button** - This button will create a new meeting for you.
2. **TextField for Meeting Id** - This text field will contain the meeting Id you want to join.
3. **Join Button** - This button will join the meeting with `meetingId` you provided.

In `/app/res/layout/activity_join.xml` file, replace the content with the following.

```xml title="activity_join.xml"
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:gravity="center"
    android:orientation="vertical"
    tools:context=".JoinActivity">

    <Button
        android:id="@+id/btnCreateMeeting"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_marginBottom="16dp"
        android:text="Create Meeting" />

    <TextView
        style="@style/TextAppearance.AppCompat.Headline"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="OR" />

    <com.google.android.material.textfield.TextInputLayout
        style="@style/Widget.MaterialComponents.TextInputLayout.OutlinedBox"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_marginVertical="16dp"
        android:hint="Enter Meeting ID">

        <EditText
            android:id="@+id/etMeetingId"
            android:layout_width="250dp"
      android:layout_height="wrap_content" />
    </com.google.android.material.textfield.TextInputLayout>

    <Button
        android:id="@+id/btnJoinMeeting"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Join Meeting" />
</LinearLayout>
```

#### Integration of Create Meeting API

1. Create field `sampleToken` in `JoinActivity` which will hold the generated token from the [VideoSDK dashboard](https://app.videosdk.live/api-keys). This token will use in VideoSDK config as well as in generating meetingId.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js title="JoinActivity.kt"
class JoinActivity : AppCompatActivity() {

  //highlight-next-line
  //Replace with the token you generated from the VideoSDK Dashboard
  private var sampleToken = ""

  override fun onCreate(savedInstanceState: Bundle?) {
    //...
  }
}
```

</TabItem>

<TabItem value="Java">

```java title="JoinActivity.java"
public class JoinActivity extends AppCompatActivity {

  //highlight-next-line
  //Replace with the token you generated from the VideoSDK Dashboard
  private String sampleToken ="";

  @Override
  protected void onCreate(Bundle savedInstanceState) {
    //...
  }
}
```

</TabItem>

</Tabs>

2. On **Join Button** `onClick` events, we will naviagte to `MeetingActivity` with token and meetingId.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js title="JoinActivity.kt"
class JoinActivity : AppCompatActivity() {

   //Replace with the token you generated from the VideoSDK Dashboard
   private var sampleToken = ""

   override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_join)

        val btnCreate = findViewById<Button>(R.id.btnCreateMeeting)
        val btnJoin = findViewById<Button>(R.id.btnJoinMeeting)
        val etMeetingId = findViewById<EditText>(R.id.etMeetingId)

        btnCreate.setOnClickListener { v: View? ->
            createMeeting(sampleToken)
        }
        btnJoin.setOnClickListener { v: View? ->
            val intent = Intent(this@JoinActivity, MeetingActivity::class.java)
            intent.putExtra("token", sampleToken)
            intent.putExtra("meetingId", etMeetingId.text.toString())
            startActivity(intent)
        }
    }

    private fun createMeeting(token: String) {
      // we will explore this method in the next step
    }
}
```

</TabItem>

<TabItem value="Java">

```java title="JoinActivity.java"
public class JoinActivity extends AppCompatActivity {

  //Replace with the token you generated from the VideoSDK Dashboard
  private String sampleToken ="";

  @Override
  protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_join);

    final Button btnCreate = findViewById(R.id.btnCreateMeeting);
    final Button btnJoin = findViewById(R.id.btnJoinMeeting);
    final EditText etMeetingId = findViewById(R.id.etMeetingId);

    btnCreate.setOnClickListener(v -> {
      createMeeting(sampleToken);
    });

    btnJoin.setOnClickListener(v -> {
      Intent intent = new Intent(JoinActivity.this, MeetingActivity.class);
      intent.putExtra("token", sampleToken);
      intent.putExtra("meetingId", etMeetingId.getText().toString());
      startActivity(intent);
    });
  }

  private void createMeeting(String token) {
    // we will explore this method in the next step
  }
}
```

</TabItem>

</Tabs>

3. For **Create Button**, under `createMeeting` method we will generate meetingId by calling API and navigate to `MeetingActivity` with token and generated meetingId.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js title="JoinActivity.kt"
class JoinActivity : AppCompatActivity() {
  //...onCreate
 private fun createMeeting(token: String) {
    // we will make an API call to VideoSDK Server to get a roomId
    AndroidNetworking.post("https://api.videosdk.live/v2/rooms")
      .addHeaders("Authorization", token) //we will pass the token in the Headers
      .build()
      .getAsJSONObject(object : JSONObjectRequestListener {
          override fun onResponse(response: JSONObject) {
              try {
                  // response will contain `roomId`
                  val meetingId = response.getString("roomId")

                  // starting the MeetingActivity with received roomId and our sampleToken
                  val intent = Intent(this@JoinActivity, MeetingActivity::class.java)
                  intent.putExtra("token", sampleToken)
                  intent.putExtra("meetingId", meetingId)
                  startActivity(intent)
              } catch (e: JSONException) {
                  e.printStackTrace()
              }
          }

          override fun onError(anError: ANError) {
              anError.printStackTrace()
                    Toast.makeText(
                        this@JoinActivity, anError.message,
                        Toast.LENGTH_SHORT
                    ).show()
          }
      })
  }
}
```

</TabItem>

<TabItem value="Java">

```java title="JoinActivity.java"
public class JoinActivity extends AppCompatActivity {
  //...onCreate

  private void createMeeting(String token) {
      // we will make an API call to VideoSDK Server to get a roomId
      AndroidNetworking.post("https://api.videosdk.live/v2/rooms")
        .addHeaders("Authorization", token) //we will pass the token in the Headers
        .build()
        .getAsJSONObject(new JSONObjectRequestListener() {
            @Override
            public void onResponse(JSONObject response) {
                try {
                    // response will contain `roomId`
                    final String meetingId = response.getString("roomId");

                    // starting the MeetingActivity with received roomId and our sampleToken
                    Intent intent = new Intent(JoinActivity.this, MeetingActivity.class);
                    intent.putExtra("token", sampleToken);
                    intent.putExtra("meetingId", meetingId);
                    startActivity(intent);
                } catch (JSONException e) {
                    e.printStackTrace();
                }
            }

            @Override
            public void onError(ANError anError) {
                anError.printStackTrace();
                Toast.makeText(JoinActivity.this, anError.getMessage(), Toast.LENGTH_SHORT).show();
            }
        });
  }
}
```

</TabItem>

</Tabs>

:::note

Don't confuse with Room and Meeting keyword, both are same thing 😃

:::

4. Our App is completely based on audio and video commutation, that's why we need to ask for runtime permissions `RECORD_AUDIO` and `CAMERA`. So, we will implement permission logic on `JoinActivity`.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js title="JoinActivity.kt"
class JoinActivity : AppCompatActivity() {
    companion object {
        private const val PERMISSION_REQ_ID = 22
        private val REQUESTED_PERMISSIONS = arrayOf(
            Manifest.permission.RECORD_AUDIO,
            Manifest.permission.CAMERA
        )
    }

  private fun checkSelfPermission(permission: String, requestCode: Int): Boolean {
        if (ContextCompat.checkSelfPermission(this, permission) !=
            PackageManager.PERMISSION_GRANTED)
        {
            ActivityCompat.requestPermissions(this, REQUESTED_PERMISSIONS, requestCode)
            return false
        }
        return true
    }

  override fun onCreate(savedInstanceState: Bundle?) {
    //... button listeneres
    //highlight-start
    checkSelfPermission(REQUESTED_PERMISSIONS[0], PERMISSION_REQ_ID)
    checkSelfPermission(REQUESTED_PERMISSIONS[1], PERMISSION_REQ_ID)
    //highlight-end
  }
}
```

</TabItem>

<TabItem value="Java">

```java title="JoinActivity.java"
public class JoinActivity extends AppCompatActivity {
  private static final int PERMISSION_REQ_ID = 22;

  private static final String[] REQUESTED_PERMISSIONS = {
    Manifest.permission.RECORD_AUDIO,
    Manifest.permission.CAMERA
  };

  private boolean checkSelfPermission(String permission, int requestCode) {
    if (ContextCompat.checkSelfPermission(this, permission) != PackageManager.PERMISSION_GRANTED) {
      ActivityCompat.requestPermissions(this, REQUESTED_PERMISSIONS, requestCode);
      return false;
    }
    return true;
  }

  @Override
  protected void onCreate(Bundle savedInstanceState) {
    //... button listeneres
    //highlight-start
    checkSelfPermission(REQUESTED_PERMISSIONS[0], PERMISSION_REQ_ID);
    checkSelfPermission(REQUESTED_PERMISSIONS[1], PERMISSION_REQ_ID);
    //highlight-end
  }
}
```

</TabItem>

</Tabs>

#### Output

<div style={{textAlign: 'center'}}>

![VideoSDK Android Quick Start joining Screen](/img/quick-start/android-join-screen.jpg)

</div>

### Step 3: Creating Meeting Screen

Create a new Activity named `MeetingActivity`.

#### Creating the UI for Meeting Screen

In `/app/res/layout/activity_meeting.xml` file, replace the content with the following.

```xml title="activty_meeting.xml"
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:gravity="center"
    android:orientation="vertical"
    tools:context=".MeetingActivity">

    <TextView
        android:id="@+id/tvMeetingId"
        style="@style/TextAppearance.AppCompat.Display1"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Meeting Id" />

    <androidx.recyclerview.widget.RecyclerView
        android:id="@+id/rvParticipants"
        android:layout_width="match_parent"
        android:layout_height="0dp"
        android:layout_weight="1" />

    <LinearLayout
        android:layout_width="wrap_content"
        android:layout_height="wrap_content">

        <Button
            android:id="@+id/btnMic"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:layout_marginVertical="8dp"
            android:text="Mic"/>

        <Button
            android:id="@+id/btnLeave"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:layout_marginVertical="8dp"
            android:layout_marginHorizontal="8dp"
            android:text="Leave"/>

        <Button
            android:id="@+id/btnWebcam"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:layout_marginVertical="8dp"
            android:text="Webcam" />

    </LinearLayout>

</LinearLayout>
```

#### Initializing the Meeting

After getting token and meetigId from `JoinActivity`,

1. Configure **VideoSDK** with token.
2. Initialize the meeting with required params such as `meetingId`, `participantName`, `micEnabled`, `webcamEnabled` and more.
3. Add `MeetingEventListener` for listening events such as **Meeting Join/Left** and **Participant Join/Left**.
4. Join the room with `meeting.join()` method.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js title="MeetingActivity.kt"
class MeetingActivity : AppCompatActivity() {
  // declare the variables we will be using to handle the meeting
  private var meeting: Meeting? = null
  private var micEnabled = true
  private var webcamEnabled = true

  override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    setContentView(R.layout.activity_meeting)

    val token = intent.getStringExtra("token")
    val meetingId = intent.getStringExtra("meetingId")
    val participantName = "John Doe"

    //highlight-next-line
    // 1. Configuration VideoSDK with Token
    VideoSDK.config(token)

    //highlight-next-line
    // 2. Initialize VideoSDK Meeting
    meeting = VideoSDK.initMeeting(
      this@MeetingActivity, meetingId, participantName,
      micEnabled, webcamEnabled, null, null, false, null, null)

    //highlight-next-line
    // 3. Add event listener for listening upcoming events
    meeting!!.addEventListener(meetingEventListener)

    //highlight-next-line
    //4. Join VideoSDK Meeting
    meeting!!.join()

    (findViewById<View>(R.id.tvMeetingId) as TextView).text = meetingId
  }

  //highlight-next-line
  // creating the MeetingEventListener
  private val meetingEventListener: MeetingEventListener = object : MeetingEventListener() {
    override fun onMeetingJoined() {
      Log.d("#meeting", "onMeetingJoined()")
    }

    override fun onMeetingLeft() {
      Log.d("#meeting", "onMeetingLeft()")
      meeting = null
      if (!isDestroyed) finish()
    }

    override fun onParticipantJoined(participant: Participant) {
      Toast.makeText(
        this@MeetingActivity, participant.displayName + " joined",
        Toast.LENGTH_SHORT
      ).show()
    }

    override fun onParticipantLeft(participant: Participant) {
      Toast.makeText(
         this@MeetingActivity, participant.displayName + " left",
         Toast.LENGTH_SHORT
      ).show()
    }
  }
}
```

</TabItem>

<TabItem value="Java">

```java title="MeetingActivity.java"
public class MeetingActivity extends AppCompatActivity {
  // declare the variables we will be using to handle the meeting
  private Meeting meeting;
  private boolean micEnabled = true;
  private boolean webcamEnabled = true;

  @Override
  protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_meeting);

    final String token = getIntent().getStringExtra("token");
    final String meetingId = getIntent().getStringExtra("meetingId");
    final String participantName = "John Doe";

    //highlight-next-line
    // 1. Configuration VideoSDK with Token
    VideoSDK.config(token);

    //highlight-next-line
    // 2. Initialize VideoSDK Meeting
    meeting = VideoSDK.initMeeting(
            MeetingActivity.this, meetingId, participantName,
            micEnabled, webcamEnabled, null, null, false, null, null);

    //highlight-next-line
    // 3. Add event listener for listening upcoming events
    meeting.addEventListener(meetingEventListener);

    //highlight-next-line
    //4. Join VideoSDK Meeting
    meeting.join();

    ((TextView)findViewById(R.id.tvMeetingId)).setText(meetingId);
  }

  //highlight-next-line
  // creating the MeetingEventListener
  private final MeetingEventListener meetingEventListener = new MeetingEventListener() {
    @Override
    public void onMeetingJoined() {
      Log.d("#meeting", "onMeetingJoined()");
    }

    @Override
    public void onMeetingLeft() {
      Log.d("#meeting", "onMeetingLeft()");
      meeting = null;
      if (!isDestroyed()) finish();
    }

    @Override
    public void onParticipantJoined(Participant participant) {
      Toast.makeText(MeetingActivity.this, participant.getDisplayName() + " joined", Toast.LENGTH_SHORT).show();
    }

    @Override
    public void onParticipantLeft(Participant participant) {
      Toast.makeText(MeetingActivity.this, participant.getDisplayName() + " left", Toast.LENGTH_SHORT).show();
    }
  };
}
```

</TabItem>

</Tabs>

### Step 4: Handle Local Participant Media

After successfully enter into the meeting, it's time to **enable/disable** local participant(You) webcam and mic, for that we will use `Meeting` class method `enableWebcam` / `disableWebcam` for camera and `muteMic` / `unmuteMic` for mic.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js title="MeetingActivity.kt"
class MeetingActivity : AppCompatActivity() {
  override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    setContentView(R.layout.activity_meeting)
    //...Meeting Setup is Here

    // actions
    setActionListeners()
  }

  private fun setActionListeners() {
    // toggle mic
    findViewById<View>(R.id.btnMic).setOnClickListener { view: View? ->
      if (micEnabled) {
        // this will mute the local participant's mic
        //highlight-next-line
        meeting!!.muteMic()
        Toast.makeText(this@MeetingActivity, "Mic Muted", Toast.LENGTH_SHORT).show()
      } else {
        // this will unmute the local participant's mic
        //highlight-next-line
        meeting!!.unmuteMic()
        Toast.makeText(this@MeetingActivity, "Mic Enabled", Toast.LENGTH_SHORT).show()
      }
        micEnabled=!micEnabled
    }

    // toggle webcam
    findViewById<View>(R.id.btnWebcam).setOnClickListener { view: View? ->
      if (webcamEnabled) {
        // this will disable the local participant webcam
        //highlight-next-line
        meeting!!.disableWebcam()
        Toast.makeText(this@MeetingActivity, "Webcam Disabled", Toast.LENGTH_SHORT).show()
      } else {
        // this will enable the local participant webcam
        //highlight-next-line
        meeting!!.enableWebcam()
        Toast.makeText(this@MeetingActivity, "Webcam Enabled", Toast.LENGTH_SHORT).show()
      }
       webcamEnabled=!webcamEnabled
    }

    // leave meeting
    findViewById<View>(R.id.btnLeave).setOnClickListener { view: View? ->
      // this will make the local participant leave the meeting
      //highlight-next-line
      meeting!!.leave()
    }
  }
}
```

</TabItem>

<TabItem value="Java">

```java title="MeetingActivity.java"
public class MeetingActivity extends AppCompatActivity {
  @Override
  protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_meeting);
    //...Meeting Setup is Here

    // actions
    setActionListeners();
  }

  private void setActionListeners() {
    // toggle mic
    findViewById(R.id.btnMic).setOnClickListener(view -> {
      if (micEnabled) {
        // this will mute the local participant's mic
        //highlight-next-line
        meeting.muteMic();
        Toast.makeText(MeetingActivity.this, "Mic Disabled", Toast.LENGTH_SHORT).show();
      } else {
        // this will unmute the local participant's mic
        //highlight-next-line
        meeting.unmuteMic();
        Toast.makeText(MeetingActivity.this, "Mic Enabled", Toast.LENGTH_SHORT).show();
      }
      micEnabled=!micEnabled;
    });

    // toggle webcam
    findViewById(R.id.btnWebcam).setOnClickListener(view -> {
      if (webcamEnabled) {
        // this will disable the local participant webcam
        //highlight-next-line
        meeting.disableWebcam();
        Toast.makeText(MeetingActivity.this, "Webcam Disabled", Toast.LENGTH_SHORT).show();
      } else {
        // this will enable the local participant webcam
        //highlight-next-line
        meeting.enableWebcam();
        Toast.makeText(MeetingActivity.this, "Webcam Enabled", Toast.LENGTH_SHORT).show();
      }
      webcamEnabled=!webcamEnabled;
    });

    // leave meeting
    findViewById(R.id.btnLeave).setOnClickListener(view -> {
      // this will make the local participant leave the meeting
      //highlight-next-line
      meeting.leave();
    });
  }
}
```

</TabItem>

</Tabs>

#### Output

<div style={{textAlign: 'center'}}>

<img style={{height: '200px'}} src="/img/quick-start/android_controls.jpeg" />

</div>

### Step 5: Handling the Participants View

We will be showing the list of participant in a `RecyclerView`.

:::info

- Here the participant's video is displayed using `VideoView`, but you may also use `SurfaceViewRender` for the same.
- For `VideoView`, SDK version should be `0.1.13` or higher.
- To know more about `VideoView`, please visit [here](/android/guide/video-and-audio-calling-api-sdk/render-media/display-video/understand-videoView-component)

:::

1. Create a new layout for the participant view named `item_remote_peer.xml` in the `res/layout` folder.

```xml title="item_remote_peer.xml"
<?xml version="1.0" encoding="utf-8"?>
<FrameLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="200dp"
    android:background="@color/cardview_dark_background"
    tools:layout_height="200dp">

    <live.videosdk.rtc.android.VideoView
        android:id="@+id/participantView"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:visibility="gone" />

    <LinearLayout
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:layout_gravity="bottom"
        android:background="#99000000"
        android:orientation="horizontal">

        <TextView
            android:id="@+id/tvName"
            android:layout_width="0dp"
            android:layout_height="wrap_content"
            android:layout_weight="1"
            android:gravity="center"
            android:padding="4dp"
            android:textColor="@color/white" />

    </LinearLayout>

</FrameLayout>
```

2. Create a recycler view adapter named `ParticipantAdapter` which will show the participant list. Create `PeerViewHolder` in the adapter which will extend `RecyclerView.ViewHolder`.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js title="ParticipantAdapter.kt"
class ParticipantAdapter(meeting: Meeting) : RecyclerView.Adapter<ParticipantAdapter.PeerViewHolder>() {

  override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): PeerViewHolder {
    return PeerViewHolder(
      LayoutInflater.from(parent.context)
        .inflate(R.layout.item_remote_peer, parent, false)
    )
  }

  override fun onBindViewHolder(holder: PeerViewHolder, position: Int) {
  }

  override fun getItemCount(): Int {
    return 0
  }

  class PeerViewHolder(view: View) : RecyclerView.ViewHolder(view) {
    // 'VideoView' to show Video Stream
    var participantView: VideoView
    var tvName: TextView

    init {
        tvName = view.findViewById(R.id.tvName)
        participantView = view.findViewById(R.id.participantView)
    }
  }
}
```

</TabItem>

<TabItem value="Java">

```java title="ParticipantAdapter.java"
public class ParticipantAdapter extends RecyclerView.Adapter<ParticipantAdapter.PeerViewHolder> {

  @NonNull
  @Override
  public PeerViewHolder onCreateViewHolder(@NonNull ViewGroup parent, int viewType) {
      return new PeerViewHolder(LayoutInflater.from(parent.getContext()).inflate(R.layout.item_remote_peer, parent, false));
  }

  @Override
  public void onBindViewHolder(@NonNull PeerViewHolder holder, int position) {
  }

  @Override
  public int getItemCount() {
      return 0;
  }

  static class PeerViewHolder extends RecyclerView.ViewHolder {
    // 'VideoView' to show Video Stream
    public VideoView participantView;
    public TextView tvName;
    public View itemView;

    PeerViewHolder(@NonNull View view) {
        super(view);
        itemView = view;
        tvName = view.findViewById(R.id.tvName);
        participantView = view.findViewById(R.id.participantView);
    }
  }
}
```

</TabItem>

</Tabs>

3. Now, we will render a list of `Participant` for the meeting.
   We will initialize this list in the constructor of the `ParticipantAdapter`

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js title="ParticipantAdapter.kt"
class ParticipantAdapter(meeting: Meeting) :
    RecyclerView.Adapter<ParticipantAdapter.PeerViewHolder>() {

  // creating a empty list which will store all participants
  private val participants: MutableList<Participant> = ArrayList()

  init {
    //highlight-next-line
    // adding the local participant(You) to the list
    participants.add(meeting.localParticipant)

    //highlight-next-line
    // adding Meeting Event listener to get the participant join/leave event in the meeting.
    meeting.addEventListener(object : MeetingEventListener() {
      override fun onParticipantJoined(participant: Participant) {
        // add participant to the list
        participants.add(participant)
        notifyItemInserted(participants.size - 1)
      }

      override fun onParticipantLeft(participant: Participant) {
        var pos = -1
        for (i in participants.indices) {
          if (participants[i].id == participant.id) {
            pos = i
            break
          }
        }
        // remove participant from the list
        participants.remove(participant)
        if (pos >= 0) {
          notifyItemRemoved(pos)
        }
      }
    })
  }

  // replace getItemCount() method with following.
  // this method returns the size of total number of participants
  override fun getItemCount(): Int {
    //highlight-next-line
    return participants.size
  }
  //...
}
```

</TabItem>

<TabItem value="Java">

```java title="ParticipantAdapter.java"
public class ParticipantAdapter extends RecyclerView.Adapter<ParticipantAdapter.PeerViewHolder> {

  // creating a empty list which will store all participants
  private final List<Participant> participants = new ArrayList<>();

  public ParticipantAdapter(Meeting meeting) {
    //highlight-next-line
    // adding the local participant(You) to the list
    participants.add(meeting.getLocalParticipant());

    //highlight-next-line
    // adding Meeting Event listener to get the participant join/leave event in the meeting.
    meeting.addEventListener(new MeetingEventListener() {
      @Override
      public void onParticipantJoined(Participant participant) {
        // add participant to the list
        participants.add(participant);
        notifyItemInserted(participants.size() - 1);
      }

      @Override
      public void onParticipantLeft(Participant participant) {
        int pos = -1;
        for (int i = 0; i < participants.size(); i++) {
          if (participants.get(i).getId().equals(participant.getId())) {
            pos = i;
            break;
          }
        }
        // remove participant from the list
        participants.remove(participant);

        if (pos >= 0) {
          notifyItemRemoved(pos);
        }
      }
    });
  }

  // replace getItemCount() method with following.
  // this method returns the size of total number of participants
  @Override
  public int getItemCount() {
    //highlight-next-line
    return participants.size();
  }
  //...
}
```

</TabItem>

</Tabs>

4. We have listed our participants. Let's set up the view holder to display a participant video.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js title="PartipantAdapter.kt"
class ParticipantAdapter(meeting: Meeting) :
    RecyclerView.Adapter<ParticipantAdapter.PeerViewHolder>() {

  // replace onBindViewHolder() method with following.
  override fun onBindViewHolder(holder: PeerViewHolder, position: Int) {
    val participant = participants[position]

    holder.tvName.text = participant.displayName

    // adding the initial video stream for the participant into the 'VideoView'
    for ((_, stream) in participant.streams) {
      if (stream.kind.equals("video", ignoreCase = true)) {
        holder.participantView.visibility = View.VISIBLE
        val videoTrack = stream.track as VideoTrack
        //highlight-next-line
        holder.participantView.addTrack(videoTrack)
        break
      }
    }

    // add Listener to the participant which will update start or stop the video stream of that participant
    participant.addEventListener(object : ParticipantEventListener() {
      override fun onStreamEnabled(stream: Stream) {
        if (stream.kind.equals("video", ignoreCase = true)) {
          holder.participantView.visibility = View.VISIBLE
          val videoTrack = stream.track as VideoTrack
          //highlight-next-line
          holder.participantView.addTrack(videoTrack)
       }
      }

      override fun onStreamDisabled(stream: Stream) {
        if (stream.kind.equals("video", ignoreCase = true)) {
          //highlight-next-line
          holder.participantView.removeTrack()
          holder.participantView.visibility = View.GONE
        }
      }
    })
  }
}
```

</TabItem>

<TabItem value="Java">

```java title="PartipantAdapter.java"
public class ParticipantAdapter extends RecyclerView.Adapter<ParticipantAdapter.PeerViewHolder> {

  // replace onBindViewHolder() method with following.
  @Override
  public void onBindViewHolder(@NonNull PeerViewHolder holder, int position) {
    Participant participant = participants.get(position);

    holder.tvName.setText(participant.getDisplayName());

    // adding the initial video stream for the participant into the 'VideoView'
    for (Map.Entry<String, Stream> entry : participant.getStreams().entrySet()) {
      Stream stream = entry.getValue();
      if (stream.getKind().equalsIgnoreCase("video")) {
        holder.participantView.setVisibility(View.VISIBLE);
        VideoTrack videoTrack = (VideoTrack) stream.getTrack();
        //highlight-next-line
        holder.participantView.addTrack(videoTrack)
        break;
      }
    }
    // add Listener to the participant which will update start or stop the video stream of that participant
    participant.addEventListener(new ParticipantEventListener() {
      @Override
      public void onStreamEnabled(Stream stream) {
        if (stream.getKind().equalsIgnoreCase("video")) {
          holder.participantView.setVisibility(View.VISIBLE);
          VideoTrack videoTrack = (VideoTrack) stream.getTrack();
          //highlight-next-line
          holder.participantView.addTrack(videoTrack)
        }
      }

      @Override
      public void onStreamDisabled(Stream stream) {
        if (stream.getKind().equalsIgnoreCase("video")) {
          //highlight-next-line
          holder.participantView.removeTrack();
          holder.participantView.setVisibility(View.GONE);
        }
      }
    });
  }
}
```

</TabItem>

</Tabs>

5. Add this adapter to the `MeetingActivity`

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js title="MeetingActivity.kt"
override fun onCreate(savedInstanceState: Bundle?) {
  //Meeting Setup...
  //...
  val rvParticipants = findViewById<RecyclerView>(R.id.rvParticipants)
  rvParticipants.layoutManager = GridLayoutManager(this, 2)
  rvParticipants.adapter = ParticipantAdapter(meeting!!)
}
```

</TabItem>

<TabItem value="Java">

```java title="MeetingActivity.java"
@Override
protected void onCreate(Bundle savedInstanceState) {
  //Meeting Setup...
  //...
  final RecyclerView rvParticipants = findViewById(R.id.rvParticipants);
  rvParticipants.setLayoutManager(new GridLayoutManager(this, 2));
  rvParticipants.setAdapter(new ParticipantAdapter(meeting));
}
```

</TabItem>

</Tabs>

:::tip

Stuck anywhere? Check out this [example code](https://github.com/videosdk-live/videosdk-rtc-android-java-sdk-example) on GitHub.

:::

## Final Output

We are done with implementation of customised video calling app in Android using Video SDK. To explore more features go through Basic and Advanced features.

import ReactPlayer from 'react-player'

<div style={{textAlign: 'center'}}>

<ReactPlayer muted controls url="https://cdn.videosdk.live/website-resources/docs-resources/android_quickstart.mp4" height="500px" width={"100%"} />

</div>

:::tip
You can checkout the complete [quick start example here](https://github.com/videosdk-live/quickstart/tree/main/android-rtc).
:::


---

---
title: Understanding Usage Quota Limits
hide_title: true
hide_table_of_contents: false
description: Explore VideoSDK quota limits and subscription plans. Learn how to optimize usage and choose the right plan for your video development needs.
sidebar_label: Understanding Usage Quota Limits
pagination_label: Understanding Usage Quota Limits
keywords:
  - videosdk plans
  - videosdk quota
  - videosdk limit
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: quotas-and-limit
---

import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>

## Understanding Usage Quota Limits - Android

In this documentation, you will find detailed information about the quotas associated with each plan, including usage limits for various features and functionalities. Understanding these quotas will help you optimize your usage, selecting the best pricing plan and make the most of your VideoSDK experience.

## How VideoSDK limits concurrent usage quota

VideoSDK's approach to limiting usage focuses on concurrent usage rather than overall usage. Concurrent usage refers to the number of participants or requests that can be hosted or processed simultaneously. 

For example, if there's a limit of 50 concurrent participants per organization, users can run multiple calls (sessions) simultaneously, with a maximum of 50 participants across all sessions combined.

## How to view my current plan’s quota limits?

To view the current quota limits on your organization, simply navigate to the [VideoSDK Dashboard](https://app.videosdk.live/), go to your Profile section, and click on the Billing tab.

## Free Plan

Since, we’ve designed Free Plan for developers who are just exploring, we’ve kept the limits that would get you started without a hitch.

Organisations on Free Plan have the following limits on concurrent usage:

| Feature | Concurrent Limit |
| --- | --- |
| Participants in Video Calls | 50 concurrent participants |
| Viewers in Live Streams | 100 concurrent viewers |
| Recording Request | 1 concurrent request at a time |
| HLS Encoding Request | 1 concurrent request at a time |
| RTMP-Out Request | 1 concurrent request at a time |

 
### How to increase my limits?

To increase your limits, simply upgrade your plan by providing billing details and credit card information.

## Pay-as-you-Go Plan

We've increased participant limits for this paid plan. This way, it won't significantly impact users heavily involved in production or integration.

Organisations on Pay-as-you-Go have the following limits on concurrent usage:

| Feature | Concurrent Limit |
| --- | --- |
| Participants in Video Calls | 100 concurrent participants |
| Viewers in Live Streams | 500 concurrent viewers |
| Recording Request | 5 concurrent request at a time |
| HLS Encoding Request | 5 concurrent request at a time |
| RTMP-Out Request | 5 concurrent request at a time |

### How to increase my limits?

To increase your limits further more, simply get in touch with us. [Contact us](https://www.videosdk.live/contact) directly or reach out via email at [support@videosdk.live](mailto:support@videosdk.live), and we'll handle the rest gladly.

## Enterprise Plan

For Enterprise users, all limits are tailored to the specific needs. Customised limits ensure optimal performance for your unique requirements.

To get started as an Enterprise user, simply get in touch with us, explain your requirements and use case, and we’ll customise the quota and limits according to your needs.

## Examples to understand concurrent limits

**Example #1**

Let's say you're using video callings (RTC) in your organization on the Free Plan. In this scenario, you can concurrently host up to 50 participants. However, the number of calls (sessions) you initiate is unrestricted.

To simplify, you can run multiple sessions simultaneously, but concurrently, you can only accommodate a maximum of 50 participants across all sessions. If a 51st participant attempts to join, they won't be able to access the session until you upgrade your plan to increase your participant limits.

**Example #2**

Let’s say you're using live streaming in your organization on the Free Plan. In this setup, you can concurrently host up to 100 viewers joining the sessions. While you have the flexibility to host multiple live streaming sessions, the number of viewers joining session concurrently is restricted.

**Example #3**

Lets say you’re using video callings (RTC) in your organization on the Pay-as-you-Go Plan and you're hosting 5 concurrent calls (sessions), all of which are being recorded. Now, when you initiate the 6th call (session) and request recording, VideoSDK will not process your recording request. Instead, it will throw an error because you've reached your recording request limit.

If you have any questions regarding quota limits and pricing plan, post in our [Discord community](https://discord.com/invite/Qfm8j4YAUJ), [contact us](https://www.videosdk.live/contact) directly, or reach out to us on [support@videosdk.live](mailto:support@videosdk.live).

---

---
title: Custom Template - Android
sidebar_position: 1
sidebar_label: Customize Recording UI
hide_table_of_contents: false
---

import CustomTemplate from '../../../../mdx/\_custom-template.mdx';

<CustomTemplate title="Custom Template With Recording"/>


---

---
title: Geo Tag Meeting recordings - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: Geo Tag meeting recordings feature quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Geo Tag Recording
pagination_label: Geo Tag Recording
keywords:
  - Start Recording meeting
  - Stop Recording meeting
  - audio calling
  - video calling
  - geo tag
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: geo-tag-recording
---

# Geo Tag Meeting Recordings - Android

To ensure compliance for BFSIs doing vKYC, it very important to include the co-ordinates(location) of the customer in the recordings. VideoSDK provides a very customizable solution to implement this feature. You will be using custom templates for this purpose.

We have created a ready to use template for this use case which can be found [here](https://github.com/videosdk-live/videosdk-rtc-react-prebuilt-ui/tree/template/geo-tag-watermark). To integrate this template with your recordings follow the below mentiond instructions.

### Host the template

1. Clone the template repository and switch to the branch `template/geo-tag-watermark`.

```bash
git clone https://github.com/videosdk-live/videosdk-rtc-react-prebuilt-ui.git
cd videosdk-rtc-react-prebuilt-ui
git checkout template/geo-tag-watermark
```

2. Install the dependencies and create a build of the project using below mentioned commands.

```bash
npm install
npm run build
```

3. Host the contents of the build folder on your server and check if the template is up and running.

:::note

If you want to create the complete template from scratch you can [follow this guide.](./custom-template.md)

:::

### Using the template for recording

1. To use the template that we deployed earlier, we will be using the `templateUrl` feature in the `startRecording` API.
   To generate the template URL, you will have to append the `meetingId`, and `token` has to be added in the query parameters. Also if you are using the template provided above you need to added a few extra paramters mentioned below. Here is the code snippet to generate the URL.

```js
async function main() {
  let meetingId = "Your MeetingID";
  let token = "Your Token";
  const templateUrl = `https://${YOUR Template URL}/?meetingId=${meetingId}&token=${token}&name=recorder&isRecorder=true&joinWithoutUserInteraction=true`;

  console.log(templateUrl);
}

main();
```

2. Now that we have the template URL, we will use this URL to start the recording using the below provided API call.

```js
async function main() {
  let meetingId = "Your MeetingID";
  let token = "Your Token";
  const templateUrl = `https://${YOUR Template URL}/?meetingId=${meetingId}&token=${token}&name=recorder&isRecorder=true&joinWithoutUserInteraction=true`;

  console.log(templateUrl);

  //Using the previouly created template URL and starting the recording using the API.
  const options = {
    method: "POST",
    headers: {
      Authorization: "$YOUR_TOKEN",
      "Content-Type": "application/json",
    },
    body: JSON.stringify({
      roomId: "Your MeetingId",
      templateUrl: templateUrl,
    }),
  };
  const url = `https://api.videosdk.live/v2/recordings/start`;
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
}

main();
```

### Updating the Geo Tagging Coordinates

We will be using the PubSub feature of VideoSDK to update the data of latitude and longitude. For the predefined template provided by us we are using `GEO_TAG` as topic name. We will be publishing the `participantName`, `latitude` and `longitude` of the participant for whom we want to show in the recording.

:::note

You will have to fetch the longitude and latitude of the participant before sending it using the pubsub.

:::

Here is the code how you will have to publish the message:

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
private fun sendMessage() {
  // publish message
  val options = PubSubPublishOptions()
  options.isPersist = true
  val geoTagData = JSONObject()
  JsonUtils.jsonPut(geoTagData, "latitude", "PARTICIPANT LATITUDE")
  JsonUtils.jsonPut(geoTagData, "longitude", "PARTICIPANT LONGITUDE")
  JsonUtils.jsonPut(geoTagData, "participantName", "PARTICIPANT NAME")

  //highlight-next-line
  meeting!!.pubSub.publish("GEO_TAG", "GEO_TAG_DATA", options, geoTagData)
}
```

</TabItem>

<TabItem value="Java">

```js
protected void sendMessage() {
  // publish message
  PubSubPublishOptions options = new PubSubPublishOptions();
  options.setPersist(true);
  JSONObject geoTagData = JSONObject()
  JsonUtils.jsonPut(geoTagData, "latitude", "YOUR LATITUDE")
  JsonUtils.jsonPut(geoTagData, "longitude", "YOUR LONGITUDE")
  JsonUtils.jsonPut(geoTagData, "participantName", "PARTICIPANT NAME")
  //highlight-next-line
  meeting.pubSub.publish("GEO_TAG", "GEO TAG DATA", options, geoTagData);
}
```

</TabItem>

</Tabs>

After implementing this, you should get the recording in the following format:

![Geo Tagging Recoridng](https://cdn.videosdk.live/website-resources/docs-resources/geo-tag-recording-template.png)

If you wish to change how UI looks on recording, you can change it by updating the layout in the template itself.

### API Reference

The API references for all the methods utilized in this guide are provided below.

- [Start Recording API](/api-reference/realtime-communication/start-recording)
- [Learn more about Custom Templates](./custom-template.md)


---

---
title: Recording Overview - Android
hide_title: false
hide_table_of_contents: false
description: Record Meeting features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Overview
pagination_label: Overview
keywords:
  - Overview
  - Start Recording meeting
  - Stop Recording meeting
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: Overview
---

import Overview from '../../../../mdx/\_recording-overview.mdx';

<Overview title="Recording Overview"/>


---

---
title: Generate presigned URL - Android
hide_title: false
hide_table_of_contents: false
description: presigned URL features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Generate presigned URL
pagination_label: Generate presigned URL
keywords:
  - Start Recording meeting
  - Stop Recording meeting
  - audio calling
  - video calling
  - real-time communication
  - presigned URL
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: presigned-URL
---

import PreSignedUrl from '../../../../mdx/\_presigned-url.mdx';

<PreSignedUrl title="Generate presigned URL - Android"/>


---

---
title: Record Meeting Video & Audio Call - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: Record Meeting features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Start and Stop
pagination_label: Start and Stop
keywords:
  - Start Recording meeting
  - Stop Recording meeting
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: record-meeting
---

# Start and Stop - Android

This guide will provide an overview of how to implement start and stop Meeting Recording.

### `startRecording()`

`startRecording()` can be used to start a recording of the meeting which can be accessed from the `Meeting` class. This method accepts four parameters:

- `1. webhookUrl`: This would the webhook URL where you would like to listen to event happening for the recording like starting and stopping of recording. It will be triggered when the recording is completed and stored into server. Read more about webhooks [here](https://en.wikipedia.org/wiki/Webhook)

- `2. awsDirPath`: This parameter accepts the path for the your S3 bucket where you want to store recordings to. To allow us to store recording in your S3 bucket, you will need to fill this form by providing the required values. ([VideoSDK Cloud (AWS S3, Azure Blob or GCP ) Integration](/android/guide/video-and-audio-calling-api-sdk/recording/recording-storage-config))

- `3. config`: This parameter will define how the meeting should be recorded.

- `4. transcription`: This parameter lets you start post transcription for the recording.

:::note

If you don't have a value for `webhookUrl`,`awsDirPath` or `config`, you should pass `null` in place of the missing value. If you pass `null` in `awsDirPath` parameter then by default recordings will be store on the VideoSDK's storage.
:::

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
val config = JSONObject()

//highlight-next-line
// Layout Configuration
val layout = JSONObject()
JsonUtils.jsonPut(layout, "type", "GRID") // "SPOTLIGHT" | "SIDEBAR",  Default : "GRID"
JsonUtils.jsonPut(layout, "priority", "SPEAKER") // "PIN", Default : "SPEAKER"
JsonUtils.jsonPut(layout, "gridSize", 4) // MAX : 4
JsonUtils.jsonPut(config, "layout", layout)

//highlight-next-line
// Theme of recording
JsonUtils.jsonPut(config, "theme", "DARK") //  "LIGHT" | "DEFAULT"

//highlight-next-line
// `mode` is used to either record video & audio both or only audio.
JsonUtils.jsonPut(config, "mode", "video-and-audio") // "audio", Default : "video-and-audio"

//highlight-next-line
// Quality of recording and is only applicable to `video-and-audio` type mode.
JsonUtils.jsonPut(config, "quality", "high") // "low" | "med",  Default : "med"

//highlight-start
// This mode refers to orientation of recording.
// landscape : Record the meeting in horizontally
// portrait : Record the meeting in vertically (Best for mobile view)
//highlight-end
JsonUtils.jsonPut(config, "orientation", "portrait") // "landscape",  Default : "landscape"

//highlight-next-line
// Post Transcription Configuration
val prompt = "Write summary in sections like Title, Agenda, Speakers, Action Items, Outlines, Notes and Summary"
val summaryConfig = SummaryConfig(true, prompt)
val modelId = "raman_v1"
val transcription = PostTranscriptionConfig(true, summaryConfig, modelId)

meeting.startRecording(null, null, config, transcription)
```

</TabItem>

<TabItem value="Java">

```js
JSONObject config = new JSONObject();

//highlight-next-line
// Layout Configuration
JSONObject layout = new JSONObject();
JsonUtils.jsonPut(layout, "type", "GRID"); // "SPOTLIGHT" | "SIDEBAR",  Default : "GRID"
JsonUtils.jsonPut(layout, "priority", "SPEAKER");  // "PIN", Default : "SPEAKER"
JsonUtils.jsonPut(layout, "gridSize", 4); // MAX : 4
JsonUtils.jsonPut(config, "layout", layout);

//highlight-next-line
// Theme of recording
JsonUtils.jsonPut(config, "theme", "DARK"); //  "LIGHT" | "DEFAULT"

//highlight-next-line
// `mode` is used to either record video & audio both or only audio.
JsonUtils.jsonPut(config, "mode", "video-and-audio"); // "audio", Default : "video-and-audio"

//highlight-next-line
// Quality of recording and is only applicable to `video-and-audio` type mode.
JsonUtils.jsonPut(config, "quality", "high"); // "low" | "med",  Default : "med"

//highlight-start
// This mode refers to orientation of recording.
// landscape : Record the meeting in horizontally
// portrait : Record the meeting in vertically (Best for mobile view)
//highlight-end
JsonUtils.jsonPut(config, "orientation", "portrait"); // "landscape",  Default : "landscape"

//highlight-next-line
// Post Transcription Configuration
String prompt = "Write summary in sections like Title, Agenda, Speakers, Action Items, Outlines, Notes and Summary";
SummaryConfig summaryConfig = new SummaryConfig(true, prompt);
String modelId = "raman_v1";
PostTranscriptionConfig transcription = new PostTranscriptionConfig(true, summaryConfig, modelId);

meeting.startRecording(null, null, config, transcription);
```

</TabItem>

</Tabs>

### `stopRecording()`

- `stopRecording()` is used to stop the meeting recording which can be accessed from the `Meeting` class.

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
// keep track of recording
val recording = false

findViewById<View>(R.id.btnRecording).setOnClickListener { view: View? ->
    if (!recording) {
      //highlight-start
      val config = JSONObject()
      val layout = JSONObject()
      JsonUtils.jsonPut(layout, "type", "GRID")
      JsonUtils.jsonPut(layout, "priority", "SPEAKER")
      JsonUtils.jsonPut(layout, "gridSize", 4)
      JsonUtils.jsonPut(config, "layout", layout)
      JsonUtils.jsonPut(config, "theme", "DARK")
      JsonUtils.jsonPut(config, "mode", "video-and-audio")
      JsonUtils.jsonPut(config, "quality", "high")
      JsonUtils.jsonPut(config, "orientation", "portrait")
      //highlight-end

      //highlight-next-line
      // Post Transcription Configuration
      val prompt = "Write summary in sections like Title, Agenda, Speakers, Action Items, Outlines, Notes and Summary"
      val summaryConfig = SummaryConfig(true, prompt)
      val modelId = "raman_v1"
      val transcription = PostTranscriptionConfig(true, summaryConfig, modelId)

      // Start Recording
      // If you don't have a `webhookUrl` or `awsDirPath`, you should pass null.
      // If you don't want to enable transcription, you can pass null as parameter.
      //highlight-next-line
      meeting!!.startRecording("YOUR WEB HOOK URL", "AWS Directory Path", config, transcription)
    } else {
      // Stop Recording
      //highlight-next-line
      meeting!!.stopRecording()
    }
}
```

</TabItem>

<TabItem value="Java">

```js
// keep track of recording
boolean recording = false;

findViewById(R.id.btnRecording).setOnClickListener(view -> {
    if (!recording) {
      //highlight-start
      JSONObject config = new JSONObject();
      JSONObject layout = new JSONObject();
      JsonUtils.jsonPut(layout, "type", "GRID");
      JsonUtils.jsonPut(layout, "priority", "SPEAKER");
      JsonUtils.jsonPut(layout, "gridSize", 4);
      JsonUtils.jsonPut(config, "layout", layout);
      JsonUtils.jsonPut(config, "theme", "DARK");
      JsonUtils.jsonPut(config, "mode", "video-and-audio");
      JsonUtils.jsonPut(config, "quality", "high");
      JsonUtils.jsonPut(config, "orientation", "portrait");
      //highlight-end

      //highlight-next-line
      // Post Transcription Configuration
      String prompt = "Write summary in sections like Title, Agenda, Speakers, Action Items, Outlines, Notes and Summary";
      SummaryConfig summaryConfig = new SummaryConfig(true, prompt);
      String modelId = "raman_v1";
      PostTranscriptionConfig transcription = new PostTranscriptionConfig(true, summaryConfig, modelId);

      // Start Recording
      // If you don't have a `webhookUrl` or `awsDirPath`, you should pass null.
      // If you don't want to enable transcription, you can pass null as parameter.
      //highlight-next-line
      meeting.startRecording("YOUR WEB HOOK URL", "AWS Directory Path", config, transcription);
    } else {
      // Stop Recording
      //highlight-next-line
      meeting.stopRecording();
    }
});
```

</TabItem>

</Tabs>

:::important

To initiate automatic recording at the beginning of a `session`, simply provide the `autoStartConfig` feature `recording` during `room` creation. For more information on configuring the `autoStartConfig`, please refer to the provided documentation **[<u>here</u>](/api-reference/realtime-communication/create-room#autoStartConfig)**.

:::

### API Reference

The API references for all the methods utilised in this guide are provided below.

- [startRecording()](/android/api/sdk-reference/meeting-class/methods#startrecording)
- [stopRecording()](/android/api/sdk-reference/meeting-class/methods#stoprecording)
- [onRecordingStateChanged](/android/api/sdk-reference/meeting-class/meeting-event-listener-class#onrecordingstatechanged)
- [autoStartConfig](/api-reference/realtime-communication/create-room#autoStartConfig)


---

---
title: Participant Recording (Individual) - Android
hide_title: false
hide_table_of_contents: false
description: Individual participant recording features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Participant Recording (Individual)
pagination_label: Participant Recording
keywords:
  - Start Participant Recording
  - Stop Participant Recording
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: record-participant
---

import RecordParticipant from '../../../../mdx/\_intro-participant-recording.mdx';
import WebhookParticipantRecording from '../../../../mdx/\_webhook-participant-recording.mdx';

<RecordParticipant title="Record Participant"/>

## Start Individual Participant Recording

To start a participant recording, you will have to call `/v2/recordings/participant/start` API with following body parameters.

- `roomId`: RoomId for which the participant recording is to be started
- `participantId`: participantId of the participant to be recorder.
- `fileFormat`: Currently only `webm` is supported as file format. We will add the support for other formats in future.
- `webhookUrl`: The webhook URL where you would like to get the status updates of the recording. To learn more about webhooks refer [here](#participant-track-recording-starting).
- `bucketDirPath`: If you are using your own storage, you can provide the directory path where you want to store the recording. To configure the storage please [refere this quide](/javascript/guide/video-and-audio-calling-api-sdk/recording/recording-storage-config).

The usual recording path would look like `${sessionId}/${participantId}/${filename}`.

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'}]}>

<TabItem value="Kotlin">

```kotlin
import org.json.JSONObject
import java.io.OutputStream
import java.net.HttpURLConnection
import java.net.URL
import java.io.IOException

fun StartParticipantRecording() {
    val roomId = "<YOUR ROOM ID>"
    val participantId = "<PARTICIPANT ID>"
    val fileFormat = "<YOUR FILE FORMAT>" // (Optional) default: webm
    val bucketDirPath = "<YOUR CLOUD STORAGE BUCKET PATH>" // (Optional) test/abc
    val webhookUrl = "<YOUR WEBHOOK URL>" // (Optional)

    try {
        val url = URL("https://api.videosdk.live/v2/recordings/participant/start")
        val conn = url.openConnection() as HttpURLConnection
        conn.requestMethod = "POST"
        conn.setRequestProperty("Authorization", "$YOUR_TOKEN")
        conn.setRequestProperty("Content-Type", "application/json")
        conn.doOutput = true

        val json = JSONObject()
        json.put("roomId", roomId)
        json.put("participantId", participantId)
        json.put("fileFormat", fileFormat)
        json.put("bucketDirPath", bucketDirPath)
        json.put("webhookUrl", webhookUrl)

        conn.outputStream.use { os: OutputStream ->
            val input = json.toString().toByteArray(Charsets.UTF_8)
            os.write(input, 0, input.size)
        }

        val responseCode = conn.responseCode
        if (responseCode == HttpURLConnection.HTTP_OK) {
            println("Participant Recording started successfully.")
        } else {
            println("Failed to start participant recording.")
        }
    } catch (e: Exception) {
        e.printStackTrace()
    }
}

```

</TabItem>

<TabItem value="Java">

```java
import java.io.OutputStream;
import java.net.HttpURLConnection;
import java.net.URL;
import org.json.JSONObject;

private void StartParticipantRecording() {
    String roomId = "<YOUR ROOM ID>";
    String participantId = "<PARTICIPANT ID>";
    String fileFormat = "<YOUR FILE FORMAT>"; // (Optional) default: webm
    String bucketDirPath = "<YOUR CLOUD STORAGE BUCKET PATH>"; // (Optional) test/abc
    String webhookUrl = "<YOUR WEBHOOK URL>"; // (Optional)

    try {
        URL url = new URL("https://api.videosdk.live/v2/recordings/participant/start");
        HttpURLConnection conn = (HttpURLConnection) url.openConnection();
        conn.setRequestMethod("POST");
        conn.setRequestProperty("Authorization", "$YOUR_TOKEN");
        conn.setRequestProperty("Content-Type", "application/json");
        conn.setDoOutput(true);

        JSONObject json = new JSONObject();
        json.put("roomId", roomId);
        json.put("participantId", participantId);
        json.put("fileFormat", fileFormat);
        json.put("bucketDirPath", bucketDirPath);
        json.put("webhookUrl", webhookUrl);

        try (OutputStream os = conn.getOutputStream()) {
            byte[] input = json.toString().getBytes("utf-8");
            os.write(input, 0, input.length);
        }

        int responseCode = conn.getResponseCode();
        if (responseCode == HttpURLConnection.HTTP_OK) {
            System.out.println("Participant Recording started successfully.");
        } else {
            System.out.println("Failed to start participant recording.");
        }
    } catch (Exception e) {
        e.printStackTrace();
    }
}

```

</TabItem>

</Tabs>

## Stop Individual Participant Recording

To stop a participant recording, you will have to call `/v2/recordings/participant/stop` API with following body parameters.

- `roomId`: RoomId for which the participant recording is to be stopped
- `participantId`: participantId for which the recording is to be stopped.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```kotlin
import org.json.JSONObject
import java.io.OutputStream
import java.net.HttpURLConnection
import java.net.URL

fun StopParticipantRecording() {
val roomId = "<YOUR ROOM ID>"
val participantId = "<PARTICIPANT ID>"

    try {
        val url = URL("https://api.videosdk.live/v2/recordings/participant/stop")
        val conn = url.openConnection() as HttpURLConnection
        conn.requestMethod = "POST"
        conn.setRequestProperty("Authorization", "$YOUR_TOKEN")
        conn.setRequestProperty("Content-Type", "application/json")
        conn.doOutput = true

        val json = JSONObject()
        json.put("roomId", roomId)
        json.put("participantId", participantId)

        conn.outputStream.use { os: OutputStream ->
            val input = json.toString().toByteArray(Charsets.UTF_8)
            os.write(input, 0, input.size)
        }

        val responseCode = conn.responseCode
        if (responseCode == HttpURLConnection.HTTP_OK) {
            println("Participant Recording stopped successfully.")
        } else {
            println("Failed to stop participant recording.")
        }
    } catch (e: Exception) {
        e.printStackTrace()
    }

}

```

</TabItem>

<TabItem value="Java">

```java
import java.io.OutputStream;
import java.net.HttpURLConnection;
import java.net.URL;
import org.json.JSONObject;

private void StopParticipantRecording() {
    String roomId = "<YOUR ROOM ID>";
    String participantId = "<PARTICIPANT ID>";

    try {
        URL url = new URL("https://api.videosdk.live/v2/recordings/participant/stop");
        HttpURLConnection conn = (HttpURLConnection) url.openConnection();
        conn.setRequestMethod("POST");
        conn.setRequestProperty("Authorization", "$YOUR_TOKEN");
        conn.setRequestProperty("Content-Type", "application/json");
        conn.setDoOutput(true);

        JSONObject json = new JSONObject();
        json.put("roomId", roomId);
        json.put("participantId", participantId);

        try (OutputStream os = conn.getOutputStream()) {
            byte[] input = json.toString().getBytes("utf-8");
            os.write(input, 0, input.length);
        }

        int responseCode = conn.getResponseCode();
        if (responseCode == HttpURLConnection.HTTP_OK) {
            System.out.println("Participant Recording stopped successfully.");
        } else {
            System.out.println("Failed to stop participant recording.");
        }
    } catch (Exception e) {
        e.printStackTrace();
    }
}


```

</TabItem>

</Tabs>

<WebhookParticipantRecording title="Webhooks"/>


---

---
title: Participant Track Recording - Android
hide_title: false
hide_table_of_contents: false
description: Participant track recording features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Participant Track Recording
pagination_label: Participant Track Recording
keywords:
  - Start Track Recording
  - Start Track Recording
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: record-track
---

import RecordTrack from '../../../../mdx/\_intro-track-recording.mdx';
import WebhookTrackRecording from '../../../../mdx/\_webhook-track-recording.mdx';

<RecordTrack title="Record Track"/>

## Start Participant Track Recording

To start a participant track recording, you will have to call `/v2/recordings/participant/track/start` API with following body parameters.

- `roomId`: RoomId for which the participant track recording is to be started
- `participantId`: participantId of the participant to be recorder.
- `kind`: The kind of tracks you want to record.
  - You can pass following values: _`audio`_ | _`video`_ | _`screen_audio`_ | _`screen_video`_
- `fileFormat`: Currently only `webm` is supported as file format. We will add the support for other formats in future.
- `webhookUrl`: The webhook URL where you would like to get the status updates of the recording. To learn more about webhooks refer [here](#participant-track-recording-starting).
- `bucketDirPath`: If you are using your own storage, you can provide the directory path where you want to store the recording. To configure the storage please [refere this quide](/javascript/guide/video-and-audio-calling-api-sdk/recording/recording-storage-config).

The usual recording path would look like `${sessionId}/${participantId}/${kind}/${filename}`.

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'}]}>

<TabItem value="Kotlin">

```kotlin
import org.json.JSONObject
import java.io.OutputStream
import java.net.HttpURLConnection
import java.net.URL
import java.io.IOException

fun StartTrackRecording() {
    val roomId = "<YOUR ROOM ID>"
    val participantId = "<PARTICIPANT ID>"
    val kind = "<YOUR STREAM KIND>"
    val fileFormat = "<YOUR FILE FORMAT>"
    val bucketDirPath = "<YOUR CLOUD STORAGE BUCKET PATH>"
    val webhookUrl = "<YOUR WEBHOOK URL>"

    try {
        val url = URL("https://api.videosdk.live/v2/recordings/participant/track/start")
        val conn = url.openConnection() as HttpURLConnection
        conn.requestMethod = "POST"
        conn.setRequestProperty("Authorization", "$YOUR_TOKEN")
        conn.setRequestProperty("Content-Type", "application/json")
        conn.doOutput = true

        val jsonBody = JSONObject()
        jsonBody.put("roomId", roomId)
        jsonBody.put("participantId", participantId)
        jsonBody.put("kind", kind)
        jsonBody.put("fileFormat", fileFormat)
        jsonBody.put("bucketDirPath", bucketDirPath)
        jsonBody.put("webhookUrl", webhookUrl)

        conn.outputStream.use { os: OutputStream ->
            val input = json.toString().toByteArray(Charsets.UTF_8)
            os.write(input, 0, input.size)
        }

        val responseCode = conn.responseCode
        if (responseCode == HttpURLConnection.HTTP_OK) {
            println("Track Recording started successfully.")
        } else {
            println("Failed to start track recording.")
        }
    } catch (e: Exception) {
        e.printStackTrace()
    }
}



```

</TabItem>

<TabItem value="Java">

```java
import java.io.OutputStream;
import java.net.HttpURLConnection;
import java.net.URL;
import org.json.JSONObject;

public void StartTrackRecording() {
    String roomId = "<YOUR ROOM ID>";
    String participantId = "<PARTICIPANT ID>";
    String kind = "<YOUR STREAM KIND>";
    String fileFormat = "<YOUR FILE FORMAT>";
    String bucketDirPath = "<YOUR CLOUD STORAGE BUCKET PATH>";
    String webhookUrl = "<YOUR WEBHOOK URL>";

    try {
        URL url = new URL("https://api.videosdk.live/v2/recordings/participant/track/start");
        HttpURLConnection conn = (HttpURLConnection) url.openConnection();
        conn.setRequestMethod("POST");
        conn.setRequestProperty("Authorization", "$YOUR_TOKEN");
        conn.setRequestProperty("Content-Type", "application/json");
        conn.setDoOutput(true);

        JSONObject jsonBody = new JSONObject();
        jsonBody.put("roomId", roomId);
        jsonBody.put("participantId", participantId);
        jsonBody.put("kind", kind);
        jsonBody.put("fileFormat", fileFormat);
        jsonBody.put("bucketDirPath", bucketDirPath);
        jsonBody.put("webhookUrl", webhookUrl);

        try (OutputStream os = conn.getOutputStream()) {
        byte[] input = json.toString().getBytes("utf-8");
        os.write(input, 0, input.length);
        }

        int responseCode = conn.getResponseCode();
        if (responseCode == HttpURLConnection.HTTP_OK) {
            System.out.println("Track Recording started successfully.");
        } else {
            System.out.println("Failed to start track recording.");
        }
    } catch (Exception e) {
        e.printStackTrace();
    }
}

```

</TabItem>

</Tabs>

## Stop Participant Track Recording

To stop a participant track recording, you will have to call `/v2/recordings/participant/track/stop` API with following body parameters.

- `roomId`: RoomId for which the participant track recording is to be stopped
- `participantId`: participantId for which the recording is to be stopped.
- `kind`: The kind of track recording you want to stop for the given participant.
  - You can pass following values: _`audio`_ | _`video`_ | _`screen_audio`_ | _`screen_video`_

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```kotlin
import org.json.JSONObject
import java.io.OutputStream
import java.net.HttpURLConnection
import java.net.URL

fun StopTrackRecording() {
    val roomId = "<YOUR ROOM ID>"
    val participantId = "<PARTICIPANT ID>"
    val kind = "<YOUR STREAM KIND>"

    try {
        val url = URL("https://api.videosdk.live/v2/recordings/participant/track/stop")
        val conn = url.openConnection() as HttpURLConnection
        conn.requestMethod = "POST"
        conn.setRequestProperty("Authorization", "$YOUR_TOKEN")
        conn.setRequestProperty("Content-Type", "application/json")
        conn.doOutput = true

        val jsonBody = JSONObject()
        jsonBody.put("roomId", roomId)
        jsonBody.put("participantId", participantId)
        jsonBody.put("kind", kind)

        conn.outputStream.use { os: OutputStream ->
            val input = json.toString().toByteArray(Charsets.UTF_8)
            os.write(input, 0, input.size)
        }

        val responseCode = conn.responseCode
        if (responseCode == HttpURLConnection.HTTP_OK) {
            println("Track Recording stopped successfully.")
        } else {
            println("Failed to stop track recording.")
        }
    } catch (e: Exception) {
        e.printStackTrace()
    }
}

```

</TabItem>

<TabItem value="Java">

```java
import java.io.OutputStream;
import java.net.HttpURLConnection;
import java.net.URL;
import org.json.JSONObject;

public void StopTrackRecording() {
    String roomId = "<YOUR ROOM ID>";
    String participantId = "<PARTICIPANT ID>";
    String kind = "<YOUR STREAM KIND>";


    try {
        URL url = new URL("https://api.videosdk.live/v2/recordings/participant/track/stop");
        HttpURLConnection conn = (HttpURLConnection) url.openConnection();
        conn.setRequestMethod("POST");
        conn.setRequestProperty("Authorization", "$YOUR_TOKEN");
        conn.setRequestProperty("Content-Type", "application/json");
        conn.setDoOutput(true);

        JSONObject jsonBody = new JSONObject();
        jsonBody.put("roomId", roomId);
        jsonBody.put("participantId", participantId);
        jsonBody.put("kind", kind);

        try (OutputStream os = conn.getOutputStream()) {
        byte[] input = json.toString().getBytes("utf-8");
        os.write(input, 0, input.length);
        }

        int responseCode = conn.getResponseCode();
        if (responseCode == HttpURLConnection.HTTP_OK) {
            System.out.println("Track Recording stopped successfully.");
        } else {
            System.out.println("Failed to stop track recording.");
        }
    } catch (Exception e) {
        e.printStackTrace();
    }
}

```

</TabItem>

</Tabs>

<WebhookTrackRecording title="Webhooks" />


---

---
title: Configure Recording Storage - Android
hide_title: false
hide_table_of_contents: false
sidebar_label: Configure Recording Storage
sidebar_position: 1
pagination_label: Configure Recording Storage
keywords:
  - configure recording storage
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
slug: recording-storage-config
---

### Storage Configuration

While recording your meetings, you have the flexibility to store them either on VideoSDK's storage or configure your own storage solution such as **`AWS S3 Storage, Azure Blob or GCP Cloud Storage`**. To set up your own storage, you can navigate to the [API section](https://app.videosdk.live/api-keys) in the VideoSDK Dashboard.

- This feature allows you to configure storage provider for your meeting recordings.

- You can configure multiple storage provider with multiple API Keys.

- Currently, we support `AWS S3`, `Azure Blob` and `GCP Cloud Storage`. We will add support for other storage provider soon !!

## Prerequisites

- An active [VideoSDK Developer Account](https://app.videosdk.live)
- `Aws S3`, `Azure Blob Storage` or `GCP Cloud Storage` Credentials

## How to setup ?

### Step 1 : Select Api Key

![Dashboard](/img/tutorial/dashboard/api-key-dashboard.png)

- Go to [VideoSDK Dashboard](https://app.videosdk.live/api-keys).
- Select API Key for which, you want to set storage configuration.
- Then click on `Storage Config` Icon in Actions.

### Step 2 : Choose Cloud Storage Provider

![Dashboard](/img/tutorial/dashboard/storage-config.png)

- As you can see in the image, there are 3 Cloud Storage Provider (`Aws`, `Azure`, `GCP`).
- You can select a Cloud Storage Provider as per your requirements.

### Step 3 : Configure Bucket or Container

<h4> For Aws S3 Storage </h4>

![Aws S3](/img/tutorial/dashboard/s3.png)

- You will need AWS S3 Bucket. [Learn to create S3 Bucket](https://docs.aws.amazon.com/AmazonS3/latest/userguide/creating-bucket.html).

- As you can see in the image, you will need enter `accessKeyId`, `secretAccessKey`, `region`, `bucket`, and `ACL` to setup for Aws S3 Storage.

- Click on `Save` button.

<hr />

<h4> For Azure Blob Storage: </h4>

![Azure Blob](/img/tutorial/dashboard/blob.png)

- You will need Azure Blob Container. [Learn to create Blob Container](https://docs.microsoft.com/en-us/azure/storage/blobs/storage-quickstart-blobs-portal#create-a-container).

- As you can see in the image, you will need to enter `connectionString` and `containerName` to setup for Azure Blob.

- Click on `Save` button.

<hr />

<h4> For Google Cloud Storage: </h4>

<img src="/img/tutorial/dashboard/gcp.png" alt="GCP Cloud Storage" width="436" height="632"/>

1. You will need Google Cloud Storage Bucket. [Learn to create Google Cloud Storage Bucket](https://cloud.google.com/storage/docs/creating-buckets).

2. After creation, click on the <b> &#xFE19; </b>button in the upper right corner and select **`Project settings`**.

3. Under **`IAM and Admin`**, select **`Service Accounts`**. In the service account list, click on the <b> &#xFE19; </b> button for the account just added or created before, and select **`Manage keys`**.

4. Click **`ADD KEY > Create new key`**. Select **`JSON`** in the pop-up box and click **`CREATE`**. A json file is downloaded with the name format `projectId-xxxxxxxx.json`.

5. Open the downloaded json file, which looks like the following example:

```
{
  "type": "service_account",
  "project_id": "videosdk-12345",
  "private_key_id": "yourprivateidkeyyourprivateidkeyyourprivateidkey",
  "private_key": "-----BEGIN PRIVATE KEY-----\nThisisYourPrivateKeyThisisYourPrivateKeyThisisYourPrivateKey\nThisisYourPrivateKey\nThisisYourPrivateKey\nThisisYourPrivateKey\n-----END PRIVATE KEY-----\n",
  "client_email": "xxxx-xxxx@videosdk-12345.iam.gserviceaccount.com",
  "client_id": "123456789012345678901",
  "auth_uri": "https://accounts.google.com/o/oauth2/auth",
  "token_uri": "https://oauth2.googleapis.com/token",
  "auth_provider_x509_cert_url": "https://www.googleapis.com/oauth2/v1/certs",
  "client_x509_cert_url": "https://www.googleapis.com/robot/v1/metadata/x509/videosdk%40videosdk-404307.iam.gserviceaccount.com",
  "universe_domain": "googleapis.com"
}
```

- As you can see in the image, you will need to enter `Project Id`, `Client Email`, `Bucket`, `Private Key` to setup for Google Cloud Storage Bucket. You can retrieve these details from the json file.

- Click on `Save` button.

### Step 4 : Test

- It's time to test !!
- [Create Room](https://docs.videosdk.live/api-reference/realtime-communication/create-room) with token generated with the API Key, you have configured for.
- Start meeting with the roomId created and Start Recording !!
- Then, you can see that recording will be available in your Bucket or Container.

:::note

- Only a single Recording Storage Config can be possible for a particular Api Key at a time.
- In order to add new Recording Configuration, first you need to delete current configuration.

:::


---

---
title: Record Meeting Video & Audio Call - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: Record Meeting features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Webhook and Events
pagination_label: Webhook and Events
keywords:
  - Start Recording meeting
  - Stop Recording meeting
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: webhook-and-events
---

# Webhooks and Events - Android

### Event associated with Recording

- **onRecordingStateChanged** - Whenever meeting recording state changes, then `onRecordingStateChanged` event will trigger.

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
private val meetingEventListener: MeetingEventListener = object : MeetingEventListener() {
  override fun onRecordingStateChanged(recordingState: String) {
    when (recordingState) {
        "RECORDING_STARTING" -> {
            Log.d("onRecordingStateChanged", "Meeting recording is starting")
        }
        "RECORDING_STARTED" -> {
            Log.d("onRecordingStateChanged", "Meeting recording is started")
        }
        "RECORDING_STOPPING" -> {
            Log.d("onRecordingStateChanged", "Meeting recording is stopping")
        }
        "RECORDING_STOPPED" -> {
            Log.d("onRecordingStateChanged", "Meeting recording is stopped")
        }
    }
  }
}

override fun onCreate(savedInstanceState: Bundle?) {
  //...

  // add listener to meeting
  //highlight-next-line
  meeting!!.addEventListener(meetingEventListener)
}
```

</TabItem>

<TabItem value="Java">

```js
private final MeetingEventListener meetingEventListener = new MeetingEventListener() {
  @Override
  public void onRecordingStateChanged(String recordingState) {
      switch (recordingState) {
          case "RECORDING_STARTING":
              Log.d("onRecordingStateChanged", "Meeting recording is starting");
              break;
          case "RECORDING_STARTED":
              Log.d("onRecordingStateChanged", "Meeting recording is started");
              break;
          case "RECORDING_STOPPING":
              Log.d("onRecordingStateChanged", "Meeting recording is stopping");
              break;
          case "RECORDING_STOPPED":
              Log.d("onRecordingStateChanged", "Meeting recording is stopped");
              break;
      }
  }
}

@Override
protected void onCreate(Bundle savedInstanceState) {
  //...

  // add listener to meeting
  //highlight-next-line
  meeting.addEventListener(meetingEventListener);
}
```

</TabItem>

</Tabs>

## Webhook associated with Recording

### recording-starting

- A "Recording Starting" webhook is triggered when the recording process for a meeting is initiated.

###### Example

```javascript
{
    "webhookType": "recording-starting",
    "data": {
        "meetingId": "jvsg-8rjn-j304",
        "sessionId": "613731342f27f56e4fc4b6d0",
    },
}
```

---

### recording-started

- Recording started webhook will be received when successfully recording is started in meeting

###### Example

```javascript
{
    "webhookType": "recording-started",
    "data": {
        "meetingId": "jvsg-8rjn-j304",
        "sessionId": "613731342f27f56e4fc4b6d0",
    },
}
```

---

### recording-stopping

- A "Recording Stopping" webhook is triggered when the recording end process for a meeting is initiated.

###### Example

```javascript
{
    "webhookType": "recording-stopping",
    "data": {
        "meetingId": "jvsg-8rjn-j304",
        "sessionId": "613731342f27f56e4fc4b6d0",
    },
}
```

---

### recording-stopped

- Recording stopped webhook will be received when recording is successfully stopped in meeting.

###### Example

```javascript
{
    "webhookType": "recording-stopped",
    "data": {
        "meetingId": "jvsg-8rjn-j304",
        "sessionId": "613731342f27f56e4fc4b6d0",
        "filePath" : "/encoded/videos/62d148951a1eb20029fc9b05.mp4",
        "fileUrl" : "https://cdn.videosdk.live/encoded/videos/62d148951a1eb20029fc9b05.mp4",

    },
}
```

---

### recording-failed

- A "Recording Failed" webhook is generated when the recording process encounters an interruption or issue during either the starting or stopping phases.

###### Example

```javascript
{
    "webhookType": "recording-failed",
    "data": {
        "meetingId": "jvsg-8rjn-j304",
        "sessionId": "613731342f27f56e4fc4b6d0",
    },
}
```


---

---
title: Interactive Livestream - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: Interactive Livestream features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Interactive Livestream (HLS)
pagination_label: Interactive Livestream (HLS)
keywords:
  - Start HLS meeting
  - Stop HLS meeting
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: interactive-livestream
---

# Interactive Livestream (HLS) - Android

Interactive live streaming (HLS) refers to a type of live streaming where viewers can actively engage with the content being streamed and with other viewers in real-time.

In an interactive live stream (HLS), viewers can take part in a variety of activities like live polling, Q&A sessions, and even sending virtual gifts to the content creator or each other.

<center>

<img src='https://cdn.videosdk.live/website-resources/docs-resources/mobile_hls.png' />

</center>

VideoSDK also allows you to configure the interactive livestream layouts in numerous ways like by simply setting different prebuilt layouts in the configuration or by providing your own custom template to do the livestream according to your layout choice.

This guide will provide an overview of how to implement start and stop Interactive live streaming (HLS).

:::important

To initiate automatic Interactive live streaming (HLS) at the beginning of a `session`, simply provide the `autoStartConfig` feature `hls` during `room` creation. For more information on configuring the `autoStartConfig`, please refer to the provided documentation **[<u>here</u>](/api-reference/realtime-communication/create-room#autoStartConfig)**.

:::

### `startHls()`

`startHls()` can be used to start a interactive livestream of the meeting which can be accessed from the `Meeting` class. This method accepts two parameter:

- `config`: This parameter will define how the interactive livestream layout should look like.

- `transcription`: This parameter lets you start post transcription for the Livestreaming.


import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
val config = JSONObject()

//highlight-next-line
// Layout Configuration
val layout = JSONObject()
JsonUtils.jsonPut(layout, "type", "GRID") // "SPOTLIGHT" | "SIDEBAR",  Default : "GRID"
JsonUtils.jsonPut(layout, "priority", "SPEAKER") // "PIN", Default : "SPEAKER"
JsonUtils.jsonPut(layout, "gridSize", 4) // MAX : 25
JsonUtils.jsonPut(config, "layout", layout)

//highlight-next-line
// Theme of interactive livestream layout
JsonUtils.jsonPut(config, "theme", "DARK") //  "LIGHT" | "DEFAULT"

//highlight-next-line
// `mode` is used to either interactive livestream video & audio both or only audio.
JsonUtils.jsonPut(config, "mode", "video-and-audio") // "audio", Default : "video-and-audio"

//highlight-next-line
// Quality of interactive livestream and is only applicable to `video-and-audio` type mode.
JsonUtils.jsonPut(config, "quality", "high") // "low" | "med",  Default : "med"

//highlight-start
// This mode refers to orientation of interactive livestream.
// landscape : Start interactive livestream of the meeting in horizontally
// portrait : Start interactive livestream of the meeting in vertically (Best for mobile view)
//highlight-end
JsonUtils.jsonPut(config, "orientation", "portrait") // "landscape",  Default : "landscape"

//highlight-next-line
// Post Transcription Configuration
val prompt = "Write summary in sections like Title, Agenda, Speakers, Action Items, Outlines, Notes and Summary"
val summaryConfig = SummaryConfig(true, prompt)
val modelId = "raman_v1"
val transcription = PostTranscriptionConfig(true, summaryConfig, modelId)

meeting.startHls(config, transcription)
```

</TabItem>

<TabItem value="Java">

```js
JSONObject config = new JSONObject();

//highlight-next-line
// Layout Configuration
JSONObject layout = new JSONObject();
JsonUtils.jsonPut(layout, "type", "GRID"); // "SPOTLIGHT" | "SIDEBAR",  Default : "GRID"
JsonUtils.jsonPut(layout, "priority", "SPEAKER");  // "PIN", Default : "SPEAKER"
JsonUtils.jsonPut(layout, "gridSize", 4); // MAX : 25
JsonUtils.jsonPut(config, "layout", layout);

//highlight-next-line
// Theme of interactive livestream layout
JsonUtils.jsonPut(config, "theme", "DARK"); //  "LIGHT" | "DEFAULT"

//highlight-next-line
// `mode` is used to either interactive livestream video & audio both or only audio.
JsonUtils.jsonPut(config, "mode", "video-and-audio"); // "audio", Default : "video-and-audio"

//highlight-next-line
// Quality of interactive livestream and is only applicable to `video-and-audio` type mode.
JsonUtils.jsonPut(config, "quality", "high"); // "low" | "med",  Default : "med"

//highlight-start
// This mode refers to orientation of interactive livestream.
// landscape : Start interactive livestream of the meeting in horizontally
// portrait : Start interactive livestream of the meeting in vertically (Best for mobile view)
//highlight-end
JsonUtils.jsonPut(config, "orientation", "portrait"); // "landscape",  Default : "landscape"

//highlight-next-line
// Post Transcription Configuration
String prompt = "Write summary in sections like Title, Agenda, Speakers, Action Items, Outlines, Notes and Summary";
SummaryConfig summaryConfig = new SummaryConfig(true, prompt);
String modelId = "raman_v1";
PostTranscriptionConfig transcription = new PostTranscriptionConfig(true, summaryConfig, modelId);

meeting.startHls(config, transcription);
```

</TabItem>

</Tabs>

### `stopHls()`

- `stopHls()` is used to stop interactive livestream of the meeting which can be accessed from the `Meeting` class.

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
// keep track of hls
val hls = false

findViewById<View>(R.id.btnHls).setOnClickListener { view: View? ->
  if (!hls) {
    //highlight-start
    val config = JSONObject()
    val layout = JSONObject()
    JsonUtils.jsonPut(layout, "type", "GRID")
    JsonUtils.jsonPut(layout, "priority", "SPEAKER")
    JsonUtils.jsonPut(layout, "gridSize", 4)
    JsonUtils.jsonPut(config, "layout", layout)
    JsonUtils.jsonPut(config, "theme", "DARK")
    JsonUtils.jsonPut(config, "mode", "video-and-audio")
    JsonUtils.jsonPut(config, "quality", "high")
    JsonUtils.jsonPut(config, "orientation", "portrait")
    //highlight-end

    //highlight-next-line
    // Post Transcription Configuration
    val prompt = "Write summary in sections like Title, Agenda, Speakers, Action Items, Outlines, Notes and Summary"
    val summaryConfig = SummaryConfig(true, prompt)
    val modelId = "raman_v1"
    val transcription = PostTranscriptionConfig(true, summaryConfig, modelId)

    // Start Hls
    //highlight-next-line
    meeting!!.startHls(config)
  } else {
    // Stop Hls
    //highlight-next-line
    meeting!!.stopHls()
  }
}
```

</TabItem>

<TabItem value="Java">

```js
// keep track of hls
boolean hls = false;

findViewById(R.id.btnHls).setOnClickListener(view -> {
  if (!hls) {
    //highlight-start
    JSONObject config = new JSONObject();
    JSONObject layout = new JSONObject();
    JsonUtils.jsonPut(layout, "type", "GRID");
    JsonUtils.jsonPut(layout, "priority", "SPEAKER");
    JsonUtils.jsonPut(layout, "gridSize", 4);
    JsonUtils.jsonPut(config, "layout", layout);
    JsonUtils.jsonPut(config, "theme", "DARK");
    JsonUtils.jsonPut(config, "mode", "video-and-audio");
    JsonUtils.jsonPut(config, "quality", "high");
    JsonUtils.jsonPut(config, "orientation", "portrait");
    //highlight-end

    //highlight-next-line
    // Post Transcription Configuration
    String prompt = "Write summary in sections like Title, Agenda, Speakers, Action Items, Outlines, Notes and Summary";
    SummaryConfig summaryConfig = new SummaryConfig(true, prompt);
    String modelId = "raman_v1";
    PostTranscriptionConfig transcription = new PostTranscriptionConfig(true, summaryConfig, modelId);
    
    // Start Hls
    //highlight-next-line
    meeting.startHls(config);
  } else {
    // Stop Hls
    //highlight-next-line
    meeting.stopHls();
  }
});
```

</TabItem>

</Tabs>

:::tip
If you want to learn more about the Interactive Livestream and how you can implement it in your own platform, you can checkout this [guide](/android/guide/interactive-live-streaming/integrate-hls/overview).
:::

### Event associated with HLS

- **onHlsStateChanged** - Whenever meeting HLS state changes, then `onHlsStateChanged` event will trigger.

- You can get the `playbackHlsUrl` and `livestreamUrl` of the HLS to play it on the Viewer side when the state changes to `HLS_PLAYABLE`.
  - `playbackHlsUrl` - Live HLS with playback support
  - `livestreamUrl` - Live HLS without playback support

:::note
`downstreamUrl` is now depecated. Use `playbackHlsUrl` or `livestreamUrl` in place of `downstreamUrl`
:::

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
private val meetingEventListener: MeetingEventListener = object : MeetingEventListener() {
  override fun onHlsStateChanged(HlsState: JSONObject) {
    when (HlsState.getString("status")) {
        "HLS_STARTING" -> Log.d("onHlsStateChanged", "Meeting hls is starting")
        "HLS_STARTED" -> Log.d("onHlsStateChanged", "Meeting hls is started")
        "HLS_PLAYABLE" -> {
            Log.d("onHlsStateChanged", "Meeting hls is playable now")
            //highlight-start
             // on hls playable you will receive playbackHlsUrl and livestreamUrl
            val playbackHlsUrl = HlsState.getString("playbackHlsUrl")
            val livestreamUrl = HlsState.getString("livestreamUrl")
            //highlight-end
        }
        "HLS_STOPPING" -> Log.d("onHlsStateChanged", "Meeting hls is stopping")
        "HLS_STOPPED" -> Log.d("onHlsStateChanged", "Meeting hls is stopped")
    }
  }
}

override fun onCreate(savedInstanceState: Bundle?) {
  //...

  // add listener to meeting
  //highlight-next-line
  meeting!!.addEventListener(meetingEventListener)
}
```

</TabItem>

<TabItem value="Java">

```js
private final MeetingEventListener meetingEventListener = new MeetingEventListener() {
  @Override
  public void onHlsStateChanged(JSONObject HlsState) {
      switch (HlsState.getString("status")) {
          case "HLS_STARTING":
              Log.d("onHlsStateChanged", "Meeting hls is starting");
              break;
          case "HLS_STARTED":
              Log.d("onHlsStateChanged", "Meeting hls is started");
              break;
          case "HLS_PLAYABLE":
              Log.d("onHlsStateChanged", "Meeting hls is playable now");
              //highlight-start
              // on hls started you will receive playbackHlsUrl and livestreamUrl
              String playbackHlsUrl = HlsState.getString("playbackHlsUrl");
              String livestreamUrl = HlsState.getString("livestreamUrl");
              //highlight-end
              break;
          case "HLS_STOPPING":
              Log.d("onHlsStateChanged", "Meeting hls is stopping");
              break;
          case "HLS_STOPPED":
              Log.d("onHlsStateChanged", "Meeting hls is stopped");
              break;
      }
  }
}

@Override
protected void onCreate(Bundle savedInstanceState) {
  //...

  // add listener to meeting
  //highlight-next-line
  meeting.addEventListener(meetingEventListener);
}
```

</TabItem>

</Tabs>

### Custom Template

With VideoSDK, you can also use your own custom designed layout template to livestream the meetings. In order to use the custom template, you need to create a template for which you can [follow this guide](/react/guide/interactive-live-streaming/custom-template). Once you have setup the template, you can use the [REST API to start](/api-reference/realtime-communication/start-livestream) the livestream with the `templateURL` parameter.

### API Reference

The API references for all the methods utilised in this guide are provided below.

- [startHls()](/android/api/sdk-reference/meeting-class/methods#starthls)
- [stopHls()](/android/api/sdk-reference/meeting-class/methods#stophls)
- [onHlsStateChanged](/android/api/sdk-reference/meeting-class/meeting-event-listener-class#onhlsstatechanged)
- [autoStartConfig](/api-reference/realtime-communication/create-room#autoStartConfig)


---

---
title: Record Meeting Video & Audio Call - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: Record Meeting features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Record Meeting
pagination_label: Record Meeting
keywords:
  - Start Recording meeting
  - Stop Recording meeting
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: record-meeting
---

# Record Meeting - Android

VideoSDK allows you to record video & audio during the meeting. The recording files are available in developer dashboard or you can also choose to store them in your own cloud storage.

VideoSDK also allows you to configure the recording layouts in numerous ways like by simply setting different prebuilt layouts in the configuration or by providing your own custom template to do the recording according to your layout choice.

This guide will provide an overview of how to implement start and stop Meeting Recording.

:::important

To initiate automatic recording at the beginning of a `session`, simply provide the `autoStartConfig` feature `recording` during `room` creation. For more information on configuring the `autoStartConfig`, please refer to the provided documentation **[<u>here</u>](/api-reference/realtime-communication/create-room#autoStartConfig)**.

:::

### `startRecording()`

`startRecording()` can be used to start a recording of the meeting which can be accessed from the `Meeting` class. This method accepts four parameters:

- `1. webhookUrl`: This would the webhook URL where you would like to listen to event happening for the recording like starting and stopping of recording. It will be triggered when the recording is completed and stored into server. Read more about webhooks [here](https://en.wikipedia.org/wiki/Webhook)

- `2. awsDirPath`: This parameter accepts the path for the your S3 bucket where you want to store recordings to. To allow us to store recording in your S3 bucket, you will need to fill this form by providing the required values. ([VideoSDK Cloud (AWS S3, Azure Blob or GCP ) Integration](/android/guide/video-and-audio-calling-api-sdk/recording/recording-storage-config))

- `3. config`: This parameter will define how the meeting should be recorded.

- `4. transcription`: This parameter lets you start post transcription for the recording.

:::note

If you don't have a value for `webhookUrl`,`awsDirPath` or `config`, you should pass `null` in place of the missing value. If you pass `null` in `awsDirPath` parameter then by default recordings will be store on the VideoSDK's storage.
:::

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
val config = JSONObject()

//highlight-next-line
// Layout Configuration
val layout = JSONObject()
JsonUtils.jsonPut(layout, "type", "GRID") // "SPOTLIGHT" | "SIDEBAR",  Default : "GRID"
JsonUtils.jsonPut(layout, "priority", "SPEAKER") // "PIN", Default : "SPEAKER"
JsonUtils.jsonPut(layout, "gridSize", 4) // MAX : 4
JsonUtils.jsonPut(config, "layout", layout)

//highlight-next-line
// Theme of recording
JsonUtils.jsonPut(config, "theme", "DARK") //  "LIGHT" | "DEFAULT"

//highlight-next-line
// `mode` is used to either record video & audio both or only audio.
JsonUtils.jsonPut(config, "mode", "video-and-audio") // "audio", Default : "video-and-audio"

//highlight-next-line
// Quality of recording and is only applicable to `video-and-audio` type mode.
JsonUtils.jsonPut(config, "quality", "high") // "low" | "med",  Default : "med"

//highlight-start
// This mode refers to orientation of recording.
// landscape : Record the meeting in horizontally
// portrait : Record the meeting in vertically (Best for mobile view)
//highlight-end
JsonUtils.jsonPut(config, "orientation", "portrait") // "landscape",  Default : "landscape"

//highlight-next-line
// Post Transcription Configuration
val prompt = "Write summary in sections like Title, Agenda, Speakers, Action Items, Outlines, Notes and Summary"
val summaryConfig = SummaryConfig(true, prompt)
val modelId = "raman_v1"
val transcription = PostTranscriptionConfig(true, summaryConfig, modelId)

meeting.startRecording(null, null, config, transcription)
```

</TabItem>

<TabItem value="Java">

```js
JSONObject config = new JSONObject();

//highlight-next-line
// Layout Configuration
JSONObject layout = new JSONObject();
JsonUtils.jsonPut(layout, "type", "GRID"); // "SPOTLIGHT" | "SIDEBAR",  Default : "GRID"
JsonUtils.jsonPut(layout, "priority", "SPEAKER");  // "PIN", Default : "SPEAKER"
JsonUtils.jsonPut(layout, "gridSize", 4); // MAX : 4
JsonUtils.jsonPut(config, "layout", layout);

//highlight-next-line
// Theme of recording
JsonUtils.jsonPut(config, "theme", "DARK"); //  "LIGHT" | "DEFAULT"

//highlight-next-line
// `mode` is used to either record video & audio both or only audio.
JsonUtils.jsonPut(config, "mode", "video-and-audio"); // "audio", Default : "video-and-audio"

//highlight-next-line
// Quality of recording and is only applicable to `video-and-audio` type mode.
JsonUtils.jsonPut(config, "quality", "high"); // "low" | "med",  Default : "med"

//highlight-start
// This mode refers to orientation of recording.
// landscape : Record the meeting in horizontally
// portrait : Record the meeting in vertically (Best for mobile view)
//highlight-end
JsonUtils.jsonPut(config, "orientation", "portrait"); // "landscape",  Default : "landscape"

//highlight-next-line
// Post Transcription Configuration
String prompt = "Write summary in sections like Title, Agenda, Speakers, Action Items, Outlines, Notes and Summary";
SummaryConfig summaryConfig = new SummaryConfig(true, prompt);
String modelId = "raman_v1";
PostTranscriptionConfig transcription = new PostTranscriptionConfig(true, summaryConfig, modelId);

meeting.startRecording(null, null, config, transcription);
```

</TabItem>

</Tabs>

### `stopRecording()`

- `stopRecording()` is used to stop the meeting recording which can be accessed from the `Meeting` class.

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
// keep track of recording
val recording = false

findViewById<View>(R.id.btnRecording).setOnClickListener { view: View? ->
    if (!recording) {
      //highlight-start
      val config = JSONObject()
      val layout = JSONObject()
      JsonUtils.jsonPut(layout, "type", "GRID")
      JsonUtils.jsonPut(layout, "priority", "SPEAKER")
      JsonUtils.jsonPut(layout, "gridSize", 4)
      JsonUtils.jsonPut(config, "layout", layout)
      JsonUtils.jsonPut(config, "theme", "DARK")
      JsonUtils.jsonPut(config, "mode", "video-and-audio")
      JsonUtils.jsonPut(config, "quality", "high")
      JsonUtils.jsonPut(config, "orientation", "portrait")
      //highlight-end

      //highlight-next-line
      // Post Transcription Configuration
      val prompt = "Write summary in sections like Title, Agenda, Speakers, Action Items, Outlines, Notes and Summary"
      val summaryConfig = SummaryConfig(true, prompt)
      val modelId = "raman_v1"
      val transcription = PostTranscriptionConfig(true, summaryConfig, modelId)

      // Start Recording
      // If you don't have a `webhookUrl` or `awsDirPath`, you should pass null.
      // If you don't want to enable transcription, you can pass null as parameter.
      //highlight-next-line
      meeting!!.startRecording("YOUR WEB HOOK URL", "AWS Directory Path", config, transcription)
    } else {
      // Stop Recording
      //highlight-next-line
      meeting!!.stopRecording()
    }
}
```

</TabItem>

<TabItem value="Java">

```js
// keep track of recording
boolean recording = false;

findViewById(R.id.btnRecording).setOnClickListener(view -> {
    if (!recording) {
      //highlight-start
      JSONObject config = new JSONObject();
      JSONObject layout = new JSONObject();
      JsonUtils.jsonPut(layout, "type", "GRID");
      JsonUtils.jsonPut(layout, "priority", "SPEAKER");
      JsonUtils.jsonPut(layout, "gridSize", 4);
      JsonUtils.jsonPut(config, "layout", layout);
      JsonUtils.jsonPut(config, "theme", "DARK");
      JsonUtils.jsonPut(config, "mode", "video-and-audio");
      JsonUtils.jsonPut(config, "quality", "high");
      JsonUtils.jsonPut(config, "orientation", "portrait");
      //highlight-end

      //highlight-next-line
      // Post Transcription Configuration
      String prompt = "Write summary in sections like Title, Agenda, Speakers, Action Items, Outlines, Notes and Summary";
      SummaryConfig summaryConfig = new SummaryConfig(true, prompt);
      String modelId = "raman_v1";
      PostTranscriptionConfig transcription = new PostTranscriptionConfig(true, summaryConfig, modelId);

      // Start Recording
      // If you don't have a `webhookUrl` or `awsDirPath`, you should pass null.
      // If you don't want to enable transcription, you can pass null as parameter.
      //highlight-next-line
      meeting.startRecording("YOUR WEB HOOK URL", "AWS Directory Path", config, transcription);
    } else {
      // Stop Recording
      //highlight-next-line
      meeting.stopRecording();
    }
});
```

</TabItem>

</Tabs>

### Event associated with Recording

- **onRecordingStateChanged** - Whenever meeting recording state changes, then `onRecordingStateChanged` event will trigger.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
private val meetingEventListener: MeetingEventListener = object : MeetingEventListener() {
  override fun onRecordingStateChanged(recordingState: String) {
    when (recordingState) {
        "RECORDING_STARTING" -> {
            Log.d("onRecordingStateChanged", "Meeting recording is starting")
        }
        "RECORDING_STARTED" -> {
            Log.d("onRecordingStateChanged", "Meeting recording is started")
        }
        "RECORDING_STOPPING" -> {
            Log.d("onRecordingStateChanged", "Meeting recording is stopping")
        }
        "RECORDING_STOPPED" -> {
            Log.d("onRecordingStateChanged", "Meeting recording is stopped")
        }
    }
  }
}

override fun onCreate(savedInstanceState: Bundle?) {
  //...

  // add listener to meeting
  //highlight-next-line
  meeting!!.addEventListener(meetingEventListener)
}
```

</TabItem>

<TabItem value="Java">

```js
private final MeetingEventListener meetingEventListener = new MeetingEventListener() {
  @Override
  public void onRecordingStateChanged(String recordingState) {
      switch (recordingState) {
          case "RECORDING_STARTING":
              Log.d("onRecordingStateChanged", "Meeting recording is starting");
              break;
          case "RECORDING_STARTED":
              Log.d("onRecordingStateChanged", "Meeting recording is started");
              break;
          case "RECORDING_STOPPING":
              Log.d("onRecordingStateChanged", "Meeting recording is stopping");
              break;
          case "RECORDING_STOPPED":
              Log.d("onRecordingStateChanged", "Meeting recording is stopped");
              break;
      }
  }
}

@Override
protected void onCreate(Bundle savedInstanceState) {
  //...

  // add listener to meeting
  //highlight-next-line
  meeting.addEventListener(meetingEventListener);
}
```

</TabItem>

</Tabs>

### Storage Configuration

While recording your meetings, you can choose to store them on the VideoSDK's storage or you can also configure your own **`AWS S3 Storage, Azure Blob or GCP Cloud Storage`** to store the meeting recordings directly on your storage.

You can configure your own **`AWS S3 Storage, Azure Blob or GCP Cloud Storage`** from the [VideoSDK Dashboard's API section](https://app.videosdk.live/api-keys).

You can also go through this [guide to setup](/docs/tutorials/user-dashboard/recording-storage-config) the storage or watch this [video to configure](https://www.loom.com/share/23a2617f824a4a5da004d14d1a541a9d) your storage.

### Custom Template

With VideoSDK, you can also use your own custom designed layout template to record the meetings. In order to use the custom template, you need to create a template for which you can [follow this guide](/react/guide/interactive-live-streaming/custom-template). Once you have setup the template, you can use the [REST API to start](/api-reference/realtime-communication/start-recording) the recording with the `templateURL` parameter.

### API Reference

The API references for all the methods utilised in this guide are provided below.

- [startRecording()](/android/api/sdk-reference/meeting-class/methods#startrecording)
- [stopRecording()](/android/api/sdk-reference/meeting-class/methods#stoprecording)
- [onRecordingStateChanged](/android/api/sdk-reference/meeting-class/meeting-event-listener-class#onrecordingstatechanged)
- [autoStartConfig](/api-reference/realtime-communication/create-room#autoStartConfig)


---

---
title: RTMP Livestream - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: RTMP Livestream features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: RTMP Livestream
pagination_label: RTMP Livestream
keywords:
  - Start Livestream meeting
  - Stop Livestream meeting
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: rtmp-livestream
---

# RTMP Livestream - Android

RTMP is a popular protocol for live streaming video content from a VideoSDK to platforms such as YouTube, Twitch, Facebook, and others.

By providing the platform-specific stream key and stream URL, the VideoSDK can connect to the platform's RTMP server and transmit the live video stream.

VideoSDK allows you to livestream your meeting to platform which support RTMP ingestion just by providing the platform-specific stream key and stream URL, we can connect to the platform's RTMP server and transmit the live video stream.

VideoSDK also allows you to configure the livestream layouts in numerous ways like by simply setting different prebuilt layouts in the configuration or by providing your own custom template to do the livestream according to your layout choice.

This guide will provide an overview of how to implement start and stop RTMP Livestreaming.

### `startLivestream()`

`startLivestream()` can be used to start a RTMP livestream of the meeting which can be accessed from the `Meeting` class. This method accepts two parameters:

- `1. outputs`: This parameter accepts a list of `LivestreamOutput` objects which contains the RTMP `url` and `streamKey` of the platforms you want to start the livestream.

- `2. config`: This parameter will define how the livestream layout should look like. You can pass `null` for default layout.

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
val config = JSONObject()

//highlight-next-line
// Layout Configuration
val layout = JSONObject()
JsonUtils.jsonPut(layout, "type", "GRID") // "SPOTLIGHT" | "SIDEBAR",  Default : "GRID"
JsonUtils.jsonPut(layout, "priority", "SPEAKER") // "PIN", Default : "SPEAKER"
JsonUtils.jsonPut(layout, "gridSize", 4) // MAX : 4
JsonUtils.jsonPut(config, "layout", layout)

//highlight-next-line
// Theme of livestream layout
JsonUtils.jsonPut(config, "theme", "DARK") //  "LIGHT" | "DEFAULT"

val outputs: MutableList<LivestreamOutput> = ArrayList()
outputs.add(LivestreamOutput(RTMP_URL, RTMP_STREAM_KEY))

meeting!!.startLivestream(outputs,config)
```

</TabItem>

<TabItem value="Java">

```js
JSONObject config = new JSONObject();

//highlight-next-line
// Layout Configuration
JSONObject layout = new JSONObject();
JsonUtils.jsonPut(layout, "type", "GRID"); // "SPOTLIGHT" | "SIDEBAR",  Default : "GRID"
JsonUtils.jsonPut(layout, "priority", "SPEAKER");  // "PIN", Default : "SPEAKER"
JsonUtils.jsonPut(layout, "gridSize", 4); // MAX : 4
JsonUtils.jsonPut(config, "layout", layout);

//highlight-next-line
// Theme of livestream layout
JsonUtils.jsonPut(config, "theme", "DARK"); //  "LIGHT" | "DEFAULT"

List<LivestreamOutput> outputs = new ArrayList<>();
outputs.add(new LivestreamOutput(RTMP_URL, RTMP_STREAM_KEY));

meeting.startLivestream(outputs,config);
```

</TabItem>

</Tabs>

### `stopLivestream()`

- `stopLivestream()` is used to stop the meeting livestream which can be accessed from the `Meeting` class.

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
// keep track of livestream status
val liveStream = false

findViewById<View>(R.id.btnLiveStream).setOnClickListener { view: View? ->
  if (!liveStream) {
    //highlight-start
    val config = JSONObject()
    val layout = JSONObject()
    JsonUtils.jsonPut(layout, "type", "GRID")
    JsonUtils.jsonPut(layout, "priority", "SPEAKER")
    JsonUtils.jsonPut(layout, "gridSize", 4)
    JsonUtils.jsonPut(config, "layout", layout)
    JsonUtils.jsonPut(config, "theme", "DARK")
    //highlight-end

    val outputs: MutableList<LivestreamOutput> = ArrayList()
    //highlight-next-line
    outputs.add(LivestreamOutput(RTMP_URL, RTMP_STREAM_KEY))

    // Start LiveStream
    //highlight-next-line
    meeting!!.startLivestream(outputs,config)
  } else {
    // Stop LiveStream
    //highlight-next-line
    meeting!!.stopLivestream()
  }
}
```

</TabItem>

<TabItem value="Java">

```js
// keep track of livestream status
boolean liveStream = false;

findViewById(R.id.btnLiveStream).setOnClickListener(view -> {
  if (!liveStream) {
    //highlight-start
    JSONObject config = new JSONObject();
    JSONObject layout = new JSONObject();
    JsonUtils.jsonPut(layout, "type", "GRID");
    JsonUtils.jsonPut(layout, "priority", "SPEAKER");
    JsonUtils.jsonPut(layout, "gridSize", 4);
    JsonUtils.jsonPut(config, "layout", layout);
    JsonUtils.jsonPut(config, "theme", "DARK");
    //highlight-end

    List<LivestreamOutput> outputs = new ArrayList<>();
    //highlight-next-line
    outputs.add(new LivestreamOutput(RTMP_URL, RTMP_STREAM_KEY));

    // Start LiveStream
    //highlight-next-line
    meeting.startLivestream(outputs,config);
  } else {
    // Stop LiveStream
    //highlight-next-line
    meeting.stopLivestream();
  }
});
```

</TabItem>

</Tabs>

### Event associated with Livestream

- **onLivestreamStateChanged** - Whenever meeting livestream state changes, then `onLivestreamStateChanged` event will trigger.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
private val meetingEventListener: MeetingEventListener = object : MeetingEventListener() {
  override fun onLivestreamStateChanged(livestreamState: String?) {
    when (livestreamState) {
      "LIVESTREAM_STARTING" -> Log.d( "LivestreamStateChanged",
          "Meeting livestream is starting"
      )
      "LIVESTREAM_STARTED" -> Log.d( "LivestreamStateChanged",
          "Meeting livestream is started"
      )
      "LIVESTREAM_STOPPING" -> Log.d("LivestreamStateChanged",
          "Meeting livestream is stopping"
      )
      "LIVESTREAM_STOPPED" -> Log.d("LivestreamStateChanged",
          "Meeting livestream is stopped"
      )
    }
  }
}

override fun onCreate(savedInstanceState: Bundle?) {
  //...

  // add listener to meeting
  //highlight-next-line
  meeting!!.addEventListener(meetingEventListener)
}
```

</TabItem>

<TabItem value="Java">

```js
private final MeetingEventListener meetingEventListener = new MeetingEventListener() {
  @Override
  public void onLivestreamStateChanged(String livestreamState) {
    switch (livestreamState) {
      case "LIVESTREAM_STARTING":
          Log.d("LivestreamStateChanged", "Meeting livestream is starting");
          break;
      case "LIVESTREAM_STARTED":
          Log.d("LivestreamStateChanged", "Meeting livestream is started");
          break;
      case "LIVESTREAM_STOPPING":
          Log.d("LivestreamStateChanged", "Meeting livestream is stopping");
          break;
      case "LIVESTREAM_STOPPED":
          Log.d("LivestreamStateChanged", "Meeting livestream is stopped");
          break;
    }
  }
}

@Override
protected void onCreate(Bundle savedInstanceState) {
  //...

  // add listener to meeting
  //highlight-next-line
  meeting.addEventListener(meetingEventListener);
}
```

</TabItem>

</Tabs>

### Custom Template

With VideoSDK, you can also use your own custom designed layout template to livestream the meetings. In order to use the custom template, you need to create a template for which you can [follow this guide](/react/guide/interactive-live-streaming/custom-template). Once you have setup the template, you can use the [REST API to start](/api-reference/realtime-communication/start-livestream) the livestream with the `templateURL` parameter.

### API Reference

The API references for all the methods utilised in this guide are provided below.

- [startLivestream()](/android/api/sdk-reference/meeting-class/methods#startlivestream)
- [stopLivestream()](/android/api/sdk-reference/meeting-class/methods#stoplivestream)
- [onLivestreamStateChanged](/android/api/sdk-reference/meeting-class/meeting-event-listener-class#onlivestreamstatechanged)


---

---
sidebar_label: Release Notes
pagination_label: Release Notes
---

# Release Notes - Android

This page will keep you update all the releases of Android SDK.

## v0.2.0

**Release Date** : 22nd Jan 2025

Change Log :

- **Deprecated Modes:** Replaced `CONFERENCE` with `SEND_AND_RECV` and `VIEWER` with `SIGNALLING_ONLY`.
- **New Mode:** Added `RECV_ONLY` for live streaming, allowing participants to receive media only.
- **Role Switching:** Enabled seamless role switching between `SEND_AND_RECV` (host) and `RECV_ONLY` (audience) using `changeMode()` of Meeting Class.

**Docs:** [Quick Start for Interactive Live Streaming](./quick-start-android-ils)

---

## v0.1.38

**Release Date** : 27th December 2024

**Change Log** :

- Added `h360p_w640p` encode configuration for `oneSixNine` aspect ratio.
- Updated video profile configurations to support adaptive bitrate.
- Updated layer configurations for simulcast.

**Bug Fix** :

- Resolved screen sharing issue on Android 14.
- Fixed an ANR issue occurring when the app resumes from the background.

---

## v0.1.37

**Release Date** : 30th October 2024

**Change Log** :

- Provided Methods and Events for Managing the Whiteboard.

  **Docs** : [Start/Stop Whiteboard](/android/guide/video-and-audio-calling-api-sdk/collaboration-in-meeting/whiteboard)  
  **Docs** : [Render Whiteboard](/android/guide/video-and-audio-calling-api-sdk/collaboration-in-meeting/render-whiteboard)

**Bug Fix** :

- Handle the case when the camera list is empty or no camera found with specified facingMode.

---

## v0.1.36

**Release Date** : 24th September 2024

**Change Log** :

- Update internal dependency
- Added the `setEnableActivityLifecycle()` method to control whether the camera is turned off when the app goes to the background.

---

## v0.1.34

**Release Date** : 20th August 2024

**Change Log** :

- Provided methods to set custom video processor.

  **Docs** : [Video Processor](../../guide/video-and-audio-calling-api-sdk/video-processor/overview.md)

- Provided methods for Virtual Background Effect through `MediaEffects` library.

  **Docs** : [Virtual Background](../../guide/video-and-audio-calling-api-sdk/render-media/virtual-background.md)

---

## v0.1.33

**Release Date** : 10th August 2024

**Change Log** :

- Added `RendererEvents` parameter in `addTrack()` method.

- Change the default value of `PreferredProtocol` to `UDP_OVER_TCP`

---

## v0.1.32

**Release Date** : 26th July 2024

**Change Log** :

- Improved error handling and emitting more precise errors on `onError` event.

**Docs** : [Error Event](../video-and-audio-calling-api-sdk/get-notified/error-events.md)

| Constant                                     | Code | Message                                                                                                                  |
| -------------------------------------------- | ---- | ------------------------------------------------------------------------------------------------------------------------ |
| ERROR_ACTION_PERFORMED_BEFORE_MEETING_JOINED | 3001 | The meeting is not connected yet. All actions on meeting should be performed after meeting is joined successfully.       |
| ERROR_CAMERA_ACCESS                          | 3002 | Something went wrong. Unable to access camera.                                                                           |
| ERROR_MIC_ACCESS_DENIED                      | 3003 | It seems like microphone access was denied or dismissed. To proceed, kindly grant access through your device's settings. |
| ERROR_CAMERA_ACCESS_DENIED                   | 3004 | It seems like camera access was denied or dismissed. To proceed, kindly grant access through your device's settings.     |
| ERROR_CUSTOM_SCREEN_SHARE_TRACK_ENDED        | 3005 | The provided custom track is in an ended state. Please try again with new custom track.                                  |
| ERROR_CUSTOM_SCREEN_SHARE_TRACK_DISPOSED     | 3006 | The provided custom track was disposed. Please try again with new custom track.                                          |
| ERROR_CHANGE_WEBCAM                          | 3007 | Something went wrong, and the camera could not be changed. Please try again.                                             |

**Bug Fix** :

- Fixed the issue of the application crashing during the `onFail()` meeting state.

---

## v0.1.31

**Release Date** : 14th July 2024

**Change Log** :

- The `changeWebcam()` method only allows switching between primary cameras.

  **Docs** : [changeWebcam()](../../api/sdk-reference/meeting-class/methods.md#changewebcam)

---

## v0.1.30

**Release Date** : 5th July 2024

**Bug Fix** :

- Fixed the issue of switching camera from front to back in devices with multiple cameras.

  **Docs** : [changeWebcam()](../../api/sdk-reference/meeting-class/methods.md#changewebcam)

**Change Log** :

- Provided `PreferredProtocol` parameter in the `initMeeting` method to specify a protocol to be used in the meeting and made `signalingBaseUrl` parameter optional.

  **Docs** : [initMeeting()](../../api/sdk-reference/videosdk-class/methods.md#initmeeting)

- Provided `modelId` parameter in post-transcription functionality for selecting a transcription model.

- Removed an internal dependency.

- Provided Pre-Call Screen features.

  - Provided `getDevices()` method in `VideoSDK` class to get list of media devices.

    **Docs** : [getDevices()](../../api/sdk-reference/videosdk-class/methods.md#getdevices)

  - Provided `getVideoDevices()` method in `VideoSDK` class to get list of camera devices.

    **Docs** : [getVideoDevices()](../../api/sdk-reference/videosdk-class/methods.md#getvideodevices)

  - Provided `getAudioDevices()` method in `VideoSDK` class to get list of audio devices.

    **Docs** : [getAudioDevices()](../../api/sdk-reference/videosdk-class/methods.md#getaudiodevices)

  - Provided `AudioDeviceChanged()` event in `VideoSDK` class, which gets triggered whenever an audio device is connected or removed from the system.

    **Docs** : [onAudioDeviceChanged()](../../api/sdk-reference/videosdk-class/events.md#onaudiodevicechanged)

  - Provided `checkPermissions()` method in `VideoSDK` class to check and request media permissions.

    **Docs** : [checkPermissions()](../../api/sdk-reference/videosdk-class/methods.md#checkpermissions)

  - Provided `setSelectedAudioDevice()` method in `VideoSDK` class to set an audio device to be used in the meeting.

    **Docs** : [setSelectedAudioDevice()](../../api/sdk-reference/videosdk-class/methods.md#setselectedaudiodevice)

  - Provided `setSelectedVideoDevice()` method in `VideoSDK` class to set a video device to be used in the meeting.

    **Docs** : [setSelectedVideoDevice()](../../api/sdk-reference/videosdk-class/methods.md#setselectedvideodevice)

  - Provided `getSelectedAudioDevice()` method in `VideoSDK` class to get the audio device, which is currently in use.

    **Docs** : [getSelectedAudioDevice()](../../api/sdk-reference/videosdk-class/properties.md#getselectedaudiodevice)

  - Provided `getSelectedVideoDevice()` method in `VideoSDK` class to get the video device, which is currently in use.

    **Docs** : [getSelectedVideoDevice()](../../api/sdk-reference/videosdk-class/properties.md#getselectedvideodevice)

---

## v0.1.29

**Release Date** : 15th June 2024

**Change Log** :

- Added `captureImage()` method in the `Participant` object to capture the image of the user from MediaStream.

  **Docs** : [captureImage()](../../api/sdk-reference/participant-class/methods#captureimage)

- Added methods `uploadBase64File()` and `fetchBase64File()` to upload and download a temporary file.

  **Docs** : [uploadBase64File()](../../api/sdk-reference/meeting-class/methods#uploadbase64file)

  **Docs** : [fetchbase64file()](../../api/sdk-reference/meeting-class/methods#fetchbase64file)

---

## v0.1.28

**Release Date** : 12th May 2024

**Change log** :

1. Introducing real-time transcription capabilities with the following methods:

   ##### Methods:

   - `startTranscription:` Easily begin real-time transcription with a single method call.

     **SDK Reference** : [startTranscription](../../api/sdk-reference/meeting-class/methods#starttranscription)

   - `stopTranscription:` Stops ongoing transcription processes seamlessly when necessary.

     **SDK Reference** : [stopTranscription](../../api/sdk-reference/meeting-class/methods#stoptranscription)

   ##### Events:

   - `onTranscriptionStateChanged:` Receive updates on transcription states, including started, stopped, and failed states.

     **SDK Reference** : [onTranscriptionStateChanged](../../api/sdk-reference/meeting-class/meeting-event-listener-class#ontranscriptionstatechanged)

   - `onTranscriptionText:` Get real-time updates of transcription text as it is generated, ensuring a responsive transcription experience.

     **SDK Reference** : [onTranscriptionText](../../api/sdk-reference/meeting-class/meeting-event-listener-class#ontranscriptiontext)

2. Introducing post-meeting transcription and summary capabilities with the recording and HLS methods:

   - `startRecording():` Begins recording the meeting and supports post-transcription and summary configuration.

     **SDK Reference** : [startRecording](../../api/sdk-reference/meeting-class/methods#startrecording)

   - `startHls():` Starts HLS streaming with options for post-transcription and summary settings.

     **SDK Reference** : [startHls](../../api/sdk-reference/meeting-class/methods#starthls)

3. Added new error code for better debugging. Checkout the list of available error codes [here](/android/api/sdk-reference/error-codes)

**Docs:** [Post Transcription & Summary](../../guide/video-and-audio-calling-api-sdk/transcription-and-summary/post-transcription.md)

**Docs:** [Realtime Transcription](../../guide/video-and-audio-calling-api-sdk/transcription-and-summary/realtime-transcription.md)

4. Provide `signalingBaseUrl` parameter in `initMeeting()` method of `VideoSDK` class to enable the usage of a proxy server with the VideoSDK.

---

## v0.1.27

**Release Date** : 25th April 2024

**Bug Fix** :

- Fixed screenShare issue for android version 14

---

## v0.1.26

**Release Date** : 12th Jan 2024

**Bug Fix** :

- Fixed landscape video issue between Firefox browser and native android SDK

---

## v0.1.25

**Release Date** : 27th Oct 2023

**Change log** :

- Added `metaData` property associated with `Participant` to pass additional information.
- Added `payload` feature in PubSub to pass additional payload data.
- Added `sendOnly` feature to PubSub to Publish data for only Participants mentioned.
- Provide `setActivityForLifeCycle()` to control camera only for specified activity.

---

## v0.1.24

**Release Date** : 6th Oct 2023

**Change log** :

- Fixed meeting end issue

---

## v0.1.23

**Release Date** : 5th Oct 2023

**Change log** :

- Change default videoTrack

**Bug Fix** :

- Fix crash issue on socket fail
- Fix Bluetooth issue for android version 13

---

## v0.1.22

**Release Date** : 24th august 2023

**Change log** :

- remove PCMU codec
- add consumer-rules

---

## v0.1.21

**Release Date** : 13th July 2023

**Bug Fix** :

- enable the camera when `onActivityResumed()` triggered

---

## v0.1.20

**Release Date** : 10th June 2023

**Bug Fix** :

- Fix bluetooth permission issue for android version 12 and higher.

---

## v0.1.18

**Release Date** : 10th May 2023

**Bug Fix** :

- Fix clash between `initMeeting` customTrack property and `enableWebcam()` customTrack property.

---

## v0.1.17

**Release Date** : 2nd May 2023

**Change log** :

- Provide `multistream` parameter for sending multiple resolution layers or single resolution layer.

  **Docs** : [Multi Stream](/android/api/sdk-reference/custom-tracks#custom-video-track---android)

---

## v0.1.15

**Release Date** : 31st March 2023

**Change log** :

- Add `HLS_PLAYABLE` state in `onHlsStateChanged` event.

  **Docs** : [onHlsStateChanged](https://docs.videosdk.live/android/api/sdk-reference/meeting-class/meeting-event-listener-class#onhlsstatechanged)

---

## v0.1.14

**Release Date** : 28th February 2023

**Change log** :

- Participant can toggle between the `CONFERENCE` and `VIEWER` mode using `changeMode()` method.

  **Docs** : [changeMode()](https://docs.videosdk.live/android/api/sdk-reference/meeting-class/methods#changemode)

- Provide `startHLS()` and `stopHLS()` method for live streaming.

  **Docs** : [startHLS()](https://docs.videosdk.live/android/api/sdk-reference/meeting-class/methods#starthls)

  **Docs** : [stopHLS()](https://docs.videosdk.live/android/api/sdk-reference/meeting-class/methods#stophls)

- Provide `pin()`/`unpin()` method for Pining / Unpining the participant.

  **Docs** : [pin()/unpin()](https://docs.videosdk.live/android/guide/video-and-audio-calling-api-sdk/features/pin-participants)

- Update `startRecording()`,`startLiveStream()` method

  **Docs** : [startRecording()](https://docs.videosdk.live/android/api/sdk-reference/meeting-class/methods#startrecording)

  **Docs** : [startLiveStream()](https://docs.videosdk.live/android/api/sdk-reference/meeting-class/methods#startlivestream)

---

## v0.1.13

**Release Date** : 13th january 2023

**Change log** :

- Provide `VideoView` component which can render video stream.

  **Docs** : [VideoView](/android/guide/video-and-audio-calling-api-sdk/render-media/display-video/understand-videoView-component)

---

## v0.1.12

**Release Date** : 3rd Janurary 2023

**Change log** :

- Provide support of [`mavenCentral()`](https://search.maven.org/artifact/live.videosdk/rtc-android-sdk)

---

## v0.1.11

**Release Date** : 28th December 2022

**Bug Fix** :

- Fix jitpack issue.

---

## v0.1.10

**Release Date** : 24th December 2022

**Change log** :

1. To obtain video, audio and screen sharing statistics, the `Participant` class now has a [`getVideoStats()`](../../api/sdk-reference/participant-class/methods.md#getvideostats),[`getAudioStats()`](/android/api/sdk-reference/participant-class/methods#getaudiostats),[`getShareStats()`](/android/api/sdk-reference/participant-class/methods#getsharestats) methods.

2. Remove `multiStream` Support.

---

## v0.1.9

**Release Date** : 9th December 2022

**Change log** :

1. Provide `multistream` parameter for sending multiple resolution layers or single resolution layer.

   **Docs** : [Multi Stream](https://docs.videosdk.live/android/guide/video-and-audio-calling-api-sdk/features/custom-track/custom-video-track)

**Bug Fix** :

1. Fix echo issue.

---

## v0.1.8

**Release Date** : 10th November 2022

**Change log** :

1. Added recordingState and liveStreamState event.

   **Docs** : [onRecordingStateChanged()](https://docs.videosdk.live/android/api/sdk-reference/meeting-class/meeting-event-listener-class#onrecordingstatechanged)

   **Docs** : [onLivestreamStateChanged()](https://docs.videosdk.live/android/api/sdk-reference/meeting-class/meeting-event-listener-class#onlivestreamstatechanged)

**Bug Fix** :

1. Fix camera automatically enable when enable screenshare.

2. Handle crash on not providing empty screenshare notification title, content or icon.

---

## v0.1.7

**Release Date** : 1st November 2022

**Change log** :

1. Provide support for banuba integration.

   **Code Sample** : [videosdk-rtc-android-sdk-banuba-example](https://github.com/videosdk-live/videosdk-rtc-android-sdk-banuba-example)

   **Docs** : [Banuba Intergation with VideoSDK](/android/guide/video-and-audio-calling-api-sdk/video-processor/banuba-integration)

---

## v0.1.4

**Release Date** : 21st October 2022

**Change log** :

1. Add support of customTrack in changeMic() method.

---

## v0.1.3

**Release Date** : 18th October 2022

**Change log** : None

**Bug Fix** :

1. Null Pointer Exception crash on meeting leave.

---

## v0.1.2

**Release Date** : 17th October 2022

**Change log** :

1.  CustomTrack for audio,video and screenshare.

    **Docs** : [Custom Video Track](/android/guide/video-and-audio-calling-api-sdk/render-media/optimize-video-track#custom-video-track)

    **Docs** : [Custom Audio Track](/android/guide/video-and-audio-calling-api-sdk/render-media/optimize-audio-track)

    **Docs** : [Custom Screen Share Track](/android/guide/video-and-audio-calling-api-sdk/render-media/optimize-video-track#custom-screen-share-track)

---

## v0.1.0 & v0.1.1

**Release Date** : 29th June 2022

**Change log** :

1. Updated internal dependency.


---

---
title: Render Participant | Video SDK
hide_title: true
hide_table_of_contents: false
description: Video SDK and Audio SDK, developers need to implement a token server. This requires efforts on both the front-end and backend.
sidebar_label: Render Participant
pagination_label: Render Participant
keywords:
  - audio calling
  - video calling
  - real-time communication
  - collaboration
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: render-participant
---

# Render Participant - Android

In this guide, we will take a look at how to render the participant's video on the screen.

:::info

- Here the participant's video is displayed using `VideoView`, but you may also use `SurfaceViewRender` for the same.
- For `VideoView`, SDK version should be `0.1.13` or higher.
- To know more about `VideoView`, please visit [here](./understand-videoView-component)

:::

## Steps to render panticipant

**`Step 1:`** Create a new layout for the participant view named `item_participant.xml` in the `res/layout` folder.

```xml title="item_participant.xml"
<?xml version="1.0" encoding="utf-8"?>
<FrameLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="200dp"
    android:background="#616161"
    tools:layout_height="200dp">

    <ImageView
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_gravity="center"
        android:background="#99000000"
        android:contentDescription="webcam_turned_off"
        android:gravity="center"
        android:padding="4dp"
        android:src="@drawable/ic_outline_videocam_off_24"
        app:tint="@color/white" />

    <live.videosdk.rtc.android.VideoView
        android:id="@+id/participantView"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:visibility="gone" />

    <LinearLayout
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:layout_gravity="bottom"
        android:background="#99000000"
        android:orientation="horizontal">

        <TextView
            android:id="@+id/tvName"
            android:layout_width="0dp"
            android:layout_height="wrap_content"
            android:layout_weight="1"
            android:gravity="center"
            android:padding="4dp"
            android:textColor="@color/white" />

    </LinearLayout>
</FrameLayout>
```

**`Step 2:`** Now, Create a recycler view adapter named `ParticipantAdapter` which will show the participant list. Create `PeerViewHolder` in the adapter which will extend `RecyclerView.ViewHolder`

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js title="ParticipantAdapter.kt"
class ParticipantAdapter(meeting: Meeting) : RecyclerView.Adapter<ParticipantAdapter.PeerViewHolder>() {

  override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): PeerViewHolder {
      //highlight-start
      return PeerViewHolder(
        LayoutInflater.from(parent.context)
          .inflate(R.layout.item_participant, parent, false)
        )
      //highlight-end
  }

  override fun onBindViewHolder(holder: PeerViewHolder, position: Int) {
  }

  override fun getItemCount(): Int {
    return 0
  }

  class PeerViewHolder(view: View) : RecyclerView.ViewHolder(view) {
    // 'VideoView' to show Video Stream
    //highlight-next-line
    var participantView: VideoView = view.findViewById(R.id.participantView)
    var tvName: TextView = view.findViewById(R.id.tvName)
  }
}
```

</TabItem>

<TabItem value="Java">

```java title="ParticipantAdapter.java"
public class ParticipantAdapter extends RecyclerView.Adapter<ParticipantAdapter.PeerViewHolder> {

  @NonNull
  @Override
  public PeerViewHolder onCreateViewHolder(@NonNull ViewGroup parent, int viewType) {
    //highlight-next-line
    return new PeerViewHolder(LayoutInflater.from(parent.getContext()).inflate(R.layout.item_participant, parent, false));
  }

  @Override
  public void onBindViewHolder(@NonNull PeerViewHolder holder, int position) {

  }

  @Override
  public int getItemCount() {
      return 0;
  }

  static class PeerViewHolder extends RecyclerView.ViewHolder {
    // 'VideoView' to show Video Stream
    //highlight-next-line
    public VideoView participantView;
    public TextView tvName;
    public View itemView;

    PeerViewHolder(@NonNull View view) {
      super(view);
      itemView = view;
      tvName = view.findViewById(R.id.tvName);
      participantView = view.findViewById(R.id.participantView);
    }
  }
}
```

</TabItem>

</Tabs>

**`Step 3:`** Next, we will render a list of `Participant` for the meeting.
We will initialize this list in the constructor of the `ParticipantAdapter`

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js title="ParticipantAdapter.kt"
class ParticipantAdapter(meeting: Meeting) :
    RecyclerView.Adapter<ParticipantAdapter.PeerViewHolder>() {

  //highlight-next-line
  // creating a empty list which will store all participants
  private val participants: MutableList<Participant> = ArrayList()

  init {
    //highlight-next-line
    // adding the local participant(You) to the list
    participants.add(meeting.localParticipant)

    //highlight-next-line
    // adding Meeting Event listener to get the participant join/leave event in the meeting.
    meeting.addEventListener(object : MeetingEventListener() {
      override fun onParticipantJoined(participant: Participant) {
        // add participant to the list
        participants.add(participant)
        notifyItemInserted(participants.size - 1)
      }

      override fun onParticipantLeft(participant: Participant) {
        var pos = -1
        for (i in participants.indices) {
          if (participants[i].id == participant.id) {
            pos = i
            break
          }
        }
        // remove participant from the list
        participants.remove(participant)
        if (pos >= 0) {
          notifyItemRemoved(pos)
        }
      }
    })
  }

  // replace getItemCount() method with following.
  // this method returns the size of total number of participants
  override fun getItemCount(): Int {
    //highlight-next-line
    return participants.size
  }
  //...
}
```

</TabItem>

<TabItem value="Java">

```java title="ParticipantAdapter.java"
public class ParticipantAdapter extends RecyclerView.Adapter<ParticipantAdapter.PeerViewHolder> {

  //highlight-next-line
  // creating a empty list which will store all participants
  private final List<Participant> participants = new ArrayList<>();

  public ParticipantAdapter(Meeting meeting) {
    //highlight-next-line
    // adding the local participant(You) to the list
    participants.add(meeting.getLocalParticipant());

    //highlight-next-line
    // adding Meeting Event listener to get the participant join/leave event in the meeting.
    meeting.addEventListener(new MeetingEventListener() {
      @Override
      public void onParticipantJoined(Participant participant) {
        // add participant to the list
        participants.add(participant);
        notifyItemInserted(participants.size() - 1);
      }

      @Override
      public void onParticipantLeft(Participant participant) {
        int pos = -1;
        for (int i = 0; i < participants.size(); i++) {
          if (participants.get(i).getId().equals(participant.getId())) {
            pos = i;
            break;
          }
        }
        // remove participant from the list
        participants.remove(participant);

        if (pos >= 0) {
          notifyItemRemoved(pos);
        }
      }
    });
  }

  // replace getItemCount() method with following.
  // this method returns the size of total number of participants
  @Override
  public int getItemCount() {
    //highlight-next-line
    return participants.size();
  }
  //...
}
```

</TabItem>

</Tabs>

**`Step 4:`** Now, We have listed our participants. Let's set up the view holder to display a participant video.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js title="PartipantAdapter.kt"
class ParticipantAdapter(meeting: Meeting) :
    RecyclerView.Adapter<ParticipantAdapter.PeerViewHolder>() {

  //highlight-next-line
  // replace onBindViewHolder() method with following.
  override fun onBindViewHolder(holder: PeerViewHolder, position: Int) {
    val participant = participants[position]

    holder.tvName.text = participant.displayName

    //highlight-next-line
    // adding the initial video stream for the participant into the 'VideoView'
    for ((_, stream) in participant.streams) {
      if (stream.kind.equals("video", ignoreCase = true)) {
        holder.participantView.visibility = View.VISIBLE
        val videoTrack = stream.track as VideoTrack
        //highlight-next-line
        holder.participantView.addTrack(videoTrack)
        break
      }
    }

    //highlight-next-line
    // add Listener to the participant which will update start or stop the video stream of that participant
    participant.addEventListener(object : ParticipantEventListener() {
      override fun onStreamEnabled(stream: Stream) {
        if (stream.kind.equals("video", ignoreCase = true)) {
          holder.participantView.visibility = View.VISIBLE
          val videoTrack = stream.track as VideoTrack
          //highlight-next-line
          holder.participantView.addTrack(videoTrack)
       }
      }

      override fun onStreamDisabled(stream: Stream) {
        if (stream.kind.equals("video", ignoreCase = true)) {
          //highlight-next-line
          holder.participantView.removeTrack()
          holder.participantView.visibility = View.GONE
        }
      }
    })
  }
}
```

</TabItem>

<TabItem value="Java">

```java title="PartipantAdapter.java"
public class ParticipantAdapter extends RecyclerView.Adapter<ParticipantAdapter.PeerViewHolder> {

  //highlight-next-line
  // replace onBindViewHolder() method with following.
  @Override
  public void onBindViewHolder(@NonNull PeerViewHolder holder, int position) {
    Participant participant = participants.get(position);

    holder.tvName.setText(participant.getDisplayName());

    //highlight-next-line
    // adding the initial video stream for the participant into the 'VideoView'
    for (Map.Entry<String, Stream> entry : participant.getStreams().entrySet()) {
      Stream stream = entry.getValue();
      if (stream.getKind().equalsIgnoreCase("video")) {
        holder.participantView.setVisibility(View.VISIBLE);
        VideoTrack videoTrack = (VideoTrack) stream.getTrack();
        //highlight-next-line
        holder.participantView.addTrack(videoTrack)
        break;
      }
    }

    //highlight-next-line
    // add Listener to the participant which will update start or stop the video stream of that participant
    participant.addEventListener(new ParticipantEventListener() {
      @Override
      public void onStreamEnabled(Stream stream) {
        if (stream.getKind().equalsIgnoreCase("video")) {
          holder.participantView.setVisibility(View.VISIBLE);
          VideoTrack videoTrack = (VideoTrack) stream.getTrack();
          //highlight-next-line
          holder.participantView.addTrack(videoTrack)
        }
      }

      @Override
      public void onStreamDisabled(Stream stream) {
        if (stream.getKind().equalsIgnoreCase("video")) {
          //highlight-next-line
          holder.participantView.removeTrack();
          holder.participantView.setVisibility(View.GONE);
        }
      }
    });
  }
}
```

</TabItem>

</Tabs>

**`Step 5:`** Final step is to add this adapter to the `MeetingActivity`

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js title="MeetingActivity.kt"
override fun onCreate(savedInstanceState: Bundle?) {
  //Meeting Setup...
  //...
  val rvParticipants = findViewById<RecyclerView>(R.id.rvParticipants)
  rvParticipants.layoutManager = GridLayoutManager(this, 2)
  //highlight-next-line
  rvParticipants.adapter = ParticipantAdapter(meeting!!)
}
```

</TabItem>

<TabItem value="Java">

```java title="MeetingActivity.java"
@Override
protected void onCreate(Bundle savedInstanceState) {
  //Meeting Setup...
  //...
  final RecyclerView rvParticipants = findViewById(R.id.rvParticipants);
  rvParticipants.setLayoutManager(new GridLayoutManager(this, 2));
  //highlight-next-line
  rvParticipants.setAdapter(new ParticipantAdapter(meeting));
}
```

</TabItem>

</Tabs>

<center>

<img style={{height: '450px'}} src="https://cdn.videosdk.live/website-resources/docs-resources/android_display_video.jpeg" />

</center>

## Mirror Local Video View

If you wish to show the mirror view of the local participant, you can set `setMirror` property to `true` of `VideoView` class.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js title="PartipantAdapter.kt"
class ParticipantAdapter(meeting: Meeting) :
    RecyclerView.Adapter<ParticipantAdapter.PeerViewHolder>() {

  override fun onBindViewHolder(holder: PeerViewHolder, position: Int) {
    //...
    holder.tvName.text = participant.displayName
    //highlight-next-line
    holder.participantView.setMirror(true)
    //...
  }
}
```

</TabItem>

<TabItem value="Java">

```java title="PartipantAdapter.java"
public class ParticipantAdapter extends RecyclerView.Adapter<ParticipantAdapter.PeerViewHolder> {

  @Override
  public void onBindViewHolder(@NonNull PeerViewHolder holder, int position) {
    //...
    holder.tvName.setText(participant.getDisplayName());
    //highlight-next-line
    holder.participantView.setMirror(true);
    //...
  };
}
```

</TabItem>

</Tabs>

##### Sample of mirror view video

![mirror view](/img/mirror-view.jpg)

## API Reference

The API references for all the methods and events utilised in this guide are provided below.

- [Participant](/android/api/sdk-reference/participant-class/introduction)
- [VideoView](./understand-videoView-component)


---

---
title: VideoView Video & Audio Call - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: VideoView component quick integrate in Android with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Understand VideoView Componenet
pagination_label: Understand VideoView Componenet
keywords:
  - SurfaceViewRender
  - VideoView
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: understand-videoView-component
---

# What is SurfaceViewRender ?

`SurfaceViewRender` is a very powerful component of `WebRTC` since it is used to display the video stream on a SurfaceView. You can use `SurfaceViewRender` to show video of participant in your screen.

Here's the lifecycle of a SurfaceViewRenderer:

<div style={{textAlign: 'center'}}>

<img style={{height: '200px'}} src="/img/android/VideoView/life-cycle.png" />

</div>

Which means:

1. The SurfaceViewRenderer must be first initialised after being created and before it can be use at all. It starts a render thread.

2. `addSink()` needs to be called when you are having VideoTrack to render. addSink is method of `VideoTrack` that you want to add to it. You have to pass `surfaceViewRender` as parameter.

3. `removeSink()` should only be called when you're done showing the video. Another method of `VideoTrack`, and it takes the `surfaceViewRenderer` as a parameter.

4. Release at last to allow the render thread to terminate. This function should be called before the activity is destroyed and/or before init it again.

#### Mistakes you might make and stuck :

###### 1. Not initialised surfaceViewRender

The video never appears since a render thread was never start and you will see black view.

###### 2. Init it again before releasing it.

If you are not releasing surfaceViewRender before calling `init()` again, you will get this error.

```js
java.lang.IllegalStateException: svrParticipant Already initialized
        at org.webrtc.EglRenderer.init(EglRenderer.java:212)
```

###### 3. Two videos render on same SurfaceViewRender

If you called `addSink()` on the same `SurfaceViewRenderer` for two different tracks and did not call `removeSink` before that, then you will see two different videos on same SurfaceViewRenderer with flickers which would look like this :

import ReactPlayer from 'react-player'

<div style={{textAlign: 'center'}}>

<ReactPlayer controls url="/img/android/VideoView/android-flicker.mp4" height="500px" width={"100%"} />

</div>

<br/>

Too complicated right? However, VideoSDK makes it simple for you. You can use `VideoView` instead of `SurfaceViewRenderer`.

:::info

- If you want to use `VideoView`, please update SDK version to `0.1.13` or higher.

:::

### VideoView

`VideoView` provides a better abstraction to render live video and handles edge cases like managing init state, render more than one videos on same surfaceViewRender.

### Methods

1. **addTrack(VideoTrack videoTrack)** - `addTrack` will initialised SurfaceViewRender for you and render videoTrack that you provided.

2. **removeTrack()** - `removeTrack` should only be called when you're done showing the video.

3. **releaseSurfaceViewRenderer()** - `releaseSurfaceViewRenderer` should be called before the activity is destroyed.

#### How to use VideoView ?

##### Layout

```js
// <org.webrtc.SurfaceViewRenderer
//        android:id="@+id/svrParticipant"
//        android:layout_width="match_parent"
//        android:layout_height="match_parent" />

<live.videosdk.rtc.android.VideoView
  android:id="@+id/participantView"
  android:layout_width="match_parent"
  android:layout_height="match_parent"
/>
```

##### Initalising and adding video track

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
// svrParticipant.init(PeerConnectionUtils.getEglContext(), null)
// var track = stream.getTrack() as VideoTrack
// track!!.addSink(svrParticipant)

val track = stream.track as VideoTrack
participantView!!.addTrack(track);
```

</TabItem>

<TabItem value="Java">

```js
// svrParticipant.init(PeerConnectionUtils.getEglContext(), null);
// VideoTrack track = (VideoTrack) stream.getTrack();
// track.addSink(svrParticipant);

VideoTrack track = (VideoTrack) stream.getTrack();
participantView.addTrack(track);
```

</TabItem>

</Tabs>

##### removeTrack

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
// var track = stream.track as VideoTrack
// track!!.removeSink(svrParticipant);

participantView.removeTrack();
```

</TabItem>

<TabItem value="Java">

```js
// VideoTrack track = (VideoTrack) stream.getTrack();
// if (track != null) track.removeSink(svrParticipant);

participantView.removeTrack();
```

</TabItem>

</Tabs>

#### release

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
override fun onDestroy() {
        participantView.releaseSurfaceViewRenderer()
        super.onDestroy()
}
```

</TabItem>

<TabItem value="Java">

```js
@Override
protected void onDestroy() {
    participantView.releaseSurfaceViewRenderer();
    super.onDestroy();
}
```

</TabItem>

</Tabs>


---

---
title: Layout and Grid Management | Video SDK
hide_title: true
hide_table_of_contents: false
description: Video SDK and Audio SDK, developers need to implement a token server. This requires efforts on both the front-end and backend.
sidebar_label: Layout and Grid Management
pagination_label: Layout and Grid Management
keywords:
  - audio calling
  - video calling
  - pause/resume video stream
  - real-time communication
  - collaboration
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: layout-and-grid-management
---

# Layout and Grid Management - Android

In this guide, we will take a look at how to efficiently manage the participants in different types of layout.

## Grid Layout

The most usual way to showing participants within a grid. There are multiple things you should keep in mind when showing participants in the grid.

This includes the number of participants being shown on the screens, number of participants in the background(in the meeting but not on the grid), quality which is being consumed for each and every participant in the grid.

### Quality of Participant's Video

When there are large number of participants present on the screen, it is best to consume them in lower resolutions. For this we recommend you to call the `setQuality` method on the participants present in the grid with dynamic values based on the number of participants on the screen.

Here is the recommended video quality:

1. Participants less than 3: `setQuality("high")`
2. Participants between 3 to 4: `setQuality("med")`
3. Participants greater than 4: `setQuality("low")`

<center>
<img src='https://cdn.videosdk.live/website-resources/docs-resources/grid_quality_mobile.png' />
</center>

### Grid with Screen Share

When you are rendering a small grid along with the screen share of the presenter or you are showing a simple sidebar video of the participants while the screenshare is on, it is recommended to do `setQuality("low")` for the participants who are present in the sidebar.

## Grid with Pagination

If you are having large video calls where there are multiple speakers with video turned on, it is best to implement a pagination type setup where only a few (4-6) participants are shown on the grid and rest can be seen by changing the page.

To best utilize the resourses, you should pause the streams of the participants who are not present in the grid and resume them when the come in to the grid. You can [follow this guide](#pauseresume-stream) to pause/resume the stream.

<center>
<img src='https://cdn.videosdk.live/website-resources/docs-resources/grid_pagination.png' />
</center>

:::note
You can get the sample code for grid with pagination [here](https://github.com/videosdk-live/videosdk-rtc-android-kotlin-sdk-example/tree/main/app/src/main/java/live/videosdk/rtc/android/kotlin/GroupCall).
:::

## Pause/Resume Stream

Whenver you wish to stop/resume download stream(webcam, screenShare and mic) of participant, you can simply do it by using `pause`, `resume` methods.

### Pause stream

- `pause()` method is used for pause stream(webcam, screenShare and mic) of a particular participant.

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
for ((_, stream) in participant.streams) {
  //highlight-next-line
  stream.pause()
}
```

</TabItem>

<TabItem value="Java">

```js
for (Map.Entry<String, Stream> entry : participant.getStreams().entrySet()) {
  Stream stream = entry.getValue();
  //highlight-next-line
  stream.pause();
}
```

</TabItem>

</Tabs>

### Resume stream

- `resume()` method is used to resume stream(webcam, screenShare and mic) of a particular participant.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
for ((_, stream) in participant.streams) {
  //highlight-next-line
  stream.resume()
}
```

</TabItem>

<TabItem value="Java">

```js
for (Map.Entry<String, Stream> entry : participant.getStreams().entrySet()) {
  Stream stream = entry.getValue();
  //highlight-next-line
  stream.resume();
}
```

</TabItem>

</Tabs>

## API Reference

The API references for all the methods and events utilised in this guide are provided below.

- [setQuality](/android/api/sdk-reference/participant-class/methods#setquality)


---

---
title: Optimize Audio Track | VideoSDK Docs
hide_title: false
hide_table_of_contents: false
description: Optimize Audio Tracks features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Optimize Audio Track
pagination_label: Optimize Audio Track
keywords:
  - Mic on
  - Mic off
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
---

# Optimize Audio Track - Android

While optimizing for the best listening experience, it is necessary to fine-tune the audio track that is being used during the calls.

For the best fine-tuning experience, we have introduced the ability to pass a custom audio track for the participant's media before and during the meeting.

## Custom Audio Track

This feature can be used to create a custom Audio track for the Audio of the participants with different encoder configuration and send it to other participants.

### `How to Create Custom Audio Track ?`

- You can create a Audio Track using `createAudioTrack()` method of `VideoSDK`.

- This method can be used to create audio track using different encoding parameters.

#### Example

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
val audioCustomTrack: CustomStreamTrack = VideoSDK.createAudioTrack("speech_standard",this)
// `high_quality` | `music_standard`,  Default : `speech_standard`
```

</TabItem>

<TabItem value="Java">

```js
CustomStreamTrack audioCustomTrack=VideoSDK.createAudioTrack("speech_standard", this);
// `high_quality` | `music_standard`,  Default : `speech_standard`
```

</TabItem>

</Tabs>

- `speech_standard` : This config is optimised for normal voice communication.

- `high_quality` : This config is used for getting RAW audio, where you can apply your `noiseConfig`.

- `music_standard` : This config is optimised for communication, where sharing of musical notes such as songs or instrumental sounds, is important.

### `How to Setup Custom Audio Track ?`

The custom track can be set up both before and after the initialization of the meeting.

1. [Setting up a Custom Track during the initialization of a meeting](/android/guide/video-and-audio-calling-api-sdk/render-media/optimize-audio-track#1-setting-up-a-custom-track-during-the-initialization-of-a-meeting)
2. [Setting up a Custom Track with methods](/android/guide/video-and-audio-calling-api-sdk/render-media/optimize-audio-track#2-setting-up-a-custom-track-with-methods)

##### 1. Setting up a Custom Track during the initialization of a meeting

If you are passing `micEnabled: true` in the `initMeeting` of `VideoSDK` and want to use custom tracks from start of the meeting, you can pass custom track in the `initMeeting` as shown below.

:::caution
Custom Track will not apply on `micEnabled: false` configuration.
:::

##### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
override fun onCreate(savedInstanceState: Bundle?) {
  //..

  val customTracks: MutableMap<String, CustomStreamTrack> = HashMap()

  //highlight-start
  val audioCustomTrack: CustomStreamTrack = VideoSDK.createAudioTrack("high_quality", this)
  customTracks["mic"] = audioCustomTrack  //Key must be "mic"
  //highlight-end

  // create a new meeting instance
  val meeting = VideoSDK.initMeeting(
    this@MainActivity,meetingId,participantName,
    //MicEnabled , If true, it will use the passed custom track to turn mic on
    true,
    //WebcamEnabled
    true,
    //ParticipantId
    null,
    //Mode
    null,
    //MultiStream
    false,
    //Pass the custom tracks here
    //highlight-next-line
    customTracks,
    //MetaData
    null
  )
}
```

</TabItem>

<TabItem value="Java">

```js
@Override
protected void onCreate(Bundle savedInstanceState) {
  //..

  Map<String, CustomStreamTrack> customTracks = new HashMap<>();

  //highlight-start
  CustomStreamTrack audioCustomTrack = VideoSDK.createAudioTrack("high_quality", this);
  customTracks.put("mic", audioCustomTrack);  //Key must be "mic"
  //highlight-end

  // create a new meeting instance
  Meeting meeting = VideoSDK.initMeeting(
      MainActivity.this, meetingId, participantName,
      //MicEnabled , If true, it will use the passed custom track to turn mic on
      true,
      //WebcamEnabled
      true,
      //ParticipantId
      null,
      //Mode
      null,
      //MultiStream
      false,
      //Pass the custom tracks here
      //highlight-next-line
      customTracks,
      //MetaData
      null
  );
}
```

</TabItem>

</Tabs>

#### 2. Setting up a Custom Track with methods

In order to switch tracks during the meeting, you have to pass the `CustomStreamTrack` in the `unmuteMic()` method of `Meeting`.

You can also pass custom track in `changeMic()` method of `Meeting`.

:::tip
Make sure to call `muteMic()` before you create a new track as it may lead to unexpected behavior.
:::

##### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
try {
  val audioCustomTrack: CustomStreamTrack = VideoSDK.createAudioTrack("high_quality", this)
  meeting!!.unmuteMic(audioCustomTrack)

  //or
  meeting!!.changeMic(AppRTCAudioManager.AudioDevice.BLUETOOTH, audioCustomTrack)
} catch (e: JSONException) {
  e.printStackTrace()
}
```

</TabItem>

<TabItem value="Java">

```js
try {
  CustomStreamTrack audioCustomTrack = VideoSDK.createAudioTrack("high_quality", this);
  meeting.unmuteMic(audioCustomTrack);

  //or
  meeting.changeMic(AppRTCAudioManager.AudioDevice.BLUETOOTH,audioCustomTrack);
}catch (JSONException e) {
  e.printStackTrace();
}
```

</TabItem>

</Tabs>

## API Reference

The API references for all the methods and events utilised in this guide are provided below.

- [Custom Audio Track](/android/api/sdk-reference/custom-tracks#custom-audio-track---android)


---

---
title: Optimize Video Tracks | VideoSDK Docs
hide_title: false
hide_table_of_contents: false
description: Optimize Video Tracks features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Optimize Video Tracks
pagination_label: Optimize Video Tracks
keywords:
  - Camera on
  - Camera off
  - Webcam on
  - Webcam off
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
---

# Optimize Video Tracks - Android

While optimizing for the best viewing experience, it is necessary to fine-tune the video tracks that are being used during the calls.

For the best fine-tuning experience, we have introduced the ability to pass a custom video track for the participant's media before and during the meeting.

1. [Custom Video Track](#custom-video-track)
2. [Custom Screen Share Track](#custom-screen-share-track)

## Custom Video Track

This feature can be used to add custom video encoder configurations, optimization mode (whether you want to focus on **motion**, **text** or **detail** of the video) and background removal & video filter from external SDK(e.g., [Banuba](https://www.banuba.com/))and send it to other participants.

### `How to Create a Custom Video Track ?`

- You can create a Video Track using `createCameraVideoTrack()` method of `VideoSDK`.
- This method can be used to create video track using different encoding parameters, camera facing mode, and optimization mode and return `CustomStreamTrack`.

#### Example

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
val videoCustomTrack: CustomStreamTrack = VideoSDK.createCameraVideoTrack(

  // highlight-next-line
  // This will accept the resolution (height x width) of video you want to capture.
  "h720p_w960p", // "h720p_w960p" | "h720p_w1280p" ... // Default : "h480p_w720p"

  // highlight-next-line
  // It will specify whether to use front or back camera for the video track.
  "front", "back",  Default : "front"

  // highlight-next-line
  // We will discuss this parameter in next step.
  CustomStreamTrack.VideoMode.MOTION, // CustomStreamTrack.VideoMode.TEXT, CustomStreamTrack.VideoMode.DETAIL ,  Default : CustomStreamTrack.VideoMode.MOTION

  // highlight-next-line
  // multiStream - we will discuss this parameter in next step.
  false, // true

  // highlight-next-line
  // Pass Context
  this,

  // highlight-next-line
  // This is Optional parameter. We will discuss this parameter in next step.
  observer)
```

</TabItem>

<TabItem value="Java">

```javascript
CustomStreamTrack customStreamTrack = VideoSDK.createCameraVideoTrack(

  // highlight-next-line
  // This will accept the resolution (height x width) of video you want to capture.
  "h480p_w640p", // "h720p_w960p" | "h720p_w1280p" ... // Default : "h480p_w640p"

  // highlight-next-line
  // It will specify whether to use front or back camera for the video track.
  "front", // "back,  Default : "front""

  // highlight-next-line
  // We will discuss this parameter in next step.
  CustomStreamTrack.VideoMode.MOTION, // CustomStreamTrack.VideoMode.TEXT, CustomStreamTrack.VideoMode.DETAIL ,  Default : CustomStreamTrack.VideoMode.MOTION

  // highlight-next-line
  // multiStream - we will discuss this parameter in next step.
  false, // true

  // highlight-next-line
  // Pass Context
  this

  // highlight-next-line
  // This is Optional parameter. We will discuss this parameter in next step.
  observer);
```

</TabItem>

</Tabs>

:::caution
The capabilities of the device have a significant impact on how custom track configurations behave. Assuming a case where you set encoder configuration to 1080p but the camera only supports 720p, then encoder configuration will automatically switch to the highest resolution that the device can handle, which is 720p.
:::

##### What is `optimizationMode`?

- It will specify the optimization mode for the video track being generated.

- `motion` : This type of track should more focus on motion video. For example, webcam video, movies or video games.

  - This type of track will degrade `resolution` in order to maintain `frame rate`.

- `text` : This type of track should more focus on significant sharp edges and areas of consistent color that can change frequently. For example, presentations or web pages with text content.

  - This type of track will degrade `frame rate` in order to maintain `resolution`.

- `detail` : This type of track should more focus on details of the video. For example, presentations, painting or line art.

  - This type of track will degrade `frame rate` in order to maintain `resolution`.

##### What is `multiStream`?

- It will specify if the stream should send multiple resolution layers or single resolution layer.

**`multiStream : true`** By default, VideoSDK sends multiple resolution video streams to the server (whether you are using custom video track or not), For instance, user device capabilty is 720p, so VideoSDK sends 720p along with 640p and 480p streams. This allows VideoSDK to deliver the appropriate stream to each participant based on their network bandwidth.

<center>

![Multi Stream False](/img/multistream_true.png)

</center>

**`multiStream : false`** If you want to restrict the VideoSDK to send only one stream to maintain quality, you can set `multiStream` to `false`.

<center>

![Multi Stream False](/img/multistream_false.png)

</center>

:::danger
`setQuality` would not have any effect if multiStream is set to `false`.
:::

##### What is `observer`?

- If you want to use video filter from external SDK(e.g., [Banuba](https://www.banuba.com/)) then pass instance of `CapturerObserver` in this parameter.

:::note

For Banuba integraion with VideoSDK, please visit [Banuba Intergation with VideoSDK](../video-processor/banuba-integration.md)

:::

### `How to Setup a Custom Video Track ?`

The custom track can be set up both before and after the initialization of the meeting.

1. [Setting up a Custom Track during the initialization of a meeting](/android/guide/video-and-audio-calling-api-sdk/render-media/optimize-video-track#1-setting-up-a-custom-track-during-the-initialization-of-a-meeting)
2. [Setting up a Custom Track with methods](/android/guide/video-and-audio-calling-api-sdk/render-media/optimize-video-track#2-setting-up-a-custom-track-with-methods)

##### 1. Setting up a Custom Track during the initialization of a meeting

If you are passing `webcamEnabled: true` in the `initMeeting` of `VideoSDK` and want to use custom tracks from start of the meeting, you can pass custom track in the `initMeeting` as shown below.

:::caution
Custom Track will not apply on `webcamEnabled: false` configuration.
:::

##### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
override fun onCreate(savedInstanceState: Bundle?) {
  //..

  //highlight-start
  val customTracks: MutableMap<String, CustomStreamTrack> = HashMap()
  val videoCustomTrack: CustomStreamTrack =
  VideoSDK.createCameraVideoTrack("h720p_w960p", "front", CustomStreamTrack.VideoMode.MOTION, false, this)
  customTracks["video"] = videoCustomTrack  //Key must be "video"
  //highlight-end

  // create a new meeting instance
  val meeting = VideoSDK.initMeeting(
    this@MainActivity, meetingId, participantName,
    //MicEnabled
    true,
    //WebcamEnabled , If true, it will use the passed custom track to turn webcam on
    true,
    // ParticipantId
    null,
    // Mode
    null,
    // MultiStream
    false,
    //Pass the custom tracks here
    //highlight-next-line
    customTracks,
    //MetaData
    null
  )
}
```

</TabItem>

<TabItem value="Java">

```js
@Override
protected void onCreate(Bundle savedInstanceState) {
  //..

  //highlight-start
  Map<String, CustomStreamTrack> customTracks = new HashMap<>();
  CustomStreamTrack videoCustomTrack = VideoSDK.createCameraVideoTrack("h720p_w960p", "front", CustomStreamTrack.VideoMode.MOTION, false, this);
  customTracks.put("video", videoCustomTrack);  //Key must be "video"
  //highlight-end

  // create a new meeting instance
  Meeting meeting = VideoSDK.initMeeting(
    MainActivity.this, meetingId, participantName,
    //MicEnabled
    true,
    //WebcamEnabled , If true, it will use the passed custom track to turn webcam on
    true,
    // ParticipantId
    null,
    // Mode
    null,
    // MultiStream
    false,
    //Pass the custom tracks here
    //highlight-next-line
    customTracks,
    //MetaData
    null
    );
}
```

</TabItem>

</Tabs>

#### 2. Setting up a Custom Track with methods

In order to switch tracks during the meeting, you have to pass the `CustomStreamTrack` in the `enableWebcam()` method of `Meeting`.

:::tip
Make sure to call `disableWebcam()` before you create a new track as it may lead to unexpected behavior.
:::

##### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
val customStreamTrack: CustomStreamTrack = VideoSDK.createCameraVideoTrack("h720p_w960p", "back", CustomStreamTrack.VideoMode.MOTION, false, this)
meeting!!.enableWebcam(customStreamTrack)
```

</TabItem>

<TabItem value="Java">

```javascript
CustomStreamTrack customStreamTrack=VideoSDK.createCameraVideoTrack("h720p_w960p", "back", CustomStreamTrack.VideoMode.MOTION, false, this);
meeting.enableWebcam(customStreamTrack);
```

</TabItem>

</Tabs>

### `Which Configuration is suitable for Device ?`

In this section, we will understand participant size wise `encoder(Resolution)` and `multiStream` configuration.

<center>
<img src='https://cdn.videosdk.live/website-resources/docs-resources/mobile_device_config.png' />
</center>

## Custom Screen Share Track

This feature can be used to customise screenshare streams with enhanced optimization mode and predefined encoderConfig(Resolution + FPS) for specific use-case and send it to other participants.

### `How to Create Custom Screen Share Track ?`

- You can create a Screen Share track using `createScreenShareVideoTrack()` method of `VideoSDK`.
- This method can be used to create video track using different encoding parameters and optimization mode.

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
// data is received from onActivityResult method.
VideoSDK.createScreenShareVideoTrack(

  //highlight-next-line
  // This will accept the  height & FPS of video you want to capture.
  "h720p_15fps", //  `h360p_30fps` | `h1080p_30fps` // Default : `h720p_15fps`

  //highlight-next-line
  // It is Intent received from onActivityResult when user provide permission for ScreenShare.
  data,

  //highlight-next-line
  // Pass Conext
  this)

  //highlight-next-line
  //Callback to this listener will be made when track is ready with CustomTrack as parameter
  {
    track ->
    meeting!!.enableScreenShare(track)
  }
```

</TabItem>

<TabItem value="Java">

```javascript
// data is received from onActivityResult method.
VideoSDK.createScreenShareVideoTrack(
  //highlight-next-line
  // This will accept the  height & FPS of video you want to capture.
  "h720p_15fps", //  `h360p_30fps` | `h1080p_30fps` // Default : `h720p_15fps`

  /highlight-next-line
  // It is Intent received from onActivityResult when user provide permission for ScreenShare
  data,

  //highlight-next-line
  // Pass Conext
  this,

  //highlight-next-line
  //Callback to this listener will be made when track is ready with CustomTrack as parameter
  (track)->{meeting.enableScreenShare(track);}
);
```

</TabItem>

</Tabs>

### `How to Setup Custom Screen Share Track ?`

In order to switch tracks during the meeting, you have to pass the `CustomStreamTrack` in the `enableScreenShare()` method of `Meeting`.

:::note

Make sure to call `disableScreenShare()` before you create a new track as it may lead to unexpected behavior.

:::

##### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
@TargetApi(21)
private fun askPermissionForScreenShare() {
  val mediaProjectionManager = application.getSystemService<Any>(
      Context.MEDIA_PROJECTION_SERVICE
  ) as MediaProjectionManager
  startActivityForResult(
      mediaProjectionManager.createScreenCaptureIntent(), CAPTURE_PERMISSION_REQUEST_CODE
  )
}

@RequiresApi(api = Build.VERSION_CODES.LOLLIPOP)
override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) {
  super.onActivityResult(requestCode, resultCode, data)
  if (requestCode != CAPTURE_PERMISSION_REQUEST_CODE) return
  if (resultCode == RESULT_OK) {
    //highlight-start
    VideoSDK.createScreenShareVideoTrack("h720p_15fps", data, this) { track ->
        meeting!!.enableScreenShare(track)
    }
    //highlight-end
  }
}

```

</TabItem>

<TabItem value="Java">

```javascript
@TargetApi(21)
private void askPermissionForScreenShare() {
  MediaProjectionManager mediaProjectionManager =
      (MediaProjectionManager) getApplication().getSystemService(
          Context.MEDIA_PROJECTION_SERVICE);
  startActivityForResult(
      mediaProjectionManager.createScreenCaptureIntent(), CAPTURE_PERMISSION_REQUEST_CODE);
}

@RequiresApi(api = Build.VERSION_CODES.LOLLIPOP)
@Override
public void onActivityResult(int requestCode, int resultCode, Intent data) {
  super.onActivityResult(requestCode, resultCode, data);
  if (requestCode != CAPTURE_PERMISSION_REQUEST_CODE)
      return;
  if (resultCode == Activity.RESULT_OK) {
    //highlight-start
    VideoSDK.createScreenShareVideoTrack("h720p_15fps", data, this, (track)->{
        meeting.enableScreenShare(track);
    });
    //highlight-end
  }
}

```

</TabItem>

</Tabs>

## API Reference

The API references for all the methods and events utilised in this guide are provided below.

- [Custom Video Track](/react/api/sdk-reference/custom-tracks#custom-video-track---react)
- [Custom Screen Share Track](/react/api/sdk-reference/custom-tracks#custom-screen-share-track---react)


---

---
title: Understanding Analytics Dashboard | Video SDK
hide_title: true
hide_table_of_contents: false
description: Video SDK and Audio SDK, developers need to implement a token server. This requires efforts on both the front-end and backend.
sidebar_label: Understanding Analytics Dashboard
pagination_label: Understanding Analytics Dashboard
keywords:
  - audio calling
  - video calling
  - real-time communication
  - collaboration
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: understanding-analytics-dashboard
---

import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>

# Understanding Analytics Dashboard - Android

Welcome to the world of actionable insights and empowered decision-making. VideoSDK's session analytics dashboard is your gateway to understanding, optimizing, and elevating every aspect of your sessions.

## Accessing Analytics Made Easy

Navigating through session data is a breeze with VideoSDK. Simply head to your session page at https://app.videosdk.live/meetings/sessions, where a treasure trove of session information awaits.

### How to Access Analytics?

Open Session Analytics effortlessly by following these steps:

1. **Click on Meeting-ID:**
    - Directly access analytics by clicking on the meeting-ID within the session table.
2. **Hover and Click View Analytics:**
    - Hover over a specific meeting row to reveal the **View Analytics** button in the Actions Column.
    - Click on **View Analytics** to open the Session Overview sidebar, unlocking a wealth of insights.

![Access Analytics](https://cdn.videosdk.live/website-resources/docs-resources/access_analytics.png)

---

There are three tabs available within the session analytics view:

## **1. Session Overview**

This tab provides an overview of the session, including its duration and participant details. You can explore individual participant statistics to understand their session performance better.

## **2. Errors**

In this tab, you can find information about any errors encountered during the session. It helps you identify and address issues like network problems or technical glitches promptly.

:::note

Session errors are visible with JS SDK v0.0.82 or higher, React SDK v0.1.85 or higher, and React Native v0.1.6 or newer versions.

:::

## **3. Session Stats**

Explore data and metrics sent and received by participants to measure performance of the session in this tab. It offers insights into data exchange among participants, including metrics on jitter, RTT, and packet loss, resolutions, and fps aiding in assessing communication efficiency.

Let's dive deeper into each of these tabs to gain a better understanding of session analytics.

# Session Overview

The session overview page is your compass in the sea of data. Here's what you'll uncover:

- **Meeting ID:** Unique identifier for the meeting in the format of `abcd-efgh-ijkl`.
- **Session ID:** Unique identifier for each session, uniquely identified by its `sessionId`.
- **Session Status:** Indicates if the session is ongoing or ended.
- **Session Initiating Time:** Time taken by the first participant to establish the connection.
- **Start and End Time:** Marks the start and end of the session.
- **Total Unique Participants Joined:** Total number of unique participants in the session.
- **Total Session Duration:** Overall duration of the session from start to end.
- **Total Participant Minutes:** A sum of all participant duration.
- **Recording, HLS, RTMP:** Additional services used in the session.

### Participant Table List

- **Participant ID:** Unique identifier for each participant.
- **Participant Name:** Personalized identification for each participant.
- **Join Time:** Time taken by the participant to establish connection.
- **Duration:** Total time spent by this participant in the session.

### Efficient Session Management with Actions

Enhance your session management with streamlined actions:

- **Kick Out Participants:** Effortlessly remove/kickout participants from ongoing sessions.
- **Detailed Participant Analytics:**
- Hover over a specific participant row to reveal the `View Stats` button at the end of the row.
- Click on `View Stats` to open the Participant Overview sidebar.


![View Stats](https://cdn.videosdk.live/website-resources/docs-resources/view_stats.png)


## Explore Participant Insights

Discover valuable participant data that provides a clear view of engagement and experience:

- **Participant ID:** Unique identifier for each participant.
- **Participant Name:** Personalized identification for better interaction.
- **Joined At:** Indicates the precise moment when participant connects to the session.
- **Left At:** Indicates the precise moment when participant left the session.
- **Total Duration:** Total duration of participant within that session.
- **Joining Time:** Time taken by the this participant to establish the connection.
- **Location:** Approx. geographic location from where the participant joined.
- **Platform:** Specifies whether participants are using a desktop or mobile device.
- **Device Info:** Offers details regarding the participant's device.
- **OS:** Provides information about the participant's OS.
- **Browser:** Provides specifics about the participant's browser
- **SDK Version:** Indicates the version of the SDK used by participants.

### Understanding Participant Call Health

We've developed call health to offer a rapid assessment of participant performance during calls. This feature highlights the performance of audio, video, and screen sharing audio-video separately. We've utilized color theory, with green indicating good performance, orange for moderate, and red for poor performance, to enhance clarity. For detailed insights, simply hover over the bars

![Participant Call Health](https://cdn.videosdk.live/website-resources/docs-resources/participant_call_health.png)

## Participant Session Stats

Dive into Participant Session Stats for valuable insights into your session experience! With just a click on `View Session Stats` at the bottom of the page, unlock a treasure trove of data crucial for understanding audio and video experiences.

Within this section, you can observe quality metrics for the selected participant, comparing them to others. Additionally, the `Sessions Stats` covers quality stats comparison for every participant. Keep reading to explore more about Session Stats.

**Visualizing Session Performance from Both Sides**

This section provides a two-sided view of your session's metrics.

- **Left Side: Sender Participant Graph** This section displays graphs representing the metrics sent by the sender participant.. Here, you can see how the various factors impacted the data you transmitted.
- **Right Side: Receiver Participant Graph** On the right side, you'll find a dropdown menu where you can select a specific participant. Choosing a receiver will display graphs showcasing the metrics **received by that participant**. This allows you to compare the sending experience (left side) with the receiving experience (right side) for different participants.

![VideoSDK Jitter Graph](https://cdn.videosdk.live/website-resources/docs-resources/video_jitter_graph.png)

**See How Your Session Performed**

These metrics give you a clear picture of your session's quality. Understanding them helps you spot any issues and keep things running smoothly. Let's dive into what each metric means!

**Jitter:** Imagine your internet connection like a bumpy road. Jitter is how much those bumps cause your signal to bounce around. Less jitter means a smoother ride for your data (audio and video, threshold ≤ 30ms).

**RTT (Latency):** This is how long it takes for data to travel between you and the server you're connected to. Think of it like the time it takes for a message to get delivered – a lower RTT means a faster delivery (affects both audio and video, threshold ≤ 300ms).

**Bitrate:** This measures the amount of data flowing through your connection per second. Imagine it like the width of a water pipe – a higher bitrate allows for more data to flow, which can be good for high-quality audio/video or fast downloads.

**Packet Loss:** Think of data traveling in tiny packets. Packet loss is when some of those packets get dropped along the way. More packet loss means information might be missing, affecting things like audio/video quality or lag in games (threshold ≤ 5%).

**Resolution:** This refers to the sharpness and detail of an image or video. Think of it like the number of pixels on your screen – a higher resolution means a crisper picture (**Video Only**).

**FPS (Frames Per Second):** This measures how many images (frames) are displayed on your screen every second. Imagine it like a flipbook – a higher FPS creates a smoother and more fluid animation or video experience (**Video Only**).

![VideoSDK FPS Graph](https://cdn.videosdk.live/website-resources/docs-resources/video_fps_graph.png)

![VideoSDK Resolution Graph](https://cdn.videosdk.live/website-resources/docs-resources/video_resolution_graph.png)

---

# **Analyse Session Stats**

Similar to `Participant Session Stats`, this tab covers quality statistics sent by individual participants. You can select any participant to compare effectively with others.

Choose a sender participant from the dropdown menu on the left and select a recipient on the right to compare data over different time frames. This allows you to identify and explore issues within specific durations.

This tab covers the same metrics as covered in the `participant session stats`: Jitter, RTT (Latency), Bitrate, Packet-loss, Resolution (Video only), and FPS (Video only).

![VideoSDK Session Stats](https://cdn.videosdk.live/website-resources/docs-resources/session_stats.png)

---

---
title: Understanding Call Quality | Video SDK
hide_title: true
hide_table_of_contents: false
description: Video SDK and Audio SDK, developers need to implement a token server. This requires efforts on both the front-end and backend.
sidebar_label: Understanding Call Quality
pagination_label: Understanding Call Quality
keywords:
  - audio calling
  - video calling
  - real-time communication
  - collaboration
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: understanding-call-quality
---

# Understanding Call Quality - Android

When developing a video call app, customer satisfaction heavily depends on your app's video and audio quality and its fluctuation.

## Call Quality

If we look at the video quality from the user's perspective, a good video quality can be defined as smooth and clear video, along with a crystal clear audio. If the same is viewed from the developer's perspective, a good video quality can be determined as a high resolution, high frame rate video with minimal latency along with a high bitrate audio with minimal audio loss.

## Factors affecting Quality

When it comes to measuring the video and audio quality of a call, there are multiple variables to consider, and the most common factors which affect the video and audio quality are:

### `1. Network Bandwidth`

- Network bandwidth is a measurement of a user's network capability to how large data can be received and send.
- If the bandwidth is low at participant side, he/she is likely to get pixelated or frozen video along with robotic voice or minor breaking in the audio.
- Frequent change in the network providers can also result in high fluctuation of the internet bandwidth, which can also result in poor quality video.

### `2. Latency`

- Latency basically means the time it takes for data to transfer from one machine to another.
- If the meeting is hosted in `Ohio` region, and users are joining from `Singapore` region, so this will create long delay for data to transfer from one machine to another, thus you should pick a server according to your user base.
- In VideoSDK you can set the server during creation of Meeting/Room.

### `3. CPU Usage`

- CPU Usage is an also quite determining factor as all the audio and video streams which are going out and coming in will have to encoded or decoded which will require a significant amount of computation.
- The high the resolution and frame rate of the videos, the larger would be the computation required, which can be a reason for the bottleneck of delivering a good quality video.
- If the CPU is being consumed heavily, it can also result in a choppy or robotic audio.

### `4. Camera and Mic Quality`

- The camera and microphone should capture good quality of streams so that remote user doesn't get low quality stream even if he/she has good network bandwidth

## Identifying the Quality Issues

In order to identify quality issues, VideoSDK collects multiple audio and video related metrics which can help in pinpointing the quality issues. Let's have a look at those metrics and understand what the indicates.

### `1. Resolutions and Framerates`

- Resolution and frame rate are key metrics for video quality in a video call app. Resolution refers to the number of pixels in a video image, while frame rate refers to the number of frames displayed per second.

- Higher resolutions and frame rates can provide better video quality, but they also require more bandwidth and processing power. It's important to optimize this metrics for the devices and network conditions of your users.

- For example, if most of your users are on mobile devices, a lower resolution and frame rate may be more appropriate to ensure smooth playback and minimize bandwidth usage.

- If most of your users are on mobile and desktop devices, having higher resolution for desktop and mid-resolutions for mobile devices can help in improving the performance and quality as we will be saving the bandwidth on the mobile end.

### `2. Bitrate`

- Bitrate is the number of bits per second send or received during the transmission of audio or video streams. Bitrate can be a key parameter to determine the quality of the audio or video streams, as it should be fine-tuned for each resolution to achieve the best match of performance and bandwidth utilization.

- If the users are having excellent network conditions, higher bitrate can result in much better video quality but on the other hand, having very high bitrates on the mobile devices can result in heating issues due to high computation required to encode and decode the videos.

##### Example

We joined using the same phone **(iPhone 14)**, but the resolution and bitrate were different, first participant having resolution **`1280x720`** with bitrate **`1442 kbps`** and second participant having resolution **`960x540`** with bitrate **`642 kbps`**, so as we can see both participants' video appeared to be of equal quality even though resolution and bitrate are different.

![resolution-and-bitrate](/img/resolution-and-bitrate.png)

### `3. Packet Loss`

- Packet loss is a metric that indicates how many data packets are lost during transmission from the sender to the receiver. Packet loss can occur due to network congestion, hardware or software issues, or network latency. Higher packet loss can result in poor video and audio quality, as the missing packets can cause gaps or distortions in the media stream.

import ReactPlayer from 'react-player'

<div style={{textAlign: 'center'}}>

<ReactPlayer autoplay muted loop playing url='/video/packet-loss-burst.mp4' width={"100%"}/>

</div>

### `4. Jitter`

- The audio and video packets are sent out at random intervals over a specified time frame as they are being sent between the server and client. Nevertheless, jitter is produced when there is a variation in transmitting or receiving this data packets as a result of a faulty network connection.

- When data packets delay while being transmitted to the participant, usually because the network is busy. They'll display as pixelated video on a video call or sound choppy, distorted, or robotic on a voice call as they arrive. They'll arrive at random intervals, creating jitter.

### `5. Round Trip Time (Latency)`

- Round trip time is the amount of time required to transmit the data packets to send or receive from the server. If the servers are located very far from the user's location, they can observe a high latency (delay).

- With VideoSDK, this factor is taken care of as we automatically choose the nearest available server for participants. But if you are geofencing to a certain region, you should make sure that you choose the server which will be nearest to your users.

<center>

![resolution-and-bitrate](/img/rtt.png)

</center>

## Checking Realtime Statistics

VideoSDK provides methods to check the realtime statistics of the audio and video of all the participants.

### `getVideoStats()`

- `getVideoStats()` returns an array of object containing the different quality parameters for video stream which can be accessed through the `useParticipant` hook.

- This objects will have values for the specific participant's video stream resolution, frame rate, bitrate, jitter, round trip time, and packet loss.

<div style={{textAlign: 'center'}}>

<ReactPlayer autoplay muted loop playing url='/video/realtime-stats.mp4' width={"100%"}/>

</div>

### `getAudioStats()`

- `getAudioStats()` returns an array of object containing the different quality parameters for audio stream which can be accessed through the `useParticipant` hook.

- This objects will have values for the specific participant's audio stream bitrate, jitter, round trip time and packet loss.

### `getShareStats()`

- `getShareStats()` returns an array of object containing the different quality parameters for screen share stream which can be accessed through the `useParticipant` hook.

- This objects will have values for the specific participant's screen share stream resolution, frame rate, bitrate, jitter, round trip time, and packet loss.

:::note
To show the popup dialog for the participant's realtime stats, you can [refer to this component](https://github.com/videosdk-live/videosdk-rtc-react-sdk-example/blob/main/src/utils/common.js#L142).
:::

## Quality analysis Graphs

For all the sessions taken using the VideoSDK, you can find the quality analysis graphs from the [VideoSDK Dashboard](https://app.videosdk.live/meetings/sessions) which can help you visualize the data you are seeing in realtime and identify the spikes of a few parameters happing during call which can help figure out the reason for the quality issue.

![quality analysis](/img/quality-analysis.png)

## API Reference

The API references for all the methods and events utilised in this guide are provided below.

- [getVideoStats()](/android/api/sdk-reference/participant-class/methods#getvideostats)
- [getAudioStats()](/android/api/sdk-reference/participant-class/methods#getaudiostats)
- [getShareStats()](/android/api/sdk-reference/participant-class/methods#getsharestats)


---

---
sidebar_label: Virtual Background
pagination_label: Virtual Background
---

# Virtual Background - Android

Virtual backgrounds allow you to replace your actual background during video calls or meetings with an image, a solid color, or even a blur effect. This can be useful for:

- Privacy: Hide your messy room or anything you don't want others to see.

- Focus: Minimize distractions and keep the focus on the conversation.

- Fun: Liven up the call with a cool background theme.

import ReactPlayer from 'react-player'

<ReactPlayer controls autoplay muted loop playing url='https://assets.videosdk.live/images/android-video-processor.mp4' width={"100%"} />

## Virtual Background using `MediaEffects` library

The `MediaEffects` library enables the integration of sophisticated virtual background effects within your video applications. By leveraging this library, users can replace their physical backgrounds with custom images or static backdrops, creating a more immersive and engaging experience. 

:::info

The Virtual Background feature in VideoSDK can be utilized regardless of the meeting environment, including the pre-call screen.

:::

### Install the library 
You can install our Android library by using Maven Central package repositories.

- Add the dependency in your `app/build.gradle` file.

```js title="app/build.gradle"
dependencies {
	implementation 'live.videosdk:videosdk-media-effects:0.0.2'
	// other app dependencies
}
```
### Apply Virtual Background

- The `applyVideoProcessor()` method of the `VideoSDK` class enables dynamic changes to the video background during a live session.
- This method accepts an instance of the `VideoFrameProcessor` class as its parameter.
- The following classes implement the `VideoFrameProcessor` interface. Depending on your requirements, you can create an instance of the appropriate class and pass it to the `applyVideoProcessor()` method:

    1. `BackgroundImageProcessor` : The `BackgroundImageProcessor` class takes a `Uri` as a parameter and uses it as the video stream background.
    2. `BackgroundBlurProcessor`: The `BackgroundBlurProcessor` class takes a `float` value for the blur radius and a `Context` to apply a blur effect to the video stream background. It supports range between 0 to 25.
    3. `BackgroundColorProcessor`: The `BackgroundColorProcessor` class takes an `int` value for the color and sets it as the background for the video stream.

### Change Virtual Background

- To change the virtual background, users can utilize a set of setters that allow easy switching between a new image, a blur effect, or a solid color. This functionality supports dynamic customization, enhancing the user's video experience by enabling seamless background updates in real-time.

- You can use following setters to change Virtual Background:

    1. `setBackgroundSource(Uri uri)`: This method of the `BackgroundImageProcessor` class takes a `Uri` as a parameter to update the current background image for the video stream.
    2. `setBlurRadius(float opacity)`: This method of the `BackgroundBlurProcessor` class takes a `float` value for the blur radius to adjust the blur effect of the current background.
    3. `setBackgroundColor(int color)`: This method of the `BackgroundColorProcessor` class takes an `int` value as a parameter to update the current background color for the video stream.
### Remove Virtual Background

- The `removeVideoProcessor()` method from the `VideoSDK` class provides users with a convenient way to revert their video background to its original state, removing any previously applied virtual background. This functionality ensures flexibility for users to switch between virtual and real backgrounds as needed.

#### Example

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
Class MeetingActivity : AppCompatActivity() {
    private var backgroundImageProcessor: BackgroundImageProcessor? = null
    private var backgroundBlurProcessor: BackgroundBlurProcessor? = null
    private var backgroundColorProcessor: BackgroundColorProcessor? = null

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)

        //...

        //To Apply Virtual Background
        findViewById<View>(R.id.applyBackground).setOnClickListener { view: View? ->
            val uri =
                Uri.parse("https://st.depositphotos.com/2605379/52364/i/450/depositphotos_523648932-stock-photo-concrete-rooftop-night-city-view.jpg")
            backgroundImageProcessor = BackgroundImageProcessor(uri)
      //    backgroundBlurProcessor = BackgroundBlurProcessor(25f, this)
      //    backgroundColorProcessor = BackgroundColorProcessor(Color.BLUE)
            VideoSDK.applyVideoProcessor(backgroundColorProcessor)
        }

        //To Change Virtual Background
        findViewById<View>(R.id.changeBackground).setOnClickListener { view: View? ->
            val newUri =
                Uri.parse("https://images.pexels.com/photos/531880/pexels-photo-531880.jpeg?cs=srgb&dl=pexels-pixabay-531880.jpg&fm=jpg")
            backgroundImageProcessor!!.setBackgroundSource(newUri)
      //    backgroundColorProcessor!!.setBackgroundColor(Color.CYAN)
      //    backgroundBlurProcessor!!.setBlurRadius(17f)
        }
        
        //To Remove Virtual Background
        findViewById<View>(R.id.changeBackground).setOnClickListener { view: View? ->
            VideoSDK.removeVideoProcessor()
        }
    }
}
```

</TabItem>

<TabItem value="Java">

```java
public class MeetingActivity extends AppCompatActivity {

    private BackgroundImageProcessor backgroundImageProcessor;
    private BackgroundBlurProcessor backgroundBlurProcessor;
    private BackgroundColorProcessor backgroundColorProcessor;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        //...

        //To Apply Virtual Background
        findViewById(R.id.applyBackground).setOnClickListener(view -> {
            Uri uri = Uri.parse("https://st.depositphotos.com/2605379/52364/i/450/depositphotos_523648932-stock-photo-concrete-rooftop-night-city-view.jpg");
            backgroundImageProcessor = new BackgroundImageProcessor(uri);
        //   backgroundBlurProcessor = new BackgroundBlurProcessor(25,this);
        //   backgroundColorProcessor = new BackgroundColorProcessor(Color.BLUE);
            VideoSDK.applyVideoProcessor(backgroundColorProcessor);
        });

        //To Change Virtual Background
        findViewById(R.id.changeBackground).setOnClickListener(view -> {
            Uri newUri = Uri.parse("https://images.pexels.com/photos/531880/pexels-photo-531880.jpeg?cs=srgb&dl=pexels-pixabay-531880.jpg&fm=jpg");
            backgroundImageProcessor.setBackgroundSource(newUri);
        //    backgroundColorProcessor.setBackgroundColor(Color.CYAN);
        //    backgroundBlurProcessor.setBlurRadius(17);    
        });
        
        //To Remove Virtual Background
        findViewById(R.id.removeBackground).setOnClickListener(view -> {
            VideoSDK.removeVideoProcessor();
        });
    }
}
```

</TabItem>

</Tabs>

## API Reference

The API references for all the methods utilized in this guide are provided below.

- [applyVideoProcessor()](/android/api/sdk-reference/videosdk-class/methods#applyvideoprocessor)
- [removeVideoProcessor()](/android/api/sdk-reference/videosdk-class/methods#removevideoprocessor)



---

---
title: Run the HLS Sample Android Project - Video SDK Docs
hide_title: true
hide_table_of_contents: false
description: Create customizable real-time video & audio calling applications with React JS SDK with Video SDK add live Video & Audio conferencing to your applications.
sidebar_label: Run Http Live Streaming Project
pagination_label: Run Http Live Streaming Project
keywords:
  - android sdk
  - sample project
  - android app
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: run-a-sample-android-hls-project
---

# Run a Sample HLS Project - Android

Video SDK provides open-source sample project [videosdk-hls-android-kotlin-example](https://github.com/videosdk-live/videosdk-hls-android-kotlin-example) on Github. This document introduces how to run this project.

## Prerequisites

- Development environment requirements:
  - [Java Development Kit](https://www.oracle.com/java/technologies/downloads/)
  - Android Studio 3.0 or later
- A physical or virtual mobile device running Android 5.0 or later
- Valid Video SDK [Account](https://app.videosdk.live/)

import APISecret from '../../../mdx/introduction/\_api-key.mdx';

<APISecret title="Get your API key and Secret key" />

## Run the Sample Project

### Step 1: Clone the sample project

Clone the repository to your local environment.

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
git clone https://github.com/videosdk-live/videosdk-hls-android-kotlin-example.git
```

</TabItem>

<TabItem value="Java">

```js
git clone https://github.com/videosdk-live/videosdk-hls-android-java-example.git
```

</TabItem>

</Tabs>

### Step 2: Modify local.properties

Open your favorite code editor, add `auth_token` in `local.properties` file and paste the earlier generated temporary token as value.

```js title="local.properties"
auth_token = "TEMPORARY-TOKEN";
```

### Step 3: Run the sample app

Run the android app with **Shift+F10** or the ** ▶ Run ** from toolbar.


---

---
title: Run the ILS Sample Android Project - Video SDK Docs
hide_title: true
hide_table_of_contents: false
description: Create customizable real-time video & audio calling applications with React JS SDK with Video SDK add live Video & Audio conferencing to your applications.
sidebar_label: Run Interactive Live Streaming Project
pagination_label: Run the ILS Project
keywords:
  - android sdk
  - sample project
  - android app
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: run-a-sample-android-ils-project
---

# Run Interactive Live Streaming Project - Android

Video SDK provides open-source sample project [videosdk-ils-android-kotlin-example](https://github.com/videosdk-live/videosdk-ils-android-sdk-example) on Github. This document introduces how to run this project.

## Prerequisites

- Development environment requirements:
  - [Java Development Kit](https://www.oracle.com/java/technologies/downloads/)
  - Android Studio 3.0 or later
- A physical or virtual mobile device running Android 5.0 or later
- Valid Video SDK [Account](https://app.videosdk.live/)

import APISecret from '../../../mdx/introduction/\_api-key.mdx';

<APISecret title="Get your API key and Secret key" />

## Run the Sample Project

### Step 1: Clone the sample project

Clone the repository to your local environment.

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
git clone https://github.com/videosdk-live/videosdk-ils-android-sdk-example
```

</TabItem>

<TabItem value="Java">

```js
git clone https://github.com/videosdk-live/videosdk-ils-android-sdk-example
```

</TabItem>

</Tabs>

### Step 2: Modify local.properties

Open your favorite code editor, add `auth_token` in `local.properties` file and paste the earlier generated temporary token as value.

```js title="local.properties"
auth_token = "TEMPORARY-TOKEN";
```

### Step 3: Run the sample app

Run the android app with **Shift+F10** or the ** ▶ Run ** from toolbar.


---

---
title: Run a sample Android Project - Video SDK Docs
hide_title: true
hide_table_of_contents: false
description: Create customizable real-time video & audio calling applications with Android SDK with Video SDK add live Video & Audio conferencing to your applications.
sidebar_label: "Run Audio & Video Call Project"
pagination_label: "Run Audio & Video Call Project"
keywords:
  - android sdk
  - java sdk
  - kotlin sdk
  - sample project
  - android app
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: run-a-sample-android-project
---

# Run Audio & Video Call Project - Android

Video SDK provides open-source sample project [videosdk-rtc-android-kotlin-sdk-example](https://github.com/videosdk-live/videosdk-rtc-android-kotlin-sdk-example) on Github. This document introduces how to run this project.

## Prerequisites

- Development environment requirements:
  - [Java Development Kit](https://www.oracle.com/java/technologies/downloads/)
  - Android Studio 3.0 or later
- A physical or virtual mobile device running Android 5.0 or later
- Valid Video SDK [Account](https://app.videosdk.live/)

import APISecret from '../../../mdx/introduction/\_api-key.mdx';

<APISecret title="Get your API key and Secret key" />

## Run the Sample Project

### Step 1: Clone the sample project

Clone the repository to your local environment.

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
git clone https://github.com/videosdk-live/videosdk-rtc-android-kotlin-sdk-example.git
```

</TabItem>

<TabItem value="Java">

```js
git clone https://github.com/videosdk-live/videosdk-rtc-android-java-sdk-example.git
```

</TabItem>

</Tabs>

### Step 2: Modify local.properties

Open your favorite code editor, add `auth_token` in `local.properties` file and paste the earlier generated temporary token as value.

```js title="local.properties"
auth_token = "TEMPORARY-TOKEN";
```

### Step 3: Run the sample app

Run the android app with **Shift+F10** or the ** ▶ Run ** from toolbar.


---

---
title: Just Click Setup - Testing Token Server | Video SDK
hide_title: true
hide_table_of_contents: false
description: Video SDK and Audio SDK, developers need to implement a token server. This requires efforts on both the front-end and backend.
sidebar_label: Authentication and Tokens
pagination_label: Authentication and Tokens
keywords:
  - audio calling
  - video calling
  - real-time communication
  - collaboration
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: server-setup
---

import ServerSetup from '../../../mdx/introduction/\_server-setup.mdx';
import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>
<ServerSetup />


---

---
title: Initialize Meeting | Video SDK
hide_title: true
hide_table_of_contents: false
description: Video SDK and Audio SDK, developers need to implement a token server. This requires efforts on both the front-end and backend.
sidebar_label: Initialize Meeting
pagination_label: Initialize Meeting
keywords:
  - audio calling
  - video calling
  - real-time communication
  - collaboration
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: initialize-meeting
---

# Initialize Meeting - Android

To configure a VideoSDK meeting you require two things, first the `token` which will be used for **Authentication** purpose and a `meetingId` which will be used to specify where a participant will join. Let's see each of the steps closely.

### Generating Token

You can generate a `token` in two ways:

1. **`Temporary Token`** : You can visit [Dashboard's API Key section](https://app.videosdk.live/api-keys) and generate the temporary token from there.

2. **`Server`** : You can setup **JWT** in backend and make an API call to get the token from your server.

To learn more about **Authentication** and token in detail you can follow [this guide](../authentication-and-token).

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
// With Temporary Token
fun getToken(): String? {
  // Update the token here from the VideoSDK dashboard
  // highlight-next-line
  return "YOUR_TOKEN"
}

// Server
fun getToken(): String? {
  val token = arrayOfNulls<String>(1)
  // highlight-start
  AndroidNetworking.get("http://localhost:3000/get-token")
      .build()
      .getAsJSONObject(object : JSONObjectRequestListener() {
          fun onResponse(response: JSONObject) {
              try {
                  token[0] = response.getString("token")
              } catch (e: JSONException) {
                  e.printStackTrace()
              }
          }

          fun onError(anError: ANError) {
              anError.printStackTrace()
          }
      })
  // highlight-end
  return token[0]
}
```

</TabItem>

<TabItem value="Java">

```java
// With Temporary Token
public String getToken()
{
  // Update the token here from the VideoSDK dashboard
  // highlight-next-line
  String token = "YOUR_TOKEN";
  return token;
}

// Server
public String getToken()
{
  final String[] token = new String[1];
  // highlight-start
  AndroidNetworking.get("http://localhost:3000/get-token")
      .build()
      .getAsJSONObject(new JSONObjectRequestListener() {
          @Override
          public void onResponse(JSONObject response) {
              try {
                  token[0] = response.getString("token");
              } catch (JSONException e) {
                  e.printStackTrace();
              }
          }
          @Override
          public void onError(ANError anError) {
              anError.printStackTrace();
          }
      });
  // highlight-end
  return token[0];
}
```

</TabItem>

</Tabs>

### Generating Meeting Id

With the token ready, we can get the `meetingId` from the [VideoSDK's rooms API](/api-reference/realtime-communication/create-room).

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
fun getMeetingId(token: String?): String? {
  var meetingId: String? =null;
  // We will use VideoSDK rooms API endpoint to create a meetingId
  // highlight-start
  AndroidNetworking.post("https://api.videosdk.live/v2/rooms")
      .addHeaders("Authorization", token) // We will pass the token in the headers
      .build()
      .getAsJSONObject(object : JSONObjectRequestListener() {
          fun onResponse(response: JSONObject) {
              try {
                  meetingId = response.getString("roomId")
              } catch (e: Exception) {
                  e.printStackTrace()
              }
          }

          fun onError(anError: ANError) {
              anError.printStackTrace()
          }
      })
  // highlight-end
  //we will return the meetingId which we got from the response of the api
  return meetingId
}
```

</TabItem>

<TabItem value="Java">

```java
public String getMeetingId(String token) {
  final String[] meetingId = new String[1];
  // We will use VideoSDK rooms API endpoint to create a meetingId
  // highlight-start
  AndroidNetworking.post("https://api.videosdk.live/v2/rooms")
      .addHeaders("Authorization", token) // We will pass the token in the headers
      .build()
      .getAsJSONObject(new JSONObjectRequestListener() {
          @Override
          public void onResponse(JSONObject response) {
              try {
                  meetingId[0] = response.getString("roomId");
              } catch (Exception e) {
                  e.printStackTrace();
              }
          }
          @Override
          public void onError(ANError anError) {
              anError.printStackTrace();
          }
      });
  // highlight-end
  //we will return the meetingId which we got from the response of the api
  return meetingId[0];
}
```

</TabItem>

</Tabs>

:::tip
To perform Network call you need to add [Fast Android Networking Library](https://github.com/amitshekhariitbhu/Fast-Android-Networking) in your application.
:::

### Initialization of Meeting

1. To initialize the meeting, first we have to initialize the VideoSDK.
   We can initialize the VideoSDK using `initialize()` method provided by the SDK.

```js title="initialize"
  VideoSDK.initialize(Context context)
```

2. Next, we have to set token property of VideoSDK class.
   By using `config()` method, you can set the token property of VideoSDK class.

```js title="config"
 VideoSDK.config(String token)
```

3. Now, we can initialize the meeting using a factory method provided by the SDK called `initMeeting()`.

`initMeeting()` is responsible for initializing the meeting with the provided configuration, which includes the `meetingId`, `name`, `participantId` and many more.

:::tip
When conducting one-to-one meetings, it is recommended to set `multistream:false`.For more information on multistream, refer to the [multistream documentation](/android/guide/video-and-audio-calling-api-sdk/render-media/optimize-video-track#what-is-multistream).
:::

Let's take a deeper look at the available configuration options first.

```js title="initMeeting"
  VideoSDK.initMeeting(
      Context context,  // context of activity
      String meetingId,  // id of meeting
      String name, // name of participant
      boolean micEnabled, // flag to enable-mic
      boolean webcamEnabled, // flag to enable-webcam
      String participantId,  // id of participant
      String mode, // mode of participant
      boolean multiStream, // multiStream
      Map<String, CustomStreamTrack> customTracks, // map of customTracks
      JSONObject metaData, // metaData
      String signalingBaseUrl // signalingBaseUrl
      PreferredProtocol preferredProtocol //preferredProtocol
  )
```

- **`context`** :

  - Context of activity.
  - It will accept `Context` type value.

- **`meetingId`** :

  - meetingId is unique identifiers that allow participants to join a specific meeting or room.
  - It will accept `String` type value.
  - It will be in the format of `xxx-yyy-zzz` and will be generated using the [VideoSDK's Room API](/api-reference/realtime-communication/create-room).

- **`name`**:

  - This will represent the name of the participant in the meeting.
  - It will accept `String` type value.

- **`micEnabled`**:

  - This is a `boolean` flag, indicating whether a participant's microphone will be automatically enabled when they join a meeting.

- **`webcamEnabled`**:

  - This is a `boolean` flag, indicating whether a participant's webcam will be automatically enabled when they join a meeting.

- **`participantId`**:

  - This will be the unique identifier for the participant inside the meeting.
  - It can be used to specify the **unique identifier** which can be linked with **your own database** service.
  - It has to be of `String` type.
  - If you passed `null` then by default VideoSDK will generate unique id for each participant.

- **`multistream`**:

  - This is a `boolean` flag, indicating if the stream should send multiple resolution layers or single resolution layer.

:::caution
You must ensure that the `participantId` is not repeated in the same meeting or room, It will enable VideoSDK to eliminate any participant respect to that `participantId`.
:::

- **`mode`**:

  - There are 3 types of modes:

    1. `SEND_AND_RECV` : Both audio and video streams will be produced and consumed in this mode.

    2. `SIGNALLING_ONLY` : Audio and video streams will not be produced or consumed in this mode.

    3. `RECV_ONLY`: This mode allows only the consumption of audio and video streams without producing any.

  - It has to be of `String` type.
  - If you passed `null` then by default VideoSDK will set `SEND_AND_RECV` mode.

import CautionMessage from '@site/src/theme/CautionMessage';

<CautionMessage sdk="Android SDK" version="v0.2.0" />

- **`multiStream`**:

  - It will specify if the stream should send multiple resolution layers or single resolution layer.

  - It has to be of `boolean` type.

- **`customTracks`**:

  - If you want to set the initial custom tracks, then you can pass map of custom tracks in this paramater.

  - It has to be of `Map<String, CustomStreamTrack>` type.

- **`metaData`**:

  - If you want to provide additional details about a user joining a meeting, such as their profile image, you can pass that information in this parameter.

  - It has to be of `JsonObject` type.

- **`signalingBaseUrl`**:

  - If you want to use a proxy server with the VideoSDK, you can specify your base URL here.

  - It has to be of `String` type.

  - It is Optional parameter.

:::note

If you intend to use a proxy server with the VideoSDK, priorly inform us at support@videosdk.live

:::

- **`preferredProtocol`**:

  - If you want to provide a preferred network protocol for communication, you can specify that in `PreferredProtocol`, with options including `UDP_ONLY`, `UDP_OVER_TCP`, and `TCP_ONLY`.

  - It has to be of `PreferredProtocol` type.

  - It is Optional parameter.

With all the configuration options explained, here is how you can initialize the meeting.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
class MainActivity : AppCompatActivity() {

  fun getToken(): String? {
    //highlight-next-line
    ...
  }

  fun getMeetingId(token: String?): String? {
    //highlight-next-line
    ...
  }

 override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    setContentView(R.layout.activity_main)

    // initialize AndroidNetworking to perform Network call
    AndroidNetworking.initialize(applicationContext)

    //We will fetch token and meetingId and store it in local variables
    val token: String = getToken()
    val meetingId = getMeetingId(token)

    // highlight-start
    // initialize the VideoSDK
    VideoSDK.initialize(this@MainActivity)

    // set token property of VideoSDK
    VideoSDK.config(token)

    // create a new meeting instance
    val meeting: Meeting = VideoSDK.initMeeting(
        this@MainActivity, meetingId, "NAME HERE",
        true, true, null, null, false, null, null
    )
    // highlight-end

    Log.d("VideoSDK", "onCreate: $meetingId")
  }
}
```

</TabItem>

<TabItem value="Java">

```java
public class MainActivity extends AppCompatActivity {

  public String getToken()
  {
    //highlight-next-line
    ...
  }

  public String getMeetingId(String token) {
    //highlight-next-line
    ...
  }

  @Override
  protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);

    // initialize AndroidNetworking to perform Network call
    AndroidNetworking.initialize(getApplicationContext());

    //We will fetch token and meetingId and store it in local variables
    String token = getToken();
    String meetingId = getMeetingId(token);

    // highlight-start
    // initialize the VideoSDK
    VideoSDK.initialize(MainActivity.this);

    // set token property of VideoSDK
    VideoSDK.config(token);

    // create a new meeting instance
    Meeting meeting = VideoSDK.initMeeting(
            MainActivity.this, meetingId, "NAME HERE",
            true, true, null, null, false, null, null
    // highlight-end

    Log.d("VideoSDK", "onCreate: " + meetingId);
  }
}
```

</TabItem>

</Tabs>

### API Reference

The API references for all the methods utilised in this guide are provided below.

- [initMeeting](/android/api/sdk-reference/initMeeting)


---

---
title: Join Meeting | Video SDK
hide_title: true
hide_table_of_contents: false
description: Video SDK and Audio SDK, developers need to implement a token server. This requires efforts on both the front-end and backend.
sidebar_label: Join Meeting
pagination_label: Join Meeting
keywords:
  - audio calling
  - video calling
  - real-time communication
  - collaboration
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: join-meeting
---

# Join Meeting - Android

### Overview

After meeting initialization by `initMeeting()` it returns a new instance of `Meeting`. If you have not initialized a meeting yet, you can [follow the guide here.](./initialize-meeting) However, by default, it will not automatically join the meeting. Hence, to join the meeting you have to call `join()` .

### `join()`

- To join the meeting you can call the `join()` method of `Meeting` class.
- This method can be called after the meeting is initialized using `VideoSDK` class.

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
class MainActivity : AppCompatActivity() {
 override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    setContentView(R.layout.activity_main)
    // initialize the meeting
    ...

    // join meeting
    // highlight-next-line
    meeting!!.join()
  }
}
```

</TabItem>

<TabItem value="Java">

```java
public class MainActivity extends AppCompatActivity {
  @Override
  protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);
    // initialize the meeting
    ...

    // join meeting
    // highlight-next-line
    meeting.join();
  }
}
```

</TabItem>

</Tabs>

### Events associated with Join

Following callbacks are received when a participant is successfully joined.

- [Local Participant](../concept-and-architecture#2-participant) will receive a [`onMeetingJoined`](/android/api/sdk-reference/meeting-class/meeting-event-listener-class#onmeetingjoined) event, when successfully joined.
- [Remote Participant](../concept-and-architecture#2-participant) will receive a [`onParticipantJoined`](/android/api/sdk-reference/meeting-class/meeting-event-listener-class#onparticipantjoined) event with the newly joined `Participant` object from the event callback.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
class MainActivity : AppCompatActivity() {
 override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    setContentView(R.layout.activity_main)
    // initialize the meeting
    ...

    // join meeting
    meeting!!.join()

    // Add event listener for listening upcoming events of meeting
    // highlight-next-line
    meeting!!.addEventListener(meetingEventListener)
  }

  private val meetingEventListener: MeetingEventListener = object : MeetingEventListener(){
    // Event to know meeting is joined
    //highlight-start
    fun onMeetingJoined() {
        Log.d("VideoSDK", "onMeetingJoined")
    }
    //highlight-end
    // Event to know some other participant joined
    //highlight-start
    fun onParticipantJoined(participant: Participant) {
        Log.d("#VideoSDK", participant.displayName + " joined");
    }
    //highlight-end
  }
}
```

</TabItem>

<TabItem value="Java">

```java
public class MainActivity extends AppCompatActivity {
  @Override
  protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);
    // initialize the meeting
    ...

    // join meeting
    meeting.join();

    // Add event listener for listening upcoming events of meeting
    //highlight-next-line
    meeting.addEventListener(meetingEventListener);
  }

  private final MeetingEventListener meetingEventListener=new MeetingEventListener() {
    // Event to know meeting is joined
    //highlight-start
    @Override
    public void onMeetingJoined() {
        Log.d("VideoSDK", "onMeetingJoined");
    }
    //highlight-end

    // Event to know some other participant joined
    //highlight-start
    @Override
    public void onParticipantJoined(Participant participant) {
        Log.d("#VideoSDK", participant.getDisplayName() + " joined");
    }
    //highlight-end
  };
}
```

</TabItem>

</Tabs>

### API Reference

The API references for all the methods and events utilised in this guide are provided below.

- [initMeeting](/android/api/sdk-reference/initMeeting)
- [join()](/android/api/sdk-reference/meeting-class/methods#join)
- [onMeetingJoined()](/android/api/sdk-reference/meeting-class/meeting-event-listener-class#onmeetingjoined)
- [onParticipantJoined()](/android/api/sdk-reference/meeting-class/meeting-event-listener-class#onparticipantjoined)


---

---
title: Leave or End Meeting | Video SDK
hide_title: true
hide_table_of_contents: false
description: Video SDK and Audio SDK, developers need to implement a token server. This requires efforts on both the front-end and backend.
sidebar_label: Leave or End Meeting
pagination_label: Leave or End Meeting
keywords:
  - audio calling
  - video calling
  - real-time communication
  - collaboration
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: leave-end-meeting
---

# Leave or End Meeting - Android

Participant can choose to leave the meeting without removing all the other participants. This is typically done by `Leave Meeting`.

Alternatively, if the participant is the host and the last person remaining in the session, they can choose `End Meeting` by removing all other participants, which will end the session for everyone.

### `leave()`

To leave the meeting without removing all the participant you need to call `leave()` method of `Meeting` class.

### `end()`

To leave the meeting by removing all the participant you need to call `end()` method of `Meeting` class.

:::note
This methods can be called after the meeting is joined successfully.
:::

#### Example

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
  btnLeave!!.setOnClickListener { _: View? ->
    //highlight-next-line
    meeting!!.leave() // Leaving Meeting
  }

  btnEnd!!.setOnClickListener { _: View? ->
    //highlight-next-line
    meeting!!.end() // Ending Meeting
  }
```

</TabItem>

<TabItem value="Java">

```js
  btnLeave.setOnClickListener(new View.OnClickListener() {
      @Override
      public void onClick(View v) {
        //highlight-next-line
        meeting.leave(); // Leaving Meeting
      }
  });

  btnEnd.setOnClickListener(new View.OnClickListener() {
      @Override
      public void onClick(View v) {
        //highlight-next-line
        meeting.end(); // Ending Meeting
      }
  });
```

</TabItem>

</Tabs>

### Events associated with Leave

Following callbacks are received when a participant leaves the meeting.

- [Local Participant](../concept-and-architecture#2-participant) will receive a callback[`onMeetingLeft`](/android/api/sdk-reference/meeting-class/meeting-event-listener-class#onmeetingleft).
- All [remote participants](../concept-and-architecture#2-participant) will receive a callback [`onParticipantLeft`](/android/api/sdk-reference/meeting-class/meeting-event-listener-class#onparticipantleft) with Participant object.

### Events associated with End

Following callbacks are received when a participant ends the meeting.

- All [remote participants](../concept-and-architecture#2-participant) and local participant will receive a callback on [`onMeetingLeft`](/android/api/sdk-reference/meeting-class/meeting-event-listener-class#onmeetingleft) of [`MeetingEventListener`](/android/api/sdk-reference/meeting-class/meeting-event-listener-class) class.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
private final MeetingEventListener meetingEventListener = new MeetingEventListener() {
  //Event to know meeting is left
  //highlight-start
  override fun onMeetingLeft() {
    Log.d("#VideoSDK", "onMeetingleft()")
  }
  //highlight-end

  //Event to know some other participant left
  //highlight-start
  override fun onParticipantLeft(participant: Participant) {
    Log.d("#VideoSDK", participant.displayName + " left");
  }
  //highlight-end
}
```

</TabItem>

<TabItem value="Java">

```javascript
private final MeetingEventListener meetingEventListener = new MeetingEventListener() {
  //Event to know meeting is left
  //highlight-start
  @Override
  public void onMeetingLeft() {
    Log.d("#VideoSDK", "onMeetingleft()")
  }
  //highlight-end

  //Event to know some other participant left
  //highlight-start
  @Override
  public void onParticipantLeft(Participant participant) {
    Log.d("#VideoSDK", participant.getDisplayName() + " left");
  }
  //highlight-end
}
```

</TabItem>

</Tabs>

### API Reference

The API references for all the methods and events utilised in this guide are provided below.

- [leave()](/android/api/sdk-reference/meeting-class/methods#leave)
- [end()](/android/api/sdk-reference/meeting-class/methods#end)
- [onMeetingLeft()](/android/api/sdk-reference/meeting-class/meeting-event-listener-class#onmeetingleft)
- [onParticipantLeft()](/android/api/sdk-reference/meeting-class/meeting-event-listener-class#onparticipantleft)


---

---
title: Precall Setup | Video SDK
hide_title: true
hide_table_of_contents: false
description: The precall feature allows users to configure their audio and video settings,  before starting a video call, ensuring a smooth and tailored communication experience.
sidebar_label: Precall Setup
pagination_label: Precall Setup
keywords:
  - audio calling
  - video calling
  - real-time communication
  - precall
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: precall
---

# Precall Setup - Android 

Picture this: before diving into the depths of a video call, imagine giving your setup a quick check-up, like a tech-savvy doctor ensuring all systems are a go. That's essentially what a precall experience does- it’s like your extensive debug session before the main code execution—a crucial step in ensuring your app's performance is top-notch.

## Why is it necessary?

Why invest time and effort into crafting a precall experience, you wonder? Well, picture this scenario: your users eagerly join a video call, only to encounter a myriad of technical difficulties—muted microphones, pixelated cameras, and laggy connections. Not exactly the smooth user experience you had in mind, right?

By integrating a robust precall process into your app, developers become the unsung heroes, preemptively addressing potential pitfalls and ensuring that users step into their video calls with confidence.

## Step-by-Step Guide: Integrating Precall Feature

### Step 1: Check and Request Permissions

- Begin by ensuring that your application has the necessary permissions to access user devices, such as the camera, microphone and Bluetooth.
- Utilize the `checkPermissions()` method of the `VideoSDK` class to verify if permissions are granted.
- If the permissions are not granted, the method will request the required permissions.
- `PermissionHandler` is used to manage and handle permission-related events (such as granting, denying, or blocking permissions).
  - `onGranted()`: This method is called when all requested permissions are granted.
  - `onBlocked()`: This method is called when one or more permissions are permanently blocked (i.e., the user has checked "Don't ask   again").
  - `onDenied()`: This method is called when one or more permissions are denied.
  - `onJustBlocked()`: This method is called when one or more permissions are just blocked (i.e., the user has just checked "Don't ask again" for the first time).

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
private fun checkPermissions() {
    val permissionList: MutableList<Permission> = ArrayList()
    permissionList.add(Permission.audio)
    permissionList.add(Permission.video)
    permissionList.add(Permission.bluetooth)
    val options = Permissions.Options()
                  .setRationaleDialogTitle("Info")
                  .setSettingsDialogTitle("Warning")
    VideoSDK.checkPermissions(this,
        permissionList,
        options,
        permissionHandler
    )
}

private val permissionHandler: PermissionHandler = object : PermissionHandler() {
    override fun onGranted() {
      Log.d("VideoSDK Permission", "onGranted: All permissions granted")          
    }
    override fun onBlocked(
      context: Context,
      blockedList: java.util.ArrayList<Permission>
    ): Boolean {
        for (blockedPermission in blockedList) {
              Log.d("VideoSDK Permission", "onBlocked: $blockedPermission")
            }
      return super.onBlocked(context, blockedList)
    }

    override fun onDenied(
      context: Context,
      deniedPermissions: java.util.ArrayList<Permission>
    ) {
        for (deniedPermission in deniedPermissions) {
              Log.d("VideoSDK Permission", "onDenied: $deniedPermission")
            }
      super.onDenied(context, deniedPermissions)
    }

    override fun onJustBlocked(
      context: Context,
      justBlockedList: java.util.ArrayList<Permission>,
      deniedPermissions: java.util.ArrayList<Permission>
      ) {
          for (justBlockedPermission in justBlockedList) {
              Log.d("VideoSDK Permission", "onJustBlocked: $justBlockedPermission")
            }
      super.onJustBlocked(context, justBlockedList, deniedPermissions)
    }
  }
```
</TabItem>

<TabItem value="Java">

```java
private void checkPermissions() {
    List<Permission> permissionList = new ArrayList<>();
    permissionListSDK.add(Permission.audio);
    permissionListSDK.add(Permission.video);
    permissionListSDK.add(Permission.bluetooth);

    Permissions.Options options = new Permissions
      .Options()
      .setRationaleDialogTitle("Info")
      .setSettingsDialogTitle("Warning");

    VideoSDK.checkPermissions(this, permissionList, options, permissionHandler);
}

PermissionHandler permissionHandler = new PermissionHandler() {
    @Override
    public void onGranted() {
      Log.d("VideoSDK Permission", "onGranted: All permissions granted")   
    }

    @Override
    public boolean onBlocked(Context context, ArrayList<Permission> blockedList) {
        for (Permission blockedPermission : blockedList) {
                Log.d("VideoSDK Permission", "onBlocked: " + blockedPermission);
            }
            return super.onBlocked(context, blockedList);
        }

      @Override
      public void onDenied(Context context, ArrayList<Permission> deniedPermissions) {
        for (Permission deniedPermission : deniedPermissions) {
                Log.d("VideoSDK Permission", "onDenied: " + deniedPermission);
            }
            super.onDenied(context, deniedPermissions);
        }

      @Override
      public void onJustBlocked(Context context, ArrayList<Permission> justBlockedList, ArrayList<Permission> deniedPermissions) {
        for (Permission justBlockedPermission : justBlockedList) {
                Log.d("VideoSDK Permission", "onJustBlocked: " + justBlockedPermission);
            }
            super.onJustBlocked(context, justBlockedList, deniedPermissions);
        }
};
```
</TabItem>

</Tabs>


<center>

<img src="https://cdn.videosdk.live/website-resources/docs-resources/android-precall-checkPermission.png" />

</center>


### Step 2: Render Device Lists

- You can fetch and render lists of available video and audio devices using the `getVideoDevices()` and `getAudioDevices()` methods of the VideoSDK class, respectively.
  
<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
private fun getAudioaDevices() {
  
  val audioDevices: Set<AudioDeviceInfo> = VideoSDK.getAudioDevices()
    for (audioDevice in audioDevices) {
        Log.d("VideoSDK", "Audio Device's DeviceId " + audioDevice.deviceId)
        Log.d("VideoSDK", "Audio Device's Label " + audioDevice.label)
        Log.d("VideoSDK", "Audio Device's Kind " + audioDevice.kind)
    }
}

private fun getVideoDevices() {
    val videoDevices: Set<VideoDeviceInfo> = VideoSDK.getVideoDevices()
    for (videoDevice in videoDevices) {
        Log.d("VideoSDK", "Video Device's DeviceId " + videoDevice.deviceId)
        Log.d("VideoSDK", "Video Device's Label " + videoDevice.label)
        Log.d("VideoSDK", "Video Device's Kind " + videoDevice.kind)
      }
}
```
</TabItem>

<TabItem value="Java">

```java

private void getAudioDevices() {
    Set<AudioDeviceInfo> audioDevices = VideoSDK.getAudioDevices();
    for (AudioDeviceInfo audioDevice:
        audioDevices) {
        Log.d("VideoSDK", "Audio Device's DeviceId " + audioDevice.getDeviceId());
        Log.d("VideoSDK", "Audio Device's Label " + audioDevice.getLabel());
        Log.d("VideoSDK", "Audio Device's Kind " + audioDevice.getKind());
    }
}

private void getVideoDevices() {
    Set<VideoDeviceInfo> videoDevices = VideoSDK.getVideoDevices();
    for (VideoDeviceInfo videoDevice:
            videoDevices) {
        Log.d("VideoSDK", "Video Device's DeviceId " + videoDevice.getDeviceId());
        Log.d("VideoSDK", "Video Device's Label " + videoDevice.getLabel());
        Log.d("VideoSDK", "Video Device's Kind " + videoDevice.getKind());
    }        
}
```
</TabItem>

</Tabs>


<center>
<img src="https://cdn.videosdk.live/website-resources/docs-resources/android-precall-audioDeviceList-new.png"  width="300" height="600"/>
</center>


### Step 3: Handle Audio Device Changes

- Implement the `onAudioDeviceChanged()` callback of the `VideoSDK` class to dynamically re-render audio device lists whenever new devices are attached or removed from the system.
- Ensure that users can seamlessly interact with newly connected devices without disruptions.


<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
VideoSDK.setAudioDeviceChangeListener(object : VideoSDK.AudioDeviceChangeEvent {
    override fun onAudioDeviceChanged(
        selectedAudioDevice: AudioDeviceInfo?,
        audioDevices: MutableSet<AudioDeviceInfo>?
    ) {
        Log.d(
            "VideoSDK",
            "Selected Audio Device: " + selectedAudioDevice.label
        )
        for (audioDevice in audioDevices) {
            Log.d("VideoSDK", "Audio Devices" + audioDevice.label)
        }
    }
})
```

</TabItem>

<TabItem value="Java">

```java
VideoSDK.setAudioDeviceChangeListener((selectedAudioDevice, audioDevices) -> {
    Log.d("VideoSDK", "Selected Audio Device: " + selectedAudioDevice.getLabel());
    for (AudioDeviceInfo audioDevice :
            audioDevices) {
        Log.d("VideoSDK", "Audio Devices" + audioDevice.getLabel());
    }
});
```

</TabItem>

</Tabs>



import ReactPlayer from 'react-player'

<ReactPlayer controls autoplay muted loop playing url='https://cdn.videosdk.live/website-resources/docs-resources/handle-new-device-android.mp4' width={"100%"} />

### Step 4: Ensuring the selected devices are used in the Meeting

- Ensure that the status of all relevant devices, such as the microphone and camera (on/off), as well as the selected devices, are correctly configured and passed into the meeting from the precall screen.
- To select a video device, you can either create a custom track with the chosen `VideoDeviceInfo` and pass it to the `initMeeting` method of the `VideoSDK` class, or you can use the `setSelectedVideoDevice()` method of the `VideoSDK` class.
- To select an audio device, use the `setSelectedAudioDevice()` method of the `VideoSDK` class.  
- By ensuring this integration, users can seamlessly transition from the precall setup to the actual meeting while preserving their preferred settings.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
class MainActivity : AppCompatActivity() {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)

        val customTracks: MutableMap<String, CustomStreamTrack> = HashMap()

        // Specify the video device to use in the meeting
        val videoDeviceInfo: VideoDeviceInfo = selectedVideoDeviceInfo

        val videoCustomTrack = VideoSDK.createCameraVideoTrack(
            "h720p_w960p", "front", CustomStreamTrack.VideoMode.TEXT, true,
            this, VideoSDK.getSelectedVideoDevice()
        )
        customTracks["video"] = videoCustomTrack

        VideoSDK.setSelectedVideoDevice(videoDeviceInfo)

        // Specify the audio device to use in the meeting
        val audioDeviceInfo: AudioDeviceInfo = selectedAudioDeviceInfo

        VideoSDK.setSelectedAudioDevice(audioDeviceInfo)

        val meeting: Meeting = VideoSDK.initMeeting(
            this@MainActivity, "meetingId", "John Due", true,
            true, null, null, false, customTracks, null
        );
    }
}
```
</TabItem>

<TabItem value="Java">

```java
public class MainActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        Map<String, CustomStreamTrack> customTracks = new HashMap<>();

        // Specify the video device to use in the meeting
        VideoDeviceInfo videoDeviceInfo = selectedVideoDeviceInfo; 

        CustomStreamTrack videoCustomTrack = VideoSDK.createCameraVideoTrack(
            "h720p_w960p", "front", CustomStreamTrack.VideoMode.TEXT, true,
            this, VideoSDK.getSelectedVideoDevice()
        );        
        customTracks.put("video", videoCustomTrack);

        VideoSDK.setSelectedVideoDevice(videoDeviceInfo);

        // Specify the audio device to use in the meeting
        AudioDeviceInfo audioDeviceInfo = selectedAudioDeviceInfo; 
 
        VideoSDK.setSelectedAudioDevice(audioDeviceInfo);

        Meeting meeting = VideoSDK.initMeeting(
            MainActivity.this, "meetingId", "John Due",true,
            true, null, null, false, customTracks,null
        );
    }
}
```
</TabItem>

</Tabs>

### Step 5: Get Selected Devices

- VideoSDK library provides two methods, `getSelectedVideoDevice()` and `getSelectedAudioDevice()`, which allow us to determine which video and audio devices are currently selected on our Android device.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
private fun getSelectedVideoDevice(){
    Log.d("TAG", "onCreate: " + VideoSDK.getSelectedVideoDevice().label)
}

private fun getSelectedAudioDevice(){
    Log.d("TAG", "onCreate: " + VideoSDK.getSelectedAudioDevice().label)
}
```

</TabItem>

<TabItem value="Java">

```java
private void getSelectedVideoDevice() {
  VideoDeviceInfo selectedVideoDevice = VideoSDK.getSelectedVideoDevice();
  Log.d("TAG", "Selected Video Device Label: " + selectedVideoDevice.getLabel());
}

private void getSelectedAudioDevice() {
  AudioDeviceInfo selectedAudioDevice = VideoSDK.getSelectedAudioDevice();
  Log.d("TAG", "Selected Audio Device Label: " + selectedAudioDevice.getLabel());
}
```

</TabItem>

</Tabs>


By following these step-by-step instructions, you can seamlessly integrate a precall feature into your application, empowering users to optimize their audio and video setup for a superior communication experience.

:::note

You can explore the complete implementation of the Precall feature in the official Android SDK example [available here.](https://github.com/videosdk-live/videosdk-rtc-android-kotlin-sdk-example)

:::

## API Reference

The API references for all the methods utilized in this guide are provided below.

- [checkPermissions](/android/api/sdk-reference/videosdk-class/methods#checkpermissions)
- [getAudioDevices](/android/api/sdk-reference/videosdk-class/methods#getaudiodevices)
- [getVideoDevices](/android/api/sdk-reference/videosdk-class/methods#getvideodevices)
- [setAudioDeviceChangeListener](/android/api/sdk-reference/videosdk-class/events)
- [getSelectedVideoDevice](/android/api/sdk-reference/videosdk-class/properties#getselectedvideodevice)
- [getSelectedAudioDevice](/android/api/sdk-reference/videosdk-class/properties#getselectedaudiodevice)






---

---
title: Sign up for free account Custom Video SDK
hide_title: false
hide_table_of_contents: false
description: Video SDK Sign up. Get started with 10,000 minutes free every month! Programmable Video SDKs and Rest APIs to build up scalable video conferencing applications.
sidebar_label: Get your API key and Secret key
pagination_label: Get your API key and Secret key
keywords:
  - authentication audio calling
  - authentication video calling
  - authentication real-time communication
  - tokens
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: signup-and-create-api
---

import APISecret from '../../../mdx/introduction/\_api-key.mdx';
import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>
<APISecret title="Get your API key and Secret key" />


---

---
title: Supported Device OS And Architecture
hide_title: false
hide_table_of_contents: false
description: Build customizable real-time video & audio calling applications in Android SDK using Video SDK add live Video & Audio conferencing to your applications.
sidebar_label: Supported Device OS And Architecture
pagination_label: Supported Device OS And Architecture
keywords:
  - android sdk
  - java sdk
  - kotlin sdk
  - chromebook sdk
  - supported device os and architecture
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: supported-device-os-architecture
---

# Supported Device OS and Architecture

:::note
The following device OS version represent the minimum required version to ensure full support for the listed features.
:::

import SupportList from '../../../src/theme/SupportedListContainer'

<SupportList renderOnlySDKList={true} isiOSSDKInclude={false}/>

<br/>

# Supported ABIs

import SupportABIList from '../../../src/theme/SupportedABIContainer'

<SupportABIList />


---

---
title: Post Transcription & Summary - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: Post Transcription features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add support for post transcription or captioning to your applications.
sidebar_label: Post Transcription & Summary
pagination_label: Post Transcription & Summary
keywords:
  - Start Post Transcription meeting
  - Stop Post Transcription meeting
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: post-transcribe-meeting
---

# Post Transcription & Summary - Android

This guide will walk you through the necessary steps to enable post-transcription functionality in your application, allowing users to access transcriptions of recorded meetings.

Moreover, VideoSDK offers flexibility in configuring post-time transcription, allowing you to set up webhooks for this purpose.

## Integrating Post Transcription Feature

![alt text](/img/transcription/post-transcription.png)

In the image above, the recording begins with transcription and summary features turned on. This triggers a webhook call for the start of recording. When the recording stops, another webhook is activated. After the recording, our transcriber starts transcribing, which in turn activates a webhook. Once the transcription is finished, it's sent to the summarizer for summary generation, and then another webhook is triggered.

### **Step 1: Configure Post Transcription & Summary**

- In this step, we set up the configuration for post transcription and summary generation. We define the webhook URL where the webhooks will be received.

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
// Webhook URL where, webhooks are received
val webhookUrl = "https://www.example.com"

//highlight-next-line
// Post Transcription Configuration
val prompt = "Write summary in sections like Title, Agenda, Speakers, Action Items, Outlines, Notes and Summary"
val summaryConfig = SummaryConfig(true, prompt)
val modelId = "raman_v1"
val transcription = PostTranscriptionConfig(true, summaryConfig, modelId)
```

</TabItem>

<TabItem value="Java">

```js
// Webhook URL where, webhooks are received
final String webhookUrl = "https://www.example.com";

//highlight-next-line
// Post Transcription Configuration
String prompt = "Write summary in sections like Title, Agenda, Speakers, Action Items, Outlines, Notes and Summary";
SummaryConfig summaryConfig = new SummaryConfig(true, prompt);
String modelId = "raman_v1";
PostTranscriptionConfig transcription = new PostTranscriptionConfig(true, summaryConfig, modelId);
```

</TabItem>

</Tabs>

### **Step 2: Start Recording with Transcription Configuration**

- Once the configuration is set, we initiate the recording process for the meeting, incorporating the transcription configuration we defined earlier.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
// Start Recording
meeting!!.startRecording(webhookUrl, "AWS Directory Path", null, transcription)
```

</TabItem>

<TabItem value="Java">

```js
// Start Recording
meeting.startRecording(webhookUrl, "AWS Directory Path", null, transcription);
```

</TabItem>

</Tabs>

### **Step 3: Stop Recording**

- When the meeting concludes or recording is no longer needed, we stop the recording process.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
// Stop Recording
meeting!!.stopRecording()
```

</TabItem>

<TabItem value="Java">

```js
// Stop Recording
meeting.stopRecording();
```

</TabItem>

</Tabs>

### **Step 4: Fetch Post Transcriptions**

- After the meeting recording is stopped, post transcription and summary data can be obtained using the [Post Transcription API](/api-reference/realtime-communication/fetch-post-transcriptions-summary).

- The API provides information such as the status of transcription, file paths for transcription data in various formats (JSON, SRT, TXT, TSV, VTT), and a summarized text file.

- The transcription document is structured as follows:

```json
{
  "id": "40b0a4ed-9842-40c9-a288-e4b1bf98a90a",
  "status": "completed",
  "roomId": "abc-xyzw-lmno",
  "sessionId": "621497578bea0d0404c35c4c",
  "recordingId": "65d303d6d2c373dfd71b38a2",
  "filePath": "https://cdn.videosdk.live/encoded/videos/dummy.mp4",
  "transcriptionFilePaths": {
    "json": "https://cdn.videosdk.live/transcriptions/dummy/dummy.json",
    "srt": "https://cdn.videosdk.live/transcriptions/dummy/dummy.srt",
    "txt": "https://cdn.videosdk.live/transcriptions/dummy/dummy.txt",
    "tsv": "https://cdn.videosdk.live/transcriptions/dummy/dummy.tsv",
    "vtt": "https://cdn.videosdk.live/transcriptions/dummy/dummy.vtt"
  },
  "summarizedFilePaths": {
    "txt": "https://cdn.videosdk.live/transcriptions/dummy/dummy-summary.txt"
  },
  "userStorage": null,
  "start": "2024-02-27T16:00:36.828Z",
  "end": "2024-02-27T16:01:46.939Z"
}
```

### Example

- The following code snippet allows you to start and stop recording meetings with just a click. When you click the "Start Recording" button, it begins recording the meeting and enables post-transcription, which generates a summary of the meeting's content. Clicking the "Stop Recording" button ends the recording.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
import android.os.Bundle
import android.widget.Button
import android.widget.Toast
import androidx.appcompat.app.AppCompatActivity

class MeetingActivity : AppCompatActivity() {
    private lateinit var meeting: Meeting

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_meeting)

        //initialize a meeting
        //...

        val startButton = findViewById<Button>(R.id.startRecording)
        val stopButton = findViewById<Button>(R.id.stopRecording)

        startButton.setOnClickListener {
            //highlight-start
            // Configuration for post transcription
            val prompt = "Write summary in sections like Title, Agenda, Speakers, Action Items, Outlines, Notes and Summary"
            val summaryConfig = SummaryConfig(true, prompt)
            val modelId = "raman_v1"
            val transcription = PostTranscriptionConfig(true, summaryConfig, modelId)

            // If you don't have a `webhookUrl` or `awsDirPath`, you have to pass null.
            // Start recording with post transcription
            meeting.startRecording("YOUR WEB HOOK URL", "AWS Directory Path", null, transcription)
            //highlight-end
        }

        stopButton.setOnClickListener {
            //highlight-start
            // Stop recording
            meeting.stopRecording()
            //highlight-end
        }
    }
}
```

</TabItem>

<TabItem value="Java">

```js
import android.os.Bundle;
import android.widget.Button;
import android.widget.Toast;
import androidx.appcompat.app.AppCompatActivity;

public class MeetingActivity extends AppCompatActivity {
    private Meeting meeting;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_meeting);

        //initialize a meeting
        //...

        Button startButton = findViewById(R.id.startRecording);
        Button stopButton = findViewById(R.id.stopRecording);

        startButton.setOnClickListener(v -> {
            //highlight-start
            // Configuration for post transcription
            String prompt = "Write summary in sections like Title, Agenda, Speakers, Action Items, Outlines, Notes and Summary";
            SummaryConfig summaryConfig = new SummaryConfig(true, prompt);
            String modelId = "raman_v1";
            PostTranscriptionConfig transcription = new PostTranscriptionConfig(true, summaryConfig, modelId);

            // If you don't have a `webhookUrl` or `awsDirPath`, you have to pass null.
            // Start recording with post transcription
            meeting.startRecording("YOUR WEB HOOK URL", "AWS Directory Path", null, transcription);
            //highlight-end
        });

        stopButton.setOnClickListener(v -> {
            //highlight-start
            // Stop recording
            meeting.stopRecording();
            //highlight-end
        });
    }
}
```

</TabItem>

</Tabs>

:::important

Please be aware that there may be a delay in processing the transcription data after the recording has been stopped. This delay could vary depending on factors such as server load and the duration of the meeting.

:::

### API Reference

The API references for all the methods utilized in this guide are provided below.

- [startRecording()](/android/api/sdk-reference/meeting-class/methods#startrecording)
- [stopRecording()](/android/api/sdk-reference/meeting-class/methods#stoprecording)
- [fetchPostTranscriptions](/api-reference/realtime-communication/fetch-post-transcriptions-summary)


---

---
title: Realtime Transcription - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: Realtime Transcription features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with VideoSDK to add support for realtime transcription or captioning to your applications.
sidebar_label: Realtime Transcription
pagination_label: Realtime Transcription
keywords:
  - Start Realtime Transcription meeting
  - Stop Realtime Transcription meeting
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: realtime-transcribe-meeting
---

# Realtime Transcription - Android

Realtime transcription allows you to transcribe audio content into text in real-time during a session. This guide will walk you through using the `startTranscription()` and `stopTranscription()` functions to manage realtime transcription in your application.

Moreover, VideoSDK offers flexibility in configuring real-time transcription, allowing you to set up webhooks for this purpose.

## Integrating Realtime Transcription Feature

![alt text](/img/transcription/realtime-transcription.png)

The above image represents,

1. **Start Transcription:** The SDK Client initiates real-time transcription using the `startTranscription` method.

2. **Resource Acquisition:** VideoSDK server requests necessary resources from transcription service.

   - If the request is denied, the server sends a `transcription-failed` event to the SDK Client.
   - If the request is successful, the server sends a `onTranscriptionStateChanged` event with status `TRANSCRIPTION_STARTED` to the client, indicating that transcription has begun.

3. **Transcription Data:** As transcription progresses, the client receives `onTranscriptionText` event with data such as the text itself, participant ID, and timestamp.

4. **Stop Transcription:** When the client decides to stop transcription, it informs the VideoSDK server to release resources.
   - The server then sends a `onTranscriptionStateChanged` event with status `TRANSCRIPTION_STOPPED` to confirm that transcription has ended and resources are released.

### **Step 1: Configure Realtime Transcription**

- In this step, we set up the configuration for realtime transcription. We define the webhook URL where the webhooks will be received.

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
// Webhook URL where, webhooks are received
val webhookUrl = "YOUR_WEBHOOK_URL"

//highlight-next-line
// Realtime Transcription Configuration
val summaryConfig = SummaryConfig(
    true,
    "Write summary in sections like Title, Agenda, Speakers, Action Items, Outlines, Notes and Summary"
)
val transcription = TranscriptionConfig(
    webhookUrl,
    summaryConfig
)
```

</TabItem>

<TabItem value="Java">

```js
// Webhook URL where, webhooks are received
final String webhookUrl = "YOUR_WEBHOOK_URL";

//highlight-next-line
// Realtime Transcription Configuration
SummaryConfig summaryConfig = new SummaryConfig(
    true,
    "Write summary in sections like Title, Agenda, Speakers, Action Items, Outlines, Notes and Summary"
);
TranscriptionConfig transcription = new TranscriptionConfig(
    webhookUrl,
    summaryConfig
);
```

</TabItem>

</Tabs>

### **Step 2: Listen for the transcription events**

- Here, we configure the callback methods for transcription events.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
private val meetingEventListener: MeetingEventListener = object : MeetingEventListener() {
  override fun onTranscriptionStateChanged(data: JSONObject) {
    try {
        val status = data.getString("status")
        val id = data.getString("id")
        when (status) {
            TranscriptionState.TRANSCRIPTION_STARTING.name -> Log.d("onTranscriptionStateChanged", "Realtime Transcription is starting, ID: $id")
            TranscriptionState.TRANSCRIPTION_STARTED.name -> Log.d("onTranscriptionStateChanged", "Realtime Transcription is started, ID: $id")
            TranscriptionState.TRANSCRIPTION_STOPPING.name -> Log.d("onTranscriptionStateChanged", "Realtime Transcription is stopping, ID: $id")
            TranscriptionState.TRANSCRIPTION_STOPPED.name -> Log.d("onTranscriptionStateChanged", "Realtime Transcription is stopped, ID: $id")
            else -> Log.d("onTranscriptionStateChanged", "Unknown transcription state: $status, ID: $id")
        }
    } catch (e: JSONException) {
        Log.e("onTranscriptionStateChanged", "Error parsing transcription state", e)
    }
  }

  override fun onTranscriptionText(data: TranscriptionText) {
    val participantId: String = data.participantId
    val participantName: String = data.participantName
    val text: String = data.text
    val timestamp: Int = data.timestamp
    val type: String = data.type

    Log.d("onTranscriptionText", "$participantName: $text $timestamp")
  }
}

override fun onCreate(savedInstanceState: Bundle?) {
  //...

  // add listener to meeting
  //highlight-next-line
  meeting!!.addEventListener(meetingEventListener)
}
```

</TabItem>

<TabItem value="Java">

```js
private final MeetingEventListener meetingEventListener = new MeetingEventListener() {
  @Override
    public void onTranscriptionStateChanged(JSONObject data) {
        try {
            String status = data.getString("status");
            String id = data.getString("id");

            if (TranscriptionState.TRANSCRIPTION_STARTING.name().equals(status)) {
                Log.d("onTranscriptionStateChanged", "Realtime Transcription is starting, ID: " + id);
            }
            else if (TranscriptionState.TRANSCRIPTION_STARTED.name().equals(status)) {
                Log.d("onTranscriptionStateChanged", "Realtime Transcription is started, ID: " + id);
            }
            else if (TranscriptionState.TRANSCRIPTION_STOPPING.name().equals(status)) {
                Log.d("onTranscriptionStateChanged", "Realtime Transcription is stopping, ID: " + id);
            }
            else if (TranscriptionState.TRANSCRIPTION_STOPPED.name().equals(status)) {
                Log.d("onTranscriptionStateChanged", "Realtime Transcription is stopped, ID: " + id);
            }
            else {
                Log.d("onTranscriptionStateChanged", "Unknown transcription state: " + status + ", ID: " + id);
            }
        } catch (JSONException e) {
            Log.e("onTranscriptionStateChanged", "Error parsing transcription state", e.getMessage());
        }
    }

    @Override
    public void onTranscriptionText(TranscriptionText data) {
        String participantId = data.getParticipantId();
        String participantName = data.getParticipantName();
        String text = data.getText();
        int timestamp = data.getTimestamp();
        String type = data.getType();

        Log.d("onTranscriptionText", participantName + ": " + text + " " + timestamp);
    }
}

@Override
protected void onCreate(Bundle savedInstanceState) {
  //...

  // add listener to meeting
  //highlight-next-line
  meeting.addEventListener(meetingEventListener);
}
```

</TabItem>

</Tabs>

### **Step 3: Start realtime transcription**

- Initiate the realtime transcription using the `startTranscription()` method.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
fun startRealtimeTranscription() {
    // Webhook URL where, webhooks are received
    val webhookUrl = "YOUR_WEBHOOK_URL"

    //highlight-next-line
    // Realtime Transcription Configuration
    val summaryConfig = SummaryConfig(
        true,
        "Write summary in sections like Title, Agenda, Speakers, Action Items, Outlines, Notes and Summary"
    )
    val transcription = TranscriptionConfig(
        webhookUrl,
        summaryConfig
    )

    //highlight-next-line
    meeting!!.startTranscription(transcription)
}
```

</TabItem>

<TabItem value="Java">

```js
private void startRealtimeTranscription() {
    // Webhook URL where, webhooks are received
    final String webhookUrl = "YOUR_WEBHOOK_URL";

    //highlight-next-line
    // Realtime Transcription Configuration
    SummaryConfig summaryConfig = new SummaryConfig(
        true,
        "Write summary in sections like Title, Agenda, Speakers, Action Items, Outlines, Notes and Summary"
    );
    TranscriptionConfig transcription = new TranscriptionConfig(
        webhookUrl,
        summaryConfig
    );

    //highlight-next-line
    meeting.startTranscription(transcription);
}
```

</TabItem>

</Tabs>

### **Step 4: Stop realtime transcription**

- Terminate the realtime transcription using the `stopTranscription() `method.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
fun stopRealtimeTranscription() {
    meeting!!.stopTranscription()
}
```

</TabItem>

<TabItem value="Java">

```js
private void stopRealtimeTranscription() {
    meeting.stopTranscription();
}
```

</TabItem>

</Tabs>

:::important

You can access a summary of your realtime transcription using the **[<u>Fetch Realtime Transcription API</u>](/api-reference/realtime-communication/fetch-a-realtime-transcription)**.

:::

### Example

- The following code snippet allows you to start and stop realtime transcription with just a click. When you click the "Start Realtime Transcription" button, it begins realtime transcription. Clicking the "Stop Realtime Transcription" button ends the realtime transcription.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
import android.os.Bundle
import android.util.Log
import android.widget.Button
import androidx.appcompat.app.AppCompatActivity
import org.json.JSONObject

class MeetingActivity : AppCompatActivity() {
    private lateinit var meeting: Meeting

    // add meetingEventListener to handle transcription events
    private val meetingEventListener = object : MeetingEventListener {
        override fun onTranscriptionStateChanged(data: JSONObject) {
            val status = data.getString("status")
            Log.d("MeetingActivity", "Transcription status: $status")
        }

        override fun onTranscriptionText(data: TranscriptionText) {
            val participantId = data.participantId
            val participantName = data.participantName
            val text = data.text
            val timestamp = data.timestamp
            val type = data.type

            Log.d("MeetingActivity", "$participantName: $text $timestamp")
        }
    }

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_meeting)

        //initialize a meeting
        //...

        val startButton: Button = findViewById(R.id.startTranscriptionButton)
        val stopButton: Button = findViewById(R.id.stopTranscriptionButton)

        startButton.setOnClickListener { startRealtimeTranscription() }
        stopButton.setOnClickListener { stopRealtimeTranscription() }

        // add listener to meeting
        meeting!!.setEventListener(meetingEventListener)
    }

    private fun startRealtimeTranscription() {
        // Configuration for realtime transcription
        val summaryConfig = SummaryConfig(
            true,
            "Write summary in sections like Title, Agenda, Speakers, Action Items, Outlines, Notes and Summary"
        )
        val transcriptionConfig = TranscriptionConfig(
            null,
            summaryConfig
        )

        // Call to start transcription with the specified configuration
        meeting!!.startTranscription(transcriptionConfig)
    }

    private fun stopRealtimeTranscription() {
        // Call to stop transcription
        meeting!!.stopTranscription()
    }
}
```

</TabItem>

<TabItem value="Java">

```js
import android.os.Bundle;
import android.util.Log;
import android.widget.Button;
import android.widget.Toast;
import androidx.appcompat.app.AppCompatActivity;

public class MeetingActivity extends AppCompatActivity {
    private Meeting meeting;

    // add meetingEventListener to handle transcription events
    private final MeetingEventListener meetingEventListener = new MeetingEventListener() {
        @Override
        public void onTranscriptionStateChanged(JSONObject data) {
            String status = data.getString("status");
            Log.d("MeetingActivity", "Transcription status: " + status);
        }

        @Override
        public void onTranscriptionText(TranscriptionText data) {
            String participantId = data.getParticipantId();
            String participantName = data.getParticipantName();
            String text = data.getText();
            int timestamp = data.getTimestamp();
            String type = data.getType();

            Log.d("MeetingActivity", participantName + ": " + text + " " + timestamp);
        }
    };

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_meeting);

        //initialize a meeting
        //...

        Button startButton = findViewById(R.id.startTranscriptionButton);
        Button stopButton = findViewById(R.id.stopTranscriptionButton);

        startButton.setOnClickListener(v -> startRealtimeTranscription());
        stopButton.setOnClickListener(v -> stopRealtimeTranscription());

        // add listener to meeting
        meeting.setEventListener(meetingEventListener);
    }

    private void startRealtimeTranscription() {
        // Configuration for realtime transcription
        SummaryConfig summaryConfig = new SummaryConfig(
            true,
            "Write summary in sections like Title, Agenda, Speakers, Action Items, Outlines, Notes and Summary"
        );
        TranscriptionConfig transcriptionConfig = new TranscriptionConfig(
            null,
            summaryConfig
        );

        // Call to start transcription with the specified configuration
        meeting.startTranscription(transcriptionConfig);
    }

    private void stopRealtimeTranscription() {
        // Call to stop transcription
        meeting.stopTranscription();
    }
}
```

</TabItem>

</Tabs>

### API Reference

The API references for all the methods utilized in this guide are provided below.

- [startTranscription()](/android/api/sdk-reference/meeting-class/methods#starttranscription)
- [stopTranscription()](/android/api/sdk-reference/meeting-class/methods#stoptranscription)
- [onTranscriptionStateChanged](/android/api/sdk-reference/meeting-class/meeting-event-listener-class#ontranscriptionstatechanged)
- [onTranscriptionText](/android/api/sdk-reference/meeting-class/meeting-event-listener-class#ontranscriptiontext)


---

---
title: Integrate Banuba SDK with Android SDK - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: Describes how to integrate Banuba SDK with videosdk.live using Android SDK to enhance video calls with real-time face filters and virtual backgrounds.
sidebar_label: "Banuba Integration"
pagination_label: "Banuba Integration"
keywords:
  - android sdk
  - java sdk
  - kotlin sdk
  - banuba
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: banuba-integration
---

# How to integrate Banuba SDK with Android Video SDK?

The Banuba SDK is a software development kit that enables developers to integrate advanced augmented reality (AR) features, such as real-time face filters and effects, into their apps. It is widely used for creating engaging video experiences in applications like video conferencing, live streaming, and social media platforms.

<center>
<img src='https://assets.videosdk.live/images/android-banuba.png' style={{height: '400px'}}/>
</center>

To integrate the Banuba SDK with Android Video SDK, follow these steps:

### Step 1: Get Banuba Token

- To begin working with the Banuba SDK in your project, you'll need Banuba's client token.
- You can obtain this token by following the instructions in Banuba's documentation at [banuba.com](https://www.banuba.com/)

### Step 2: Add Banuba SDK dependencies

- Add custom maven repo to your `settings.gradle`:

```js title="settings.gradle"
dependencyResolutionManagement {
    repositoriesMode.set(RepositoriesMode.FAIL_ON_PROJECT_REPOS)
    repositories {
        google()
        mavenCentral()
        maven {
            name = "GitHubPackages"
            url = uri("https://maven.pkg.github.com/sdk-banuba/banuba-sdk-android")
            credentials {
                username = "sdk-banuba"
                password = "\u0067\u0068\u0070\u005f\u004a\u0067\u0044\u0052\u0079\u0049\u0032\u006d\u0032\u004e\u0055\u0059\u006f\u0033\u0033\u006b\u0072\u0034\u0049\u0069\u0039\u0049\u006f\u006d\u0077\u0034\u0052\u0057\u0043\u0064\u0030\u0052\u0078\u006d\u0045\u0069"
            }
        }
        maven { url 'https://jitpack.io' }
        maven { url "https://maven.aliyun.com/repository/jcenter" }
}}
```

- Add Banuba SDK and VideoSDK dependencies in `app/build.gradle` file.

```js title="app/build.gradle"
dependencies {
  // Banuba SDK dependencies
    implementation "com.banuba.sdk:banuba_sdk:1+"
  // Video SDK dependencies
    implementation 'live.videosdk:rtc-android-sdk:0.1.38'
  // other app dependencies
  }
```
### Step 3: Initialization of Banuba SDK

1. Create a `MainApplication` class that extends `android.app.Application`.

2. Within the `MainApplication` class, create a KEY field to store the token you generated from Banuba. This token will be used to initialize the `BanubaSdkManager`.

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js title="MainApplication.kt"
class MainApplication : Application() {
    override fun onCreate() {
        super.onCreate()

        //...
        val key = "Banuba Client Token"
        BanubaSdkManager.initialize(requireNonNull(applicationContext), key)
    }

    override fun onTerminate() {
        BanubaSdkManager.deinitialize()
        super.onTerminate()
    }
}
```

</TabItem>

<TabItem value="Java">
  
```js title="MainApplication.java"
public class MainApplication extends Application {
    @Override
    public void onCreate() {
        super.onCreate();

        //...
        String KEY ="Banuba Client Token";
        BanubaSdkManager.initialize(requireNonNull(getApplicationContext()), KEY);
    }
    @Override
    public void onTerminate() {
        BanubaSdkManager.deinitialize();
        super.onTerminate();
    }
}
```

</TabItem>

</Tabs>

### Step 4: Add effects into your project

- Create an effects folder under the assets directory in your project and add the filters you want to use. You can download test filters from here [Effects](https://docs.banuba.com/face-ar-sdk-v1/overview/demo_face_filters)

<div style={{textAlign: 'center'}}>

![Banuba SDK effects folder](/img/android/banuba/banuba_effects.png)

</div>

### Step 5: Integration of BanubaProcessor

- The `BanubaProcessor` class will implement the `VideoFrameProcessor` interface from VideoSDK.
- The `VideoFrameProcessor` interface provides `onFrameCaptured()` method, which is invoked when a new video frame is captured.
- The `onFrameCaptured()` method is used to manipulate the `VideoFrame` in order to achieve the desired effects.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js title="BanubaProcessor.kt"
class BanubaProcessor : VideoFrameProcessor {
    private var mPlayer: Player = Player()
    private var mFrameOutput: FrameOutput? = null
    private val eglContext: EglBase.Context = EglBase.create().eglBaseContext
    private var mSurfaceTextureHelper: SurfaceTextureHelper? = null
    private var videoFrame: VideoFrame? = null
    private val streamInput: StreamInput = StreamInput()

    init {
        mSurfaceTextureHelper = SurfaceTextureHelper.create("CaptureThread", eglContext, false)
    }

    // set a visual effect in the Banuba Player
    fun setEffect(effect: String) {
        mPlayer.loadAsync("effects/$effect")
        mPlayer.play()
    }

    // remove any applied effects
    fun removeEffect() {
        mPlayer.loadAsync("")
    }

    fun removePlayer() {
        // close the player when it's no longer needed
        mPlayer.close()
    }

    // method to initialize the frame output for video processing
    private fun initOutput(): VideoFrame? {
        val handler = mSurfaceTextureHelper!!.handler
        mFrameOutput = FrameOutput { iOutput, framePixelBuffer ->
            handler.post {
                val i420Buffer = JavaI420Buffer.wrap(
                    framePixelBuffer.width,
                    framePixelBuffer.height,
                    framePixelBuffer.getPlane(0),
                    framePixelBuffer.getBytesPerRowOfPlane(0),
                    framePixelBuffer.getPlane(1),
                    framePixelBuffer.getBytesPerRowOfPlane(1),
                    framePixelBuffer.getPlane(2),
                    framePixelBuffer.getBytesPerRowOfPlane(2),
                    null
                )
                videoFrame = VideoFrame(i420Buffer, 0, System.nanoTime())
            }
        }
        mFrameOutput!!.format = FramePixelBufferFormat.I420_BT601_FULL

        handler.postDelayed({
            mFrameOutput?.close()
        }, 2000)

        // attach the FrameOutput to the player for rendering
        mPlayer.use(mFrameOutput)

        // Return the processed video frame
        return videoFrame
    }

     // called whenever a new video frame is captured
    override fun onFrameCaptured(videoFrame: VideoFrame?): VideoFrame? {
        if (videoFrame != null) {
            // Determine the camera orientation based on the rotation of the video frame
            val cameraOrientation = CameraOrientation.values()[(videoFrame.rotation / 90) % 4]
            val orientation = FullImageData.Orientation(cameraOrientation, true, 0)
            val i420Buffer = videoFrame.buffer.toI420()

            // create FullImageData using the frame data and orientation
            val fullImageData = FullImageData(
                Size(i420Buffer.width, i420Buffer.height),
                i420Buffer.dataY,
                i420Buffer.dataU,
                i420Buffer.dataV,
                i420Buffer.strideY,
                i420Buffer.strideU,
                i420Buffer.strideV,
                1, 1, 1,
                orientation
            )

            val frameData = FrameData.create() ?: return null
            frameData.addFullImg(fullImageData)
            i420Buffer.release()
            streamInput.push(frameData, videoFrame.timestampNs)

            // attach the StreamInput to the player for further processing
            mPlayer.use(streamInput)

            // return the processed video frame
            return initOutput()
        }
        return null
    }
}
```

</TabItem>

<TabItem value="Java">

```js title="BanubaProcessor.java"
public class BanubaProcessor implements VideoFrameProcessor {
    private Player mPlayer;
    private FrameOutput mFrameOutput;
    private final EglBase.Context eglContext = EglBase.create().getEglBaseContext();
    private SurfaceTextureHelper mSurfaceTextureHelper;
    VideoFrame videoFrame;
    final StreamInput streamInput = new StreamInput();

    public BanubaProcessor (){
        mSurfaceTextureHelper = SurfaceTextureHelper.create("CaptureThread", eglContext, false);
        mPlayer = new Player();
    }
    // set a visual effect in the Banuba Player
    public void setEffect(String effect)
    {
        mPlayer.loadAsync("effects/" + effect);
        mPlayer.play();
    }
    // remove any applied effects
    public void removeEffect()
    {
        mPlayer.loadAsync("");
    }
    public void removePlayer()
    {
        // close the player when it's no longer needed
        mPlayer.close();
    }
    // method to initialize the frame output for video processing
    private VideoFrame initOutput() {
        final Handler handler = mSurfaceTextureHelper.getHandler();
        mFrameOutput = new FrameOutput((iOutput, framePixelBuffer) -> {
            handler.post(() -> {

                final JavaI420Buffer i420buffer = JavaI420Buffer.wrap(
                        framePixelBuffer.getWidth(),
                        framePixelBuffer.getHeight(),
                        framePixelBuffer.getPlane(0),
                        framePixelBuffer.getBytesPerRowOfPlane(0),
                        framePixelBuffer.getPlane(1),
                        framePixelBuffer.getBytesPerRowOfPlane(1),
                        framePixelBuffer.getPlane(2),
                        framePixelBuffer.getBytesPerRowOfPlane(2),
                        null);
                videoFrame = new VideoFrame(i420buffer, 0, System.nanoTime());
            });
        });
        mFrameOutput.setFormat(FramePixelBufferFormat.I420_BT601_FULL);
        
        handler.postDelayed(() -> {
            mFrameOutput.close();
        },2000);

        // attach the FrameOutput to the player for rendering
        mPlayer.use(mFrameOutput);

        // return the processed video frame
        return videoFrame;
    }
    // called whenever a new video frame is captured
    @Override
    public VideoFrame onFrameCaptured(VideoFrame videoFrame) {
        if(videoFrame != null) {
            // determine the camera orientation based on the rotation of the video frame
            final CameraOrientation cameraOrientation = CameraOrientation.values()[(videoFrame.getRotation() / 90) % 4];
            final FullImageData.Orientation orientation = new FullImageData.Orientation(cameraOrientation, true, 0);
            final VideoFrame.I420Buffer i420Buffer = videoFrame.getBuffer().toI420();
            // create FullImageData using the frame data and orientation
            final FullImageData fullImageData = new FullImageData(
                    new Size(i420Buffer.getWidth(), i420Buffer.getHeight()),
                    i420Buffer.getDataY(),
                    i420Buffer.getDataU(),
                    i420Buffer.getDataV(),
                    i420Buffer.getStrideY(),
                    i420Buffer.getStrideU(),
                    i420Buffer.getStrideV(),
                    1, 1, 1,
                    orientation);
            final FrameData frameData = Objects.requireNonNull(FrameData.create());
            frameData.addFullImg(fullImageData);
            i420Buffer.release();
            streamInput.push(frameData, videoFrame.getTimestampNs());
            // attach the StreamInput to the player for further processing
            mPlayer.use(streamInput);
            // return the processed video frame
            return initOutput();
        }
        return null;
    }
}
```

</TabItem>

</Tabs>

### Step 5: Use filters in the Meeting

- First, create an instance of `BanubaProcessor` class and pass it to the `applyVideoProcessor()` method of `VideoSDK` class.
- Next, use the `setEffect` method on the instance of `BanubaProcessor` class apply the desired effect.
- To apply video filters from the beginning of the meeting, you can call `setEffect` method in `onMeetingJoined` event.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">


```js title="MainActivity.kt"
private val meetingEventListener = object : MeetingEventListener {
    override fun onMeetingJoined() {
        val banubaProcessor = BanubaProcessor()
        VideoSDK.applyVideoProcessor(banubaProcessor)
        //here you can pass any effect that you want to apply
        banubaProcessor.setEffect("PineappleGlasses")
    }
}
```

</TabItem>

<TabItem value="Java">

```js title="MainActivity.java"
private final MeetingEventListener meetingEventListener = new MeetingEventListener() {
    @Override
    public void onMeetingJoined() {
        BanubaProcessor banubaProcessor = new BanubaProcessor();
        VideoSDK.applyVideoProcessor(banubaProcessor);
        //here you can pass any effect that you want to apply
        banubaProcessor.setEffect("PineappleGlasses");
    }
};
```

</TabItem>

</Tabs>

:::tip

Stuck anywhere? Check out this [Code Sample of Banuba Intergation with Android-SDK](https://github.com/videosdk-live/videosdk-rtc-android-sdk-banuba-example.git) on GitHub

:::


---

---
sidebar_label: Overview
pagination_label: Overview
---

# Video Processor - Android

VideoSDK allows you to add custom effects to your video stream before it's transmitted during video calls. This lets you enhance your video in creative ways or achieve specific functionalities.

### Understanding Video Processing

Video processing involves manipulating raw video data (frames) captured by your camera. You can create native processors to enhance video streams during meetings.


### The `VideoFrameProcessor` Interface

The `VideoFrameProcessor` interface defines a way for your code to interact with the video stream. It essentially lets you intercept each frame before it's sent and apply your processing logic.

#### Key Function: `onFrameCaptured`

This is the heart of video processing with VideoSDK. Whenever a new video frame is captured by your camera, the `onFrameCaptured` function is called. This function provides you with the raw frame data, allowing you to modify it as needed.

### How it Works:

1. **Implement the Interface:** Create a class that implements the `VideoFrameProcessor` interface. Within this class, define the `onFrameCaptured` function.

2. **Process the Frame:** In the `onFrameCaptured` function, access the raw video frame data. Apply your desired effects or manipulations to this data.

3. **Return the Processed Frame:** After processing the frame, return the modified version to VideoSDK. This processed frame will then be transmitted during the video call.

4. **Apply the Processor:** To apply a processor, pass an object of your class as a parameter to the `applyVideoProcessor()` method of the `VideoSDK` class.

5. **Remove the Processor:** To stop applying the selected video processor, use the `removeVideoProcessor()` method of the `VideoSDK` class.

## API Reference

The API references for all the methods utilized in this guide are provided below.

- [applyVideoProcessor()](/android/api/sdk-reference/videosdk-class/methods#applyvideoprocessor)
- [removeVideoProcessor()](/android/api/sdk-reference/videosdk-class/methods#removevideoprocessor)


---

---
sidebar_position: 2
sidebar_label: Meeting Error Codes
pagination_label: Meeting Error Codes
title: Meeting Error Codes
---

# Meeting Error Codes - Android

import ErrorCodesTable from "../../../../src/theme/ErrorCodesTable"
import meetingErrorCodes from "./data/meetingErrorCodes.json"
import NoIndex from '../../../../mdx/\_no-index.mdx';

<NoIndex/>

<ErrorCodesTable errorCodes={meetingErrorCodes} />


---

---
sidebar_position: 2
sidebar_label: Initializing a Meeting
pagination_label: Initializing a Meeting
title: Initializing a Meeting
---

import NoIndex from '../../../../mdx/\_no-index.mdx';

<NoIndex/>

# Initializing a Meeting - Android

<div class="sdk-api-ref">

## initialize()

To initialize the meeting, first you have to initialize the `VideoSDK`.
You can initialize the `VideoSDK` using `initialize()` method provided by the SDK.

#### Parameters

- **context**: Context

#### Returns

- _`void`_

```js title="initialize"
  VideoSDK.initialize(Context context)
```

---

## config()

Now, you have to set `token` property of `VideoSDK` class.
By using `config()` method, you can set the `token` property of `VideoSDK` class.

Please refer this [documentation](/api-reference/realtime-communication/intro/) to generate a token.

#### Parameters

- **token**: String

#### Returns

- _`void`_

```js title="config"
 VideoSDK.config(String token)
```

---

## initMeeting()

- Now, you can initialize the meeting using a factory method provided by the SDK called `initMeeting()`.
- `initMeeting()` will generate a new [`Meeting`](./meeting-class/introduction.md) class and the initiated meeting will be returned.

```js title="initMeeting"
   VideoSDK.initMeeting(
        Context context,
        String meetingId,
        String name,
        boolean micEnabled,
        boolean webcamEnabled,
        boolean multiStream,
        String participantId,
        Map<String, CustomStreamTrack> customTracks
      )
```

## Parameters

### context

- Context of activity.

  - type : Context
  - `REQUIRED`

### meetingId

- Unique Id of the meeting where that participant will be joining.

  - type : `String`
  - `REQUIRED`

Please refer this [documentation](/api-reference/realtime-communication/create-room) to create a room.

### name

- Name of the participant who will be joining the meeting, this name will be displayed to other participants in the same meeting.

  - type : String
  - `REQUIRED`

### micEnabled

- Whether `mic` of the participant will be on while joining the meeting. If it is set to `false`, then mic of that participant will be `disabled` by default, but can be `enabled` or `disabled` later.

  - type: `Boolean`
  - `REQUIRED`

### webcamEnabled

- Whether `webcam` of the participant will be on while joining the meeting. If it is set to `false`, then webcam of that participant will be `disabled` by default, but can be `enabled` or `disabled` later.

  - type: `Boolean`
  - `REQUIRED`

### multiStream

- It will specify if the stream should send multiple resolution layers or single resolution layer.

  - type: `boolean`
  - `REQUIRED`

### participantId

- Unique Id of the participant. If you passed `null` then SDK will create an Id by itself and will use that id.

  - type : `String` or `null`
  - `REQUIRED`

### customTracks

- If you want to use custom tracks from start of the meeting, you can pass map of custom tracks in this paramater.

  - type : `Map<String, CustomStreamTrack>` or `null`
  - `REQUIRED`

Please refer this [documentation](../../guide/video-and-audio-calling-api-sdk/features/custom-track/custom-video-track) to know more about CustomTrack.

## Returns

### meeting

- After initializing the meeting, `initMeeting()` will return a new [`Meeting`](./meeting-class/introduction.md) instance.

---

## Example

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js title="initMeeting"

VideoSDK.initialize(applicationContext)

// Configure the token
VideoSDK.config(token) // pass the token generated from VideoSDK Dashboard

// Initialize the meeting
var meeting = VideoSDK.initMeeting(
  arrayOf(
    this@MainActivity,
    "abc-1234-xyz",
    "John Doe",
    true,
    true,
    false,
    null,
    null
  )
)
```

</TabItem>

<TabItem value="Java">

```js title="initMeeting"

VideoSDK.initialize(getApplicationContext());

// Configure the token
VideoSDK.config(token);  // pass the token generated from VideoSDK Dashboard

// Initialize the meeting
Meeting meeting = VideoSDK.initMeeting({
  MainActivity.this,
  "abc-1234-xyz",
  "John Doe",
  true,
  true,
  false,
  null,
  null
});
```

</TabItem>

</Tabs>

</div>


---

---
sidebar_position: 1
sidebar_label: Introduction
pagination_label: Intro to Video SDK Meeting Class
title: Video SDK Meeting Class
---

import NoIndex from '../../../../../mdx/\_no-index.mdx';

<NoIndex/>

# Video SDK Meeting Class - React Native

<div class="sdk-api-ref">

## Introduction

The `Meeting` class includes properties, methods and meeting-event-listener-class for managing a meeting, participants, video, audio and share streams, messaging and UI customization.

import LinksGrid from "../../../../../src/theme/LinksGrid";
import properties from "./../data/meeting-class/properties.json";
import methods from "./../data/meeting-class/methods.json";
import events from "./../data/meeting-class/events.json";

## Meeting Properties

<div class="row">

<div class="col col--4 margin-bottom--sm" >

- [getmeetingId()](/android/0.0.x/api/sdk-reference/meeting-class/properties#getmeetingid)

</div>
<div class="col col--4 margin-bottom--sm" >

- [getLocalParticipant()](./properties#getlocalparticipant)

</div>
<div class="col col--4 margin-bottom--sm" >

- [getParticipants()](./properties#getparticipants)

</div>
<div class="col col--4 margin-bottom--sm" >

- [pubSub](./properties#pubsub)

</div>

</div>

## Meeting Methods

<div class="row">

<div class="col col--4 margin-bottom--sm" >

- [join()](./methods#join)

</div>
<div class="col col--4 margin-bottom--sm" >

- [leave()](./methods#leave)

</div>
<div class="col col--4 margin-bottom--sm" >

- [end()](./methods#end)

</div>
<div class="col col--4 margin-bottom--sm" >

- [enableWebcam()](./methods#enablewebcam)

</div>
<div class="col col--4 margin-bottom--sm" >

- [disableWebcam()](./methods#disablewebcam)

</div>
<div class="col col--4 margin-bottom--sm" >

- [unmuteMic()](./methods#unmutemic)

</div>
<div class="col col--4 margin-bottom--sm" >

- [muteMic()](./methods#mutemic)

</div>
<div class="col col--4 margin-bottom--sm" >

- [enableScreenShare()](./methods#enablescreenshare)

</div>
<div class="col col--4 margin-bottom--sm" >

- [disableScreenShare()](./methods#disablescreenshare)

</div>
<div class="col col--4 margin-bottom--sm" >

- [startRecording()](./methods#startrecording)

</div>
<div class="col col--4 margin-bottom--sm" >

- [stopRecording()](./methods#stoprecording)

</div>
<div class="col col--4 margin-bottom--sm" >

- [startLiveStream()](./methods#startlivestream)

</div>
<div class="col col--4 margin-bottom--sm" >

- [stopLiveStream()](./methods#stoplivestream)

</div>
<div class="col col--4 margin-bottom--sm" >

- [getMics()](./methods#getmics)

</div>
<div class="col col--4 margin-bottom--sm" >

- [changeMic()](./methods#changemic)

</div>
<div class="col col--4 margin-bottom--sm" >

- [setAudioDeviceChangeListener()](./methods#setaudiodevicechangelistener)

</div>
<div class="col col--4 margin-bottom--sm" >

- [changeWebcam()](./methods#changewebcam)

</div>
<div class="col col--4 margin-bottom--sm" >

- [addEventListener()](./methods#addeventlistener)

</div>
<div class="col col--4 margin-bottom--sm" >

- [removeEventListener()](./methods#removeeventlistener)

</div>
<div class="col col--4 margin-bottom--sm" >

- [removeAllListeners()](./methods#removealllisteners)

</div>

</div>

## Meeting Events

<div class="row">

<div class="col col--4 margin-bottom--sm" >

- [onMeetingJoined](./meeting-event-listener-class#onmeetingjoined)

</div>
<div class="col col--4 margin-bottom--sm" >

- [onMeetingLeft](./meeting-event-listener-class#onmeetingleft)

</div>
<div class="col col--4 margin-bottom--sm" >

- [onParticipantJoined](./meeting-event-listener-class#onparticipantjoined)

</div>
<div class="col col--4 margin-bottom--sm" >

- [onParticipantLeft](./meeting-event-listener-class#onparticipantleft)

</div>
<div class="col col--4 margin-bottom--sm" >

- [onSpeakerChanged](./meeting-event-listener-class#onspeakerchanged)

</div>
<div class="col col--4 margin-bottom--sm" >

- [onPresenterChanged](./meeting-event-listener-class#onpresenterchanged)

</div>
<div class="col col--4 margin-bottom--sm" >

- [onEntryRequested](./meeting-event-listener-class#onentryrequested)

</div>
<div class="col col--4 margin-bottom--sm" >

- [onEntryResponded](./meeting-event-listener-class#onentryresponded)

</div>
<div class="col col--4 margin-bottom--sm" >

- [onWebcamRequested](./meeting-event-listener-class#onwebcamrequested)

</div>
<div class="col col--4 margin-bottom--sm" >

- [onMicRequested](./meeting-event-listener-class#onmicrequested)

</div>
<div class="col col--4 margin-bottom--sm" >

- [onRecordingStarted](./meeting-event-listener-class#onrecordingstarted)

</div>
<div class="col col--4 margin-bottom--sm" >

- [onRecordingStopped](./meeting-event-listener-class#onrecordingstopped)

</div>
<div class="col col--4 margin-bottom--sm" >

- [onLivestreamStarted](./meeting-event-listener-class#onlivestreamstarted)

</div>
<div class="col col--4 margin-bottom--sm" >

- [onLivestreamStopped](./meeting-event-listener-class#onlivestreamstopped)

</div>
<div class="col col--4 margin-bottom--sm" >

- [onExternalCallStarted](./meeting-event-listener-class#onexternalcallstarted)

</div>

</div>

</div>


---

---
sidebar_position: 1
sidebar_label: MeetingEventListener Class
pagination_label: MeetingEventListener Class
title: MeetingEventListener Class
---

import NoIndex from '../../../../../mdx/\_no-index.mdx';

<NoIndex/>

# MeetingEventListener Class - React Native

<div class="sdk-api-ref-only-h4">

---

### implementation

- You can implement all the methods of `MeetingEventListener` abstract Class and add the listener to `Meeting` class using the `addEventListener()` method of `Meeting` Class.

#### Example

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
private final MeetingEventListener meetingEventListener = new MeetingEventListener() {
  override fun onMeetingJoined() {
    Log.d("#meeting", "onMeetingJoined()")
  }
}
```

</TabItem>

<TabItem value="Java">

```javascript
private final MeetingEventListener meetingEventListener = new MeetingEventListener() {
  @Override
  public void onMeetingJoined() {
    Log.d("#meeting", "onMeetingJoined()");
  }
}
```

</TabItem>

</Tabs>

---

### onMeetingJoined()

- This event will be emitted when a [localParticipant](./properties#getlocalparticipant) successfully joined the meeting.

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
 override fun onMeetingJoined() {
    Log.d("#meeting", "onMeetingJoined()")
 }
```

</TabItem>

<TabItem value="Java">

```javascript
 @Override
 public void onMeetingJoined() {
     Log.d("#meeting", "onMeetingJoined()");
 }
```

</TabItem>

</Tabs>

---

### onMeetingLeft()

- This event will be emitted when a [localParticipant](./properties#getlocalparticipant) left the meeting.

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
 override fun onMeetingLeft() {
    Log.d("#meeting", "onMeetingLeft()")
 }
```

</TabItem>

<TabItem value="Java">

```javascript
 @Override
 public void onMeetingLeft() {
    Log.d("#meeting", "onMeetingLeft()");
 }
```

</TabItem>

</Tabs>

---

### onParticipantJoined()

- This event will be emitted when a new [participant](../participant-class/introduction) joined the meeting.

#### Event callback parameters

- **participant**: [Participant](../participant-class/introduction)

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
 override fun onParticipantJoined(participant: Participant) {
    Log.d("#meeting", participant.displayName + " joined");
 }
```

</TabItem>

<TabItem value="Java">

```javascript
 @Override
 public void onParticipantJoined(Participant participant) {
    Log.d("#meeting", participant.getDisplayName() + " joined");
 }
```

</TabItem>

</Tabs>

---

### onParticipantLeft

- This event will be emitted when a joined [participant](../participant-class/introduction) left the meeting.

#### Event callback parameters

- **participant**: [Participant](../participant-class/introduction)

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
 override fun onParticipantLeft(participant: Participant) {
    Log.d("#meeting", participant.displayName + " left");
 }
```

</TabItem>

<TabItem value="Java">

```javascript
 @Override
 public void onParticipantLeft(Participant participant) {
    Log.d("#meeting", participant.getDisplayName() + " left");
 }
```

</TabItem>

</Tabs>

---

### onSpeakerChanged()

- This event will be emitted when a active speaker changed.
- If you want to know which participant is actively speaking, then this event will be used.
- If no participant is actively speaking, then this event will pass `null` as en event callback parameter.

#### Event callback parameters

- **participantId**: String

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
 override fun onSpeakerChanged(participantId: String?) {
  //
 }
```

</TabItem>

<TabItem value="Java">

```javascript
 @Override
 public void onSpeakerChanged(String participantId) {
  //
 }
```

</TabItem>

</Tabs>

---

### onPresenterChanged()

- This event will be emitted when any [participant](../participant-class/introduction) starts or stops screen sharing.
- It will pass `participantId` as an event callback parameter.
- If a participant stops screensharing, then this event will pass `null` as en event callback parameter.

#### Event callback parameters

- **participantId**: String

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
 override fun onPresenterChanged(participantId: String) {
  //
 }
```

</TabItem>

<TabItem value="Java">

```javascript
 @Override
 public void onPresenterChanged(String participantId) {
  //
 }
```

</TabItem>

</Tabs>

---

### onEntryRequested()

- This event will be emitted when a new [participant](../participant-class/introduction) who is trying to join the meeting, is having permission **`ask_join`** in token.
- This event will only be emitted to the [participants](./properties#getparticipants) in the meeting, who is having the permission **`allow_join`** in token.
- This event will pass following parameters as an event parameters, `participantId` and `name` of the new participant who is trying to join the meeting, `allow()` and `deny()` to take required actions.

#### Event callback parameters

- **peerId**: String
- **name**: String

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
 override fun onEntryRequested(id: String?, name: String?) {
    //
}
```

</TabItem>

<TabItem value="Java">

```javascript
 @Override
 public void onEntryRequested(String id, String name) {
    //
}
```

</TabItem>

</Tabs>

---

### onEntryResponded()

- This event will be emitted when the `join()` request is responded.
- This event will be emitted to the [participants](./properties#getparticipants) in the meeting, who is having the permission **`allow_join`** in token.
- This event will be also emitted to the [participant](../participant-class/introduction) who requested to join the meeting.

#### Event callback parameters

- **participantId**: _String_
- **decision**: _"allowed"_ | _"denied"_

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
 override fun onEntryResponded(id: String?, decision: String?) {
    //
  }
```

</TabItem>

<TabItem value="Java">

```javascript
 @Override
 public void onEntryResponded(String id, String decision) {
    //
  }
```

</TabItem>

</Tabs>

---

### onWebcamRequested()

- This event will be emitted to the participant `B` when any other participant `A` requests to enable webcam of participant `B`.
- On accepting the request, webcam of participant `B` will be enabled.

#### Event callback parameters

- **participantId**: String
- **listener**: WebcamRequestListener \{ **accept**: Method; **reject**: Method }

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
  override fun onWebcamRequested(participantId: String, listener: WebcamRequestListener) {
     // if accept request
     listener.accept()

     // if reject request
     listener.reject()
 }
```

</TabItem>

<TabItem value="Java">

```javascript
  @Override
 public void onWebcamRequested(String participantId, WebcamRequestListener listener) {
     // if accept request
     listener.accept();

     // if reject request
     listener.reject();
 }
```

</TabItem>

</Tabs>

### onMicRequested()

- This event will be emitted to the participant `B` when any other participant `A` requests to enable mic of participant `B`.
- On accepting the request, mic of participant `B` will be enabled.

#### Event callback parameters

- **participantId**: String
- **listener**: MicRequestListener \{ **accept**: Method; **reject**: Method }

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
 override fun onMicRequested(participantId: String, listener: MicRequestListener) {
     // if accept request
     listener.accept()

     // if reject request
     listener.reject()
 }
```

</TabItem>

<TabItem value="Java">

```javascript
 @Override
 public void onMicRequested(String participantId, MicRequestListener listener) {
     // if accept request
     listener.accept();

     // if reject request
     listener.reject();
 }
```

</TabItem>

</Tabs>

---

### onRecordingStarted()

- This event will be emitted when recording of the meeting is started.

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
 override fun onRecordingStarted() {
   //
 }
```

</TabItem>

<TabItem value="Java">

```javascript
 @Override
 public void onRecordingStarted() {
   //
 }
```

</TabItem>

</Tabs>

---

### onRecordingStopped()

- This event will be emitted when recording of the meeting is stopped.

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
 override fun onRecordingStopped() {
   //
 }
```

</TabItem>

<TabItem value="Java">

```javascript
 @Override
 public void onRecordingStopped() {
   //
 }
```

</TabItem>

</Tabs>

---

### onLivestreamStarted()

- This event will be emitted when `RTMP` live stream of the meeting is started.

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
 override fun onLivestreamStarted() {
   //
 }
```

</TabItem>

<TabItem value="Java">

```javascript
 @Override
 public void onLivestreamStarted() {
   //
 }
```

</TabItem>

</Tabs>

---

### onLivestreamStopped()

- This event will be emitted when `RTMP` live stream of the meeting is stopped.

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
 override fun onLivestreamStopped() {
   //
 }
```

</TabItem>

<TabItem value="Java">

```javascript
 @Override
 public void onLivestreamStopped() {
   //
 }
```

</TabItem>

</Tabs>

---

### onExternalCallStarted()

- This event will be emitted when local particpant receive incoming call.

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
 override fun onExternalCallStarted() {
   //
 }
```

</TabItem>

<TabItem value="Java">

```javascript
 @Override
 public void onExternalCallStarted() {
   //
 }
```

</TabItem>

</Tabs>

---

### onMeetingStateChanged()

- This event will be emitted when state of meeting changes.
- It will pass **`state`** as an event callback parameter which will indicate current state of the meeting.
- All available states are `CONNECTING`, `CONNECTED`, `FAILED`, `DISCONNECTED`, `CLOSING`, `CLOSED`.

#### Event callback parameters

- **state**: String

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
 override fun onMeetingStateChanged(state: String?) {
    when (state) {
      "CONNECTING" -> Log.d("onMeetingStateChanged: ", "Meeting is Connecting")
      "CONNECTED" -> Log.d("onMeetingStateChanged: ", "Meeting is Connected")
      "FAILED" -> Log.d("onMeetingStateChanged: ", "Meeting connection failed")
      "DISCONNECTED" -> Log.d("onMeetingStateChanged: ","Meeting connection disconnected abruptly")
      "CLOSING" -> Log.d("onMeetingStateChanged: ", "Meeting is closing")
      "CLOSED" -> Log.d("onMeetingStateChanged: ", "Meeting connection closed")
    }
  }
```

</TabItem>

<TabItem value="Java">

```javascript
@Override
  public void onMeetingStateChanged(String state) {
    switch (state) {
        case "CONNECTING":
          Log.d("onMeetingStateChanged: ", "Meeting is Connecting");
          break;
        case "CONNECTED":
          Log.d("onMeetingStateChanged: ", "Meeting is Connected");
          break;
        case "FAILED":
          Log.d("onMeetingStateChanged: ", "Meeting connection failed");
          break;
        case "DISCONNECTED":
          Log.d("onMeetingStateChanged: ", "Meeting connection disconnected abruptly");
          break;
        case "CLOSING":
          Log.d("onMeetingStateChanged: ", "Meeting is closing");
          break;
        case "CLOSED":
          Log.d("onMeetingStateChanged: ", "Meeting connection closed");
          break;
    }
  }

```

</TabItem>

</Tabs>

---

</div>


---

---
sidebar_position: 1
sidebar_label: Methods
pagination_label: Meeting Class Methods
title: Meeting Class Methods
---

import NoIndex from '../../../../../mdx/\_no-index.mdx';

<NoIndex/>

# Meeting Class Methods - React Native

<div class="sdk-api-ref-only-h4">

### join()

- It is used to join a meeting.
- After meeting initialization by [`initMeeting()`](../initMeeting) it returns a new instance of [Meeting](./introduction). However by default, it will not automatically join the meeting. Hence, to join the meeting you should call `join()`.

#### Events associated with `join()`:

- Local Participant will receive a [`onMeetingJoined`](./meeting-event-listener-class#onmeetingjoined) event, when successfully joined.
- Remote Participant will receive a [`onParticipantJoined`](./meeting-event-listener-class#onparticipantjoined) event with the newly joined [`Participant`](../participant-class/introduction) object from the event callback.

#### Participant having `ask_join` permission inside token

- If a token contains the permission `ask_join`, then the participant will not join the meeting directly after calling `join()`, but an event will be emitted to the participant having the permission `allow_join` called [`onEntryRequested`](./meeting-event-listener-class#onentryrequested).

- After the decision from the remote participant, an event will be emitted to participant called [`onEntryResponded`](./meeting-event-listener-class#onentryresponded). This event will contain the decision made by the remote participant.

#### Participant having `allow_join` permission inside token

- If a token containing the permission `allow_join`, then the participant will join the meeting directly after calling `join()`.

#### Returns

- _`void`_

---

### leave()

- It is used to leave the current meeting.

#### Events associated with `leave()`:

- Local participant will receive a [`onMeetingLeft`](./meeting-event-listener-class#onmeetingleft) event.
- All remote participants will receive a [`onParticipantLeft`](./meeting-event-listener-class#onparticipantleft) event with `participantId`.

#### Returns

- _`void`_

---

### end()

- It is used to end the current running session.
- By calling `end()`, all joined [participants](properties#getparticipants) including [localParticipant](./properties.md#getlocalparticipant) of that session will leave the meeting.

#### Events associated with `end()`:

- All [participants](./properties.md#getparticipants) and [localParticipant](./properties.md#getlocalparticipant), will be emitted [`onMeetingLeft`](./meeting-event-listener-class#onmeetingleft) event.

#### Returns

- _`void`_

---

### enableWebcam()

- It is used to enable self camera.
- [`onStreamEnabled`](../participant-class/participant-event-listener-class#onstreamenabled) event of `ParticipantEventListener` will be emitted with [`stream`](../stream-class/introduction) object from the event callback.

#### Returns

- _`void`_

---

### disableWebcam()

- It is used to disable self camera.
- [`onStreamDisabled`](../participant-class/participant-event-listener-class#onstreamdisabled) event of `ParticipantEventListener` will be emitted with [`stream`](../stream-class/introduction) object from the event callback.

#### Returns

- _`void`_

---

### unmuteMic()

- It is used to enable self microphone.
- [`onStreamEnabled`](../participant-class/participant-event-listener-class#onstreamenabled) event of `ParticipantEventListener` will be emitted with [`stream`](../stream-class/introduction) object from the event callback.

#### Returns

- _`void`_

---

### muteMic()

- It is used to disable self microphone.
- [`onStreamDisabled`](../participant-class/participant-event-listener-class#onstreamdisabled) event of `ParticipantEventListener` will be emitted with [`stream`](../stream-class/introduction) object from the event callback.

#### Returns

- _`void`_

---

### enableScreenShare()

- it is used to enable screen-sharing.

- [`onStreamEnabled`](../participant-class/participant-event-listener-class#onstreamenabled) event of `ParticipantEventListener` will be emitted with [`stream`](../stream-class/introduction) object from the event callback.

- [`onPresenterChanged()`](./meeting-event-listener-class#onpresenterchanged) event will be trigget to all participant with `participantId`.

#### Parameters

- **data**: Intent

#### Returns

- _`void`_

---

### disableScreenShare()

- It is used to disable screen-sharing.

- [`onStreamDisabled`](../participant-class/participant-event-listener-class#onstreamdisabled) event of `ParticipantEventListener` will be emitted with [`stream`](../stream-class/introduction) object from the event callback.

- [`onPresenterChanged()`](./meeting-event-listener-class#onpresenterchanged) event will be trigget to all participant with `null`.

#### Returns

- _`void`_

---

### startRecording()

- It is used to start meeting recording.
- All [participants](./properties.md#getparticipants) and [localParticipant](./properties.md#getlocalparticipant), will receive `onRecordingStarted` event.

- `webhookUrl` will be triggered when the recording is completed and stored into server. Read more about webhooks [here](https://en.wikipedia.org/wiki/Webhook).

#### Parameters

- **webhookUrl**: String

#### Returns

- _`void`_

#### Example

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
val webhookUrl = "https://webhook.your-api-server.com"

meeting!!.startRecording(webhookUrl)
```

</TabItem>

<TabItem value="Java">

```js
String webhookUrl = "https://webhook.your-api-server.com";

meeting.startRecording(webhookUrl);
```

</TabItem>

</Tabs>

---

### stopRecording()

- It is used to stop meeting recording.
- All [participants](./properties.md#getparticipants) and [localParticipant](./properties.md#getlocalparticipant), will receive `onRecordingStopped` event.

#### Returns

- _`void`_

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
meeting!!.stopRecording()
```

</TabItem>

<TabItem value="Java">

```javascript
meeting.stopRecording();
```

</TabItem>

</Tabs>

---

### startLivestream()

- It is used to start meeting livestreaming.
- You will be able to start live stream meetings to other platforms such as Youtube, Facebook, etc. that support `RTMP` streaming.
- All [participants](./properties.md#getparticipants) and [localParticipant](./properties.md#getlocalparticipant), will receive [`onLivestreamStarted`](./meeting-event-listener-class#onlivestreamstarted) event.

#### Parameters

- **outputs**: `List<LivestreamOutput>`

#### Returns

- _`void`_

---

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
val YOUTUBE_RTMP_URL = "rtmp://a.rtmp.youtube.com/live2"
val YOUTUBE_RTMP_STREAM_KEY = "<STREAM_KEY>"

val outputs: MutableList<LivestreamOutput> = ArrayList()
outputs.add(LivestreamOutput(YOUTUBE_RTMP_URL, YOUTUBE_RTMP_STREAM_KEY))

meeting!!.startLivestream(outputs)
```

</TabItem>

<TabItem value="Java">

```javascript
final String YOUTUBE_RTMP_URL = "rtmp://a.rtmp.youtube.com/live2";
final String YOUTUBE_RTMP_STREAM_KEY = "<STREAM_KEY>";

List<LivestreamOutput> outputs = new ArrayList<>();
outputs.add(new LivestreamOutput(YOUTUBE_RTMP_URL, YOUTUBE_RTMP_STREAM_KEY));

meeting.startLivestream(outputs);
```

</TabItem>

</Tabs>

### stopLivestream()

- It is used to stop meeting livestreaming.
- All [participants](./properties.md#getparticipants) and [localParticipant](./properties.md#getlocalparticipant), will receive [`onLivestreamStopped`](./meeting-event-listener-class#onlivestreamstopped) event.

#### Returns

- _`void`_

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
meeting!!.stopLivestream()
```

</TabItem>

<TabItem value="Java">

```javascript
meeting.stopLivestream();
```

</TabItem>

</Tabs>

---

### getMics()

- It will return all connected mic devices.

#### Returns

- `Set<AppRTCAudioManager.AudioDevice>`

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
val mics = meeting!!.mics
var mic: String
for (i in mics.indices) {
  mic = mics.toTypedArray()[i].toString()
  Toast.makeText(this, "Mic : $mic", Toast.LENGTH_SHORT).show()
}
```

</TabItem>

<TabItem value="Java">

```javascript
Set<AppRTCAudioManager.AudioDevice> mics = meeting.getMics();
String mic;
for (int i = 0; i < mics.size(); i++) {
    mic=mics.toArray()[i].toString();
    Toast.makeText(this, "Mic : " + mic, Toast.LENGTH_SHORT).show();
}
```

</TabItem>

</Tabs>

---

### changeMic()

- It is used to change the mic device.
- If multiple mic devices are connected, by using `changeMic()` one can change the mic device.

#### Parameters

- **device**: AppRTCAudioManager.AudioDevice

#### Returns

- _`void`_

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
meeting!!.changeMic(AppRTCAudioManager.AudioDevice.BLUETOOTH)
```

</TabItem>

<TabItem value="Java">

```javascript
meeting.changeMic(AppRTCAudioManager.AudioDevice.BLUETOOTH);
```

</TabItem>

</Tabs>

---

### changeWebcam()

- It is used to change the camera mode.

#### Returns

- _`void`_

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
meeting!!.changeWebcam()
```

</TabItem>

<TabItem value="Java">

```javascript
meeting.changeWebcam();
```

</TabItem>

</Tabs>

---

### setAudioDeviceChangeListener()

- When a Local participant changes the Mic, `AppRTCAudioManager.AudioManagerEvents()` is triggered which can be set by using `setAudioDeviceChangeListener()` method.

#### Parameters

- **audioManagerEvents**: AppRTCAudioManager.AudioManagerEvents

#### Returns

- _`void`_

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
    meeting!!.setAudioDeviceChangeListener(object : AudioManagerEvents {
      override fun onAudioDeviceChanged(
        selectedAudioDevice: AppRTCAudioManager.AudioDevice,
        availableAudioDevices: Set<AppRTCAudioManager.AudioDevice>
      ) {
          when (selectedAudioDevice) {
            AppRTCAudioManager.AudioDevice.BLUETOOTH ->
              Toast.makeText(this@MainActivity, "Selected AudioDevice: BLUETOOTH", Toast.LENGTH_SHORT).show()

            AppRTCAudioManager.AudioDevice.WIRED_HEADSET ->
              Toast.makeText(this@MainActivity, "Selected AudioDevice: WIRED_HEADSET", Toast.LENGTH_SHORT).show()

            AppRTCAudioManager.AudioDevice.SPEAKER_PHONE ->
              Toast.makeText(this@MainActivity, "Selected AudioDevice: SPEAKER_PHONE", Toast.LENGTH_SHORT).show()

            AppRTCAudioManager.AudioDevice.EARPIECE ->
              Toast.makeText(this@MainActivity, "Selected AudioDevice: EARPIECE", Toast.LENGTH_SHORT).show()
          }
        }
    })
```

</TabItem>

<TabItem value="Java">

```javascript
    meeting.setAudioDeviceChangeListener(new AppRTCAudioManager.AudioManagerEvents() {
         @Override
        public void onAudioDeviceChanged(AppRTCAudioManager.AudioDevice selectedAudioDevice, Set<AppRTCAudioManager.AudioDevice> availableAudioDevices) {
            switch (selectedAudioDevice) {
                case BLUETOOTH:
                  Toast.makeText(MainActivity.this, "Selected AudioDevice: BLUETOOTH", Toast.LENGTH_SHORT).show();
                  break;
                case WIRED_HEADSET:
                  Toast.makeText(MainActivity.this, "Selected AudioDevice: WIRED_HEADSET", Toast.LENGTH_SHORT).show();
                  break;
                case SPEAKER_PHONE:
                  Toast.makeText(MainActivity.this, "Selected AudioDevice: SPEAKER_PHONE", Toast.LENGTH_SHORT).show();
                  break;
                case EARPIECE:
                  Toast.makeText(MainActivity.this, "Selected AudioDevice: EARPIECE", Toast.LENGTH_SHORT).show();
                  break;
               }
        }
    });
```

</TabItem>

</Tabs>

---

### addEventListener()

#### Parameters

- **listener**: MeetingEventListener

#### Returns

- _`void`_

---

### removeEventListener()

#### Parameters

- **listener**: MeetingEventListener

#### Returns

- _`void`_

---

### removeAllListeners()

#### Returns

- _`void`_

</div>


---

---
sidebar_position: 1
sidebar_label: Properties
pagination_label: Meeting Class Properties
title: Meeting Class Properties
---

import NoIndex from '../../../../../mdx/\_no-index.mdx';

<NoIndex/>

# Meeting Class Properties - React Native

<div class="sdk-api-ref-only-h4">

### getmeetingId()

- type: `String`

- `getmeetingId()` will return `meetingId`, which is unique id of the meeting where the participant has joined.

---

### getLocalParticipant()

- type: [Participant](../participant-class/introduction)

- It will be the instance of [Participant](../participant-class/introduction) class for the local participant(You) who joined the meeting.

---

### getParticipants()

- type: [`Map`](https://developer.android.com/reference/java/util/Map) of [Participant](../participant-class/introduction)

- `Map<String, Participant>`

  - Map{'<'}`participantId`, [Participant](../participant-class/introduction)>

- It will contain all joined participants in the meeting except the `localParticipant`.

- This will be the [`Map`](https://developer.android.com/reference/java/util/Map) what will container all participants attached with the key as id of that participant.

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
val remoteParticipantId = "ajf897"

val participant = meeting!!.participants[remoteParticipantId]
```

</TabItem>

<TabItem value="Java">

```javascript
String remoteParticipantId = "ajf897";

Participant participant = meeting.getParticipants().get(remoteParticipantId);
```

</TabItem>

</Tabs>

---

### pubSub

- type: [`PubSub`](../pubsub-class/introduction)
- It is used to enable Publisher-Subscriber feature in [`meeting`](introduction) class.

Learn more about `PubSub`, [here](../pubsub-class/introduction)

</div>


---

---
title: Meeting class for android SDK.
hide_title: false
hide_table_of_contents: false
description: RTC Meeting Class provides features to implement custom meeting layout in your application.
sidebar_label: Meeting Class
pagination_label: Meeting Class
keywords:
  - RTC Android
  - Meeting Class
  - Video API
  - Video Conferencing
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: meeting-class
---

import NoIndex from '../../../../mdx/\_no-index.mdx';

<NoIndex/>

# Meeting Class - Android

## using Meeting Class

The `Meeting Class` includes methods and events for managing meetings, participants, video & audio streams, data channels and UI customization.

import MethodListGroup from '@theme/MethodListGroup';
import MethodListItemLabel from '@theme/MethodListItemLabel';
import MethodListHeading from '@theme/MethodListHeading';

## Constructor

### Meeting(String meetingId, Participant localParticipant)

- return type : `void`

## Properties

### getmeetingId()

- `getmeetingId()` will return `meetingId`, which represents the meetingId for the current meeting
- return type : `void`

### getLocalParticipant()

- `getLocalParticipant()` will return Local participant
- return type :`Participant`

### getParticipants()

- `getParticipants()` will return all Remote participant
- return type : `void`

### pubSub()

- `pubSub()` will return object of `PubSub` class
- return type : `PubSub`

### Events

<MethodListGroup>
  <MethodListItemLabel name="__events" >
    <MethodListGroup>
      <MethodListHeading heading="Events" />
      <MethodListItemLabel name="addEventListener(MeetingEventListener listener)"  type={"void"} />
      <MethodListItemLabel name="removeEventListener(MeetingEventListener listener)"  type={"void"} />
      <MethodListItemLabel name="removeAllListeners()"  type={"void"} />
    </MethodListGroup>
  </MethodListItemLabel>
</MethodListGroup>

### Methods

<MethodListGroup>
  <MethodListItemLabel name="__methods" >
    <MethodListGroup>
      <MethodListHeading heading="Methods" />
      <MethodListItemLabel description={"join the meeting"} name="join()"  type={"void"} />
      <MethodListItemLabel description={"leave the meeting"} name="leave()"  type={"void"} />
      <MethodListItemLabel description={"end the meeting"} name="end()"  type={"void"} />
      <MethodListItemLabel description={"enable self mic"} name="muteMic()"  type={"void"} />
      <MethodListItemLabel description={"disable self mic"} name="unmuteMic()"  type={"void"} />
      <MethodListItemLabel description={"enable self webcam"} name="enableWebcam()"  type={"void"} />
      <MethodListItemLabel description={"disable self webcam"} name="disableWebcam()"  type={"void"} />
      <MethodListItemLabel description={"start meeting recording"} name="startRecording(String webhookUrl)"  type={"void"} />
      <MethodListItemLabel description={"stop meeting recording"} name="stopRecording()"  type={"void"} />
      <MethodListItemLabel description={"start meeting live streaming"} name="startLivestream(List<LivestreamOutput> outputs)"  type={"void"} />
      <MethodListItemLabel description={"stop meeting live streaming"} name="stopLivestream()"  type={"void"} />
      <MethodListItemLabel description={"get all mic devices"} name="getMics()"  type={"Set<AppRTCAudioManager.AudioDevice>"} />
      <MethodListItemLabel description={"change self mic"} name="changeMic()"  type={"void"} />
      <MethodListItemLabel description={"When a Local participant changes the Mic, `AppRTCAudioManager.AudioManagerEvents()` is triggered which can be set by using this method"} name="setAudioDeviceChangeListener(AppRTCAudioManager.AudioManagerEvents audioManagerEvents)"  type={"void"} />
      <MethodListItemLabel description={"change self webcam"} name="changeWebcam()"  type={"void"} />
      <MethodListItemLabel description={"start sharing phone screen"} name="enableScreenShare(Intent data)"  type={"void"} />
      <MethodListItemLabel description={"stop sharing phone screen"} name="disableScreenShare()"  type={"void"} />
    </MethodListGroup>
  </MethodListItemLabel>
</MethodListGroup>


---

---
title: MeetingEventListener Class for android SDK.
hide_title: false
hide_table_of_contents: false
description: The `MeetingEventListener Class` includes list of events which can be useful for the design custom user interface.
sidebar_label: MeetingEventListener Class
pagination_label: MeetingEventListener Class
keywords:
  - RTC Android
  - MeetingEventListener Class
  - Video API
  - Video Conferencing
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: meeting-event-listener-class
---

import NoIndex from '../../../../mdx/\_no-index.mdx';

<NoIndex/>

# MeetingEventListener Class - Android

## using MeetingEventListener Class

The `MeetingEventListener Class` is responsible for listening to all the events that are related to `Meeting Class`.

import MethodListGroup from '@theme/MethodListGroup';
import MethodListItemLabel from '@theme/MethodListItemLabel';
import MethodListHeading from '@theme/MethodListHeading';

### Listeners

<MethodListGroup>
  <MethodListItemLabel name="__listeners" >
    <MethodListGroup>
      <MethodListHeading heading="Listeners" />
      <MethodListItemLabel description={"emitted when local participant joined the meeting successfully"} name="onMeetingJoined()"  type={"void"} />
      <MethodListItemLabel description={"emitted when local participant left the meeting"} name="onMeetingLeft()"  type={"void"} />
      <MethodListItemLabel description={"emitted when new participant joined the meeting"} name="onParticipantJoined(Participant participant)"  
      type={"void"} />
      <MethodListItemLabel description={"emitted when any participant left the meeting"} name="onParticipantLeft(Participant participant)"  type={"void"} />
      <MethodListItemLabel description={"emitted when remote participant requested for entry in the meeting"} name="onEntryRequested(String id, String name)"  type={"void"} />
      <MethodListItemLabel description={"emitted when meeting host responded to participant's joining request"} 
      name="onEntryResponded(String id, String decision)"  type={"void"} />
      <MethodListItemLabel description={"emitted when any participant shared the screen"} name="onPresenterChanged(String participantId)"  type={"void"} />
      <MethodListItemLabel description={"emitted when active speaker is changed"} name="onSpeakerChanged(String participantId)"  type={"void"} />
      <MethodListItemLabel description={"emitted when recording of the meeting is started successfully"} name="onRecordingStarted()"  type={"void"} />
      <MethodListItemLabel description={"emitted when recording of the meeting is stopped"} name="onRecordingStopped()"  type={"void"} />
      <MethodListItemLabel description={"emitted when live streaming of the meeting in social media is started successfully"} name="onLivestreamStarted()"  type={"void"} />
      <MethodListItemLabel description={"emitted when live streaming of the meeting is stopped"} name="onLivestreamStopped()"  type={"void"} />
      <MethodListItemLabel description={"emitted when remote participant asked you to toggle the Mic"} name="onMicRequested(String participantId, MicRequestListener listener)"  type={"void"} />
      <MethodListItemLabel description={"emitted when remote participant asked you to toggle the Webcam"} name="onWebcamRequested(String participantId, WebcamRequestListener listener)"  type={"void"} />
      <MethodListItemLabel description={"emitted when local participant answer/dial the phone call"} name="onExternalCallStarted()"  type={"void"} />
    </MethodListGroup>
  </MethodListItemLabel>
</MethodListGroup>


---

---
title: Video SDK Participant Class
sidebar_position: 1
sidebar_label: Introduction
pagination_label: Video SDK Participant Class
---

import NoIndex from '../../../../../mdx/\_no-index.mdx';

<NoIndex/>

# Video SDK Participant Class - Android

<div class="sdk-api-ref">

import properties from './../data/participant-class/properties.json'
import methods from './../data/participant-class/methods.json'
import events from './../data/participant-class/events.json'
import LinksGrid from '../../../../../src/theme/LinksGrid'

Participant class includes all the properties, methods and events related to all the participants joined in a particular meeting.

## Get local and remote participants

You can get the local streams and participant meta from `meeting.getLocalParticipant()`. And a Map of joined participants is always available via `meeting.getParticipants()`

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js title="Javascript"
val localParticipant = meeting!!.getLocalParticipant()
val participants = meeting!!.getParticipants()
```

</TabItem>

<TabItem value="Java">

```js title="Javascript"
Participant localParticipant = meeting.getLocalParticipant();
Map<String, Participant> participants = meeting.getParticipants();
```

</TabItem>

</Tabs>

## Participant Properties

<div class="row">

<div class="col col--4 margin-bottom--sm" >

- [getId()](./properties#getid)

</div>
<div class="col col--4 margin-bottom--sm" >

- [getDisplayName()](./properties#getdisplayname)

</div>
<div class="col col--4 margin-bottom--sm" >

- [getQuality()](./properties#getquality)

</div>

<div class="col col--4 margin-bottom--sm" >

- [isLocal()](./properties#islocal)

</div>

<div class="col col--4 margin-bottom--sm" >

- [getStreams()](./properties#getstreams)

</div>

</div>

## Participant Methods

<div class="row">

<div class="col col--4 margin-bottom--sm" >

- [enableWebcam()](./methods#enablewebcam)

</div>
<div class="col col--4 margin-bottom--sm" >

- [disableWebcam()](./methods#disablewebcam)

</div>
<div class="col col--4 margin-bottom--sm" >

- [enableMic()](./methods#enablemic)

</div>
<div class="col col--4 margin-bottom--sm" >

- [disableMic()](./methods#disablemic)

</div>
<div class="col col--4 margin-bottom--sm" >

- [remove()](./methods#remove)

</div>
<div class="col col--4 margin-bottom--sm" >

- [setQuality()](./methods#setquality)

</div>
<div class="col col--4 margin-bottom--sm" >

- [setViewPort()](./methods#setviewport)

</div>
<div class="col col--4 margin-bottom--sm" >

</div>

</div>

## Participant Events

<div class="row">

<div class="col col--4 margin-bottom--sm" >

- [onStreamEnabled](./participant-event-listener-class#onstreamenabled)

</div>
<div class="col col--4 margin-bottom--sm" >

- [onStreamDisabled](./participant-event-listener-class#onstreamdisabled)

</div>

</div>

</div>


---

---
title: Participant Class Methods
sidebar_position: 1
sidebar_label: Methods
pagination_label: Participant Class Methods
---

import NoIndex from '../../../../../mdx/\_no-index.mdx';

<NoIndex/>

# Participant Class Methods - React Native

<div class="sdk-api-ref-only-h4">

### enableWebcam()

- `enableWebcam()` is used to enable participant's camera.

#### Events associated with `enableWebcam()` :

- First the participant will get a callback on [onWebcamRequested()](../meeting-class/meeting-event-listener-class#onwebcamrequested) and once the participant accepts the request, webcam will be enabled.

- Every Participant will receive a `streamEnabled` event of `ParticipantEventListener` Class with `stream` object.

#### Returns

- `void`

---

### disableWebcam()

- `disableWebcam()` is used to disable participant camera.

#### Events associated with `disableWebcam()` :

- Every Participant will receive a `streamDisabled` event of `ParticipantEventListener` Class with `stream` object.

#### Returns

- `void`

---

### enableMic()

- `enableMic()` is used to enable participant microphone.

#### Events associated with `enableMic()` :

- First the participant will get a callback on [onMicRequested()](../meeting-class/meeting-event-listener-class#onmicrequested) and once the participant accepts the request, mic will be enabled.

- Every Participant will receive a `streamEnabled` event of `ParticipantEventListener` Class with `stream` object.

#### Returns

- `void`

---

### disableMic()

- `disableMic()` is used to disable participant microphone.

#### Events associated with `disableMic()`:

- Every Participant will receive a `streamDisabled` event of `ParticipantEventListener` Class with `stream` object.

#### Returns

- `void`

---

### setQuality()

- `setQuality()` is used to set the quality of the participant's video stream.

#### Parameters

- `quality`: low | med | high

#### Returns

- `void`

---

### setViewPort()

- `setViewPort()` is used to set the quality of the participant's video stream based on the viewport height and width.

#### Parameters

- **width**: int
- **height**: int

#### Returns

- `void`

---

### remove()

- `remove()` is used to remove the participant from the meeting.

#### Events associated with `remove()` :

- Local participant will receive a [`onMeetingLeft`](../meeting-class/meeting-event-listener-class.md#onmeetingleft) event.
- All remote participants will receive a [`onParticipantLeft`](../meeting-class/meeting-event-listener-class.md#onparticipantleft) event with `participantId`.

#### Returns

- `void`

---

### addEventListener()

#### Parameters

- **listener**: ParticipantEventListener

#### Returns

- _`void`_

---

### removeEventListener()

#### Parameters

- **listener**: ParticipantEventListener

#### Returns

- _`void`_

---

### removeAllListeners()

#### Returns

- _`void`_

</div>


---

---
title: ParticipantEventListener Class
sidebar_position: 1
sidebar_label: ParticipantEventListener
pagination_label: ParticipantEventListener Class
---

import NoIndex from '../../../../../mdx/\_no-index.mdx';

<NoIndex/>

# ParticipantEventListener Class - React Native

<div class="sdk-api-ref-only-h4">

### implementation

- You can implement all the methods of `ParticipantEventListener` abstract Class and add the listener to `Participant` class using the `addEventListener()` method of `Participant` Class.

---

### onStreamEnabled()

- `onStreamEnabled()` is a callback which gets triggered whenever a participant's video, audio or screen share stream is enabled.

#### Event callback parameters

- **stream**: [Stream](../stream-class/introduction.md)

---

### onStreamDisabled()

- `onStreamDisabled()` is a callback which gets triggered whenever a participant's video, audio or screen share stream is disabled.

#### Event callback parameters

- **stream**: [Stream](../stream-class/introduction.md)

---

### Example

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
  meeting!!.localParticipant.addEventListener(object : ParticipantEventListener() {
    override fun onStreamEnabled(stream: Stream) {
        //
    }

    override fun onStreamDisabled(stream: Stream) {
        //
    }
  });
```

</TabItem>

<TabItem value="Java">

```js
  participant.addEventListener(new ParticipantEventListener() {
    @Override
    public void onStreamEnabled(Stream stream) {
        //
    }

    @Override
    public void onStreamDisabled(Stream stream) {
        //
    }
  });
```

</TabItem>

</Tabs>

</div>


---

---
title: Participant Class Properties
sidebar_position: 1
sidebar_label: Properties
pagination_label: Participant Class Properties
---

import NoIndex from '../../../../../mdx/\_no-index.mdx';

<NoIndex/>

# Participant Class Propeties - React Native

<div class="sdk-api-ref-only-h4">

### getId()

- type: `String`

- `getId` will return unique id of the participant who has joined the meeting.

---

### getDisplayName()

- type: `String`

- It will return the `displayName` of the participant who has joined the meeting.

---

### getQuality()

- type: `String`

- `getQuality()` will return quality of participant's stream. Stream could be `audio` , `video` or `share`.

---

### isLocal()

- type: `boolean`

- `isLocal()` will return `true` if participant is Local,`false` otherwise.

---

### getStreams()

- type: `Map<String,name>`

- It will represents the stream for that particular participant who has joined the meeting. Streams could be `audio` , `video` or `share`.

</div>


---

---
title: Participant class for android SDK.
hide_title: false
hide_table_of_contents: false
description: The `Participant Class` includes methods and events for participants and their associated video & audio streams, data channels and UI customization.
sidebar_label: Participant Class
pagination_label: Participant Class
keywords:
  - RTC Android
  - Participant Class
  - Video API
  - Video Conferencing
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: participant-class
---

import NoIndex from '../../../../mdx/\_no-index.mdx';

<NoIndex/>

# Participant Class - Android

## Introduction

The `Participant Class` includes methods and events for participants and their associated video & audio streams, data channels and UI customization.

import MethodListGroup from '@theme/MethodListGroup';
import MethodListItemLabel from '@theme/MethodListItemLabel';
import MethodListHeading from '@theme/MethodListHeading';

## Properties

### getId()

- `getId()` will return participant's Id
- return type : `String`

### getDisplayName()

- `getDisplayName()` will return name of participant
- return type : `String`

### getQuality()

- `getQuality()` will return quality of participant's video stream
- return type : `String`

### isLocal()

- `isLocal()` will return `true` if participant is Local,`false` otherwise
- return type : `boolean`

### getStreams()

- `getStreams()` will return streams of participant
- return type : `Map<String, Stream>`
- Map contains `streamId` as key and `stream` as value

## Events

### addEventListener(ParticipantEventListener listener)

- By using `addEventListener(ParticipantEventListener listener)`, we can add listener to the List of `ParticipantEventListener`
- return type : `void`

### removeEventListener(ParticipantEventListener listener)

- By using `removeEventListener(ParticipantEventListener listener)`, we can remove listener from List of `ParticipantEventListener`
- return type : `void`

### removeAllListeners()

- By using `removeAllListeners()`, we can remove all listener from List
- return type : `void`

## Methods

### enableMic()

- By using `enableMic()` function, a participant can enable the Mic of any particular Remote Participant
- When `enableMic()` is called,
  - Local Participant will receive a callback on `streamEnabled()` of `ParticipantEventListener` class
  - Remote Participant will receive a callback for `onMicRequested()` and once the remote participant accepts the request, mic will be enabled for that participant
- return type : `void`

### disableMic()

- By using `disableMic()` function, a participant can disable the Mic of any particular Remote Participant
- When `enableMic()` is called,
  - Local Participant will receive a callback on `streamDisabled()` of `ParticipantEventListener` class
  - Remote Participant will receive a callback on `streamDisabled()` of `ParticipantEventListener` class
- return type : `void`

### enableWebcam()

- By using `enableWebcam()` function, a participant can enable the Webcam of any particular Remote Participant
- When `enableWebcam()` is called,
  - Local Participant will receive a callback on `streamEnabled()` of `ParticipantEventListener` class
  - Remote Participant will receive a callback for `webcamRequested()` and once the remote participant accepts the request, webcam will be enabled for that participant
- return type : `void`

### disableWebcam()

- By using `disableWebcam()` function, a participant can disable the Webcam of any particular Remote Participant
- When `disableWebcam()` is called,
  - Local Participant will receive a callback on `streamDisabled()` of `ParticipantEventListener` class
  - Remote Participant will receive a callback on `streamDisabled()` of `ParticipantEventListener` class
- return type : `void`

### remove()

- By using `remove()` function, a participant can remove any particular Remote Participant
- When `remove()` is called,
  - Local Participant will receive a callback on `meetingLeft()`
  - Remote Participant will receive a callback on `participantLeft()`
- return type : `void`

### setQuality()

- By using `setQuality()`,you can set quality of participant's video stream
- return type : `void`


---

---
title: ParticipantEventListener Class for android SDK.
hide_title: false
hide_table_of_contents: false
description: The `ParticipantEventListener Class` includes list of events which can be useful for the design custom user interface.
sidebar_label: ParticipantEventListener Class
pagination_label: ParticipantEventListener Class
keywords:
  - RTC Android
  - ParticipantEventListener Class
  - Video API
  - Video Conferencing
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: participant-event-listener-class
---

import NoIndex from '../../../../mdx/\_no-index.mdx';

<NoIndex/>

# ParticipantEventListener Class - Android

## using ParticipantEventListener Class

The `ParticipantEventListener Class` is responsible for listening to all the events that are related to `Participant Class`.

import MethodListGroup from '@theme/MethodListGroup';
import MethodListItemLabel from '@theme/MethodListItemLabel';
import MethodListHeading from '@theme/MethodListHeading';

### Listeners

<MethodListGroup>
  <MethodListItemLabel name="__listeners" >
    <MethodListGroup>
      <MethodListHeading heading="Listeners" />
      <MethodListItemLabel name="onStreamEnabled(Stream stream)"  type={"void"} />
      <MethodListItemLabel name="onStreamDisabled(Stream stream)"  type={"void"} />
    </MethodListGroup>
  </MethodListItemLabel>
</MethodListGroup>


---

---
title: Video SDK PubSub Class
sidebar_position: 1
sidebar_label: Introduction
pagination_label: Video SDK PubSub Class
---

import NoIndex from '../../../../../mdx/\_no-index.mdx';

<NoIndex/>

# Video SDK PubSub Class - Android

<div class="sdk-api-ref">

## Introduction

PubSub class provides the methods to implement Publisher-Subscriber feature in your Application.

## PubSub Methods

<div class="row">

<div  class="col col--4 margin-bottom--sm" >

- [publish()](methods#publish)

</div>

<div  class="col col--4 margin-bottom--sm" >

- [subscribe()](methods#subscribe)

</div>

<div  class="col col--4 margin-bottom--sm" >

- [unsubscribe()](methods#unsubscribe)

</div>
</div>
</div>


---

---
sidebar_position: 1
sidebar_label: Methods
pagination_label: PubSub Class Methods
title: PubSub Class Methods
---

import NoIndex from '../../../../../mdx/\_no-index.mdx';

<NoIndex/>

# PubSub Class Methods - Android

<div class="sdk-api-ref-only-h4">

### publish()

- `publish()` is used to publish messages on a specified topic in the meeting.

#### Parameters

- topic

  - type: `String`
  - This is the name of the topic, for which message will be published.

- message

  - type: `String`
  - This is the actual message.

- options
  - type: [`PubSubPublishOptions`](pubsub-publish-options-class)
  - This specifies the options for publish.

#### Returns

- _`void`_

#### Example

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
// Publish message for 'CHAT' topic
val publishOptions = PubSubPublishOptions()
publishOptions.isPersist = true

meeting!!.pubSub.publish("CHAT", "Hello from Android", publishOptions)
```

</TabItem>

<TabItem value="Java">

```js
// Publish message for 'CHAT' topic
PubSubPublishOptions publishOptions = new PubSubPublishOptions();
publishOptions.setPersist(true);

meeting.pubSub.publish("CHAT", "Hello from Android", publishOptions);
```

</TabItem>

</Tabs>

---

### subscribe()

- `subscribe()` is used to subscribe a particular topic to get all the messages of that particular topic in the meeting.

#### Parameters

- topic:

  - type: `String`
  - Participants can listen to messages on that particular topic.

- listener:

  - type: [`PubSubMessageListener`](pubsub-message-listener-class)

#### Returns

- [_`List<PubSubMessage>`_](pubsub-message-class)

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
var pubSubMessageListener: ubSubMessageListener =
  PubSubMessageListener { message ->
    Log.d("#message","onMessageReceived: " + message.message)
  }

  // Subscribe for 'CHAT' topic
  val pubSubMessageList = meeting!!.pubSub.subscribe("CHAT", pubSubMessageListener)
```

</TabItem>

<TabItem value="Java">

```js
PubSubMessageListener pubSubMessageListener = new PubSubMessageListener() {
    @Override
    public void onMessageReceived(PubSubMessage message) {
        Log.d("#message", "onMessageReceived: " + message.getMessage());
    }
};

 // Subscribe for 'CHAT' topic
 List<PubSubMessage> pubSubMessageList = meeting.pubSub.subscribe("CHAT", pubSubMessageListener);
```

</TabItem>

</Tabs>

---

### unsubscribe()

- `unsubscribe()` is used to unsubscribe a particular topic on which you have subscribed priviously.

#### Parameters

- topic:

  - type: `String`
  - This is the name of the topic to be unsubscribed.

- listener:

  - type: [`PubSubMessageListener`](pubsub-message-listener-class)

#### Returns

- _`void`_

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
// Unsubscribe for 'CHAT' topic
meeting!!.pubSub.unsubscribe("CHAT", pubSubMessageListener)
```

</TabItem>

<TabItem value="Java">

```js
// Unsubscribe for 'CHAT' topic
meeting.pubSub.unsubscribe("CHAT", pubSubMessageListener);
```

</TabItem>

</Tabs>

</div>


---

---
sidebar_position: 1
sidebar_label: Properties
pagination_label: Properties
title: Properties
---

import NoIndex from '../../../../../mdx/\_no-index.mdx';

<NoIndex/>

# Properties - Android

<div class="sdk-api-ref-only-h4">

### getId()

- type: `String`

- `getId()` will return unique id of the pubsub message.

---

### getMessage()

- type: `String`

- `getMessage()` will return message that has been published on the specific topic.

---

### getTopic()

- type: `String`

- `getTopic()` will return name of the message topic.

---

### getSenderId()

- type: `String`

- `getSenderId()` will return id of the participant, who has sent the message.

---

### getSenderName()

- type: `String`

- `getSenderName()` will return name of the participant, who has sent the pubsub message.

---

### getTimestamp()

- type: `long`

- `getTimestamp()` will return timestamp at which, the pubsub message was sent.

</div>


---

---
sidebar_position: 1
sidebar_label: PubSubMessageListener Class
pagination_label: PubSubMessageListener Class
title: PubSubMessageListener Class
---

import NoIndex from '../../../../../mdx/\_no-index.mdx';

<NoIndex/>

# PubSubMessageListener Class - React Native

<div class="sdk-api-ref-only-h4">

---

#### onMessageReceived()

- This event will be emitted whenever any pubsub message received.

#### Example

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
var pubSubMessageListener = PubSubMessageListener { message ->
    Log.d("#message", "onMessageReceived: " + message.message)
}
```

</TabItem>

<TabItem value="Java">

```javascript
PubSubMessageListener pubSubMessageListener = new PubSubMessageListener() {
    @Override
    public void onMessageReceived(PubSubMessage message) {
        Log.d("#message", "onMessageReceived: " + message.getMessage());
    }
};
```

</TabItem>

</Tabs>

</div>


---

---
sidebar_position: 1
sidebar_label: PubSubPublishOptions Class
pagination_label: PubSubPublishOptions Class
title: PubSubPublishOptions Class
---

import NoIndex from '../../../../../mdx/\_no-index.mdx';

<NoIndex/>

# PubSubPublishOptions Class - React Native

<div class="sdk-api-ref-only-h4">

---

## Properties

### persist

- type: `boolean`

- defaultValue: `false`

- This property specifies whether to store messages on server for upcoming participants.

- If the value of this property is true, then server will store pubsub messages for the upcoming participants.

</div>


---

---
title: PubSub class for android SDK.
hide_title: false
hide_table_of_contents: false
description: PubSub Class
sidebar_label: PubSub Class
pagination_label: PubSub Class
keywords:
  - RTC Android
  - Publisher-Subscriber
  - PubSub
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: pubsub-class
---

import NoIndex from '../../../../mdx/\_no-index.mdx';

<NoIndex/>

# PubSub Class - Android

## using PubSub Class

The `PubSub` includes methods for pubsub.

import MethodListGroup from '@theme/MethodListGroup';
import MethodListItemLabel from '@theme/MethodListItemLabel';
import MethodListHeading from '@theme/MethodListHeading';

### Methods

<MethodListGroup>
  <MethodListItemLabel name="__methods" >
    <MethodListGroup>
      <MethodListHeading heading="Methods" />
      <MethodListItemLabel name="publish(String topic, String message, PubSubPublishOptions options)"  type={"void"} />
      <MethodListItemLabel name="subscribe(String topic, PubSubMessageListener listener)"  type={"List<PubSubMessage>"} />
      <MethodListItemLabel name="unsubscribe(String topic, PubSubMessageListener listener)"  type={"void"} />
    </MethodListGroup>
  </MethodListItemLabel>
</MethodListGroup>


---

---
title: PubSubMessage class for android SDK.
hide_title: false
hide_table_of_contents: false
description: PubSubMessage Class
sidebar_label: PubSubMessage Class
pagination_label: PubSubMessage Class
keywords:
  - RTC Android
  - Publisher-Subscriber
  - PubSub
  - PubSubMessage
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: pubsub-message-class
---

import NoIndex from '../../../../mdx/\_no-index.mdx';

<NoIndex/>

# PubSubMessage Class - Android

## using PubSubMessage Class

The `PubSubMessage` includes properties of PubSub message.

import MethodListGroup from '@theme/MethodListGroup';
import MethodListItemLabel from '@theme/MethodListItemLabel';
import MethodListHeading from '@theme/MethodListHeading';

### Properties

<MethodListGroup>
  <MethodListItemLabel name="__properties"  >
    <MethodListGroup>
      <MethodListHeading heading="Properties" />
      <MethodListItemLabel name="id" type={"String"} />
      <MethodListItemLabel name="message" type={"String"} />
      <MethodListItemLabel name="senderId" type={"String"} />
      <MethodListItemLabel name="senderName" type={"String?"} />
      <MethodListItemLabel name="timestamp" type={"DateTime"} />
      <MethodListItemLabel name="topic" type={"String"} />
    </MethodListGroup>
  </MethodListItemLabel>
</MethodListGroup>


---

---
title: PubSubPublishOptions class for android SDK.
hide_title: false
hide_table_of_contents: false
description: PubSubPublishOptions Class
sidebar_label: PubSubPublishOptions Class
pagination_label: PubSubPublishOptions Class
keywords:
  - RTC Android
  - PubSub
  - PubSubPublishOptions
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: pubsub-publish-options-class
---

import NoIndex from '../../../../mdx/\_no-index.mdx';

<NoIndex/>

# PubSubPublishOptions Class - Android

## using PubSubPublishOptions Class

The `PubSubPublishOptions` includes properties of PubSub options.

import MethodListGroup from '@theme/MethodListGroup';
import MethodListItemLabel from '@theme/MethodListItemLabel';
import MethodListHeading from '@theme/MethodListHeading';

### Properties

<MethodListGroup>
  <MethodListItemLabel name="__properties"  >
    <MethodListGroup>
      <MethodListHeading heading="Properties" />
      <MethodListItemLabel name="persist" type={"bool"} description={"Specifies whether to store messages on server for upcoming participants"} />
    </MethodListGroup>
  </MethodListItemLabel>
</MethodListGroup>

### Methods

<MethodListGroup>
  <MethodListItemLabel name="__methods" >
    <MethodListGroup>
      <MethodListHeading heading="Methods" />
      <MethodListItemLabel name="toJSONObject()"  type={"JSONObject"} />
    </MethodListGroup>
  </MethodListItemLabel>
</MethodListGroup>


---

---
id: setup
title: Installation steps for RTC Android SDK
hide_title: false
hide_table_of_contents: false
description: RTC Android SDK provides client for almost all Android devices. it takes less amount of cpu and memory.
sidebar_label: Setup
pagination_label: Setup
keywords:
  - RTC Android
  - Android SDK
  - Kotlin SDK
  - Java SDK
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: setup
---

import NoIndex from '../../../../mdx/\_no-index.mdx';

<NoIndex/>

# Setup - Android

## Setting up android sdk

Android SDK is client for real-time communication for android devices. It inherits the same terminology as all other SDKs does.

## Minimum OS/SDK versions

It supports the following OS/SDK versions.

### Android: minSdkVersion >= 18

## Installation

1. If your Android Studio Version is older than Android Studio Bumblebees, add the repository to project's `build.gradle` file. <br/>
   If your are using Android Studio Bumblebees or newer Version, add the repository to `settings.gradle` file.

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="<2021.1.1"
groupId={"android-studio-version"}
values={[{label: 'Android Studio Version < 2021.1.1', value: '<2021.1.1'},{label: 'Android Studio Version 2021.1.1', value: '2021.1.1'},]}>

<TabItem value="<2021.1.1">

```js title="build.gradle"
allprojects {
  repositories {
    // ...
    maven { url 'https://jitpack.io' }
    jcenter()
  }
}
```

</TabItem>

<TabItem value="2021.1.1">

```js title="settings.gradle"
dependencyResolutionManagement{
  repositories {
    // ...
    maven { url 'https://jitpack.io' }
    jcenter()
  }
}
```

</TabItem>

</Tabs>

### Step 2: Add the following dependency in your app's `app/build.gradle`.

```js title="app/build.gradle"
dependencies {
  implementation 'live.videosdk:android-sdk:0.0.26'

  // library to perform Network call to generate a meeting id
  implementation 'com.amitshekhar.android:android-networking:1.0.2'

  // other app dependencies
  }
```

## Integration

### Step 1: Add the following permissions in `AndroidManifest.xml`.

```xml title="AndroidManifest.xml"
<uses-permission android:name="android.permission.RECORD_AUDIO" />
<uses-permission android:name="android.permission.INTERNET" />
<uses-permission android:name="android.permission.READ_PHONE_STATE" />
<uses-permission android:name="android.permission.CAMERA" />

<!-- Needed to communicate with already-paired Bluetooth devices. (Legacy up to Android 11) -->
<uses-permission
    android:name="android.permission.BLUETOOTH"
    android:maxSdkVersion="30" />
<uses-permission
    android:name="android.permission.BLUETOOTH_ADMIN"
    android:maxSdkVersion="30" />

<!-- Needed to communicate with already-paired Bluetooth devices. (Android 12 upwards)-->
<uses-permission android:name="android.permission.BLUETOOTH_CONNECT" />

```

### Step 2: Create `MainApplication` class which will extend the `android.app.Application`.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js title="MainApplication.kt"
package live.videosdk.demo;

import live.videosdk.android.VideoSDK

class MainApplication : Application() {
    override fun onCreate() {
        super.onCreate()
        VideoSDK.initialize(applicationContext)
    }
}
```

</TabItem>

<TabItem value="Java">

```js title="MainApplication.java"
package live.videosdk.demo;

import android.app.Application;

import live.videosdk.android.VideoSDK;

public class MainApplication extends Application {
    @Override
    public void onCreate() {
        super.onCreate();
        VideoSDK.initialize(getApplicationContext());
    }
}
```

</TabItem>

</Tabs>

### Step 3: Add `MainApplication` to `AndroidManifest.xml`.

```js title="AndroidManifest.xml"
<application
        android:name=".MainApplication"
				...
>
  <!-- ... -->
</application>
```

### Step 4: In your `JoinActivity` add the following code in `onCreate()` method.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js title="JoinActivity.kt"
override fun onCreate(savedInstanceState: Bundle?) {
  super.onCreate(savedInstanceState)
  setContentView(R.layout.activity_join)

  val meetingId = "<meeting-id>"
  val participantName = "John Doe"

  var micEnabled = true
  var webcamEnabled = true

  // generate the jwt token from your api server and add it here
  VideoSDK.config("JWT TOKEN GENERATED FROM SERVER")

  // create a new meeting instance
  meeting = VideoSDK.initMeeting(
      this@MeetingActivity, meetingId, participantName,
      micEnabled, webcamEnabled,false,null,null)

  // get permissions and join the meeting with meeting.join();
  // checkPermissionAndJoinMeeting();
}
```

</TabItem>

<TabItem value="Java">

```js title="JoinActivity.java"
@Override
protected void onCreate(Bundle savedInstanceState) {
  super.onCreate(savedInstanceState);
  setContentView(R.layout.activity_join);

  final String meetingId = "<meeting-id>";
  final String participantName = "John Doe";

  final boolean micEnabled = true;
  final boolean webcamEnabled = true;

  // generate the jwt token from your api server and add it here
  VideoSDK.config("JWT TOKEN GENERATED FROM SERVER");

  // create a new meeting instance
  Meeting meeting = VideoSDK.initMeeting(
          MainActivity.this, meetingId, participantName,
          micEnabled, webcamEnabled,false,null,null
  );

  // get permissions and join the meeting with meeting.join();
  // checkPermissionAndJoinMeeting();
}
```

</TabItem>

</Tabs>

All set! Here is the link to the complete sample code on [Github](https://github.com/videosdk-live/videosdk-rtc-android-java-sdk-example). Please refer to the [documentation](initMeeting) for a full list of available methods, events and features of the SDK.


---

---
title: Video SDK Stream Class
sidebar_position: 1
sidebar_label: Introduction
pagination_label: Video SDK Stream Class
---

import NoIndex from '../../../../../mdx/\_no-index.mdx';

<NoIndex/>

# Video SDK Stream Class

<div id="tailwind" class="sdk-api-ref">

import properties from './../data/stream-class/properties.json'
import methods from './../data/stream-class/methods.json'
import LinksGrid from '../../../../../src/theme/LinksGrid'

Stream class is responsible for handling audio, video and screen sharing streams.

Stream class defines instance of audio, video and shared screen stream of participants.

## Stream Properties

<div class="row">

<div class="col col--4 margin-bottom--sm" >

- [getId()](./properties#getid)

</div>
<div class="col col--4 margin-bottom--sm" >

- [getKind()](./properties#getkind)

</div>
<div class="col col--4 margin-bottom--sm" >

- [getTrack()](./properties#gettrack)

</div>
<div class="col col--4 margin-bottom--sm" >

- [getProducer()](/android/0.0.x/api/sdk-reference/stream-class/properties)

</div>

<div class="col col--4 margin-bottom--sm" >

- [getConsumer()](/android/0.0.x/api/sdk-reference/stream-class/properties)

</div>

</div>

## Stream Methods

<div class="row">

<div class="col col--4 margin-bottom--sm" >

- [resume()](methods#resume)

</div>
<div class="col col--4 margin-bottom--sm" >

- [pause()](./methods#pause)

</div>

</div>

</div>


---

---
title: Participant Class Methods
sidebar_position: 1
sidebar_label: Methods
pagination_label: Participant Class Methods
---

import NoIndex from '../../../../../mdx/\_no-index.mdx';

<NoIndex/>

# Participant Class Methods - Android

<div class="sdk-api-ref-only-h4">

### resume()

- By using `resume()`, a participant can resume the stream of Remote Participant.

#### Returns

- `void`

---

### pause()

- By using `pause()`, a participant can pause the stream of Remote Participant.

#### Returns

- `void`

</div>


---

---
title: Stream Class Properties
sidebar_position: 1
sidebar_label: Properties
pagination_label: Stream Class Properties
---

import NoIndex from '../../../../../mdx/\_no-index.mdx';

<NoIndex/>

# Stream Class Properties - Android

<div class="sdk-api-ref-only-h4">

### getId()

- type: `String`

- `getId()` will return id for that stream .

---

### getKind()

- type: `String`

- `getKind()` will return `kind`, which represents the type of stream which could be `audio` | `video` or `share` .

---

### getTrack()

- type: `MediaStreamTrack`

- `getTrack()` will return a MediaStreamTrack object stored in the MediaStream object.

</div>


---

---
title: Stream class for android SDK.
hide_title: false
hide_table_of_contents: false
description: RTC Stream Class enables opportunity to .
sidebar_label: Stream Class
pagination_label: Stream Class
keywords:
  - RTC Android
  - Stream Class
  - Video API
  - Video Conferencing
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: stream-class
---

import NoIndex from '../../../../mdx/\_no-index.mdx';

<NoIndex/>

# Stream Class - Android

## Introduction

The `Stream Class` includes methods and events of video & audio streams.

import MethodListGroup from '@theme/MethodListGroup';
import MethodListItemLabel from '@theme/MethodListItemLabel';
import MethodListHeading from '@theme/MethodListHeading';

## Properties

### getId()

- `getId()` will return Id of stream
- return type : `String`

### getKind()

- `getKind()` will return kind of stream, which can `audio`,`video` or `share`
- return type : `String`

### getTrack()

- `getTrack()` will return a MediaStreamTrack object stored in the MediaStream object
- return type : `MediaStreamTrack`

## Methods

### pause()

- By using `pause()` function, a participant can pause the stream of Remote Participant
- return type : `void`

### resume()

- By using `resume()` function, a participant can resume the stream of Remote Participant
- return type : `void`


---

---
title: Terminology - Video SDK Documentation
hide_title: true
hide_table_of_contents: false
description: Video SDK enables the opportunity to integrate native IOS, Android & Web SDKs to add live video & audio conferencing to your applications.
sidebar_label: Terminology
pagination_label: Terminology
keywords:
  - audio calling
  - video calling
  - real-time communication
  - collaboration
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: terminology
---

import Terminology from '../../../../mdx/introduction/\_terminology.mdx';
import NoIndex from '../../../../mdx/\_no-index.mdx';

<NoIndex/>
<Terminology title="Terms related to VideoSDK - Android" />


---

---
title: Video SDK Class for android SDK.
hide_title: false
hide_table_of_contents: false
description: Video SDK Class is a factory for initialize, configure and init meetings.
sidebar_label: VideoSDK Class
pagination_label: VideoSDK Class
keywords:
  - RTC Android
  - VideoSDK Class
  - Video API
  - Video Conferencing
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: videosdk-class
---

import NoIndex from '../../../../mdx/\_no-index.mdx';

<NoIndex/>

# VideoSDK Class - Android

The entry point into real-time communication SDK.

## using VideoSDK Class

The `VideoSDK Class` includes methods and events to initialize and configure the SDK. It is a factory class.

import MethodListGroup from '@theme/MethodListGroup';
import MethodListItemLabel from '@theme/MethodListItemLabel';
import MethodListHeading from '@theme/MethodListHeading';

### Parameters

<MethodListGroup>
  <MethodListItemLabel name="__namedParameters" option={"required"} type={"object"} >
    <MethodListGroup>
      <MethodListHeading heading="Properties" />
      <MethodListItemLabel description={"set meeting id"} name="meetingId" option={"required"} type={"string"} />
      <MethodListItemLabel description={"set local participant's name"} name="name" option={"required"} type={"string"} />
      <MethodListItemLabel description={"set local participant's mic state"} name="micEnabled" option={"required"} type={"bool"} />
      <MethodListItemLabel description={"set local participant's webcam state"} name="webcamEnabled" option={"required"} type={"bool"}/>
      <MethodListItemLabel description={"set local participant's Id"} name="paricipantId" option={"required"} type={"string"}/>
    </MethodListGroup>
  </MethodListItemLabel>
</MethodListGroup>

### Methods

<MethodListGroup>
  <MethodListItemLabel name="__methods" >
    <MethodListGroup>
      <MethodListHeading heading="Methods" />
      <MethodListItemLabel description={"initialize the MediasoupClient"} name="initialize(Context context)"  type={"void"} />
      <MethodListItemLabel description={"configure the token"} name="config(String token)"  type={"void"} />
      <MethodListItemLabel description={"initialize the meeting"} 
      name="initMeeting(
        Context context, 
        String meetingId, 
        String name, 
        boolean micEnabled,
        boolean webcamEnabled,
        boolean multiStream,
        String participantId,
        Map<String, CustomStreamTrack> customTracks
      )"  type={"Meeting"} />
    </MethodListGroup>
  </MethodListItemLabel>
</MethodListGroup>

## Example

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js title="initMeeting"
// Configure the token
VideoSDK.config(token)

// Initialize the meeting
Meeting meeting = VideoSDK.initMeeting(
      context,
      meetingId, // required
      name, // required
      micEnabled, // required
      webcamEnabled, // required
      false, // required
      null, // required
      null // required
      )
});
```

</TabItem>

<TabItem value="Java">

```js title="initMeeting"
// Configure the token
VideoSDK.config(token)

// Initialize the meeting
Meeting meeting = VideoSDK.initMeeting({
  context,
  meetingId, // required
  name, // required
  micEnabled, // required
  webcamEnabled, // required
  false, // required
  null, // required
  null // required
});
```

</TabItem>

</Tabs>


---

---
title: Start a Video & Audio Call in Android SDK - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: Build customizable real-time video & audio calling applications in Android SDK using Video SDK add live Video & Audio conferencing to your applications.
sidebar_label: "Client Setup for Android"
pagination_label: "Client Setup for Android"
keywords:
  - android sdk
  - java sdk
  - kotlin sdk
  - chromebook sdk
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: android-sdk
---

import NoIndex from '../../../../mdx/\_no-index.mdx';

<NoIndex/>

# Getting Started - Android SDK

Android SDK is natively written SDK using Java. It is compatible with both Java and Kotlin.

## Install an Android SDK

The easiest way to get started is by installing the sdk in your app.

### Step 1: Add the repositories into your project.

- If your Android Studio Version is older than Android Studio Bumblebees, add the repository to project's `build.gradle` file.
- If your are using Android Studio Bumblebees or newer Version, add the repository to `settings.gradle` file.

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="2021.1.1"
groupId={"android-studio-version"}
values={[{label: 'Android Studio Version < 2021.1.1', value: '<2021.1.1'},{label: 'Android Studio Version 2021.1.1', value: '2021.1.1'},]}>

<TabItem value="<2021.1.1">

```js title="build.gradle"
allprojects {
  repositories {
    // ...
    maven { url 'https://jitpack.io' }
    jcenter()
  }
}
```

</TabItem>

<TabItem value="2021.1.1">

```js title="settings.gradle"
dependencyResolutionManagement{
  repositories {
    // ...
    maven { url 'https://jitpack.io' }
    jcenter()
  }
}
```

</TabItem>

</Tabs>


### Step 2: Add the dependency in `app/build.gradle`:

```js title="app/build.gradle"
dependencies {
		implementation 'live.videosdk:android-sdk:0.0.26'

		// other app dependencies
}
```

### Step 3: Add all the following permissions to AndroidManifest.xml

```js title="AndroidManifest.xml"
<uses-permission android:name="android.permission.RECORD_AUDIO" />
<uses-permission android:name="android.permission.INTERNET" />
<uses-permission android:name="android.permission.READ_PHONE_STATE" />
<uses-permission android:name="android.permission.CAMERA" />

<!-- Needed to communicate with already-paired Bluetooth devices. (Legacy up to Android 11) -->
<uses-permission
    android:name="android.permission.BLUETOOTH"
    android:maxSdkVersion="30" />
<uses-permission
    android:name="android.permission.BLUETOOTH_ADMIN"
    android:maxSdkVersion="30" />

<!-- Needed to communicate with already-paired Bluetooth devices. (Android 12 upwards)-->
<uses-permission android:name="android.permission.BLUETOOTH_CONNECT" />

```

### Step 4: Create MainApplication class with the following code

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js title="MainApplication.kt"
package live.videosdk.demo;

import live.videosdk.rtc.android.VideoSDK;

class MainApplication : Application() {
  override fun onCreate() {
    super.onCreate()
    
    VideoSDK.initialize(applicationContext)
  }
}
```

</TabItem>

<TabItem value="Java">

```js title="MainApplication.java"
package live.videosdk.demo;

import android.app.Application;

import live.videosdk.rtc.android.VideoSDK;

public class MainApplication extends Application {
    @Override
    public void onCreate() {
        super.onCreate();

        VideoSDK.initialize(getApplicationContext());
    }
}
```

</TabItem>

</Tabs>

### Step 5: Add MainApplication to AndroidManifest.xml

```js title="AndroidManifest.xml"
<application
    android:name=".MainApplication"
>
  <!-- ... -->
</application>
```

:::note

Check out official example of Android SDK implementation for Java and Kotlin as mentioned below: 

- For **Java** Code Sample [Click here](https://github.com/videosdk-live/videosdk-rtc-android-java-sdk-example)<br />
- For **Kotlin** Code Sample [Click here](https://github.com/videosdk-live/videosdk-rtc-android-kotlin-sdk-example)

:::


---

---
title: Authentication in Video & Audio Calling SDK
hide_title: false
hide_table_of_contents: false
description: This guide will explain authentication and token flow for video & audio calling SDK.
sidebar_label: Authentication and Tokens
pagination_label: Authentication and Tokens
keywords:
  - authentication audio calling
  - authentication video calling
  - authentication real-time communication
  - tokens
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: authentication-and-tokens
---

import Mermaid from '@theme/Mermaid';
import NoIndex from '../../../../mdx/\_no-index.mdx';

<NoIndex/>

# Authentication and Token - Android

VideoSDK uses access tokens for authentication. Using our dashboard ([app.videosdk.live](https://app.videosdk.live/)), anyone can generate access tokens tokens with an API key and secret pair.

- Your backend server will generate access tokens using API Key and secret.
- Your client obtains token from your backend server.
- Your client will pass the token to VideoSDK server.
- VideoSDK client sdk will conncts to the VideoSDK server with available token.
- VideoSDK server will validate the token and accpets your incoming connection.

Here is the simple sequence diagram represents the authentication.
<Mermaid chart={`sequenceDiagram Your App Client->>Your App Server: Request for token; activate Your App Server; Note left of Your App Server: Generate token; Your App Server-->>Your App Client: Received token; deactivate Your App Server; Your App Client->>VideoSDK Server: Request to establish connection; activate VideoSDK Server; Note left of VideoSDK Server: Validates Token; VideoSDK Server-->>Your App Client: Connection established; deactivate VideoSDK Server;`}/>

## Generate API Key and Secret

Visit, [app.videosdk.live](https://app.videosdk.live/) to gererate API Key and secret.

![Generate API Key from Dashboard](/img/tutorial/generate-api-key.jpg)

## Generate Access Token

For security, every participant that connects to meeting needs a access token. By substituting `apikey` and `permissions` in it.

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="node"
groupId={"server-group-id"}
values={[
{label: 'Node.js', value: 'node'},
{label: 'Python', value: 'python'},
{label: 'Java', value: 'java'},
{label: 'Ruby', value: 'ruby'},
{label: 'PHP', value: 'php'},
]}>
<TabItem value="node">

```js
var jwt = require("jsonwebtoken");
var uuid4 = require("uuid4");

// Need to generate from app.videosdk.live
const API_KEY = "API_KEY_GENERATED";
const SECRET_KEY = "API_SECRET_KEY_GENERATED";

jwt.sign(
  {
    apikey: API_KEY,
    permissions: ["allow_join"], // Permission to join the meeting
  },
  SECRET_KEY,
  {
    algorithm: "HS256",
    expiresIn: "24h",
    jwtid: uuid4(),
  },
  function (err, token) {
    console.log(token);
  }
);
```

</TabItem>
<TabItem value="python">

```python
#!/usr/bin/env python3
import jwt
import uuid
import datetime

api_key = 'api_key_generated'
secret_key = 'secret_key_generated'


def generateToken():
    expires = 24 * 3600
    now = datetime.datetime.utcnow()
    exp = now + datetime.timedelta(seconds=expires)
    return jwt.encode(payload={
          'apikey': api_key,
          permissions: ["allow_join"]
        }, key=secret_key).decode('utf-8')

if __name__ == '__main__':
    print(generateToken())
```

</TabItem>
<TabItem value="java">

```js
import java.time.Instant;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;
import java.util.UUID;
import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.SignatureAlgorithm;

private void generateManagementToken() {
    Map<String, Object> payload = new HashMap<>();
    payload.put("apikey", "<api_key_generated>");
    payload.put("permissions", ["allow_join"]);
    String token = Jwts.builder().setClaims(payload).setId(UUID.randomUUID().toString())
        .setExpiration(new Date(System.currentTimeMillis() + 86400 * 1000))
        .setIssuedAt(Date.from(Instant.ofEpochMilli(System.currentTimeMillis() - 60000)))
        .setNotBefore(new Date(System.currentTimeMillis()))
        .signWith(SignatureAlgorithm.HS256, "<secret_key_generated>".getBytes()).compact();
  }
```

</TabItem>
<TabItem value="ruby">

```js
require 'jwt'
require 'securerandom'

$api_key = "api_key_generated"
$secret_key = "secret_key_generated"

def generateToken()
    payload = {
      apikey: $api_key,
      permissions: ["allow_join"]
    }
token = JWT.encode(payload, $secret_key, 'HS256')
return token
end

puts generateToken
```

</TabItem>
<TabItem value="php">

```js
<?php

use Firebase\JWT\JWT;
use Ramsey\Uuid\Uuid;

$api_key = "api_key_generated";
$secret_key = "secret_key_generated"

$payload = [
    'apikey' => api_key,
    'permissions': ["allow_join"],
];

$token = JWT::encode($payload, $secret_key, 'HS256');
?>
```

</TabItem>
</Tabs>

Available permissions are:

- **allow_join**: The participant will be permitted entry without request.
- **ask_join**: The participant will not be permitted entry without request.
- **allow_mod**: Allow participant to enable/disable other participant's mic/webcam.


---

---
sidebar_label: Concept And Architecture
pagination_label: Concept And Architecture
---

# Concept and Architecture - Android

Before diving into the concept, let's understand the VideoSDK, VideoSDK is a software development kit that offers tools and APIs for creating apps that are based on video and audio. It typically includes features such as video and audio calls, chat, cloud recording, simulcasting (RTMP), interactive live streaming (HLS), and many more across a wide range of platforms and devices.

## Concepts

![img.png](../../../../static/img/room-concept.png)

### `1. Meeting / Room`

- Meeting or Room object in the VideoSDK provide a virtual place for participants to interact and engage in real-time voice, video, and screen-sharing sessions. The object is in charge of handling media streams and participant communication.

- Meeting or Room can be uniquely identified by `meetingId` or `roomId`.

### `2. Participant`

- Participant is a VideoSDK object that represents each user/client in the meeting or room and allows them to share audio/video assets.

- `2.1 Local Participant` :
  The local participant is the one that runs on the user's device. The local participant has control over their own media streams, including the ability to start and stop audio and video.

  - The local participant in a meeting/room can also connect with other participants by transmitting and receiving audio and video streams, exchanging chat messages, and more.

- `2.2 Remote Participant` :
  The remote participant receives audio and video streams from the local participant and other remote participants and also has the ability to exchange audio, video, and chat messages with the local participant.

- Each participant in VideoSDK can be uniquely identified by `participantId`.

### `3. MediaStream & Track`

- A mediastream is a collection of audio & video tracks that can be transmitted between participants in real-time.

- A track is a continuous flow of audio or video data and can be thought of as a stream of media frames.

- A mediastream can contain multiple tracks. One video track for the video feed from the camera and one audio track for the audio feed from the microphone. These tracks can be transmitted between participants in VideoSDK Meeting / Room.

### `4. Events / Notifications`

- Events / Notifications can be used to inform users about various activities happening in a Meeting / Room, including participant join/leave and new messages. They can also be used to alert users about any SDK-level errors that occur during a call.

### `5. Session`

- A Session is the instance of an ongoing meeting/room which has one or more participants in it. A single room or meeting can have multiple sessions.
- Each session can be uniquely identified by `sessionId`.

![img.png](../../../../static/img/meeting-session.jpg)

---

![img.png](../../../../static/img/recording-hls-rtmp.png)

### `6. Cloud Recording`

- Cloud recording in VideoSDK refers to the process of recording audio or video content and storing it on a remote server or VideoSDK server.

### `7. Simulcasting (RTMP)`

- RTMP is a popular protocol for live streaming video content from a VideoSDK to platforms such as YouTube, Twitch, Facebook, and others.
- By providing the platform-specific `stream key` and `stream URL`, the VideoSDK can connect to the platform's RTMP server and transmit the live video stream.

### `8. Http Live Streaming (HLS)`

- Interactive live streaming (HLS) refers to a type of live streaming where viewers can actively engage with the content being streamed and with other viewers in real-time.

- In an interactive live stream (HLS), viewers can take part in a variety of activities like live polling, Q&A sessions, and even sending virtual gifts to the content creator or each other.

## Architecture

This diagram demonstrates end-to-end flow to implement video & audio calls, record calls, and go live on social media.

![Video-sdk-architecture!](/img/video-sdk-archietecture.svg)


---

---
title: Integrate Banuba SDK with Android SDK - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: Describes how to integrate Banuba SDK with videosdk.live using Android SDK to enhance video calls with real-time face filters and virtual backgrounds.
sidebar_label: "Banuba Integration"
pagination_label: "Banuba Integration"
keywords:
  - android sdk
  - java sdk
  - kotlin sdk
  - banuba
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: banuba-integration
---

import NoIndex from '../../../../../mdx/\_no-index.mdx';

<NoIndex/>

# How to intergrate Banuba SDK with Android Video SDK?

Use Banuba SDK with Android SDK to enhance video calls with real-time face filters and virtual backgrounds.

### Step 1: Banuba Token

- To start working with the Banuba SDK into your project, you need to have the client token. To receive the client token please fill form on [banuba.com](https://www.banuba.com/)

### Step 2: Add Banuba SDK dependencies

- With the client token, you will also receive the Banuba SDK archive for Android which contains Banuba Effect Player (compiled Android library project with .aar extension), Banuba SDK (compiled Android library project with .aar extension) and example filters located under effects folder.

- Create `libs` directory in your project and add `banuba_effect_player.aar`, `banuba_sdk.aar` files.

<div style={{textAlign: 'center'}}>

![Banuba SDK dependency .aar files](/img/android/banuba/banuba_dependency.png)

</div>

- Open build.gradle (Module: app) and add Banuba SDK dependencies.

```js title="app/build.gradle"
dependencies {
  // Banuba SDK dependencies
   implementation fileTree(dir: 'libs', include: ['*.aar'])

  // other app dependencies
  }
```

### Step 3: Add effects into your project

- Create `effects` folder under `assets` directory in your project and add filters that you want to use in the `effects` folder.You can download test effects here: [Effects](https://docs.banuba.com/face-ar-sdk-v1/overview/demo_face_filters)

<div style={{textAlign: 'center'}}>

![Banuba SDK effects folder](/img/android/banuba/banuba_effects.png)

</div>

### Step 4: Integrate Banuba

1. Create one interface named `IVideoFrameProcessor` and a class named `BanubaProcessor` in your project and copy paste code from the [example](https://github.com/videosdk-live/videosdk-rtc-android-sdk-banuba-example).

2. Update your Banuba client token into `BanubaProcessor.java` file.

```js title="BanubaProcessor.java"
public class BanubaProcessor implements IVideoFrameProcessor {
    //...
    public static final String KEY = "place_your_token_here";
    //...
}
```

3. Create instance of `CapturerObserver` class and pass into VideoSDK.createCameraVideoTrack() method. To know more about createCameraVideoTrack() method please visit [CustomVideoTrack](../features/custom-track/custom-video-track.md).

4. Copy paste method named `initVideoFrameProcessor(VideoSource videosource,CustomStreamTrack videoCustomTrack)` from the [example](https://github.com/videosdk-live/videosdk-rtc-android-sdk-banuba-example). into your Activity and call it after creating `CustomStreamTrack` for video.

### Step 5: Use filters in Meeting

- If you want to use video filters from start of the meeting, you can pass `CustomStreamTrack` in the `initMeeting`.

- Also you can use video filters during the meeting by passing the `CustomStreamTrack` in the `enableWebcam()` method of Meeting.

:::tip

Stuck anywhere? Check out this [Code Sample of Banuba Intergation with Android-SDK](https://github.com/videosdk-live/videosdk-rtc-android-sdk-banuba-example.git) on GitHub

:::


---

---
title: Camera Controls Video & Audio Call - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: Camera Controls features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Camera Controls
pagination_label: Camera Controls
keywords:
  - Camera on
  - Camera off
  - Webcam on
  - Webcam off
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: camera-controls
---

import NoIndex from '../../../../../mdx/\_no-index.mdx';

<NoIndex/>

# Camera Controls - Android

Whenever any participant wants to start/stop broadcasting their video to other participant in a meeting, they can simply do it with VideoSDK Meeting.

This guide will provide an overview of how to implement enable, disable and switch webcam features in a meeting.

1. **Enable Camera** - By using `enableWebcam()` function, a participant can publish camera stream to other participants.
2. **Disable Camera** - By using `disableWebcam()` function, a participant can stop publishing camera stream to other participants.
3. **Switch Camera** - By using `changeWebcam()` function, a participant can stream from front / rear camera during the meeting.This function is only applicable for Mobile devices.

### Enable, Disable And Switch Webcam

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
  btnWebcam!!.setOnClickListener {

    // Toggle participant webcam in meeting
    if (webcamEnabled) {
      meeting!!.disableWebcam()
    } else {
      meeting!!.enableWebcam()
    }

    // Change Webcam in Meeting
    meeting!!.changeWebcam()
  }
```

</TabItem>

<TabItem value="Java">

```js
  btnWebcam.setOnClickListener(new View.OnClickListener() {
      @Override
      public void onClick(View v) {

        // Toggle participant webcam in meeting
        if (webcamEnabled) {
          meeting.disableWebcam();
        } else {
          meeting.enableWebcam();
        }

         // Change Webcam in Meeting
        meeting.changeWebcam();
      }
  });
```

</TabItem>

</Tabs>

### Events

**Event associated with `enableWebcam()`:**

- Every Participant will receive a callback on [`onStreamEnabled()`](../../../api/sdk-reference/participant-class/participant-event-listener-class.md#onstreamenabled) of the [`Participant`](../../../api/sdk-reference/participant-class//introduction.md) with `Stream` object.

**Event associated with `disableWebcam()`:**

- Every Participant will receive a callback on [`onStreamDisabled()`](../../../api/sdk-reference/participant-class/participant-event-listener-class.md#onstreamenabled) of the [`Participant`](../../../api/sdk-reference/participant-class//introduction.md) with `Stream` object.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
  meeting!!.localParticipant.addEventListener(object : ParticipantEventListener() {
    override fun onStreamEnabled(stream: Stream) {
        //

        if(stream.getKind().equals("video")){
          //participant turned on video
          //Render participant video
        }
    }

    override fun onStreamDisabled(stream: Stream) {
        //

        if(stream.getKind().equals("video")){
          //participant turned off video
          //remove participant video
        }
    }
  });
```

</TabItem>

<TabItem value="Java">

```js
  participant.addEventListener(new ParticipantEventListener() {
    @Override
    public void onStreamEnabled(Stream stream) {
        //
        if(stream.getKind().equals("video")){
          //participant turned on video
          //Render participant video
        }
    }

    @Override
    public void onStreamDisabled(Stream stream) {
        //
        if(stream.getKind().equals("video")){
          //participant turned off video
          //remove participant video
        }
    }
  });
```

</TabItem>

</Tabs>


---

---
title: Custom Audio Track
hide_title: false
hide_table_of_contents: false
description: Custom Audio Track features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Custom Audio Track
pagination_label: Custom Audio Track
keywords:
  - Camera on
  - Camera off
  - Webcam on
  - Webcam off
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
---

import NoIndex from '../../../../../../mdx/\_no-index.mdx';

<NoIndex/>

# Custom Audio Track - Android

We have introduced the ability to pass a custom Audio track for the Audio of the participants. This feature can be used to add custom layers like background noise removal, echo cancellation, etc. on audio and send it to other participants.

## Creating a Custom Audio Track

- You can create a Audio Track using `createAudioTrack()` method of `VideoSDK`.
- This method can be used to create audio track using different encoding parameters and noise cancellation configuration.

### Parameters

- **encoderConfig**:

  - type: `String`
  - required: `true`
  - default: `speech_standard`
  - Allowed values : `speech_low_quality` | `speech_standard` | `music_standard` | `standard_stereo` | `high_quality` | `high_quality_stereo`
  - It will be the encoder configuration you want to use for Audio Track.

- **noiseConfig**

  - type: `JSONObject`
  - required: `true`

  - **acousticEchoCancellation**

    - type: `boolean`
    - required: `true`
    - If `true` echo cancellation will turned on else it would be turned off.

  - **autoGainControl**

    - type: `boolean`
    - required: `true`
    - If `true` auto gain will turned on else it would be turned off.

  - **noiseSuppression**
    - type: `boolean`
    - required: `true`
    - If `true` noise suppression will turned on else it would be turned off.

- **context**

  - type: `Context`
  - required: `true`
  - Pass the Android Context for this parameter.

#### Returns

- `CustomStreamTrack`

### Example

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
val noiseConfig = JSONObject()
try {
  noiseConfig.put("acousticEchoCancellation", true)
  noiseConfig.put("autoGainControl", true)
  noiseConfig.put("noiseSuppression", true)

  val audioCustomTrack: CustomStreamTrack = VideoSDK.createAudioTrack("high_quality", noiseConfig, this)
} catch (e: JSONException) {
   e.printStackTrace()
}
```

</TabItem>

<TabItem value="Java">

```js
JSONObject noiseConfig=new JSONObject();
try {
  noiseConfig.put("acousticEchoCancellation",true);
  noiseConfig.put("autoGainControl",true);
  noiseConfig.put("noiseSuppression",true);

  CustomStreamTrack audioCustomTrack=VideoSDK.createAudioTrack("high_quality", noiseConfig, this);
}catch (JSONException e) {
  e.printStackTrace();
}
```

</TabItem>

</Tabs>

## Using Custom Audio Track

### Custom Track while initializing the meeting

If you are passing `micEnabled: true` in the `initMeeting` of `VideoSDK` and want to use custom tracks from start of the meeting, you can pass custom track in the `initMeeting` as shown below.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
override fun onCreate(savedInstanceState: Bundle?) {
    //..

    val customTracks: MutableMap<String, CustomStreamTrack> = HashMap()
    val noiseConfig = JSONObject()
    try {
      noiseConfig.put("acousticEchoCancellation", true)
      noiseConfig.put("autoGainControl", true)
      noiseConfig.put("noiseSuppression", true)
    } catch (e: JSONException) {
       e.printStackTrace()
    }

    val audioCustomTrack: CustomStreamTrack = VideoSDK.createAudioTrack("high_quality", noiseConfig, this)
    customTracks["mic"] = audioCustomTrack  //Key must be "mic"

    // create a new meeting instance
    val meeting = VideoSDK.initMeeting(
      this@MainActivity,meetingId,participantName,
      //MicEnabled , If true, it will use the passed custom track to turn mic on
      true,
      //WebcamEnabled
      true,
      //multiStream
      false,
      //ParticipantId
      null,
      //Pass the custom tracks here
      customTracks
    )
}
```

</TabItem>

<TabItem value="Java">

```js
@Override
protected void onCreate(Bundle savedInstanceState) {
    //..

    Map<String, CustomStreamTrack> customTracks = new HashMap<>();

    JSONObject noiseConfig=new JSONObject();
    try {
      noiseConfig.put("acousticEchoCancellation",true);
      noiseConfig.put("autoGainControl",true);
      noiseConfig.put("noiseSuppression",true);
    }catch (JSONException e) {
      e.printStackTrace();
    }

    CustomStreamTrack audioCustomTrack = VideoSDK.createAudioTrack("high_quality", noiseConfig, this);
    customTracks.put("mic", audioCustomTrack);  //Key must be "mic"

    // create a new meeting instance
    Meeting meeting = VideoSDK.initMeeting(
        MainActivity.this, meetingId, participantName,
       //MicEnabled , If true, it will use the passed custom track to turn mic on
        true,
        //WebcamEnabled
        true,
        //multiStream
        false,
        //ParticipantId
        null,
        //Pass the custom tracks here
        customTracks
    );

}
```

</TabItem>

</Tabs>

### Custom Track with `unmuteMic()`

In order to switch tracks during the meeting, you have to pass the `CustomStreamTrack` in the `unmuteMic()` method of `Meeting`.

You can also pass custom track in `changeMic()` method of `Meeting`.

:::note

Make sure to call `muteMic()` before you create a new track as it may lead to unexpected behavior.

:::

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
val noiseConfig = JSONObject()
try {
  noiseConfig.put("acousticEchoCancellation", true)
  noiseConfig.put("autoGainControl", true)
  noiseConfig.put("noiseSuppression", true)

  val audioCustomTrack: CustomStreamTrack = VideoSDK.createAudioTrack("high_quality", noiseConfig, this)
  meeting!!.unmuteMic(audioCustomTrack)

  //or
  meeting!!.changeMic(AppRTCAudioManager.AudioDevice.BLUETOOTH, audioCustomTrack)
} catch (e: JSONException) {
  e.printStackTrace()
}

```

</TabItem>

<TabItem value="Java">

```js
JSONObject noiseConfig=new JSONObject();
try {
  noiseConfig.put("acousticEchoCancellation",true);
  noiseConfig.put("autoGainControl",true);
  noiseConfig.put("noiseSuppression",true);

  CustomStreamTrack audioCustomTrack = VideoSDK.createAudioTrack("high_quality", noiseConfig, this);
  meeting.unmuteMic(audioCustomTrack);

  //or
  meeting.changeMic(AppRTCAudioManager.AudioDevice.BLUETOOTH,audioCustomTrack);
}catch (JSONException e) {
  e.printStackTrace();
}

```

</TabItem>

</Tabs>


---

---
title: Custom Screen Share Track
hide_title: false
hide_table_of_contents: false
description: Custom Screen Share Track features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Custom Screen Share Track
pagination_label: Custom Screen Share Track
keywords:
  - Camera on
  - Camera off
  - Webcam on
  - Webcam off
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
---

import NoIndex from '../../../../../../mdx/\_no-index.mdx';

<NoIndex/>

# Custom Screen Share Track - Android

We have introduced the ability to pass a custom Screen Share track while sharing the screen of participants. This feature can be used to add custom video encoder config,background removal & video filter from external SDK(e.g., [Banuba](https://www.banuba.com/)) and send it to other participants.

## Creating a Custom Screen Share Track

- You can create a Screen Share track using `createScreenShareVideoTrack()` method of `VideoSDK`.
- This method can be used to create screen share track using different encoding parameters.

### Parameters

- **encoderConfig**:

  - type: `String`
  - required: `true`
  - default: `h720p_15fps`
  - Allowed values : `h360p_30fps` | `h720p_5fps` | `h720p_15fps` | `h1080p_15fps` | `h1080p_30fps`
  - It will be the encoderConfigs you can want to use for the Screen Share Track.

:::note

Above mentioned encoder configurations are valid for both, landscape as well as portrait mode.

:::

- **data**

  - type: `Intent`
  - required: `true`
  - It is Intent received from onActivityResult when user provide permission for ScreenShare.

- **context**

  - type: `Context`
  - required: `true`
  - Pass the Android Context for this parameter.

- **listener**
  - type: `CustomTrackListener`
  - required: `true`
  - Callback to this listener will be made when track is ready with CustomTrack as parameter.

### Example

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
// data is received from onActivityResult method.
VideoSDK.createScreenShareVideoTrack("h720p_5fps", data, this) { track ->
    meeting!!.enableScreenShare(track)
}
```

</TabItem>

<TabItem value="Java">

```javascript
// data is received from onActivityResult method.
VideoSDK.createScreenShareVideoTrack("h720p_5fps", data, this, (track)->{
    meeting.enableScreenShare(track);
});
```

</TabItem>

</Tabs>

## Using Custom Screen Share Track

### Custom Track with `enableScreenShare()`

In order to switch tracks during the meeting, you have to pass the `CustomStreamTrack` in the `enableScreenShare()` method of `Meeting`.

:::note

Make sure to call `disableScreenShare()` before you create a new track as it may lead to unexpected behavior.

:::

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
@TargetApi(21)
private fun askPermissionForScreenShare() {
    val mediaProjectionManager = application.getSystemService<Any>(
        Context.MEDIA_PROJECTION_SERVICE
    ) as MediaProjectionManager
    startActivityForResult(
        mediaProjectionManager.createScreenCaptureIntent(), CAPTURE_PERMISSION_REQUEST_CODE
    )
}

@RequiresApi(api = Build.VERSION_CODES.LOLLIPOP)
override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) {
    super.onActivityResult(requestCode, resultCode, data)
    if (requestCode != CAPTURE_PERMISSION_REQUEST_CODE) return
    if (resultCode == RESULT_OK) {
        VideoSDK.createScreenShareVideoTrack("h720p_5fps", data, this) { track ->
            meeting!!.enableScreenShare(track)
        }
    }
}

```

</TabItem>

<TabItem value="Java">

```javascript
@TargetApi(21)
private void askPermissionForScreenShare() {
    MediaProjectionManager mediaProjectionManager =
        (MediaProjectionManager) getApplication().getSystemService(
            Context.MEDIA_PROJECTION_SERVICE);
    startActivityForResult(
        mediaProjectionManager.createScreenCaptureIntent(), CAPTURE_PERMISSION_REQUEST_CODE);
}

@RequiresApi(api = Build.VERSION_CODES.LOLLIPOP)
@Override
public void onActivityResult(int requestCode, int resultCode, Intent data) {
    super.onActivityResult(requestCode, resultCode, data);
    if (requestCode != CAPTURE_PERMISSION_REQUEST_CODE)
        return;
    if (resultCode == Activity.RESULT_OK) {
        VideoSDK.createScreenShareVideoTrack("h720p_5fps", data, this, (track)->{
            meeting.enableScreenShare(track);
        });
    }
}

```

</TabItem>

</Tabs>


---

---
title: Custom Video Track
hide_title: false
hide_table_of_contents: false
description: Custom Video Track features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Custom Video Track
pagination_label: Custom Video Track
keywords:
  - Camera on
  - Camera off
  - Webcam on
  - Webcam off
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
---

import NoIndex from '../../../../../../mdx/\_no-index.mdx';

<NoIndex/>

# Custom Video Track - Android

We have introduced the ability to pass a custom video track for the video of the participants. This feature can be used to add custom video encoder config, video filter from external SDK(e.g., [Banuba](https://www.banuba.com/)) and send it to other participants.

## Creating a Custom Video Track

- You can create a Video Track using `createCameraVideoTrack()` method of `VideoSDK`.
- This method can be used to create video track using different encoding parameters & camera facing mode.

### Parameters

- **encoderConfig**:

  - type: `String`
  - required: `true`
  - default: `h480p_w640p`
  - Allowed values : `h144p_w176p` | `h240p_w320p` | `h480p_w640p` | `h480p_w720p` | `h720p_w960p` | `h1080p_w1440p` | `h720p_w1280p`
  - It will be the encoderConfigs you can want to use for the Video Track.

:::note

Above mentioned encoder configurations are valid for both, landscape as well as portrait mode.

:::

- **facingMode**:

  - type: `String`
  - required: `true`
  - Allowed values : `front` | `back`
  - It will specify wheater to use front or back camera for the video track.

- **context**:

  - type: `Context`
  - required: `true`
  - Pass the Android Context for this parameter.

- **multiStream**

  - type: `boolean`
  - required: `true`
  - default: true
  - It will specify if the stream should send multiple resolution layers or single resolution layer.

    :::info

    - For meetings with fewer than or equal to four participants, setting `multiStream:false` is regarded as best practice.
    - This parameter is only available from `v0.0.26`.

    :::

- **observer**:

  - type: `CapturerObserver`
  - required: `false`
  - If you want to use video filter from external SDK(e.g., [Banuba](https://www.banuba.com/)) then pass instance of `CapturerObserver` in this parameter.

:::note

For banuba integraion with videosdk.live android sdk,please visit [Banuba Intergation with Android-SDK](../../extras/banuba-integration.md)

:::

#### Returns

- `CustomStreamTrack`

### Example

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
val videoCustomTrack: CustomStreamTrack = VideoSDK.createCameraVideoTrack("h240p_w320p", "front", false, this)
```

</TabItem>

<TabItem value="Java">

```javascript
CustomStreamTrack customStreamTrack = VideoSDK.createCameraVideoTrack("h240p_w320p", "front", false, this);
```

</TabItem>

</Tabs>

## Using Custom Video Track

### Custom Track while initializing the meeting

If you are passing `webcamEnabled: true` in the `initMeeting` of `VideoSDK` and want to use custom tracks from start of the meeting, you can pass custom track in the `initMeeting` as shown below.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
override fun onCreate(savedInstanceState: Bundle?) {
    //..

    val customTracks: MutableMap<String, CustomStreamTrack> = HashMap()
    val videoCustomTrack: CustomStreamTrack =
    VideoSDK.createCameraVideoTrack("h240p_w320p", "back", false, this)
    customTracks["video"] = videoCustomTrack  //Key must be "video"

     // create a new meeting instance
    val meeting = VideoSDK.initMeeting(
      this@MainActivity, meetingId, participantName,
      //MicEnabled
      true,
      //WebcamEnabled , If true, it will use the passed custom track to turn webcam on
      true,
      //multiStream
      false,
      // ParticipantId
      null,
      //Pass the custom tracks here
      customTracks
    )
}
```

</TabItem>

<TabItem value="Java">

```js
@Override
protected void onCreate(Bundle savedInstanceState) {
    //..

    Map<String, CustomStreamTrack> customTracks = new HashMap<>();

    CustomStreamTrack videoCustomTrack = VideoSDK.createCameraVideoTrack("h240p_w320p", "back", false, this);
    customTracks.put("video", videoCustomTrack);  //Key must be "video"

    // create a new meeting instance
    Meeting meeting = VideoSDK.initMeeting(
        MainActivity.this, meetingId, participantName,
       //MicEnabled
        true,
        //WebcamEnabled , If true, it will use the passed custom track to turn webcam on
        true,
        //multiStream
        false,
        // ParticipantId
        null,
        //Pass the custom tracks here
        customTracks
        );
}
```

</TabItem>

</Tabs>

### Custom Track with `enableWebcam()`

In order to switch tracks during the meeting, you have to pass the `CustomStreamTrack` in the `enableWebcam()` method of `Meeting`.

:::note

Make sure to call `disableWebcam()` before you create a new track as it may lead to unexpected behavior.

:::

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
val customStreamTrack: CustomStreamTrack = VideoSDK.createCameraVideoTrack("h240p_w320p", "back", false, this)
meeting!!.enableWebcam(customStreamTrack)
```

</TabItem>

<TabItem value="Java">

```javascript
CustomStreamTrack customStreamTrack=VideoSDK.createCameraVideoTrack("h240p_w320p", "back", false, this);
meeting.enableWebcam(customStreamTrack);
```

</TabItem>

</Tabs>


---

---
sidebar_label: Error Event
pagination_label: Error Event
---

import NoIndex from '../../../../../mdx/\_no-index.mdx';

<NoIndex/>

# Error Event - Android

This event is helpful for development level troubleshooting while integrating SDK.

Whenever any invalid configuration provided or server/network errors arise, this event will trigger with a specific error code and message.

This event can ease your development process.

We have depicted a specific constant with code and message in the below table.

| Constant                      | Code | Message                                                                                                               |
| ----------------------------- | ---- | --------------------------------------------------------------------------------------------------------------------- |
| **INVALID_API_KEY**           | 4001 | `apikey` provided in the token is empty or invalid, please verify it on the dashboard.                                |
| **INVALID_TOKEN**             | 4002 | `token` is empty or invalid or might have expired.                                                                    |
| **INVALID_MEETING_ID**        | 4003 | `meetingId` is empty or invalid, please verify it or generate new meetingId using the API.                            |
| **INVALID_PARTICIPANT_ID**    | 4004 | `participantId` is empty or invalid, it shouldn't contain any whitespaces.                                            |
| **DUPLICATE_PARTICIPANT**     | 4005 | Leaving meeting, since this `participantId` joined from another device.                                               |
| **ACCOUNT_DEACTIVATED**       | 4006 | It seems your account is deactivated by VideoSDK for some reason, you can reach out to us at `support@videosdk.live`. |
| **ACCOUNT_DISCONTINUED**      | 4007 | Server will respond you with specific message.\_                                                                      |
| **INVALID_PERMISSIONS**       | 4008 | `permissions` provided in the token are invalid, please don't use `allow_join` or `allow_mod` with `ask_join`.        |
| **START_RECORDING_FAILED**    | 4011 | Recording start request failed due to an unknown error.                                                               |
| **STOP_RECORDING_FAILED**     | 4012 | Recording stop request failed due to an unknown error.                                                                |
| **START_LIVESTREAM_FAILED**   | 4013 | Livestream start request failed due to an unknown error.                                                              |
| **STOP_LIVESTREAM_FAILED**    | 4014 | Livestream stop request failed due to an unknown error.                                                               |
| **MAX_SPEAKER_LIMIT_REACHED_ON_ORGANIZATION**    | 4026 | You have reached max speaker limit on organization. To increase contact at support@videosdk.live".                                                               |
| **MAX_VIEWER_LIMIT_REACHED_ON_ORGANIZATION**    | 4027 | You have reached max viewer limit on organization. To increase contact at support@videosdk.live".                                                               |
| **MAX_RECORDING_LIMIT_REACHED_ON_ORGANIZATION**    | 4028 | You have reached max limit of recording on organization. To increase contact at support@videosdk.live.                                                               |
| **MAX_HLS_LIMIT_REACHED_ON_ORGANIZATION**    | 4029 | You have reached max limit of hls on organization. To increase contact at support@videosdk.live.                                                               |
| **MAX_LIVESTREAM_LIMIT_REACHED_ON_ORGANIZATION**    | 4030 | You have reached max limit of livestream on organization. To increase contact at support@videosdk.live.                                                               |
| **INVALID_LIVESTREAM_CONFIG** | 4015 | Livestream 'outputs' configuration provided was invalid.                                                              |
| **PREV_RECORDING_PROCESSING** | 4018 | Previous recording session is being processed, please try again after few seconds.                                    |
| **RECORDING_FAILED**          | 5001 | Recording stopped due to an unknown error.                                                                            |
| **LIVESTREAM_FAILED**         | 5002 | Livestream stopped due to an unknown error.                                                                           |

### Event Code

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
private val meetingEventListener: MeetingEventListener = object : MeetingEventListener() {
    //..
    override fun onError(error: JSONObject) {
    try {
        val errorCodes: JSONObject = VideoSDK.getErrorCodes()
        val code = error.getInt("code")
        if (code == errorCodes.getInt("START_LIVESTREAM_FAILED")) {
            Log.d("#error", "Error is: " + error["message"])
        } else if (code == errorCodes.getInt("START_RECORDING_FAILED")) {
            Log.d("#error", "Error is: " + error["message"])
        }
    } catch (e: Exception) {
            e.printStackTrace()
        }
    }
}
```

</TabItem>

<TabItem value="Java">

```js
private final MeetingEventListener meetingEventListener = new MeetingEventListener() {
    //..
    @Override
    public void onError(JSONObject error) {
        try {
            JSONObject errorCodes = VideoSDK.getErrorCodes();
            int code = error.getInt("code");
            if (code == errorCodes.getInt("START_LIVESTREAM_FAILED")) {
                Log.d("#error", "Error is: " + error.get("message"));
            }else if(code == errorCodes.getInt("START_RECORDING_FAILED"))
            {
                Log.d("#error", "Error is: " + error.get("message"));
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
};
```

</TabItem>

</Tabs>


---

---
title: External Call Detection Video & Audio Call - Video SDK Docs
hide_title: false
hide_table_of_contents: false
sidebar_label: External Call Detection
pagination_label: External Call Detection
keywords:
  - External Call Detection
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: external-call-detection
---

import NoIndex from '../../../../../mdx/\_no-index.mdx';

<NoIndex/>

# External Call Detection - Android

External call detection feature in VideoSDK let you know, participant is on the call during meeting.

Whenever local participant accept the incoming call or place outgoing call, `externalcall-started` event will trigger.`externalcall-started` event only received by localParticipant.

For example, the meeting is running with **Alice** and **Bob**. Whenever **Alice** receives the call or she call someone, **Alice** will receive `externalcall-started` event.

We can access `externalcall-started` event through [meeting object](/android/guide/video-and-audio-calling-api-sdk/features/start-join-meeting).

### externalcall-started Event

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
private val meetingEventListener: MeetingEventListener = object : MeetingEventListener() {
     // ...
    override fun onExternalCallStarted() {
      Log.d("#meeting", "onExternalCallAnswered")
    }
};
```

</TabItem>

<TabItem value="Java">

```js
private final MeetingEventListener meetingEventListener = new MeetingEventListener() {
     // ...
    @Override
    public void onExternalCallStarted() {
        Log.d("#meeting", "onExternalCallStarted");
    }
};
```

</TabItem>

</Tabs>


---

---
title: RTMP Live Social Media Video & Audio Call - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: RTMP Live Social Media features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Go Live On Social Media
pagination_label: Go Live On Social Media
keywords:
  - Facebook Live
  - Youtube Live
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: go-live-social-media
---

import NoIndex from '../../../../../mdx/\_no-index.mdx';

<NoIndex/>

# Go Live On Social Media - Android

This feature allows participant to broadcast meeting on various social media platforms such as Facebook or Youtube.
This guide will provide an overview of how participant can start and stop broadcasting meeting.

1. **Start LiveStream** - By using `startLivestream()` function, a participant can start broadcasting meeting on various platforms by provding url and stream keys as an argument.
2. **Stop LiveStream** - By using `stopLivestream()` function, a participant can stop broadcasting on all platforms.

### Start And Stop Live Stream

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
private val YOUTUBE_RTMP_URL: String? = null
private val YOUTUBE_RTMP_STREAM_KEY: String? = null

//
findViewById<View>(R.id.btnLivestream).setOnClickListener {
    if (!livestreaming) {
        if (YOUTUBE_RTMP_URL == null || YOUTUBE_RTMP_STREAM_KEY == null) {
            throw Error("RTMP url or stream key missing.")
        }
        val outputs: MutableList<LivestreamOutput> = ArrayList()
        outputs.add(LivestreamOutput(YOUTUBE_RTMP_URL, YOUTUBE_RTMP_STREAM_KEY))

        meeting!!.startLivestream(outputs)
    } else {
        meeting!!.stopLivestream()
    }
}
```

</TabItem>

<TabItem value="Java">

```js
private static final String YOUTUBE_RTMP_URL = null;
private static final String YOUTUBE_RTMP_STREAM_KEY = null;

//
findViewById(R.id.btnLivestream).setOnClickListener(view -> {
    if (!livestreaming) {
        if (YOUTUBE_RTMP_URL == null || YOUTUBE_RTMP_STREAM_KEY == null) {
            throw new Error("RTMP url or stream key missing.");
        }

        List<LivestreamOutput> outputs = new ArrayList<>();
        outputs.add(new LivestreamOutput(YOUTUBE_RTMP_URL, YOUTUBE_RTMP_STREAM_KEY));

        meeting.startLivestream(outputs);
    } else {
        meeting.stopLivestream();
    }
});
```

</TabItem>

</Tabs>

### Events

1. **livestream-started** - Whenever broadcasting of meeting started, `livestream-started` event will trigger.

2. **livestream-stopped** - Whenever broadcasting of meeting stopped, `livestream-stopped` event will trigger.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
object : MeetingEventListener() {
  override fun onLivestreamStarted() {
    livestreaming = true

    // TODO: show indication that meeting livestream is started.
  }

  override fun onLivestreamStopped() {
    livestreaming = false

    // TODO: show indication that meeting livestream is stopped.
  }

}
```

</TabItem>

<TabItem value="Java">

```js
new MeetingEventListener() {
  @Override
  public void onLivestreamStarted() {
      livestreaming = true;

      // TODO: show indication that meeting livestream is started.
  }

  @Override
  public void onLivestreamStopped() {
      livestreaming = false;

      // TODO: show indication that meeting livestream is stopped.
  }
}
```

</TabItem>

</Tabs>


---

---
title: Leave End Meeting Video & Audio Call - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: Leave or End Meeting features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Leave or End Meeting
pagination_label: Leave or End Meeting
keywords:
  - Exit Meeting
  - Leave Meeting
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: leave-end-meeting
---

import NoIndex from '../../../../../mdx/\_no-index.mdx';

<NoIndex/>

# Leave or End Meeting - Android

Whenever participant wishes to end their communication in the meeting, they can simply leave the meeting.

This guide will provide an overview of how to implement leave or end feature in VideoSDK meetings.

1. **Leave** - By using `leave()` function, only a participant will leave/exit the meeting, the rest of the meeting will continue with other participants.
2. **End** - By using `end()` function, meeting will end for each and every participant. So, use this function according to your use cases.

### Leave And End Meeting

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
  btnLeave!!.setOnClickListener { _: View? ->
    meeting!!.leave()
  }

  btnEnd!!.setOnClickListener { _: View? ->
    meeting!!.end()
  }
```

</TabItem>

<TabItem value="Java">

```js
  btnLeave.setOnClickListener(new View.OnClickListener() {
      @Override
      public void onClick(View v) {
        meeting.leave();
      }
  });

  btnEnd.setOnClickListener(new View.OnClickListener() {
      @Override
      public void onClick(View v) {
        meeting.end();
      }
  });
```

</TabItem>

</Tabs>

### Events

**Events associated with `leave()`:**

- Local participant will receive a callback on[`onMeetingLeft`](../../../api/sdk-reference/meeting-class/meeting-event-listener-class.md#onmeetingleft) of `Meeting`.
- All remote participants will receive a callback [`onParticipantLeft`](../../../api/sdk-reference/meeting-class/meeting-event-listener-class.md#onparticipantleft) with Participant object.

**Event associated with `end()`:**

- All remote participants and local participant will receive a callback on [`onParticipantLeft`](../../../api/sdk-reference/meeting-class/meeting-event-listener-class.md#onparticipantleft) with Participant object.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
private final MeetingEventListener meetingEventListener = new MeetingEventListener() {
  override fun onMeetingLeft() {
    Log.d("#meeting", "onMeetingleft()")
  }

  override fun onParticipantLeft(participant: Participant) {
    Log.d("#meeting", participant.displayName + " left");
  }
}
```

</TabItem>

<TabItem value="Java">

```javascript
private final MeetingEventListener meetingEventListener = new MeetingEventListener() {
  @Override
  public void onMeetingLeft() {
    Log.d("#meeting", "onMeetingleft()")
  }

  @Override
  public void onParticipantLeft(Participant participant) {
    Log.d("#meeting", participant.getDisplayName() + " left");
  }
}
```

</TabItem>

</Tabs>


---

---
title: Manage Participants Video & Audio Call - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: Manage Participants features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Manage Participants
pagination_label: Manage Participants
keywords:
  - Exit Meeting
  - Leave Meeting
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: manage-participants
---

import NoIndex from '../../../../../mdx/\_no-index.mdx';

<NoIndex/>

# Manage Participants - Android

## 1. Local Participant (self)

Local participant is used to consume your video & audio streams.
it contains information about local participant such as displayName, id, quality and streams Map.

You can acces localParticipant from the [meeting object](/android/guide/video-and-audio-calling-api-sdk/features/start-join-meeting#2-initialization).

### Participant object properties

| Property Name | Type          | Description                                            |
| ------------- | ------------- | ------------------------------------------------------ |
| id            | string        | Unique id of the participant.                          |
| displayName   | string        | The name you define during the meeting initialization. |
| local         | boolean       | Indicates the participant is local or not.             |
| quality       | string        | Indicates the participant streams quality.             |
| Streams       | Map of Stream | Returns Video & Audio Streams.                         |

### Stream Object properties

| Property Name | Type   | Description        |
| ------------- | ------ | ------------------ |
| id            | string | Unique id          |
| codec         | string | Video/Audio codec. |
| kind          | string | Stream Kind.       |
| track         | string | MediaStreamTrack   |

## 2. Other Participants (Except You)

Other participants Map is used to get all the participants (except you) in the meeting at any given time.

Other participants Map contains same properties as [LocalParticipant](/android/0.0.x/guide/video-and-audio-calling-api-sdk/features/manage-participants#participant-object-properties).

### Local And Other Participants

```xml title="activity_main.xml"
  <org.webrtc.SurfaceViewRenderer
      android:id="@+id/svrLocal"
      android:layout_width="80dp"
      android:layout_height="100dp"
      android:layout_gravity="end" />

  <androidx.recyclerview.widget.RecyclerView
      android:id="@+id/rvParticipants"
      android:layout_width="match_parent"
      android:layout_height="match_parent" />
```

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js title="MainActivity.kt"
  import org.webrtc.SurfaceViewRenderer;
  import org.webrtc.VideoTrack;

  private fun displayLocalParticipant() {
    var svrLocal: SurfaceViewRenderer = findViewById(R.id.btnScreenShare)

    // display local video when stream available
    meeting!!.localParticipant.addEventListener(
       object : ParticipantEventListener() {
         override fun onStreamEnabled(stream: Stream) {
           if (stream.kind.equals("video", ignoreCase = true)) {
             val videoTrack = stream.track as VideoTrack
             videoTrack.addSink(svrLocal)
            }
         }
      }
    )
  }

  private fun displayRemoteParticipants() {
    val rvParticipants = findViewById<RecyclerView>(R.id.rvParticipants)
    rvParticipants.layoutManager = GridLayoutManager(this, 2)
    rvParticipants.adapter = ParticipantAdapter(meeting!!)
  }

```

</TabItem>

<TabItem value="Java">

```js title="MainActivity.java"
  import org.webrtc.SurfaceViewRenderer;
  import org.webrtc.VideoTrack;

  private void displayLocalParticipant() {
    final SurfaceViewRenderer svrLocal = findViewById(R.id.svrLocal);

    // display local video when stream available
    meeting.getLocalParticipant().addEventListener(
        new ParticipantEventListener() {
          @Override
          public void onStreamEnabled(Stream stream) {
            if (stream.getKind().equalsIgnoreCase("video")) {
              VideoTrack track = (VideoTrack) stream.getTrack();
              track.addSink(svrLocal);
            }
          }
        }
      );
  }

  private void displayRemoteParticipants() {
    final RecyclerView rvParticipants = findViewById(R.id.rvParticipants);
    rvParticipants.setLayoutManager(new GridLayoutManager(this, 2));
    rvParticipants.setAdapter(new ParticipantAdapter(meeting));
  }

```

</TabItem>

</Tabs>

```xml title="item_remote_peer.xml"
<?xml version="1.0" encoding="utf-8"?>
<FrameLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="wrap_content">

    <org.webrtc.SurfaceViewRenderer
        android:id="@+id/svrParticipant"
        android:layout_width="match_parent"
        android:layout_height="match_parent" />

</FrameLayout>
```

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js title="ParticipantAdapter.kt"

class ParticipantAdapter(meeting: Meeting) : RecyclerView.Adapter<ParticipantAdapter.PeerViewHolder>() {
    private val participants: MutableList<Participant> = ArrayList()
    private var containerHeight = 0

    init {
        participants.add(meeting.localParticipant)
        meeting.addEventListener(object : MeetingEventListener() {
            override fun onParticipantJoined(participant: Participant) {
                participants.add(participant)
                notifyItemInserted(participants.size - 1)
            }

            override fun onParticipantLeft(participant: Participant) {
                // remove participant from grid
            }
        })
    }

    override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): PeerViewHolder {
        containerHeight = parent.height
        return PeerViewHolder(
            LayoutInflater.from(parent.context)
                .inflate(R.layout.item_remote_peer, parent, false)
        )
    }

    override fun onBindViewHolder(holder: PeerViewHolder, position: Int) {
        val participant = participants[position]

        val layoutParams = holder.itemView.layoutParams
        layoutParams.height = containerHeight / 3
        holder.itemView.layoutParams = layoutParams

        for ((_, stream) in participant.streams) {
            if (stream.kind.equals("video", ignoreCase = true)) {
                val videoTrack = stream.track as VideoTrack
                videoTrack.addSink(holder.svrParticipant)
                break
            }
        }

        participant.addEventListener(object : ParticipantEventListener() {
            override fun onStreamEnabled(stream: Stream) {
                if (stream.kind.equals("video", ignoreCase = true)) {
                    val videoTrack = stream.track as VideoTrack
                    videoTrack.addSink(holder.svrParticipant)
                }
            }
        })
    }

    override fun getItemCount(): Int {
        return participants.size
    }

    class PeerViewHolder(view: View) : RecyclerView.ViewHolder(view) {
        var svrParticipant: SurfaceViewRenderer = view.findViewById(R.id.svrParticipant)
        init{
            svrParticipant.init(PeerConnectionUtils.getEglContext(), null)
        }
    }
}

```

Please refer the [example code](https://github.com/videosdk-live/videosdk-rtc-android-kotlin-sdk-example) on Github for more details.

</TabItem>

<TabItem value="Java">

```js title="ParticipantAdapter.java"

public class ParticipantAdapter extends RecyclerView.Adapter<ParticipantAdapter.PeerViewHolder> {

    private final List<Participant> participants = new ArrayList<>();
    private int containerHeight;

    public ParticipantAdapter(Meeting meeting) {
        Handler mHandler = new Handler(Looper.getMainLooper());

        meeting.addEventListener(new MeetingEventListener() {
            @Override
            public void onParticipantJoined(Participant participant) {
                participants.add(participant);
                mHandler.post(() -> notifyItemInserted(participants.size() - 1));
            }

            @Override
            public void onParticipantLeft(Participant participant) {
                // remove participant from grid
            }
        });
    }

    @NonNull
    @Override
    public PeerViewHolder onCreateViewHolder(@NonNull ViewGroup parent, int viewType) {
        containerHeight = parent.getHeight();

        return new PeerViewHolder(LayoutInflater.from(parent.getContext())
                .inflate(R.layout.item_remote_peer, parent, false));
    }

    @Override
    public void onBindViewHolder(@NonNull PeerViewHolder holder, int position) {
        final Participant participant = participants.get(position);

        ViewGroup.LayoutParams layoutParams = holder.itemView.getLayoutParams();
        layoutParams.height = containerHeight / 3;
        holder.itemView.setLayoutParams(layoutParams);

        for (Map.Entry<String, Stream> entry : participant.getStreams().entrySet()) {
            Stream stream = entry.getValue();
            if (stream.getKind().equalsIgnoreCase("video")) {
                VideoTrack videoTrack = (VideoTrack) stream.getTrack();
                videoTrack.addSink(holder.svrParticipant);
                break;
            }
        }

        participant.addEventListener(new ParticipantEventListener() {
            @Override
            public void onStreamEnabled(Stream stream) {
                if (stream.getKind().equalsIgnoreCase("video")) {
                    VideoTrack videoTrack = (VideoTrack) stream.getTrack();
                    videoTrack.addSink(holder.svrParticipant);
                }
            }
        });

    }

    @Override
    public int getItemCount() {
        return participants.size();
    }

    static class PeerViewHolder extends RecyclerView.ViewHolder {
        public SurfaceViewRenderer svrParticipant;
        public View itemView;

        PeerViewHolder(@NonNull View view) {
            super(view);

            itemView = view;

            svrParticipant = view.findViewById(R.id.svrParticipant);
            svrParticipant.init(PeerConnectionUtils.getEglContext(), null);
        }
    }
}
```

Please refer the [example code](https://github.com/videosdk-live/videosdk-rtc-android-java-sdk-example/blob/master/app/src/main/java/live/videosdk/rtc/android/java) on Github for more details.

</TabItem>

</Tabs>

## 3. Participant Related Events

1. **onParticipantJoined** - Whenever any new participant join the meeting, `onParticipantJoined` event will trigger. For example, the meeting is running with **Alice** and **Bob**, then **Eve** join that meeting, after that `onParticipantJoined` event trigger and return the [participant object](/android/guide/video-and-audio-calling-api-sdk/features/manage-participants#participant-object-properties).

2. **onParticipantLeft** - Whenever any participant leave/exit the meeting, `onParticipantLeft` event will trigger.For example, the meeting is running with **Alice** and **Bob**, then **Bob** leave that meeting, after that `onParticipantLeft` event trigger and return the [participant object](/android/guide/video-and-audio-calling-api-sdk/features/manage-participants#participant-object-properties)

3. **onPresenterChanged** - Whenever any participant present/screenshare their screen/window in meeting, `onPresenterChanged` event will trigger and return the presenter `participantId`.

4. **onStreamEnabled** - Whenever any participant enabled mic/webcam in meeting, `onStreamEnabled` event will trigger and return [Stream](/android/guide/video-and-audio-calling-api-sdk/features/manage-participants#stream-object-properties).

5. **onStreamDisabled** - Whenever any participant disabled mic/webcam in meeting, `onStreamDisabled` event will trigger and return [Stream](/android/guide/video-and-audio-calling-api-sdk/features/manage-participants#stream-object-properties).

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
 meeting.addEventListener(object : MeetingEventListener() {
    override fun onParticipantJoined(participant: Participant) {
        participant.addEventListener(object : ParticipantEventListener() {
                override fun onStreamEnabled(stream: Stream) {
                    if (stream.kind.equals("video", ignoreCase = true)) {
                         // participant video enabled
                    } else if (stream.kind.equals("audio", ignoreCase = true)) {
                         // participant mic enabled
                    }
                }
                override fun onStreamDisabled(stream: Stream) {
                    if (stream.kind.equals("video", ignoreCase = true)) {
                         // participant video disabled
                    } else if (stream.kind.equals("audio", ignoreCase = true)) {
                        // participant mic disabled
                    }
                }
        })
    }

    override fun onParticipantLeft(participant: Participant) {
        Toast.makeText(this@MainActivity, participant.displayName + " left", Toast.LENGTH_SHORT).show()
    }

    override fun onPresenterChanged(presenterId: String) {
        Toast.makeText(this@MainActivity, presenterId + " started presenting", Toast.LENGTH_SHORT).show()
    }
 })
```

</TabItem>

<TabItem value="Java">

```js
 meeting.addEventListener(new MeetingEventListener() {
    @Override
    public void onParticipantJoined(Participant participant) {
      participant.addEventListener(new ParticipantEventListener() {
          @Override
          public void onStreamEnabled(Stream stream) {
              if (stream.getKind().equalsIgnoreCase("video")) {
                  // participant video enabled
              } else if (stream.getKind().equalsIgnoreCase("audio")) {
                  // participant mic enabled
              }
          }

          @Override
          public void onStreamDisabled(Stream stream) {
              if (stream.getKind().equalsIgnoreCase("video")) {
                  // participant video disabled
              } else if (stream.getKind().equalsIgnoreCase("audio")) {
                  // participant mic disabled
              }
          }
      });
    }

    @Override
    public void onParticipantLeft(Participant participant) {
      Toast
        .makeText(
          MainActivity.this,
          participant.getDisplayName() + " left",
          Toast.LENGTH_SHORT
        )
        .show();
    }
    @Override
    public void onPresenterChanged(String presenterId) {
      Toast
        .makeText(
          MainActivity.this,
          presenterId + " started presenting",
          Toast.LENGTH_SHORT
        )
        .show();
    }
 });
```

</TabItem>

</Tabs>


---

---
title: Mic Controls Video & Audio Call - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: Mic Controls features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Mic Controls
pagination_label: Mic Controls
keywords:
  - Mic on
  - Mic off
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: mic-controls
---

import NoIndex from '../../../../../mdx/\_no-index.mdx';

<NoIndex/>

# Mic Controls - Android

Whenever any participant wants to start / stop broadcasting their audio to other participant in meeting, they can simply do it with VideoSDK Meeting.

This guide will provide an overview of how to use enable and disable Mic in a meeting.

1. **Enable Mic** - By using `unmuteMic()` function, a participant can publish audio to other participants.
2. **Disable Mic** - By using `muteMic()` function, a participant can stop publishing audio to other participants.

### 1. Enable, Disable Mic

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
  private var micEnabled = false

  btnMic!!.setOnClickListener { _: View? ->
    // Toggle participant mic in meeting
     if (micEnabled) {
       meeting!!.muteMic()
       micEnabled=false
     } else {
      meeting!!.unmuteMic()
      micEnabled=true
     }
  }
```

</TabItem>

<TabItem value="Java">

```js
  private boolean micEnabled = false;

  btnMic.setOnClickListener(new View.OnClickListener() {
      @Override
      public void onClick(View v) {
          // Toggle participant mic in meeting
          if (micEnabled) {
              meeting.muteMic();
              micEnabled = false;
          } else {
              meeting.unmuteMic();
              micEnabled = true;
          }
      }
  });
```

</TabItem>

</Tabs>

### Events

**Event associated with `unmuteMic()`:**

- Every Participant will receive a callback on [`onStreamEnabled()`](../../../api/sdk-reference/participant-class/participant-event-listener-class.md#onstreamenabled) of the [`Participant`](../../../api/sdk-reference/participant-class//introduction.md) with `Stream` object.

**Event associated with `muteMic()`:**

- Every Participant will receive a callback on [`onStreamDisabled()`](../../../api/sdk-reference/participant-class/participant-event-listener-class.md#onstreamenabled) of the [`Participant`](../../../api/sdk-reference/participant-class//introduction.md) with `Stream` object.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
  meeting!!.localParticipant.addEventListener(object : ParticipantEventListener() {
    override fun onStreamEnabled(stream: Stream) {
        //
        if(stream.getKind().equals("audio")){
          //participant turned on audio
        }
    }

    override fun onStreamDisabled(stream: Stream) {
        //
        if(stream.getKind().equals("audio")){
          //participant turned off audio
        }
    }
  });
```

</TabItem>

<TabItem value="Java">

```js
  participant.addEventListener(new ParticipantEventListener() {
    @Override
    public void onStreamEnabled(Stream stream) {
        //
        if(stream.getKind().equals("audio")){
          //participant turned on audio
        }
    }

    @Override
    public void onStreamDisabled(Stream stream) {
        //
        if(stream.getKind().equals("audio")){
          //participant turned off audio
        }
    }
  });
```

</TabItem>

</Tabs>

### 2. Change Audio Device

#### Get all audio Devices

- By using `meeting.getMics()` function, a participant can get all the connected mics.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
  private fun getMics(): MutableSet<AppRTCAudioManager.AudioDevice>? {
    val mics= meeting!!.mics
    return mics  // returns all mics
  }
```

</TabItem>

<TabItem value="Java">

```js
  private Set<AppRTCAudioManager.AudioDevice> getMics() {
    Set<AppRTCAudioManager.AudioDevice> mics = meeting.getMics();
    return mics; // returns all mics
  }
```

</TabItem>

</Tabs>

#### Select audio Device

- Local participant can change the audio device using `changeMic(AppRTCAudioManager.AudioDevice device)` method of meeting class.

- Parameters that can be passed to `changeMic` are

  | Audio Devices                                | Usage                        |
  | -------------------------------------------- | ---------------------------- |
  | AppRTCAudioManager.AudioDevice.BLUETOOTH     | For Bluetooth Device.        |
  | AppRTCAudioManager.AudioDevice.WIRED_HEADSET | For Wired Handset Device.    |
  | AppRTCAudioManager.AudioDevice.SPEAKER_PHONE | For Inbuilt - Speaker Device |
  | AppRTCAudioManager.AudioDevice.EARPIECE      | For Earpiece Device          |

- When a Local participant changes the Mic, `AppRTCAudioManager.AudioManagerEvents()` is triggered which can be set to `Meeting` class by using `meeting.setAudioDeviceChangeListener()`

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js

  btnChangeMic!!.setOnClickListener { _: View? ->
  // Change Mic in Meeting
    meeting!!.changeMic(AppRTCAudioManager.AudioDevice.BLUETOOTH)
  }

  private fun setAudioDeviceListeners() {
    meeting!!.setAudioDeviceChangeListener(object : AudioManagerEvents {
      override fun onAudioDeviceChanged(
        selectedAudioDevice: AppRTCAudioManager.AudioDevice,
        availableAudioDevices: Set<AppRTCAudioManager.AudioDevice>
      ) {
          when (selectedAudioDevice) {
            AppRTCAudioManager.AudioDevice.BLUETOOTH ->
              Toast.makeText(this@MainActivity, "Selected AudioDevice: BLUETOOTH", Toast.LENGTH_SHORT).show()

            AppRTCAudioManager.AudioDevice.WIRED_HEADSET ->
              Toast.makeText(this@MainActivity, "Selected AudioDevice: WIRED_HEADSET", Toast.LENGTH_SHORT).show()

            AppRTCAudioManager.AudioDevice.SPEAKER_PHONE ->
              Toast.makeText(this@MainActivity, "Selected AudioDevice: SPEAKER_PHONE", Toast.LENGTH_SHORT).show()

            AppRTCAudioManager.AudioDevice.EARPIECE ->
              Toast.makeText(this@MainActivity, "Selected AudioDevice: EARPIECE", Toast.LENGTH_SHORT).show()
          }
        }
    })
  }

  override fun onCreate(savedInstanceState: Bundle?) {
       // ...
       setAudioDeviceListeners()
  }
```

</TabItem>

<TabItem value="Java">

```js

  btnChangeMic.setOnClickListener(new View.OnClickListener() {
      @Override
      public void onClick(View v) {
        // Change Mic in Meeting
        meeting.changeMic(AppRTCAudioManager.AudioDevice.BLUETOOTH);
      }
  });

  private void setAudioDeviceListeners() {
    meeting.setAudioDeviceChangeListener(new AppRTCAudioManager.AudioManagerEvents() {
         @Override
        public void onAudioDeviceChanged(AppRTCAudioManager.AudioDevice selectedAudioDevice, Set<AppRTCAudioManager.AudioDevice> availableAudioDevices) {
            switch (selectedAudioDevice) {
                case BLUETOOTH:
                  Toast.makeText(MainActivity.this, "Selected AudioDevice: BLUETOOTH", Toast.LENGTH_SHORT).show();
                  break;
                case WIRED_HEADSET:
                  Toast.makeText(MainActivity.this, "Selected AudioDevice: WIRED_HEADSET", Toast.LENGTH_SHORT).show();
                  break;
                case SPEAKER_PHONE:
                  Toast.makeText(MainActivity.this, "Selected AudioDevice: SPEAKER_PHONE", Toast.LENGTH_SHORT).show();
                  break;
                case EARPIECE:
                  Toast.makeText(MainActivity.this, "Selected AudioDevice: EARPIECE", Toast.LENGTH_SHORT).show();
                  break;
               }
        }
    });
  }

  @Override
    protected void onCreate(Bundle savedInstanceState) {
       // ...
       setAudioDeviceListeners();
    }
```

</TabItem>

</Tabs>

- To use Bluetooth device, you must declare `BLUETOOTH` permission in `AndroidManifest.xml` file.

```js
<manifest ... >

<!-- Needed to communicate with already-paired Bluetooth devices. (Legacy up to Android 11) -->
<uses-permission
    android:name="android.permission.BLUETOOTH"
    android:maxSdkVersion="30" />
<uses-permission
    android:name="android.permission.BLUETOOTH_ADMIN"
    android:maxSdkVersion="30" />

<!-- Needed to communicate with already-paired Bluetooth devices. (Android 12 upwards)-->
<uses-permission android:name="android.permission.BLUETOOTH_CONNECT" />

//...
</manifest>
```


---

---
title: Pause/Resume Video Stream - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: Pause/Resume Video Stream features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Pause/Resume Video Stream
pagination_label: Pause/Resume Video Stream
keywords:
  - pause/resume video stream
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: pause-resume-video-stream
---

import NoIndex from '../../../../../mdx/\_no-index.mdx';

<NoIndex/>

# Pause/Resume Video Stream - Android

Whenver you wish to stop/resume downlaod stream(webcam, screenShare and mic) of participant, you can simply do it by using `pause`, `resume` methods.

## Pause video stream

- `pause()` method is used for pause stream(webcam, screenShare and mic) of a particular participant.

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
  btnPause!!.setOnClickListener { _: View? ->
    for ((_, stream) in participant.streams) {
      stream.pause()
    }
  }
```

</TabItem>

<TabItem value="Java">

```js
  btnPause.setOnClickListener(new View.OnClickListener() {
      @Override
      public void onClick(View v) {
        for (Map.Entry<String, Stream> entry : participant.getStreams().entrySet()) {
                Stream stream = entry.getValue();
                stream.pause();
        }
      }
  });
```

</TabItem>

</Tabs>

## Resume video stream

- `resume()` method is used to resume stream(webcam, screenShare and mic) of a particular participant.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
  btnResume!!.setOnClickListener { _: View? ->
    for ((_, stream) in participant.streams) {
      stream.resume()
    }
  }
```

</TabItem>

<TabItem value="Java">

```js
  btnResume.setOnClickListener(new View.OnClickListener() {
      @Override
      public void onClick(View v) {
        for (Map.Entry<String, Stream> entry : participant.getStreams().entrySet()) {
            Stream stream = entry.getValue();
            stream.resume();
        }
      }
  });
```

</TabItem>

</Tabs>


---

---
sidebar_label: Send Message using PubSub
pagination_label: PubSub
---

import NoIndex from '../../../../../mdx/\_no-index.mdx';

<NoIndex/>

# PubSub - Android

PubSub feature allows the participant to send and receive messages of the topics which he has subscribed.

## Methods

### publish()

This method is use for publishing message of specific topic.

#### Syntax

```js
public void publish(String topic, String message, PubSubPublishOptions options)
```

| Parameter Name | Type                 | Description                                                                                                                                       |
| -------------- | -------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------- |
| topic          | String               | This should be the topic for which you are publishing a message.                                                                                  |
| message        | String               | This is the actual message, which will be published to participants, who had subscribed to a particular topic.                                    |
| options        | PubSubPublishOptions | This is an object of PubSubPublishOptions, which provides an option, such as `persist`, which persists message history for upcoming participants. |

#### Example

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
private fun sendMessage() {
  val options = PubSubPublishOptions()
  options.isPersist = true
  meeting!!.pubSub.publish("CHAT", "Hello from Android", options)
}
```

</TabItem>

<TabItem value="Java">

```js
protected void sendMessage() {
  PubSubPublishOptions options = new PubSubPublishOptions();
  options.setPersist(true);
  meeting.pubSub.publish("CHAT", "Hello from Android", options);
}
```

</TabItem>

</Tabs>

### subscribe()

This method is used to subscribe for particular topic. This method returns a list of messages which were sent earlier.

#### Syntax

```js
public List<PubSubMessage> subscribe(String topic, PubSubMessageListener listener)
```

| Parameter Name | Type                  | Description                                                                                                                                      |
| -------------- | --------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------ |
| topic          | String                | This should be the topic to be subscribed.                                                                                                       |
| listener       | PubSubMessageListener | This is an object of PubSubMessageListener, which listens for upcoming messages and calls onMessageReceived function, when new message received. |

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
var pubSubMessageListener =
  PubSubMessageListener { message ->
    // Logs new message
    Log.v("New Message Received", "Message : " + message.message)
  }

@Override
protected void onCreate(Bundle savedInstanceState) {
  //...

  // Subscribe for 'CHAT' topic
  val pubSubMessageList = meeting!!.pubSub.subscribe("CHAT", pubSubMessageListener)

  // Logs persisted message list
  for (message in pubSubMessageList) {
    Log.v("Message List: ", "Message : " + message.message)
  }
}
```

</TabItem>

<TabItem value="Java">

```js
PubSubMessageListener pubSubMessageListener = new PubSubMessageListener() {
  @Override
  public void onMessageReceived(PubSubMessage message) {
    // Logs new message
    Log.v("New Message Received", "Message : " + message.getMessage());
  }
};

@Override
protected void onCreate(Bundle savedInstanceState) {
  //...

  // Subscribe for 'CHAT' topic
  List<PubSubMessage> pubSubMessageList = meeting.pubSub.subscribe("CHAT",pubSubMessageListener);

  // Logs persisted message list
  for(PubSubMessage message : pubSubMessageList){
    Log.v("Message List: ", "Message : " + message.getMessage());
  }
}
```

</TabItem>

</Tabs>

### unsubscribe()

This method is used to unsubscribe the message topic.

#### Syntax

```js
public void unsubscribe(String topic, PubSubMessageListener listener)
```

| Parameter Name | Type                  | Description                                                                    |
| -------------- | --------------------- | ------------------------------------------------------------------------------ |
| topic          | String                | This should be the topic to be unsubscribed.                                   |
| listener       | PubSubMessageListener | This is an object of PubSubMessageListener, which was passed in `subscribe()`. |

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
fun unsubscribe() {
  // Unsubscribe 'CHAT' topic
  meeting!!.pubSub.unsubscribe("CHAT", pubSubMessageListener)
}
```

</TabItem>

<TabItem value="Java">

```js
public void unsubscribe(){
  // Unsubscribe 'CHAT' topic
  meeting.pubSub.unsubscribe("CHAT", pubSubMessageListener);
}
```

</TabItem>

</Tabs>

## Sample Code

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
package live.videosdk.rtc.android.kotlin

import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle
import android.view.View
import android.widget.EditText
import android.widget.Toast
import androidx.appcompat.widget.Toolbar
import androidx.recyclerview.widget.LinearLayoutManager
import androidx.recyclerview.widget.RecyclerView
import live.videosdk.rtc.android.Meeting
import live.videosdk.rtc.android.listeners.PubSubMessageListener
import live.videosdk.rtc.android.model.PubSubPublishOptions

class ChatActivity : AppCompatActivity() {

    // Meeting
    var meeting: Meeting? = null

    // PubSubMessageListener
    var pubSubMessageListener =
      PubSubMessageListener { message ->
        // Logs new message
        Log.v("New Message Received", "Message : " + message.message)
    }

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_chat)

        /**
         * Here, we have created 'MainApplication' class, which extends android.app.Application class.
         * It has Meeting property and getter and setter methods of Meeting property.
         * In your android manifest, you must declare the class implementing android.app.Application (add the android:name=".MainApplication" attribute to the existing application tag):
         * In MainActivity.kt, we have set Meeting property.
         *
         * For Example: (MainActivity.kt)
         * var meeting = VideoSDK.initMeeting(context, meetingId, ParticipantName, micEnabled, webcamEnabled,multiStream,paricipantId,customTrack)
         * (this.application as MainApplication).meeting = meeting
        */

        // Get Meeting
        meeting = (this.application as MainApplication).meeting

        // Subscribe for 'CHAT' topic
        val pubSubMessageList = meeting!!.pubSub.subscribe("CHAT", pubSubMessageListener)

        for (message in pubSubMessageList) {
          // Logs persisted messages
           Log.v("Message List: ", "Message : " + message.message)
        }

        sendMessage()
    }

    private fun sendMessage() {
      val options = PubSubPublishOptions()
      options.isPersist = true
      meeting!!.pubSub.publish("CHAT", "Hello from Android", options)
    }

    override fun onDestroy() {
      // Unsubscribe for 'CHAT' topic
      meeting!!.pubSub.unsubscribe("CHAT", pubSubMessageListener)
      super.onDestroy()
    }
}
```

</TabItem>

<TabItem value="Java">

```js
package live.videosdk.rtc.android.java;

import androidx.appcompat.app.AppCompatActivity;
import android.os.Bundle;
import android.util.Log;
import java.util.List;
import live.videosdk.rtc.android.Meeting;
import live.videosdk.rtc.android.lib.PubSubMessage;
import live.videosdk.rtc.android.listeners.PubSubMessageListener;
import live.videosdk.rtc.android.model.PubSubPublishOptions;

public class ChatActivity extends AppCompatActivity {

    // Meeting
    Meeting meeting;

    // PubSubMessageListener
    private PubSubMessageListener pubSubMessageListener = new PubSubMessageListener() {
      @Override
      public void onMessageReceived(PubSubMessage message) {
          // Logs new message
          Log.v("New Message Received : ", "Message : " + message.getMessage());
      }
    };

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_chat);

        /**
         * Here, we have created 'MainApplication' class, which extends android.app.Application class.
         * It has Meeting property and getter and setter methods of Meeting property.
         * In your android manifest, you must declare the class implementing android.app.Application (add the android:name=".MainApplication" attribute to the existing application tag):
         * In MainActivity.java, we have set Meeting property.
         *
         * For Example: (MainActivity.java)
         * Meeting meeting = VideoSDK.initMeeting(context, meetingId, ParticipantName, micEnabled, webcamEnabled,multiStream,participantId,customTrack);
         * ((MainApplication) this.getApplication()).setMeeting(meeting);
        */

        // Get Meeting
        meeting = ((MainApplication) this.getApplication()).getMeeting();

        // Subscribe for 'CHAT' topic
        List<PubSubMessage> pubSubMessageList = meeting.pubSub.subscribe("CHAT", pubSubMessageListener);
        for(PubSubMessage message : pubSubMessageList){
            // Logs persisted messages
            Log.v("Message List : ", "Message : " + message.getMessage());
        }

        sendMessage();
    }

    protected void sendMessage() {
      PubSubPublishOptions publishOptions = new PubSubPublishOptions();
      publishOptions.setPersist(true);
      meeting.pubSub.publish("CHAT", "Hello from Android", publishOptions);
    }

    @Override
    protected void onDestroy() {
      // Unsubscribe for 'CHAT' topic
      meeting.pubSub.unsubscribe("CHAT", pubSubMessageListener);
      super.onDestroy();
    }
}
```

</TabItem>

</Tabs>


---

---
title: Record Meeting Video & Audio Call - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: Record Meeting features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Record Meeting
pagination_label: Record Meeting
keywords:
  - Start Recording meeting
  - Stop Recording meeting
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: recording-meeting
---

import NoIndex from '../../../../../mdx/\_no-index.mdx';

<NoIndex/>

# Record Meeting - Android

Record meeting allows participants to record video & audio during the meeting. The recording files are available in developer dashboard.
Any participant can start / stop recording any time during the meeting.

This guide will provide an overview of how to implement start and stop Meeting Recording.

1. **Start Recording** - By using `startRecording()` function, a participant can start meeting recording.
2. **Stop Recording** - By using `stopRecording()` function, a participant can stop meeting recording.

### Start And Stop Recording

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
// TODO: change webhookUrl
val webhookUrl = "<webhook-url-here>"

// keep track of recording
val recording = false

findViewById<View>(R.id.btnRecording).setOnClickListener { view: View? ->
    if (!recording) {
        meeting!!.startRecording(webhookUrl)
    } else {
        meeting!!.stopRecording()
    }
}
```

</TabItem>

<TabItem value="Java">

```js
// TODO: change webhookUrl
String webhookUrl = "<webhook-url-here>";

// keep track of recording
boolean recording = false;

findViewById(R.id.btnRecording).setOnClickListener(view -> {
    if (!recording) {
        meeting.startRecording(webhookUrl);
    } else {
        meeting.stopRecording();
    }
});
```

</TabItem>

</Tabs>

### Events

1. **recording-started** - Whenever any participant start meeting recording, then `recording-started` event will trigger.

2. **recording-stopped** - Whenever any participant stop meeting recording, then `recording-stopped` event will trigger.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
object : MeetingEventListener() {
  override fun onRecordingStarted() {
    recording = true

    // TODO: show indication that meeting recording is started.
  }

  override fun onRecordingStopped() {
    recording = false

    // TODO: show indication that meeting recording is stopped.
  }

}
```

</TabItem>

<TabItem value="Java">

```js
new MeetingEventListener() {
  @Override
  public void onRecordingStarted() {
      recording = true;

      // TODO: show indication that meeting recording is started.
  }

  @Override
  public void onRecordingStopped() {
      recording = false;

      // TODO: show indication that meeting recording is stopped.
  }
}
```

</TabItem>

</Tabs>


---

---
title: Share your Screen Video & Audio Call - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: Share your Screen features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Share Your Screen
pagination_label: Share Your Screen
keywords:
  - Start Screen share
  - Stop Screen share
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: screenshare
---

import NoIndex from '../../../../../mdx/\_no-index.mdx';

<NoIndex/>

# Share Your Screen - Android

- Whenever any participant wants to share a complete screen of mobile, they can simply do it with VideoSDK Meeting.

- This guide will provide an overview of how to enable or disable Screen Share in a meeting.

## How Screen share works?

- The following diagram shows flow of the screen sharing in android using VideoSDK:

<div style={{textAlign: 'center'}}>

![VideoSDK Android Screenshare Flow Diagram](/img/android/screenshare/flow_diagram.png)

</div>

## Enable Screen Share

- A participant’s Screen share stream is provided via the `MediaProjection` API. This API is only compatible with `Build.VERSION_CODES.LOLLIPOP` or higher.

- Get an instance of the `MediaProjectionManager` and Call the `createScreenCaptureIntent()` method in an activity. This initiates a prompt dialog for the user to confirm screen projection.

- One will get a prompt dialog like this:

<div style={{textAlign: 'center'}}>

<img
src={require('/img/android/screenshare/user_permission.jpg').default}
alt="user permission"
width="450"
/>

</div>

<br/>

- After permission is received from the user, call `meeting.enableScreenShare()` method.

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
private fun enableScreenShare() {
    val mediaProjectionManager = application.getSystemService(
        MEDIA_PROJECTION_SERVICE
    ) as MediaProjectionManager
    startActivityForResult(
        mediaProjectionManager.createScreenCaptureIntent(), CAPTURE_PERMISSION_REQUEST_CODE
    )
}

public override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) {
    super.onActivityResult(requestCode, resultCode, data)
    if (requestCode != CAPTURE_PERMISSION_REQUEST_CODE) return
    if (resultCode == RESULT_OK) {
        meeting!!.enableScreenShare(data)
    }
}
```

</TabItem>

<TabItem value="Java">

```js
private void enableScreenShare() {
    MediaProjectionManager mediaProjectionManager =
        (MediaProjectionManager) getApplication().getSystemService(
            Context.MEDIA_PROJECTION_SERVICE);
    startActivityForResult(
        mediaProjectionManager.createScreenCaptureIntent(), CAPTURE_PERMISSION_REQUEST_CODE);
}

@Override
public void onActivityResult(int requestCode, int resultCode, Intent data) {
    super.onActivityResult(requestCode, resultCode, data);
    if (requestCode != CAPTURE_PERMISSION_REQUEST_CODE)
        return;
    if (resultCode == Activity.RESULT_OK) {
        meeting.enableScreenShare(data);
    }
}
```

</TabItem>

</Tabs>

### Customise notification

- When a presenter starts screen share, presenter will receive a notification with a pre-defined title and message.

- Notification with pre-defined title and message will look like this:

<div style={{textAlign: 'center'}}>

<img
src={require('/img/android/screenshare/notification.jpg').default}
alt="notification"
width="450"
/>

</div>

- You can Customise those title, message and icon as per your requirements using `<meta-data>` specified in `app/src/main/AndroidManifest.xml`.

```js
<application>
  <meta-data
    android:name="notificationTitle"
    android:value="@string/notificationTitle"
  />
  <meta-data
    android:name="notificationContent"
    android:value="@string/notificationContent"
  />
  <meta-data
    android:name="notificationIcon"
    android:resource="@mipmap/ic_launcher_round"
  />
</application>
```

## Disable Screen Share

By using `meeting.disableScreenShare()` function, a participant can stop publishing screen stream to other participants.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
private fun disableScreenShare() {
    meeting!!.disableScreenShare()
}
```

</TabItem>

<TabItem value="Java">

```js
private void disableScreenShare(){
    meeting.disableScreenShare();
}
```

</TabItem>

</Tabs>

## Display Screen Share Stream

#### Local Participant

When a Local participant share the screen, `onStreamEnabled()` of `ParticipantEventListener` is triggered with the `Stream` which can be added to a `SurfaceViewRenderer`.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
override fun onCreate(savedInstanceState: Bundle?) {
    //...
    svrShare!!.init(PeerConnectionUtils.getEglContext(), null)
}

private fun setLocalListeners() {
    meeting!!.localParticipant.addEventListener(object : ParticipantEventListener() {
        override fun onStreamEnabled(stream: Stream) {
           if (stream.kind.equals("share", ignoreCase = true)) {
                // display share video
                val videoTrack = stream.track as VideoTrack
                videoTrack.addSink(svrShare)
            }
        }
        override fun onStreamDisabled(stream: Stream) {
            if (stream.kind.equals("share", ignoreCase = true)) {
               val track: VideoTrack? = stream.track as VideoTrack
               track?.removeSink(svrShare)
               svrShare!!.clearImage()
            }
        }
    });
}
```

</TabItem>

<TabItem value="Java">

```js
@Override
protected void onCreate(Bundle savedInstanceState) {
    //...
    svrShare.init(PeerConnectionUtils.getEglContext(), null);
}

private void setLocalListeners() {
    meeting.getLocalParticipant().addEventListener(new ParticipantEventListener() {
        @Override
        public void onStreamEnabled(Stream stream) {
            if (stream.getKind().equalsIgnoreCase("share")) {
                // display share video
                VideoTrack videoTrack = (VideoTrack) stream.getTrack();
                videoTrack.addSink(svrShare);
            }
        }
        @Override
        public void onStreamDisabled(Stream stream) {
            if (stream.getKind().equalsIgnoreCase("share")) {
                VideoTrack track = (VideoTrack) stream.getTrack();
                if (track != null) track.removeSink(svrShare);
                svrShare.clearImage();
            }
        }
    });
}
```

</TabItem>

</Tabs>

#### Other Participants

When other participant(Except you) share their screen, `onPresenterChanged()` in the `MeetingEventListener` is triggered with the `participantId` of the screen share.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
override fun onCreate(savedInstanceState: Bundle?) {
    //...
    svrShare!!.init(PeerConnectionUtils.getEglContext(), null)
}

private val meetingEventListener: MeetingEventListener = object : MeetingEventListener() {
    override fun onPresenterChanged(participantId: String) {
        updatePresenter(participantId)
    }
}

//Getting the stream from the participantId
private fun updatePresenter(participantId: String?) {
    // find participant
    val participant = meeting!!.participants.get(participantId) ?: return

    // find share stream in participant
    var shareStream: Stream? = null
    for (stream: Stream in participant.streams.values) {
        if ((stream.kind == "share")) {
            shareStream = stream
            break
        }
    }
    if (shareStream == null) return

    // display share video
    val videoTrack = shareStream.track as VideoTrack
    videoTrack.addSink(svrShare)

    // listen for share stop event
    participant.addEventListener(object : ParticipantEventListener() {
        override fun onStreamDisabled(stream: Stream) {
            if ((stream.kind == "share")) {
                val track: VideoTrack? = stream.track as VideoTrack
                track?.removeSink(svrShare)

                svrShare!!.clearImage()
            }
        }
    })
}
```

</TabItem>

<TabItem value="Java">

```js
@Override
protected void onCreate(Bundle savedInstanceState) {
    //...
    svrShare.init(PeerConnectionUtils.getEglContext(), null);
}

private final MeetingEventListener meetingEventListener = new MeetingEventListener() {
    //Triggered when Presenter changes
    @Override
    public void onPresenterChanged(String participantId) {
        updatePresenter(participantId);
    }
};

//Getting the stream from the participantId
private void updatePresenter(String participantId) {
    // find participant
    Participant participant = meeting.getParticipants().get(participantId);
    if (participant == null) return;

    // find share stream in participant
    Stream shareStream = null;
    for (Stream stream: participant.getStreams().values()) {
        if (stream.getKind().equals("share")) {
            shareStream = stream;
            break;
        }
    }
    if (shareStream == null) return;

    // display share video
    VideoTrack videoTrack = (VideoTrack) shareStream.getTrack();
    videoTrack.addSink(svrShare);

    // listen for share stop event
    participant.addEventListener(new ParticipantEventListener() {
        @Override
        public void onStreamDisabled(Stream stream) {
            if (stream.getKind().equals("share")) {
                VideoTrack track = (VideoTrack) stream.getTrack();
                if (track != null) track.removeSink(svrShare);

                svrShare.clearImage();
            }
        }
    });
}
```

</TabItem>

</Tabs>


---

---
title: Set Participant Video Quality - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: Set Participant Video Quality features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Set Participant Video Quality
pagination_label: Set Participant Video Quality
keywords:
  - set video quality
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: set-participant-video-quality
---

import NoIndex from '../../../../../mdx/\_no-index.mdx';

<NoIndex/>

# Set Participant Video Quality - Android

This feature allows participants to set other participant's video quality during the meeting.

## Set Quality

- `setQuality` method will accept `low`, `med` or `high` as string parameter.

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
private fun setQuality()
{
  val participants: Iterator<Participant> = meeting!!.participants.values.iterator()
  for (i in 0 until meeting!!.participants.size) {
    val participant = participants.next()

    participant.quality = "low"
    //or
    participant.quality = "med"
    //or
    participant.quality = "high"
  }
}
```

</TabItem>

<TabItem value="Java">

```js
private void setQuality() {
  final Iterator<Participant> participants = meeting.getParticipants().values().iterator();

  for (int i = 0; i < meeting.getParticipants().size(); i++) {
    Participant participant = participants.next();

    participant.setQuality("low");
    //or
    participant.setQuality("med");
    //or
    participant.setQuality("high");
  }
}
```

</TabItem>

</Tabs>


---

---
title: Set Viewport
hide_title: false
hide_table_of_contents: false
sidebar_label: Set Viewport
pagination_label: Set Viewport
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: set-viewport
---

import NoIndex from '../../../../../mdx/\_no-index.mdx';

<NoIndex/>

# Set Viewport - Android

When you are working with Video Calling, video quality is the most important part of communication. When a participant is shown on the screen, consuming multiple high quality although not required, will result in more memory and CPU usage of the device, eventually degrading quality.

The way to optimze around these situation is to consume the video quality which is required to fit the view of a particular participant, resulting in better quality, less usage of network bandwith and providing a better experience.

Viewport is the size of window or visible area in which video for the participant is shown. We can optimize the consuming video quality based on the viewport size of the participant. For example if the viewport size of a particular participant view is `480x360`, VideoSDK will download a `480x360` stream. If a participant on screen is present in bigger size, VideoSDK will provide a higher quality video for that particular participant only.

import ReactPlayer from 'react-player'

<div style={{textAlign: 'center'}}>

<ReactPlayer autoplay muted loop playing url='/img/viewport_illustration.mp4' width={"100%"}/>

</div>

### setViewPort()

`setViewPort()` can be used to achieve the best optimization of the video. This method is called with the `width` and `height` of the participant view on the `Participant` object and VideoSDK will handle the rest.

##### Parameters

- `width`

  - type: `int`
  - Width of the participant view for which the quliaty of video is to be adjusted.

- `height`
  - type: `int`
  - Height of the participant view for which the quliaty of video is to be adjusted.

### Example

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
class ParticipantAdapter(meeting: Meeting) : RecyclerView.Adapter<ParticipantAdapter.PeerViewHolder() {

  //Your variables here

  override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): PeerViewHolder {
    containerHeight = parent.height
    return PeerViewHolder(
      LayoutInflater.from(parent.context)
        .inflate(R.layout.item_remote_peer, parent, false)
    )
  }

  override fun onBindViewHolder(holder: PeerViewHolder, position: Int) {
    val participant = participants[position]

    //View updates here

    //Update Consuming quality using setViewPort
    participant.setViewPort(holder.itemView.getWidth(), holder.itemView.getHeight());
  }
}

```

</TabItem>

<TabItem value="Java">

```js

public class ParticipantAdapter extends RecyclerView.Adapter<ParticipantAdapter.PeerViewHolder> {

  //Your variables here

  @NonNull
  @Override
  public PeerViewHolder onCreateViewHolder(@NonNull ViewGroup parent, int viewType) {
    containerHeight = parent.getHeight();

    return new PeerViewHolder(LayoutInflater.from(parent.getContext())
            .inflate(R.layout.item_remote_peer, parent, false));
  }

  @Override
  public void onBindViewHolder(@NonNull PeerViewHolder holder, int position) {
    final Participant participant = participants.get(position);

    //View updates here

    //Update Consuming quality using setViewPort
    participant.setViewPort(holder.itemView.getWidth(), holder.itemView.getHeight());
  }
}

```

</TabItem>

</Tabs>

The complete usage of this method can be seen here in the [code sample](https://github.com/videosdk-live/videosdk-rtc-android-java-sdk-example/blob/master/app/src/main/java/live/videosdk/rtc/android/java/ParticipantAdapter.java#L134)


---

---
title: Speaker Indication Video & Audio Call - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: Speaker Indication features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Speaker Indication
pagination_label: Speaker Indication
keywords:
  - Active Speaker
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: speaker-indication
---

import NoIndex from '../../../../../mdx/\_no-index.mdx';

<NoIndex/>

# Speaker Indication - Android

Speaker indication feature in VideoSDK let you know, which participant is active speaker in a meeting.

Whenever any participant speaks in meeting, `onSpeakerChanged` event will trigger.

For example, the meeting is running with **Alice** and **Bob**. Whenever any of them speaks, `onSpeakerChanged` event will trigger and return the speaker `participantId`.

We can access `onSpeakerChanged` event through [meeting object](../../../api/sdk-reference/meeting-class/introduction.md).

### onSpeakerChanged Event

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
private val meetingEventListener: MeetingEventListener = object : MeetingEventListener() {
     // ...
    override fun onSpeakerChanged(participantId: String?) {
        Toast.makeText(this@MainActivity, "active Speaker Id" + participantId, Toast.LENGTH_SHORT).show();
        super.onSpeakerChanged(participantId)
    }
};
```

</TabItem>

<TabItem value="Java">

```js
private final MeetingEventListener meetingEventListener = new MeetingEventListener() {
     // ...
    @Override
    public void onSpeakerChanged(String participantId) {
        Toast.makeText(MainActivity.this, "active Speaker Id" + participantId, Toast.LENGTH_SHORT).show();
        super.onSpeakerChanged(participantId);
    }
};
```

</TabItem>

</Tabs>


---

---
title: Start join Meeting Video & Audio Call - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: Start or join Meeting features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Start or Join Meeting
pagination_label: Start or Join Meeting
keywords:
  - Join audio calling
  - Join video calling
  - Join real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: start-join-meeting
---

import NoIndex from '../../../../../mdx/\_no-index.mdx';

<NoIndex/>

# Start or Join Meeting - Android

<div style={{display:'flex',flexDirection:'row',alignItems:'stretch',}}>
<div style={{}}>
<p>After the successful installation of VideoSDK, the next step is to integrate VideoSDK features with your webApp/MobileApp.</p>

<p>To Communicate with other participant's audio or video call, you will need to join the meeting.</p>

<p>This guide will provide an overview of how to configure, initialize and join a VideoSDK meeting.</p>

</div>
<div>
<img src="/img/gif/new-meeting.gif"/>
</div>

</div>

## 1. Configuration

To configure a meeting, you will need [generated token](/android/0.0.x/guide/video-and-audio-calling-api-sdk/server-setup) and [meetingId](/api-reference/realtime-communication/create-room), we had discussed in [Server Setup](/android/guide/video-and-audio-calling-api-sdk/server-setup).
This code snippet calls API from local server

**Scenario 1** - Suppose you **don't have** any meetingId, you can simply generate meetingId by invoking `create-meeting` API.

**Scenario 2** - Suppose you **have** meetingId, now you don't have to call `create-meeting` API to generate meetingId, instead you can call `validate-meeting` API to validate meetingId.

**Token generation API is necessary for both scenario.**

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
package live.videosdk.rtc.android.java;

import com.androidnetworking.AndroidNetworking;
import com.androidnetworking.error.ANError;
import com.androidnetworking.interfaces.JSONObjectRequestListener;
import org.json.JSONException;
import org.json.JSONObject;

class JoinActivity : AppCompatActivity() {
  private val apiServerUrl = "http://localhost:9000"

  // ...
  // onCreate() and other methods
  private fun getToken(@Nullable meetingId: String?) {
    AndroidNetworking
      .get("$apiServerUrl/get-token")
      .build()
      .getAsJSONObject(
        object : JSONObjectRequestListener {
          override fun onResponse(response: JSONObject) {
            try
            {
              token = response.getString("token")
              if (meetingId == null) {
                createMeeting(token)
              } else {
                joinMeeting(token, meetingId)
              }
            } catch (e: JSONException) {
              e.printStackTrace()
            }
          }

          override fun onError(anError: ANError) {
            anError.printStackTrace()
          }
        }
      )
  }

  private fun createMeeting(token: String) {
    AndroidNetworking
      .post("$apiServerUrl/create-meeting")
      .addBodyParameter("token", token)
      .build()
      .getAsJSONObject(
        object : JSONObjectRequestListener {
          override fun onResponse(response: JSONObject) {
            try {
              // final String meetingId = response.getString("meetingId");

              // Intent intent = new Intent(JoinActivity.this, MainActivity.class);
              // intent.putExtra("token", token);
              // intent.putExtra("meetingId", meetingId);

              // startActivity(intent);
            } catch (e: JSONException) {
                e.printStackTrace()
            }
          }

          override fun onError(anError: ANError) {
            anError.printStackTrace()
          }
        }
      )
  }

  private fun joinMeeting(token: String, meetingId: String) {
    AndroidNetworking
      .post("$apiServerUrl/validate-meeting/{meetingId}")
      .addPathParameter("meetingId", meetingId)
      .addBodyParameter("token", token)
      .build()
      .getAsJSONObject(
        object : JSONObjectRequestListener {
          override fun onResponse(response: JSONObject) {
            // Intent intent = new Intent(JoinActivity.this, MainActivity.class);
            // intent.putExtra("token", token);
            // intent.putExtra("meetingId", meetingId);

            // startActivity(intent);
          }

          override fun onError(anError: ANError) {
            anError.printStackTrace()
          }
        }
      )
  }
}

```

</TabItem>

<TabItem value="Java">

```js
package live.videosdk.rtc.android.java;

import com.androidnetworking.AndroidNetworking;
import com.androidnetworking.error.ANError;
import com.androidnetworking.interfaces.JSONObjectRequestListener;
import org.json.JSONException;
import org.json.JSONObject;

public class JoinActivity extends AppCompatActivity {
  private String apiServerUrl = "http://localhost:9000";

  // ...
  // onCreate() and other methods

  private void getToken(@Nullable String meetingId) {
    AndroidNetworking
      .get(apiServerUrl + "/get-token")
      .build()
      .getAsJSONObject(
        new JSONObjectRequestListener() {
          @Override
          public void onResponse(JSONObject response) {
            try {
              String token = response.getString("token");

              if (meetingId == null) {
                createMeeting(token);
              } else {
                joinMeeting(token, meetingId);
              }
            } catch (JSONException e) {
              e.printStackTrace();
            }
          }

          @Override
          public void onError(ANError anError) {
            anError.printStackTrace();
          }
        }
      );
  }

  private void createMeeting(String token) {
    AndroidNetworking
      .post(apiServerUrl + "/create-meeting")
      .addBodyParameter("token", token)
      .build()
      .getAsJSONObject(
        new JSONObjectRequestListener() {
          @Override
          public void onResponse(JSONObject response) {
            try {
              // final String meetingId = response.getString("meetingId");

              // Intent intent = new Intent(JoinActivity.this, MainActivity.class);
              // intent.putExtra("token", token);
              // intent.putExtra("meetingId", meetingId);

              // startActivity(intent);
            } catch (JSONException e) {
              e.printStackTrace();
            }
          }

          @Override
          public void onError(ANError anError) {
            anError.printStackTrace();
          }
        }
      );
  }

  private void joinMeeting(String token, String meetingId) {
    AndroidNetworking
      .post(apiServerUrl + "/validate-meeting/{meetingId}")
      .addPathParameter("meetingId", meetingId)
      .addBodyParameter("token", token)
      .build()
      .getAsJSONObject(
        new JSONObjectRequestListener() {
          @Override
          public void onResponse(JSONObject response) {
            // Intent intent = new Intent(JoinActivity.this, MainActivity.class);
            // intent.putExtra("token", token);
            // intent.putExtra("meetingId", meetingId);

            // startActivity(intent);
          }

          @Override
          public void onError(ANError anError) {
            anError.printStackTrace();
          }
        }
      );
  }
}

```

</TabItem>

</Tabs>

## 2. Initialization

<div style={{display:'flex',flexDirection:'row',alignItems:'stretch',}}>
<div style={{}}>
<p>
After configuration, you will have to Initialize 
<p>
meeting by providing name, meetingId, micEnabled, webcamEnabled & maxResolution.
</p>
</p>

<p>
NOTE : For React & React native developer, you have

<p>to be familiar with hooks concept. You can understand hooks concept on <a href={'https://reactjs.org/docs/hooks-intro.html'}>React Hooks</a>.</p>

</p>
</div>
<div>
<img src="/img/gif/add-participant.gif"/>
</div>

</div>

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
import live.videosdk.rtc.android.VideoSDK;
import live.videosdk.rtc.android.Meeting;

class MainActivity : AppCompatActivity() {
  private var meeting: Meeting? = null

  override fun onCreate(savedInstanceState: Bundle?) {
    // Configure parameters
    val token = intent.getStringExtra("token")
    val meetingId = intent.getStringExtra("meetingId")
    val participantName = "John Doe"
    val micEnabled = true
    val webcamEnabled = true
    val multiStream = false
    val paticipantId="demo@123"  // If you passed `null` then SDK will create an Id by itself and will use that id.

    // Configure authentication token
    VideoSDK.config(token)

    // create a new meeting instance
    meeting = VideoSDK.initMeeting(
      this@MainActivity,
      meetingId,
      participantName,
      micEnabled,
      webcamEnabled,
      multiStream,
      paticipantId,
      null
    )
  }
}

```

</TabItem>

<TabItem value="Java">

```js
import live.videosdk.rtc.android.VideoSDK;
import live.videosdk.rtc.android.Meeting;

public class MainActivity extends AppCompatActivity {
    private Meeting meeting;

    @Override
    protected void onCreate(Bundle savedInstanceState) {

        // Configure parameters
        final String token = getIntent().getStringExtra("token");
        final String meetingId = getIntent().getStringExtra("meetingId");
        final String participantName = "John Doe";
        final boolean micEnabled = true;
        final boolean webcamEnabled = true;
        final boolean multiStream = false;
        final String participantId = "demo@123"; // If you passed `null` then SDK will create an Id by itself and will use that id.

        // Configure authentication token
        VideoSDK.config(token);

        // create a new meeting instance
        meeting = VideoSDK.initMeeting(
                MainActivity.this,
                meetingId,
                participantName,
                micEnabled,
                webcamEnabled,
                multiStream,
                participantId,
                null
        );
    }
}

```

</TabItem>

</Tabs>

## 3. Join

<div style={{display:'flex',flexDirection:'row',alignItems:'stretch',}}>
<div style={{}}>
<p>
After configuration & initialization, the third step is to call join() to join a meeting.
</p>

<p>
After joining, you will be able to Manage Participant in a meeting.
</p>

</div>
<div>
<img src="/img/gif/join-meeting.gif"/>
</div>

</div>

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
// After receiving mic and webcam access permissions
// join the meeting
meeting!!.join()
```

</TabItem>

<TabItem value="Java">

```js
// After receiving mic and webcam access permissions
// join the meeting
meeting.join();
```

</TabItem>

</Tabs>

## Events

Following events are emitted on the `meeting` when it is successfully joined.

- Local Participant will receive a [`onMeetingJoined`](../../../api/sdk-reference/meeting-class/meeting-event-listener-class.md#onmeetingjoined) event when successfully joined.
- Remote Participant will receive a [`onParticipantJoined`](../../../api/sdk-reference/meeting-class/meeting-event-listener-class.md#onparticipantjoined) event with the newly joined [`Participant`](../../../api/sdk-reference/participant-class/introduction.md) object from the event callback.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
private final MeetingEventListener meetingEventListener = new MeetingEventListener() {
  override fun onMeetingJoined() {
    Log.d("#meeting", "onMeetingJoined()")
  }

  override fun onParticipantJoined(participant: Participant) {
    Log.d("#meeting", participant.displayName + " left");
  }
}
```

</TabItem>

<TabItem value="Java">

```javascript
private final MeetingEventListener meetingEventListener = new MeetingEventListener() {

  @Override
  public void onMeetingJoined() {
    Log.d("#meeting", "onMeetingJoined()");
  }

  @Override
  public void onParticipantJoined(Participant participant) {
    Log.d("#meeting", participant.getDisplayName() + " left");
  }
}
```

</TabItem>

</Tabs>


---

---
title: Toggle Participant Media
hide_title: false
hide_table_of_contents: false
description: Camera Controls features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Toggle Participant Media
pagination_label: Toggle Participant Media
keywords:
  - Camera on
  - Camera off
  - Webcam on
  - Webcam off
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: toggle-participant-media
---

import NoIndex from '../../../../../mdx/\_no-index.mdx';

<NoIndex/>

# Toggle Participant Media - Android

Control other participant's webcam and mic.
For better idea, let's understand this with a real case scenario

**Scenario 1 (Online Class)** - In this scenario, the lecturer(Local Participant) will control the student's(Other Participant) webcam and mic as per his/her needs.

**Scenario 2 (Online Events)** - In this scenario, the event hosts will control the audience webcam and mic when someone wants to speak.

This guide will provide an overview of how to control other participant webcam and mic in a meeting.

1. **Enable Webcam of Participant** - By using `enableWebcam()` function, a `onWebcamRequested` event will trigger on requested participant side.

   **Example** : Meeting is running with **User A** and **User B**. Now **User A** wants to Enable Webcam of **User B**, so **User A** will use `enableWebcam()` function to request **User B**, after that **User B** recieve the `onWebcamRequested` event, from there user can either accept or reject the incoming request.

2. **Disable Webcam of Participant** - By using `disableWebcam()` function, webcam of that participant will be turned off.

   **Example** : **User A** wants to Disable Webcam of **User B**, so **User A** will use `disableWebcam()` function to Disable it without any request.

3. **Enable Mic of Participant** - By using `enableMic()` function, a `onMicRequested` event will trigger on requested participant side.

   **Example** : Meeting is running with **User A** and **User B**. Now **User A** wants to Enable Mic of **User B**, so **User A** will use `enableMic()` function to request **User B**, after that **User B** will receive the `onMicRequested` event, from there user can either accept or reject the incoming request.

4. **Disable Mic of Participant** - By using `disableMic()` function, Mic of that participant will disable.

   **Example** : **User A** wants to Disable Mic of **User B**, so **User A** will use `disableMic()` function to Disable it without any request.

:::note

To achieve this feature, you need to pass `allow_join` persmission while genearting token for meeting initialization. After that you will be able to access participant media methods.

[How to apply permission while generating token?](/android/0.0.x/guide/video-and-audio-calling-api-sdk/server-setup)

:::

### Request Media Methods

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
val participant = meeting!!.participants.get("<participant-id>")

// This will emit an event called "onWebcamRequested" to that particular participant
participant.enableWebcam()

// This will directly disable webcam of particular participant
participant.disableWebcam()

// This will emit an event called "onMicRequested" to that particular participant
participant.enableMic()

// This will directly disable mic of particular participant
participant.disableMic()
```

</TabItem>

<TabItem value="Java">

```js
Participant participant = meeting.getParticipants().get("<participant-id>");

// This will emit an event called "onWebcamRequested" to that particular participant
participant.enableWebcam();

// This will directly disable webcam of particular participant
participant.disableWebcam();

// This will emit an event called "onMicRequested" to that particular participant
participant.enableMic();

// This will directly disable mic of particular participant
participant.disableMic();
```

</TabItem>

</Tabs>

### Manage Requested Media Events

1. **onWebcamRequested** - This event will be emitted to the participant `B` when any other participant `A` requests to enable webcam of that participant `B`. This event handler will receieve following three arguments:

   - `accept()` - Callback function to accept the request.
   - `reject()` - Callback function to reject the request.

<div style={{height: "10px"}}></div>

2. **onMicRequested** - This event will be emitted to the participant `B` when any other participant `A` requests to enable mic of that participant `B`. This event handler will receieve following three arguments:

   - `accept()` - Callback function to accept the request.
   - `reject()` - Callback function to reject the request.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
object : MeetingEventListener() {
  override fun onMicRequested(participantId: String, listener: MicRequestListener) {
      // TODO: show dialog before accepting request
      listener.accept()
  }

  override fun onWebcamRequested(participantId: String, listener: WebcamRequestListener) {
      // TODO: show dialog before accepting request
      listener.accept()
  }
}
```

</TabItem>

<TabItem value="Java">

```js
new MeetingEventListener() {
  @Override
  public void onMicRequested(String participantId, MicRequestListener listener) {
      // TODO: show dialog before accepting request
      listener.accept();
  }

  @Override
  public void onWebcamRequested(String participantId, WebcamRequestListener listener) {
      // TODO: show dialog before accepting request
      listener.accept();
  }
}
```

</TabItem>

</Tabs>


---

---
title: Get Started with Video & Audio Call - Video SDK Documentation
hide_title: true
hide_table_of_contents: false
description: Video SDK enables the opportunity to integrate native IOS, Android & Web SDKs to add live video & audio conferencing to your applications.
sidebar_label: Getting Started
pagination_label: Getting Started
keywords:
  - audio calling
  - video calling
  - real-time communication
  - collaboration
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: getting-started
---

import Mermaid from '@theme/Mermaid';
import GettingStarted from '/mdx/introduction/\_getting-started.mdx';
import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>
<GettingStarted title="Get Started with Android" />

## Steps

import Card from '@theme/Card';

<div class="container guide-steps-block">
  <div class="row ">
    <div class="col col--6">
      <Card heading="1. Get your API key and Secret" link="/android/guide/video-and-audio-calling-api-sdk/signup-and-create-api" description="Generate your API key and Secret from Video SDK." />
    </div>
     <div class="col col--6">
      <Card heading="2. Client Setup for Android" link="/android/guide/video-and-audio-calling-api-sdk/android-sdk" description="Easy to integrate SDK with cross-channel support." />
    </div>
  </div>
  <div class="row ">
   <div class="col col--6" >
      <Card heading="3. Authentication and Tokens" link="/android/guide/video-and-audio-calling-api-sdk/server-setup" description="Setup secured server authentication and authorization."  />
    </div>
    <div class="col col--6">
      <Card heading="4. Start a Audio / Video Call" link="/android/guide/video-and-audio-calling-api-sdk/quick-start" description="Get started with step by step guide of integrating Video SDK." />
    </div>
  </div>
  <div class="row ">
   <div class="col col--6" >
      <Card heading="5. Basic Features" link="/android/guide/video-and-audio-calling-api-sdk/features/start-join-meeting" description="Explore basic features such as join, leave and customise sessions."  />
    </div>
    <div class="col col--6">
      <Card heading="6. Advanced Features" link="/android/guide/video-and-audio-calling-api-sdk/features/error-event" description="Explore advanced features such as screen sharing, recording and live streaming." />
    </div>
  </div>
</div>

## Architecture

This diagram demonstrates end-to-end flow to implement video & audio calling, record calls and go-live on social media.

![Video-sdk-architecture!](/img/video-sdk-archietecture.svg)


---

---
title: Quick Start with Android
hide_title: false
hide_table_of_contents: false
description: Video SDK enables the opportunity to integrate native IOS, Android & Web SDKs to add live video & audio conferencing to your applications.
sidebar_label: Start a Audio / Video Call
pagination_label: Quick Start with Android
keywords:
  - audio calling
  - video calling
  - real-time communication
  - collaboration
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: quick-start
---

import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>

# Quick Start

VideoSDK enables the opportunity to integrate video & audio calling to Web, Android, IOS applications. it provides Programmable SDKs and REST APIs to build up scalable video conferencing applications.

This guide will get you running with the VideoSDK video & audio calling in minutes.

## Prerequisites

Before proceeding, ensure that your development environment meets the following requirements:

- Java Development Kit.
- Android Studio 3.0 or later.
- Android SDK API Level 18 or higher.
- A mobile device that runs Android 4.3 or later.

:::important

One should have a VideoSDK account to generate token.
Visit VideoSDK **[dashboard](https://app.videosdk.live/api-keys)** to generate token

:::

## Getting Started with the Code!

Follow the steps to add Video Call into your app.

### Create new Android Project

For a new project in **Android Studio**, create a **Phone and Tablet** Android project with an **Empty Activity**.

![VideoSDK Android Quick Start New Project](/img/quick-start/android_newProject.png)

:::caution
After creating the project, Android Studio automatically starts gradle sync. Ensure that the sync succeeds before you continue.
:::

### Integrate Video SDK

- If your Android Studio Version is older than Android Studio Bumblebees, add the repository to project's `build.gradle` file.
- If your are using Android Studio Bumblebees or newer Version, add the repository to `settings.gradle` file.

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="2021.1.1"
groupId={"android-studio-version"}
values={[{label: 'Android Studio Version < 2021.1.1', value: '<2021.1.1'},{label: 'Android Studio Version 2021.1.1', value: '2021.1.1'},]}>

<TabItem value="<2021.1.1">

```js title="build.gradle"
allprojects {
  repositories {
    // ...
    maven { url 'https://jitpack.io' }
    jcenter()
  }
}
```

</TabItem>

<TabItem value="2021.1.1">

```js title="settings.gradle"
dependencyResolutionManagement{
  repositories {
    // ...
    maven { url 'https://jitpack.io' }
    jcenter()
  }
}
```

</TabItem>

</Tabs>

- Add the following dependency in your app's `app/build.gradle`.

```js title="app/build.gradle"
dependencies {
  implementation 'live.videosdk:android-sdk:0.0.26'

  // library to perform Network call to generate a meeting id
  implementation 'com.amitshekhar.android:android-networking:1.0.2'

  // other app dependencies
  }
```

### Add permissions into your project

- In `/app/Manifests/AndroidManifest.xml`, add the following permissions after `</application>`.

```xml title="AndroidManifest.xml"
<uses-permission android:name="android.permission.RECORD_AUDIO" />
<uses-permission android:name="android.permission.INTERNET" />
<uses-permission android:name="android.permission.READ_PHONE_STATE" />
<uses-permission android:name="android.permission.CAMERA" />

<!-- Needed to communicate with already-paired Bluetooth devices. (Legacy up to Android 11) -->
<uses-permission
    android:name="android.permission.BLUETOOTH"
    android:maxSdkVersion="30" />
<uses-permission
    android:name="android.permission.BLUETOOTH_ADMIN"
    android:maxSdkVersion="30" />

<!-- Needed to communicate with already-paired Bluetooth devices. (Android 12 upwards)-->
<uses-permission android:name="android.permission.BLUETOOTH_CONNECT" />

```

### Structure of the project

Your project structure should look like this.

```jsx title="Project Structure"
   app
   ├── java
   │    ├── packagename
   │         ├── JoinActivity.java
   │         ├── MainApplication.java
   │         ├── MeetingActivity.java
   │         ├── ParticipantAdapter.java
   ├── res
   │    ├── layout
   │    │    ├── activity_join.xml
   │    │    ├── activity_meeting.xml
   │    │    ├── item_remote_peer.xml
```

:::note

You have to set JoinActivity as Launcher activity.

:::

### App Architecture

<div style={{textAlign: 'center'}}>

![VideoSDK Android Quick Start App Structure](/img/quick-start/android_AppStructure.jpg)

</div>

### Step 1: Initialize VideoSDK

1. Create `MainApplication` class which will extend the `android.app.Application`.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js title="MainApplication.kt"
import live.videosdk.rtc.android.VideoSDK

class MainApplication : Application() {
    override fun onCreate() {
        super.onCreate()
        VideoSDK.initialize(applicationContext)
    }
}
```

</TabItem>

<TabItem value="Java">

```java title="MainApplication.java"
import android.app.Application;
import live.videosdk.rtc.android.VideoSDK;

public class MainApplication extends Application {
    @Override
    public void onCreate() {
      super.onCreate();
      VideoSDK.initialize(getApplicationContext());
    }
}
```

</TabItem>

</Tabs>

2. Add `MainApplication` to `AndroidManifest.xml`

```xml title="AndroidManifest.xml"
<application
    android:name=".MainApplication" >
   <!-- ... -->
</application>
```

### Step 2: Creating Joining Screen

#### Creating UI

The Joining screen will include :

1. **Create Button** - This button will create a new meeting for you.
2. **TextField for Meeting Id** - This text field will contain the meeting Id you want to join.
3. **Join Button** - This button will join the meeting with `meetingId` you provided.

In `/app/res/layout/activity_join.xml` file, replace the content with the following.

```xml title="activity_join.xml"
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
  xmlns:tools="http://schemas.android.com/tools"
  android:layout_width="match_parent"
  android:layout_height="match_parent"
  android:gravity="center"
  android:orientation="vertical"
  tools:context=".JoinActivity">
  <Button
    android:id="@+id/btnCreateMeeting"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:layout_marginBottom="16dp"
    android:text="Create Meeting" />
  <TextView
    style="@style/TextAppearance.AppCompat.Headline"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:text="OR" />
  <com.google.android.material.textfield.TextInputLayout
    style="@style/Widget.MaterialComponents.TextInputLayout.OutlinedBox"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:layout_marginVertical="16dp"
    android:hint="Enter Meeting ID">
    <EditText
      android:id="@+id/etMeetingId"
      android:layout_width="250dp"
      android:layout_height="wrap_content"
      android:textColor="@color/white" />
  </com.google.android.material.textfield.TextInputLayout>
  <Button
    android:id="@+id/btnJoinMeeting"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:text="Join Meeting" />
</LinearLayout>
```

#### Integration of Create Meeting API

1. Declare the variables `sampleToken` which will hold the generated token from the [VideoSDK dashboard](https://app.videosdk.live/api-keys). This token will use in VideoSDK config as well as generating meetingId.

**Note** : This generated token is only valid for ten minutes, if you want to regenerate you can do it as well by clicking the same link.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js title="JoinActivity.kt"
//Replace with the token you generated from the VideoSDK Dashboard
var sampleToken = "";
```

</TabItem>

<TabItem value="Java">

```java title="JoinActivity.java"
//Replace with the token you generated from the VideoSDK Dashboard
String sampleToken = "";
```

</TabItem>

</Tabs>

2. On **Join Button** `onClick` events, we will naviagte to `MeetingActivity` with token and meetingId.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js title="JoinActivity.kt"
class JoinActivity : AppCompatActivity() {
   override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_join)

        val btnCreate = findViewById<Button>(R.id.btnCreateMeeting)
        val btnJoin = findViewById<Button>(R.id.btnJoinMeeting)
        val etMeetingId = findViewById<EditText>(R.id.etMeetingId)

        btnCreate.setOnClickListener { v: View? ->
            // we will explore this method in the next step
            createMeeting(sampleToken)
        }
        btnJoin.setOnClickListener { v: View? ->
            val intent = Intent(this@JoinActivity, MeetingActivity::class.java)
            intent.putExtra("token", sampleToken)
            intent.putExtra("meetingId", etMeetingId.text.toString())
            startActivity(intent)
        }
    }

    private fun createMeeting(token: String) {
    }
}
```

</TabItem>

<TabItem value="Java">

```java title="JoinActivity.java"
public class JoinActivity extends AppCompatActivity {
  @Override
  protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_join);

    final Button btnCreate = findViewById(R.id.btnCreateMeeting);
    final Button btnJoin = findViewById(R.id.btnJoinMeeting);
    final EditText etMeetingId = findViewById(R.id.etMeetingId);

    btnCreate.setOnClickListener(v -> {
      // we will explore this method in the next step
      createMeeting(sampleToken);
    });

    btnJoin.setOnClickListener(v -> {
      Intent intent = new Intent(JoinActivity.this, MeetingActivity.class);
      intent.putExtra("token", sampleToken);
      intent.putExtra("meetingId", etMeetingId.getText().toString());
      startActivity(intent);
    });
  }

  private void createMeeting(String token) {
  }
}
```

</TabItem>

</Tabs>

3. For **Create Button**, under `createMeeting` method we will gnerate meetingId by calling API and navigate to `MeetingActivity` with token and generated meetingId.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js title="JoinActivity.kt"
class JoinActivity : AppCompatActivity() {
  //...onCreate
 private fun createMeeting(token: String) {
        AndroidNetworking.post("https://api.videosdk.live/v2/rooms")
            .addHeaders("Authorization", token)
            .build()
            .getAsJSONObject(object : JSONObjectRequestListener {
                override fun onResponse(response: JSONObject) {
                    try {
                        val meetingId = response.getString("roomId")
                        val intent = Intent(this@JoinActivity, MeetingActivity::class.java)
                        intent.putExtra("token", sampleToken)
                        intent.putExtra("meetingId", meetingId)
                        startActivity(intent)
                    } catch (e: JSONException) {
                        e.printStackTrace()
                    }
                }

                override fun onError(anError: ANError) {
                    anError.printStackTrace()
                    Toast.makeText(
                        this@JoinActivity, anError.message,
                        Toast.LENGTH_SHORT
                    ).show()
                }
            })
    }
}
```

</TabItem>

<TabItem value="Java">

```java title="JoinActivity.java"
public class JoinActivity extends AppCompatActivity {
  //...onCreate

  private void createMeeting(String token) {
    // we will make an API call to VideoSDK Server to get a meetingId
    AndroidNetworking.post("https://api.videosdk.live/v2/rooms")
      .addHeaders("Authorization", token) //we will pass the token in the Headers
      .build()
      .getAsJSONObject(new JSONObjectRequestListener() {
        @Override
        public void onResponse(JSONObject response) {
          try {
            // resposne will contain `roomId`
            final String meetingId = response.getString("roomId");

            // starting the MeetingActivity with recieved meetingId and our sampleToken
            Intent intent = new Intent(JoinActivity.this, MeetingActivity.class);
            intent.putExtra("token", sampleToken);
            intent.putExtra("meetingId", meetingId);
            startActivity(intent);
          } catch (JSONException e) {
            e.printStackTrace();
          }
        }

        @Override
        public void onError(ANError anError) {
          anError.printStackTrace();
          Toast.makeText(JoinActivity.this, anError.getMessage(), Toast.LENGTH_SHORT).show();
        }
    });
  }
}
```

</TabItem>

</Tabs>

4. Our App is completely based on audio and video commutation, that's why we need to ask for runtime permissions `RECORD_AUDIO` and `CAMERA`. So, we will implement permission logic on `JoinActivity`.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js title="JoinActivity.kt"
class JoinActivity : AppCompatActivity() {
    companion object {
        private const val PERMISSION_REQ_ID = 22
        private val REQUESTED_PERMISSIONS = arrayOf(
            Manifest.permission.RECORD_AUDIO,
            Manifest.permission.CAMERA
        )
    }

  private fun checkSelfPermission(permission: String, requestCode: Int): Boolean {
        if (ContextCompat.checkSelfPermission(this, permission) !=
            PackageManager.PERMISSION_GRANTED)
        {
            ActivityCompat.requestPermissions(this, REQUESTED_PERMISSIONS, requestCode)
            return false
        }
        return true
    }

  override fun onCreate(savedInstanceState: Bundle?) {
    //... button listeneres
    checkSelfPermission(REQUESTED_PERMISSIONS[0], PERMISSION_REQ_ID)
    checkSelfPermission(REQUESTED_PERMISSIONS[1], PERMISSION_REQ_ID)
  }
}
```

</TabItem>

<TabItem value="Java">

```java title="JoinActivity.java"
public class JoinActivity extends AppCompatActivity {
  private static final int PERMISSION_REQ_ID = 22;

  private static final String[] REQUESTED_PERMISSIONS = {
    Manifest.permission.RECORD_AUDIO,
    Manifest.permission.CAMERA
  };

  private boolean checkSelfPermission(String permission, int requestCode) {
    if (ContextCompat.checkSelfPermission(this, permission) != PackageManager.PERMISSION_GRANTED) {
      ActivityCompat.requestPermissions(this, REQUESTED_PERMISSIONS, requestCode);
      return false;
    }
    return true;
  }

  @Override
  protected void onCreate(Bundle savedInstanceState) {
    //... button listeneres
    checkSelfPermission(REQUESTED_PERMISSIONS[0], PERMISSION_REQ_ID);
    checkSelfPermission(REQUESTED_PERMISSIONS[1], PERMISSION_REQ_ID);
  }
}
```

</TabItem>

</Tabs>

#### Output

<div style={{textAlign: 'center'}}>

![VideoSDK Android Quick Start joining Screen](/img/quick-start/android-join-screen.jpg)

</div>

### Step 3: Creating Meeting Screen

Create a new Activity named `MeetingActivity`.

#### Creating the UI for Meeting Screen

In `/app/res/layout/activity_meeting.xml` file, replace the content with the following.

```xml title="activty_meeting.xml"
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:gravity="center"
    android:orientation="vertical"
    tools:context=".MainActivity">

    <TextView
        android:id="@+id/tvMeetingId"
        style="@style/TextAppearance.AppCompat.Display1"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Hello World!" />

    <androidx.recyclerview.widget.RecyclerView
        android:id="@+id/rvParticipants"
        android:layout_width="match_parent"
        android:layout_height="0dp"
        android:layout_weight="1" />

    <LinearLayout
        android:layout_width="wrap_content"
        android:layout_height="wrap_content">

        <Button
            android:id="@+id/btnMic"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:layout_marginVertical="8dp"
            android:text="Mic"/>

        <Button
            android:id="@+id/btnLeave"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:layout_marginVertical="8dp"
            android:layout_marginHorizontal="8dp"
            android:text="Leave"/>

        <Button
            android:id="@+id/btnWebcam"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:layout_marginVertical="8dp"
            android:text="Webcam" />

    </LinearLayout>


</LinearLayout>
```

#### Initializing the Meeting

After getting token and meetigId from `JoinActivity`,

1. Configure **VideoSDK** with token.
2. Initialize the meeting with required params such as `meetingId`, `participantName`, `micEnabled`, `webcamEnabled`
3. Add `MeetingEventListener` for listening events such as **Meeting Join/Left** and **Participant Join/Left**.
4. Join the room with `meeting.join()` method.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js title="MeetingActivity.kt"
class MeetingActivity : AppCompatActivity() {
  // declare the variables we will be using to handle the meeting
  private var meeting: Meeting? = null
  private var micEnabled = true
  private var webcamEnabled = true
  private var multiStream = false

  override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    setContentView(R.layout.activity_meeting)

    val token = intent.getStringExtra("token")
    val meetingId = intent.getStringExtra("meetingId")
    val participantName = "John Doe"

    // 1. Configuration VideoSDK with Token
    VideoSDK.config(token)
    // 2. Initialize VideoSDK Meeting
    meeting = VideoSDK.initMeeting(
      this@MeetingActivity, meetingId, participantName,
      micEnabled, webcamEnabled, multiStream, null, null)

    // 3. Add event listener for listening upcoming events
    meeting!!.addEventListener(meetingEventListener)

    //4. Join VideoSDK Meeting
    meeting!!.join()

    (findViewById<View>(R.id.tvMeetingId) as TextView).text = meetingId
  }

  // creating the MeetingEventListener
  private val meetingEventListener: MeetingEventListener = object : MeetingEventListener() {
    override fun onMeetingJoined() {
      Log.d("#meeting", "onMeetingJoined()")
    }

    override fun onMeetingLeft() {
      Log.d("#meeting", "onMeetingLeft()")
      meeting = null
      if (!isDestroyed) finish()
    }

    override fun onParticipantJoined(participant: Participant) {
      Toast.makeText(
        this@MeetingActivity, participant.displayName + " joined",
        Toast.LENGTH_SHORT
      ).show()
    }

    override fun onParticipantLeft(participant: Participant) {
      Toast.makeText(
         this@MeetingActivity, participant.displayName + " left",
         Toast.LENGTH_SHORT
      ).show()
    }
  }
}
```

</TabItem>

<TabItem value="Java">

```java title="MeetingActivity.java"
public class MeetingActivity extends AppCompatActivity {
  // declare the variables we will be using to handle the meeting
  private Meeting meeting;
  private boolean micEnabled = true;
  private boolean webcamEnabled = true;
  private boolean multiStream = false;

  @Override
  protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_meeting);

    final String token = getIntent().getStringExtra("token");
    final String meetingId = getIntent().getStringExtra("meetingId");
    final String participantName = "John Doe";

    // 1. Configuration VideoSDK with Token
    VideoSDK.config(token);
    // 2. Initialize VideoSDK Meeting
    meeting = VideoSDK.initMeeting(
            MeetingActivity.this, meetingId, participantName,
            micEnabled, webcamEnabled, multiStream, null, null);

    // 3. Add event listener for listening upcoming events
    meeting.addEventListener(meetingEventListener);

    //4. Join VideoSDK Meeting
    meeting.join();

    ((TextView)findViewById(R.id.tvMeetingId)).setText(meetingId);
  }

  // creating the MeetingEventListener
  private final MeetingEventListener meetingEventListener = new MeetingEventListener() {
    @Override
    public void onMeetingJoined() {
      Log.d("#meeting", "onMeetingJoined()");
    }

    @Override
    public void onMeetingLeft() {
      Log.d("#meeting", "onMeetingLeft()");
      meeting = null;
      if (!isDestroyed()) finish();
    }

    @Override
    public void onParticipantJoined(Participant participant) {
      Toast.makeText(MeetingActivity.this, participant.getDisplayName() + " joined", Toast.LENGTH_SHORT).show();
    }

    @Override
    public void onParticipantLeft(Participant participant) {
      Toast.makeText(MeetingActivity.this, participant.getDisplayName() + " left", Toast.LENGTH_SHORT).show();
    }
  };
}
```

</TabItem>

</Tabs>

### Step 4: Handle Local Participant Media

After successfully enter into the meeting, it's time to **enable/disable** local participant(You) webcam and mic, for that we will use `Meeting` class method `enableWebcam` / `disableWebcam` for camera and `muteMic` / `unmuteMic` for mic.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js title="MeetingActivity.kt"
class MeetingActivity : AppCompatActivity() {
  override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    setContentView(R.layout.activity_meeting)
    //...Meeting Setup is Here

    // actions
    setActionListeners()
  }

  private fun setActionListeners() {
    // toggle mic
    findViewById<View>(R.id.btnMic).setOnClickListener { view: View? ->
      if (micEnabled) {
        // this will mute the local participant's mic
        meeting!!.muteMic()
        Toast.makeText(this@MeetingActivity, "Mic Muted", Toast.LENGTH_SHORT).show()
      } else {
        // this will unmute the local participant's mic
        meeting!!.unmuteMic()
        Toast.makeText(this@MeetingActivity, "Mic Enabled", Toast.LENGTH_SHORT).show()
      }
        micEnabled=!micEnabled
    }

    // toggle webcam
    findViewById<View>(R.id.btnWebcam).setOnClickListener { view: View? ->
      // TODO : How we are managing webcamEnabled and micEnabled variable
      if (webcamEnabled) {
        // this will disable the local participant webcam
        meeting!!.disableWebcam()
        Toast.makeText(this@MeetingActivity, "Webcam Disabled", Toast.LENGTH_SHORT).show()
      } else {
        // this will enable the local participant webcam
        meeting!!.enableWebcam()
        Toast.makeText(this@MeetingActivity, "Webcam Enabled", Toast.LENGTH_SHORT).show()
      }
       webcamEnabled=!webcamEnabled
    }

    // leave meeting
    findViewById<View>(R.id.btnLeave).setOnClickListener { view: View? ->
      // this will make the local participant leave the meeting
      meeting!!.leave()
    }
  }
}
```

</TabItem>

<TabItem value="Java">

```java title="MeetingActivity.java"
public class MeetingActivity extends AppCompatActivity {
  @Override
  protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_meeting);
    //...Meeting Setup is Here

    // actions
    setActionListeners();
  }

  private void setActionListeners() {
    // toggle mic
    findViewById(R.id.btnMic).setOnClickListener(view -> {
      if (micEnabled) {
        // this will mute the local participant's mic
        meeting.muteMic();
        Toast.makeText(MeetingActivity.this, "Mic Muted", Toast.LENGTH_SHORT).show();
      } else {
        // this will unmute the local participant's mic
        meeting.unmuteMic();
        Toast.makeText(MeetingActivity.this, "Mic Enabled", Toast.LENGTH_SHORT).show();
      }
      micEnabled=!micEnabled;
    });

    // toggle webcam
    findViewById(R.id.btnWebcam).setOnClickListener(view -> {
      // TODO : How we are managing webcamEnabled and micEnabled variable
      if (webcamEnabled) {
        // this will disable the local participant webcam
        meeting.disableWebcam();
        Toast.makeText(MeetingActivity.this, "Webcam Disabled", Toast.LENGTH_SHORT).show();
      } else {
        // this will enable the local participant webcam
        meeting.enableWebcam();
        Toast.makeText(MeetingActivity.this, "Webcam Enabled", Toast.LENGTH_SHORT).show();
      }
      webcamEnabled=!webcamEnabled;
    });

    // leave meeting
    findViewById(R.id.btnLeave).setOnClickListener(view -> {
      // this will make the local participant leave the meeting
      meeting.leave();
    });
  }
}
```

</TabItem>

</Tabs>

#### Output

<div style={{textAlign: 'center'}}>

<img style={{height: '200px'}} src="/img/quick-start/android_controls.jpeg" />

</div>

### Step 5: Handling the Participants View

We will be showing the list of participant in a recycler view.

1. Create a new layout for the participant view named `item_remote_peer.xml` in the `res/layout` folder.

```xml title="item_remote_peer.xml"
<?xml version="1.0" encoding="utf-8"?>
<FrameLayout xmlns:android="http://schemas.android.com/apk/res/android"
  xmlns:app="http://schemas.android.com/apk/res-auto"
  xmlns:tools="http://schemas.android.com/tools"
  android:layout_width="match_parent"
  android:layout_height="wrap_content"
  tools:layout_height="200dp">
  <ImageView
    android:layout_width="100dp"
    android:layout_height="100dp"
    android:layout_gravity="center"
    app:tint="@color/white" />
  <org.webrtc.SurfaceViewRenderer
    android:id="@+id/svrParticipant"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:visibility="gone" />
  <FrameLayout
    android:layout_width="match_parent"
    android:layout_height="wrap_content"
    android:layout_gravity="bottom"
    android:background="@color/black">
    <TextView
      android:id="@+id/tvName"
      android:layout_width="wrap_content"
      android:layout_height="wrap_content"
      android:layout_gravity="center"
      android:textColor="@color/white" />
  </FrameLayout>
</FrameLayout>
```

2. Create a recycler view adapter named `ParticipantAdapter` which will show the participant list. Create `PeerViewHolder` in the adapter which will extend `RecyclerView.ViewHolder`.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js title="ParticipantAdapter.kt"
class ParticipantAdapter(meeting: Meeting) : RecyclerView.Adapter<ParticipantAdapter.PeerViewHolder>() {

  private var containerHeight = 0

  override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): PeerViewHolder {
  containerHeight = parent.height
    return PeerViewHolder(
      LayoutInflater.from(parent.context)
        .inflate(R.layout.item_remote_peer, parent, false)
      )
  }

  override fun onBindViewHolder(holder: PeerViewHolder, position: Int) {
  }

  override fun getItemCount(): Int {
    return 0
  }

  class PeerViewHolder(view: View) : RecyclerView.ViewHolder(view) {
    var svrParticipant: SurfaceViewRenderer = view.findViewById(R.id.svrParticipant)
    var tvName: TextView = view.findViewById(R.id.tvName)

    init{
      svrParticipant.init(PeerConnectionUtils.getEglContext(), null)
    }
  }
}
```

</TabItem>

<TabItem value="Java">

```java title="ParticipantAdapter.java"
public class ParticipantAdapter extends RecyclerView.Adapter<ParticipantAdapter.PeerViewHolder> {

  private int containerHeight;

  @NonNull
  @Override
  public PeerViewHolder onCreateViewHolder(@NonNull ViewGroup parent, int viewType) {
    containerHeight = parent.getHeight();
    return new PeerViewHolder(LayoutInflater.from(parent.getContext()).inflate(R.layout.item_remote_peer, parent, false));
  }

  @Override
  public void onBindViewHolder(@NonNull PeerViewHolder holder, int position) {

  }

  @Override
  public int getItemCount() {
      return 0;
  }

  static class PeerViewHolder extends RecyclerView.ViewHolder {
    // 'SurfaceViewRenderer' to show Video Stream
    public SurfaceViewRenderer svrParticipant;
    public TextView tvName;
    public View itemView;

    PeerViewHolder(@NonNull View view) {
      super(view);
      itemView = view;
      tvName = view.findViewById(R.id.tvName);
      svrParticipant = view.findViewById(R.id.svrParticipant);
      svrParticipant.init(PeerConnectionUtils.getEglContext(), null);
    }
  }
}
```

</TabItem>

</Tabs>

3. Now, we will render a list of `Participant` for the meeting.
   We will initialize this list in the constructor of the `ParticipantAdapter`

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js title="ParticipantAdapter.kt"
class ParticipantAdapter(meeting: Meeting) :
    RecyclerView.Adapter<ParticipantAdapter.PeerViewHolder>() {

  // creating a empty list which will store all participants
  private val participants: MutableList<Participant> = ArrayList()

  init {
    // adding the local participant(You) to the list
    participants.add(meeting.localParticipant)

    // adding Meeting Event listener to get the participant join/leave event in the meeting.
    meeting.addEventListener(object : MeetingEventListener() {
      override fun onParticipantJoined(participant: Participant) {
        // add participant to the list
        participants.add(participant)
        notifyItemInserted(participants.size - 1)
      }

      override fun onParticipantLeft(participant: Participant) {
        var pos = -1
        for (i in participants.indices) {
          if (participants[i].id == participant.id) {
            pos = i
            break
          }
        }
        // remove participant from the list
        participants.remove(participant)
        if (pos >= 0) {
          notifyItemRemoved(pos)
        }
      }
    })
  }

  // this method returns the size of total number of participants
  override fun getItemCount(): Int {
        return participants.size
  }
  //...
}
```

</TabItem>

<TabItem value="Java">

```java title="ParticipantAdapter.java"
public class ParticipantAdapter extends RecyclerView.Adapter<ParticipantAdapter.PeerViewHolder> {

  // creating a empty list which will store all participants
  private final List<Participant> participants = new ArrayList<>();

  public ParticipantAdapter(Meeting meeting) {
    // adding the local participant(You) to the list
    participants.add(meeting.getLocalParticipant());

    // adding Meeting Event listener to get the participant join/leave event in the meeting.
    meeting.addEventListener(new MeetingEventListener() {
      @Override
      public void onParticipantJoined(Participant participant) {
        // add participant to the list
        participants.add(participant);
        notifyItemInserted(participants.size() - 1);
      }

      @Override
      public void onParticipantLeft(Participant participant) {
        int pos = -1;
        for (int i = 0; i < participants.size(); i++) {
          if (participants.get(i).getId().equals(participant.getId())) {
            pos = i;
            break;
          }
        }
        // remove participant from the list
        participants.remove(participant);

        if (pos >= 0) {
          notifyItemRemoved(pos);
        }
      }
    });
  }

  // this method returns the size of total number of participants
  @Override
  public int getItemCount() {
    return participants.size();
  }
  //...
}
```

</TabItem>

</Tabs>

4. We have listed our participants. Let's set up the view holder to display a participant video.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js title="PartipantAdapter.kt"
class ParticipantAdapter(meeting: Meeting) :
    RecyclerView.Adapter<ParticipantAdapter.PeerViewHolder>() {

  override fun onBindViewHolder(holder: PeerViewHolder, position: Int) {
    val participant = participants[position]

    val layoutParams = holder.itemView.layoutParams
    layoutParams.height = containerHeight / 3
    holder.itemView.layoutParams = layoutParams

    holder.tvName.text = participant.displayName

    // adding the initial video stream for the participant into the 'SurfaceViewRenderer'
    for ((_, stream) in participant.streams) {
      if (stream.kind.equals("video", ignoreCase = true)) {
        holder.svrParticipant.visibility = View.VISIBLE
        val videoTrack = stream.track as VideoTrack
        videoTrack.addSink(holder.svrParticipant)
        break
      }
    }

    // add Listener to the participant which will update start or stop the video stream of that participant
    participant.addEventListener(object : ParticipantEventListener() {
      override fun onStreamEnabled(stream: Stream) {
        if (stream.kind.equals("video", ignoreCase = true)) {
          holder.svrParticipant.visibility = View.VISIBLE
          val videoTrack = stream.track as VideoTrack
          videoTrack.addSink(holder.svrParticipant)
       }
      }

      override fun onStreamDisabled(stream: Stream) {
        if (stream.kind.equals("video", ignoreCase = true)) {
          val track = stream.track as VideoTrack
          track?.removeSink(holder.svrParticipant)
          holder.svrParticipant.clearImage()
          holder.svrParticipant.visibility = View.GONE
        }
      }
    })
  }
}
```

</TabItem>

<TabItem value="Java">

```java title="PartipantAdapter.java"
public class ParticipantAdapter extends RecyclerView.Adapter<ParticipantAdapter.PeerViewHolder> {

  @Override
  public void onBindViewHolder(@NonNull PeerViewHolder holder, int position) {
    Participant participant = participants.get(position);

    ViewGroup.LayoutParams layoutParams = holder.itemView.getLayoutParams();
    layoutParams.height = containerHeight / 3;
    holder.itemView.setLayoutParams(layoutParams);

    holder.tvName.setText(participant.getDisplayName());

    // adding the initial video stream for the participant into the 'SurfaceViewRenderer'
    for (Map.Entry<String, Stream> entry : participant.getStreams().entrySet()) {
      Stream stream = entry.getValue();
      if (stream.getKind().equalsIgnoreCase("video")) {
        holder.svrParticipant.setVisibility(View.VISIBLE);
        VideoTrack videoTrack = (VideoTrack) stream.getTrack();
        videoTrack.addSink(holder.svrParticipant);
        break;
      }
    }
    // add Listener to the participant which will update start or stop the video stream of that participant
    participant.addEventListener(new ParticipantEventListener() {
      @Override
      public void onStreamEnabled(Stream stream) {
        if (stream.getKind().equalsIgnoreCase("video")) {
          holder.svrParticipant.setVisibility(View.VISIBLE);
          VideoTrack videoTrack = (VideoTrack) stream.getTrack();
          videoTrack.addSink(holder.svrParticipant);
        }
      }

      @Override
      public void onStreamDisabled(Stream stream) {
        if (stream.getKind().equalsIgnoreCase("video")) {
          VideoTrack track = (VideoTrack) stream.getTrack();
          if (track != null)
            track.removeSink(holder.svrParticipant);
          holder.svrParticipant.clearImage();
          holder.svrParticipant.setVisibility(View.GONE);
        }
      }
    });
  }
}
```

</TabItem>

</Tabs>

5. Add this adapter to the `MeetingActivity`

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js title="MeetingActivity.kt"
override fun onCreate(savedInstanceState: Bundle?) {
  //Meeting Setup...
  //...
  val rvParticipants = findViewById<RecyclerView>(R.id.rvParticipants)
  rvParticipants.layoutManager = GridLayoutManager(this, 2)
  rvParticipants.adapter = ParticipantAdapter(meeting!!)
}
```

</TabItem>

<TabItem value="Java">

```java title="MeetingActivity.java"
@Override
protected void onCreate(Bundle savedInstanceState) {
  //Meeting Setup...
  //...
  final RecyclerView rvParticipants = findViewById(R.id.rvParticipants);
  rvParticipants.setLayoutManager(new GridLayoutManager(this, 2));
  rvParticipants.setAdapter(new ParticipantAdapter(meeting));
}
```

</TabItem>

</Tabs>

:::tip

Stuck anywhere? Check out this [example code](https://github.com/videosdk-live/videosdk-rtc-android-java-sdk-example) on GitHub

:::

### Step 6: Run and Test

The app is all set to test. Make sure to update the `sampleToken` in `JoinActivity.java`

Your app should look like this after the implementation.

import ReactPlayer from 'react-player'

<div style={{textAlign: 'center'}}>

<ReactPlayer controls url="/img/quick-start/android-final-video.mp4" height="500px" width={"100%"} />

</div>

<br/>

:::caution
For the tutorial purpose, we used a static token to initialize and join the meeting. But for the production version of the app, we recommend you use an Authentication Server that will generate and pass on the token to the Client App. For more details checkout [how to do server setup](/android/guide/video-and-audio-calling-api-sdk/server-setup).
:::


---

---
sidebar_label: Release Notes
pagination_label: Release Notes
---

import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>

# Release Notes - Android

This page will keep you update all the releases of Android SDK.

## v0.0.26

**Release Date** : 25th November 2022

**Change log** :

1. Provide `multistream` parameter for sending multiple resolution layers or single resolution layer.

   **Docs** : [Multi Stream](https://docs.videosdk.live/android/0.0.x/guide/video-and-audio-calling-api-sdk/features/custom-track/custom-video-track)

---

## v0.0.25

**Release Date** : 24th August 2022

**Change log** :

1. Add [onMeetingStateChanged](https://docs.videosdk.live/android/api/sdk-reference/meeting-class/meeting-event-listener-class#onmeetingstatechanged) Event Listener for Websocket connection status.

2. Throw `PREV_RECORDING_PROCESSING` error.

---

## v0.0.24

**Release Date** : 12th August 2022

**Change log** : None

**Bug Fix** :

1. Fix Echo issue on Xiomi Device after Mute Unmute Mic.

---

## v0.0.23

**Release Date** : 21st July 2022

**Change log** :

1.  CustomTrack for audio,video and screenshare.

    **Docs** : [Custom Video Track](https://docs.videosdk.live/android/guide/video-and-audio-calling-api-sdk/features/custom-track/custom-video-track)

    **Docs** : [Custom Audio Track](https://docs.videosdk.live/android/guide/video-and-audio-calling-api-sdk/features/custom-track/custom-audio-track)

    **Docs** : [Custom Screen Share Track](https://docs.videosdk.live/android/guide/video-and-audio-calling-api-sdk/features/custom-track/custom-screen-share-track)

2.  Provide support for banuba integration.

    **Code Sample** : [videosdk-rtc-android-sdk-banuba-example](https://github.com/videosdk-live/videosdk-rtc-android-sdk-banuba-example)

**Bug Fix** :

1.  Fix `PendingIntent.FLAG_IMMUTABLE` for android 12 or later.

2.  Camera flicker on screen share fix.

3.  Camera will automatically off when you open another activity.

---

## v0.0.21

**Release Date** : 1st July 2022

**Change log** :

1.  Add the ViewPort method for better video quality based on view container.

    **Docs** : [How to Set Viewport?](https://docs.videosdk.live/android/guide/video-and-audio-calling-api-sdk/features/set-viewport)

---

## v0.0.17 & v0.0.20

**Release Date** : 27th June 2022

**Change log** : None

**Bug Fix** :

1. Mic issue in Redmi 9 device(OPUS codec).

2. For `arembi-v7a` architecture remove Audio/Opus codec

---

## v0.0.16

**Release Date** : 11th May 2022

**Change log** :

1. Add custom participantId in `initMeeting` method.

   **SDK Reference** : [customParticipantId](https://docs.videosdk.live/javascript/api/sdk-reference/initMeeting#participantid)

2. Error Codes events Added.

   **Docs** : [Error Event](https://docs.videosdk.live/android/guide/video-and-audio-calling-api-sdk/features/error-event)

**Bug Fix** :

1. FATAL EXCEPTION: AudioTrackJavaThread java.lang.UnsatisfiedLinkError on leave meeting.

---

## v0.0.15

**Release Date** : 27th April 2022

**Change log** : None

**Bug Fix** :

1. Crash on `meeting.end()` issue fixes.

2. Open native camera to stop publishing video from meeting.

---

## v0.0.14

**Release Date** : 30th March 2022

**Change log** : None

**Bug Fix** :

1. Android screen share crash issue on `stopScreenShare` fixes.

---

## v0.0.13

**Release Date** : 21st March 2022

**Change log** : None

**Bug Fix** :

1. `android:exported` needs to be explicitly specified for element.

---

## v0.0.11 & v0.0.12

**Release Date** : 17th March 2022

**Change log** :

1. Change input/output devices.

2. Pause/Resume participant stream.

   **Docs** : [Pause/Resume Video Stream](https://docs.videosdk.live/android/guide/video-and-audio-calling-api-sdk/features/pause-resume-video-stream)

3. setQuality for participant stream.

   **Docs** : [Set Participant Video Quality](https://docs.videosdk.live/android/guide/video-and-audio-calling-api-sdk/features/set-participant-video-quality)

4. Incoming call detection event.

   **Docs** : [External Call Detection](https://docs.videosdk.live/android/guide/video-and-audio-calling-api-sdk/features/external-call-detection)

---

## v0.0.10

**Release Date** : 8th March 2022

**Change log** : None

**Bug Fix** :

1. Crash issue while screen share.

---

## v0.0.9

**Release Date** : 1st March 2022

**Change log** :

1. Screen sharing feature added.

   **Docs** : [Share Your Screen](https://docs.videosdk.live/android/guide/video-and-audio-calling-api-sdk/features/screenshare)

---

## v0.0.8

**Release Date** : 13th February 2022

**Change log** :

1. PubSub feature for messaging over topics.

   **Docs** : [PubSub](https://docs.videosdk.live/android/guide/video-and-audio-calling-api-sdk/features/pubsub)

---

## v0.0.7

**Release Date** : 8th January 2022

**Change log** :

1. Added `onPresenterChanged` event for displaying screenshare.

   **SDK Reference** : [onPresenterChanged](https://docs.videosdk.live/android/api/sdk-reference/meeting-class/meeting-event-listener-class#onpresenterchanged)

---

## v0.0.6

**Release Date** : 9th December 2021

**Change log** : None

**Bug Fix** :

1. Fixed audio issues for devices older than Android 10.

---

## v0.0.5

**Release Date** : 9th December 2021

**Change log** : None

**Bug Fix** :

1. Fixed meeting end and participant remove bugs.

---

## v0.0.4

**Release Date** : 29th November 2021

**Change log** :

1. Toggle other participants mic and webcam.

   **Docs** : [Leave or End Meeting](https://docs.videosdk.live/android/guide/video-and-audio-calling-api-sdk/features/toggle-participant-media)

2. Remove participants from meeting.

3. Toggle meeting cloud recording.

   **Docs** : [Record Meeting](https://docs.videosdk.live/android/guide/video-and-audio-calling-api-sdk/features/recording-meeting)

4. Go live on youtube and other platforms with RTMP.

   **Docs** : [Go Live On Social Media](https://docs.videosdk.live/android/guide/video-and-audio-calling-api-sdk/features/go-live-social-media)

5. End meeting for all participants.

   **Docs** : [Leave or End Meeting](https://docs.videosdk.live/android/guide/video-and-audio-calling-api-sdk/features/leave-end-meeting)

---

## v0.0.2 & v0.0.3

**Release Date** : 21st November 2021

**Change log** :

1. Emit all events on Main thread.

---

## v0.0.1

**Release Date** : 15th October 2021

**Change log** :

1. Pilot release.

2. Join and leave meeting.

   **Docs** : [Start or Join Meeting](https://docs.videosdk.live/android/guide/video-and-audio-calling-api-sdk/features/start-join-meeting)

3. Toggle Mic and Camera.

   **Docs** : [Camera Controls](https://docs.videosdk.live/android/guide/video-and-audio-calling-api-sdk/features/camera-controls)

   **Docs** : [Mic Controls](https://docs.videosdk.live/android/guide/video-and-audio-calling-api-sdk/features/mic-controls)


---

---
title: Run a sample Android Project - Video SDK Docs
hide_title: true
hide_table_of_contents: false
description: Create customizable real-time video & audio calling applications with Android SDK with Video SDK add live Video & Audio conferencing to your applications.
sidebar_label: "Run the Sample Project"
pagination_label: "Run the Sample Project"
keywords:
  - android sdk
  - java sdk
  - kotlin sdk
  - sample project
  - android app
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: run-a-sample-android-project
---

import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>

# Run a Sample Project - Android

Video SDK provides open-source sample project [videosdk-rtc-android-java-sdk-example](https://github.com/videosdk-live/videosdk-rtc-android-java-sdk-example) on Github. This document introduces how to run this project.

## Prerequisites

- Development environment requirements:
  - [Java Development Kit](https://www.oracle.com/java/technologies/downloads/)
  - Android Studio 3.0 or later
- A physical or virtual mobile device running Android 5.0 or later
- Valid Video SDK [Account](https://app.videosdk.live/)

import APISecret from '../../../../mdx/introduction/\_api-key.mdx';

<APISecret title="Get your API key and Secret key" />

## Run the Sample Project

### Step 1: Clone the sample project

Clone the repository to your local environment.

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
git clone https://github.com/videosdk-live/videosdk-rtc-android-kotlin-sdk-example.git
```

</TabItem>

<TabItem value="Java">

```js
git clone https://github.com/videosdk-live/videosdk-rtc-android-java-sdk-example.git
```

</TabItem>

</Tabs>

### Step 2: Modify local.properties

Open your favorite code editor and add `auth_token` in it.

```js title="local.properties"
auth_token = "TEMPORARY-TOKEN";
```

### Step 3: Run the sample app

Run the android app with **Shift+F10** or the ** ▶ Run ** from toolbar.


---

---
title: Just Click Setup - Testing Token Server | Video SDK
hide_title: true
hide_table_of_contents: false
description: Video SDK and Audio SDK, developers need to implement a token server. This requires efforts on both the front-end and backend.
sidebar_label: Authentication and Tokens
pagination_label: Authentication and Tokens
keywords:
  - audio calling
  - video calling
  - real-time communication
  - collaboration
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: server-setup
---

import ServerSetup from '../../../../mdx/introduction/\_server-setup.mdx';
import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>
<ServerSetup />


---

---
title: Sign up for free account Custom Video SDK
hide_title: false
hide_table_of_contents: false
description: Video SDK Sign up. Get started with 10,000 minutes free every month! Programmable Video SDKs and Rest APIs to build up scalable video conferencing applications.
sidebar_label: Get your API key and Secret key
pagination_label: Get your API key and Secret key
keywords:
  - authentication audio calling
  - authentication video calling
  - authentication real-time communication
  - tokens
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: signup-and-create-api
---

import APISecret from '../../../../mdx/introduction/\_api-key.mdx';
import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>
<APISecret title="Get your API key and Secret key" />


---

---
title: Custom Tracks
hide_title: true
hide_table_of_contents: false
description: Custom Video Track features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Custom Tracks
pagination_label: Custom Tracks
keywords:
  - custom Track
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
---

## Custom Video Track - Android

- You can create a Video Track using `createCameraVideoTrack()` method of `VideoSDK`.
- This method can be used to create video track using different encoding parameters, camera facing mode, and optimization mode.

### Parameters

- **encoderConfig**:

  - type: `String`
  - required: `true`
  - default: `h480p_w720p`
  - You can chose from the below mentioned list of values for the encoder config.

| Encoder Config | Resolution | Frame Rate |   Bitrate    |
| -------------- | :--------: | :--------: | :----------: |
| h144p_w176p    |  176x144   |   15 fps   | 120000 kbps  |
| h240p_w320p    |  320x240   |   15 fps   | 150000 kbps  |
| h480p_w640p    |  640x480   |   25 fps   | 300000 kbps  |
| h480p_w720p    |  720x480   |   30 fps   | 450000 kbps  |
| h720p_w960p    |  720x960   |   30 fps   | 1500000 kbps |
| h1080p_w1440p  | 1080x1440  |   30 fps   | 2500000 kbps |
| h720p_w1280p   |  720x1280  |   30 fps   | 2000000 kbps |
| h360p_w640p    |  360x640   |   30 fps   | 400000 kbps  |  

:::note

Above mentioned encoder configurations are valid for both, landscape as well as portrait mode.

:::

- **facingMode**:

  - type: `String`
  - required: `true`
  - Allowed values : `front` | `back`
  - It will specify wheater to use front or back camera for the video track.

- **optimizationMode**

  - type: `CustomStreamTrack.VideoMode`
  - required: `true`
  - Allowed values: `motion` | `text` | `detail`
  - It will specify the optimization mode for the video track being generated.

- **multiStream**:

  - type: `boolean`
  - required: `true`
  - It will specify if the stream should send multiple resolution layers or single resolution layer.

- **context**:

  - type: `Context`
  - required: `true`
  - Pass the Android Context for this parameter.

- **observer**:

  - type: `CapturerObserver`
  - required: `false`
  - If you want to use video filter from external SDK(e.g., [Banuba](https://www.banuba.com/)) then pass instance of `CapturerObserver` in this parameter.

- **videoDeviceInfo**:

  - type: `VideoDeviceInfo`
  - required: `false`
  - If you want to specify a camera device to be used in the meeting.

:::note

For Banuba integraion with VideoSDK, please visit [Banuba Intergation with VideoSDK](/android/guide/video-and-audio-calling-api-sdk/video-processor/banuba-integration)

:::

:::info

- To learn more about optimizations and best practices for using custom video tracks, [follow this guide](/android/guide/video-and-audio-calling-api-sdk/render-media/optimize-video-track).

:::

#### Returns

- `CustomStreamTrack`

### Example

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
val videoCustomTrack: CustomStreamTrack = VideoSDK.createCameraVideoTrack("h720p_w960p", "front", CustomStreamTrack.VideoMode.MOTION, false, this)
```

</TabItem>

<TabItem value="Java">

```javascript
CustomStreamTrack customStreamTrack = VideoSDK.createCameraVideoTrack("h720p_w960p", "front", CustomStreamTrack.VideoMode.MOTION, false, this);
```

</TabItem>

</Tabs>

## Custom Audio Track - Android

- You can create a Audio Track using `createAudioTrack()` method of `VideoSDK`.
- This method can be used to create audio track using different encoding parameters.

### Parameters

- **encoderConfig**:

  - type: `String`
  - required: `true`
  - default: `speech_standard`
  - You can chose from the below mentioned list of values for the encoder config.

| Encoder Config      | Bitrate  | Auto Gain | Echo Cancellation | Noise Suppression |
| ------------------- | :------: | :-------: | :---------------: | :---------------: |
| speech_low_quality  | 16 kbps  |   TRUE    |       TRUE        |       TRUE        |
| speech_standard     | 24 kbps  |   TRUE    |       TRUE        |       TRUE        |
| music_standard      | 32 kbps  |   FALSE   |       FALSE       |       FALSE       |
| standard_stereo     | 64 kbps  |   FALSE   |       FALSE       |       FALSE       |
| high_quality        | 128 kbps |   FALSE   |       FALSE       |       FALSE       |
| high_quality_stereo | 192 kbps |   FALSE   |       FALSE       |       FALSE       |

- **context**

  - type: `Context`
  - required: `true`
  - Pass the Android Context for this parameter.

#### Returns

- `CustomStreamTrack`

### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
val audioCustomTrack: CustomStreamTrack = VideoSDK.createAudioTrack("speech_standard",this)
```

</TabItem>

<TabItem value="Java">

```js
CustomStreamTrack audioCustomTrack=VideoSDK.createAudioTrack("speech_standard", this);
```

</TabItem>

</Tabs>

## Custom Screen Share Track - Android

- You can create a Screen Share track using `createScreenShareVideoTrack()` method of `VideoSDK`.
- This method can be used to create screen share track using different encoding parameters.

### Parameters

- **encoderConfig**:

  - type: `String`
  - required: `true`
  - default: `h720p_15fps`
  - You can chose from the below mentioned list of values for the encoder config.

| Encoder Config | Resolution | Frame Rate |   Bitrate    |
| -------------- | :--------: | :--------: | :----------: |
| h360p_30fps    |  640x360   |   3 fps    | 200000 kbps  |
| h720p_5fps     |  1280x720  |   5 fps    | 400000 kbps  |
| h720p_15fps    |  1280x720  |   15 fps   | 1000000 kbps |
| h1080p_15fps   | 1920x1080  |   15 fps   | 1500000 kbps |
| h1080p_30fps   | 1920x1080  |   15 fps   | 1000000 kbps |

:::note

Above mentioned encoder configurations are valid for both, landscape as well as portrait mode.

:::

- **data**

  - type: `Intent`
  - required: `true`
  - It is Intent received from onActivityResult when user provide permission for ScreenShare.

- **context**

  - type: `Context`
  - required: `true`
  - Pass the Android Context for this parameter.

- **listener**
  - type: `CustomTrackListener`
  - required: `true`
  - Callback to this listener will be made when track is ready with CustomTrack as parameter.

### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
// data is received from onActivityResult method.
VideoSDK.createScreenShareVideoTrack("h720p_15fps", data, this) { track ->
    meeting!!.enableScreenShare(track)
}
```

</TabItem>

<TabItem value="Java">

```javascript
// data is received from onActivityResult method.
VideoSDK.createScreenShareVideoTrack("h720p_15fps", data, this, (track)->{
    meeting.enableScreenShare(track);
});
```

</TabItem>

</Tabs>


---

---
sidebar_position: 2
sidebar_label: Meeting Error Codes
pagination_label: Meeting Error Codes
title: Meeting Error Codes
---

# Meeting Error Codes - Android

If you encounter any of the errors listed below, refer to the [Developer Experience Guide](../../guide/best-practices/developer-experience.md#listen-for-error-events), which offers recommended solutions based on common error categories.

import ServerErrorCodes from '../../../../mdx/\_server-error-codes.mdx'
import SDKErrorCodes from '../../data/\_sdk-error-codes.mdx'

<ServerErrorCodes />

<SDKErrorCodes/>





---

---
sidebar_position: 2
sidebar_label: Initializing a Meeting
pagination_label: Initializing a Meeting
title: Initializing a Meeting
---

# Initializing a Meeting - Android

<div class="sdk-api-ref">

## initialize()

To initialize the meeting, first you have to initialize the `VideoSDK`.
You can initialize the `VideoSDK` using `initialize()` method provided by the SDK.

#### Parameters

- **context**: Context

#### Returns

- _`void`_

```js title="initialize"
  VideoSDK.initialize(Context context)
```

---

## config()

Now, you have to set `token` property of `VideoSDK` class.
By using `config()` method, you can set the `token` property of `VideoSDK` class.

Please refer this [documentation](/api-reference/realtime-communication/intro/) to generate a token.

#### Parameters

- **token**: String

#### Returns

- _`void`_

```js title="config"
 VideoSDK.config(String token)
```

---

## initMeeting()

- Now, you can initialize the meeting using a factory method provided by the SDK called `initMeeting()`.
- `initMeeting()` will generate a new [`Meeting`](./meeting-class/introduction.md) class and the initiated meeting will be returned.

```js title="initMeeting"
   VideoSDK.initMeeting(
        Context context,
        String meetingId,
        String name,
        boolean micEnabled,
        boolean webcamEnabled,
        String participantId,
        String mode,
        boolean multiStream,
        Map<String, CustomStreamTrack> customTracks
        JSONObject metaData,
        String signalingBaseUrl,
        PreferredProtocol preferredProtocol
      )
```

## Parameters

### context

- Context of activity.

  - type : Context
  - `REQUIRED`

### meetingId

- Unique Id of the meeting where that participant will be joining.

  - type : `String`
  - `REQUIRED`

Please refer this [documentation](/api-reference/realtime-communication/create-room) to create a room.

### name

- Name of the participant who will be joining the meeting, this name will be displayed to other participants in the same meeting.

  - type : String
  - `REQUIRED`

### micEnabled

- Whether `mic` of the participant will be on while joining the meeting. If it is set to `false`, then mic of that participant will be `disabled` by default, but can be `enabled` or `disabled` later.

  - type: `Boolean`
  - `REQUIRED`

### webcamEnabled

- Whether `webcam` of the participant will be on while joining the meeting. If it is set to `false`, then webcam of that participant will be `disabled` by default, but can be `enabled` or `disabled` later.

  - type: `Boolean`
  - `REQUIRED`

### participantId

- Unique Id of the participant. If you passed `null` then SDK will create an Id by itself and will use that id.

  - type : `String` or `null`
  - `REQUIRED`

### Modes

There are three modes available:

- **`SEND_AND_RECV`**: In this mode, both audio and video streams will be produced and consumed.

- **`SIGNALLING_ONLY`**: In this mode, no audio or video streams will be produced or consumed. It is used solely for signaling.

- **`RECV_ONLY`**: This mode allows only the consumption of audio and video streams without producing any.

**Type**: `String` or `null`  
**Default Value**: `SEND_AND_RECV`

import CautionMessage from '@site/src/theme/CautionMessage';

<CautionMessage sdk="Android SDK" version="v0.2.0" />

### multiStream

- It will specify if the stream should send multiple resolution layers or single resolution layer.

  - type: `boolean`
  - `REQUIRED`

### customTracks

- If you want to use custom tracks from start of the meeting, you can pass map of custom tracks in this paramater.

  - type : `Map<String, CustomStreamTrack>` or `null`
  - `REQUIRED`

Please refer this [documentation](../../guide/video-and-audio-calling-api-sdk/features/custom-track/custom-video-track) to know more about CustomTrack.

### metaData

- If you want to provide additional details about a user joining a meeting, such as their profile image, you can pass that information in this parameter.

  - type: `JSONObject`
  - `REQUIRED`

### signalingBaseUrl

- If you want to use a proxy server with the VideoSDK, you can specify your baseURL here.

  - type: `String`
  - `OPTIONAL`

:::note

If you intend to use a proxy server with the VideoSDK, priorly inform us at support@videosdk.live

:::

### preferredProtocol

- If you want to provide a preferred network protocol for communication, you can specify that in `PreferredProtocol`, with options including `UDP_ONLY`, `UDP_OVER_TCP`, and `TCP_ONLY`.

  - type: `PreferredProtocol`
  - `OPTIONAL`

## Returns

### meeting

- After initializing the meeting, `initMeeting()` will return a new [`Meeting`](./meeting-class/introduction.md) instance.

---

## Example

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js title="initMeeting"

VideoSDK.initialize(applicationContext)

// Configure the token
VideoSDK.config(token) // pass the token generated from VideoSDK Dashboard

// Initialize the meeting
var meeting = VideoSDK.initMeeting(
  arrayOf(
    this@MainActivity,
    "abc-1234-xyz",
    "John Doe",
    true,
    true,
    null,
    null,
    false,
    null,
    null
  )
)
```

</TabItem>

<TabItem value="Java">

```js title="initMeeting"

VideoSDK.initialize(getApplicationContext());

// Configure the token
VideoSDK.config(token);  // pass the token generated from VideoSDK Dashboard

// Initialize the meeting
Meeting meeting = VideoSDK.initMeeting({
  MainActivity.this,
  "abc-1234-xyz",
  "John Doe",
  true,
  true,
  null,
  null,
  false,
  null,
  null,
  null
});
```

</TabItem>

</Tabs>

</div>


---

---
title: MediaEffects library
hide_title: true
hide_table_of_contents: false
description: The MediaEffects library enhances video applications by providing advanced media effects, including virtual backgrounds.
sidebar_label: MediaEffects library
pagination_label: MediaEffects library
keywords:
  - Apply Virtual Background
  - Remove Virtual Background
  - Change Virtual Background
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
---

# MediaEffects library - Android

<div id="tailwind" class="sdk-api-ref">

## Introduction

- The `MediaEffects` library enhances video applications with advanced media effects, including virtual backgrounds. It supports real-time processing and is optimized for Android devices.

- The `MediaEffects` library offers three classes to customize your video background: using a custom image, applying a blur effect, or choosing a solid color.

:::info

The Virtual Background feature in VideoSDK can be utilized regardless of the meeting environment, including the pre-call screen.

:::

## 1. BackgroundImageProcessor

- `BackgroundImageProcessor` sets a specified image as the background in a video stream, allowing you to customize the visual appearance of the video.
- `BackgroundImageProcessor` class provides following method.

  - `setBackgroundSource()` method updates the virtual background by setting a new image as the background that the user wants to switch to.
  
     - **Parameters**: `Uri`: An image URI for the background image.

     - **Return Type**: `void`
  
import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
val uri = Uri.parse("https://st.depositphotos.com/2605379/52364/i/450/depositphotos_523648932-stock-photo-concrete-rooftop-night-city-view.jpg")
val backgroundImageProcessor = BackgroundImageProcessor(uri) // Sets the background image

val newUri = Uri.parse("https://img.freepik.com/free-photo/plant-against-blue-wall-mockup_53876-96052.jpg?size=626&ext=jpg&ga=GA1.1.2008272138.1723420800&semt=ais_hybrid")
backgroundImageProcessor.setBackgroundSource(newUri) // Changed background image
```

</TabItem>

<TabItem value="Java">

```java
Uri uri = Uri.parse("https://st.depositphotos.com/2605379/52364/i/450/depositphotos_523648932-stock-photo-concrete-rooftop-night-city-view.jpg");
BackgroundImageProcessor backgroundImageProcessor= new BackgroundImageProcessor(uri); // Sets the background image

Uri uri = Uri.parse("https://img.freepik.com/free-photo/plant-against-blue-wall-mockup_53876-96052.jpg?size=626&ext=jpg&ga=GA1.1.2008272138.1723420800&semt=ais_hybrid");
backgroundImageProcessor.setBackgroundSource(uri); //Changed background image
```
</TabItem>

</Tabs>


## 2. BackgroundBlurProcessor
- `BackgroundBlurProcessor` applies a blur effect to the video background, with the intensity controlled by a float value, creating a softened visual effect.
- `BackgroundBlurProcessor` class provides following method.

  - `setBlurRadius()` method adjusts the blur effect on the video background, with the blur strength controlled by the specified float value.
  

     - **Parameters**: `Float`: representing the blur strength; higher values mean stronger blur. The supported range is 0 to 25.

     - **Return Type**: `void`


<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
val backgroundBlurProcessor = BackgroundBlurProcessor(25, this) // Applies a blur with intensity 25
backgroundBlurProcessor.setBlurRadius(17) // Changes the blur intensity to 17
```

</TabItem>

<TabItem value="Java">

```java
BackgroundBlurProcessor backgroundBlurProcessor = new BackgroundBlurProcessor(25, this);// Applies a blur with intensity 25
backgroundBlurProcessor.setBlurRadius(17); // changes the blur intensity to 17
```
</TabItem>

</Tabs>

## 3. BackgroundColorProcessor
- `BackgroundColorProcessor` sets a solid color as the video background using a `Color` object, enabling you to create a uniform color backdrop for your video.
- `BackgroundColorProcessor` class provides following method.

  - `setBackgroundColor()` method sets the color that user wants to switch to, for virtual background effect.

     - **Parameters**: `Integer`: Specifies the color for the virtual background.
     - **Return Type**: `void`

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
val backgroundColorProcessor = BackgroundColorProcessor(Color.BLUE) // Sets the background color to blue
backgroundColorProcessor.setBackgroundColor(Color.CYAN) // Changes the background color to CYAN
```

</TabItem>

<TabItem value="Java">

```java
BackgroundColorProcessor backgroundColorProcessor = new BackgroundColorProcessor(Color.BLUE);// Sets the background color to blue
backgroundColorProcessor.setBackgroundColor(Color.CYAN); // changed the background color to CYAN
```
</TabItem>

</Tabs>

</div>

---

---
sidebar_position: 1
sidebar_label: Introduction
pagination_label: Intro to Video SDK Meeting Class
title: Video SDK Meeting Class
---

# Video SDK Meeting Class - Android

<div class="sdk-api-ref">

## Introduction

The `Meeting` class includes properties, methods and meeting-event-listener-class for managing a meeting, participants, video, audio and share streams, messaging and UI customization.

import LinksGrid from "../../../../../src/theme/LinksGrid";
import properties from "./../data/meeting-class/properties.json";
import methods from "./../data/meeting-class/methods.json";
import events from "./../data/meeting-class/events.json";

## Meeting Properties

<div class="row">

<div class="col col--4 margin-bottom--sm" >

- [getmeetingId()](/android/api/sdk-reference/meeting-class/properties#getmeetingid)

</div>
<div class="col col--4 margin-bottom--sm" >

- [getLocalParticipant()](./properties#getlocalparticipant)

</div>
<div class="col col--4 margin-bottom--sm" >

- [getParticipants()](./properties#getparticipants)

</div>
<div class="col col--4 margin-bottom--sm" >

- [pubSub](./properties#pubsub)

</div>

</div>

## Meeting Methods

<div class="row">

<div class="col col--4 margin-bottom--sm" >

- [join()](./methods#join)

</div>
<div class="col col--4 margin-bottom--sm" >

- [leave()](./methods#leave)

</div>
<div class="col col--4 margin-bottom--sm" >

- [end()](./methods#end)

</div>
<div class="col col--4 margin-bottom--sm" >

- [enableWebcam()](./methods#enablewebcam)

</div>
<div class="col col--4 margin-bottom--sm" >

- [disableWebcam()](./methods#disablewebcam)

</div>
<div class="col col--4 margin-bottom--sm" >

- [unmuteMic()](./methods#unmutemic)

</div>
<div class="col col--4 margin-bottom--sm" >

- [muteMic()](./methods#mutemic)

</div>
<div class="col col--4 margin-bottom--sm" >

- [enableScreenShare()](./methods#enablescreenshare)

</div>
<div class="col col--4 margin-bottom--sm" >

- [disableScreenShare()](./methods#disablescreenshare)

</div>
<div class="col col--4 margin-bottom--sm" >

- [startRecording()](./methods#startrecording)

</div>
<div class="col col--4 margin-bottom--sm" >

- [stopRecording()](./methods#stoprecording)

</div>
<div class="col col--4 margin-bottom--sm" >

- [startLiveStream()](./methods#startlivestream)

</div>
<div class="col col--4 margin-bottom--sm" >

- [stopLiveStream()](./methods#stoplivestream)

</div>
<div class="col col--4 margin-bottom--sm" >

- [startHls()](./methods#starthls)

</div>
<div class="col col--4 margin-bottom--sm" >

- [stopHls()](./methods#stophls)

</div>
<div class="col col--4 margin-bottom--sm" >

- [startTranscription()](./methods#starttranscription)

</div>
<div class="col col--4 margin-bottom--sm" >

- [stopTranscription()](./methods#stoptranscription)

</div>
<div class="col col--4 margin-bottom--sm" >

- [changeMode()](./methods#changemode)

</div>
<div class="col col--4 margin-bottom--sm" >

- [getMics()](./methods#getmics)

</div>
<div class="col col--4 margin-bottom--sm" >

- [changeMic()](./methods#changemic)

</div>
<div class="col col--4 margin-bottom--sm" >

- [setAudioDeviceChangeListener()](./methods#setaudiodevicechangelistener)

</div>
<div class="col col--4 margin-bottom--sm" >

- [changeWebcam()](./methods#changewebcam)

</div>
<div class="col col--4 margin-bottom--sm" >

- [uploadBase64File()](./methods#uploadbase64file)

</div>
<div class="col col--4 margin-bottom--sm" >

- [fetchBase64File()](./methods#fetchbase64file)

</div>
<div class="col col--4 margin-bottom--sm" >

- [addEventListener()](./methods#addeventlistener)

</div>
<div class="col col--4 margin-bottom--sm" >

- [removeEventListener()](./methods#removeeventlistener)

</div>
<div class="col col--4 margin-bottom--sm" >

- [removeAllListeners()](./methods#removealllisteners)

</div>
<div class="col col--4 margin-bottom--sm" >

- [startWhiteboard()](./methods#startwhiteboard)

</div>
<div class="col col--4 margin-bottom--sm" >

- [stopWhiteboard()](./methods#stopwhiteboard)

</div>

</div>

## Meeting Events

<div class="row">

<div class="col col--4 margin-bottom--sm" >

- [onMeetingJoined](./meeting-event-listener-class#onmeetingjoined)

</div>
<div class="col col--4 margin-bottom--sm" >

- [onMeetingLeft](./meeting-event-listener-class#onmeetingleft)

</div>
<div class="col col--4 margin-bottom--sm" >

- [onParticipantJoined](./meeting-event-listener-class#onparticipantjoined)

</div>
<div class="col col--4 margin-bottom--sm" >

- [onParticipantLeft](./meeting-event-listener-class#onparticipantleft)

</div>
<div class="col col--4 margin-bottom--sm" >

- [onSpeakerChanged](./meeting-event-listener-class#onspeakerchanged)

</div>
<div class="col col--4 margin-bottom--sm" >

- [onPresenterChanged](./meeting-event-listener-class#onpresenterchanged)

</div>
<div class="col col--4 margin-bottom--sm" >

- [onEntryRequested](./meeting-event-listener-class#onentryrequested)

</div>
<div class="col col--4 margin-bottom--sm" >

- [onEntryResponded](./meeting-event-listener-class#onentryresponded)

</div>
<div class="col col--4 margin-bottom--sm" >

- [onWebcamRequested](./meeting-event-listener-class#onwebcamrequested)

</div>
<div class="col col--4 margin-bottom--sm" >

- [onMicRequested](./meeting-event-listener-class#onmicrequested)

</div>
<div class="col col--4 margin-bottom--sm" >

- [onRecordingStateChanged](./meeting-event-listener-class#onrecordingstatechanged)

</div>
<div class="col col--4 margin-bottom--sm" >

- [onRecordingStarted](./meeting-event-listener-class#onrecordingstarted)

</div>
<div class="col col--4 margin-bottom--sm" >

- [onRecordingStopped](./meeting-event-listener-class#onrecordingstopped)

</div>
<div class="col col--4 margin-bottom--sm" >

- [onLivestreamStateChanged](./meeting-event-listener-class#onlivestreamstatechanged)

</div>
<div class="col col--4 margin-bottom--sm" >

- [onLivestreamStarted](./meeting-event-listener-class#onlivestreamstarted)

</div>
<div class="col col--4 margin-bottom--sm" >

- [onLivestreamStopped](./meeting-event-listener-class#onlivestreamstopped)

</div>
<div class="col col--4 margin-bottom--sm" >

- [onHlsStateChanged](./meeting-event-listener-class#onhlsstatechanged)

</div>
<div class="col col--4 margin-bottom--sm" >

- [onTranscriptionStateChanged](./meeting-event-listener-class#ontranscriptionstatechanged)

</div>
<div class="col col--4 margin-bottom--sm" >

- [onTranscriptionText](./meeting-event-listener-class#ontranscriptiontext)

</div>
<div class="col col--4 margin-bottom--sm" >

- [onExternalCallStarted](./meeting-event-listener-class#onexternalcallstarted)

</div>
<div class="col col--4 margin-bottom--sm" >

- [onMeetingStateChanged](./meeting-event-listener-class#onmeetingstatechanged)

</div>
<div class="col col--4 margin-bottom--sm" >

- [onParticipantModeChanged](./meeting-event-listener-class#onparticipantmodechanged)

</div>
<div class="col col--4 margin-bottom--sm" >

- [onPinStateChanged()](./meeting-event-listener-class#onpinstatechanged)

</div>

<div class="col col--4 margin-bottom--sm" >

- [onWhiteboardStarted()](./meeting-event-listener-class#onwhiteboardstarted)

</div>

<div class="col col--4 margin-bottom--sm" >

- [onWhiteboardStopped()](./meeting-event-listener-class#onwhiteboardstopped)

</div>

</div>

</div>


---

---
sidebar_position: 1
sidebar_label: MeetingEventListener Class
pagination_label: MeetingEventListener Class
title: MeetingEventListener Class
---

# MeetingEventListener Class - Android

<div class="sdk-api-ref-only-h4">

---

### implementation

- You can implement all the methods of `MeetingEventListener` abstract Class and add the listener to `Meeting` class using the `addEventListener()` method of `Meeting` Class.

#### Example

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
private final MeetingEventListener meetingEventListener = new MeetingEventListener() {
  override fun onMeetingJoined() {
    Log.d("#meeting", "onMeetingJoined()")
  }
}
```

</TabItem>

<TabItem value="Java">

```javascript
private final MeetingEventListener meetingEventListener = new MeetingEventListener() {
  @Override
  public void onMeetingJoined() {
    Log.d("#meeting", "onMeetingJoined()");
  }
}
```

</TabItem>

</Tabs>

---

### onMeetingJoined()

- This event will be emitted when a [localParticipant](./properties#getlocalparticipant) successfully joined the meeting.

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
 override fun onMeetingJoined() {
    Log.d("#meeting", "onMeetingJoined()")
 }
```

</TabItem>

<TabItem value="Java">

```javascript
 @Override
 public void onMeetingJoined() {
     Log.d("#meeting", "onMeetingJoined()");
 }
```

</TabItem>

</Tabs>

---

### onMeetingLeft()

- This event will be emitted when a [localParticipant](./properties#getlocalparticipant) left the meeting.

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
 override fun onMeetingLeft() {
    Log.d("#meeting", "onMeetingLeft()")
 }
```

</TabItem>

<TabItem value="Java">

```javascript
 @Override
 public void onMeetingLeft() {
    Log.d("#meeting", "onMeetingLeft()");
 }
```

</TabItem>

</Tabs>

---

### onParticipantJoined()

- This event will be emitted when a new [participant](../participant-class/introduction) joined the meeting.

#### Event callback parameters

- **participant**: [Participant](../participant-class/introduction)

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
 override fun onParticipantJoined(participant: Participant) {
    Log.d("#meeting", participant.displayName + " joined");
 }
```

</TabItem>

<TabItem value="Java">

```javascript
 @Override
 public void onParticipantJoined(Participant participant) {
    Log.d("#meeting", participant.getDisplayName() + " joined");
 }
```

</TabItem>

</Tabs>

---

### onParticipantLeft

- This event will be emitted when a joined [participant](../participant-class/introduction) left the meeting.

#### Event callback parameters

- **participant**: [Participant](../participant-class/introduction)

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
 override fun onParticipantLeft(participant: Participant) {
    Log.d("#meeting", participant.displayName + " left");
 }
```

</TabItem>

<TabItem value="Java">

```javascript
 @Override
 public void onParticipantLeft(Participant participant) {
    Log.d("#meeting", participant.getDisplayName() + " left");
 }
```

</TabItem>

</Tabs>

---

### onSpeakerChanged()

- This event will be emitted when a active speaker changed.
- If you want to know which participant is actively speaking, then this event will be used.
- If no participant is actively speaking, then this event will pass `null` as en event callback parameter.

#### Event callback parameters

- **participantId**: String

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
 override fun onSpeakerChanged(participantId: String?) {
  //
 }
```

</TabItem>

<TabItem value="Java">

```javascript
 @Override
 public void onSpeakerChanged(String participantId) {
  //
 }
```

</TabItem>

</Tabs>

---

### onPresenterChanged()

- This event will be emitted when any [participant](../participant-class/introduction) starts or stops screen sharing.
- It will pass `participantId` as an event callback parameter.
- If a participant stops screensharing, then this event will pass `null` as en event callback parameter.

#### Event callback parameters

- **participantId**: String

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
 override fun onPresenterChanged(participantId: String) {
  //
 }
```

</TabItem>

<TabItem value="Java">

```javascript
 @Override
 public void onPresenterChanged(String participantId) {
  //
 }
```

</TabItem>

</Tabs>

---

### onEntryRequested()

- This event will be emitted when a new [participant](../participant-class/introduction) who is trying to join the meeting, is having permission **`ask_join`** in token.
- This event will only be emitted to the [participants](./properties#getparticipants) in the meeting, who is having the permission **`allow_join`** in token.
- This event will pass following parameters as an event parameters, `participantId` and `name` of the new participant who is trying to join the meeting, `allow()` and `deny()` to take required actions.

#### Event callback parameters

- **peerId**: String
- **name**: String

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
 override fun onEntryRequested(id: String?, name: String?) {
    //
}
```

</TabItem>

<TabItem value="Java">

```javascript
 @Override
 public void onEntryRequested(String id, String name) {
    //
}
```

</TabItem>

</Tabs>

---

### onEntryResponded()

- This event will be emitted when the `join()` request is responded.
- This event will be emitted to the [participants](./properties#getparticipants) in the meeting, who is having the permission **`allow_join`** in token.
- This event will be also emitted to the [participant](../participant-class/introduction) who requested to join the meeting.

#### Event callback parameters

- **participantId**: _String_
- **decision**: _"allowed"_ | _"denied"_

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
 override fun onEntryResponded(id: String?, decision: String?) {
    //
  }
```

</TabItem>

<TabItem value="Java">

```javascript
 @Override
 public void onEntryResponded(String id, String decision) {
    //
  }
```

</TabItem>

</Tabs>

---

### onWebcamRequested()

- This event will be emitted to the participant `B` when any other participant `A` requests to enable webcam of participant `B`.
- On accepting the request, webcam of participant `B` will be enabled.

#### Event callback parameters

- **participantId**: String
- **listener**: WebcamRequestListener \{ **accept**: Method; **reject**: Method }

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
  override fun onWebcamRequested(participantId: String, listener: WebcamRequestListener) {
     // if accept request
     listener.accept()

     // if reject request
     listener.reject()
 }
```

</TabItem>

<TabItem value="Java">

```javascript
  @Override
 public void onWebcamRequested(String participantId, WebcamRequestListener listener) {
     // if accept request
     listener.accept();

     // if reject request
     listener.reject();
 }
```

</TabItem>

</Tabs>

### onMicRequested()

- This event will be emitted to the participant `B` when any other participant `A` requests to enable mic of participant `B`.
- On accepting the request, mic of participant `B` will be enabled.

#### Event callback parameters

- **participantId**: String
- **listener**: MicRequestListener \{ **accept**: Method; **reject**: Method }

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
 override fun onMicRequested(participantId: String, listener: MicRequestListener) {
     // if accept request
     listener.accept()

     // if reject request
     listener.reject()
 }
```

</TabItem>

<TabItem value="Java">

```javascript
 @Override
 public void onMicRequested(String participantId, MicRequestListener listener) {
     // if accept request
     listener.accept();

     // if reject request
     listener.reject();
 }
```

</TabItem>

</Tabs>

---

### onRecordingStateChanged()

- This event will be emitted when the meeting's recording status changed.

#### Event callback parameters

- **recordingState**: String

`recordingState` has following values

- `RECORDING_STARTING` - Recording is in starting phase and hasn't started yet.
- `RECORDING_STARTED` - Recording has started successfully.
- `RECORDING_STOPPING` - Recording is in stopping phase and hasn't stopped yet.
- `RECORDING_STOPPED` - Recording has stopped successfully.

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
  override fun onRecordingStateChanged(recordingState: String) {
    when (recordingState) {
        "RECORDING_STARTING" -> {
            Log.d("onRecordingStateChanged", "Meeting recording is starting")
        }
        "RECORDING_STARTED" -> {
            Log.d("onRecordingStateChanged", "Meeting recording is started")
        }
        "RECORDING_STOPPING" -> {
            Log.d("onRecordingStateChanged", "Meeting recording is stopping")
        }
        "RECORDING_STOPPED" -> {
            Log.d("onRecordingStateChanged", "Meeting recording is stopped")
        }
    }
  }
```

</TabItem>

<TabItem value="Java">

```javascript
  @Override
  public void onRecordingStateChanged(String recordingState) {
      switch (recordingState) {
          case "RECORDING_STARTING":
              Log.d("onRecordingStateChanged", "Meeting recording is starting");
              break;
          case "RECORDING_STARTED":
              Log.d("onRecordingStateChanged", "Meeting recording is started");
              break;
          case "RECORDING_STOPPING":
              Log.d("onRecordingStateChanged", "Meeting recording is stopping");
              break;
          case "RECORDING_STOPPED":
              Log.d("onRecordingStateChanged", "Meeting recording is stopped");
              break;
      }
  }
```

</TabItem>

</Tabs>

---

### onRecordingStarted()

_`This event will be deprecated soon`_

- This event will be emitted when recording of the meeting is started.

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
 override fun onRecordingStarted() {
   //
 }
```

</TabItem>

<TabItem value="Java">

```javascript
 @Override
 public void onRecordingStarted() {
   //
 }
```

</TabItem>

</Tabs>

---

### onRecordingStopped()

_`This event will be deprecated soon`_

- This event will be emitted when recording of the meeting is stopped.

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
 override fun onRecordingStopped() {
   //
 }
```

</TabItem>

<TabItem value="Java">

```javascript
 @Override
 public void onRecordingStopped() {
   //
 }
```

</TabItem>

</Tabs>

---

### onLivestreamStateChanged()

- This event will be emitted when the meeting's livestream status changed.

#### Event callback parameters

- **livestreamState**: String

`livestreamState` has following values

- `LIVESTREAM_STARTING` - Livestream is in starting phase and hasn't started yet.
- `LIVESTREAM_STARTED` - Livestream has started successfully.
- `LIVESTREAM_STOPPING` - Livestream is in stopping phase and hasn't stopped yet.
- `LIVESTREAM_STOPPED` - Livestream has stopped successfully.

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
  override fun onLivestreamStateChanged(livestreamState: String?) {
    when (livestreamState) {
        "LIVESTREAM_STARTING" -> Log.d( "LivestreamStateChanged",
            "Meeting livestream is starting"
        )
        "LIVESTREAM_STARTED" -> Log.d( "LivestreamStateChanged",
            "Meeting livestream is started"
        )
        "LIVESTREAM_STOPPING" -> Log.d("LivestreamStateChanged",
            "Meeting livestream is stopping"
        )
        "LIVESTREAM_STOPPED" -> Log.d("LivestreamStateChanged",
            "Meeting livestream is stopped"
        )
    }
  }
```

</TabItem>

<TabItem value="Java">

```javascript
  @Override
  public void onLivestreamStateChanged(String livestreamState) {
      switch (livestreamState) {
          case "LIVESTREAM_STARTING":
              Log.d("LivestreamStateChanged", "Meeting livestream is starting");
              break;
          case "LIVESTREAM_STARTED":
              Log.d("LivestreamStateChanged", "Meeting livestream is started");
              break;
          case "LIVESTREAM_STOPPING":
              Log.d("LivestreamStateChanged", "Meeting livestream is stopping");
              break;
          case "LIVESTREAM_STOPPED":
              Log.d("LivestreamStateChanged", "Meeting livestream is stopped");
              break;
      }
  }
```

</TabItem>

</Tabs>

---

### onLivestreamStarted()

_`This event will be deprecated soon`_

- This event will be emitted when `RTMP` live stream of the meeting is started.

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
 override fun onLivestreamStarted() {
   //
 }
```

</TabItem>

<TabItem value="Java">

```javascript
 @Override
 public void onLivestreamStarted() {
   //
 }
```

</TabItem>

</Tabs>

---

### onLivestreamStopped()

_`This event will be deprecated soon`_

- This event will be emitted when `RTMP` live stream of the meeting is stopped.

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
 override fun onLivestreamStopped() {
   //
 }
```

</TabItem>

<TabItem value="Java">

```javascript
 @Override
 public void onLivestreamStopped() {
   //
 }
```

</TabItem>

</Tabs>

---

### onHlsStateChanged()

- This event will be emitted when the meeting's HLS(Http Livestreaming) status changed.

#### Event callback parameters

- **HlsState**: \{ **status**: String}

  - `status` has following values :
    - `HLS_STARTING` - HLS is in starting phase and hasn't started yet.
    - `HLS_STARTED` - HLS has started successfully.
    - `HLS_PLAYABLE` - HLS can be playable now.
    - `HLS_STOPPING` - HLS is in stopping phase and hasn't stopped yet.
    - `HLS_STOPPED` - HLS has stopped successfully.

- when you receive `HLS_PLAYABLE` status you will receive 2 urls in response
  - `playbackHlsUrl` - Live HLS with playback support
  - `livestreamUrl` - Live HLS without playback support

:::note
`downstreamUrl` is now depecated. Use `playbackHlsUrl` or `livestreamUrl` in place of `downstreamUrl`
:::

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
  override fun onHlsStateChanged(HlsState: JSONObject) {
    when (HlsState.getString("status")) {
        "HLS_STARTING" -> Log.d("onHlsStateChanged", "Meeting hls is starting")
        "HLS_STARTED" -> Log.d("onHlsStateChanged", "Meeting hls is started")
        "HLS_PLAYABLE" -> {
            Log.d("onHlsStateChanged", "Meeting hls is playable now")
            // on hls playable you will receive playbackHlsUrl and livestreamUrl
            val playbackHlsUrl = HlsState.getString("playbackHlsUrl")
            val livestreamUrl = HlsState.getString("livestreamUrl")

        }
        "HLS_STOPPING" -> Log.d("onHlsStateChanged", "Meeting hls is stopping")
        "HLS_STOPPED" -> Log.d("onHlsStateChanged", "Meeting hls is stopped")
    }
  }
```

</TabItem>

<TabItem value="Java">

```javascript
  @Override
  public void onHlsStateChanged(JSONObject HlsState) {
      switch (HlsState.getString("status")) {
          case "HLS_STARTING":
              Log.d("onHlsStateChanged", "Meeting hls is starting");
              break;
          case "HLS_STARTED":
              Log.d("onHlsStateChanged", "Meeting hls is started");
              break;
          case "HLS_PLAYABLE":
              Log.d("onHlsStateChanged", "Meeting hls is playable now");
              // on hls started you will receive playbackHlsUrl and livestreamUrl
              String playbackHlsUrl = HlsState.getString("playbackHlsUrl");
              String livestreamUrl = HlsState.getString("livestreamUrl");
              break;
          case "HLS_STOPPING":
              Log.d("onHlsStateChanged", "Meeting hls is stopping");
              break;
          case "HLS_STOPPED":
              Log.d("onHlsStateChanged", "Meeting hls is stopped");
              break;
      }
  }
```

</TabItem>

</Tabs>

---

### onTranscriptionStateChanged()

- This event will be triggered whenever state of realtime transcription is changed.

#### Event callback parameters

- **data**: \{ **status**: String, **id**: String }
  - **status**: String
  - **id**: String

`status` has following values

- `TRANSCRIPTION_STARTING` - Realtime Transcription is in starting phase and hasn't started yet.
- `TRANSCRIPTION_STARTED` - Realtime Transcription has started successfully.
- `TRANSCRIPTION_STOPPING` - Realtime Transcription is in stopping phase and hasn't stopped yet.
- `TRANSCRIPTION_STOPPED` - Realtime Transcription has stopped successfully.

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
override fun onTranscriptionStateChanged(data: JSONObject) {
  //Status can be :: TRANSCRIPTION_STARTING
  //Status can be :: TRANSCRIPTION_STARTED
  //Status can be :: TRANSCRIPTION_STOPPING
  //Status can be :: TRANSCRIPTION_STOPPED
  val status = data.getString("status")
  Log.d("MeetingActivity", "Transcription status: $status")
}
```

</TabItem>

<TabItem value="Java">

```javascript
@Override
public void onTranscriptionStateChanged(JSONObject data) {
  //Status can be :: TRANSCRIPTION_STARTING
  //Status can be :: TRANSCRIPTION_STARTED
  //Status can be :: TRANSCRIPTION_STOPPING
  //Status can be :: TRANSCRIPTION_STOPPED
  String status = data.getString("status");
  Log.d("MeetingActivity", "Transcription status: " + status);
}
```

</TabItem>

</Tabs>

---

### onTranscriptionText()

- This event will be emitted when text for running realtime transcription received.

#### Event callback parameters

- **data**: TranscriptionText
  - **TranscriptionText.participantId**: String
  - **TranscriptionText.participantName**: String
  - **TranscriptionText.text**: String
  - **TranscriptionText.timestamp**: int
  - **TranscriptionText.type**: String

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
override fun onTranscriptionText(data: TranscriptionText) {
  val participantId = data.participantId
  val participantName = data.participantName
  val text = data.text
  val timestamp = data.timestamp
  val type = data.type

  Log.d("MeetingActivity", "$participantName: $text $timestamp")
}
```

</TabItem>

<TabItem value="Java">

```javascript
@Override
public void onTranscriptionText(TranscriptionText data) {
  String participantId = data.getParticipantId();
  String participantName = data.getParticipantName();
  String text = data.getText();
  int timestamp = data.getTimestamp();
  String type = data.getType();

  Log.d("MeetingActivity", participantName + ": " + text + " " + timestamp);
}
```

</TabItem>

</Tabs>

---

### onWhiteboardStarted()

- This event will be triggered when the whiteboard is successfully started.

#### Event callback parameters

**url**: String

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
override fun onWhiteboardStarted(url: String) {
    super.onWhiteboardStarted(url)
    //...
}
```

</TabItem>

<TabItem value="Java">

```java
@Override
public void onWhiteboardStarted(String url) {
    super.onWhiteboardStarted(url);
    //...
}
```

</TabItem>

</Tabs>

---

### onWhiteboardStopped()

- This event will be triggered when the whiteboard session is successfully terminated.

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
override fun onWhiteboardStopped() {
    super.onWhiteboardStopped()
    //...
}
```

</TabItem>

<TabItem value="Java">

```java
@Override
public void onWhiteboardStopped() {
    super.onWhiteboardStopped();
    //...
}
```

</TabItem>

</Tabs>

---

### onExternalCallStarted()

- This event will be emitted when local particpant receive incoming call.

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
 override fun onExternalCallStarted() {
   //
 }
```

</TabItem>

<TabItem value="Java">

```javascript
 @Override
 public void onExternalCallStarted() {
   //
 }
```

</TabItem>

</Tabs>

---

### onMeetingStateChanged()

- This event will be emitted when state of meeting changes.
- It will pass **`state`** as an event callback parameter which will indicate current state of the meeting.
- All available states are `CONNECTING`, `CONNECTED`, `FAILED`, `DISCONNECTED`, `CLOSING`, `CLOSED`.

#### Event callback parameters

- **state**: String

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
 override fun onMeetingStateChanged(state: String?) {
    when (state) {
      "CONNECTING" -> Log.d("onMeetingStateChanged: ", "Meeting is Connecting")
      "CONNECTED" -> Log.d("onMeetingStateChanged: ", "Meeting is Connected")
      "FAILED" -> Log.d("onMeetingStateChanged: ", "Meeting connection failed")
      "DISCONNECTED" -> Log.d("onMeetingStateChanged: ","Meeting connection disconnected abruptly")
      "CLOSING" -> Log.d("onMeetingStateChanged: ", "Meeting is closing")
      "CLOSED" -> Log.d("onMeetingStateChanged: ", "Meeting connection closed")
    }
  }
```

</TabItem>

<TabItem value="Java">

```javascript
@Override
  public void onMeetingStateChanged(String state) {
    switch (state) {
        case "CONNECTING":
          Log.d("onMeetingStateChanged: ", "Meeting is Connecting");
          break;
        case "CONNECTED":
          Log.d("onMeetingStateChanged: ", "Meeting is Connected");
          break;
        case "FAILED":
          Log.d("onMeetingStateChanged: ", "Meeting connection failed");
          break;
        case "DISCONNECTED":
          Log.d("onMeetingStateChanged: ", "Meeting connection disconnected abruptly");
          break;
        case "CLOSING":
          Log.d("onMeetingStateChanged: ", "Meeting is closing");
          break;
        case "CLOSED":
          Log.d("onMeetingStateChanged: ", "Meeting connection closed");
          break;
    }
  }

```

</TabItem>

</Tabs>

---
### onParticipantModeChanged()

This event is triggered when a participant's mode is updated.

It passes `data` as an event callback parameter, which includes the following:

- **`SEND_AND_RECV`**: Both audio and video streams will be produced and consumed.

- **`SIGNALLING_ONLY`**: Audio and video streams will not be produced or consumed. It is used solely for signaling.

- **`RECV_ONLY`**: Only audio and video streams will be consumed without producing any.
This event is triggered when a participant's mode is updated.

#### Event Callback Parameters

- **data**: `{ mode: String, participantId: String }`
  - **mode**: `String`
  - **participantId**: `String`

import CautionMessage from '@site/src/theme/CautionMessage';


<CautionMessage sdk="Android SDK" version="v0.2.0" />


#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
 override fun onParticipantModeChanged(data: JSONObject?) {
   //
  }
```

</TabItem>

<TabItem value="Java">

```javascript
@Override
  public void onParticipantModeChanged(JSONObject data) {
    //
  }

```

</TabItem>

</Tabs>

---

### onPinStateChanged()

- This event will be triggered when any participant got pinned or unpinned by any participant got pinned or unpinned by any participant.

#### Event callback parameters

- **pinStateData**: \{ **peerId**: String, **state**: JSONObject, **pinnedBy**: String }
  - **peerId**: String
  - **state**: JSONObject
  - **pinnedBy**: String

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
 override fun onPinStateChanged(pinStateData: JSONObject?) {
   Log.d("onPinStateChanged: ", pinStateData.getString("peerId")) // id of participant who were pinned
   Log.d("onPinStateChanged: ", pinStateData.getJSONObject("state")) // { cam: true, share: true }
   Log.d("onPinStateChanged: ", pinStateData.getString("pinnedBy")) // id of participant who pinned that participant
  }
```

</TabItem>

<TabItem value="Java">

```javascript
@Override
  public void onPinStateChanged(JSONObject pinStateData) {
    Log.d("onPinStateChanged: ", pinStateData.getString("peerId")); // id of participant who were pinned
    Log.d("onPinStateChanged: ", pinStateData.getJSONObject("state")); // { cam: true, share: true }
    Log.d("onPinStateChanged: ", pinStateData.getString("pinnedBy")); // id of participant who pinned that participant
  }

```

</TabItem>

</Tabs>

</div>


---

---
sidebar_position: 1
sidebar_label: Methods
pagination_label: Meeting Class Methods
title: Meeting Class Methods
---

# Meeting Class Methods - Android

<div class="sdk-api-ref-only-h4">

### join()

- It is used to join a meeting.
- After meeting initialization by [`initMeeting()`](../initMeeting) it returns a new instance of [Meeting](./introduction). However by default, it will not automatically join the meeting. Hence, to join the meeting you should call `join()`.

#### Events associated with `join()`:

- Local Participant will receive a [`onMeetingJoined`](./meeting-event-listener-class#onmeetingjoined) event, when successfully joined.
- Remote Participant will receive a [`onParticipantJoined`](./meeting-event-listener-class#onparticipantjoined) event with the newly joined [`Participant`](../participant-class/introduction) object from the event callback.

#### Participant having `ask_join` permission inside token

- If a token contains the permission `ask_join`, then the participant will not join the meeting directly after calling `join()`, but an event will be emitted to the participant having the permission `allow_join` called [`onEntryRequested`](./meeting-event-listener-class#onentryrequested).

- After the decision from the remote participant, an event will be emitted to participant called [`onEntryResponded`](./meeting-event-listener-class#onentryresponded). This event will contain the decision made by the remote participant.

#### Participant having `allow_join` permission inside token

- If a token containing the permission `allow_join`, then the participant will join the meeting directly after calling `join()`.

#### Returns

- _`void`_

---

### leave()

- It is used to leave the current meeting.

#### Events associated with `leave()`:

- Local participant will receive a [`onMeetingLeft`](./meeting-event-listener-class#onmeetingleft) event.
- All remote participants will receive a [`onParticipantLeft`](./meeting-event-listener-class#onparticipantleft) event with `participantId`.

#### Returns

- _`void`_

---

### end()

- It is used to end the current running session.
- By calling `end()`, all joined [participants](properties#getparticipants) including [localParticipant](./properties.md#getlocalparticipant) of that session will leave the meeting.

#### Events associated with `end()`:

- All [participants](./properties.md#getparticipants) and [localParticipant](./properties.md#getlocalparticipant), will be emitted [`onMeetingLeft`](./meeting-event-listener-class#onmeetingleft) event.

#### Returns

- _`void`_

---

### enableWebcam()

- It is used to enable self camera.
- [`onStreamEnabled`](../participant-class/participant-event-listener-class#onstreamenabled) event of `ParticipantEventListener` will be emitted with [`stream`](../stream-class/introduction) object from the event callback.

#### Returns

- _`void`_

---

### disableWebcam()

- It is used to disable self camera.
- [`onStreamDisabled`](../participant-class/participant-event-listener-class#onstreamdisabled) event of `ParticipantEventListener` will be emitted with [`stream`](../stream-class/introduction) object from the event callback.

#### Returns

- _`void`_

---

### unmuteMic()

- It is used to enable self microphone.
- [`onStreamEnabled`](../participant-class/participant-event-listener-class#onstreamenabled) event of `ParticipantEventListener` will be emitted with [`stream`](../stream-class/introduction) object from the event callback.

#### Returns

- _`void`_

---

### muteMic()

- It is used to disable self microphone.
- [`onStreamDisabled`](../participant-class/participant-event-listener-class#onstreamdisabled) event of `ParticipantEventListener` will be emitted with [`stream`](../stream-class/introduction) object from the event callback.

#### Returns

- _`void`_

---

### enableScreenShare()

- it is used to enable screen-sharing.

- [`onStreamEnabled`](../participant-class/participant-event-listener-class#onstreamenabled) event of `ParticipantEventListener` will be emitted with [`stream`](../stream-class/introduction) object from the event callback.

- [`onPresenterChanged()`](./meeting-event-listener-class#onpresenterchanged) event will be trigget to all participant with `participantId`.

#### Parameters

- **data**: Intent

#### Returns

- _`void`_

---

### disableScreenShare()

- It is used to disable screen-sharing.

- [`onStreamDisabled`](../participant-class/participant-event-listener-class#onstreamdisabled) event of `ParticipantEventListener` will be emitted with [`stream`](../stream-class/introduction) object from the event callback.

- [`onPresenterChanged()`](./meeting-event-listener-class#onpresenterchanged) event will be trigget to all participant with `null`.

#### Returns

- _`void`_

---

### uploadBase64File()

- It is used to upload your file to Videosdk's Temporary storage.

- `base64Data` convert your file to base64 and pass here.
- `token` pass your videosdk token. Read more about token [here](/android/guide/video-and-audio-calling-api-sdk/authentication-and-token)
- `fileName` provide your fileName with extension.
- `TaskCompletionListener` will handle the result of the upload operation.

  - When the upload is complete, the `onComplete()` method of `TaskCompletionListener` will provide the corresponding `fileUrl`, which can be used to retrieve the uploaded file.

  - If an error occurs during the upload process, the `onError()` method of `TaskCompletionListener` will provide the error details.

#### Parameters

- **base64Data**: String
- **token**: String
- **fileName**: String
- **listener**: TaskCompletionListener

#### Returns

- _`void`_

#### Example

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
private fun uploadFile() {
  val base64Data = "<Your File's base64>" // Convert your file to base64 and pass here
  val token = "<VIDEOSDK_TOKEN>"
  val fileName = "myImage.jpeg" // Provide name with extension here
  meeting!!.uploadBase64File(
    base64Data,
    token,
    fileName,
    object : TaskCompletionListener<String?, String?> {
      override fun onComplete(data: String?) {
          Log.d("VideoSDK", "Uploaded file url: $data")
      }

      override fun onError(error: String?) {
          Log.d("VideoSDK", "Error in upload file: $error")
      }
    }
  )
}
```

</TabItem>

<TabItem value="Java">

```js
private void uploadFile() {
  String base64Data = "<Your File's base64>"; // Convert your file to base64 and pass here
  String token = "<VIDEOSDK_TOKEN>";
  String fileName = "myImage.jpeg"; // Provide name with extension here
  meeting.uploadBase64File(base64Data, token, fileName, new TaskCompletionListener<String, String>() {
    @Override
    public void onComplete(@Nullable String data) {
        Log.d("VideoSDK", "Uploaded file url: " + data);
    }

    @Override
    public void onError(@Nullable String error) {
        Log.d("VideoSDK", "Error in upload file: " + error);
    }
  });
}
```

</TabItem>

</Tabs>

---

### fetchBase64File()

- It is used to retrieve your file from the Videosdk's Temporary storage.

- `url` pass fileUrl which is returned by `uploadBase64File()`
- `token` pass your videosdk token. Read more about token [here](/android/guide/video-and-audio-calling-api-sdk/authentication-and-token)
- `TaskCompletionListener` will handle the result of the fetch operation.

  - When the fetch operation is complete, the `onComplete()` method of `TaskCompletionListener` will provide the file in `base64` format.

  - If an error occurs during the fetch operation, the `onError()` method of `TaskCompletionListener` will provide the error details.

#### Parameters

- **url**: String
- **token**: String
- **listener**: TaskCompletionListener

#### Returns

- _`void`_

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
private fun fetchFile() {
  val url = "<Your FileUrl>"  // Provide fileUrl which is returned by uploadBase64File()
  val token = "<VIDEOSDK_TOKEN>"
  meeting.fetchBase64File(url, token, object : TaskCompletionListener<String?, String?> {
      override fun onComplete(data: String?) {
          Log.d("VideoSDK", "Fetched file in base64:$data")
      }

      override fun onError(error: String?) {
          Log.d("VideoSDK", "Error in fetch file: $error")
      }
  })
}
```

</TabItem>

<TabItem value="Java">

```js
private void fetchFile() {
  String url = "<Your FileUrl>";  // Provide fileUrl which is returned by uploadBase64File()
  String token = "<VIDEOSDK_TOKEN>";
  meeting.fetchBase64File(url, token, new TaskCompletionListener<String, String>() {
      @Override
      public void onComplete(@Nullable String data) {
          Log.d("VideoSDK", "Fetched file in base64:" + data);
      }

      @Override
      public void onError(@Nullable String error) {
          Log.d("VideoSDK", "Error in fetch file: " + error);
      }
  });
}
```

</TabItem>

</Tabs>

---

### startRecording()

- `startRecording` is used to start meeting recording.

- `webhookUrl` will be triggered when the recording is completed and stored into server. Read more about webhooks [here](https://en.wikipedia.org/wiki/Webhook).

- `awsDirPath` will be the path for the your S3 bucket where you want to store recordings to. To allow us to store recording in your S3 bucket, you will need to fill this form by providing the required values. [VideoSDK AWS S3 Integration](https://zfrmz.in/RVlFLFiturVJ7Q97fr23)

- `config: mode` is used to either record video-and-audio both or only audio. And by default it will be video-and-audio.

- `config: quality` is only applicable to video-and-audio.

- `transcription` This parameter lets you start post transcription for the recording.

#### Parameters

- **webhookUrl**: String
- **awsDirPath**: String
- **config**:

  - **layout**:
    - **type**: _"GRID"_ | _"SPOTLIGHT"_ | _"SIDEBAR"_
    - **priority**: _"SPEAKER"_ | _"PIN"_
    - **gridSize**: Number _`max 4`_
  - **theme**: _"DARK"_ | _"LIGHT"_ | _"DEFAULT"_
  - **mode**: _"video-and-audio"_ | _"audio"_
  - **quality**: _"low"_ | _"med"_ | _"high"_
  - **orientation**: _"landscape"_ | _"portrait"_

- **transcription**: **PostTranscriptionConfig**
  - **PostTranscriptionConfig.enabled**: boolean
  - **PostTranscriptionConfig.modelId**: String
  - **PostTranscriptionConfig.summary**: SummaryConfig
    - **SummaryConfig.enabled**: boolean
    - **SummaryConfig.prompt**: String

#### Returns

- _`void`_

#### Events associated with `startRecording()`:

- Every participant will receive a callback on [`onRecordingStateChanged()`](./meeting-event-listener-class#onrecordingstatechanged)

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
val webhookUrl = "https://webhook.your-api-server.com"
var config = JSONObject()
var layout = JSONObject()
JsonUtils.jsonPut(layout, "type", "SPOTLIGHT")
JsonUtils.jsonPut(layout, "priority", "PIN")
JsonUtils.jsonPut(layout, "gridSize", 9)
JsonUtils.jsonPut(config, "layout", layout)
JsonUtils.jsonPut(config, "theme", "DARK")

val prompt = "Write summary in sections like Title, Agenda, Speakers, Action Items, Outlines, Notes and Summary"
val summaryConfig = SummaryConfig(true, prompt)
val modelId = "raman_v1"
val transcription = PostTranscriptionConfig(true, summaryConfig, modelId)

meeting!!.startRecording(webhookUrl,null,config,transcription)
```

</TabItem>

<TabItem value="Java">

```js
String webhookUrl = "https://webhook.your-api-server.com";
JSONObject config = new JSONObject();
JSONObject layout = new JSONObject();
JsonUtils.jsonPut(layout, "type", "SPOTLIGHT");
JsonUtils.jsonPut(layout, "priority", "PIN");
JsonUtils.jsonPut(layout, "gridSize", 9);
JsonUtils.jsonPut(config, "layout", layout);
JsonUtils.jsonPut(config, "theme", "DARK");

String prompt = "Write summary in sections like Title, Agenda, Speakers, Action Items, Outlines, Notes and Summary";
SummaryConfig summaryConfig = new SummaryConfig(true, prompt);
String modelId = "raman_v1";
PostTranscriptionConfig transcription = new PostTranscriptionConfig(true, summaryConfig, modelId);

meeting.startRecording(webhookUrl,null,config,transcription);
```

</TabItem>

</Tabs>

---

### stopRecording()

- It is used to stop meeting recording.

#### Returns

- _`void`_

#### Events associated with `stopRecording()`:

- Every participant will receive a callback on [`onRecordingStateChanged()`](./meeting-event-listener-class#onrecordingstatechanged)

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
meeting!!.stopRecording()
```

</TabItem>

<TabItem value="Java">

```javascript
meeting.stopRecording();
```

</TabItem>

</Tabs>

---

### startLivestream()

- `startLiveStream()` is used to start meeting livestreaming.

- You will be able to start live stream meetings to other platforms such as Youtube, Facebook, etc. that support `RTMP` streaming.

#### Parameters

- **outputs**: `List<LivestreamOutput>`
- **config**:
  - **layout**:
    - **type**: _"GRID"_ | _"SPOTLIGHT"_ | _"SIDEBAR"_
    - **priority**: _"SPEAKER"_ | _"PIN"_
    - **gridSize**: Number _`max 25`_
  - **theme**: _"DARK"_ | _"LIGHT"_ | _"DEFAULT"_

#### Returns

- _`void`_

#### Events associated with `startLiveStream()`:

- Every participant will receive a callback on [`onLivestreamStateChanged()`](./meeting-event-listener-class#onlivestreamstatechanged)

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
val YOUTUBE_RTMP_URL = "rtmp://a.rtmp.youtube.com/live2"
val YOUTUBE_RTMP_STREAM_KEY = "<STREAM_KEY>"

val outputs: MutableList<LivestreamOutput> = ArrayList()
outputs.add(LivestreamOutput(YOUTUBE_RTMP_URL, YOUTUBE_RTMP_STREAM_KEY))

var config = JSONObject()
var layout = JSONObject()
JsonUtils.jsonPut(layout, "type", "SPOTLIGHT")
JsonUtils.jsonPut(layout, "priority", "PIN")
JsonUtils.jsonPut(layout, "gridSize", 9)
JsonUtils.jsonPut(config, "layout", layout)
JsonUtils.jsonPut(config, "theme", "DARK")

meeting!!.startLivestream(outputs,config)
```

</TabItem>

<TabItem value="Java">

```javascript
final String YOUTUBE_RTMP_URL = "rtmp://a.rtmp.youtube.com/live2";
final String YOUTUBE_RTMP_STREAM_KEY = "<STREAM_KEY>";

List<LivestreamOutput> outputs = new ArrayList<>();
outputs.add(new LivestreamOutput(YOUTUBE_RTMP_URL, YOUTUBE_RTMP_STREAM_KEY));

JSONObject config = new JSONObject();
JSONObject layout = new JSONObject();
JsonUtils.jsonPut(layout, "type", "SPOTLIGHT");
JsonUtils.jsonPut(layout, "priority", "PIN");
JsonUtils.jsonPut(layout, "gridSize", 9);
JsonUtils.jsonPut(config, "layout", layout);
JsonUtils.jsonPut(config, "theme", "DARK");

meeting.startLivestream(outputs,config);
```

</TabItem>

</Tabs>

---

### stopLivestream()

- It is used to stop meeting livestreaming.

#### Returns

- _`void`_

#### Events associated with `stopLivestream()`:

- Every participant will receive a callback on [`onLivestreamStateChanged()`](./meeting-event-listener-class#onlivestreamstatechanged)

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
meeting!!.stopLivestream()
```

</TabItem>

<TabItem value="Java">

```javascript
meeting.stopLivestream();
```

</TabItem>

</Tabs>

---

### startHls()

- `startHls()` will start HLS streaming of your meeting.

- You will be able to start HLS and watch the live stream of meeting over HLS.

- `mode` is used to either start hls streaming of video-and-audio both or only audio. And by default it will be video-and-audio.

- `quality` is only applicable to video-and-audio.

- `transcription` This parameter lets you start post transcription for the recording.

#### Parameters

- **config**:

  - **layout**:
    - **type**: _"GRID"_ | _"SPOTLIGHT"_ | _"SIDEBAR"_
    - **priority**: _"SPEAKER"_ | _"PIN"_
    - **gridSize**: Number _`max 25`_
  - **theme**: _"DARK"_ | _"LIGHT"_ | _"DEFAULT"_
  - **mode**: _"video-and-audio"_ | _"audio"_
  - **quality**: _"low"_ | _"med"_ | _"high"_

- **transcription**: **PostTranscriptionConfig**
  - **PostTranscriptionConfig.enabled**: boolean
  - **PostTranscriptionConfig.modelId**: String
  - **PostTranscriptionConfig.summary**: SummaryConfig
    - **SummaryConfig.enabled**: boolean
    - **SummaryConfig.prompt**: String

#### Returns

- _`void`_

#### Events associated with `startHls()`:

- Every participant will receive a callback on [`onHlsStateChanged()`](./meeting-event-listener-class#onhlsstatechanged)

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
var config = JSONObject()
var layout = JSONObject()
JsonUtils.jsonPut(layout, "type", "SPOTLIGHT")
JsonUtils.jsonPut(layout, "priority", "PIN")
JsonUtils.jsonPut(layout, "gridSize", 9)
JsonUtils.jsonPut(config, "layout", layout)
JsonUtils.jsonPut(config, "orientation", "portrait")
JsonUtils.jsonPut(config, "theme", "DARK")

val prompt = "Write summary in sections like Title, Agenda, Speakers, Action Items, Outlines, Notes and Summary"
val summaryConfig = SummaryConfig(true, prompt)
val modelId = "raman_v1"
val transcription = PostTranscriptionConfig(true, summaryConfig,modelId)

meeting!!.startHls(config, transcription)
```

</TabItem>

<TabItem value="Java">

```javascript
JSONObject config = new JSONObject();
JSONObject layout = new JSONObject();
JsonUtils.jsonPut(layout, "type", "SPOTLIGHT");
JsonUtils.jsonPut(layout, "priority", "PIN");
JsonUtils.jsonPut(layout, "gridSize", 9);
JsonUtils.jsonPut(config, "layout", layout);
JsonUtils.jsonPut(config, "orientation", "portrait");
JsonUtils.jsonPut(config, "theme", "DARK");

String prompt = "Write summary in sections like Title, Agenda, Speakers, Action Items, Outlines, Notes and Summary";
SummaryConfig summaryConfig = new SummaryConfig(true, prompt);
String modelId = "raman_v1";
PostTranscriptionConfig transcription = new PostTranscriptionConfig(true, summaryConfig,modelId);

meeting.startHls(config,transcription);
```

</TabItem>

</Tabs>

---

### stopHls()

- `stopHls()` is used to stop the HLS streaming.

#### Returns

- _`void`_

#### Events associated with `stopHls()`:

- Every participant will receive a callback on [`onHlsStateChanged()`](./meeting-event-listener-class#onhlsstatechanged)

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
meeting!!.stopHls()
```

</TabItem>

<TabItem value="Java">

```javascript
meeting.stopHls();
```

</TabItem>

</Tabs>

---

### startTranscription()

- `startTranscription()` It is used to start realtime transcription.

#### Parameters

#### config

- type : `TranscriptionConfig`

- This specifies the configurations for realtime transcription. You can specify following properties.
  - `TranscriptionConfig.webhookUrl`: Webhooks will be triggered when the state of realtime transcription is changed. Read more about webhooks [here](https://en.wikipedia.org/wiki/Webhook)
  - `TranscriptionConfig.summary`: `SummaryConfig`
    - `enabled`: Indicates whether realtime transcription summary generation is enabled. Summary will be available after realtime transcription stopped. Default: `false`
    - `prompt`: provides guidelines or instructions for generating a custom summary based on the realtime transcription content.

#### Returns

- _`void`_

#### Events associated with `startTranscription()`:

- Every participant will receive a callback on [`onTranscriptionStateChanged()`](./meeting-event-listener-class#ontranscriptionstatechanged)

- Every participant will receive a callback on [`onTranscriptionText()`](./meeting-event-listener-class#ontranscriptiontext)

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
// Realtime Transcription Configuration
val webhookUrl = "https://www.example.com"

val summaryConfig = SummaryConfig(
    true,
    "Write summary in sections like Title, Agenda, Speakers, Action Items, Outlines, Notes and Summary"
)
val transcriptionConfig = TranscriptionConfig(
    webhookUrl,
    summaryConfig
)

meeting!!.startTranscription(transcriptionConfig)
```

</TabItem>

<TabItem value="Java">

```javascript
// Realtime Transcription Configuration
final String webhookUrl = "https://www.example.com";

SummaryConfig summaryConfig = new SummaryConfig(
    true,
    "Write summary in sections like Title, Agenda, Speakers, Action Items, Outlines, Notes and Summary"
);
TranscriptionConfig transcriptionConfig = new TranscriptionConfig(
    webhookUrl,
    summaryConfig
);

meeting.startTranscription(transcriptionConfig);
```

</TabItem>

</Tabs>

---

### stopTranscription()

- `stopTranscription()` It is used to stop realtime transcription.

#### Returns

- _`void`_

#### Events associated with `startTranscription()`:

- Every participant will receive a callback on [`onTranscriptionStateChanged()`](./meeting-event-listener-class#ontranscriptionstatechanged)

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
meeting!!.stopTranscription()
```

</TabItem>

<TabItem value="Java">

```javascript
meeting.stopTranscription();
```

</TabItem>

</Tabs>

---

### startWhiteboard()

- It is used to initilize a whiteboard session.

#### Returns

- _`void`_

---

### stopWhiteboard()

- It is used to end a whiteboard session.

#### Returns

- _`void`_

---

### changeMode()

- It is used to change the mode.
- You can toggle between the following modes:

  - **`SEND_AND_RECV`**: Both audio and video streams will be produced and consumed.

  - **`SIGNALLING_ONLY`**: Audio and video streams will not be produced or consumed. It is used solely for signaling.

  - **`RECV_ONLY`**: Only audio and video streams will be consumed without producing any.

import CautionMessage from '@site/src/theme/CautionMessage';

<CautionMessage sdk="Android SDK" version="v0.2.0" />

#### Parameters

- **mode**: `String`
- **mode**: `String`

#### Returns

- _`void`_

#### Events associated with `changeMode()`:

- Every participant will receive a callback on [`onParticipantModeChanged()`](./meeting-event-listener-class#onparticipantmodechanged)

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
meeting!!.changeMode("SIGNALLING_ONLY")
meeting!!.changeMode("SIGNALLING_ONLY")
```

</TabItem>

<TabItem value="Java">

```javascript
meeting!!.changeMode("SIGNALLING_ONLY")
meeting!!.changeMode("SIGNALLING_ONLY")
```

</TabItem>

</Tabs>

---

### getMics()

- It will return all connected mic devices.

#### Returns

- `Set<AppRTCAudioManager.AudioDevice>`

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
val mics = meeting!!.mics
var mic: String
for (i in mics.indices) {
  mic = mics.toTypedArray()[i].toString()
  Toast.makeText(this, "Mic : $mic", Toast.LENGTH_SHORT).show()
}
```

</TabItem>

<TabItem value="Java">

```javascript
Set<AppRTCAudioManager.AudioDevice> mics = meeting.getMics();
String mic;
for (int i = 0; i < mics.size(); i++) {
    mic=mics.toArray()[i].toString();
    Toast.makeText(this, "Mic : " + mic, Toast.LENGTH_SHORT).show();
}
```

</TabItem>

</Tabs>

---

### changeMic()

- It is used to change the mic device.
- If multiple mic devices are connected, by using `changeMic()` one can change the mic device.

#### Parameters

- **device**: AppRTCAudioManager.AudioDevice

#### Returns

- _`void`_

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
meeting!!.changeMic(AppRTCAudioManager.AudioDevice.BLUETOOTH)
```

</TabItem>

<TabItem value="Java">

```javascript
meeting.changeMic(AppRTCAudioManager.AudioDevice.BLUETOOTH);
```

</TabItem>

</Tabs>

---

### changeWebcam()

- It is used to change the camera device.
- If multiple camera devices are connected, by using `changeWebcam()`, one can change the camera device with its respective device id.
- You can get a list of connected video devices using [`VideoSDK.getVideoDevices()`](../videosdk-class/methods#getvideodevices)

#### Parameters

- **deviceId**:

  - The `deviceId` represents the unique identifier of the camera device you wish to switch to. If no deviceId is provided, the facing mode will toggle, from the back camera to the front camera if the back camera is currently in use, or from the front camera to the back camera if the front camera is currently in use.

    - type : String
    - `OPTIONAL`

#### Returns

- _`void`_

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
meeting!!.changeWebcam()
```

</TabItem>

<TabItem value="Java">

```javascript
meeting.changeWebcam();
```

</TabItem>

</Tabs>

---

### setAudioDeviceChangeListener()

- When a Local participant changes the Mic, `AppRTCAudioManager.AudioManagerEvents()` is triggered which can be set by using `setAudioDeviceChangeListener()` method.

#### Parameters

- **audioManagerEvents**: AppRTCAudioManager.AudioManagerEvents

#### Returns

- _`void`_

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
    meeting!!.setAudioDeviceChangeListener(object : AudioManagerEvents {
      override fun onAudioDeviceChanged(
        selectedAudioDevice: AppRTCAudioManager.AudioDevice,
        availableAudioDevices: Set<AppRTCAudioManager.AudioDevice>
      ) {
          when (selectedAudioDevice) {
            AppRTCAudioManager.AudioDevice.BLUETOOTH ->
              Toast.makeText(this@MainActivity, "Selected AudioDevice: BLUETOOTH", Toast.LENGTH_SHORT).show()

            AppRTCAudioManager.AudioDevice.WIRED_HEADSET ->
              Toast.makeText(this@MainActivity, "Selected AudioDevice: WIRED_HEADSET", Toast.LENGTH_SHORT).show()

            AppRTCAudioManager.AudioDevice.SPEAKER_PHONE ->
              Toast.makeText(this@MainActivity, "Selected AudioDevice: SPEAKER_PHONE", Toast.LENGTH_SHORT).show()

            AppRTCAudioManager.AudioDevice.EARPIECE ->
              Toast.makeText(this@MainActivity, "Selected AudioDevice: EARPIECE", Toast.LENGTH_SHORT).show()
          }
        }
    })
```

</TabItem>

<TabItem value="Java">

```javascript
    meeting.setAudioDeviceChangeListener(new AppRTCAudioManager.AudioManagerEvents() {
         @Override
        public void onAudioDeviceChanged(AppRTCAudioManager.AudioDevice selectedAudioDevice, Set<AppRTCAudioManager.AudioDevice> availableAudioDevices) {
            switch (selectedAudioDevice) {
                case BLUETOOTH:
                  Toast.makeText(MainActivity.this, "Selected AudioDevice: BLUETOOTH", Toast.LENGTH_SHORT).show();
                  break;
                case WIRED_HEADSET:
                  Toast.makeText(MainActivity.this, "Selected AudioDevice: WIRED_HEADSET", Toast.LENGTH_SHORT).show();
                  break;
                case SPEAKER_PHONE:
                  Toast.makeText(MainActivity.this, "Selected AudioDevice: SPEAKER_PHONE", Toast.LENGTH_SHORT).show();
                  break;
                case EARPIECE:
                  Toast.makeText(MainActivity.this, "Selected AudioDevice: EARPIECE", Toast.LENGTH_SHORT).show();
                  break;
               }
        }
    });
```

</TabItem>

</Tabs>

---

### addEventListener()

#### Parameters

- **listener**: MeetingEventListener

#### Returns

- _`void`_

---

### removeEventListener()

#### Parameters

- **listener**: MeetingEventListener

#### Returns

- _`void`_

---

### removeAllListeners()

#### Returns

- _`void`_
</div>


---

---
sidebar_position: 1
sidebar_label: Properties
pagination_label: Meeting Class Properties
title: Meeting Class Properties
---

# Meeting Class Properties - Android

<div class="sdk-api-ref-only-h4">

### getmeetingId()

- type: `String`

- `getmeetingId()` will return `meetingId`, which is unique id of the meeting where the participant has joined.

---

### getLocalParticipant()

- type: [Participant](../participant-class/introduction)

- It will be the instance of [Participant](../participant-class/introduction) class for the local participant(You) who joined the meeting.

---

### getParticipants()

- type: [`Map`](https://developer.android.com/reference/java/util/Map) of [Participant](../participant-class/introduction)

- `Map<String, Participant>`

  - Map{'<'}`participantId`, [Participant](../participant-class/introduction)>

- It will contain all joined participants in the meeting except the `localParticipant`.

- This will be the [`Map`](https://developer.android.com/reference/java/util/Map) what will container all participants attached with the key as id of that participant.

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
val remoteParticipantId = "ajf897"

val participant = meeting!!.participants[remoteParticipantId]
```

</TabItem>

<TabItem value="Java">

```javascript
String remoteParticipantId = "ajf897";

Participant participant = meeting.getParticipants().get(remoteParticipantId);
```

</TabItem>

</Tabs>

---

### pubSub

- type: [`PubSub`](../pubsub-class/introduction)
- It is used to enable Publisher-Subscriber feature in [`meeting`](introduction) class.

Learn more about `PubSub`, [here](../pubsub-class/introduction)

</div>


---

---
title: Meeting class for android SDK.
hide_title: false
hide_table_of_contents: false
description: RTC Meeting Class provides features to implement custom meeting layout in your application.
sidebar_label: Meeting Class
pagination_label: Meeting Class
keywords:
  - RTC Android
  - Meeting Class
  - Video API
  - Video Conferencing
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: meeting-class
---

import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>

# Meeting Class

## using Meeting Class

The `Meeting Class` includes methods and events for managing meetings, participants, video & audio streams, data channels and UI customization.

import MethodListGroup from '@theme/MethodListGroup';
import MethodListItemLabel from '@theme/MethodListItemLabel';
import MethodListHeading from '@theme/MethodListHeading';

## Constructor

### Meeting(String meetingId, Participant localParticipant)

- return type : `void`

## Properties

### getmeetingId()

- `getmeetingId()` will return `meetingId`, which represents the meetingId for the current meeting
- return type : `void`

### getLocalParticipant()

- `getLocalParticipant()` will return Local participant
- return type :`Participant`

### getParticipants()

- `getParticipants()` will return all Remote participant
- return type : `void`

### pubSub()

- `pubSub()` will return object of `PubSub` class
- return type : `PubSub`

### Events

<MethodListGroup>
  <MethodListItemLabel name="__events" >
    <MethodListGroup>
      <MethodListHeading heading="Events" />
      <MethodListItemLabel name="addEventListener(MeetingEventListener listener)"  type={"void"} />
      <MethodListItemLabel name="removeEventListener(MeetingEventListener listener)"  type={"void"} />
      <MethodListItemLabel name="removeAllListeners()"  type={"void"} />
    </MethodListGroup>
  </MethodListItemLabel>
</MethodListGroup>

### Methods

<MethodListGroup>
  <MethodListItemLabel name="__methods" >
    <MethodListGroup>
      <MethodListHeading heading="Methods" />
      <MethodListItemLabel description={"join the meeting"} name="join()"  type={"void"} />
      <MethodListItemLabel description={"leave the meeting"} name="leave()"  type={"void"} />
      <MethodListItemLabel description={"end the meeting"} name="end()"  type={"void"} />
      <MethodListItemLabel description={"enable self mic"} name="muteMic()"  type={"void"} />
      <MethodListItemLabel description={"disable self mic"} name="unmuteMic()"  type={"void"} />
      <MethodListItemLabel description={"enable self webcam"} name="enableWebcam()"  type={"void"} />
      <MethodListItemLabel description={"disable self webcam"} name="disableWebcam()"  type={"void"} />
      <MethodListItemLabel description={"start meeting recording"} name="startRecording(String webhookUrl)"  type={"void"} />
      <MethodListItemLabel description={"stop meeting recording"} name="stopRecording()"  type={"void"} />
      <MethodListItemLabel description={"start meeting live streaming"} name="startLivestream(List<LivestreamOutput> outputs)"  type={"void"} />
      <MethodListItemLabel description={"stop meeting live streaming"} name="stopLivestream()"  type={"void"} />
      <MethodListItemLabel description={"get all mic devices"} name="getMics()"  type={"Set<AppRTCAudioManager.AudioDevice>"} />
      <MethodListItemLabel description={"change self mic"} name="changeMic()"  type={"void"} />
      <MethodListItemLabel description={"When a Local participant changes the Mic, `AppRTCAudioManager.AudioManagerEvents()` is triggered which can be set by using this method"} name="setAudioDeviceChangeListener(AppRTCAudioManager.AudioManagerEvents audioManagerEvents)"  type={"void"} />
      <MethodListItemLabel description={"change self webcam"} name="changeWebcam()"  type={"void"} />
      <MethodListItemLabel description={"start sharing phone screen"} name="enableScreenShare(Intent data)"  type={"void"} />
      <MethodListItemLabel description={"stop sharing phone screen"} name="disableScreenShare()"  type={"void"} />
    </MethodListGroup>
  </MethodListItemLabel>
</MethodListGroup>


---

---
title: MeetingEventListener Class for android SDK.
hide_title: false
hide_table_of_contents: false
description: The `MeetingEventListener Class` includes list of events which can be useful for the design custom user interface.
sidebar_label: MeetingEventListener Class
pagination_label: MeetingEventListener Class
keywords:
  - RTC Android
  - MeetingEventListener Class
  - Video API
  - Video Conferencing
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: meeting-event-listener-class
---

import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>

# MeetingEventListener Class

## using MeetingEventListener Class

The `MeetingEventListener Class` is responsible for listening to all the events that are related to `Meeting Class`.

import MethodListGroup from '@theme/MethodListGroup';
import MethodListItemLabel from '@theme/MethodListItemLabel';
import MethodListHeading from '@theme/MethodListHeading';

### Listeners

<MethodListGroup>
  <MethodListItemLabel name="__listeners" >
    <MethodListGroup>
      <MethodListHeading heading="Listeners" />
      <MethodListItemLabel description={"emitted when local participant joined the meeting successfully"} name="onMeetingJoined()"  type={"void"} />
      <MethodListItemLabel description={"emitted when local participant left the meeting"} name="onMeetingLeft()"  type={"void"} />
      <MethodListItemLabel description={"emitted when new participant joined the meeting"} name="onParticipantJoined(Participant participant)"  
      type={"void"} />
      <MethodListItemLabel description={"emitted when any participant left the meeting"} name="onParticipantLeft(Participant participant)"  type={"void"} />
      <MethodListItemLabel description={"emitted when remote participant requested for entry in the meeting"} name="onEntryRequested(String id, String name)"  type={"void"} />
      <MethodListItemLabel description={"emitted when meeting host responded to participant's joining request"} 
      name="onEntryResponded(String id, String decision)"  type={"void"} />
      <MethodListItemLabel description={"emitted when any participant shared the screen"} name="onPresenterChanged(String participantId)"  type={"void"} />
      <MethodListItemLabel description={"emitted when active speaker is changed"} name="onSpeakerChanged(String participantId)"  type={"void"} />
      <MethodListItemLabel description={"emitted when the meeting's recording status changed"} name="onRecordingStateChanged(String recordingState)"  type={"void"} />
      <MethodListItemLabel description={"emitted when recording of the meeting is started successfully"} name="onRecordingStarted()"  type={"void"} />
      <MethodListItemLabel description={"emitted when recording of the meeting is stopped"} name="onRecordingStopped()"  type={"void"} />
      <MethodListItemLabel description={"emitted when the meeting's livestream status changed"} name="onLivestreamStateChanged(String livestreamState)"  type={"void"} />
      <MethodListItemLabel description={"emitted when live streaming of the meeting in social media is started successfully"} name="onLivestreamStarted()"  type={"void"} />
      <MethodListItemLabel description={"emitted when live streaming of the meeting is stopped"} name="onLivestreamStopped()"  type={"void"} />
      <MethodListItemLabel description={"emitted when remote participant asked you to toggle the Mic"} name="onMicRequested(String participantId, MicRequestListener listener)"  type={"void"} />
      <MethodListItemLabel description={"emitted when remote participant asked you to toggle the Webcam"} name="onWebcamRequested(String participantId, WebcamRequestListener listener)"  type={"void"} />
      <MethodListItemLabel description={"emitted when local participant answer/dial the phone call"} name="onExternalCallStarted()"  type={"void"} />
    </MethodListGroup>
  </MethodListItemLabel>
</MethodListGroup>


---

---
title: Video SDK Participant Class
sidebar_position: 1
sidebar_label: Introduction
pagination_label: Video SDK Participant Class
---

# Video SDK Participant Class - Android

<div class="sdk-api-ref">

import properties from './../data/participant-class/properties.json'
import methods from './../data/participant-class/methods.json'
import events from './../data/participant-class/events.json'
import LinksGrid from '../../../../../src/theme/LinksGrid'

Participant class includes all the properties, methods and events related to all the participants joined in a particular meeting.

## Get local and remote participants

You can get the local streams and participant meta from `meeting.getLocalParticipant()`. And a Map of joined participants is always available via `meeting.getParticipants()`

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js title="Javascript"
val localParticipant = meeting!!.getLocalParticipant()
val participants = meeting!!.getParticipants()
```

</TabItem>

<TabItem value="Java">

```js title="Javascript"
Participant localParticipant = meeting.getLocalParticipant();
Map<String, Participant> participants = meeting.getParticipants();
```

</TabItem>

</Tabs>

## Participant Properties

<div class="row">

<div class="col col--4 margin-bottom--sm" >

- [getId()](./properties#getid)

</div>
<div class="col col--4 margin-bottom--sm" >

- [getDisplayName()](./properties#getdisplayname)

</div>
<div class="col col--4 margin-bottom--sm" >

- [getQuality()](./properties#getquality)

</div>

<div class="col col--4 margin-bottom--sm" >

- [isLocal()](./properties#islocal)

</div>

<div class="col col--4 margin-bottom--sm" >

- [getStreams()](./properties#getstreams)

</div>

<div class="col col--4 margin-bottom--sm" >

- [getMode()](./properties#getmode)

</div>

<div class="col col--4 margin-bottom--sm" >

- [getMetaData()](./properties#getmetadata)

</div>

</div>

## Participant Methods

<div class="row">

<div class="col col--4 margin-bottom--sm" >

- [enableWebcam()](./methods#enablewebcam)

</div>
<div class="col col--4 margin-bottom--sm" >

- [disableWebcam()](./methods#disablewebcam)

</div>
<div class="col col--4 margin-bottom--sm" >

- [enableMic()](./methods#enablemic)

</div>
<div class="col col--4 margin-bottom--sm" >

- [disableMic()](./methods#disablemic)

</div>
<div class="col col--4 margin-bottom--sm" >

- [remove()](./methods#remove)

</div>
<div class="col col--4 margin-bottom--sm" >

- [setQuality()](./methods#setquality)

</div>
<div class="col col--4 margin-bottom--sm" >

- [setViewPort()](./methods#setviewport)

</div>
<div class="col col--4 margin-bottom--sm" >

- [captureImage()](./methods#captureimage)

</div>

</div>

## Participant Events

<div class="row">

<div class="col col--4 margin-bottom--sm" >

- [onStreamEnabled](./participant-event-listener-class#onstreamenabled)

</div>
<div class="col col--4 margin-bottom--sm" >

- [onStreamDisabled](./participant-event-listener-class#onstreamdisabled)

</div>

</div>

</div>


---

---
title: Participant Class Methods
sidebar_position: 1
sidebar_label: Methods
pagination_label: Participant Class Methods
---

# Participant Class Methods - Android

<div class="sdk-api-ref-only-h4">

### enableWebcam()

- `enableWebcam()` is used to enable participant's camera.

#### Events associated with `enableWebcam()` :

- First the participant will get a callback on [onWebcamRequested()](../meeting-class/meeting-event-listener-class#onwebcamrequested) and once the participant accepts the request, webcam will be enabled.

- Every Participant will receive a `streamEnabled` event of `ParticipantEventListener` Class with `stream` object.

#### Returns

- `void`

---

### disableWebcam()

- `disableWebcam()` is used to disable participant camera.

#### Events associated with `disableWebcam()` :

- Every Participant will receive a `streamDisabled` event of `ParticipantEventListener` Class with `stream` object.

#### Returns

- `void`

---

### enableMic()

- `enableMic()` is used to enable participant microphone.

#### Events associated with `enableMic()` :

- First the participant will get a callback on [onMicRequested()](../meeting-class/meeting-event-listener-class#onmicrequested) and once the participant accepts the request, mic will be enabled.

- Every Participant will receive a `streamEnabled` event of `ParticipantEventListener` Class with `stream` object.

#### Returns

- `void`

---

### disableMic()

- `disableMic()` is used to disable participant microphone.

#### Events associated with `disableMic()`:

- Every Participant will receive a `streamDisabled` event of `ParticipantEventListener` Class with `stream` object.

#### Returns

- `void`

---

### pin()

- It is used to set pin state of the participant. You can use it to pin the screen share, camera or both of the participant. It accepts a paramter of type `String`. Default `SHARE_AND_CAM`

#### Parameters

- **pinType**: `SHARE_AND_CAM` | `CAM` | `SHARE`

---

### unpin()

- It is used to unpin participant. You can use it to unpin the screen share, camera or both of the participant. It accepts a paramter of type `String`. Default is `SHARE_AND_CAM`

#### Parameters

- **pinType**: `SHARE_AND_CAM` | `CAM` | `SHARE`

---

### remove()

- It is used to remove a participant from the meeting

---

### setQuality()

- `setQuality()` is used to set the quality of the participant's video stream.

#### Parameters

- `quality`: low | med | high

#### Returns

- `void`

---

### setViewPort()

- `setViewPort()` is used to set the quality of the participant's video stream based on the viewport height and width.

#### Parameters

- **width**: int
- **height**: int

#### Returns

- `void`

---

:::info

MultiStream is not supported by the Android SDK. Use `customTrack` rather than `setQuality()` and `setViewPort()` if you want to change participant's quality who joined using our Android SDK.

To know more about customTrack visit [here](/android/guide/video-and-audio-calling-api-sdk/features/custom-track/custom-video-track)

:::

### remove()

- `remove()` is used to remove the participant from the meeting.

#### Events associated with `remove()` :

- Local participant will receive a [`onMeetingLeft`](../meeting-class/meeting-event-listener-class.md#onmeetingleft) event.
- All remote participants will receive a [`onParticipantLeft`](../meeting-class/meeting-event-listener-class.md#onparticipantleft) event with `participantId`.

#### Returns

- `void`

---

### captureImage()

- It is used to capture image of local participant's current videoStream.

- You need to pass an implementation of `TaskCompletionListener` as a parameter. This listener will handle the result of the image capture task.

- When the image capture task is complete, the `onComplete()` method will provide the image in the form of a `base64` string. If an error occurs, the `onError()` method will provide the error details.

#### Parameters

- **height**: int
- **width**: int
- **listener**: TaskCompletionListener

#### Returns

- _`void`_

---

### getVideoStats()

- `getVideoStats()` will return an JSONObject which will contain details regarding the participant's critical video metrics such as **Jitter**, **Packet Loss**, **Quality Score** etc.

#### Returns

- `JSONObject`
  - `jitter` : It represents the distortion in the stream.
  - `bitrate` : It represents the bitrate of the stream which is being transmitted.
  - `totalPackets` : It represents the total packet count which were transmitted for that particiular stream.
  - `packetsLost` : It represents the total packets lost during the transimission of the stream.
  - `rtt` : It represents the time between the stream being reached to client from the server in milliseconds(ms).
  - `codec`: It represents the codec used for the stream.
  - `network`: It represents the network used to transmit the stream
  - `size`: It is object containing the height, width and frame rate of the stream.

:::note

getVideoStats() will return the metrics for the participant at that given point of time and not average data of the complete meeting.

To view the metrics for the complete meeting using the stats API documented [here](/api-reference/realtime-communication/fetch-session-quality-stats).

:::

:::info

If you are getting `rtt` greater than 300ms, try using a different region which is nearest to your user. To know more about changing region [visit here](/api-reference/realtime-communication/create-room).

If you are getting high packet loss, try using the `customTrack` for better experience. To know more about customTrack [visit here](/android/guide/video-and-audio-calling-api-sdk/features/custom-track/custom-video-track)

:::

---

### getAudioStats()

- `getAudioStats()` will return an JSONObject which will contain details regarding the participant's critical audio metrics such as **Jitter**, **Packet Loss**, **Quality Score** etc.

#### Returns

- `JSONObject`
  - `jitter` : It represents the distortion in the stream.
  - `bitrate` : It represents the bitrate of the stream which is being transmitted.
  - `totalPackets` : It represents the total packet count which were transmitted for that particiular stream.
  - `packetsLost` : It represents the total packets lost during the transimission of the stream.
  - `rtt` : It represents the time between the stream being reached to client from the server in milliseconds(ms).
  - `codec`: It represents the codec used for the stream.
  - `network`: It represents the network used to transmit the stream

:::note

getAudioStats() will return the metrics for the participant at that given point of time and not average data of the complete meeting.

To view the metrics for the complete meeting using the stats API documented [here](/api-reference/realtime-communication/fetch-session-quality-stats).

:::

:::info

If you are getting `rtt` greater than 300ms, try using a different region which is nearest to your user. To know more about changing region [visit here](/api-reference/realtime-communication/create-room).

:::

### getShareStats()

- `getShareStats()` will return an JSONObject which will contain details regarding the participant's critical video metrics such as **Jitter**, **Packet Loss**, **Quality Score** etc.

#### Returns

- `JSONObject`
  - `jitter` : It represents the distortion in the stream.
  - `bitrate` : It represents the bitrate of the stream which is being transmitted.
  - `totalPackets` : It represents the total packet count which were transmitted for that particiular stream.
  - `packetsLost` : It represents the total packets lost during the transimission of the stream.
  - `rtt` : It represents the time between the stream being reached to client from the server in milliseconds(ms).
  - `codec`: It represents the codec used for the stream.
  - `network`: It represents the network used to transmit the stream
  - `size`: It is object containing the height, width and frame rate of the stream.

:::note

getShareStats() will return the metrics for the participant at that given point of time and not average data of the complete meeting.

To view the metrics for the complete meeting using the stats API documented [here](/api-reference/realtime-communication/fetch-session-quality-stats).

:::

:::info

If you are getting `rtt` greater than 300ms, try using a different region which is nearest to your user. To know more about changing region [visit here](/api-reference/realtime-communication/create-room).

:::

### addEventListener()

#### Parameters

- **listener**: ParticipantEventListener

#### Returns

- _`void`_

---

### removeEventListener()

#### Parameters

- **listener**: ParticipantEventListener

#### Returns

- _`void`_

---

### removeAllListeners()

#### Returns

- _`void`_

</div>


---

---
title: ParticipantEventListener Class
sidebar_position: 1
sidebar_label: ParticipantEventListener
pagination_label: ParticipantEventListener Class
---

# ParticipantEventListener Class - Android

<div class="sdk-api-ref-only-h4">

### Implementation

- You can implement all the methods of `ParticipantEventListener` abstract Class and add the listener to `Participant` class using the `addEventListener()` method of `Participant` Class.

---

### onStreamEnabled()

- `onStreamEnabled()` is a callback which gets triggered whenever a participant's video, audio or screen share stream is enabled.

#### Event callback parameters

- **stream**: [Stream](../stream-class/introduction.md)

---

### onStreamDisabled()

- `onStreamDisabled()` is a callback which gets triggered whenever a participant's video, audio or screen share stream is disabled.

#### Event callback parameters

- **stream**: [Stream](../stream-class/introduction.md)

---

### Example

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
  meeting!!.localParticipant.addEventListener(object : ParticipantEventListener() {
    override fun onStreamEnabled(stream: Stream) {
        //
    }

    override fun onStreamDisabled(stream: Stream) {
        //
    }
  });
```

</TabItem>

<TabItem value="Java">

```js
  participant.addEventListener(new ParticipantEventListener() {
    @Override
    public void onStreamEnabled(Stream stream) {
        //
    }

    @Override
    public void onStreamDisabled(Stream stream) {
        //
    }
  });
```

</TabItem>

</Tabs>

</div>


---

---
title: Participant Class Properties
sidebar_position: 1
sidebar_label: Properties
pagination_label: Participant Class Properties
---

# Participant Class Properties - Android

<div class="sdk-api-ref-only-h4">

### getId()

- type: `String`

- `getId` will return unique id of the participant who has joined the meeting.

---

### getDisplayName()

- type: `String`

- It will return the `displayName` of the participant who has joined the meeting.

---

### getQuality()

- type: `String`

- `getQuality()` will return quality of participant's stream. Stream could be `audio` , `video` or `share`.

---

### isLocal()

- type: `boolean`

- `isLocal()` will return `true` if participant is Local,`false` otherwise.

---

### getStreams()

- type: `Map<String,name>`

- It will represents the stream for that particular participant who has joined the meeting. Streams could be `audio` , `video` or `share`.

---

### getMode()

- type : `string`

- ` getMode()` will return mode of the Participant.

---

### getMetaData()

- type : `JSONObject`

- `getMetaData()` will return additional information, that you have passed in `initMeeting()`.

</div>


---

---
title: Participant class for android SDK.
hide_title: false
hide_table_of_contents: false
description: The `Participant Class` includes methods and events for participants and their associated video & audio streams, data channels and UI customization.
sidebar_label: Participant Class
pagination_label: Participant Class
keywords:
  - RTC Android
  - Participant Class
  - Video API
  - Video Conferencing
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: participant-class
---

import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>

# Participant Class

## Introduction

The `Participant Class` includes methods and events for participants and their associated video & audio streams, data channels and UI customization.

import MethodListGroup from '@theme/MethodListGroup';
import MethodListItemLabel from '@theme/MethodListItemLabel';
import MethodListHeading from '@theme/MethodListHeading';

## Properties

### getId()

- `getId()` will return participant's Id
- return type : `String`

### getDisplayName()

- `getDisplayName()` will return name of participant
- return type : `String`

### getQuality()

- `getQuality()` will return quality of participant's video stream
- return type : `String`

### isLocal()

- `isLocal()` will return `true` if participant is Local,`false` otherwise
- return type : `boolean`

### getStreams()

- `getStreams()` will return streams of participant
- return type : `Map<String, Stream>`
- Map contains `streamId` as key and `stream` as value

## Events

### addEventListener(ParticipantEventListener listener)

- By using `addEventListener(ParticipantEventListener listener)`, we can add listener to the List of `ParticipantEventListener`
- return type : `void`

### removeEventListener(ParticipantEventListener listener)

- By using `removeEventListener(ParticipantEventListener listener)`, we can remove listener from List of `ParticipantEventListener`
- return type : `void`

### removeAllListeners()

- By using `removeAllListeners()`, we can remove all listener from List
- return type : `void`

## Methods

### enableMic()

- By using `enableMic()` function, a participant can enable the Mic of any particular Remote Participant
- When `enableMic()` is called,
  - Local Participant will receive a callback on `streamEnabled()` of `ParticipantEventListener` class
  - Remote Participant will receive a callback for `onMicRequested()` and once the remote participant accepts the request, mic will be enabled for that participant
- return type : `void`

### disableMic()

- By using `disableMic()` function, a participant can disable the Mic of any particular Remote Participant
- When `enableMic()` is called,
  - Local Participant will receive a callback on `streamDisabled()` of `ParticipantEventListener` class
  - Remote Participant will receive a callback on `streamDisabled()` of `ParticipantEventListener` class
- return type : `void`

### enableWebcam()

- By using `enableWebcam()` function, a participant can enable the Webcam of any particular Remote Participant
- When `enableWebcam()` is called,
  - Local Participant will receive a callback on `streamEnabled()` of `ParticipantEventListener` class
  - Remote Participant will receive a callback for `webcamRequested()` and once the remote participant accepts the request, webcam will be enabled for that participant
- return type : `void`

### disableWebcam()

- By using `disableWebcam()` function, a participant can disable the Webcam of any particular Remote Participant
- When `disableWebcam()` is called,
  - Local Participant will receive a callback on `streamDisabled()` of `ParticipantEventListener` class
  - Remote Participant will receive a callback on `streamDisabled()` of `ParticipantEventListener` class
- return type : `void`

### remove()

- By using `remove()` function, a participant can remove any particular Remote Participant
- When `remove()` is called,
  - Local Participant will receive a callback on `meetingLeft()`
  - Remote Participant will receive a callback on `participantLeft()`
- return type : `void`

### setQuality()

- By using `setQuality()`,you can set quality of participant's video stream
- return type : `void`


---

---
title: ParticipantEventListener Class for android SDK.
hide_title: false
hide_table_of_contents: false
description: The `ParticipantEventListener Class` includes list of events which can be useful for the design custom user interface.
sidebar_label: ParticipantEventListener Class
pagination_label: ParticipantEventListener Class
keywords:
  - RTC Android
  - ParticipantEventListener Class
  - Video API
  - Video Conferencing
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: participant-event-listener-class
---

# ParticipantEventListener Class

## using ParticipantEventListener Class

The `ParticipantEventListener Class` is responsible for listening to all the events that are related to `Participant Class`.

import MethodListGroup from '@theme/MethodListGroup';
import MethodListItemLabel from '@theme/MethodListItemLabel';
import MethodListHeading from '@theme/MethodListHeading';

### Listeners

<MethodListGroup>
  <MethodListItemLabel name="__listeners" >
    <MethodListGroup>
      <MethodListHeading heading="Listeners" />
      <MethodListItemLabel name="onStreamEnabled(Stream stream)"  type={"void"} />
      <MethodListItemLabel name="onStreamDisabled(Stream stream)"  type={"void"} />
    </MethodListGroup>
  </MethodListItemLabel>
</MethodListGroup>


---

---
title: Video SDK PubSub Class
sidebar_position: 1
sidebar_label: Introduction
pagination_label: Video SDK PubSub Class
---

# Video SDK PubSub Class - Android

<div class="sdk-api-ref">

## Introduction

PubSub class provides the methods to implement Publisher-Subscriber feature in your Application.

## PubSub Methods

<div class="row">

<div  class="col col--4 margin-bottom--sm" >

- [publish()](methods#publish)

</div>

<div  class="col col--4 margin-bottom--sm" >

- [subscribe()](methods#subscribe)

</div>

<div  class="col col--4 margin-bottom--sm" >

- [unsubscribe()](methods#unsubscribe)

</div>
</div>
</div>


---

---
sidebar_position: 1
sidebar_label: Methods
pagination_label: PubSub Class Methods
title: PubSub Class Methods
---

# PubSub Class Methods - Android

<div class="sdk-api-ref-only-h4">

### publish()

- `publish()` is used to publish messages on a specified topic in the meeting.

#### Parameters

- topic

  - type: `String`
  - This is the name of the topic, for which message will be published.

- message

  - type: `String`
  - This is the actual message.

- options
  - type: [`PubSubPublishOptions`](pubsub-publish-options-class)
  - This specifies the options for publish.

- payload

  - type: `JSONObject`
  - `OPTIONAL`
  - If you need to include additional information along with a message, you can pass here as `JSONObject`. 

#### Returns

- _`void`_

#### Example

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
// Publish message for 'CHAT' topic
val publishOptions = PubSubPublishOptions()
publishOptions.isPersist = true

meeting!!.pubSub.publish("CHAT", "Hello from Android", publishOptions)
```

</TabItem>

<TabItem value="Java">

```js
// Publish message for 'CHAT' topic
PubSubPublishOptions publishOptions = new PubSubPublishOptions();
publishOptions.setPersist(true);

meeting.pubSub.publish("CHAT", "Hello from Android", publishOptions);
```

</TabItem>

</Tabs>

---

### subscribe()

- `subscribe()` is used to subscribe a particular topic to get all the messages of that particular topic in the meeting.

#### Parameters

- topic:

  - type: `String`
  - Participants can listen to messages on that particular topic.

- listener:

  - type: [`PubSubMessageListener`](pubsub-message-listener-class)

#### Returns

- [_`List<PubSubMessage>`_](pubsub-message-class)

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
var pubSubMessageListener: ubSubMessageListener =
  PubSubMessageListener { message ->
    Log.d("#message","onMessageReceived: " + message.message)
  }

  // Subscribe for 'CHAT' topic
  val pubSubMessageList = meeting!!.pubSub.subscribe("CHAT", pubSubMessageListener)
```

</TabItem>

<TabItem value="Java">

```js
PubSubMessageListener pubSubMessageListener = new PubSubMessageListener() {
    @Override
    public void onMessageReceived(PubSubMessage message) {
        Log.d("#message", "onMessageReceived: " + message.getMessage());
    }
};

 // Subscribe for 'CHAT' topic
 List<PubSubMessage> pubSubMessageList = meeting.pubSub.subscribe("CHAT", pubSubMessageListener);
```

</TabItem>

</Tabs>

---

### unsubscribe()

- `unsubscribe()` is used to unsubscribe a particular topic on which you have subscribed priviously.

#### Parameters

- topic:

  - type: `String`
  - This is the name of the topic to be unsubscribed.

- listener:

  - type: [`PubSubMessageListener`](pubsub-message-listener-class)

#### Returns

- _`void`_

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
// Unsubscribe for 'CHAT' topic
meeting!!.pubSub.unsubscribe("CHAT", pubSubMessageListener)
```

</TabItem>

<TabItem value="Java">

```js
// Unsubscribe for 'CHAT' topic
meeting.pubSub.unsubscribe("CHAT", pubSubMessageListener);
```

</TabItem>

</Tabs>

</div>


---

---
sidebar_position: 1
sidebar_label: Properties
pagination_label: Properties
title: Properties
---

# Properties - Android

<div class="sdk-api-ref-only-h4">

### getId()

- type: `String`

- `getId()` will return unique id of the pubsub message.

---

### getMessage()

- type: `String`

- `getMessage()` will return message that has been published on the specific topic.

---

### getTopic()

- type: `String`

- `getTopic()` will return name of the message topic.

---

### getSenderId()

- type: `String`

- `getSenderId()` will return id of the participant, who has sent the message.

---

### getSenderName()

- type: `String`

- `getSenderName()` will return name of the participant, who has sent the pubsub message.

---

### getTimestamp()

- type: `long`

- `getTimestamp()` will return timestamp at which, the pubsub message was sent.

---

### getPayload()

- type: `JSONObject`

- `getPayload()` will return data that you have send with message.

</div>


---

---
sidebar_position: 1
sidebar_label: PubSubMessageListener Class
pagination_label: PubSubMessageListener Class
title: PubSubMessageListener Class
---

# PubSubMessageListener Class - Android

<div class="sdk-api-ref-only-h4">

---

#### onMessageReceived()

- This event will be emitted whenever any pubsub message received.

#### Example

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
var pubSubMessageListener = PubSubMessageListener { message ->
    Log.d("#message", "onMessageReceived: " + message.message)
}
```

</TabItem>

<TabItem value="Java">

```javascript
PubSubMessageListener pubSubMessageListener = new PubSubMessageListener() {
    @Override
    public void onMessageReceived(PubSubMessage message) {
        Log.d("#message", "onMessageReceived: " + message.getMessage());
    }
};
```

</TabItem>

</Tabs>

</div>


---

---
sidebar_position: 1
sidebar_label: PubSubPublishOptions Class
pagination_label: PubSubPublishOptions Class
title: PubSubPublishOptions Class
---

# PubSubPublishOptions Class - Android

<div class="sdk-api-ref-only-h4">


## Properties

### persist

- type: `boolean`

- defaultValue: `false`

- This property specifies whether to store messages on server for upcoming participants.

- If the value of this property is true, then server will store pubsub messages for the upcoming participants.

---

### sendOnly

- type: `String[]`

- defaultValue: `null`

- If you want to send a message to specific participants, you can pass their respective `participantId` here. If you don't provide any IDs or pass a `null` value, the message will be sent to all participants by default.

:::note
Make sure that participantId present in the array must be subscribe to that specific topic.
:::

</div>


---

---
title: PubSub class for android SDK.
hide_title: false
hide_table_of_contents: false
description: PubSub Class
sidebar_label: PubSub Class
pagination_label: PubSub Class
keywords:
  - RTC Android
  - Publisher-Subscriber
  - PubSub
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: pubsub-class
---

# PubSub Class

## using PubSub Class

The `PubSub` includes methods for pubsub.

import MethodListGroup from '@theme/MethodListGroup';
import MethodListItemLabel from '@theme/MethodListItemLabel';
import MethodListHeading from '@theme/MethodListHeading';

### Methods

<MethodListGroup>
  <MethodListItemLabel name="__methods" >
    <MethodListGroup>
      <MethodListHeading heading="Methods" />
      <MethodListItemLabel name="publish(String topic, String message, PubSubPublishOptions options)"  type={"void"} />
      <MethodListItemLabel name="subscribe(String topic, PubSubMessageListener listener)"  type={"List<PubSubMessage>"} />
      <MethodListItemLabel name="unsubscribe(String topic, PubSubMessageListener listener)"  type={"void"} />
    </MethodListGroup>
  </MethodListItemLabel>
</MethodListGroup>


---

---
title: PubSubMessage class for android SDK.
hide_title: false
hide_table_of_contents: false
description: PubSubMessage Class
sidebar_label: PubSubMessage Class
pagination_label: PubSubMessage Class
keywords:
  - RTC Android
  - Publisher-Subscriber
  - PubSub
  - PubSubMessage
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: pubsub-message-class
---

# PubSubMessage Class

## using PubSubMessage Class

The `PubSubMessage` includes properties of PubSub message.

import MethodListGroup from '@theme/MethodListGroup';
import MethodListItemLabel from '@theme/MethodListItemLabel';
import MethodListHeading from '@theme/MethodListHeading';

### Properties

<MethodListGroup>
  <MethodListItemLabel name="__properties"  >
    <MethodListGroup>
      <MethodListHeading heading="Properties" />
      <MethodListItemLabel name="id" type={"String"} />
      <MethodListItemLabel name="message" type={"String"} />
      <MethodListItemLabel name="senderId" type={"String"} />
      <MethodListItemLabel name="senderName" type={"String?"} />
      <MethodListItemLabel name="timestamp" type={"DateTime"} />
      <MethodListItemLabel name="topic" type={"String"} />
      <MethodListItemLabel name="payload" type={"JSONObject"} />
    </MethodListGroup>
  </MethodListItemLabel>
</MethodListGroup>


---

---
title: PubSubPublishOptions class for android SDK.
hide_title: false
hide_table_of_contents: false
description: PubSubPublishOptions Class
sidebar_label: PubSubPublishOptions Class
pagination_label: PubSubPublishOptions Class
keywords:
  - RTC Android
  - PubSub
  - PubSubPublishOptions
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: pubsub-publish-options-class
---

# PubSubPublishOptions Class

## using PubSubPublishOptions Class

The `PubSubPublishOptions` includes properties of PubSub options.

import MethodListGroup from '@theme/MethodListGroup';
import MethodListItemLabel from '@theme/MethodListItemLabel';
import MethodListHeading from '@theme/MethodListHeading';

### Properties

<MethodListGroup>
  <MethodListItemLabel name="__properties"  >
    <MethodListGroup>
      <MethodListHeading heading="Properties" />
      <MethodListItemLabel name="persist" type={"bool"} description={"Specifies whether to store messages on server for upcoming participants"} />
      <MethodListItemLabel name="sendOnly" type={"String[]"} description={"Sends a message to only those participants which are present in array"} />
    </MethodListGroup>
  </MethodListItemLabel>
</MethodListGroup>

### Methods

<MethodListGroup>
  <MethodListItemLabel name="__methods" >
    <MethodListGroup>
      <MethodListHeading heading="Methods" />
      <MethodListItemLabel name="toJSONObject()"  type={"JSONObject"} />
    </MethodListGroup>
  </MethodListItemLabel>
</MethodListGroup>


---

---
id: setup
title: Installation steps for RTC Android SDK
hide_title: false
hide_table_of_contents: false
description: RTC Android SDK provides client for almost all Android devices. it takes less amount of cpu and memory.
sidebar_label: Setup
pagination_label: Setup
keywords:
  - RTC Android
  - Android SDK
  - Kotlin SDK
  - Java SDK
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: setup
---

# Setup - Android

## Setting up android sdk

Android SDK is client for real-time communication for android devices. It inherits the same terminology as all other SDKs does.

## Minimum OS/SDK versions

It supports the following OS/SDK versions.

### Android: minSdkVersion >= 21

## Installation

1. If your Android Studio Version is older than Android Studio Bumblebees, add the repository to project's `build.gradle` file. <br/>
   If your are using Android Studio Bumblebees or newer Version, add the repository to `settings.gradle` file.

:::note

You can use imports with Maven Central after rtc-android-sdk version `0.1.12`.

Whether on Maven or Jitpack, the same version numbers always refer to the same SDK.

:::

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Maven Central"
groupId={"android-repositories"}
values={[{label: 'Maven Central', value: 'Maven Central'},{label: 'Jitpack', value: 'Jitpack'},]}>

<TabItem value="Maven Central">

```js title="build.gradle"
allprojects {
  repositories {
    // ...
    google()
    mavenCentral()
    maven { url "https://maven.aliyun.com/repository/jcenter" }
  }
}
```

```js title="settings.gradle"
dependencyResolutionManagement{
  repositories {
    // ...
    google()
    mavenCentral()
    maven { url "https://maven.aliyun.com/repository/jcenter" }
  }
}

```

</TabItem>

<TabItem value="Jitpack">

```js title="build.gradle"
allprojects {
  repositories {
    // ...
    google()
    maven { url 'https://jitpack.io' }
    mavenCentral()
    maven { url "https://maven.aliyun.com/repository/jcenter" }
  }
}
```

```js title="settings.gradle"
dependencyResolutionManagement{
  repositories {
    // ...
    google()
    maven { url 'https://jitpack.io' }
    mavenCentral()
    maven { url "https://maven.aliyun.com/repository/jcenter" }
  }
}

```

</TabItem>

</Tabs>

### Step 2: Add the following dependency in your app's `app/build.gradle`.

```js title="app/build.gradle"
dependencies {
  implementation 'live.videosdk:rtc-android-sdk:0.1.38'

  // library to perform Network call to generate a meeting id
  implementation 'com.amitshekhar.android:android-networking:1.0.2'

  // other app dependencies
  }
```

:::important

Android SDK compatible with armeabi-v7a, arm64-v8a, x86_64 architectures. If you want to run the application in an emulator, choose ABI x86_64 when creating a device.

:::

## Integration

### Step 1: Add the following permissions in `AndroidManifest.xml`.

```xml title="AndroidManifest.xml"
<uses-permission android:name="android.permission.RECORD_AUDIO" />
<uses-permission android:name="android.permission.MODIFY_AUDIO_SETTINGS" />
<uses-permission android:name="android.permission.INTERNET" />
<uses-permission android:name="android.permission.READ_PHONE_STATE" />
<uses-permission android:name="android.permission.CAMERA" />

<uses-permission android:name="android.permission.BLUETOOTH" />
<uses-permission android:name="android.permission.BLUETOOTH_ADMIN" />
<uses-permission android:name="android.permission.BLUETOOTH_CONNECT" />

```

### Step 2: Create `MainApplication` class which will extend the `android.app.Application`.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js title="MainApplication.kt"
package live.videosdk.demo;

import live.videosdk.android.VideoSDK

class MainApplication : Application() {
    override fun onCreate() {
        super.onCreate()
        VideoSDK.initialize(applicationContext)
    }
}
```

</TabItem>

<TabItem value="Java">

```js title="MainApplication.java"
package live.videosdk.demo;

import android.app.Application;

import live.videosdk.android.VideoSDK;

public class MainApplication extends Application {
    @Override
    public void onCreate() {
        super.onCreate();
        VideoSDK.initialize(getApplicationContext());
    }
}
```

</TabItem>

</Tabs>

### Step 3: Add `MainApplication` to `AndroidManifest.xml`.

```js title="AndroidManifest.xml"
<application
        android:name=".MainApplication"
				...
>
  <!-- ... -->
</application>
```

### Step 4: In your `JoinActivity` add the following code in `onCreate()` method.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js title="JoinActivity.kt"
override fun onCreate(savedInstanceState: Bundle?) {
  super.onCreate(savedInstanceState)
  setContentView(R.layout.activity_join)

  val meetingId = "<meeting-id>"
  val participantName = "John Doe"

  var micEnabled = true
  var webcamEnabled = true

  // generate the jwt token from your api server and add it here
  VideoSDK.config("JWT TOKEN GENERATED FROM SERVER")

  // create a new meeting instance
  meeting = VideoSDK.initMeeting(
      this@MeetingActivity, meetingId, participantName,
      micEnabled, webcamEnabled, null, null, false, null, null)

  // get permissions and join the meeting with meeting.join();
  // checkPermissionAndJoinMeeting();
}
```

</TabItem>

<TabItem value="Java">

```js title="JoinActivity.java"
@Override
protected void onCreate(Bundle savedInstanceState) {
  super.onCreate(savedInstanceState);
  setContentView(R.layout.activity_join);

  final String meetingId = "<meeting-id>";
  final String participantName = "John Doe";

  final boolean micEnabled = true;
  final boolean webcamEnabled = true;

  // generate the jwt token from your api server and add it here
  VideoSDK.config("JWT TOKEN GENERATED FROM SERVER");

  // create a new meeting instance
  Meeting meeting = VideoSDK.initMeeting(
          MainActivity.this, meetingId, participantName,
          micEnabled, webcamEnabled, null, null, false, null, null
  );

  // get permissions and join the meeting with meeting.join();
  // checkPermissionAndJoinMeeting();
}
```

</TabItem>

</Tabs>

All set! Here is the link to the complete sample code on [Github](https://github.com/videosdk-live/videosdk-rtc-android-java-sdk-example). Please refer to the [documentation](initMeeting) for a full list of available methods, events and features of the SDK.


---

---
title: Video SDK Stream Class
sidebar_position: 1
sidebar_label: Introduction
pagination_label: Video SDK Stream Class
---

# Video SDK Stream Class - Android

<div id="tailwind" class="sdk-api-ref">

import properties from './../data/stream-class/properties.json'
import methods from './../data/stream-class/methods.json'
import LinksGrid from '../../../../../src/theme/LinksGrid'

Stream class is responsible for handling audio, video and screen sharing streams.

Stream class defines instance of audio, video and shared screen stream of participants.

## Stream Properties

<div class="row">

<div class="col col--4 margin-bottom--sm" >

- [getId()](./properties#getid)

</div>
<div class="col col--4 margin-bottom--sm" >

- [getKind()](./properties#getkind)

</div>
<div class="col col--4 margin-bottom--sm" >

- [getTrack()](./properties#gettrack)

</div>

</div>

## Stream Methods

<div class="row">

<div class="col col--4 margin-bottom--sm" >

- [resume()](methods#resume)

</div>
<div class="col col--4 margin-bottom--sm" >

- [pause()](./methods#pause)

</div>

</div>

</div>


---

---
title: Stream Class Methods
sidebar_position: 1
sidebar_label: Methods
pagination_label: Stream Class Methods
---

# Stream Class Methods - Android

<div class="sdk-api-ref-only-h4">

### resume()

- By using `resume()`, a participant can resume the stream of Remote Participant.

#### Returns

- `void`

---

### pause()

- By using `pause()`, a participant can pause the stream of Remote Participant.

#### Returns

- `void`

</div>


---

---
title: Stream Class Properties
sidebar_position: 1
sidebar_label: Properties
pagination_label: Stream Class Properties
---

# Stream Class Properties - Android

<div class="sdk-api-ref-only-h4">

### getId()

- type: `String`

- `getId()` will return id for that stream .

---

### getKind()

- type: `String`

- `getKind()` will return `kind`, which represents the type of stream which could be `audio` | `video` or `share` .

---

### getTrack()

- type: `MediaStreamTrack`

- `getTrack()` will return a MediaStreamTrack object stored in the MediaStream object.

</div>


---

---
title: Stream class for android SDK.
hide_title: false
hide_table_of_contents: false
description: RTC Stream Class enables opportunity to .
sidebar_label: Stream Class
pagination_label: Stream Class
keywords:
  - RTC Android
  - Stream Class
  - Video API
  - Video Conferencing
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: stream-class
---

# Stream Class

## Introduction

The `Stream Class` includes methods and events of video & audio streams.

import MethodListGroup from '@theme/MethodListGroup';
import MethodListItemLabel from '@theme/MethodListItemLabel';
import MethodListHeading from '@theme/MethodListHeading';

## Properties

### getId()

- `getId()` will return Id of stream
- return type : `String`

### getKind()

- `getKind()` will return kind of stream, which can `audio`,`video` or `share`
- return type : `String`

### getTrack()

- `getTrack()` will return a MediaStreamTrack object stored in the MediaStream object
- return type : `MediaStreamTrack`

## Methods

### pause()

- By using `pause()` function, a participant can pause the stream of Remote Participant
- return type : `void`

### resume()

- By using `resume()` function, a participant can resume the stream of Remote Participant
- return type : `void`


---

---
title: Terminology - Video SDK Documentation
hide_title: true
hide_table_of_contents: false
description: Video SDK enables the opportunity to integrate native IOS, Android & Web SDKs to add live video & audio conferencing to your applications.
sidebar_label: Terminology
pagination_label: Terminology
keywords:
  - audio calling
  - video calling
  - real-time communication
  - collaboration
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: terminology
---

import Terminology from '../../../../mdx/introduction/\_terminology.mdx';

<Terminology title="Terms related to VideoSDK - Android" />


---

---
title: Video SDK Class for android SDK.
hide_title: false
hide_table_of_contents: false
description: Video SDK Class is a factory for initialize, configure and init meetings.
sidebar_label: VideoSDK Class
pagination_label: VideoSDK Class
keywords:
  - RTC Android
  - VideoSDK Class
  - Video API
  - Video Conferencing
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: videosdk-class
---

# VideoSDK Class

The entry point into real-time communication SDK.

## using VideoSDK Class

The `VideoSDK Class` includes methods and events to initialize and configure the SDK. It is a factory class.

import MethodListGroup from '@theme/MethodListGroup';
import MethodListItemLabel from '@theme/MethodListItemLabel';
import MethodListHeading from '@theme/MethodListHeading';

### Parameters

<MethodListGroup>
  <MethodListItemLabel name="__namedParameters" option={"required"} type={"object"} >
    <MethodListGroup>
      <MethodListHeading heading="Properties" />
      <MethodListItemLabel description={"set meeting id"} name="meetingId" option={"required"} type={"string"} />
      <MethodListItemLabel description={"set local participant's name"} name="name" option={"required"} type={"string"} />
      <MethodListItemLabel description={"set local participant's mic state"} name="micEnabled" option={"required"} type={"bool"} />
      <MethodListItemLabel description={"set local participant's webcam state"} name="webcamEnabled" option={"required"} type={"bool"}/>
      <MethodListItemLabel description={"set local participant's Id"} name="paricipantId" option={"required"} type={"string"}/>
    </MethodListGroup>
  </MethodListItemLabel>
</MethodListGroup>

### Methods

<MethodListGroup>
  <MethodListItemLabel name="__methods" >
    <MethodListGroup>
      <MethodListHeading heading="Methods" />
      <MethodListItemLabel description={"initialize the MediasoupClient"} name="initialize(Context context)"  type={"void"} />
      <MethodListItemLabel description={"configure the token"} name="config(String token)"  type={"void"} />
      <MethodListItemLabel description={"initialize the meeting"} 
      name="initMeeting(
        Context context, 
        String meetingId, 
        String name, 
        boolean micEnabled,
        boolean webcamEnabled,
        String participantId
      )"  type={"Meeting"} />
    </MethodListGroup>
  </MethodListItemLabel>
</MethodListGroup>

## Example

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js title="initMeeting"
// Configure the token
VideoSDK.config(token)

// Initialize the meeting
Meeting meeting = VideoSDK.initMeeting(
      context,
      meetingId, // required
      name, // required
      micEnabled, // required
      webcamEnabled, // required
      null, // required
      null, // required
      null // required
      )
});
```

</TabItem>

<TabItem value="Java">

```js title="initMeeting"
// Configure the token
VideoSDK.config(token)

// Initialize the meeting
Meeting meeting = VideoSDK.initMeeting({
  context,
  meetingId, // required
  name, // required
  micEnabled, // required
  webcamEnabled, // required
  null, // required
  null // required
  null // required
});
```

</TabItem>

</Tabs>


---

---
sidebar_position: 1
sidebar_label: Events
pagination_label: VideoSDK Class Events
title: VideoSDK Class Events
---

# VideoSDK Class Events - Android

<div class="sdk-api-ref-only-h4">


### onAudioDeviceChanged()

- This event will be emitted when an audio device, is connected to or removed from the device.

#### Example

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
VideoSDK.setAudioDeviceChangeListener(object : VideoSDK.AudioDeviceChangeEvent {
    override fun onAudioDeviceChanged(
        selectedAudioDevice: AudioDeviceInfo?,
        audioDevices: MutableSet<AudioDeviceInfo>?
    ) {
        Log.d(
            "VideoSDK",
            "Selected Audio Device: " + selectedAudioDevice.label
        )
        for (audioDevice in audioDevices) {
            Log.d("VideoSDK", "Audio Devices" + audioDevice.label)
        }
    }
})
```

</TabItem>

<TabItem value="Java">

```javascript
VideoSDK.setAudioDeviceChangeListener(new VideoSDK.AudioDeviceChangeEvent() {
    @Override
    public void onAudioDeviceChanged(AudioDeviceInfo selectedAudioDevice, Set<AudioDeviceInfo> audioDevices) {
        Log.d("VideoSDK", "Selected Audio Device: " + selectedAudioDevice.getLabel());
        for (AudioDeviceInfo audioDevice :
                audioDevices) {
            Log.d("VideoSDK", "Audio Devices" + audioDevice.getLabel());
        }
    }
});
```

</TabItem>

</Tabs>

---

</div>


---

---
sidebar_position: 1
sidebar_label: Introduction
pagination_label: Intro to VideoSDK Class
title: VideoSDK Class
---

# VideoSDK Class - Android 

<div class="sdk-api-ref">

## Introduction

The `VideoSDK` class includes properties, methods and events for creating and configuring a meeting, and managing media devices.

import LinksGrid from "../../../../../src/theme/LinksGrid";
//import properties from "./../data/meeting-class/properties.json";
import methods from "./../data/meeting-class/methods.json";
import events from "./../data/meeting-class/events.json";

## VideoSDK Properties

<div class="row">

<div class="col col--4 margin-bottom--sm" >

- [getSelectedAudioDevice()](./properties.md#getselectedaudiodevice)

</div>
<div class="col col--4 margin-bottom--sm" >

- [getSelectedVideoDevice()](./properties#getselectedvideodevice)

</div>

</div>

## VideoSDK Methods

<div class="row">

<div class="col col--4 margin-bottom--sm" >

- [initialize()](./methods#initialize)

</div>

<div class="col col--4 margin-bottom--sm" >

- [config()](./methods#config)

</div>
<div class="col col--4 margin-bottom--sm" >

- [initMeeting()](./methods#initmeeting)

</div>
<div class="col col--4 margin-bottom--sm" >

- [getDevices()](./methods#getdevices)

</div>
<div class="col col--4 margin-bottom--sm" >

- [getVideoDevices()](./methods#getvideodevices)

</div>
<div class="col col--4 margin-bottom--sm" >

- [getAudioDevices()](./methods#getaudiodevices)

</div>
<div class="col col--4 margin-bottom--sm" >

- [checkPermissions()](./methods#checkpermissions)

</div>

<div class="col col--4 margin-bottom--sm" >

- [setAudioDeviceChangeListener()](./methods#setaudiodevicechangelistener)

</div>
<div class="col col--4 margin-bottom--sm" >

- [setSelectedAudioDevice()](./methods#setselectedaudiodevice)

</div>
<div class="col col--4 margin-bottom--sm" >

- [setSelectedVideoDevice()](./methods#setselectedvideodevice)

</div>

</div>

## VideoSDK Events

<div class="row">

<div class="col col--4 margin-bottom--sm" >

- [onAudioDeviceChanged](./events.md#onaudiodevicechanged)

</div>

</div>

</div>


---

---
sidebar_position: 1
sidebar_label: Methods
pagination_label: VideoSDK Class Methods
title: VideoSDK Class Methods
---

# VideoSDK Class Methods - Android

<div class="sdk-api-ref-only-h4">

### initialize()

To initialize the meeting, first you have to initialize the `VideoSDK`.
You can initialize the `VideoSDK` using `initialize()` method provided by the SDK.

#### Parameters

- **context**: Context

#### Returns

- _`void`_

```js title="initialize"
  VideoSDK.initialize(Context context)
```

---

### config()

By using `config()` method, you can set the `token` property of `VideoSDK` class.

Please refer this [documentation](/api-reference/realtime-communication/intro/) to generate a token.

#### Parameters

- **token**: String

#### Returns

- _`void`_

```js title="config"
 VideoSDK.config(String token)
```

---

### initMeeting()

- Initialize the meeting using a factory method provided by the SDK called `initMeeting()`.
- `initMeeting()` will generate a new [`Meeting`](../meeting-class/introduction.md) class and the initiated meeting will be returned.

```js title="initMeeting"
   VideoSDK.initMeeting(
        Context context,
        String meetingId,
        String name,
        boolean micEnabled,
        boolean webcamEnabled,
        String participantId,
        String mode,
        boolean multiStream,
        Map<String, CustomStreamTrack> customTracks
        JSONObject metaData,
        String signalingBaseUrl
        PreferredProtocol preferredProtocol
      )
```
- Please refer this [documentation](../initMeeting.md#initmeeting) to know more about `initMeeting()`.

---

### getDevices()

- The `getDevices()` method returns a list of the currently available media devices, such as microphones, cameras, headsets, and so forth. The method returns a list of `DeviceInfo` objects describing the devices.

- `DeviceInfo` class has four properties :

  1. `DeviceInfo.deviceId`

     - Returns a string that is an identifier for the represented device, persisted across sessions.

  2. `DeviceInfo.label`

     - Returns a string describing this device (for example `BLUETOOTH`).

  3. `DeviceInfo.kind`

     - Returns an enumerated value that is either `video` or `audio`.

  4. `DeviceInfo.FacingMode`

     - Returns a value of type `FacingMode` indicating which camera device is in use (front or back).

#### Returns

- `Set<DeviceInfo>`

#### Example

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
val devices: Set<DeviceInfo> = VideoSDK.getDevices()
for (deviceInfo in devices) {
    Log.d("VideoSDK", "Device's DeviceId " + deviceInfo.deviceId)
    Log.d("VideoSDK", "Device's Label " + deviceInfo.label)
    Log.d("VideoSDK", "Device's Kind " + deviceInfo.kind)
    Log.d("VideoSDK", "Device's Facing Mode " + deviceInfo.facingMode) //Value will be null for Audio Devices
}
```

</TabItem>

<TabItem value="Java">

```javascript
Set<DeviceInfo> devices = VideoSDK.getDevices();
for (DeviceInfo deviceInfo :
        devices) {
    Log.d("VideoSDK", "Device's DeviceId " + deviceInfo.getDeviceId());
    Log.d("VideoSDK", "Device's Label " + deviceInfo.getLabel());
    Log.d("VideoSDK", "Device's Kind " + deviceInfo.getKind());
    Log.d("VideoSDK", "Device's Facing Mode " + deviceInfo.getFacingMode()) //Value will be null for Audio Devices
}
```

</TabItem>

</Tabs>

---

### getVideoDevices()

- The `getVideoDevices` method returns a list of currently available video devices. The method returns a list of `VideoDeviceInfo` objects describing the video devices.

- `VideoDeviceInfo` class has four properties :

  1. `VideoDeviceInfo.deviceId`

     - Returns a string that is an identifier for the represented device, persisted across sessions.

  2. `VideoDeviceInfo.label`

     - Returns a string describing this device (for example `BLUETOOTH`).

  2. `VideoDeviceInfo.kind`

     - Returns an enumerated value that is `video` .

  4. `VideoDeviceInfo.FacingMode`

     - Returns a value of type `FacingMode` indicating which camera device is in use (front or back).


#### Returns

- `Set<VideoDeviceInfo>`

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
val videoDevices: Set<VideoDeviceInfo> = VideoSDK.getVideoDevices()
for (videoDevice in videoDevices) {
    Log.d("VideoSDK", "Video Device's DeviceId " + videoDevice.deviceId)
    Log.d("VideoSDK", "Video Device's Label " + videoDevice.label)
    Log.d("VideoSDK", "Video Device's Kind " + videoDevice.kind)
}
```

</TabItem>

<TabItem value="Java">

```js
Set<VideoDeviceInfo> videoDevices = VideoSDK.getVideoDevices();
for (VideoDeviceInfo videoDevice:
        videoDevices) {
    Log.d("VideoSDK", "Video Device's DeviceId " + videoDevice.getDeviceId());
    Log.d("VideoSDK", "Video Device's Label " + videoDevice.getLabel());
    Log.d("VideoSDK", "Video Device's Kind " + videoDevice.getKind());
}
```

</TabItem>

</Tabs>

---

### getAudioDevices()

- The `getAudioDevices` method returns a list of currently available audio devices. The method returns a list of `AudioDeviceInfo` objects describing the audio devices.

- `AudioDeviceInfo` class has three properties :

  1. `AudioDeviceInfo.deviceId`

     - Returns a string that is an identifier for the represented device, persisted across sessions.

  2. `AudioDeviceInfo.label`

     - Returns a string describing this device (for example `BLUETOOTH`).

  3. `AudioDeviceInfo.kind`

     - Returns an enumerated value that is `audio`.

#### Returns

- `Set<AudioDeviceInfo>`

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
val audioDevices: Set<AudioDeviceInfo> = VideoSDK.getAudioDevices()
for (audioDevice in audioDevices) {
    Log.d("VideoSDK", "Audio Device's DeviceId " + audioDevice.deviceId)
    Log.d("VideoSDK", "Audio Device's Label " + audioDevice.label)
    Log.d("VideoSDK", "Audio Device's Kind " + audioDevice.kind)
}
```

</TabItem>

<TabItem value="Java">

```js
Set<AudioDeviceInfo> audioDevices = VideoSDK.getAudioDevices();
for (AudioDeviceInfo audioDevice:
     audioDevices) {
    Log.d("VideoSDK", "Audio Device's DeviceId " + audioDevice.getDeviceId());
    Log.d("VideoSDK", "Audio Device's Label " + audioDevice.getLabel());
    Log.d("VideoSDK", "Audio Device's Kind " + audioDevice.getKind());
}
```

</TabItem>

</Tabs>

---

### setAudioDeviceChangeListener()

- The `AudioDeviceChangeEvent` is emitted when an audio device, is connected to or removed from the device. This event can be set by using `setAudioDeviceChangeListener()` method.

#### Parameters

- **audioDeviceChangeEvent**: AudioDeviceChangeEvent

#### Returns

- _`void`_

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
VideoSDK.setAudioDeviceChangeListener { selectedAudioDevice: AudioDeviceInfo, audioDevices: Set<AudioDeviceInfo> ->
    Log.d(
        "VideoSDK",
        "Selected Audio Device: " + selectedAudioDevice.label
    )
    for (audioDevice in audioDevices) {
        Log.d("VideoSDK", "Audio Devices" + audioDevice.label)
    }
}
```

</TabItem>

<TabItem value="Java">

```javascript
VideoSDK.setAudioDeviceChangeListener((selectedAudioDevice, audioDevices) -> {
    Log.d("VideoSDK", "Selected Audio Device: " + selectedAudioDevice.getLabel());
    for (AudioDeviceInfo audioDevice :
            audioDevices) {
        Log.d("VideoSDK", "Audio Devices" + audioDevice.getLabel());
    }
});
```

</TabItem>

</Tabs>

---

### checkPermissions()

- The `checkPermissions()` method verifies whether permissions to access camera and microphone devices have been granted. If the required permissions are not granted, the method will proceed to request these permissions from the user.

#### Parameters

- context

  - type: `Context`
  - `REQUIRED`
  - The android context.

- permission

  - type: `List<Permission>`
  - `REQUIRED`
  - The permission to be requested.

- permissionHandler

  - type: `PermissionHandler`
  - `REQUIRED`
  - The permission handler object for handling callbacks of various user actions such as permission granted, permission denied, etc.

- rationale

  - type: `String`
  - `OPTIONAL`
  - Explanation to be shown to user if they have denied permission earlier. If this parameter is not provided, permissions will be requested without showing the rationale dialog.

- options

  - type: `Permissions.Options`
  - `OPTIONAL`
  - The options object for setting title and description of dialog box that prompts users to manually grant permissions by navigating to device settings. If this parameter is not provided,the default title and decription will be used for the dialog box.

#### Returns

- _`void`_

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
private val permissionHandler: PermissionHandler = object : PermissionHandler() {
    override fun onGranted() {}
    override fun onBlocked(
        context: Context,
        blockedList: java.util.ArrayList<Permission>
    ): Boolean {
        for (blockedPermission in blockedList) {
            Log.d("VideoSDK Permission", "onBlocked: $blockedPermission")
        }
        return super.onBlocked(context, blockedList)
    }

    override fun onDenied(
        context: Context,
        deniedPermissions: java.util.ArrayList<Permission>
    ) {
        for (deniedPermission in deniedPermissions) {
            Log.d("VideoSDK Permission", "onDenied: $deniedPermission")
        }
        super.onDenied(context, deniedPermissions)
    }

    override fun onJustBlocked(
        context: Context,
        justBlockedList: java.util.ArrayList<Permission>,
        deniedPermissions: java.util.ArrayList<Permission>
    ) {
        for (justBlockedPermission in justBlockedList) {
            Log.d("VideoSDK Permission", "onJustBlocked: $justBlockedPermission")
        }
        super.onJustBlocked(context, justBlockedList, deniedPermissions)
    }
}
val permissionList: MutableList<Permission> = ArrayList()
permissionList.add(Permission.audio)
permissionList.add(Permission.video)
permissionList.add(Permission.bluetooth)
val rationale = "Please provide permissions"
val options =
    Permissions.Options().setRationaleDialogTitle("Info").setSettingsDialogTitle("Warning")
//If you wish to disable the dialog box that prompts 
//users to manually grant permissions by navigating to device settings, 
//you can set options.sendDontAskAgainToSettings(false)
VideoSDK.checkPermissions(this, permissionList, rationale, options, permissionHandler)
```

</TabItem>

<TabItem value="Java">

```js
private final PermissionHandler permissionHandler = new PermissionHandler() {
    @Override
    public void onGranted() {
    }

    @Override
    public boolean onBlocked(Context context, ArrayList<Permission> blockedList) {
        for (Permission blockedPermission :
                blockedList) {
            Log.d("VideoSDK Permission", "onBlocked: " + blockedPermission);
        }
        return super.onBlocked(context, blockedList);
    }

    @Override
    public void onDenied(Context context, ArrayList<Permission> deniedPermissions) {
        for (Permission deniedPermission :
                deniedPermissions) {
            Log.d("VideoSDK Permission", "onDenied: " + deniedPermission);
        }
        super.onDenied(context, deniedPermissions);
    }

    @Override
    public void onJustBlocked(Context context, ArrayList<Permission> justBlockedList, ArrayList<Permission> deniedPermissions) {
        for (Permission justBlockedPermission :
                justBlockedList) {
            Log.d("VideoSDK Permission", "onJustBlocked: " + justBlockedPermission);
        }
        super.onJustBlocked(context, justBlockedList, deniedPermissions);
    }
};
List<Permission> permissionList = new ArrayList<>();
permissionList.add(Permission.audio);
permissionList.add(Permission.video);
permissionList.add(Permission.bluetooth);
String rationale = "Please provide permissions";
Permissions.Options options =
        new Permissions.Options().setRationaleDialogTitle("Info").setSettingsDialogTitle("Warning");
//If you wish to disable the dialog box that prompts 
//users to manually grant permissions by navigating to device settings, 
//you can set options.sendDontAskAgainToSettings(false)
VideoSDK.checkPermissions(this, permissionList, rationale, options, permissionHandler);
```

</TabItem>

</Tabs>

---

### setSelectedAudioDevice()

- It sets the selected audio device, allowing the user to specify which audio device to use in the meeting.

#### Parameters

- **selectedAudioDevice**: AudioDeviceInfo

#### Returns

- _`void`_

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
val audioDevices: Set<AudioDeviceInfo> = VideoSDK.getAudioDevices()
val audioDeviceInfo: AudioDeviceInfo = audioDevices.toTypedArray().get(0) as AudioDeviceInfo
VideoSDK.setSelectedAudioDevice(audioDeviceInfo)
```

</TabItem>

<TabItem value="Java">

```js
Set<AudioDeviceInfo> audioDevices = VideoSDK.getAudioDevices();
AudioDeviceInfo audioDeviceInfo = (AudioDeviceInfo) audioDevices.toArray()[0];
VideoSDK.setSelectedAudioDevice(audioDeviceInfo);
```

</TabItem>

</Tabs>

---

### setSelectedVideoDevice()

- It sets the selected video device, allowing the user to specify which video device to use in the meeting.

#### Parameters

- **selectedVideoDevice**: VideoDeviceInfo

#### Returns

- _`void`_

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
val videoDevices: Set<VideoDeviceInfo> = VideoSDK.getVideoDevices()
val videoDeviceInfo: VideoDeviceInfo = videoDevices.toTypedArray().get(1) as VideoDeviceInfo
VideoSDK.setSelectedVideoDevice(videoDeviceInfo)
```

</TabItem>

<TabItem value="Java">

```js
Set<VideoDeviceInfo> videoDevices = VideoSDK.getVideoDevices();
VideoDeviceInfo videoDeviceInfo = (VideoDeviceInfo) videoDevices.toArray()[1];
VideoSDK.setSelectedVideoDevice(videoDeviceInfo);
```

</TabItem>

</Tabs>

---

### applyVideoProcessor()

- This method allows users to dynamically apply virtual background to their video stream during a live session.

#### Parameters

- videoFrameProcessor

  - type: `VideoFrameProcessor`
  - This is an object of the `VideoFrameProcessor` class, which overrides the `onFrameCaptured(VideoFrame videoFrame)` method.

#### Returns

- _`void`_

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
val uri = Uri.parse("https://st.depositphotos.com/2605379/52364/i/450/depositphotos_523648932-stock-photo-concrete-rooftop-night-city-view.jpg")
val backgroundImageProcessor = BackgroundImageProcessor(uri)
VideoSDK.applyVideoProcessor(backgroundImageProcessor)
```

</TabItem>

<TabItem value="Java">

```java
Uri uri = Uri.parse("https://st.depositphotos.com/2605379/52364/i/450/depositphotos_523648932-stock-photo-concrete-rooftop-night-city-view.jpg");
BackgroundImageProcessor backgroundImageProcessor = new BackgroundImageProcessor(uri)
VideoSDK.applyVideoProcessor(backgroundColorProcessor);
```

</TabItem>

</Tabs>

---

### removeVideoProcessor()

- This method provides users with a convenient way to revert their video background to its original state, removing any previously applied virtual background.

   - **Returns:**
      - _`void`_

#### Example

```js
VideoSDK.removeVideoProcessor();
```


</div>


---

---
sidebar_position: 1
sidebar_label: Properties
pagination_label: VideoSDK Class Properties
title: VideoSDK Class Properties
---

# VideoSDK Class Properties - Android

<div class="sdk-api-ref-only-h4">

### getSelectedAudioDevice()

- type: `AudioDeviceInfo`

- The `getSelectedAudioDevice()` method will return the object of the audio device, which is currently in use.

---

### getSelectedVideoDevice()

- type: `VideoDeviceInfo`

- The `getSelectedVideoDevice()` method will return the object of the video device, which is currently in use.



</div>


---

### 5.Errors associated with Media

These errors involve media access, device availability, or permission-related issues affecting camera, microphone, and screen sharing.

### Device access-related errors

| Type                                      | Code  | Message                                          |
|-------------------------------------------|-------|--------------------------------------------------|
| ERROR_CAMERA_ACCESS  | 3002  | Something went wrong. Unable to access camera. |
| ERROR_MIC_ACCESS_DENIED  | 3003  | It seems like microphone access was denied or dismissed. To proceed, kindly grant access through your device's settings. |
| ERROR_CAMERA_ACCESS_DENIED | 3004 | It seems like camera access was denied or dismissed. To proceed, kindly grant access through your device's settings. |

### 6.Errors associated with Track

These errors occur when there are issues with video or audio tracks, such as disconnections or invalid custom tracks.

| Type                        | Code  | Message                                          |
|-----------------------------|-------|--------------------------------------------------|
| ERROR_CUSTOM_SCREEN_SHARE_TRACK_ENDED      | 3005  | The provided custom track is in an ended state. Please try again with new custom track. |
| ERROR_CUSTOM_SCREEN_SHARE_TRACK_DISPOSED      | 3006  | The provided custom track was disposed. Please try again with new custom track. |
| ERROR_CHANGE_WEBCAM      | 3007  | Something went wrong, and the camera could not be changed. Please try again. |

### 7.Errors associated with Actions

Below error is triggered when an action is attempted before joining a meeting.

| Type                        | Code  | Message                                          |
|-----------------------------|-------|--------------------------------------------------|
| ERROR_ACTION_PERFORMED_BEFORE_MEETING_JOINED     | 3001  | Oops! Something went wrong. The room was in a connecting state, and during that time, an action encountered an issue. Please try again after joining a meeting. |

---

---
sidebar_label: App Size Optimization
pagination_label: App Size Optimization
---

# App Size Optimization - Android

This guide is designed to help developers optimize app size, enhancing performance and efficiency across different devices. By following these best practices, you can reduce load times, minimize storage requirements, and deliver a more seamless experience to users, all while preserving essential functionality.

### Deliver Leaner Apps with App Bundles

Using Android App Bundles (AAB) is an effective way to optimize the size of your application, making it lighter and more efficient for users to download and install. App Bundles allow Google Play to dynamically generate APKs tailored to each device, so users only download the resources and code relevant to their specific configuration. This approach reduces app size significantly, leading to faster installs and conserving storage space on users’ devices.

Recommended Practices:

- `Enable App Bundles`: Configure your build to use the App Bundle format instead of APKs. This will allow Google Play to optimize your app for each device type automatically.

- `Organize Resources by Device Type`: Ensure that resources (like images and layouts) are organized by device type (such as screen density or language) to maximize the benefits of App Bundles.

- `Test Modularization`: If your app contains large, optional features, use dynamic feature modules to let users download them on demand. This reduces the initial download size and provides features only as needed.

- `Monitor Size Reductions`: Regularly analyze your app size to see where the most savings occur, and make sure that App Bundle optimizations are effectively reducing your app size across different device configurations.

### Optimize Libraries for a Leaner App Experience

Managing dependencies carefully is essential for minimizing app size and improving performance. Every library or dependency included in your app adds to its overall size, so it’s crucial to only incorporate what’s necessary. Optimizing dependencies helps streamline your app, reduce load times, and enhance maintainability.

Recommended Practices:

- `Use Only Essential Libraries`: Review all libraries and dependencies, removing any that are not critical to your app’s functionality. This helps avoid unnecessary bloat.

- `Leverage Lightweight Alternatives`: Whenever possible, choose lightweight libraries or modularized versions of larger ones. For example, opt for a specific feature module rather than including an entire library.

- `Monitor Library Updates`: Regularly update your dependencies to take advantage of any optimizations or size reductions made by the library maintainers. Newer versions are often more efficient.

- `Minimize Native Libraries`: If your app uses native libraries, ensure they’re essential and compatible across platforms, as they can significantly increase app size.

- `Analyze Dependency Tree`: Use tools like Gradle’s dependency analyzer to identify unnecessary or redundant dependencies, ensuring your app’s dependency tree is as lean as possible.


### Optimize with ProGuard

ProGuard is a powerful tool for shrinking, optimizing, and obfuscating your code, which can significantly reduce your app's size and improve performance. By removing unused code and reducing the size of classes, fields, and methods, ProGuard helps to minimize the footprint of your app without sacrificing functionality. Additionally, ProGuard’s obfuscation feature enhances security by making reverse engineering more difficult. You can refer to the official [documentation](https://developer.android.com/build/shrink-code) for more information.

Recommended Practices:

- `Enable ProGuard`: To enable ProGuard in your project, ensure that your `proguard-rules.pro` file is properly configured, and add the following lines to your `build.gradle` file:

```js title="build.gradle"
buildTypes {
    release {
        minifyEnabled true
        proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'
    }
}
```

- `Customize ProGuard Rules`: Carefully review and customize ProGuard rules in the proguard-rules.pro file to avoid stripping essential code. For example, to keep a specific class, add:

```js
-keep class com.example.myapp.MyClass { *; }
```

If you encounter an issue after enabling ProGuard rules, refer to our [known issues section](https://docs.videosdk.live/android/guide/video-and-audio-calling-api-sdk/known-issues).

---

---
sidebar_label: Developer Experience Guidelines
pagination_label: Developer Experience Guidelines
---

# Developer Experience Guidelines - Android

This section provides best practices for creating a smooth and efficient development process when working with VideoSDK. From handling errors gracefully to managing resources and event subscriptions, these guidelines help developers build more reliable and maintainable applications. Following these practices can simplify troubleshooting, prevent common pitfalls, and improve overall application performance.

### Initiate Key Features After Meeting Join Event

To provide a seamless and reliable meeting experience, initiate specific features **only** after the [onMeetingJoined()](https://docs.videosdk.live/android/api/sdk-reference/meeting-class/meeting-event-listener-class#onmeetingjoined) event has been triggered.

- **Trigger Key Actions After Joining the Meeting** : Initiating crucial actions after the `onMeetingJoined()` event helps avoid errors and optimizes the meeting setup, ensuring a smoother experience for participants. If your application utilizes any of the following features or you want to perform any action as soon as meeting joins, it's recommended to call them only after the meeting has successfully started:

    - `Chat Subscription`: To enable in-meeting chat functionality, subscribe to the chat topic after the `onMeetingJoined()` event is triggered. This ensures that messages are reliably received by participants.

    <br/>
    <div style={{textAlign: 'center'}}>

    <img src="https://cdn.videosdk.live/docs/best-practices/mobile/android_chat_correct_incorrect_code.png" />

    </div>

    - `Device Management`: If you need users to use specific audio or video devices when the meeting is first joined, you can utilize the [`setSelectedAudioDevice()`](https://docs.videosdk.live/android/api/sdk-reference/videosdk-class/methods#setselectedaudiodevice) and [`setSelectedVideoDevice()`](https://docs.videosdk.live/android/api/sdk-reference/videosdk-class/methods#setselectedvideodevice) methods of `VideoSDK` class.

    - `Recording and Transcription`: To automatically start recording or transcription as soon as the meeting begins, configure the `autoStartConfig` in the `createMeeting` API. For detailed information, refer to the documentation [here](https://docs.videosdk.live/api-reference/realtime-communication/create-room#autoCloseConfig).

### Dispose Custom Tracks When Necessary

Proper disposal of custom tracks is essential for managing system resources and ensuring a smooth experience. In most scenarios, tracks are automatically disposed of by the SDK, ensuring efficient resource management. However, in specific cases outlined below, you will need to dispose of custom tracks explicitly:

1. **When Enabling/Disabling the Camera on a Precall Screen**:
    - If your application includes a precall screen and you want to ensure that the device's camera is not used when the camera is disabled, you must dispose of the custom video track. Otherwise, the device’s camera will continue to be used even when the camera is off.
    - Additionally, remember to create a new track when the user enables the camera again.
    - If you don’t need to manage the camera's usage on the device level (i.e., you’re okay with the camera being used whether it’s enabled or disabled), you can skip this step.
    - Here's how you can manage customTrack on a precall screen :

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
import live.videosdk.rtc.android.CustomStreamTrack
import live.videosdk.rtc.android.VideoSDK
import live.videosdk.rtc.android.VideoView

class JoinActivity : AppCompatActivity() {
    private var videoTrack: CustomStreamTrack? = null
    private var joinView: VideoView? = null

    private fun toggleWebcam(videoDevice: VideoDeviceInfo?) {
        if (isWebcamEnabled) {
            // check the track state is LIVE
            if(videoTrack?.track?.state()?.equals("LIVE") == true){
                videoTrack?.track?.dispose()  // Dispose the current video track
                videoTrack?.track?.setEnabled(false) // Disable the track
            }
            videoTrack = null
            joinView!!.removeTrack() // Remove the video track from the view
            joinView!!.releaseSurfaceViewRenderer()
            joinView!!.visibility = View.INVISIBLE;
        } else {
            // Re-enabling the webcam by creating a new track
            videoTrack = VideoSDK.createCameraVideoTrack(
                "h720p_w960p",
                "front",
                CustomStreamTrack.VideoMode.TEXT,
                true,
                this,
                videoDevice  // Passes the VideoDeviceInfo object of the user's selected device
            )
            // display in localView
            joinView!!.addTrack(videoTrack!!.track as VideoTrack?)
            joinView!!.visibility = View.VISIBLE
        }
        isWebcamEnabled = !isWebcamEnabled // Toggle webcam state
    }
}
```

</TabItem>

<TabItem value="Java">

```js
import live.videosdk.rtc.android.CustomStreamTrack
import live.videosdk.rtc.android.VideoSDK
import live.videosdk.rtc.android.VideoView

public class JoinActivity extends AppCompatActivity {
    private CustomStreamTrack videoTrack = null;
    private VideoView joinView = null;
    private boolean isWebcamEnabled = false;

    private void toggleWebcam(VideoDeviceInfo videoDevice) {
        if (isWebcamEnabled) {
            // Check if the track state is LIVE
            if (videoTrack != null && "LIVE".equals(videoTrack.getTrack().state())) {
                videoTrack.getTrack().dispose(); // Dispose the current video track
                videoTrack.getTrack().setEnabled(false); // Disable the track
            }
            videoTrack = null;
            joinView.removeTrack(); // Remove the video track from the view
            joinView.releaseSurfaceViewRenderer();
            joinView.setVisibility(View.INVISIBLE);
        } else {
            // Re-enabling the webcam by creating a new track
            videoTrack = VideoSDK.createCameraVideoTrack(
                "h720p_w960p",
                "front",
                CustomStreamTrack.VideoMode.TEXT,
                true,
                this,
                videoDevice // Passes the VideoDeviceInfo object of the user's selected device
            );
            // Display in the local view
            joinView.addTrack((VideoTrack) videoTrack.getTrack());
            joinView.setVisibility(View.VISIBLE);
        }
        isWebcamEnabled = !isWebcamEnabled; // Toggle webcam state
    }
}
```
</TabItem>

</Tabs>


### Listen for Error Events

Listening to error events enables your application to handle unexpected issues efficiently, providing users with clear feedback and potential solutions. Error codes pinpoint specific problems, whether from configuration settings, account restrictions, permission limitations, or device constraints. Here are recommended solutions based on common error categories:

1. [Errors associated with Organization](../../api/sdk-reference/error-codes.md#1-errors-associated-with-organization): If you encounter errors related to your organization (e.g., account status or participant limits), reach out to support at support@videosdk.live or reach out to us on [Discord](https://discord.com/invite/Qfm8j4YAUJ) for assistance.

2. [Errors associated with Token](../../api/sdk-reference/error-codes#2-errors-associated-with-token): For errors related to authentication tokens, ensure the token is valid and hasn’t expired, then try the request again.

3. [Errors associated with Meeting and Participant](../../api/sdk-reference/error-codes#3-errors-associated-with-meeting-and-participant): Check that meetingId and participantId are correctly passed and valid. Also, ensure each participant has a unique participantId to avoid duplicate entries.

4. [Errors associated with Add-on Service](../../api/sdk-reference/error-codes#4-errors-associated-with-add-on-service): If you encounter errors with add-on services (such as recording or streaming), try restarting the service after receiving a failure event. For example, if a `START_RECORDING_FAILED` error event occurs, attempt to call the `startRecording()` method again. If you're using webhooks, you can also retry on [recording-failed](https://docs.videosdk.live/api-reference/realtime-communication/user-webhooks#recording-failed) hook.

5. [Errors associated with Media](../../api/sdk-reference/error-codes#5errors-associated-with-media): Inform the user about media access issues, such as microphone or camera permissions. Design the UI to clearly indicate what is preventing the mic or camera from enabling, helping the user understand the problem.

6. [Errors associated with Track](../../api/sdk-reference/error-codes#6errors-associated-with-track): Ensure that the track you’ve created and passed to enable the mic or camera methods meets the required specifications.

7. [Errors associated with Actions](../../api/sdk-reference/error-codes#7errors-associated-with-actions): If you need to perform actions as soon as a meeting joins, only initiate them after receiving the [onMeetingJoined()](https://docs.videosdk.live/android/api/sdk-reference/meeting-class/meeting-event-listener-class#onmeetingjoined) event, otherwise it will not work well.

- Here's how to listen for the error event:

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
private val meetingEventListener: MeetingEventListener = object : MeetingEventListener() {
  //..
  override fun onError(error: JSONObject) {
  try {
      val errorCodes: JSONObject = VideoSDK.getErrorCodes()
      val code = error.getInt("code")
      Log.d("#error", "Error is: " + error["message"])
  } catch (e: Exception) {
          e.printStackTrace()
      }
  }
}
```

</TabItem>

<TabItem value="Java">

```js
private final MeetingEventListener meetingEventListener = new MeetingEventListener() {
  //..
  @Override
  public void onError(JSONObject error) {
      try {
          JSONObject errorCodes = VideoSDK.getErrorCodes();
          int code = error.getInt("code");
          Log.d("#error", "Error is: " + error.get("message"));
      } catch (Exception e) {
          e.printStackTrace();
      }
  }
};
```

</TabItem>

</Tabs>

---

---
sidebar_label: Handle Large Rooms
pagination_label: Handle Large Rooms
---

# Handle Large Rooms - Android

Managing large meetings requires specific strategies to ensure performance, stability, and a seamless user experience. This section provides best practices for optimizing VideoSDK applications to handle high participant volumes effectively. By implementing these recommendations, you can reduce lag, maintain video and audio quality, and provide a smooth experience even in large rooms.

### User Interface Optimization

When hosting large meetings, an optimized UI helps manage participant visibility and ensures smooth performance.

Recommended Practices:

- `Limit Visible Participants`: Display only a limited number of participants on screen at any given time, adapting the view based on screen size. Use pagination to allow users to browse or switch between additional participants seamlessly. For example, you could display only users whose video stream is enabled, or you could choose to display all active speakers. This approach helps manage screen space efficiently, ensuring that the most relevant participants are visible without overwhelming the interface.
- `Prioritize Active Speakers`: Ensure all active speakers are displayed on the screen to highlight who is currently talking, helping participants stay engaged and aware of ongoing discussions. To identify which participant is speaking, you can use the [onSpeakerChanged()](https://docs.videosdk.live/android/api/sdk-reference/meeting-class/meeting-event-listener-class#onspeakerchanged) event.

### Optimizing Media Streams 

In large video calls, it’s important to manage media streams effectively to optimize system resources while maintaining a smooth user experience. 

Recommended Practices:

- `Pause Streams for Non-Visible Participants`: To optimize performance, pause the video and/or audio streams of participants who are not currently visible on the screen. This reduces unnecessary resource consumption.
- `Resume Streams When Visible`: Once a participant comes into view, resume their stream to provide an uninterrupted experience as they appear on the screen.

For detailed setup instructions on how to achieve this, check out our in-depth documentation [here](https://docs.videosdk.live/android/guide/video-and-audio-calling-api-sdk/render-media/layout-and-grid-management#pauseresume-stream).

### Media Stream Quality Adjustment

In large meetings, managing media stream quality is essential to balance performance and user experience. 

Recommended Practices:

- `High Quality for Active Speakers`: For all active speakers, set the video stream quality to a higher level using the setQuality method (e.g., `setQuality("high")`). This ensures that participants will receive higher-quality video for active speakers, providing a clearer and more engaging experience.
- `Lower Quality for Non-Speaking Participants`: For other participants who are not actively speaking, set their video stream quality to a lower level (e.g., `setQuality("low")`). This helps conserve bandwidth and system resources while maintaining overall meeting performance.

Checkout the documentation for `setQuality()` method [here](https://docs.videosdk.live/android/api/sdk-reference/participant-class/methods#setquality) 

---

---
sidebar_label: User Experience Guidelines
pagination_label: User Experience Guidelines
---

# User Experience Guidelines - Android

This guide aims to help developers optimize the user experience and functionality of video conferencing applications with VideoSDK. By following these best practices, you can create smoother interactions, minimize common issues, and deliver a more reliable experience for users.

Here are our recommended best practices to enhance the user experience in your application:

| **Section**                          | **Description**                                                                                                                                                      |
|--------------------------------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| [Configure Precall for Effortless Meeting Join](#configure-precall-for-effortless-meeting-join) | Users may enter meetings unprepared due to device or connection issues. A Precall setup can help them configure devices and settings beforehand for a smooth start. |
| [Listen Key Events for Optimal User Experience](#listen-key-events-for-optimal-user-experience) | Users can feel lost without real-time updates on meeting status, events, and errors. Event monitoring and notifications keep them informed and engaged.              |
| [Handling Media Devices](#handling-media-devices)                                             | Users may want to change their audio or video setup mid-meeting but struggle to manage device controls. Providing easy device switching enhances control and flexibility. |
| [Monitoring Real-Time Participant Statistics](#monitoring-real-time-participant-statistics)   | Poor video or audio quality without real-time feedback leaves users frustrated. Real-time stats let them assess connection quality and troubleshoot issues actively.    |

### Configure Precall for Effortless Meeting Join

A Precall step is crucial for ensuring users are set up correctly and have no device before joining a meeting. This step allows users to configure their devices and settings before entering a meeting, leading to a smoother experience and minimizing technical issues once the call begins.

Recommended Practices:

- `Request Permissions`: Prompt users to grant microphone, and camera permissions before entering the meeting, ensuring seamless access to their devices.
- `Device Selection`: Allow users to select their preferred camera, and microphone giving them control over their setup from the start.
- `Entry Preferences`: Provide options to join with the microphone and camera either on or off, letting users choose their level of engagement upon entry.
- `Camera Preview`: Show a live camera preview, allowing users to adjust angles and lighting to ensure they appear clearly and professionally.
- `Virtual Backgrounds`: Allow users to choose from different virtual backgrounds or enter with a virtual background enabled, enhancing privacy and creating a more polished appearance.

For detailed setup instructions on each of these features, check out our in-depth documentation [here](https://docs.videosdk.live/android/guide/video-and-audio-calling-api-sdk/setup-call/precall).

<div style={{textAlign: 'center'}}>

<img height="400" src="https://cdn.videosdk.live/docs/best-practices/mobile/mobile_precall.gif" />

</div>

### Monitor Key Events for Optimal User Experience

Listening for crucial events is vital for providing users with a responsive and engaging experience in your application. By effectively managing state changes and user notifications, you can keep participants informed and enhance their overall experience during meetings.

Recommended Practices:

- `Monitor State Change Events`: Listen for state change events, such as `onMeetingStateChanged` and `onRecordingStateChanged`, and notify users promptly about these transitions. Keeping users informed helps them understand the current state of the meeting.

<div style={{textAlign: 'center'}}>

<img height="400" src="https://cdn.videosdk.live/docs/best-practices/mobile/mobile_meeting_state.jpg" />

</div>

- `UI Handling on Event Trigger`: Update the user interface only in response to specific events. For instance, display that the meeting is recording only when the `onRecordingStateChanged` event with the status `RECORDING_STARTED` is received, rather than when the record button is clicked. This ensures users receive accurate and timely updates.

<div style={{textAlign: 'center'}}>

<img height="400" src="https://cdn.videosdk.live/docs/best-practices/mobile/mobile_recording.gif" />

</div>

- `Notify Participants of Join/Leave Events`: Keep users informed about participant activity by notifying them when someone joins or leaves the meeting. This fosters a sense of presence and awareness of who is currently available to engage.
- `Listen for Error Events`: It is crucial to monitor error events and notify users promptly when issues arise. Clear communication about errors can help users troubleshoot and address problems quickly, minimizing disruptions to the meeting.


### Handling Media Devices

Providing seamless control over devices enhances user convenience and allows participants to adjust their setup for the best meeting experience. Proper device management within the UI also helps users stay informed about their current settings and troubleshoot issues effectively.

Recommended Practices:

- `Allow Device Switching`: Provide users with the option to switch between available microphone, and camera devices during the meeting. This flexibility is essential, especially if users want to adjust their setup mid-call.
- `Display Selected Devices`: Ensure the UI shows users which microphone, and camera devices are currently selected. Clear device labeling in the interface can reduce confusion and help users verify their setup at a glance.

<div style={{textAlign: 'center'}}>

<img height="400" src="https://cdn.videosdk.live/docs/best-practices/mobile/mobile_audio_selected_device.jpg" />

</div>

### Monitoring Real-Time Participant Statistics

Providing real-time insights into stream quality allows participants to monitor and optimize their connection for the best experience. With detailed metrics on video, audio, and screen sharing, users can assess and troubleshoot quality issues, ensuring smooth and uninterrupted meetings. To display these statistics, you can use the [getVideoStats()](https://docs.videosdk.live/android/api/sdk-reference/participant-class/methods#getvideostats), [getAudioStats()](https://docs.videosdk.live/android/api/sdk-reference/participant-class/methods#getaudiostats), and [getShareStats()](https://docs.videosdk.live/android/api/sdk-reference/participant-class/methods#getsharestats) methods.

import ReactPlayer from 'react-player'

<div style={{textAlign: 'center'}}>

<ReactPlayer autoplay muted loop playing url='https://cdn.videosdk.live/docs/best-practices/mobile/mobile_call-stats.mp4' width={"100%"}/>

</div>

<br/>

:::note
To show the popup dialog for the participant's realtime stats, you can [refer to this function](https://github.com/videosdk-live/videosdk-rtc-android-kotlin-sdk-example/blob/main/app/src/main/java/live/videosdk/rtc/android/kotlin/Common/Utils/HelperClass.kt#L91).
:::



---

---
sidebar_label: Face Match API (BETA)
pagination_label: Face Match API (BETA)
---

# Face Match API (BETA)

import FaceMatchApi from '../../../../mdx/\_api-face-match.mdx';

<FaceMatchApi/>


---

---
sidebar_label: Face Spoof Detection API (BETA)
pagination_label: Face Spoof Detection API (BETA)
---

# Face Spoof Detection (BETA)

import FaceSpoofDetection from '../../../../mdx/\_api-spoof-detection.mdx';

<FaceSpoofDetection/>


---

---
sidebar_label: Number of Face Detection API (BETA)
pagination_label: Number of Face Detection API (BETA)
---

# Number of Face Detection (BETA)

import NoOfFaceDetectionApi from '../../../../mdx/\_api-number-of-face-detection.mdx';

<NoOfFaceDetectionApi/>


---

---
sidebar_label: OCR API (BETA)
pagination_label: OCR API (BETA)
---

# OCR API (BETA)

import OcrApi from '../../../../mdx/\_api-ocr.mdx';

<OcrApi/>


---

---
title: Customized Live Stream
sidebar_position: 1
sidebar_label: Customized Live Stream
hide_table_of_contents: false
---

# Customized Live Stream - Android

VideoSDK is a platform that offers a range of video streaming tools and solutions for content creators, publishers, and developers.

### Custom Template

- Custom template is template for live stream, which allows users to add real-time graphics to their streams.
- With custom templates, users can create unique and engaging video experiences by overlaying graphics, text, images, and animations onto their live streams. These graphics can be customized to match the branding.
- Custom templates enable users to create engaging video content with real-time graphics, with live scoreboards, social media feeds, and other customizations, users can easily create unique and visually appealing streams that stands out from the crowd.

:::note

Custom templates can be used with recordings and RTMP service provided by VideoSDK as well.

:::

### What you can do with Custom Template

Using a custom template, you may create a variety of various modes. Here are a few of the more well-known modes that you can create.

- **`PK Host:`** Host can organise player vs player battle. Below image is example of gaming battle.

- **`Watermark:`** Host can add & update watermark anywhere in the template. In below image we have added VideoSDK watermark on top right side of the screen.

- **`News Mode:`** Host can add dynamic text in lower third banner. in below image we have added some sample text in bottom left of the screen.

![Mobile Custom Template ](https://cdn.videosdk.live/website-resources/docs-resources/mobile_custom_template.png)

### Custom template with VideoSDK

In this section, we will discuss how Custom Templates work with VideoSDK.

- **`Host`**: The host is responsible for starting the live streaming by passing the `templateURL`. The `templateURL` is the URL of the hosted template webpage. The host is also responsible for managing the template, such as changing text, logos, and switching template layout, among other things.

- **`VideoSDK Template Engine`** : The VideoSDK Template Engine accepts and opens the templateURL in the browser. It listens to all the events performed by the Host and enables customization of the template according to the Host's preferences.

- **`Viewer`**: The viewer can stream the content. They can watch the live stream with the added real-time graphics, which makes for a unique and engaging viewing experience.

![custom template](https://cdn.videosdk.live/website-resources/docs-resources/custom_template.png)

### Understanding Template URL

The template URL is the webpage that VideoSDK Template Engine will open while composing the live stream.

The template URL will appear as shown below.

![template url](https://cdn.videosdk.live/website-resources/docs-resources/custom_template_url.png)

The Template URL consists of two parts:

- Your actual page URL, which will look something like `https://example.com/videosdk-template`.
- Query parameters, which will allow the VideoSDK Template Engine to join the meeting when the URL is opened. There are a total of three query parameters:
  - `token`: This will be your token, which will be used to join the meeting.
  - `meetingId`: This will be the meeting ID that will be joined by the VideoSDK Template Engine.
  - `participantId`: This will be the participant ID of the VideoSDK Template Engine, which should be passed while joining the template engine in your template so that the tempalte engine participant is not visible to other participants. **This parameter will be added by the** **VideoSDK**.

:::info

Above mentioned query parameters are mandatory. Apart from these parameters, you can pass any other extra parameters which are required according to your use-case.

:::

### **Creating Template**

**`Step 1:`** Create a new React App using the below command

```js
npx create-react-app videosdk-custom-template
```

:::note

You can use VideoSDK's React or JavaScript SDK to create custom template. Following is the example of building custom template with React SDK.

:::

**`Step 2:`** Install the VideoSDK using the below-mentioned npm command.

Make sure you are in your react app directory before you run this command.

```js
npm install "@videosdk.live/react-sdk"

//For the Participants Video
npm install "react-player"
```

###### App Architecture

![template architechture](https://cdn.videosdk.live/website-resources/docs-resources/custom_template_arch.png)

###### Structure of the Project

```jsx title="Project Structure"
   root
   ├── node_modules
   ├── public
   ├── src
   │    ├── components
   │          ├── MeetingContainer.js
   │          ├── ParticipantsAudioPlayer.js
   │          ├── ParticipantsView.js
   │          ├── Notification.js
   │    ├── icons
   │    ├── App.js
   │    ├── index.js
   ├── package.json
   .
```

**`Step 3:`** Next we will fetch the query parameters, from the URL which we will later use to initialize the meeting

```js title=App.js
function App() {
  const { meetingId, token, participantId } = useMemo(() => {
    //highlight-start
    const location = window.location;

    const urlParams = new URLSearchParams(location.search);

    const paramKeys = {
      meetingId: "meetingId",
      token: "token",
      participantId: "participantId",
    };

    Object.keys(paramKeys).forEach((key) => {
      paramKeys[key] = urlParams.get(key)
        ? decodeURIComponent(urlParams.get(key))
        : null;
    });

    return paramKeys;
    //highlight-end
  }, []);
}
```

**`Step 4:`** Now we will initialize the meeting with the parameters we extracted from the URL. Make sure `joinWithoutUserInteraction` is specified, so that the template engine is able to join directly into the meeting, on the page load.

```js title=App.js
function App(){
//highlight-next-line
...

return meetingId && token && participantId ? (
  <div>
    <MeetingProvider
      //highlight-start
      config={{
        meetingId,
        micEnabled: false,
        webcamEnabled: false,
        name: "recorder",
        participantId,
      }}
      token={token}
      joinWithoutUserInteraction
      //highlight-end
    >
      {/* We will create this in upcoming steps */}
      <MeetingContainer />
    </MeetingProvider>
  </div>
) : null;

}
```

**`Step 5:`** Let us create the `MeetingContainer` which will render the meeting view for us.

- It will also listen to the PubSub messages from the `CHANGE_BACKGROUND` topic, which will change the background color of the meeting.
- It will have `Notification` component which will show any messages share by Host

:::note

We will be using the PubSub mechanism to communicate with the template. You can learn more about [PubSub from here](../video-and-audio-calling-api-sdk/collaboration-in-meeting/pubsub).

:::

import CautionMessage from '@site/src/theme/CautionMessage';

<CautionMessage sdk="Android SDK" version="v0.2.0" />

```js title=MeetingContainer.js
import { Constants, useMeeting, usePubSub } from "@videosdk.live/react-sdk";
import { Notification } from "./Notification";
import { ParticipantsAudioPlayer } from "./ParticipantsAudioPlayer";
import { ParticipantView } from "./ParticipantView";

export const MeetingContainer = () => {
  const { isMeetingJoined, participants, localParticipant } = useMeeting();
  //highlight-next-line
  const { messages } = usePubSub("CHANGE_BACKGROUND");

  const remoteSpeakers = [...participants.values()].filter((participant) => {
    return (
      participant.mode == Constants.modes.SEND_AND_RECV && !participant.local
    );
  });

  return isMeetingJoined ? (
    <div
      style={{
        display: "flex",
        flexDirection: "column",
        height: "100vh",
        //highlight-start
        backgroundColor:
          messages.length > 0
            ? messages.at(messages.length - 1).message
            : "#fff",
        //highlight-end
      }}
    >
      //highlight-next-line
      <ParticipantsAudioPlayer />
      <div
        style={{
          display: "grid",
          gridTemplateColumns: remoteSpeakers?.length > 1 ? "1fr 1fr" : "1fr",
          flex: 1,
          maxHeight: `100vh`,
          overflowY: "auto",
          gap: "20px",
          padding: "20px",
          alignItems: "center",
          justifyItems: "center",
        }}
      >
        {[...remoteSpeakers].map((participant) => {
          return (
            //highlight-start
            <ParticipantView
              key={participant.id}
              participantId={participant.id}
            />
            //highlight-end
          );
        })}
      </div>
      //highlight-next-line
      <Notification />
    </div>
  ) : (
    <div
      style={{
        display: "flex",
        justifyContent: "center",
        alignItems: "center",
        height: "100vh",
      }}
    >
      <div class="loader"></div>
    </div>
  );
};
```

**`Step 6:`** Let us create the `ParticipantView` and `ParticipantsAudioPlayer` which will render the video and audio of the participants respectively.

```js title=ParticipantView.js
import { useParticipant } from "@videosdk.live/react-sdk";
import { useMemo } from "react";
import ReactPlayer from "react-player";
import MicOffIcon from "../icons/MicOffIcon";

export const ParticipantView = (props) => {
  const { webcamStream, webcamOn, displayName, micOn } = useParticipant(
    props.participantId
  );

  const videoStream = useMemo(() => {
    if (webcamOn && webcamStream) {
      const mediaStream = new MediaStream();
      mediaStream.addTrack(webcamStream.track);
      return mediaStream;
    }
  }, [webcamStream, webcamOn]);

  return (
    <div
      style={{
        width: "100%",
        height: "400px",
        maxWidth: "600px",
        display: "flex",
        flex: 1,
        alignItems: "center",
        justifyContent: "center",
        position: "relative",
        backgroundColor: "#1A1C22",
        borderRadius: "10px",
        overflow: "hidden",
      }}
      class="video-cover"
    >
      {webcamOn && webcamStream ? (
        <ReactPlayer
          //
          playsinline // extremely crucial prop
          pip={false}
          light={false}
          controls={false}
          muted={true}
          playing={true}
          //
          url={videoStream}
          //
          height={"100%"}
          width={"100%"}
          onError={(err) => {
            console.log(err, "participant video error");
          }}
        />
      ) : (
        <div
          style={{
            fontSize: "50px",
            color: "#fff",
          }}
        >
          {String(displayName).charAt(0).toUpperCase()}
        </div>
      )}
      <div
        style={{
          position: "absolute",
          left: "10px",
          bottom: "10px",
          backgroundColor: "#050A0E",
          color: "#fff",
          padding: "4px",
          borderRadius: "4px",
          alignItems: "center",
          justifyItems: "center",
          display: "flex",
        }}
      >
        {displayName}{" "}
        {!micOn && <MicOffIcon fillcolor="#fff" height="18" width="18" />}
      </div>
    </div>
  );
};
```

```js title=ParticipantsAudioPlayer.js
import { useMeeting, useParticipant } from "@videosdk.live/react-sdk";
import { useEffect, useRef } from "react";

const ParticipantAudio = ({ participantId }) => {
  const { micOn, micStream, isLocal } = useParticipant(participantId);
  const audioPlayer = useRef();

  useEffect(() => {
    if (!isLocal && audioPlayer.current && micOn && micStream) {
      const mediaStream = new MediaStream();
      mediaStream.addTrack(micStream.track);

      audioPlayer.current.srcObject = mediaStream;
      audioPlayer.current.play().catch((err) => {});
    } else {
      audioPlayer.current.srcObject = null;
    }
  }, [micStream, micOn, isLocal, participantId]);

  return <audio autoPlay playsInline controls={false} ref={audioPlayer} />;
};

export const ParticipantsAudioPlayer = () => {
  const mMeeting = useMeeting();

  const participants = mMeeting?.participants;

  return participants ? (
    [...participants.keys()].map((participantId) => (
      <ParticipantAudio
        key={`participant_audio_${participantId}`}
        participantId={participantId}
      />
    ))
  ) : (
    <></>
  );
};
```

**`Step 7:`** Let us create the `Notification` component which will listen to PubSub messages for the topic `SIGNALLING_ONLY_MESSAGE` and show a notification on the lower left corner.

```js title=Notification.js
import { usePubSub } from "@videosdk.live/react-sdk";
import { useEffect, useRef, useState } from "react";

export const Notification = () => {
  const timeoutRef = useRef(null);
  const handleChatMessage = (msg) => {
    if (timeoutRef.current) {
      clearTimeout(timeoutRef.current);
    }
    setMessage(msg);
    timeoutRef.current = setTimeout(() => {
      setMessage(null);
    }, 3200);
  };
  const [message, setMessage] = useState(null);
  const { publish } = usePubSub("SIGNALLING_ONLY_MESSAGE", {
    onMessageReceived: handleChatMessage,
  });
  useEffect(() => {
    return () => {
      if (timeoutRef.current) {
        clearTimeout(timeoutRef.current);
      }
    };
  }, []);
  return message ? (
    <div
      style={{
        backgroundColor: "#232830",
        padding: "10px",
        textAlign: "center",
        color: "#fff",
        position: "absolute",
        bottom: "50px",
        left: "30px",
        borderRadius: "10px",
        animation: "fadein 0.5s",
      }}
    >
      <strong>
        {message.senderName} says {message.message}
      </strong>
    </div>
  ) : null;
};
```

:::note

For the CSS stylings and animations used in the project, please [refer to this file](https://github.com/videosdk-live/quickstart/blob/main/react-custom-template-manager/src/index.css).

:::

**`Step 9:`** Once tested, you can deploy it using your backend or host it on services like [firebase](https://www.geeksforgeeks.org/how-to-deploy-react-project-on-firebase/) or vercel.

:::tip

You can checkout the github repository for sample custom template we just [created here](https://github.com/videosdk-live/videosdk-custom-recording-template-react-example).

:::

### Setup Livestream Using Custom Template

- To use Custom Template, you will need Host and Viewer setup from where the host will start the livestream and viewer can watch them.

![Android Custom Template Example](https://cdn.videosdk.live/website-resources/docs-resources/android_custom_template.png)

- You can clone this example and run it on your system.

```bash
git clone https://github.com/videosdk-live/quickstart.git
```

- The cloned example will contain two directories under the `android-custom-template-manager` directory which has to runned.

  - **For Kotlin** : `Videosdk_android_kotlin_hls_quickstart`
  - **For Java** : `Videosdk_android_java_hls_quickstart`

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
cd android-custom-template-manager
cd Videosdk_android_kotlin_hls_quickstart
```

</TabItem>

<TabItem value="Java">

```js
cd android-custom-template-manager
cd Videosdk_android_java_hls_quickstart
```

</TabItem>

</Tabs>

- To use the custom template which we just deployed, we will call the [Start HLS API](https://docs.videosdk.live/api-reference/realtime-communication/start-hlsStream) instead of the `startHls` method from the `Meeting` class. This code has already been added in the example you cloned.

:::note
`downstreamUrl` is now depecated. Use `playbackHlsUrl` or `livestreamUrl` in place of `downstreamUrl`
:::

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
btnHls!!.setOnClickListener {
  //Update your Custom Template URL here if you have deployed your own, if not deployed you can use this template from our URL.
  //highlight-start
  val templateUrl =
      "https://lab.videosdk.live/react-custom-template-demo?meetingId=" + meeting!!.meetingId + "&token=" + token
  //highlight-end

  val bodyJson = JSONObject()
  JsonUtils.jsonPut(bodyJson, "roomId", meeting!!.meetingId)
  JsonUtils.jsonPut(bodyJson, "templateUrl", templateUrl)

  val config= new JSONObject()
  JsonUtils.jsonPut(config,"orientation","portrait")
  JsonUtils.jsonPut(bodyJson,"config",config)

  AndroidNetworking.post("https://api.videosdk.live/v2/hls/start")
    .addHeaders(
        "Authorization",
        token
    ) //we will pass the token in the Headers
    .addJSONObjectBody(bodyJson)
    .build()
    .getAsJSONObject(object : JSONObjectRequestListener {
        override fun onResponse(response: JSONObject) {
            try {
                Log.d("TAG", "onResponse: $response") // result will have playbackHlsUrl and livestreamUrl
            } catch (e: Exception) {
                e.printStackTrace()
            }
        }
        override fun onError(anError: ANError) {
            anError.printStackTrace()
            Toast.makeText(
                mContext,
                anError.message,
                Toast.LENGTH_SHORT
            ).show()
        }
    })
}
```

</TabItem>

<TabItem value="Java">

```js
btnHls.setOnClickListener(v -> {
  //Update your Custom Template URL here if you have deployed your own, if not deployed you can use this template from our URL.
  //highlight-start
  final String templateUrl =
  "https://lab.videosdk.live/react-custom-template-demo?meetingId=" + meeting.getMeetingId() + "&token=" + token;
  //highlight-end

  JSONObject bodyJson = new JSONObject();
  JsonUtils.jsonPut(bodyJson, "roomId", meeting.getMeetingId());
  JsonUtils.jsonPut(bodyJson, "templateUrl", templateUrl);

  JSONObject config= new JSONObject();
  JsonUtils.jsonPut(config,"orientation","portrait");
  JsonUtils.jsonPut(bodyJson,"config",config);

  AndroidNetworking.post("https://api.videosdk.live/v2/hls/start")
    .addHeaders("Authorization", token) //we will pass the token in the Headers
    .addJSONObjectBody(bodyJson)
    .build()
    .getAsJSONObject(new JSONObjectRequestListener() {
        @Override
        public void onResponse(JSONObject response) {
            try {
                Log.d("TAG", "onResponse: " + response.toString()); // result will have playbackHlsUrl and livestreamUrl
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        @Override
        public void onError(ANError anError) {
            anError.printStackTrace();
            Toast.makeText(mContext, anError.getMessage(), Toast.LENGTH_SHORT).show();
        }
    });
});
```

</TabItem>

</Tabs>

- This example has two option on the Host side which will allow them to change the background and send the messages to the viewer.

- Let's give this example a test run.

import ReactPlayer from 'react-player'

<div style={{textAlign: 'center'}}>

<ReactPlayer autoplay muted loop playing controls url="https://cdn.videosdk.live/website-resources/docs-resources/android_custom_template_video.mp4" height="500px" width={"100%"} />

</div>

### API Reference

The API references for all the methods utilized in this guide are provided below.

- [Start HLS API](/api-reference/realtime-communication/start-hlsStream)
- [onHlsStateChanged](/android/api/sdk-reference/meeting-class/meeting-event-listener-class#onhlsstatechanged)


---

---
title: Display Attendees Count - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: Interactive Livestream features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Display Attendees Count
pagination_label: Display Attendees Count
keywords:
  - Start HLS meeting
  - Stop HLS meeting
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: display-attendees-count
---

# Display Attendees Count - Android

In this guide, we will see how you can display the number of attendees in realtime.

:::note
Before going forward in this guide, do make sure all the attendees join the meeting with mode as `SIGNALLING_ONLY`
:::

- We will get the all the `participants` except local participant using `getParticipants()` method of the the `Meeting` class. With all the participants, we will filter out participants who have joined as a `SIGNALLING_ONLY` and then display that count.

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
private fun showViewerCount() {
    var viewerCount = 1  // start with 1 to count local participant
    val participants = meeting!!.participants
    for (entry: Map.Entry<String, Participant> in participants.entries) {
        val participant = entry.value
        if (participant.mode == "SIGNALLING_ONLY") {
            viewerCount++
        }
    }
    this.viewerCount!!.text = viewerCount.toString()
}
```

</TabItem>

<TabItem value="Java">

```js
private void showViewerCount() {
    int viewerCount = 1; // start with 1 to count local participant
    Map<String, Participant> participants = meeting.getParticipants();
    for (Map.Entry<String, Participant> entry : participants.entrySet()) {
        Participant participant = entry.getValue();
        if (participant.getMode().equals("SIGNALLING_ONLY")) {
            viewerCount++;
        }
    }
    this.viewerCount.setText(String.valueOf(viewerCount));
}
```

</TabItem>

</Tabs>

## API Reference

The API references for all the methods utilized in this guide are provided below.

- [getparticipants()](/android/api/sdk-reference/meeting-class/properties#getparticipants)


---

---
title: Invite Guest on Stage - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: Interactive Livestream features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Invite Guest on Stage
pagination_label: Invite Guest on Stage
keywords:
  - Start HLS meeting
  - Stop HLS meeting
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: invite-guest-on-stage
---

# Invite Guest on Stage - Android

In this guide, we will see how you can request a viewer to join your livestream by using the `changeMode()`.

import CautionMessage from '@site/src/theme/CautionMessage';

<CautionMessage sdk="Android SDK" version="v0.2.0" />

Let's first have a look at how we will be using the `PubSub` mechanism to acheive the requesting and switching of the participant's mode.

![invite-guest-pubsub](https://cdn.videosdk.live/website-resources/docs-resources/invite_guest_pubsub.png)

:::note
Before going forward in this guide, do make sure all the attendees join the meeting with mode as `SIGNALLING_ONLY` and the host joins with mode as `SEND_AND_RECV`
:::

### Step 1: Loading Viewer List

The host will see a list of participants who have joined as `SIGNALLING_ONLY` along with a button that, when selected, will invite that user to join the livestream.

Here we are using `RecyclerView` to display viewer list with button.

```xml title="layout_viewers_list_view.xml"
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical"
    android:background="#2B3034"
    android:id="@+id/layout_participants">

    <TextView
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_gravity="center"
        android:paddingVertical="15sp"
        android:text="Viewer List"
        android:textSize="20sp"
        android:textColor="@color/white"/>

    <androidx.recyclerview.widget.RecyclerView
        android:id="@+id/rvViewersLinearView"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:paddingHorizontal="15sp" />

</LinearLayout>
```

```xml title="item_viewer_list_layout.xml"
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="wrap_content"
    android:layout_marginBottom="10dp"
    android:gravity="center"
    android:orientation="horizontal"
    android:padding="12dp">


    <TextView
        android:id="@+id/viewerName"
        android:layout_width="0dp"
        android:layout_height="wrap_content"
        android:layout_weight="1"
        android:textSize="20sp"
        android:textColor="@color/white"/>

    <Button
        android:id="@+id/btnRequest"
        android:layout_width="0dp"
        android:layout_height="wrap_content"
        android:layout_weight="1"
        android:text="Request to join Stage"
        android:textAllCaps="false" />


</LinearLayout>
```

- Create a recycler view adapter named `ViewerListAdapter` which will show the viewer list. Create `PeerViewHolder` in the adapter which will extend `RecyclerView.ViewHolder`.

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
class ViewerListAdapter(items: ArrayList<Participant?>?, private val meeting: Meeting) :
    RecyclerView.Adapter<ViewerListAdapter.ViewHolder?>() {
    private var viewers = ArrayList<Participant?>()

    init {
      viewers.addAll(items!!)

      //highlight-next-line
      // adding Meeting Event listener to get the participant join/leave and panticipant mode change event in the meeting.
      meeting.addEventListener(object : MeetingEventListener() {
        override fun onParticipantJoined(participant: Participant) {
            super.onParticipantJoined(participant)
            viewers = ArrayList()
            viewers.addAll(allViewers)
            notifyDataSetChanged()
        }

        override fun onParticipantLeft(participant: Participant) {
            super.onParticipantLeft(participant)
            viewers = ArrayList()
            viewers.addAll(allViewers)
            notifyDataSetChanged()
        }

        override fun onParticipantModeChanged(data: JSONObject) {
            viewers = ArrayList()
            viewers.addAll(allViewers)
            notifyDataSetChanged()
        }
      })
    }

    private val allViewers: ArrayList<Participant?>
        private get() {
            val viewerList: ArrayList<Participant?> = ArrayList()
            val participants: Iterator<Participant> = meeting.participants.values.iterator()
            for (i in 0 until meeting.participants.size) {
                val participant = participants.next()
                //highlight-start
                if (participant.mode == "SIGNALLING_ONLY") {
                    viewerList.add(participant)
                }
                //highlight-end
            }
            return viewerList
        }

    override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): ViewHolder {
        return ViewHolder(
            LayoutInflater.from(parent.context)
                .inflate(R.layout.item_viewer_list_layout, parent, false)
        )
    }

    override fun onBindViewHolder(holder: ViewHolder, position: Int) {
        val participant = viewers[position]
        holder.viewerName.text = viewers[position]!!.displayName
    }

    override fun getItemCount(): Int {
        return viewers.size
    }

    class ViewHolder(itemView: View) : RecyclerView.ViewHolder(itemView) {
        var viewerName: TextView
        var btnRequest: Button

        init {
            viewerName = itemView.findViewById(R.id.viewerName)
            btnRequest = itemView.findViewById(R.id.btnRequest)
        }
    }
}
```

</TabItem>

<TabItem value="Java">

```js
public class ViewerListAdapter extends RecyclerView.Adapter<ViewerListAdapter.ViewHolder> {
    private ArrayList<Participant> viewers = new ArrayList<>();
    private Meeting meeting;

    public ViewerListAdapter(ArrayList<Participant> items, Meeting meeting) {
      this.meeting = meeting;
      viewers.addAll(items);

      //highlight-next-line
      // adding Meeting Event listener to get the participant join/leave and panticipant mode change event in the meeting.
      meeting.addEventListener(new MeetingEventListener() {
        @Override
        public void onParticipantJoined(Participant participant) {
            super.onParticipantJoined(participant);
            viewers = new ArrayList<>();
            viewers.addAll(getAllViewers());
            notifyDataSetChanged();
        }

        @Override
        public void onParticipantLeft(Participant participant) {
            super.onParticipantLeft(participant);
            viewers = new ArrayList<>();
            viewers.addAll(getAllViewers());
            notifyDataSetChanged();
        }

        @Override
        public void onParticipantModeChanged(JSONObject data) {
            viewers = new ArrayList<>();
            viewers.addAll(getAllViewers());
            notifyDataSetChanged();
        }
      });

    }

    private ArrayList<Participant> getAllViewers() {
        ArrayList<Participant> viewerList = new ArrayList();
        Iterator<Participant> participants = meeting.getParticipants().values().iterator();

        for (int i = 0; i < meeting.getParticipants().size(); i++) {
            //highlight-start
            final Participant participant = participants.next();
            if (participant.getMode().equals("SIGNALLING_ONLY")) {
                viewerList.add(participant);
            }
            //highlight-end
        }
        return viewerList;
    }

    @NonNull
    @Override
    public ViewHolder onCreateViewHolder(@NonNull ViewGroup parent, int viewType) {
        return new ViewHolder(LayoutInflater.from(parent.getContext()).inflate(R.layout.item_viewer_list_layout, parent, false));
    }

    @Override
    public void onBindViewHolder(@NonNull ViewHolder holder, int position) {
        final Participant participant = viewers.get(position);
        holder.viewerName.setText(viewers.get(position).getDisplayName());
    }

    @Override
    public int getItemCount() {
        return viewers.size();
    }

    static class ViewHolder extends RecyclerView.ViewHolder {
        TextView viewerName;
        Button btnRequest;

        public ViewHolder(@NonNull View itemView) {
            super(itemView);
            viewerName = itemView.findViewById(R.id.viewerName);
            btnRequest = itemView.findViewById(R.id.btnRequest);
        }
    }

}
```

</TabItem>

</Tabs>

- Set this adapter to `RecyclerView`

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
btnViewerList.setOnClickListener { openViewerList() }

fun openViewerList() {
  val viewerListView: RecyclerView
  val bottomSheetDialog = BottomSheetDialog(mContext!!)
  val layout_participants = findViewById(R.id.layout_participants)
  val v3 = LayoutInflater.from(mContext)
      .inflate(R.layout.layout_viewers_list_view, layout_participants)
  bottomSheetDialog.setContentView(v3)
  viewerListView = v3.findViewById(R.id.rvViewersLinearView)
  viewerListView.minimumHeight = 400
  bottomSheetDialog.show()
  val viewerList: ArrayList<*> = ArrayList<Any?>()
  val participants: Iterator<Participant> = meeting!!.participants.values.iterator()
  for (i in 0 until meeting!!.participants.size) {
      val participant = participants.next()
      //highlight-start
      if (participant.mode == "SIGNALLING_ONLY")
        viewerList.add(participant)
      //highlight-end
  }
  viewerListView.layoutManager = LinearLayoutManager(mContext)
  //highlight-next-line
  viewerListView.adapter = ViewerListAdapter(viewerList, meeting!!)
  viewerListView.setHasFixedSize(true)
}
```

</TabItem>

<TabItem value="Java">

```js
btnViewerList.setOnClickListener(v -> openParticipantList());

public void openViewerList() {
  RecyclerView viewerListView;
  BottomSheetDialog bottomSheetDialog = new BottomSheetDialog(mContext);
  LinearLayout layout_participants = findViewById(R.id.layout_participants);
  View v3 = LayoutInflater.from(mContext).inflate(R.layout.layout_viewers_list_view, layout_participants);
  bottomSheetDialog.setContentView(v3);
  viewerListView = v3.findViewById(R.id.rvViewersLinearView);
  viewerListView.setMinimumHeight(400);
  bottomSheetDialog.show();

  ArrayList viewerList = new ArrayList();
  final Iterator<Participant> participants = meeting.getParticipants().values().iterator();
  for (int i = 0; i < meeting.getParticipants().size(); i++) {
      final Participant participant = participants.next();
      //highlight-start
      if (participant.getMode().equals("SIGNALLING_ONLY"))
          viewerList.add(participant);
      //highlight-end
  }
  viewerListView.setLayoutManager(new LinearLayoutManager(mContext));
  //highlight-next-line
  viewerListView.setAdapter(new ViewerListAdapter(viewerList, meeting));
  viewerListView.setHasFixedSize(true);
}

```

</TabItem>

</Tabs>

<center>

<img style={{height: '450px'}} src="https://cdn.videosdk.live/website-resources/docs-resources/android_stage_request.jpg" />

</center>

### Step 2: Requesting a Viewer to Join Livestream

We have a Viewer list ready. Now, let us handle the click event for the `btnRequest`.

We will be using `CHANGE_MODE_ + participantId` as the topic for PubSub.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
override fun onBindViewHolder(holder: ViewHolder, position: Int) {
  //...

  holder.btnRequest.setOnClickListener { v: View? ->
    val pubSubPublishOptions = PubSubPublishOptions()
    pubSubPublishOptions.isPersist = false
    //highlight-start
    meeting.pubSub.publish(
        "CHANGE_MODE_" + participant!!.id,
        participant.id,
        pubSubPublishOptions
    )
    //highlight-end
  }
}
```

</TabItem>

<TabItem value="Java">

```js
@Override
public void onBindViewHolder(@NonNull ViewHolder holder, int position) {
  //...

  holder.btnRequest.setOnClickListener(v -> {
    PubSubPublishOptions pubSubPublishOptions = new PubSubPublishOptions();
    pubSubPublishOptions.setPersist(false);
    //highloght-next-line
    meeting.pubSub.publish("CHANGE_MODE_"+ participant.getId(), participant.getId(), pubSubPublishOptions);
  });
}
```

</TabItem>

</Tabs>

### Step 3: Showing Viewer Request Dialog

After implementing the Host requesting viewer to join the livestream, let's display the viewer's request dialogue and switch the `SIGNALLING_ONLY` mode to `SEND_AND_RECV`.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
meeting!!.addEventListener(object : MeetingEventListener() {
  override fun onMeetingJoined() {
    val changeModeListener =
      PubSubMessageListener { pubSubMessage: PubSubMessage ->
          if (pubSubMessage.message == meeting!!.localParticipant.id) {
              showRequestDialog(pubSubMessage.senderName)
          }
      }
    //highlight-next-line
    meeting!!.pubSub.subscribe("CHANGE_MODE_" + meeting!!.localParticipant.id, changeModeListener)
  }
})

private fun showRequestDialog(name: String) {
    val builder = AlertDialog.Builder(
        mContext!!
    )
    builder.setMessage("$name has request you to go on stage")
    builder.setTitle("Change mode Request")
    builder.setCancelable(false)
    builder.setPositiveButton("Yes") { dialog: DialogInterface, _: Int ->
        //highlight-next-line
        meeting!!.changeMode("SEND_AND_RECV")
        //...
        dialog.dismiss()
    }
    builder.setNegativeButton(
        "No"
    ) { dialog: DialogInterface, which: Int -> dialog.dismiss() }
    val alertDialog = builder.create()
    alertDialog.show()
}

```

</TabItem>

<TabItem value="Java">

```js
meeting.addEventListener(new MeetingEventListener() {
  @Override
  public void onMeetingJoined() {
    PubSubMessageListener changeModeListener = pubSubMessage -> {
        if (pubSubMessage.getMessage().equals(meeting.getLocalParticipant().getId())) {
            showRequestDialog(pubSubMessage.getSenderName());
        }
    };
    //highlight-next-line
    meeting.pubSub.subscribe("CHANGE_MODE_"+ meeting.getLocalParticipant().getId(), changeModeListener);
  }
}

private void showRequestDialog(String name) {
  AlertDialog.Builder builder = new AlertDialog.Builder(mContext);
  builder.setMessage(name + " has request you to go on stage");
  builder.setTitle("Change mode Request");
  builder.setCancelable(false);

  builder.setPositiveButton("Yes", (dialog, which) -> {
      //highlight-next-line
      meeting.changeMode("SEND_AND_RECV");
      //...
      dialog.dismiss();
  });

  builder.setNegativeButton("No", (dialog, which) -> {
      dialog.dismiss();
  });

  AlertDialog alertDialog = builder.create();
  alertDialog.show();
}
```

</TabItem>

</Tabs>

<center>

<img style={{height: '450px'}} src="https://cdn.videosdk.live/website-resources/docs-resources/android_stage_request_dialog.jpg" />

</center>

### Step 4: Pin the participant

We need to pin the participant so that he/she can appears on the livestream. To achieve this, we will listen to the callback on the `onParticipantModeChanged` of `Meeting` class.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
class ParticipantListAdapter(
    items: ArrayList<Participant?>?,
    private val meeting: Meeting,
    private val context: Context
) : RecyclerView.Adapter<ParticipantListAdapter.ViewHolder>() {
  // ...

 init {
    //...
    meeting.addEventListener(object : MeetingEventListener() {
      override fun onParticipantJoined(participant: Participant) {
          //...
      }

      override fun onParticipantLeft(participant: Participant) {
         // ...
      }

      //highlight-start
      override fun onParticipantModeChanged(data: JSONObject) {
        //...
         val participant = meeting.participants[data.getString("participantId")]
          if (data.getString("mode") == "SEND_AND_RECV") {
              participant!!.pin("SHARE_AND_CAM")
          } else {
              participant!!.unpin("SHARE_AND_CAM")
          }
      }
      //highlight-end
    })
  }

  //...
  class ViewHolder(itemView: View) : RecyclerView.ViewHolder(itemView) {
      //...
  }
}
```

</TabItem>

<TabItem value="Java">

```js
public class ParticipantListAdapter extends RecyclerView.Adapter<ParticipantListAdapter.ViewHolder> {
    // ...

  public ParticipantListAdapter(ArrayList<Participant> items, Meeting meeting, Context context) {
    //...
    meeting.addEventListener(new MeetingEventListener() {
      @Override
      public void onParticipantJoined(Participant participant) {
        //...
      }

      @Override
      public void onParticipantLeft(Participant participant) {
        //...
      }

      //highlight-start
      @Override
      public void onParticipantModeChanged(JSONObject data) {
        //...
        Participant participant = meeting.getParticipants().get(data.getString("participantId"));
        if (data.getString("mode").equals("SEND_AND_RECV"))
        {
          participant.pin("SHARE_AND_CAM");
        }else
        {
          participant.unpin("SHARE_AND_CAM");
        }
      }
      //highlight-end
    });

  }

  //...
  static class ViewHolder extends RecyclerView.ViewHolder {
      //...
  }
}
```

</TabItem>

</Tabs>

import ReactPlayer from 'react-player'

<div style={{textAlign: 'center'}}>

<ReactPlayer muted controls url="https://cdn.videosdk.live/website-resources/docs-resources/android_stage_request_demo.mp4" height="500px" width={"100%"} />

</div>

<br/>

## API Reference

The API references for all the methods utilized in this guide are provided below.

- [Meeting](/android/api/sdk-reference/meeting-class/introduction)
- [pubSub](/android/guide/video-and-audio-calling-api-sdk/collaboration-in-meeting/pubsub)
- [onParticipantModeChanged()](/android/api/sdk-reference/meeting-class/meeting-event-listener-class#onparticipantmodechanged)


---

---
title: Manage On-Screen Participants - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: Interactive Livestream features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Manage On-Screen Participants
pagination_label: Manage On-Screen Participants
keywords:
  - Start HLS meeting
  - Stop HLS meeting
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: manage-on-screen-participants
---

# Manage On-Screen Participants - Android

It is important that only the necessary person are present on the screen when livestream is on. To handle this, we will be using the `pin` and `unpin` methods of the `Participant` class.

:::note
To ensure only the hosts/speakers are shown in the grid, you should use the `SPOTLIGHT` layout and `pin` as the priority when starting the interactive livestream.
:::

Let us first explore two methods that we will be using to manage on-screen participants.

### `pin()`

With these method you can pin any participant's Camera, Screen Share or both. This can be useful to identify the participants based on which you can perform rendering participant grid.

### `unpin()`

With these methods you can unpin any participant's Camera, Screen Share or both. This can be useful to reset pin state of the participant.

import CautionMessage from '@site/src/theme/CautionMessage';


<CautionMessage sdk="Android SDK" version="v0.2.0" />

### Managing On-Screen Participants

1. If you want to pin all the hosts/speakers automatically, you can do it by listenting to the `onMeetingJoined` callback and `onParticipantModeChanged`, where you can `pin` and `unpin` based on the mode.

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
private val meetingEventListener: MeetingEventListener = object : MeetingEventListener() {
  override fun onMeetingJoined() {
        //highlight-start
        val localParticipant = meeting!!.localParticipant
        //We will pin the participant if mode is SEND_AND_RECV
        if (localParticipant.mode == "SEND_AND_RECV") {
            localParticipant.pin()
        } else {
            localParticipant.unpin()
        }
        //highlight-end
   }

  override fun onParticipantModeChanged(data: JSONObject) {
    //highlight-start
    val localParticipant = meeting!!.localParticipant
    //We will pin the participant if mode is SEND_AND_RECV else unpin him
    if(localParticipant.id.equals(data.getString("peerId"))
    {
        if(localParticipant.mode == "SEND_AND_RECV")
        {
            localParticipant.pin()
        }else{
            localParticipant.unpin()
        }
    }
    //highlight-end
  }
}

override fun onCreate(savedInstanceState: Bundle?) {
  //...

  // add listener to meeting
  //highlight-next-line
  meeting!!.addEventListener(meetingEventListener)
}
```

</TabItem>

<TabItem value="Java">

```js
private final MeetingEventListener meetingEventListener = new MeetingEventListener() {
  @Override
  public void onMeetingJoined() {
    //highlight-start
    Participant localParticipant = meeting.getLocalParticipant();
    //We will pin the participant if mode is SEND_AND_RECV
    if (localParticipant.getMode() == "SEND_AND_RECV") {
        localParticipant.pin();
    } else {
        localParticipant.unpin();
    }
    //highlight-end
  }

  @Override
  public void onParticipantModeChanged(JSONObject data) {
    //highlight-start
    Participant localParticipant = meeting.getLocalParticipant();
    //We will pin the participant if mode is SEND_AND_RECV else unpin him
    if(localParticipant.getId().equals(data.getString("peerId"))
    {
        if(localParticipant.getMode() == "SEND_AND_RECV")
        {
            localParticipant.pin();
        }else{
            localParticipant.unpin();
        }
    }
    //highlight-end
  }
};

@Override
protected void onCreate(Bundle savedInstanceState) {
  //...

  // add listener to meeting
  //highlight-next-line
  meeting.addEventListener(meetingEventListener);
}
```

</TabItem>

</Tabs>

2. When rendering the participant grid on the Speaker side, make sure to show only the participants who are in `SEND_AND_RECV` mode. You can filter the participants as shown in below example.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
 private fun getSpeakerList(): List<Participant?>? {
    val speakerList: MutableList<Participant?> = ArrayList()
    val participants = meeting!!.participants
    for (entry: Map.Entry<String, Participant> in participants.entries) {
        val participant = entry.value
        if (participant.mode == "SEND_AND_RECV") {
            speakerList.add(participant)
        }
    }
    return speakerList
}
```

</TabItem>

<TabItem value="Java">

```js
private List<Participant> getSpeakerList() {
    List<Participant> speakerList = new ArrayList();
    Map<String, Participant> participants = meeting.getParticipants();
    for (Map.Entry<String, Participant> entry : participants.entrySet()) {
        Participant participant = entry.getValue();
        if (participant.getMode().equals("SEND_AND_RECV")) {
            speakerList.add(participant);
        }
    }
    return speakerList;
}
```

</TabItem>

</Tabs>

## API Reference

The API references for all the methods utilized in this guide are provided below.

- [pin](/android/api/sdk-reference/participant-class/methods#pin)
- [unpin](/android/api/sdk-reference/participant-class/methods#unpin)


---

---
title: Manage Roles - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: Interactive Livestream features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Manage Roles
pagination_label: Manage Roles
keywords:
  - Start HLS meeting
  - Stop HLS meeting
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: manage-roles
---

# Manage Roles - Android

## Roles with VideoSDK

When doing interactive live streaming maintaining the role of users is quite important. To help manage these roles better, VideoSDK allows a participant with two types of modes:

**`1. SEND_AND_RECV`** When a participant is joining with mode set to `SEND_AND_RECV`, we will be able to **publish and consume the media** of other participants and also interact with them using the features like chat, poll etc.

**`2. SIGNALLING_ONLY`** When a participant is joining with mode set to `SIGNALLING_ONLY`, that participant is **not allowed to publish or consume any media** from other participants. Although they can interact with other participants using chat, polls etc.

import CautionMessage from '@site/src/theme/CautionMessage';


<CautionMessage sdk="Android SDK" version="v0.2.0" />

**_This image is for education purpose_**

![manage-roles](https://cdn.videosdk.live/website-resources/docs-resources/meeting_modes.jpg)

## When to use the Roles?

##### 1. Simple Adaptive Streaming

- Simple Adaptive Streaming (SAS) is a type of livestreaming that requires minimal interaction between the host and viewers.

- It is particularly useful for events with a large number of viewers who prefer not to engage with the host.

- In SAS, each speaker attends a VideoSDK meeting in `SEND_AND_RECV` mode, while viewers can simply watch the livestream using the `playbackHlsUrl` or `livestreamUrl`. Unlike the speakers, viewers do not need to join the meeting in `SEND_AND_RECV` or `SIGNALLING_ONLY` mode. This allows for a seamless streaming experience without any unnecessary interruptions or distractions.
  - `playbackHlsUrl` - Live HLS with playback support
  - `livestreamUrl` - Live HLS without playback support

:::note
`downstreamUrl` is now depecated. Use `playbackHlsUrl` or `livestreamUrl` in place of `downstreamUrl`
:::

**_This video is for education purpose_**

import ReactPlayer from 'react-player'

<div style={{textAlign: 'center'}}>

<ReactPlayer autoplay muted loop playing controls url="https://cdn.videosdk.live/website-resources/docs-resources/react_simple_ils.mp4" height="500px" width={"100%"} />

</div>

##### 2. Adaptive Streaming with increased engagement

- If you're looking to increase engagement with your audience during a live streaming event, consider using Adaptive Streaming technology. With this approach, you can incorporate interactive features such as polls and conversations, and give viewers the ability to join and leave the livestream as the host decides.

- To set this up, have all speakers join as `SEND_AND_RECV` mode participants, while the audience joins as `SIGNALLING_ONLY` mode participants. This way, everyone can participate in the interactive elements of the live stream and create a more dynamic and engaging experience for all.

**_This video is for education purpose_**

<div style={{textAlign: 'center'}}>

<ReactPlayer autoplay muted loop playing controls url="https://cdn.videosdk.live/website-resources/docs-resources/react_livestream_interaction_1.mp4" height="500px" width={"100%"} />

</div>

## Using roles

When you initialize the meeting, you can set the mode of Participant.

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
class MainActivity : AppCompatActivity() {

  fun getToken(): String? {
    //highlight-next-line
    ...
  }

  fun getMeetingId(token: String?): String? {
    //highlight-next-line
    ...
  }

 override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    setContentView(R.layout.activity_main)

    //We will fetch token and meetingId and store it in local variables
    val token: String = getToken()
    val meetingId = getMeetingId(token)

    // initialize the VideoSDK
    VideoSDK.initialize(this@MainActivity)

    // set token property of VideoSDK
    VideoSDK.config(token)

    // highlight-start
    // create a new meeting instance
    val meeting: Meeting = VideoSDK.initMeeting(
        this@MainActivity, meetingId, "NAME HERE",
        true, true, null,
        //highlight-next-line
        "SEND_AND_RECV", // allowed: SEND_AND_RECV | SIGNALLING_ONLY | RECV_ONLY
        false,
        null,
        null
    )
    // highlight-end

    Log.d("VideoSDK", "onCreate: $meetingId")
  }
}
```

</TabItem>

<TabItem value="Java">

```java
public class MainActivity extends AppCompatActivity {

  public String getToken()
  {
    //highlight-next-line
    ...
  }

  public String getMeetingId(String token) {
    //highlight-next-line
    ...
  }

  @Override
  protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);

    //We will fetch token and meetingId and store it in local variables
    String token = getToken();
    String meetingId = getMeetingId(token);

    // initialize the VideoSDK
    VideoSDK.initialize(MainActivity.this);

    // set token property of VideoSDK
    VideoSDK.config(token);

    // highlight-start
    // create a new meeting instance
    Meeting meeting = VideoSDK.initMeeting(
            MainActivity.this, meetingId, "NAME HERE",
            true, true, null,
            //highlight-next-line
            "SEND_AND_RECV", // allowed: SEND_AND_RECV | SIGNALLING_ONLY | RECV_ONLY
            false,
            null,
            null,
    );
    // highlight-end

    Log.d("VideoSDK", "onCreate: " + meetingId);
  }
}
```

</TabItem>

</Tabs>

## Getting Participant Mode

You can identify the participants role by using `mode` property from `Participant` class.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
override fun onCreate(savedInstanceState: Bundle?) {
  //...

  val localParticipant = meeting!!.localParticipant
  //highlight-next-line
  Log.d("VideoSDK", "Participant mode : " + localParticipant.mode)
}
```

</TabItem>

<TabItem value="Java">

```js
@Override
protected void onCreate(Bundle savedInstanceState) {
  //...

  Participant localParticipant = meeting.getLocalParticipant();
  //highlight-next-line
  Log.d("VideoSDK", "Participant mode : " + participant.getMode());
}
```

</TabItem>

</Tabs>

## Changing Participant's Mode

Let's say you are hosting a livestream and you want one of your viewer to join the livestream with you. In this case you can change the mode of the participant using the `changeMode()` of the `Meeting` class.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
findViewById<View>(R.id.btnConferenceMode).setOnClickListener { view: View? ->
    // change mode to SEND_AND_RECV
    //highlight-next-line
    meeting!!.changeMode("SEND_AND_RECV")
}

findViewById<View>(R.id.btnViewerMode).setOnClickListener { view: View? ->
    // change mode to SIGNALLING_ONLY
    //highlight-next-line
    meeting!!.changeMode("SIGNALLING_ONLY")
}
```

</TabItem>

<TabItem value="Java">

```js
findViewById(R.id.btnConferenceMode).setOnClickListener(view -> {
    // change mode to SEND_AND_RECV
    //highlight-next-line
    meeting.changeMode("SEND_AND_RECV");
});

findViewById(R.id.btnViewerMode).setOnClickListener(view -> {
    // change mode to SIGNALLING_ONLY
    //highlight-next-line
   meeting.changeMode("SIGNALLING_ONLY");
});
```

</TabItem>

</Tabs>

## API Reference

The API references for all the methods utilized in this guide are provided below.

- [Meeting](/android/api/sdk-reference/meeting-class/introduction)
- [Participant](/android/api/sdk-reference/participant-class/introduction)
- [changeMode()](/android/api/sdk-reference/meeting-class/methods#changemode)


---

---
title: Interactive Livestream - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: Interactive Livestream features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Overview
pagination_label: Overview
keywords:
  - Start HLS meeting
  - Stop HLS meeting
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: overview
---

# Interactive Livestream (HLS) - Android

### What is Interactive Livestream (HLS)?

Interactive live streaming (HLS) refers to a type of live streaming where viewers can actively engage with the content being streamed and with other viewers in real-time.

In an interactive live stream (HLS), viewers can take part in a variety of activities like live polling, Q&A sessions, and even sending virtual gifts to the content creator or each other.

### What is Adaptive Live Streaming?

Livestream experience is important while undertaking interactive live streaming in order to increase audience. To do this, the livestream should be able to respond to the viewer's network bandwidth, and change the stream's resolution as necessary. Therefore, adaptive live streaming refers to a feed that automatically adjusts to a lower or higher resolution dependent on the user's preferences.

### What is Latency?

Latency is the delay between capturing video content and its playback. Key factors that affecting latency :

- **Buffering**: Balance buffer size for smoother playback against latency.
- **Network Conditions**: Efficient servers and network health contribute to lower latency.

Standard HLS has a latency around 5-6 seconds.

### HLS Architecture of VideoSDK

<center>

<img src='https://cdn.videosdk.live/website-resources/docs-resources/mobile_hls.png' />

</center>

When a host starts the interactive live stream, VideoSDK will use a default theme or user specified template to compose and encode a live stream which will be delivered to the viewers through a `M3U8` video file which can be played directly on the viewer end which will adapt to the viewer's network bandwidth.

When using VideoSDK for interactive live stream, you get multiple types of URLs which you can use based on your requirements.

**`1. Standard Streaming:`** This type of streaming is where the user is not allowed to go back in the live and can just stream it.

**`2. Rolling Playback:`** This type of streaming is where the user is allowed to do rewind and do a playback of the complete stream.

**`3. VoD Playback`** With this, users can playback the complete live stream on demand whenever needed.

### Using HLS with VideoSDK

You can use HLS with VideoSDK in two different ways.

#### 1. Simple Adaptive Streaming

When we talk about simple adaptive streaming, we imply that there is hardly any interaction between the hosts and the viewers.

These livestreams are helpful when there are a lot of viewers, and they don't want to engage with the host. In this scenario, every presenter attends a VideoSDK meeting, while every viewer only watches the livestream.

**_This video is for education purpose_**

import ReactPlayer from 'react-player'

<div style={{textAlign: 'center'}}>

<ReactPlayer autoplay muted loop playing controls url="https://cdn.videosdk.live/website-resources/docs-resources/react_simple_ils.mp4" height="500px" width={"100%"} />

</div>

#### 2. Adaptive Streaming with increased engagement

When you want to communicate with your audience by enabling polls, conversations, and the ability for viewers to join and leave the livestream based on the host's decision, adaptive streaming with enhanced engagement will be the best fit for you.

In this scenario, both the host and the viewer will have to join a VideoSDK meeting with different roles. To learn more about the roles [follow these guide.](../handling-participants/manage-roles)

**_This video is for education purpose_**

<div style={{textAlign: 'center'}}>

<ReactPlayer autoplay muted loop playing controls url="https://cdn.videosdk.live/website-resources/docs-resources/react_livestream_interaction_2.mp4" height="500px" width={"100%"} />

</div>


---

---
title: Setup HLS Player | Video SDK
hide_title: true
hide_table_of_contents: false
description: Using VideoSDK to do the interactive livestreaming.
sidebar_label: Setup HLS Player
pagination_label: Setup HLS Player
keywords:
  - audio calling
  - video calling
  - real-time communication
  - interactive live streaming
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: setup-hls-player
---

# Setup HLS Player - Android

In this guide, we will add player which will be responsible for playing the HLS stream.
Before starting this guide, make sure you have a VideoSDK meetings setup allowing you to join the room. To learn more about setting up a VideoSDK meeting, follow this [quick start guide](/android/guide/video-and-audio-calling-api-sdk/quick-start).

To play the HLS stream we will be using the [Exoplayer](https://github.com/google/ExoPlayer) library.

### `1. Setup player into your project`

**`Step 1:`** Let's first add ExoPlayer module dependency into the project.

```js title="app/build.gradle"
dependencies {
  implementation 'com.google.android.exoplayer:exoplayer:2.18.5'
  // other app dependencies
  }
```

**`Step 2:`** Now let's add the `StyledPlayerView` which will display livestreaming. And also add the `TextView` which will be shown when there is no active HLS. For these, we will use the `onHlsStateChanged` event from the `MeetingEventListener` abstract class to identify if there is an active HLS.

```xml title="activity_viewer.xml"
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent">

    <TextView
        android:id="@+id/waitingLayout"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:text="Waiting for host \n to start the live streaming"
        android:textFontWeight="700"
        android:textSize="20sp"
        android:gravity="center"/>

    <com.google.android.exoplayer2.ui.StyledPlayerView
        android:id="@+id/player_view"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:visibility="gone"
        app:resize_mode="fixed_width"
        app:show_buffering="when_playing"
        app:show_subtitle_button="false"
        app:use_artwork="false"
        app:show_next_button="false"
        app:show_previous_button="false"
        app:use_controller="true"/>

</LinearLayout>
```

### `2. Initialize player and Playing HLS stream`

**`Step 1:`** Now that player is setup, let's initialize player and play the HLS once it becomes playable. For these, we will get the `playbackHlsUrl` and `livestreamUrl` when the `onHlsStateChanged` event of `MeetingEventListener` state changes to `HLS_PLAYABLE`.

- when you receive `HLS_PLAYABLE` status you will receive 2 urls
  - `playbackHlsUrl` - Live HLS with playback support
  - `livestreamUrl` - Live HLS without playback support

:::note
`downstreamUrl` is now depecated. Use `playbackHlsUrl` or `livestreamUrl` in place of `downstreamUrl`
:::

**`Step 2:`** We also need to release player and show `TextView` which shows there is no active HLS. We will release player when the `onHlsStateChanged` event of `MeetingEventListener` state changes to `HLS_STOPPED`.

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js title="ViewerActivity.kt"
class ViewerActivity : AppCompatActivity() {
    private val meeting: Meeting? = null
    private var playerView: StyledPlayerView? = null
    private var waitingLayout: TextView? = null
    private var player: ExoPlayer? = null
    private var dataSourceFactory: DefaultHttpDataSource.Factory? = null
    private val startAutoPlay = true
    private var playbackHlsUrl: String? = ""


    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_meeting)
        playerView = findViewById(R.id.player_view)
        waitingLayout = findViewById(R.id.waitingLayout)

        // setup meeting
        //...

        //highlight-next-line
        // add listener to the meeting
        meeting!!.addEventListener(meetingEventListener)
    }

    private val meetingEventListener: MeetingEventListener = object : MeetingEventListener() {
        override fun onMeetingJoined() {
            Log.d("VideoSDK", "onMeetingJoined: ")
        }

        override fun onMeetingLeft() {
            Log.d("VideoSDK", "onMeetingLeft: ")
        }

        //highlight-start
        @RequiresApi(api = Build.VERSION_CODES.P)
        override fun onHlsStateChanged(HlsState: JSONObject) {
            if (HlsState.has("status")) {
                try {
                    if (HlsState.getString("status") == "HLS_PLAYABLE" && HlsState.has("playbackHlsUrl")) {
                        playbackHlsUrl = HlsState.getString("playbackHlsUrl")
                        waitingLayout!!.visibility = View.GONE
                        playerView!!.visibility = View.VISIBLE
                        // initialize player
                        initializePlayer()
                    }
                    if (HlsState.getString("status") == "HLS_STOPPED") {
                        // release the player
                        releasePlayer()
                        playbackHlsUrl = null
                        waitingLayout!!.text = "Host has stopped \n the live streaming"
                        waitingLayout!!.visibility = View.VISIBLE
                        playerView!!.visibility = View.GONE
                    }
                } catch (e: JSONException) {
                    e.printStackTrace()
                }
            }
            //highlight-end
        }
    }

    private fun initializePlayer() {
        if (player == null) {
            dataSourceFactory = DefaultHttpDataSource.Factory()
            val mediaSource = HlsMediaSource.Factory(dataSourceFactory!!).createMediaSource(
                MediaItem.fromUri(Uri.parse(playbackHlsUrl))
            )
            val playerBuilder = ExoPlayer.Builder( /* context= */this@ViewerActivity)
            player = playerBuilder.build()
            // auto play when player is ready
            player!!.playWhenReady = startAutoPlay
            player!!.setMediaSource(mediaSource)
            // if you want display setting for player then remove this line
            playerView!!.findViewById<View>(com.google.android.exoplayer2.ui.R.id.exo_settings).visibility =
                View.GONE
            playerView!!.player = player
        }
        player!!.prepare()
    }

    private fun releasePlayer() {
        if (player != null) {
            player!!.release()
            player = null
            dataSourceFactory = null
            playerView!!.player = null
        }
    }
}
```

</TabItem>

<TabItem value="Java">

```java title="ViewerFragment.java"
public class ViewerActivity extends AppCompatActivity {
    private Meeting meeting;
    protected StyledPlayerView playerView;
    private TextView waitingLayout;
    protected @Nullable
    ExoPlayer player;

    private DefaultHttpDataSource.Factory dataSourceFactory;
    private boolean startAutoPlay = true;
    private String playbackHlsUrl = "";

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_meeting);
        playerView = findViewById(R.id.player_view);
        waitingLayout = findViewById(R.id.waitingLayout);

        // setup meeting
        //...

        //highlight-next-line
        // add listener to the meeting
        meeting.addEventListener(meetingEventListener);
    }

    private final MeetingEventListener meetingEventListener = new MeetingEventListener() {
        @Override
        public void onMeetingJoined() {
            Log.d("VideoSDK", "onMeetingJoined: ");
        }

        @Override
        public void onMeetingLeft() {
            Log.d("VideoSDK", "onMeetingLeft: ");
        }

        //highlight-start
        @RequiresApi(api = Build.VERSION_CODES.P)
        @Override
        public void onHlsStateChanged(JSONObject HlsState) {
            if (HlsState.has("status")) {
                try {
                    if (HlsState.getString("status").equals("HLS_PLAYABLE") && HlsState.has("playbackHlsUrl")) {
                        playbackHlsUrl = HlsState.getString("playbackHlsUrl");
                        waitingLayout.setVisibility(View.GONE);
                        playerView.setVisibility(View.VISIBLE);
                        // initialize player
                        initializePlayer();
                    }
                    if (HlsState.getString("status").equals("HLS_STOPPED")) {
                        // release the player
                        releasePlayer();
                        playbackHlsUrl = null;
                        waitingLayout.setText("Host has stopped \n the live streaming");
                        waitingLayout.setVisibility(View.VISIBLE);
                        playerView.setVisibility(View.GONE);
                    }
                } catch (JSONException e) {
                    e.printStackTrace();
                }
            }
            //highlight-end
        }
    };

    protected void initializePlayer() {
        if (player == null) {
            dataSourceFactory = new DefaultHttpDataSource.Factory();
            HlsMediaSource mediaSource = new HlsMediaSource.Factory(dataSourceFactory).createMediaSource(
                    MediaItem.fromUri(Uri.parse(this.playbackHlsUrl)));

            ExoPlayer.Builder playerBuilder =
                    new ExoPlayer.Builder(/* context= */ ViewerActivity.this);
            player = playerBuilder.build();
            // auto play when player is ready
            player.setPlayWhenReady(startAutoPlay);
            player.setMediaSource(mediaSource);
            // if you want display setting for player then remove this line
            playerView.findViewById(com.google.android.exoplayer2.ui.R.id.exo_settings).setVisibility(View.GONE);
            playerView.setPlayer(player);
        }
        player.prepare();
    }

    protected void releasePlayer() {
        if (player != null) {
            player.release();
            player = null;
            dataSourceFactory = null;
            playerView.setPlayer(/* player= */ null);
        }
    }
}
```

</TabItem>

</Tabs>

With this, the player is setup to play the HLS.

<center>

<img style={{height: '450px',marginRight:'15px'}} src="https://cdn.videosdk.live/website-resources/docs-resources/android_ils_quickstart_viewer_screen_waiting.jpg" />

<img style={{height: '450px'}} src="https://cdn.videosdk.live/website-resources/docs-resources/android_ils_quickstart_viewer_screen.jpg" />

</center>

## API Reference

The API references for all the methods utilized in this guide are provided below.

- [onHlsStateChanged](/android/api/sdk-reference/meeting-class/meeting-event-listener-class#onhlsstatechanged)


---

---
title: Start HLS | Video SDK
hide_title: true
hide_table_of_contents: false
description: Using VideoSDK to do the interactive livestreaming.
sidebar_label: Start HLS
pagination_label: Start HLS
keywords:
  - audio calling
  - video calling
  - real-time communication
  - interactive live streaming
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: start-hls
---

# Start HLS - Android

Before starting the HLS, the prequisite steps require you to have a VideoSDK Meeting running which you want to use for interactive livestream. To learn more about setting up a interactive live streaming, you can follow the steps [here in the quick start guide.](/android/guide/video-and-audio-calling-api-sdk/quick-start-ILS)

## Starting HLS

Once the user has joined the meeting, `startHls()` can be used to start a interactive livestream of the meeting which can be accessed from the `Meeting` class. This method accepts one parameter:

- `config`: This parameter will define how the interactive livestream layout should look like.

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
val config = JSONObject()

//highlight-next-line
// Layout Configuration
val layout = JSONObject()
JsonUtils.jsonPut(layout, "type", "GRID") // "SPOTLIGHT" | "SIDEBAR",  Default : "GRID"
JsonUtils.jsonPut(layout, "priority", "SPEAKER") // "PIN", Default : "SPEAKER"
JsonUtils.jsonPut(layout, "gridSize", 4) // MAX : 25
JsonUtils.jsonPut(config, "layout", layout)

//highlight-next-line
// Theme of interactive livestream layout
JsonUtils.jsonPut(config, "theme", "DARK") //  "LIGHT" | "DEFAULT"

//highlight-next-line
// `mode` is used to either interactive livestream video & audio both or only audio.
JsonUtils.jsonPut(config, "mode", "video-and-audio") // "audio", Default : "video-and-audio"

//highlight-next-line
// Quality of interactive livestream and is only applicable to `video-and-audio` type mode.
JsonUtils.jsonPut(config, "quality", "high") // "low" | "med",  Default : "med"

//highlight-start
// This mode refers to orientation of interactive livestream.
// landscape : Start interactive livestream of the meeting in horizontally
// portrait : Start interactive livestream of the meeting in vertically (Best for mobile view)
//highlight-end
JsonUtils.jsonPut(config, "orientation", "portrait") // "landscape",  Default : "landscape"

meeting!!.startHls(config)
```

</TabItem>

<TabItem value="Java">

```js
JSONObject config = new JSONObject();

//highlight-next-line
// Layout Configuration
JSONObject layout = new JSONObject();
JsonUtils.jsonPut(layout, "type", "GRID"); // "SPOTLIGHT" | "SIDEBAR",  Default : "GRID"
JsonUtils.jsonPut(layout, "priority", "SPEAKER");  // "PIN", Default : "SPEAKER"
JsonUtils.jsonPut(layout, "gridSize", 4); // MAX : 25
JsonUtils.jsonPut(config, "layout", layout);

//highlight-next-line
// Theme of interactive livestream layout
JsonUtils.jsonPut(config, "theme", "DARK"); //  "LIGHT" | "DEFAULT"

//highlight-next-line
// `mode` is used to either interactive livestream video & audio both or only audio.
JsonUtils.jsonPut(config, "mode", "video-and-audio"); // "audio", Default : "video-and-audio"

//highlight-next-line
// Quality of interactive livestream and is only applicable to `video-and-audio` type mode.
JsonUtils.jsonPut(config, "quality", "high"); // "low" | "med",  Default : "med"

//highlight-start
// This mode refers to orientation of interactive livestream.
// landscape : Start interactive livestream of the meeting in horizontally
// portrait : Start interactive livestream of the meeting in vertically (Best for mobile view)
//highlight-end
JsonUtils.jsonPut(config, "orientation", "portrait"); // "landscape",  Default : "landscape"

meeting.startHls(config);
```

</TabItem>

</Tabs>

:::note
If you want only the SEND_AND_RECV participants to be seen in the livestream, you can `pin` all the participants in the SEND_AND_RECV mode and start the livestream with the `SPOTLIGHT` layout and `pin` as the `PRIORITY`.

Deprecated: Use SEND_AND_RECV instead of CONFERENCE
:::

### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
// keep track of hls
findViewById<View>(R.id.btnStartHls).setOnClickListener { view: View? ->
    //highlight-start
    val config = JSONObject()
    val layout = JSONObject()
    JsonUtils.jsonPut(layout, "type", "SPOTLIGHT")
    JsonUtils.jsonPut(layout, "priority", "PRIORITY")
    JsonUtils.jsonPut(layout, "gridSize", 4)
    JsonUtils.jsonPut(config, "layout", layout)
    JsonUtils.jsonPut(config, "theme", "DARK")
    JsonUtils.jsonPut(config, "mode", "video-and-audio")
    JsonUtils.jsonPut(config, "quality", "high")
    JsonUtils.jsonPut(config, "orientation", "portrait")
    //highlight-end

    // Start Hls
    //highlight-next-line
    meeting!!.startHls(config)
}
```

</TabItem>

<TabItem value="Java">

```js
findViewById(R.id.btnStartHls).setOnClickListener(view -> {
    //highlight-start
    JSONObject config = new JSONObject();
    JSONObject layout = new JSONObject();
    JsonUtils.jsonPut(layout, "type", "SPOTLIGHT");
    JsonUtils.jsonPut(layout, "priority", "PRIORITY");
    JsonUtils.jsonPut(layout, "gridSize", 4);
    JsonUtils.jsonPut(config, "layout", layout);
    JsonUtils.jsonPut(config, "theme", "DARK");
    JsonUtils.jsonPut(config, "mode", "video-and-audio");
    JsonUtils.jsonPut(config, "quality", "high");
    JsonUtils.jsonPut(config, "orientation", "portrait");
    //highlight-end

    // Start Hls
    //highlight-next-line
    meeting.startHls(config);
});
```

</TabItem>

</Tabs>

## Understanding Layouts

##### 1. GRID Layout

This layout is default layout if no participants are pinned, it will look same as a normal meeting grid layout, when any participant is pinned that participant will be moved on top of the main screen grid above all non pinned participants

While screenshare as well the main view will contain only screenshare media but the side panel view of participant grid will maintain same order of pinned and unpinned participants.

|                       Grid                        |                     Grid with Screenshare                     |
| :-----------------------------------------------: | :-----------------------------------------------------------: |
| ![prebuilt-grid](/img/prebuilt/prebuilt-grid.png) | ![prebuilt-grid-share](/img/prebuilt/prebuilt-grid-share.png) |

##### 2. SIDEBAR Layout

This layout will have one main screen view and other sidebar grid layout. Only pinned participant will be visible in this layout, all unpinned participants will not be visible in this layout. If more than one participant is pinned then the first participant who was pinned will appear in main screen layout and all other remaining pinned particiapants will be visible in sidebar.

If any pinned participant started screenshare then the screenshare media will be visible in main screen layout and all other pinned participants webcam view will be visible in sidebar

|                         Sidebar                         |                      Sidebar with Screenshare                       |
| :-----------------------------------------------------: | :-----------------------------------------------------------------: |
| ![prebuilt-sidebar](/img/prebuilt/prebuilt-sidebar.png) | ![prebuilt-sidebar-share](/img/prebuilt/prebuilt-sidebar-share.png) |

##### 3. SPOTLIGHT Layout

This layout will only contain main screen layout, multiple pinned participants will be visible in main screen view. Same as `SIDEBAR` layout only pinned participants will be visible in main screen.

If any pinned participant started screenshare then only screenshare view will be visible in main screen, no webcam view will be visible when any pinned participant started screenshare.

|                          Spotlight                          |                       Spotlight with Screenshare                        |
| :---------------------------------------------------------: | :---------------------------------------------------------------------: |
| ![prebuilt-spotlight](/img/prebuilt/prebuilt-spotlight.png) | ![prebuilt-spotlight-share](/img/prebuilt/prebuilt-spotlight-share.png) |

## Event associated with HLS

- **onHlsStateChanged** - Whenever meeting HLS state changes, then `onHlsStateChanged` event will trigger.

- You can get the `livestreamUrl` and `playbackHlsUrl` of the HLS to play it on the Viewer side when the state changes to `HLS_PLAYABLE`.
  - `playbackHlsUrl` - Live HLS with playback support
  - `livestreamUrl` - Live HLS without playback support

:::note
`downstreamUrl` is now depecated. Use `playbackHlsUrl` or `livestreamUrl` in place of `downstreamUrl`
:::

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
private val meetingEventListener: MeetingEventListener = object : MeetingEventListener() {
  override fun onHlsStateChanged(HlsState: JSONObject) {
    when (HlsState.getString("status")) {
        "HLS_STARTING" -> Log.d("onHlsStateChanged", "Meeting hls is starting")
        "HLS_STARTED" -> Log.d("onHlsStateChanged", "Meeting hls is started")
        "HLS_PLAYABLE" -> {
            Log.d("onHlsStateChanged", "Meeting hls is playable now")
            //highlight-start
            // on hls playable you will receive playbackHlsUrl and livestreamUrl
            val playbackHlsUrl = HlsState.getString("playbackHlsUrl")
            val livestreamUrl = HlsState.getString("livestreamUrl")
            //highlight-end
        }
        "HLS_STOPPING" -> Log.d("onHlsStateChanged", "Meeting hls is stopping")
        "HLS_STOPPED" -> Log.d("onHlsStateChanged", "Meeting hls is stopped")
    }
  }
}

override fun onCreate(savedInstanceState: Bundle?) {
  //...

  // add listener to meeting
  //highlight-next-line
  meeting!!.addEventListener(meetingEventListener)
}
```

</TabItem>

<TabItem value="Java">

```js
private final MeetingEventListener meetingEventListener = new MeetingEventListener() {
  @Override
  public void onHlsStateChanged(JSONObject HlsState) {
      switch (HlsState.getString("status")) {
          case "HLS_STARTING":
              Log.d("onHlsStateChanged", "Meeting hls is starting");
              break;
          case "HLS_STARTED":
              Log.d("onHlsStateChanged", "Meeting hls is started");
              break;
          case "HLS_PLAYABLE":
              Log.d("onHlsStateChanged", "Meeting hls is playable now");
              //highlight-start
              // on hls started you will receive playbackHlsUrl and livestreamUrl
              String playbackHlsUrl = HlsState.getString("playbackHlsUrl");
              String livestreamUrl = HlsState.getString("livestreamUrl");
              //highlight-end
              break;
          case "HLS_STOPPING":
              Log.d("onHlsStateChanged", "Meeting hls is stopping");
              break;
          case "HLS_STOPPED":
              Log.d("onHlsStateChanged", "Meeting hls is stopped");
              break;
      }
  }
}

@Override
protected void onCreate(Bundle savedInstanceState) {
  //...

  // add listener to meeting
  //highlight-next-line
  meeting.addEventListener(meetingEventListener);
}
```

</TabItem>

</Tabs>

## Custom Template

With VideoSDK, you can also use your own custom designed layout template to livestream the meetings. In order to use the custom template, you need to create a template for which you can [follow this guide](/react/guide/interactive-live-streaming/custom-template). Once you have setup the template, you can use the [REST API to start](/api-reference/realtime-communication/start-livestream) the livestream with the `templateURL` parameter.

## API Reference

The API references for all the methods utilized in this guide are provided below.

- [startHls()](/android/api/sdk-reference/meeting-class/methods#starthls)
- [stopHls()](/android/api/sdk-reference/meeting-class/methods#stophls)
- [onHlsStateChanged](/android/api/sdk-reference/meeting-class/meeting-event-listener-class#onhlsstatechanged)


---

---
title: Stop HLS | Video SDK
hide_title: true
hide_table_of_contents: false
description: Using VideoSDK to do the interactive livestreaming.
sidebar_label: Stop HLS
pagination_label: Stop HLS
keywords:
  - audio calling
  - video calling
  - real-time communication
  - interactive live streaming
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: stop-hls
---

# Stop HLS - Android

This could refer to stopping the transmission of an ongoing HLS stream, which would mean the stream is no longer available to viewers.

## Stopping HLS

- `stopHls()` is used to stop interactive livestream of the meeting which can be accessed from the `Meeting` class.

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
findViewById<View>(R.id.btnStopHls).setOnClickListener { view: View? ->
    // Stop Hls
    //highlight-next-line
    meeting!!.stopHls()
}
```

</TabItem>

<TabItem value="Java">

```js
findViewById(R.id.btnStopHls).setOnClickListener(view -> {
    // Stop Hls
    //highlight-next-line
    meeting.stopHls();
});
```

</TabItem>

</Tabs>

## Event associated with HLS

- **onHlsStateChanged** - Whenever meeting HLS state changes, then `onHlsStateChanged` event will trigger.

- You will get `HLS_STOPPING` and `HLS_STOPPED` status on calling `stopHls()`.

:::note
`downstreamUrl` is now depecated. Use `playbackHlsUrl` or `livestreamUrl` in place of `downstreamUrl`
:::

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
private val meetingEventListener: MeetingEventListener = object : MeetingEventListener() {
  override fun onHlsStateChanged(HlsState: JSONObject) {
    when (HlsState.getString("status")) {
        "HLS_STARTING" -> Log.d("onHlsStateChanged", "Meeting hls is starting")
        "HLS_STARTED" -> Log.d("onHlsStateChanged", "Meeting hls is started")
        "HLS_PLAYABLE" -> {
            Log.d("onHlsStateChanged", "Meeting hls is playable now")
             // on hls playable you will receive playbackHlsUrl and livestreamUrl
            val playbackHlsUrl = HlsState.getString("playbackHlsUrl")
            val livestreamUrl = HlsState.getString("livestreamUrl")
        }
            //highlight-start
        "HLS_STOPPING" -> Log.d("onHlsStateChanged", "Meeting hls is stopping")
        "HLS_STOPPED" -> Log.d("onHlsStateChanged", "Meeting hls is stopped")
            //highlight-end

    }
  }
}

override fun onCreate(savedInstanceState: Bundle?) {
  //...

  // add listener to meeting
  //highlight-next-line
  meeting!!.addEventListener(meetingEventListener)
}
```

</TabItem>

<TabItem value="Java">

```js
private final MeetingEventListener meetingEventListener = new MeetingEventListener() {
  @Override
  public void onHlsStateChanged(JSONObject HlsState) {
      switch (HlsState.getString("status")) {
          case "HLS_STARTING":
              Log.d("onHlsStateChanged", "Meeting hls is starting");
              break;
          case "HLS_STARTED":
              Log.d("onHlsStateChanged", "Meeting hls is started");
              break;
          case "HLS_PLAYABLE":
              Log.d("onHlsStateChanged", "Meeting hls is playable now");
              // on hls started you will receive playbackHlsUrl and livestreamUrl
              String playbackHlsUrl = HlsState.getString("playbackHlsUrl");
              String livestreamUrl = HlsState.getString("livestreamUrl");
              break;
              //highlight-start
          case "HLS_STOPPING":
              Log.d("onHlsStateChanged", "Meeting hls is stopping");
              break;
          case "HLS_STOPPED":
              Log.d("onHlsStateChanged", "Meeting hls is stopped");
              break;
              //highlight-end

      }
  }
}

@Override
protected void onCreate(Bundle savedInstanceState) {
  //...

  // add listener to meeting
  //highlight-next-line
  meeting.addEventListener(meetingEventListener);
}
```

</TabItem>

</Tabs>

## API Reference

The API references for all the methods utilized in this guide are provided below.

- [startHls()](/android/api/sdk-reference/meeting-class/methods#starthls)
- [stopHls()](/android/api/sdk-reference/meeting-class/methods#stophls)
- [onHlsStateChanged](/android/api/sdk-reference/meeting-class/meeting-event-listener-class#onhlsstatechanged)


---

---
title: Chat messages with PubSub - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: PubSub features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Chat using PubSub
pagination_label: Chat using PubSub
keywords:
  - Chat in meeting
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: chat-using-pubsub
---

# Chat using PubSub - Android

For the communication or any kind of messaging in between the participants, VideoSDK provides `pubSub` class which use Publish-Subscribe mechanism and can be used to develope wide varitey of functionalities. For example, participants could use it to send chat messages to each other, share files or other media, or even trigger actions like muting or unmuting audio or video.

Now we will see, how we can use PubSub to implement Chat functionality. If you are not familiar with the PubSub mechanism and `pubSub` class, you can [follow this guide](/android/guide/video-and-audio-calling-api-sdk/collaboration-in-meeting/pubsub).

## Implementing Chat

### `Group Chat`

1. First step in creating a group chat is choosing the topic which all the participants will publish and subscribe to send and receive the messages. We will be using `CHAT` as the topic for this one.
2. On the send button, publish the message that the sender typed in the `EditText` field.

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle
import android.view.View
import android.widget.EditText
import android.widget.Toast
import androidx.appcompat.widget.Toolbar
import live.videosdk.rtc.android.Meeting
import live.videosdk.rtc.android.listeners.PubSubMessageListener
import live.videosdk.rtc.android.model.PubSubPublishOptions

class ChatActivity : AppCompatActivity() {
  // Meeting
  var meeting: Meeting? = null

  override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    setContentView(R.layout.activity_chat)

    /**
     * Here, we have created 'MainApplication' class, which extends android.app.Application class.
     * It has Meeting property and getter and setter methods of Meeting property.
     * In your android manifest, you must declare the class implementing android.app.Application
     * (add the android:name=".MainApplication" attribute to the existing application tag):
     * In MainActivity.kt, we have set Meeting property.
     *
     * For Example: (MainActivity.kt)
     * var meeting = VideoSDK.initMeeting(context, meetingId, ParticipantName, micEnabled, webcamEnabled, paricipantId, mode, multiStream, customTrack, metaData, signalingBaseUrl)
     * (this.application as MainApplication).meeting = meeting
    */

    // Get Meeting
    meeting = (this.application as MainApplication).meeting

    findViewById(R.id.btnSend).setOnClickListener(view -> sendMessage());
  }

  private fun sendMessage() {
    // get message from EditText
    val message: String = etmessage.getText().toString()
    if (!TextUtils.isEmpty(message)) {
        val publishOptions = PubSubPublishOptions()
        publishOptions.setPersist(true)

        // Sending the Message using the publish method
        //highlight-next-line
        meeting!!.pubSub.publish("CHAT", message, publishOptions)

        // Clearing the message input
        etmessage.setText("")
    } else {
        Toast.makeText(
            this@ChatActivity, "Please Enter Message",
            Toast.LENGTH_SHORT
        ).show()
    }
  }
}
```

</TabItem>

<TabItem value="Java">

```js
import androidx.appcompat.app.AppCompatActivity;
import android.os.Bundle;
import java.util.List;
import live.videosdk.rtc.android.Meeting;
import live.videosdk.rtc.android.lib.PubSubMessage;
import live.videosdk.rtc.android.listeners.PubSubMessageListener;
import live.videosdk.rtc.android.model.PubSubPublishOptions;

public class ChatActivity extends AppCompatActivity {
  // Meeting
  Meeting meeting;

  @Override
  protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_chat);

    /**
     * Here, we have created 'MainApplication' class, which extends android.app.Application class.
     * It has Meeting property and getter and setter methods of Meeting property.
     * In your android manifest, you must declare the class implementing android.app.Application
     * (add the android:name=".MainApplication" attribute to the existing application tag):
     * In MainActivity.java, we have set Meeting property.
     *
     * For Example: (MainActivity.java)
     * Meeting meeting = VideoSDK.initMeeting(context, meetingId, ParticipantName, micEnabled, webcamEnabled, participantId, mode, mutliStream, customTrack,metaData, signalingBaseUrl, preferredProtocol);
     * ((MainApplication) this.getApplication()).setMeeting(meeting);
    */

    // Get Meeting
    meeting = ((MainApplication) this.getApplication()).getMeeting();

    findViewById(R.id.btnSend).setOnClickListener(view -> sendMessage());
  }

  private void sendMessage()
  {
    // get message from EditText
    String message = etmessage.getText().toString();
    if (!message.equals("")) {
        PubSubPublishOptions publishOptions = new PubSubPublishOptions();
        publishOptions.setPersist(true);

        // Sending the Message using the publish method
        //highlight-next-line
        meeting.pubSub.publish("CHAT", message, publishOptions);

        // Clearing the message input
        etmessage.setText("");
    } else {
        Toast.makeText(ChatActivity.this, "Please Enter Message",
                Toast.LENGTH_SHORT).show();
    }
  }
}
```

</TabItem>

</Tabs>

3. Next step would be to display the messages others send. For this we have to `subscribe` to that topic i.e `CHAT` and display all the messages.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
class ChatActivity : AppCompatActivity() {

  // PubSubMessageListener
  //highlight-start
  var pubSubMessageListener =
    PubSubMessageListener { message ->
      // New message
      Toast.makeText(
            this@ChatActivity, message.senderName + " says : " + message.message,
            Toast.LENGTH_SHORT
        ).show()
  }
  //highlight-end

  override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    setContentView(R.layout.activity_chat)

    //...

    // Subscribe for 'CHAT' topic
    //highlight-next-line
    val pubSubMessageList = meeting!!.pubSub.subscribe("CHAT", pubSubMessageListener)

    for (message in pubSubMessageList) {
      // Persisted messages
      Toast.makeText(
            this@ChatActivity, message.senderName + " says : " + message.message,
            Toast.LENGTH_SHORT
        ).show()
    }
  }
}
```

</TabItem>

<TabItem value="Java">

```js
public class ChatActivity extends AppCompatActivity {

  // PubSubMessageListener
  //highlight-start
  private PubSubMessageListener pubSubMessageListener = new PubSubMessageListener() {
    @Override
    public void onMessageReceived(PubSubMessage message) {
        // New message
        Toast.makeText(
          ChatActivity.this, message.senderName + " says : "+ message.getMessag(),
          Toast.LENGTH_SHORT
        ).show();
    }
  };
  //highlight-end

  @Override
  protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_chat);

    //..

    // Subscribe for 'CHAT' topic
    //highlight-next-line
    List<PubSubMessage> pubSubMessageList = meeting.pubSub.subscribe("CHAT", pubSubMessageListener);

    for(PubSubMessage message : pubSubMessageList){
        // Persisted messages
        Toast.makeText(
          ChatActivity.this, message.senderName + " says : "+ message.getMessag(),
          Toast.LENGTH_SHORT
        ).show();
    }
  }
}
```

</TabItem>

</Tabs>

4. Final step in the group chat would be `unsubscribe` to that topic, which you had previously subscribed but no longer needed. Here we are `unsubscribe` to `CHAT` topic on activity destroy.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
class ChatActivity : AppCompatActivity() {
  override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    setContentView(R.layout.activity_chat)

    //...
  }

  override fun onDestroy() {
    // Unsubscribe for 'CHAT' topic
    //highlight-next-line
    meeting!!.pubSub.unsubscribe("CHAT", pubSubMessageListener)
    super.onDestroy()
  }
}
```

</TabItem>

<TabItem value="Java">

```js
public class ChatActivity extends AppCompatActivity {
  @Override
  protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_chat);

    //..
  }

  @Override
  protected void onDestroy() {
    // Unsubscribe for 'CHAT' topic
    //highlight-next-line
    meeting.pubSub.unsubscribe("CHAT", pubSubMessageListener);
    super.onDestroy();
  }
}
```

</TabItem>

</Tabs>

### `Private Chat`

In the above example, if you want to convert into the private chat between two participants, then all you have to do is pass `sendOnly` parameter in `PubSubPublishOptions`.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
class ChatActivity : AppCompatActivity() {

  //..
  
  private fun sendMessage() {
    // get message from EditText
    val message: String = etmessage.getText().toString()
    if (!TextUtils.isEmpty(message)) {
        val publishOptions = PubSubPublishOptions()
        publishOptions.setPersist(true)
        //highlight-start
        // Pass the participantId of the participant to whom you want to send the message.
        var sendOnly: Array<String> = arrayOf("xyz")
        publishOptions.setSendOnly(sendOnly);
        //highlight-end

        // Sending the Message using the publish method
        //highlight-next-line
        meeting!!.pubSub.publish("CHAT", message, publishOptions)

        // Clearing the message input
        etmessage.setText("")
    } else {
        Toast.makeText(
            this@ChatActivity, "Please Enter Message",
            Toast.LENGTH_SHORT
        ).show()
    }
  }
}
```

</TabItem>

<TabItem value="Java">

```js
public class ChatActivity extends AppCompatActivity {
 
  //...

  private void sendMessage()
  {
    // get message from EditText
    String message = etmessage.getText().toString();
    if (!message.equals("")) {
        PubSubPublishOptions publishOptions = new PubSubPublishOptions();
        publishOptions.setPersist(true);
        //highlight-start
        // Pass the participantId of the participant to whom you want to send the message.
        String[] sendOnly = {
          "xyz" 
        };
        publishOptions.setSendOnly(sendOnly);
        //highlight-end

        // Sending the Message using the publish method
        //highlight-next-line
        meeting.pubSub.publish("CHAT", message, publishOptions);

        // Clearing the message input
        etmessage.setText("");
    } else {
        Toast.makeText(ChatActivity.this, "Please Enter Message",
                Toast.LENGTH_SHORT).show();
    }
  }
}
```

</TabItem>

</Tabs>

### Downloading Chat Messages

All the messages from the PubSub which where published with `persist : true` and can be downloaded as an `.csv` file. This file will be available in the VideoSDK dashboard as well as throught the [Sessions API](/api-reference/realtime-communication/fetch-session-using-sessionid).

### API Reference

The API references for all the methods and events utilised in this guide are provided below.

- [pubSub()](/android/api/sdk-reference/pubsub-class/introduction)


---

---
title: Notify Attendees with PubSub - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: PubSub features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Notify Attendees in Realtime
pagination_label: Notify Attendees in Realtime
keywords:
  - Start Livestream meeting
  - Stop Livestream meeting
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: notify-attendees
---

# Notify Attendees in Realtime - Android

When doing livestream, you may want to broadcast message to all the viewers at once.

Let us see, how we can use PubSub to implement this functionality. If you are not familiar with the PubSub mechanism, you can [follow this guide](/android/guide/video-and-audio-calling-api-sdk/collaboration-in-meeting/pubsub).

### Notifying Attendees

1. We will be publish the message that the sender typed in the `EditText` field to the topic `NOTIFY_ATTENDEES`.

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js

class SpeakerActivity : AppCompatActivity() {
  override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    //...
    findViewById(R.id.btnSend).setOnClickListener(view -> sendMessage());
  }

  private fun sendMessage() {
    // get message from EditText
    val message: String = etmessage.getText().toString()
    if (!TextUtils.isEmpty(message)) {
        val publishOptions = PubSubPublishOptions()
        publishOptions.setPersist(true)

        // Sending the Message using the publish method
        //highlight-next-line
        meeting!!.pubSub.publish("NOTIFY_ATTENDEES", message, publishOptions)

        // Clearing the message input
        etmessage.setText("")
    } else {
        Toast.makeText(
            this@SpeakerActivity, "Please Enter Message",
            Toast.LENGTH_SHORT
        ).show()
    }
  }
}
```

</TabItem>

<TabItem value="Java">

```js
public class SpeakerActivity extends AppCompatActivity {
  @Override
  protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    //...
    findViewById(R.id.btnSend).setOnClickListener(view -> sendMessage());
  }

  private void sendMessage()
  {
    // get message from EditText
    String message = etmessage.getText().toString();
    if (!message.equals("")) {
        PubSubPublishOptions publishOptions = new PubSubPublishOptions();
        publishOptions.setPersist(true);

        // Sending the Message using the publish method
        //highlight-next-line
        meeting.pubSub.publish("NOTIFY_ATTENDEES", message, publishOptions);

        // Clearing the message input
        etmessage.setText("");
    } else {
        Toast.makeText(SpeakerActivity.this, "Please Enter Message",
                Toast.LENGTH_SHORT).show();
    }
  }
}
```

</TabItem>

</Tabs>

2. Now let us show an alert to all the viewers displaying the message posted by the speaker.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
class ViewerActivity : AppCompatActivity() {

  // PubSubMessageListener
  //highlight-start
  var pubSubMessageListener =
    PubSubMessageListener { message ->
      if(meeting!!.localparticipant.mode == "SIGNALLING_ONLY"){
        Toast.makeText(
                this@ViewerActivity, message.message,
                Toast.LENGTH_SHORT
            ).show()
      }
  }
  //highlight-end

  override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    setContentView(R.layout.activity_chat)

    //...

    // Subscribe for 'NOTIFY_ATTENDEES' topic
    //highlight-next-line
    val pubSubMessageList = meeting!!.pubSub.subscribe("NOTIFY_ATTENDEES", pubSubMessageListener)

    for (message in pubSubMessageList) {
      // Persisted messages
      if(meeting!!.localparticipant.mode == "SIGNALLING_ONLY"){
        Toast.makeText(
                this@ViewerActivity, message.message,
                Toast.LENGTH_SHORT
            ).show()
      }
    }
  }
}
```

</TabItem>

<TabItem value="Java">

```js
public class ViewerActivity extends AppCompatActivity {

  // PubSubMessageListener
  //highlight-start
  private PubSubMessageListener pubSubMessageListener = new PubSubMessageListener() {
    @Override
    public void onMessageReceived(PubSubMessage message) {
        if(meeting.getLocalParticipant().getMode() == "SIGNALLING_ONLY"){
            Toast.makeText(
                ViewerActivity.this, message.getMessage(),
                Toast.LENGTH_SHORT
                ).show();
        }
    }
  };
  //highlight-end

  @Override
  protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);

    //..

    // Subscribe for 'NOTIFY_ATTENDEES' topic
    //highlight-next-line
    List<PubSubMessage> pubSubMessageList = meeting.pubSub.subscribe("NOTIFY_ATTENDEES", pubSubMessageListener);

    for(PubSubMessage message : pubSubMessageList){
        // Persisted messages
        if(meeting.getLocalParticipant().getMode() == "SIGNALLING_ONLY"){
            Toast.makeText(
            ViewerActivity.this, message.getMessage(),
            Toast.LENGTH_SHORT
            ).show();
        }
    }
  }
}
```

</TabItem>

</Tabs>

### API Reference

The API references for all the methods and events utilised in this guide are provided below.

- [pubSub()](/android/api/sdk-reference/pubsub-class/introduction)


---

---
title: Raise Hand with PubSub - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: PubSub features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Raise Hand using PubSub
pagination_label: Raise Hand using PubSub
keywords:
  - Raise Hand
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: raise-hand-using-pubsub
---

# Raise Hand using PubSub - Android

Let us see, how we can use PubSub to implement Raise Hand functionality. If you are not familiar with the PubSub mechanism and `pubSub` class, you can [follow this guide](/android/guide/video-and-audio-calling-api-sdk/collaboration-in-meeting/pubsub).

## Implementing Raise Hand

1. First step in raise hand is choosing the topic which all the participants will publish and subscribe to know some participant raise their hand. We will be using `RAISE_HAND` as the topic for this one.
2. On the raiseHand button, publish any message to that specific topic.

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
class MainActivity : AppCompatActivity() {

  override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    setContentView(R.layout.activity_main)

    //...

    findViewById(R.id.btnRaiseHand).setOnClickListener(view -> sendRaiseHandMessage());
  }

  private fun sendRaiseHandMessage() {
    val publishOptions = PubSubPublishOptions()
    publishOptions.setPersist(false)

    // Sending the Message using the publish method
    //highlight-next-line
    meeting!!.pubSub.publish("RAISE_HAND", "Raise Hand", publishOptions)
  }
}
```

</TabItem>

<TabItem value="Java">

```js
public class MainActivity extends AppCompatActivity {
  @Override
  protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_chat);

    //...

    findViewById(R.id.btnRaiseHand).setOnClickListener(view -> sendRaiseHandMessage());
  }

  private void sendRaiseHandMessage()
  {
    PubSubPublishOptions publishOptions = new PubSubPublishOptions();
    publishOptions.setPersist(false);

    // Sending the Message using the publish method
    //highlight-next-line
    meeting.pubSub.publish("RAISE_HAND", "Raise Hand", publishOptions);
  }
}
```

</TabItem>

</Tabs>

3. Now let us show an alert to all the participants showing who raised the hand.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
class MainActivity : AppCompatActivity() {

  // PubSubMessageListener
  //highlight-start
  var pubSubMessageListener =
    PubSubMessageListener { message ->
      // Participant raise hand
      Toast.makeText(
            this@MainActivity, message.senderName + " raise hand",
            Toast.LENGTH_SHORT
        ).show()
  }
  //highlight-end

  override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    setContentView(R.layout.activity_chat)

    //...

    // Subscribe for 'RAISE_HAND' topic
    //highlight-next-line
    val pubSubMessageList = meeting!!.pubSub.subscribe("RAISE_HAND", pubSubMessageListener)
  }
}
```

</TabItem>

<TabItem value="Java">

```js
public class MainActivity extends AppCompatActivity {

  // PubSubMessageListener
  //highlight-start
  private PubSubMessageListener pubSubMessageListener = new PubSubMessageListener() {
    @Override
    public void onMessageReceived(PubSubMessage message) {
        // Participant raise hand
        Toast.makeText(
          MainActivity.this, message.senderName + " raise hand",
          Toast.LENGTH_SHORT
        ).show();
    }
  };
  //highlight-end

  @Override
  protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);

    //..

    // Subscribe for 'RAISE_HAND' topic
    //highlight-next-line
    List<PubSubMessage> pubSubMessageList = meeting.pubSub.subscribe("RAISE_HAND", pubSubMessageListener);
  }
}
```

</TabItem>

</Tabs>

### API Reference

The API references for all the methods and events utilised in this guide are provided below.

- [pubSub()](/android/api/sdk-reference/pubsub-class/introduction)


---

---
title: Reactions with PubSub - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: PubSub features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Reactions
pagination_label: Reactions
keywords:
  - Start Livestream meeting
  - Stop Livestream meeting
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: reactions
---

# Reactions - Android

When doing a livestream, one of the way to increase the interaction in between the viewer and speaker is by showing the viewers reaction to all. You might have seen emojis flying around during the livestream happening on instagram.

Lets create a similar flying emoji by using the VideoSDK PubSub mechanism.

### Step 1: Creating a button to send reaction

When `btnReaction` is clicked we will send the emoji name to all the participants using the VideoSDK PubSub mechanism and also shows emoji to localParticipant.

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
class ILSViewActivity : AppCompatActivity() {

  override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    //...
    findViewById(R.id.btnReaction).setOnClickListener { v: View? ->
        showEmoji(resources.getDrawable(R.drawable.love_eyes_emoji))
        meeting!!.pubSub.publish("REACTION", "love_eyes", pubSubPublishOptions)
    }
  }

  private fun showEmoji(drawable: Drawable?) {
    // we will implement this method in step 2
  }
}
```

</TabItem>

<TabItem value="Java">

```js
public class ILSViewActivity extends AppCompatActivity {
  @Override
  protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    //...
    findViewById(R.id.loveEyes).setOnClickListener(v -> {
        showEmoji(getResources().getDrawable(R.drawable.love_eyes_emoji));
        meeting.pubSub.publish("REACTION", "love_eyes", pubSubPublishOptions);
    });
  }

  public void showEmoji(Drawable drawable) {
    // we will implement this method in step 2
  }
}
```

</TabItem>

</Tabs>

### Step 2: Displaying the Reactions to all the users

Here we will listen to the `onMessageReceived` event of `PubSubMessageListener` to know someone send the reactions, and show the flying emoji whenever it triggered.

To Display flyingEmoji, we are using `DirectionGenerator` class to specify direction and `ZeroGravityAnimation` class to give animation to the flyingEmoji.

Copy `DirectionGenerator` and `ZeroGravityAnimation` classes from our [code sample](https://github.com/videosdk-live/videosdk-hls-android-kotlin-example/tree/main/app/src/main/java/live/videosdk/android/hlsdemo/common/reactions).

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
class ILSViewActivity : AppCompatActivity() {

  override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    //...
    var emojiListener =
    PubSubMessageListener { pubSubMessage ->
        when (pubSubMessage.message) {
            //Showing other participants reactions
            "loveEyes" -> showEmoji(resources.getDrawable(R.drawable.love_eyes_emoji))
        }
    }
    //Subscribing to the PubSub topic REACTION to recive other participants reactions.
    //highlight-start
    meeting!!.pubSub.subscribe("REACTION", emojiListener)
  }
}
```

</TabItem>

<TabItem value="Java">

```js
public class ILSViewActivity extends AppCompatActivity {
  @Override
  protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    //...
    private PubSubMessageListener pubSubMessageListener = new PubSubMessageListener() {
    @Override
    public void onMessageReceived(PubSubMessage pubSubMessage) {
            switch (pubSubMessage.getMessage()) {
                case "loveEyes":
                    //Showing other participants reactions
                    showEmoji(getResources().getDrawable(R.drawable.love_eyes_emoji));
                    break;
            }

        }
    };
    //Subscribing to the PubSub topic REACTION to recive other participants reactions.
    //highlight-start
    meeting.pubSub.subscribe("REACTION", emojiListener);
  }
}
```

</TabItem>

</Tabs>

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
private fun showEmoji(drawable: Drawable?) {
    // You can change the number of emojis that will be flying on screen
    for (i in 0..4) {
        flyObject(
            drawable,
            3000,
            DirectionGenerator.Direction.BOTTOM,
            DirectionGenerator.Direction.TOP,
            1f
        )
    }
}

private fun flyObject(
    drawable: Drawable?,
    duration: Int,
    from: DirectionGenerator.Direction?,
    to: DirectionGenerator.Direction?,
    scale: Float
) {
    val animation = ZeroGravityAnimation()
    animation.setCount(1)
    animation.setScalingFactor(scale)
    animation.setOriginationDirection((from)!!)
    animation.setDestinationDirection((to)!!)
    animation.setImage(drawable)
    animation.setDuration(duration)
    animation.setAnimationListener(object : Animation.AnimationListener {
        override fun onAnimationStart(animation: Animation) {}
        override fun onAnimationEnd(animation: Animation) {}
        override fun onAnimationRepeat(animation: Animation) {}
    })
    viewerEmojiHolder!!.bringToFront()
    animation.play(mActivity, viewerEmojiHolder)
}
```

</TabItem>

<TabItem value="Java">

```js
public void showEmoji(Drawable drawable) {
    // You can change the number of emojis that will be flying on screen
    for (int i = 0; i < 5; i++) {
        flyObject(drawable, 3000, DirectionGenerator.Direction.BOTTOM, DirectionGenerator.Direction.TOP, 1);
    }
}

public void flyObject(final Drawable drawable, final int duration, final DirectionGenerator.Direction from, final DirectionGenerator.Direction to, final float scale) {
    ZeroGravityAnimation animation = new ZeroGravityAnimation();
    animation.setCount(1);
    animation.setScalingFactor(scale);
    animation.setOriginationDirection(from);
    animation.setDestinationDirection(to);
    animation.setImage(drawable);
    animation.setDuration(duration);
    animation.setAnimationListener(new Animation.AnimationListener() {
        @Override
        public void onAnimationStart(Animation animation) {

        }

        @Override
        public void onAnimationEnd(Animation animation) {
        }

        @Override
        public void onAnimationRepeat(Animation animation) {

        }
    });
    viewerEmojiHolder.bringToFront();
    animation.play(mActivity, viewerEmojiHolder);
}

```

</TabItem>

</Tabs>

:::note
Here `viewerEmojiHolder` is FrameLayout, you can change recording to your requirement.
:::

<center>

<img style={{height: '450px',marginRight:'15px'}} src="https://cdn.videosdk.live/website-resources/docs-resources/android_emoji_viewer.gif" />

<img style={{height: '450px'}} src="https://cdn.videosdk.live/website-resources/docs-resources/android_emoji_speaker.gif"/>

</center>

### API Reference

The API references for all the methods and events utilised in this guide are provided below.

- [pubSub()](/android/api/sdk-reference/pubsub-class/introduction)


---

---
sidebar_label: Overview
pagination_label: Overview
---

# Overview of SIP with VideoSDK - Android

import SipConnect from '../../../../mdx/\_sip-connect.mdx';
import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>

<SipConnect title="SIP Connect with VideoSDK - Android"/>


---

---
sidebar_label: Quick Start
pagination_label: Quick Start
---

# Build a SIP Integration: VideoSDK & Twilio for Inbound Outbound Calls! Step-by-Step

import SipQuickStart from '../../../../mdx/\_sip-connect-quick-start.mdx';

<SipQuickStart/>


---

---
title: SIP Connect
hide_title: false
hide_table_of_contents: false
description: Interactive Livestream features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: SIP Connect
pagination_label: SIP Connect
keywords:
  - SIP connect
  - PSTN connect
  - sip videosdk
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: sip-connect
---

# SIP Connect - Android

import SipConnect from '../../../mdx/\_sip-connect.mdx';
import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>

<SipConnect title="SIP Connect with VideoSDK - Android"/>


---

---
title: Start a Video & Audio Call in Android SDK - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: Build customizable real-time video & audio calling applications in Android SDK using Video SDK add live Video & Audio conferencing to your applications.
sidebar_label: "Client Setup for Android"
pagination_label: "Client Setup for Android"
keywords:
  - android sdk
  - java sdk
  - kotlin sdk
  - chromebook sdk
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: android-sdk
---

import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>

# Getting Started - Android SDK

Android SDK is natively written SDK using Java. It is compatible with both Java and Kotlin.

## Install an Android SDK

The easiest way to get started is by installing the sdk in your app.

### Step 1: Add the repositories into your project.

- If your Android Studio Version is older than Android Studio Bumblebees, add the repository to project's `build.gradle` file.
- If your are using Android Studio Bumblebees or newer Version, add the repository to `settings.gradle` file.

:::note

You can use imports with Maven Central after rtc-android-sdk version `0.1.12`.

Whether on Maven or Jitpack, the same version numbers always refer to the same SDK.

:::

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Maven Central"
groupId={"android-repositories"}
values={[{label: 'Maven Central', value: 'Maven Central'},{label: 'Jitpack', value: 'Jitpack'},]}>

<TabItem value="Maven Central">

```js title="build.gradle"
allprojects {
  repositories {
    // ...
    google()
    mavenCentral()
    maven { url "https://maven.aliyun.com/repository/jcenter" }
  }
}
```

```js title="settings.gradle"
dependencyResolutionManagement{
  repositories {
    // ...
    google()
    mavenCentral()
    maven { url "https://maven.aliyun.com/repository/jcenter" }
  }
}

```

</TabItem>

<TabItem value="Jitpack">

```js title="build.gradle"
allprojects {
  repositories {
    // ...
    google()
    maven { url 'https://jitpack.io' }
    mavenCentral()
    maven { url "https://maven.aliyun.com/repository/jcenter" }
  }
}
```

```js title="settings.gradle"
dependencyResolutionManagement{
  repositories {
    // ...
    google()
    maven { url 'https://jitpack.io' }
    mavenCentral()
    maven { url "https://maven.aliyun.com/repository/jcenter" }
  }
}

```

</TabItem>

</Tabs>

### Step 2: Add the dependency in `app/build.gradle`:

```js title="app/build.gradle"
dependencies {
		implementation 'live.videosdk:rtc-android-sdk:0.1.38'

		// other app dependencies
}
```

:::important

Android SDK compatible with armeabi-v7a, arm64-v8a, x86_64 architectures. If you want to run the application in an emulator, choose ABI x86_64 when creating a device.

:::

### Step 3: Add all the following permissions to AndroidManifest.xml

```js title="AndroidManifest.xml"
<uses-permission android:name="android.permission.RECORD_AUDIO" />
<uses-permission android:name="android.permission.MODIFY_AUDIO_SETTINGS" />
<uses-permission android:name="android.permission.INTERNET" />
<uses-permission android:name="android.permission.READ_PHONE_STATE" />
<uses-permission android:name="android.permission.CAMERA" />

<uses-permission android:name="android.permission.BLUETOOTH" />
<uses-permission android:name="android.permission.BLUETOOTH_ADMIN" />
<uses-permission android:name="android.permission.BLUETOOTH_CONNECT" />

```

### Step 4: Create MainApplication class with the following code

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js title="MainApplication.kt"
package live.videosdk.demo;

import live.videosdk.rtc.android.VideoSDK;

class MainApplication : Application() {
  override fun onCreate() {
    super.onCreate()
    
    VideoSDK.initialize(applicationContext)
  }
}
```

</TabItem>

<TabItem value="Java">

```js title="MainApplication.java"
package live.videosdk.demo;

import android.app.Application;

import live.videosdk.rtc.android.VideoSDK;

public class MainApplication extends Application {
    @Override
    public void onCreate() {
        super.onCreate();

        VideoSDK.initialize(getApplicationContext());
    }
}
```

</TabItem>

</Tabs>

### Step 5: Add MainApplication to AndroidManifest.xml

```js title="AndroidManifest.xml"
<application
    android:name=".MainApplication"
>
  <!-- ... -->
</application>
```

:::note

Check out official example of Android SDK implementation for Java and Kotlin as mentioned below: 

- For **Java** Code Sample [Click here](https://github.com/videosdk-live/videosdk-rtc-android-java-sdk-example)<br />
- For **Kotlin** Code Sample [Click here](https://github.com/videosdk-live/videosdk-rtc-android-kotlin-sdk-example)

:::


---

---
title: Authentication and Token | Video SDK
hide_title: true
hide_table_of_contents: false
description: Video SDK and Audio SDK, developers need to implement a token server. This requires efforts on both the front-end and backend.
sidebar_label: Authentication and Tokens
pagination_label: Authentication and Tokens
keywords:
  - audio calling
  - video calling
  - real-time communication
  - collaboration
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: authentication-and-token
---

import ServerSetup from '../../../../mdx/introduction/\_server-setup.mdx';

<ServerSetup title="Authentication and Tokens for VideoSDK - Android" />


---

---
title: Authentication in Video & Audio Calling SDK
hide_title: false
hide_table_of_contents: false
description: This guide will explain authentication and token flow for video & audio calling SDK.
sidebar_label: Authentication and Tokens
pagination_label: Authentication and Tokens
keywords:
  - authentication audio calling
  - authentication video calling
  - authentication real-time communication
  - tokens
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: authentication-and-tokens
---

import Mermaid from '@theme/Mermaid';
import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>

# Authentication and Token

VideoSDK uses access tokens for authentication. Using our dashboard ([app.videosdk.live](https://app.videosdk.live/)), anyone can generate access tokens tokens with an API key and secret pair.

- Your backend server will generate access tokens using API Key and secret.
- Your client obtains token from your backend server.
- Your client will pass the token to VideoSDK server.
- VideoSDK client sdk will conncts to the VideoSDK server with available token.
- VideoSDK server will validate the token and accpets your incoming connection.

Here is the simple sequence diagram represents the authentication.
<Mermaid chart={`sequenceDiagram Your App Client->>Your App Server: Request for token; activate Your App Server; Note left of Your App Server: Generate token; Your App Server-->>Your App Client: Received token; deactivate Your App Server; Your App Client->>VideoSDK Server: Request to establish connection; activate VideoSDK Server; Note left of VideoSDK Server: Validates Token; VideoSDK Server-->>Your App Client: Connection established; deactivate VideoSDK Server;`}/>

## Generate API Key and Secret

Visit, [app.videosdk.live](https://app.videosdk.live/) to gererate API Key and secret.

![Generate API Key from Dashboard](/img/tutorial/generate-api-key.jpg)

## Generate Access Token

For security, every participant that connects to meeting needs a access token. By substituting `apikey` and `permissions` in it.

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="node"
groupId={"server-group-id"}
values={[
{label: 'Node.js', value: 'node'},
{label: 'Python', value: 'python'},
{label: 'Java', value: 'java'},
{label: 'Ruby', value: 'ruby'},
{label: 'PHP', value: 'php'},
]}>
<TabItem value="node">

```js
var jwt = require("jsonwebtoken");
var uuid4 = require("uuid4");

// Need to generate from app.videosdk.live
const API_KEY = "API_KEY_GENERATED";
const SECRET_KEY = "API_SECRET_KEY_GENERATED";

jwt.sign(
  {
    apikey: API_KEY,
    permissions: ["allow_join"], // Permission to join the meeting
  },
  SECRET_KEY,
  {
    algorithm: "HS256",
    expiresIn: "24h",
    jwtid: uuid4(),
  },
  function (err, token) {
    console.log(token);
  }
);
```

</TabItem>
<TabItem value="python">

```python
#!/usr/bin/env python3
import jwt
import uuid
import datetime

api_key = 'api_key_generated'
secret_key = 'secret_key_generated'


def generateToken():
    expires = 24 * 3600
    now = datetime.datetime.utcnow()
    exp = now + datetime.timedelta(seconds=expires)
    return jwt.encode(payload={
          'apikey': api_key,
          permissions: ["allow_join"]
        }, key=secret_key).decode('utf-8')

if __name__ == '__main__':
    print(generateToken())
```

</TabItem>
<TabItem value="java">

```js
import java.time.Instant;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;
import java.util.UUID;
import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.SignatureAlgorithm;

private void generateManagementToken() {
    Map<String, Object> payload = new HashMap<>();
    payload.put("apikey", "<api_key_generated>");
    payload.put("permissions", ["allow_join"]);
    String token = Jwts.builder().setClaims(payload).setId(UUID.randomUUID().toString())
        .setExpiration(new Date(System.currentTimeMillis() + 86400 * 1000))
        .setIssuedAt(Date.from(Instant.ofEpochMilli(System.currentTimeMillis() - 60000)))
        .setNotBefore(new Date(System.currentTimeMillis()))
        .signWith(SignatureAlgorithm.HS256, "<secret_key_generated>".getBytes()).compact();
  }
```

</TabItem>
<TabItem value="ruby">

```js
require 'jwt'
require 'securerandom'

$api_key = "api_key_generated"
$secret_key = "secret_key_generated"

def generateToken()
    payload = {
      apikey: $api_key,
      permissions: ["allow_join"]
    }
token = JWT.encode(payload, $secret_key, 'HS256')
return token
end

puts generateToken
```

</TabItem>
<TabItem value="php">

```js
<?php

use Firebase\JWT\JWT;
use Ramsey\Uuid\Uuid;

$api_key = "api_key_generated";
$secret_key = "secret_key_generated"

$payload = [
    'apikey' => api_key,
    'permissions': ["allow_join"],
];

$token = JWT::encode($payload, $secret_key, 'HS256');
?>
```

</TabItem>
</Tabs>

Available permissions are:

- **allow_join**: The participant will be permitted entry without request.
- **ask_join**: The participant will not be permitted entry without request.
- **allow_mod**: Allow participant to enable/disable other participant's mic/webcam.


---

---
title: Chat messages with PubSub - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: PubSub features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Chat using PubSub
pagination_label: Chat using PubSub
keywords:
  - Chat in meeting
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: chat-using-pubsub
---

# Chat using PubSub - Android

For the communication or any kind of messaging in between the participants, VideoSDK provides `pubSub` class which use Publish-Subscribe mechanism and can be used to develope wide varitey of functionalities. For example, participants could use it to send chat messages to each other, share files or other media, or even trigger actions like muting or unmuting audio or video.

Now we will see, how we can use PubSub to implement Chat functionality. If you are not familiar with the PubSub mechanism and `pubSub` class, you can [follow this guide](./pubsub).

## Implementing Chat

### `Group Chat`

1. First step in creating a group chat is choosing the topic which all the participants will publish and subscribe to send and receive the messages. We will be using `CHAT` as the topic for this one.
2. On the send button, publish the message that the sender typed in the `EditText` field.

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle
import android.view.View
import android.widget.EditText
import android.widget.Toast
import androidx.appcompat.widget.Toolbar
import live.videosdk.rtc.android.Meeting
import live.videosdk.rtc.android.listeners.PubSubMessageListener
import live.videosdk.rtc.android.model.PubSubPublishOptions

class ChatActivity : AppCompatActivity() {
  // Meeting
  var meeting: Meeting? = null

  override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    setContentView(R.layout.activity_chat)

    /**
     * Here, we have created 'MainApplication' class, which extends android.app.Application class.
     * It has Meeting property and getter and setter methods of Meeting property.
     * In your android manifest, you must declare the class implementing android.app.Application
     * (add the android:name=".MainApplication" attribute to the existing application tag):
     * In MainActivity.kt, we have set Meeting property.
     *
     * For Example: (MainActivity.kt)
     * var meeting = VideoSDK.initMeeting(context, meetingId, ParticipantName, micEnabled, webcamEnabled, paricipantId, mode, multiStream, customTrack, metaData, signalingBaseUrl,preferredProtocol)
     * (this.application as MainApplication).meeting = meeting
    */

    // Get Meeting
    meeting = (this.application as MainApplication).meeting

    findViewById(R.id.btnSend).setOnClickListener(view -> sendMessage());
  }

  private fun sendMessage() {
    // get message from EditText
    val message: String = etmessage.getText().toString()
    if (!TextUtils.isEmpty(message)) {
        val publishOptions = PubSubPublishOptions()
        publishOptions.setPersist(true)

        // Sending the Message using the publish method
        //highlight-next-line
        meeting!!.pubSub.publish("CHAT", message, publishOptions)

        // Clearing the message input
        etmessage.setText("")
    } else {
        Toast.makeText(
            this@ChatActivity, "Please Enter Message",
            Toast.LENGTH_SHORT
        ).show()
    }
  }
}
```

</TabItem>

<TabItem value="Java">

```js
import androidx.appcompat.app.AppCompatActivity;
import android.os.Bundle;
import java.util.List;
import live.videosdk.rtc.android.Meeting;
import live.videosdk.rtc.android.lib.PubSubMessage;
import live.videosdk.rtc.android.listeners.PubSubMessageListener;
import live.videosdk.rtc.android.model.PubSubPublishOptions;

public class ChatActivity extends AppCompatActivity {
  // Meeting
  Meeting meeting;

  @Override
  protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_chat);

    /**
     * Here, we have created 'MainApplication' class, which extends android.app.Application class.
     * It has Meeting property and getter and setter methods of Meeting property.
     * In your android manifest, you must declare the class implementing android.app.Application
     * (add the android:name=".MainApplication" attribute to the existing application tag):
     * In MainActivity.java, we have set Meeting property.
     *
     * For Example: (MainActivity.java)
     * Meeting meeting = VideoSDK.initMeeting(context, meetingId, ParticipantName, micEnabled, webcamEnabled, participantId, mode, multiStream, customTrack,metaData, signalingBaseUrl,preferredProtocol);
     * ((MainApplication) this.getApplication()).setMeeting(meeting);
    */

    // Get Meeting
    meeting = ((MainApplication) this.getApplication()).getMeeting();

    findViewById(R.id.btnSend).setOnClickListener(view -> sendMessage());
  }

  private void sendMessage()
  {
    // get message from EditText
    String message = etmessage.getText().toString();
    if (!message.equals("")) {
        PubSubPublishOptions publishOptions = new PubSubPublishOptions();
        publishOptions.setPersist(true);

        // Sending the Message using the publish method
        //highlight-next-line
        meeting.pubSub.publish("CHAT", message, publishOptions);

        // Clearing the message input
        etmessage.setText("");
    } else {
        Toast.makeText(ChatActivity.this, "Please Enter Message",
                Toast.LENGTH_SHORT).show();
    }
  }
}
```

</TabItem>

</Tabs>

3. Next step would be to display the messages others send. For this we have to `subscribe` to that topic i.e `CHAT` and display all the messages.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
class ChatActivity : AppCompatActivity() {

  // PubSubMessageListener
  //highlight-start
  var pubSubMessageListener =
    PubSubMessageListener { message ->
      // New message
      Toast.makeText(
            this@ChatActivity, message.senderName + " says : " + message.message,
            Toast.LENGTH_SHORT
        ).show()
  }
  //highlight-end

  override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    setContentView(R.layout.activity_chat)

    //...

    // Subscribe for 'CHAT' topic
    //highlight-next-line
    val pubSubMessageList = meeting!!.pubSub.subscribe("CHAT", pubSubMessageListener)

    for (message in pubSubMessageList) {
      // Persisted messages
      Toast.makeText(
            this@ChatActivity, message.senderName + " says : " + message.message,
            Toast.LENGTH_SHORT
        ).show()
    }
  }
}
```

</TabItem>

<TabItem value="Java">

```js
public class ChatActivity extends AppCompatActivity {

  // PubSubMessageListener
  //highlight-start
  private PubSubMessageListener pubSubMessageListener = new PubSubMessageListener() {
    @Override
    public void onMessageReceived(PubSubMessage message) {
        // New message
        Toast.makeText(
          ChatActivity.this, message.senderName + " says : "+ message.getMessage(),
          Toast.LENGTH_SHORT
        ).show();
    }
  };
  //highlight-end

  @Override
  protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_chat);

    //..

    // Subscribe for 'CHAT' topic
    //highlight-next-line
    List<PubSubMessage> pubSubMessageList = meeting.pubSub.subscribe("CHAT", pubSubMessageListener);

    for(PubSubMessage message : pubSubMessageList){
        // Persisted messages
        Toast.makeText(
          ChatActivity.this, message.senderName + " says : "+ message.getMessage(),
          Toast.LENGTH_SHORT
        ).show();
    }
  }
}
```

</TabItem>

</Tabs>

4. Final step in the group chat would be `unsubscribe` to that topic, which you had previously subscribed but no longer needed. Here we are `unsubscribe` to `CHAT` topic on activity destroy.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
class ChatActivity : AppCompatActivity() {
  override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    setContentView(R.layout.activity_chat)

    //...
  }

  override fun onDestroy() {
    // Unsubscribe for 'CHAT' topic
    //highlight-next-line
    meeting!!.pubSub.unsubscribe("CHAT", pubSubMessageListener)
    super.onDestroy()
  }
}
```

</TabItem>

<TabItem value="Java">

```js
public class ChatActivity extends AppCompatActivity {
  @Override
  protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_chat);

    //..
  }

  @Override
  protected void onDestroy() {
    // Unsubscribe for 'CHAT' topic
    //highlight-next-line
    meeting.pubSub.unsubscribe("CHAT", pubSubMessageListener);
    super.onDestroy();
  }
}
```

</TabItem>

</Tabs>

### `Private Chat`

In the above example, if you want to convert into the private chat between two participants, then all you have to do is pass `sendOnly` parameter in `PubSubPublishOptions`.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
class ChatActivity : AppCompatActivity() {

  //..
  
  private fun sendMessage() {
    // get message from EditText
    val message: String = etmessage.getText().toString()
    if (!TextUtils.isEmpty(message)) {
        val publishOptions = PubSubPublishOptions()
        publishOptions.setPersist(true)
        //highlight-start
        // Pass the participantId of the participant to whom you want to send the message.
        var sendOnly: Array<String> = arrayOf("xyz")
        publishOptions.setSendOnly(sendOnly);
        //highlight-end

        // Sending the Message using the publish method
        //highlight-next-line
        meeting!!.pubSub.publish("CHAT", message, publishOptions)

        // Clearing the message input
        etmessage.setText("")
    } else {
        Toast.makeText(
            this@ChatActivity, "Please Enter Message",
            Toast.LENGTH_SHORT
        ).show()
    }
  }
}
```

</TabItem>

<TabItem value="Java">

```js
public class ChatActivity extends AppCompatActivity {
 
  //...

  private void sendMessage()
  {
    // get message from EditText
    String message = etmessage.getText().toString();
    if (!message.equals("")) {
        PubSubPublishOptions publishOptions = new PubSubPublishOptions();
        publishOptions.setPersist(true);
        //highlight-start
        // Pass the participantId of the participant to whom you want to send the message.
        String[] sendOnly = {
          "xyz" 
        };
        publishOptions.setSendOnly(sendOnly);
        //highlight-end

        // Sending the Message using the publish method
        //highlight-next-line
        meeting.pubSub.publish("CHAT", message, publishOptions);

        // Clearing the message input
        etmessage.setText("");
    } else {
        Toast.makeText(ChatActivity.this, "Please Enter Message",
                Toast.LENGTH_SHORT).show();
    }
  }
}
```

</TabItem>

</Tabs>

### Downloading Chat Messages

All the messages from the PubSub which where published with `persist : true` and can be downloaded as an `.csv` file. This file will be available in the VideoSDK dashboard as well as throught the [Sessions API](/api-reference/realtime-communication/fetch-session-using-sessionid).

### API Reference

The API references for all the methods and events utilised in this guide are provided below.

- [pubSub()](/android/api/sdk-reference/pubsub-class/introduction)


---

---
title: PubSub - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: PubSub features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: PubSub
pagination_label: PubSub
keywords:
  - Start Livestream meeting
  - Stop Livestream meeting
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: pubsub
---

# PubSub - Android

PubSub is a short acronym for Publish-Subscribe mechanism. This mechanism is used to send and recieve messages from a particular topic. As the name suggests, for someone to send a message, they have to specify the topic and the message which should be published and for someone to receive a message, they should be subscribed to that topic.

Here is a visual to better understand publish-subscribe mechanism.

![pubsub](/img/pubsub.png)

## pubSub

In order to use PubSub in meeting, VideoSDK provides a class `pubSub` which allows you to subscribe to any topic and publish to any topic allowing to pass on messages and instructions during the meeting easily.

### `publish()`

- This method is used for publishing message of specific topic.
- This method can be accessed from the `pubSub` class, which is subclass of `Meeting` class.
- This method will accept following parameters as input:
  - `topic`: This will be the topic for which you are publishing a message.
  - `message`: This will be the actual message to be published. It has to be in `String` format.
  - `options`: This is an object of `PubSubPublishOptions` which specifies the options for publish. `PubSubPublishOptions` has 2 properties.
    - `persist` : `persist` offered the option of keeping the message around for the duration of the session. When `persist` is set to `true`, that message will be retained for upcoming participants and will be available in [VideoSDK Session Dashboard](https://app.videosdk.live/meetings/sessions) with `.CSV` format after completion of session.
    - `sendOnly`: If you want to send a message to specific participants, you can pass their respective `participantId` in form of `String[]`. If you don't provide any IDs or pass a `null` value, the message will be sent to all participants by default. This is optional parameter.
  - `payload`: If you need to include additional information along with a message, you can pass here as `JSONObject`. This is optional parameter.

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
private fun sendMessage() {
  // publish message
  val options = PubSubPublishOptions()
  options.isPersist = true
  //highlight-next-line
  meeting!!.pubSub.publish("CHAT", "Hello Everyone!", options)
}
```

</TabItem>

<TabItem value="Java">

```js
protected void sendMessage() {
  // publish message
  PubSubPublishOptions options = new PubSubPublishOptions();
  options.setPersist(true);
  //highlight-next-line
  meeting.pubSub.publish("CHAT", "Hello Everyone!", options);
}
```

</TabItem>

</Tabs>

### `subscribe()`

- This method is used to subscribe for particular topic.
- This method will accept two parameters as input:

  - `topic`: This will be the topic to be subscribed.
  - `listener`: This is an object of `PubSubMessageListener`, which listens for upcoming messages and calls `onMessageReceived` function, when new message received.

- This method will return `List<PubSubMessage>` which is a list of messages which were sent earlier.

The object of `PubSubMessage` contains following properties:

- `senderId`: This represents the `participantId` of the participant who send the message.
- `senderName`: This represents the `displayName` of the participant who send the message.
- `message`: This will be the actual message that was send.
- `timestamp`: This wil the timestamp for when the message was published.
- `topic`: This will be the name of the topic message was published to.
- `payload`: This will be the data that you have send with message.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
//highlight-start
var pubSubMessageListener =
  PubSubMessageListener { message ->
    // New message
    Log.v("New Message Received", message.senderName + " says : " + message.message)
  }
//highlight-end

@Override
protected void onCreate(Bundle savedInstanceState) {
  //...

  // Subscribe for 'CHAT' topic
  //highlight-next-line
  val pubSubMessageList = meeting!!.pubSub.subscribe("CHAT", pubSubMessageListener)

  // Persisted message list
  for (message in pubSubMessageList) {
    Log.v("Message List: ", message.senderName + " says : " + message.message)
  }
}
```

</TabItem>

<TabItem value="Java">

```js
//highlight-start
PubSubMessageListener pubSubMessageListener = new PubSubMessageListener() {
  @Override
  public void onMessageReceived(PubSubMessage message) {
    // New message
    Log.v("New Message Received", message.senderName + " says : " + message.getMessage());
  }
};
//highlight-end

@Override
protected void onCreate(Bundle savedInstanceState) {
  //...

  // Subscribe for 'CHAT' topic
  //highlight-next-line
  List<PubSubMessage> pubSubMessageList = meeting.pubSub.subscribe("CHAT",pubSubMessageListener);

  // Persisted message list
  for(PubSubMessage message : pubSubMessageList){
    Log.v("Message List: ", message.senderName + " says : " + message.getMessage());
  }
}
```

</TabItem>

</Tabs>

### `unsubscribe()`

- This method is used to unsubscribe for particular topic.
- This method will accept two parameters as input:

  - `topic`: This will be the topic to be unsubscribed.
  - `listener`: This is an object of `PubSubMessageListener`, which was passed in `subscribe()`.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
fun unsubscribe() {
  // Unsubscribe 'CHAT' topic
  meeting!!.pubSub.unsubscribe("CHAT", pubSubMessageListener)
}
```

</TabItem>

<TabItem value="Java">

```js
public void unsubscribe(){
  // Unsubscribe 'CHAT' topic
  meeting.pubSub.unsubscribe("CHAT", pubSubMessageListener);
}
```

</TabItem>

</Tabs>

## Applications of usePubSub

PubSub is a very powerful mechanism which can be used to do alot of things which can make your meeting experience much more interactive. Some of the most common usecase that we have come across for the PubSub during a meeting are listed below:

1. [`Chat`](./chat-using-pubsub): You can utilise this to develop various Chat features, such as Private Chat and Group Chat. You can follow our chat [integration guide here](./chat-using-pubsub).
2. `Raise Hand`: You can allow attendees to raise their hands at any time during the meeting, informing everyone else that someone has done so.
3. `Poll`: You may make polls, let users respond to them, and display the results at the end of a poll.
4. `Question Answer Session`: You can also design interactive functionality that is question-and-answer based.

### Downloading PubSub Messages

All the messages from the PubSub which were published with `persist : true` and can be downloaded as an `.csv` file. This file will be available in the VideoSDK dashboard as well as throught the [Sessions API](/api-reference/realtime-communication/fetch-session-using-sessionid).

### API Reference

The API references for all the methods and events utilised in this guide are provided below.

- [pubSub()](/android/api/sdk-reference/pubsub-class/introduction)


---

---
title: Raise Hand with PubSub - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: PubSub features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Raise Hand using PubSub
pagination_label: Raise Hand using PubSub
keywords:
  - Raise Hand
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: raise-hand-using-pubsub
---

# Raise Hand using PubSub - Android

Let us see, how we can use PubSub to implement Raise Hand functionality. If you are not familiar with the PubSub mechanism and `pubSub` class, you can [follow this guide](./pubsub).

## Implementing Raise Hand

1. First step in raise hand is choosing the topic which all the participants will publish and subscribe to know some participant raise their hand. We will be using `RAISE_HAND` as the topic for this one.
2. On the raiseHand button, publish any message to that specific topic.

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
class MainActivity : AppCompatActivity() {

  override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    setContentView(R.layout.activity_main)

    //...

    findViewById(R.id.btnRaiseHand).setOnClickListener(view -> sendRaiseHandMessage());
  }

  private fun sendRaiseHandMessage() {
    val publishOptions = PubSubPublishOptions()
    publishOptions.setPersist(false)

    // Sending the Message using the publish method
    //highlight-next-line
    meeting!!.pubSub.publish("RAISE_HAND", "Raise Hand", publishOptions)
  }
}
```

</TabItem>

<TabItem value="Java">

```js
public class MainActivity extends AppCompatActivity {
  @Override
  protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_chat);

    //...

    findViewById(R.id.btnRaiseHand).setOnClickListener(view -> sendRaiseHandMessage());
  }

  private void sendRaiseHandMessage()
  {
    PubSubPublishOptions publishOptions = new PubSubPublishOptions();
    publishOptions.setPersist(false);

    // Sending the Message using the publish method
    //highlight-next-line
    meeting.pubSub.publish("RAISE_HAND", "Raise Hand", publishOptions);
  }
}
```

</TabItem>

</Tabs>

3. Now let us show an alert to all the participants showing who raised the hand.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
class MainActivity : AppCompatActivity() {

  // PubSubMessageListener
  //highlight-start
  var pubSubMessageListener =
    PubSubMessageListener { message ->
      // Participant raise hand
      Toast.makeText(
            this@MainActivity, message.senderName + " raise hand",
            Toast.LENGTH_SHORT
        ).show()
  }
  //highlight-end

  override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    setContentView(R.layout.activity_chat)

    //...

    // Subscribe for 'RAISE_HAND' topic
    //highlight-next-line
    val pubSubMessageList = meeting!!.pubSub.subscribe("RAISE_HAND", pubSubMessageListener)
  }
}
```

</TabItem>

<TabItem value="Java">

```js
public class MainActivity extends AppCompatActivity {

  // PubSubMessageListener
  //highlight-start
  private PubSubMessageListener pubSubMessageListener = new PubSubMessageListener() {
    @Override
    public void onMessageReceived(PubSubMessage message) {
        // Participant raise hand
        Toast.makeText(
          MainActivity.this, message.senderName + " raise hand",
          Toast.LENGTH_SHORT
        ).show();
    }
  };
  //highlight-end

  @Override
  protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);

    //..

    // Subscribe for 'RAISE_HAND' topic
    //highlight-next-line
    List<PubSubMessage> pubSubMessageList = meeting.pubSub.subscribe("RAISE_HAND", pubSubMessageListener);
  }
}
```

</TabItem>

</Tabs>

### API Reference

The API references for all the methods and events utilised in this guide are provided below.

- [pubSub()](/android/api/sdk-reference/pubsub-class/introduction)


---

---
title: Render Whiteboard - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: Whiteboard is a digital canvas that allows users to collaborate in real-time by drawing, writing, and sharing ideas visually, making it ideal for brainstorming, presentations, and teamwork.
sidebar_label: Render Whiteboard
pagination_label: Render Whiteboard
keywords:
  - Start Livestream meeting
  - Stop Livestream meeting
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg2
sidebar_position: 1
slug: render-whiteboard
---

# Render Whiteboard - Android

This guide explains how to dynamically render a whiteboard in your Android application.

## Setup WebView

- The whiteboard is rendered using a `WebView` component.
- You can configure the required XML style using the following code

```js
<WebView
    android:id="@+id/webView"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    />
```

## Render the Whiteboard

You can start the whiteboard with `meeting.startWhiteboard()` method, which triggers the `onWhiteboardStarted()` event. The event provides the URL to load in the WebView for rendering. To stop it, call `meeting.stopWhiteboard()`, which triggers the `onWhiteboardStopped()` event.

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
class MeetingActivity : AppCompatActivity() {

    private lateinit var meeting: Meeting
    private lateinit var webView: WebView

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_meeting)

        webView = findViewById(R.id.webView)

        // Init and config meeting
        // meeting = ...

        meeting.addEventListener(meetingEventListener);

        val meetingEventListener = object : MeetingEventListener() {
            override fun onWhiteboardStarted(url: String) {
                super.onWhiteboardStarted(url)
                webView.loadUrl(url)
                webView.settings.javaScriptEnabled = true
                webView.webViewClient = WebViewClient()
            }

            override fun onWhiteboardStopped() {
                super.onWhiteboardStopped()
                //...
            }
        }

        findViewById<View>(R.id.btnStartWhiteboard).setOnClickListener {
            meeting.startWhiteboard()
        }

        findViewById<View>(R.id.btnStopWhiteboard).setOnClickListener {
            meeting.stopWhiteboard()
        }
    }
}
```

</TabItem>

<TabItem value="Java">

```js
public class MeetingActivity extends AppCompatActivity {
    
    private Meeting meeting;
    private WebView webView ;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        //...

        webView = findViewById(R.id.webView);
        /* 
        init and config meeting ...
        meeting = //...
        */
        meeting.addEventListener(meetingEventListener);
        
        final MeetingEventListener meetingEventListener = new MeetingEventListener() {
            //...
            @Override
            public void onWhiteboardStarted(String url) {
                super.onWhiteboardStarted(url);
                webView.loadUrl(url);
                webView.getSettings().setJavaScriptEnabled(true);
                webView.setWebViewClient(new WebViewClient());
            }

            @Override
            public void onWhiteboardStopped() {
                super.onWhiteboardStopped();
                //...
            }
        };

        findViewById(R.id.btnStartWhiteboard).setOnClickListener(v -> {
            meeting.startWhiteboard();
        });

        findViewById(R.id.btnStopWhiteboard).setOnClickListener(v -> {
            meeting.stopWhiteboard();
        });
    }
}
```

</TabItem>

</Tabs>


## API Reference

- [startWhiteboard()](/android/api/sdk-reference/meeting-class/methods#startwhiteboard)
- [stopWhiteboard()](/android/api/sdk-reference/meeting-class/methods#stopwhiteboard)
- [onWhiteboardStarted()](/android/api/sdk-reference/meeting-class/meeting-event-listener-class#onwhiteboardstarted)
- [onWhiteboardStopped()](/android/api/sdk-reference/meeting-class/meeting-event-listener-class#onwhiteboardstopped)




---

---
title: Upload & Fetch Temporary File | Video SDK
hide_title: true
hide_table_of_contents: false
description: Upload & Fetch Temporary File.
sidebar_label: Upload-Fetch Temporary File
pagination_label: Upload-Fetch Temporary File
keywords:
  - upload temporary file
  - fetch temporary file
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: upload-fetch-temporary-file
--- 

# Upload and Retrieve the Temporary File - Android

This guide demonstrates how to upload and retrieve files from VideoSDK's temporary file storage system.

### `uploadBase64File()`

- By using the `uploadBase64File()` method of the [`Meeting`](/android/api/sdk-reference/meeting-class/introduction) class, you can upload your file to Videosdk's Temporary storage.

- The `uploadBase64File()` method only works with `base64`. Therefore, it is necessary to convert your file into `base64` format.

- You have to pass `base64Data`,`token`,`fileName` and implementation of `TaskCompletionListener` as parameter in `uploadBase64File()` method.

- When the upload is complete, the `onComplete()` method of `TaskCompletionListener` will provide the corresponding `fileUrl`, which can be used to retrieve the uploaded file.

- If an error occurs during the upload process, the `onError()` method of `TaskCompletionListener` will provide the error details.

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
private fun uploadFile() {
  val base64Data = "<Your File's base64>" // Convert your file to base64 and pass here
  val token = "<VIDEOSDK_TOKEN>"
  val fileName = "myImage.jpeg" // Provide name with extension here
  meeting!!.uploadBase64File(
    base64Data,
    token,
    fileName,
    object : TaskCompletionListener<String?, String?> {
      override fun onComplete(data: String?) {
          Log.d("VideoSDK", "Uploaded file url: $data")
      }

      override fun onError(error: String?) {
          Log.d("VideoSDK", "Error in upload file: $error")
      }
    }
  )
}
```

</TabItem>

<TabItem value="Java">

```js
private void uploadFile() {
  String base64Data = "<Your File's base64>"; // Convert your file to base64 and pass here
  String token = "<VIDEOSDK_TOKEN>";
  String fileName = "myImage.jpeg"; // Provide name with extension here
  meeting.uploadBase64File(base64Data, token, fileName, new TaskCompletionListener<String, String>() {
    @Override
    public void onComplete(@Nullable String data) {
        Log.d("VideoSDK", "Uploaded file url: " + data);
    }

    @Override
    public void onError(@Nullable String error) {
        Log.d("VideoSDK", "Error in upload file: " + error);
    }
  });
}
```

</TabItem>

</Tabs>


### `fetchBase64File()`

- By using the `fetchBase64File()` method of the [`Meeting`](/android/api/sdk-reference/meeting-class/introduction) class, you can retrieve your file from Videosdk's Temporary storage.

- To retrieve a file, you need to pass the `fileUrl` (which is returned by the `uploadBase64File()` method), the `token`, and an implementation of the `TaskCompletionListener` as parameters.

- When the fetch operation is complete, the `onComplete()` method of `TaskCompletionListener` will provide the file in `base64` format.

- If an error occurs during the fetch operation, the `onError()` method of `TaskCompletionListener` will provide the error details.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
private fun fetchFile() {
  val url = "<Your FileUrl>"  // Provide fileUrl which is returned by uploadBase64File()
  val token = "<VIDEOSDK_TOKEN>"
  meeting.fetchBase64File(url, token, object : TaskCompletionListener<String?, String?> {
      override fun onComplete(data: String?) {
          Log.d("VideoSDK", "Fetched file in base64:$data")
      }

      override fun onError(error: String?) {
          Log.d("VideoSDK", "Error in fetch file: $error")
      }
  })
}
```

</TabItem>

<TabItem value="Java">

```js
private void fetchFile() {
  String url = "<Your FileUrl>";  // Provide fileUrl which is returned by uploadBase64File()
  String token = "<VIDEOSDK_TOKEN>";
  meeting.fetchBase64File(url, token, new TaskCompletionListener<String, String>() {
      @Override
      public void onComplete(@Nullable String data) {
          Log.d("VideoSDK", "Fetched file in base64:" + data);
      }

      @Override
      public void onError(@Nullable String error) {
          Log.d("VideoSDK", "Error in fetch file: " + error);
      }
  });
}
```

</TabItem>

</Tabs>


:::note

The file stored in the system will be automatically deleted once the current room/meeting comes to an end.

:::

### API Reference

The API references for all the methods and events utilised in this guide are provided below.

- [uploadBase64File()](/android/api/sdk-reference/meeting-class/methods#uploadbase64file)
- [fetchBase64File()](/android/api/sdk-reference/meeting-class/methods#fetchbase64file)

---

---
title: Whiteboard - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: Whiteboard is a digital canvas that allows users to collaborate in real-time by drawing, writing, and sharing ideas visually, making it ideal for brainstorming, presentations, and teamwork.
sidebar_label: Start/Stop Whiteboard
pagination_label: Start/Stop Whiteboard
keywords:
  - Start Livestream meeting
  - Stop Livestream meeting
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg2
sidebar_position: 1
slug: whiteboard
---

# Whiteboard - Android

The Whiteboard is an interactive, shared canvas that enables users to collaborate in real-time within your Android application. It allows multiple participants to draw, write, and add annotations simultaneously, making it ideal for meetings, presentations, brainstorming sessions, and other collaborative activities.

This documentation will guide you on how to start and stop the whiteboard, and handle the necessary events to ensure a smooth user experience.

## `startWhiteboard()`

- To start the whiteboard session, you can call the `startWhiteboard()` method of the `meeting` class, which initializes the whiteboard and makes it available for user interaction.

### Events associated with startWhiteboard

- All participants will receive the `onWhiteboardStarted` event from the `MeetingEventListener` when the whiteboard starts successfully. This event provides a URL that can be used to render and interact with the whiteboard within the app.

- The whiteboard URL can be displayed using a `WebView` component, allowing participants to interact seamlessly within the app. For detailed instructions on rendering the whiteboard, refer to this [guide](/android/guide/video-and-audio-calling-api-sdk/collaboration-in-meeting/render-whiteboard).


import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
val meetingEventListener = object : MeetingEventListener() {
    override fun onWhiteboardStarted(url: String) {
        super.onWhiteboardStarted(url)
        //...
    }
    //...
    meeting!!.addEventListener(meetingEventListener)
}
```

</TabItem>

<TabItem value="Java">

```js
final MeetingEventListener meetingEventListener = new MeetingEventListener() {
    @Override
    public void onWhiteboardStarted(String url) {
        super.onWhiteboardStarted(url);
        //...
    }
    //...
    meeting!!.addEventListener(meetingEventListener)
};
```

</TabItem>

</Tabs>

## `stopWhiteboard()`

- To end the whiteboard session, you can call the `stopWhiteboard()` method of the `meeting` class, which terminates the active whiteboard and cleans up any resources associated with it.

### Events associated with stopWhiteboard

- All participants will receive the `onWhiteboardStopped` event from the `MeetingEventListener` when the whiteboard session is successfully terminated. This event signals that the whiteboard is no longer available for interaction within the app.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
val meetingEventListener = object : MeetingEventListener() {
    override fun onWhiteboardStopped() {
        super.onWhiteboardStopped()
        //...
    }
    //...
    meeting!!.addEventListener(meetingEventListener)
}
```

</TabItem>

<TabItem value="Java">

```js
final MeetingEventListener meetingEventListener = new MeetingEventListener() {
    @Override
    public void onWhiteboardStopped() {
        super.onWhiteboardStopped();
        //...
    }
    //...
    meeting!!.addEventListener(meetingEventListener)
};
```

</TabItem>

</Tabs>


## API Reference

- [startWhiteboard()](/android/api/sdk-reference/meeting-class/methods#startwhiteboard)
- [stopWhiteboard()](/android/api/sdk-reference/meeting-class/methods#stopwhiteboard)
- [onWhiteboardStarted()](/android/api/sdk-reference/meeting-class/meeting-event-listener-class#onwhiteboardstarted)
- [onWhiteboardStopped()](/android/api/sdk-reference/meeting-class/meeting-event-listener-class#onwhiteboardstopped)




---

---
title: VideoView Video & Audio Call - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: VideoView component quick integrate in Android with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: VideoView
pagination_label: VideoView
keywords:
  - SurfaceViewRender
  - VideoView
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: videoView
---

import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>

# What is SurfaceViewRender ?

`SurfaceViewRender` is a very powerful component of `WebRTC` since it is used to display the video stream on a SurfaceView. You can use `SurfaceViewRender` to show video of participant in your screen.

Here's the lifecycle of a SurfaceViewRenderer:

<div style={{textAlign: 'center'}}>

<img style={{height: '200px'}} src="/img/android/VideoView/life-cycle.png" />

</div>

Which means:

1. The SurfaceViewRenderer must be first initialised after being created and before it can be use at all. It starts a render thread.

2. `addSink()` needs to be called when you are having VideoTrack to render. addSink is method of `VideoTrack` that you want to add to it. You have to pass `surfaceViewRender` as parameter.

3. `removeSink()` should only be called when you're done showing the video. Another method of `VideoTrack`, and it takes the `surfaceViewRenderer` as a parameter.

4. Release at last to allow the render thread to terminate. This function should be called before the activity is destroyed and/or before init it again.

#### Mistakes you might make and stuck :

###### 1. Not initialised surfaceViewRender

The video never appears since a render thread was never start and you will see black view.

###### 2. Init it again before releasing it.

If you are not releasing surfaceViewRender before calling `init()` again, you will get this error.

```js
java.lang.IllegalStateException: svrParticipant Already initialized
        at org.webrtc.EglRenderer.init(EglRenderer.java:212)
```

###### 3. Two videos render on same SurfaceViewRender

If you called `addSink()` on the same `SurfaceViewRenderer` for two different tracks and did not call `removeSink` before that, then you will see two different videos on same SurfaceViewRenderer with flickers which would look like this :

import ReactPlayer from 'react-player'

<div style={{textAlign: 'center'}}>

<ReactPlayer controls url="/img/android/VideoView/android-flicker.mp4" height="500px" width={"100%"} />

</div>

<br/>

Too complicated right? However, VideoSDK makes it simple for you. You can use `VideoView` instead of `SurfaceViewRenderer`.

:::info

- If you want to use `VideoView`, please update SDK version to `0.1.13` or higher.

:::

### VideoView

`VideoView` provides a better abstraction to render live video and handles edge cases like managing init state, render more than one videos on same surfaceViewRender.

### Methods

1. **addTrack(VideoTrack videoTrack)** - `addTrack` will initialised SurfaceViewRender for you and render videoTrack that you provided.

2. **removeTrack()** - `removeTrack` should only be called when you're done showing the video.

3. **releaseSurfaceViewRenderer()** - `releaseSurfaceViewRenderer` should be called before the activity is destroyed.

#### How to use VideoView ?

##### Layout

```js
// <org.webrtc.SurfaceViewRenderer
//        android:id="@+id/svrParticipant"
//        android:layout_width="match_parent"
//        android:layout_height="match_parent" />

<live.videosdk.rtc.android.VideoView
  android:id="@+id/participantView"
  android:layout_width="match_parent"
  android:layout_height="match_parent"
/>
```

##### Initalising and adding video track

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
// svrParticipant.init(PeerConnectionUtils.getEglContext(), null)
// var track = stream.getTrack() as VideoTrack
// track!!.addSink(svrParticipant)

val track = stream.track as VideoTrack
participantView!!.addTrack(track);
```

</TabItem>

<TabItem value="Java">

```js
// svrParticipant.init(PeerConnectionUtils.getEglContext(), null);
// VideoTrack track = (VideoTrack) stream.getTrack();
// track.addSink(svrParticipant);

VideoTrack track = (VideoTrack) stream.getTrack();
participantView.addTrack(track);
```

</TabItem>

</Tabs>

##### removeTrack

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
// var track = stream.track as VideoTrack
// track!!.removeSink(svrParticipant);

participantView.removeTrack();
```

</TabItem>

<TabItem value="Java">

```js
// VideoTrack track = (VideoTrack) stream.getTrack();
// if (track != null) track.removeSink(svrParticipant);

participantView.removeTrack();
```

</TabItem>

</Tabs>

#### release

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
override fun onDestroy() {
        participantView.releaseSurfaceViewRenderer()
        super.onDestroy()
}
```

</TabItem>

<TabItem value="Java">

```js
@Override
protected void onDestroy() {
    participantView.releaseSurfaceViewRenderer();
    super.onDestroy();
}
```

</TabItem>

</Tabs>


---

---
sidebar_label: Concept And Architecture
pagination_label: Concept And Architecture
---

# Concept and Architecture - Android

Before diving into the concept, let's understand the VideoSDK, VideoSDK is a software development kit that offers tools and APIs for creating apps that are based on video and audio. It typically includes features such as video and audio calls, chat, cloud recording, simulcasting (RTMP), interactive live streaming (HLS), and many more across a wide range of platforms and devices.

## Concepts

![img.png](../../../../static/img/room-concept.png)

### `1. Meeting / Room`

- Meeting or Room object in the VideoSDK provide a virtual place for participants to interact and engage in real-time voice, video, and screen-sharing sessions. The object is in charge of handling media streams and participant communication.

- Meeting or Room can be uniquely identified by `meetingId` or `roomId`.

### `2. Participant`

- Participant is a VideoSDK object that represents each user/client in the meeting or room and allows them to share audio/video assets.

- `2.1 Local Participant` :
  The local participant is the one that runs on the user's device. The local participant has control over their own media streams, including the ability to start and stop audio and video.

  - The local participant in a meeting/room can also connect with other participants by transmitting and receiving audio and video streams, exchanging chat messages, and more.

- `2.2 Remote Participant` :
  The remote participant receives audio and video streams from the local participant and other remote participants and also has the ability to exchange audio, video, and chat messages with the local participant.

- Each participant in VideoSDK can be uniquely identified by `participantId`.

### `3. MediaStream & Track`

- A mediastream is a collection of audio & video tracks that can be transmitted between participants in real-time.

- A track is a continuous flow of audio or video data and can be thought of as a stream of media frames.

- A mediastream can contain multiple tracks. One video track for the video feed from the camera and one audio track for the audio feed from the microphone. These tracks can be transmitted between participants in VideoSDK Meeting / Room.

### `4. Events / Notifications`

- Events / Notifications can be used to inform users about various activities happening in a Meeting / Room, including participant join/leave and new messages. They can also be used to alert users about any SDK-level errors that occur during a call.

### `5. Session`

- A Session is the instance of an ongoing meeting/room which has one or more participants in it. A single room or meeting can have multiple sessions.
- Each session can be uniquely identified by `sessionId`.

![img.png](../../../../static/img/meeting-session.jpg)

---

![img.png](../../../../static/img/recording-hls-rtmp.png)

### `6. Cloud Recording`

- Cloud recording in VideoSDK refers to the process of recording audio or video content and storing it on a remote server or VideoSDK server.

### `7. Simulcasting (RTMP)`

- RTMP is a popular protocol for live streaming video content from a VideoSDK to platforms such as YouTube, Twitch, Facebook, and others.
- By providing the platform-specific `stream key` and `stream URL`, the VideoSDK can connect to the platform's RTMP server and transmit the live video stream.

### `8. Http Live Streaming (HLS)`

- Interactive live streaming (HLS) refers to a type of live streaming where viewers can actively engage with the content being streamed and with other viewers in real-time.

- In an interactive live stream (HLS), viewers can take part in a variety of activities like live polling, Q&A sessions, and even sending virtual gifts to the content creator or each other.

## Architecture

This diagram demonstrates end-to-end flow to implement video & audio calls, record calls, and go live on social media.

![Video-sdk-architecture!](/img/video-sdk-archietecture.svg)


---

---
title: Mute All Participants | Video SDK
hide_title: true
hide_table_of_contents: false
description: Video SDK and Audio SDK, developers need to implement a token server. This requires efforts on both the front-end and backend.
sidebar_label: Mute All Participants
pagination_label: Mute All Participants
keywords:
  - audio calling
  - video calling
  - real-time communication
  - collaboration
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: mute-all-participants
---

# Mute All Participants - Android

If you are the host or moderator of a video conference, you may want to mute all the participants at once. This can be useful in various scenarios, such as when you want to deliver a presentation or when there is background noise that is causing distractions.

- To achieve this, you have to iterate over the list of participants from the `Meeting` class and call `disableMic` method from `Participant` class.

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
btnMuteAllParticipant!!.setOnClickListener { _: View? ->
  var participants: Iterator<Participant> = meeting.participants.values.iterator()
  for (i in 0 until meeting.participants.size) {
      val participant = participants.next()
      participant.disableMic()
  }
}
```

</TabItem>

<TabItem value="Java">

```js
btnMuteAllParticipant.setOnClickListener(new View.OnClickListener() {
  @Override
  public void onClick(View v) {
    final Iterator<Participant> participants = meeting.getParticipants().values().iterator();
    for (int i = 0; i < meeting.getParticipants().size(); i++) {
      final Participant participant = participants.next();
      participant.disableMic();
    }
  }
});
```

</TabItem>

</Tabs>

:::note
Participant who will be muting other participants should have permission **`allow_mod`** passed in the token. To know more about permissions [**visit here**](/android/guide/video-and-audio-calling-api-sdk/authentication-and-token).
:::

### API Reference

The API references for all the methods and events utilised in this guide are provided below.

- [disableMic()](/android/api/sdk-reference/participant-class/methods#disablemic)


---

---
title: Toggle Remote Participant Media | Video SDK
hide_title: true
hide_table_of_contents: false
description: Video SDK and Audio SDK, developers need to implement a token server. This requires efforts on both the front-end and backend.
sidebar_label: Toggle Remote Participant Media
pagination_label: Toggle Remote Participant Media
keywords:
  - audio calling
  - video calling
  - real-time communication
  - collaboration
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: remote-participant-media
---

# Toggle Remote Participant Media - Android

When hosting a meeting, it's important that the host of the meeting should be able to request someone's Mic or Camera to be turned on or should be able to turn them off.

:::note
Participant who will be controlling other participant's mic and camera should have permission **`allow_mod`** passed in the token. To know more about permissions [**visit here**](/android/guide/video-and-audio-calling-api-sdk/authentication-and-token).
:::

Before we discuss the methods and events associated with this functionality, here is how the flow would look like.

![img1](../../../../../static/img/toggle-remote-media.png)

## Methods

### `enableMic()`

- If you wish to turn **on** the microphone of a participant, you will be calling the `enableMic()` from the `Participant` class.

- When this method is called, the participant whose microphone is requested will receive the `onMicRequested` event with the `participantId` of the participant who requested it and two callback functions `accept` and `reject` which should be called based on decision made by the user.

- **Example:** Meeting is running with **Participant A** and **Participant B**. Now **Participant A** wants to Enable Mic of **Participant B**, so **Participant A** will use `enableMic()` function to request **Participant B**, after that **Participant B** recieve the `onMicRequested` event, from there user can either accept or reject the incoming request.

### `enableWebcam()`

- If you wish to turn **on** the camera of a participant, you will be calling the `enableWebcam()` from the `Participant` class.

- When this method is called, the participant whose camera is requested will receive the `onWebcamRequested` event with the `participantId` of the participant who requested it and two callback functions `accept` and `reject` which should be called based on decision made by the user.

- **Example:** Meeting is running with **Participant A** and **Participant B**. Now **Participant A** wants to Enable Webcam of **Participant B**, so **Participant A** will use `enableWebcam()` function to request **Participant B**, after that **Participant B** recieve the `onWebcamRequested` event, from there user can either accept or reject the incoming request.

### `disableMic()`

- If you wish to turn **off** the microphone of a participant, you will be calling the `disableMic()` from the `Participant` class.
- This will disable the microphone of the participant.

### `disableWebcam()`

- If you wish to turn **off** the camera of a participant, you will be calling the `disableWebcam()` from the `Participant` class.
- This will disable the camera of the participant.

#### Example

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
btnEnableWebcam!!.setOnClickListener { _: View? ->
  // This will emit an event called "onWebcamRequested" to that particular participant
  participant!!.enableWebcam()
}

btnEnableMic!!.setOnClickListener { _: View? ->
  // This will emit an event called "onMicRequested" to that particular participant
  participant!!.enableMic()
}

btnDisableWebcam!!.setOnClickListener { _: View? ->
  // This will disable the webcam of that particular participant
  participant.disableWebcam()
}

btnDisableWebcam!!.setOnClickListener { _: View? ->
  // This will disable the mic of that particular participant
  participant.disableMic()
}
```

</TabItem>

<TabItem value="Java">

```js
btnEnableWebcam.setOnClickListener(new View.OnClickListener() {
    @Override
    public void onClick(View v) {
      // This will emit an event called "onWebcamRequested" to that particular participant
      participant.enableWebcam();
    }
});

btnEnableMic.setOnClickListener(new View.OnClickListener() {
    @Override
    public void onClick(View v) {
      // This will emit an event called "onMicRequested" to that particular participant
      participant.enableMic();
    }
});

btnDisableWebcam.setOnClickListener(new View.OnClickListener() {
    @Override
    public void onClick(View v) {
      // This will disable the webcam of that particular participant
      participant.disableWebcam();
    }
});

btnDisableMic.setOnClickListener(new View.OnClickListener() {
    @Override
    public void onClick(View v) {
      // This will disable the mic of that particular participant
      participant.disableMic();
    }
});
```

</TabItem>

</Tabs>

## Events

### `onWebcamRequested`

This event will be emitted to the `Participant B` when any other `Participant A` requests to enable webcam of that participant (`Participant B`). This event handler will receieve following two arguments:

- `participantId` - ParticipantId of the requesting participant
- `listener`: MicRequestListener \{ accept: Method; reject: Method }

### `onMicRequested`

This event will be emitted to the `Participant B` when any other `Participant A` requests to enable mic of that participant (`Participant B`). This event handler will receieve following two arguments:

- `participantId` - ParticipantId of the requesting participant
- `listener`: MicRequestListener \{ accept: Method; reject: Method }

###### Usage

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
override fun onMicRequested(participantId: String, listener: MicRequestListener) {
  // callback function to accept the request
  listener.accept()

  // callback function to reject the request
  listener.reject()
}

override fun onWebcamRequested(participantId: String, listener: WebcamRequestListener) {
  // callback function to accept the request
  listener.accept()

  // callback function to reject the request
  listener.reject()
}
```

</TabItem>

<TabItem value="Java">

```javascript
@Override
public void onMicRequested(String participantId, MicRequestListener listener) {
  // callback function to accept the request
  listener.accept();

  // callback function to reject the request
  listener.reject();
}

@Override
public void onWebcamRequested(String participantId, WebcamRequestListener listener) {
  // callback function to accept the request
  listener.accept();

  // callback function to reject the request
  listener.reject();
}
```

</TabItem>

</Tabs>

## API Reference

The API references for all the methods and events utilised in this guide are provided below.

- [enableMic()](/android/api/sdk-reference/participant-class/methods#enablemic)
- [disableMic()](/android/api/sdk-reference/participant-class/methods#disablemic)
- [enableWebcam()](/android/api/sdk-reference/participant-class/methods#enablewebcam)
- [disableWebcam()](/android/api/sdk-reference/participant-class/methods#disablewebcam)
- [onMicRequested()](/android/api/sdk-reference/meeting-class/meeting-event-listener-class#onmicrequested)
- [onWebcamRequested()](/android/api/sdk-reference/meeting-class/meeting-event-listener-class#onwebcamrequested)


---

---
title: Remove participant from the meeting - React JS SDK
hide_title: false
hide_table_of_contents: false
description: Remove a participant or a peer from the meeting while it is still in progress. It helps in meeting moderation.
sidebar_label: Remove Participant
pagination_label: Remove Participant
keywords:
  - remove participant
  - block participant
  - react js
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: remove-participant
---

# Remove Participant - Android

This feature in a meeting allows the meeting host or organizer to remove a participant from the meeting. This can be helpful in situations where a participant is causing a disturbance, is behaving inappropriately, or is not following meeting guidelines.

VideoSDK provide three ways to remove participant from meeting.

1. [Using SDK](#1-using-sdk)
2. [Using VideoSDK Dashboard](#2-using-videosdk-dashboard)
3. [Using Rest API](#3-using-rest-api)

## 1. Using SDK

### `remove()`

Remove participant allows removing participant while session is on-going. This can be helpful when moderation in particular meeting is required.

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
btnRemoveParticipant!!.setOnClickListener { _: View? ->
  val remoteParticipantId = "<participant-id>"
  // Get specific participant instance
  val participant = meeting!!.participants[remoteParticipantId]
  // Remove participant from active session
  // This will emit an event called "onParticipantLeft" for that particular participant
  participant!!.remove()
}
```

</TabItem>

<TabItem value="Java">

```js
btnRemoveParticipant.setOnClickListener(new View.OnClickListener() {
  @Override
  public void onClick(View v) {
    String remoteParticipantId = "<participant-id>";
    // Get specific participant instance
    Participant participant = meeting.getParticipants().get(remoteParticipantId);
    // Remove participant from active session
    // This will emit an event called "onParticipantLeft" for that particular participant
    participant.remove();
  }
});
```

</TabItem>

</Tabs>

### Events associated with remove

Following callbacks are received when a participant is removed from the meeting.

- Participant who was removed from the meeting will receive a callback on[`onMeetingLeft`](/android/api/sdk-reference/meeting-class/meeting-event-listener-class#onmeetingleft).
- All other [remote participants](../concept-and-architecture#2-participant) will receive a callback [`onParticipantLeft`](/android/api/sdk-reference/meeting-class/meeting-event-listener-class#onparticipantleft) with Participant object.

## 2. Using VideoSDK Dashboard

- You can go the session page on [VideoSDK Dashboard](https://app.videosdk.live/meetings/sessions) and select the meeting you can to remove a participant from.
- And then from the participants list you can remove any participant you want.

import ReactPlayer from 'react-player'

<div style={{textAlign: 'center'}}>

<ReactPlayer autoplay muted loop playing url='/video/kickout-user.mp4' width={"100%"}/>

</div>

## 3. Using Rest API

- You can also remove the particular participant from the meeting [using the REST API](/api-reference/realtime-communication/remove-participant).
- To use this method, you should have the `sessionId` of the meeting and `participantId` of the participant who is supposed to be removed.

## API Reference

The API references for all the methods and events utilised in this guide are provided below.

- [remove()](/android/api/sdk-reference/participant-class/methods#remove)
- [onMeetingLeft()](/android/api/sdk-reference/meeting-class/meeting-event-listener-class#onmeetingleft)
- [onParticipantLeft()](/android/api/sdk-reference/meeting-class/meeting-event-listener-class#onparticipantleft)


---

---
title: Integrate Banuba SDK with Android SDK - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: Describes how to integrate Banuba SDK with videosdk.live using Android SDK to enhance video calls with real-time face filters and virtual backgrounds.
sidebar_label: "Banuba Integration"
pagination_label: "Banuba Integration"
keywords:
  - android sdk
  - java sdk
  - kotlin sdk
  - banuba
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: banuba-integration
---

import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>

# How to intergrate Banuba SDK with Android Video SDK?

Use Banuba SDK with Android SDK to enhance video calls with real-time face filters and virtual backgrounds.

### Step 1: Banuba Token

- To start working with the Banuba SDK into your project, you need to have the client token. To receive the client token please fill form on [banuba.com](https://www.banuba.com/)

### Step 2: Add Banuba SDK dependencies

- With the client token, you will also receive the Banuba SDK archive for Android which contains Banuba Effect Player (compiled Android library project with .aar extension), Banuba SDK (compiled Android library project with .aar extension) and example filters located under effects folder.

- Create `libs` directory in your project and add `banuba_effect_player.aar`, `banuba_sdk.aar` files.

<div style={{textAlign: 'center'}}>

![Banuba SDK dependency .aar files](/img/android/banuba/banuba_dependency.png)

</div>

- Open build.gradle (Module: app) and add Banuba SDK dependencies.

```js title="app/build.gradle"
dependencies {
  // Banuba SDK dependencies
   implementation fileTree(dir: 'libs', include: ['*.aar'])

  // other app dependencies
  }
```

### Step 3: Add effects into your project

- Create `effects` folder under `assets` directory in your project and add filters that you want to use in the `effects` folder.You can download test effects here: [Effects](https://docs.banuba.com/face-ar-sdk-v1/overview/demo_face_filters)

<div style={{textAlign: 'center'}}>

![Banuba SDK effects folder](/img/android/banuba/banuba_effects.png)

</div>

### Step 4: Integrate Banuba

1. Create one interface named `IVideoFrameProcessor` and a class named `BanubaProcessor` in your project and copy paste code from the [example](https://github.com/videosdk-live/videosdk-rtc-android-sdk-banuba-example).

2. Update your Banuba client token into `BanubaProcessor.java` file.

```js title="BanubaProcessor.java"
public class BanubaProcessor implements IVideoFrameProcessor {
    //...
    public static final String KEY = "place_your_token_here";
    //...
}
```

3. Create instance of `CapturerObserver` class and pass into VideoSDK.createCameraVideoTrack() method. To know more about createCameraVideoTrack() method please visit [CustomVideoTrack](../features/custom-track/custom-video-track.md).

4. Copy paste method named `initVideoFrameProcessor(VideoSource videosource,CustomStreamTrack videoCustomTrack)` from the [example](https://github.com/videosdk-live/videosdk-rtc-android-sdk-banuba-example). into your Activity and call it after creating `CustomStreamTrack` for video.

### Step 5: Use filters in Meeting

- If you want to use video filters from start of the meeting, you can pass `CustomStreamTrack` in the `initMeeting`.

- Also you can use video filters during the meeting by passing the `CustomStreamTrack` in the `enableWebcam()` method of Meeting.

:::tip

Stuck anywhere? Check out this [Code Sample of Banuba Intergation with Android-SDK](https://github.com/videosdk-live/videosdk-rtc-android-sdk-banuba-example.git) on GitHub

:::


---

---
title: Camera Controls Video & Audio Call - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: Camera Controls features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Camera Controls
pagination_label: Camera Controls
keywords:
  - Camera on
  - Camera off
  - Webcam on
  - Webcam off
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: camera-controls
---

import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>

# Camera Controls - Android

Whenever any participant wants to start/stop broadcasting their video to other participant in a meeting, they can simply do it with VideoSDK Meeting.

This guide will provide an overview of how to implement enable, disable and switch webcam features in a meeting.

1. **Enable Camera** - By using `enableWebcam()` function, a participant can publish camera stream to other participants.
2. **Disable Camera** - By using `disableWebcam()` function, a participant can stop publishing camera stream to other participants.
3. **Switch Camera** - By using `changeWebcam()` function, a participant can stream from front / rear camera during the meeting.This function is only applicable for Mobile devices.

### Enable, Disable And Switch Webcam

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
  btnWebcam!!.setOnClickListener {

    // Toggle participant webcam in meeting
    if (webcamEnabled) {
      meeting!!.disableWebcam()
    } else {
      meeting!!.enableWebcam()
    }

    // Change Webcam in Meeting
    meeting!!.changeWebcam()
  }
```

</TabItem>

<TabItem value="Java">

```js
  btnWebcam.setOnClickListener(new View.OnClickListener() {
      @Override
      public void onClick(View v) {

        // Toggle participant webcam in meeting
        if (webcamEnabled) {
          meeting.disableWebcam();
        } else {
          meeting.enableWebcam();
        }

         // Change Webcam in Meeting
        meeting.changeWebcam();
      }
  });
```

</TabItem>

</Tabs>

### Events

**Event associated with `enableWebcam()`:**

- Every Participant will receive a callback on [`onStreamEnabled()`](../../../api/sdk-reference/participant-class/participant-event-listener-class.md#onstreamenabled) of the [`Participant`](../../../api/sdk-reference/participant-class//introduction.md) with `Stream` object.

**Event associated with `disableWebcam()`:**

- Every Participant will receive a callback on [`onStreamDisabled()`](../../../api/sdk-reference/participant-class/participant-event-listener-class.md#onstreamenabled) of the [`Participant`](../../../api/sdk-reference/participant-class//introduction.md) with `Stream` object.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
  meeting!!.localParticipant.addEventListener(object : ParticipantEventListener() {
    override fun onStreamEnabled(stream: Stream) {
        //

        if(stream.getKind().equals("video")){
          //participant turned on video
          //Render participant video
        }
    }

    override fun onStreamDisabled(stream: Stream) {
        //

        if(stream.getKind().equals("video")){
          //participant turned off video
          //remove participant video
        }
    }
  });
```

</TabItem>

<TabItem value="Java">

```js
  participant.addEventListener(new ParticipantEventListener() {
    @Override
    public void onStreamEnabled(Stream stream) {
        //
        if(stream.getKind().equals("video")){
          //participant turned on video
          //Render participant video
        }
    }

    @Override
    public void onStreamDisabled(Stream stream) {
        //
        if(stream.getKind().equals("video")){
          //participant turned off video
          //remove participant video
        }
    }
  });
```

</TabItem>

</Tabs>


---

---
title: Custom Audio Track
hide_title: false
hide_table_of_contents: false
description: Custom Audio Track features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Custom Audio Track
pagination_label: Custom Audio Track
keywords:
  - Camera on
  - Camera off
  - Webcam on
  - Webcam off
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
---

import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>

# Custom Audio Track - React Native

We have introduced the ability to pass a custom Audio track for the Audio of the participants with different encoder configuration.

## Creating a Custom Audio Track

- You can create a Audio Track using `createAudioTrack()` method of `VideoSDK`.
- This method can be used to create audio track using different encoding parameters.

### Parameters

- **encoderConfig**:

  - type: `String`
  - required: `true`
  - default: `speech_standard`
  - Allowed values : `speech_low_quality` | `speech_standard` | `music_standard` | `standard_stereo` | `high_quality` | `high_quality_stereo`
  - It will be the encoder configuration you want to use for Audio Track.

- **context**

  - type: `Context`
  - required: `true`
  - Pass the Android Context for this parameter.

#### Returns

- `CustomStreamTrack`

### Example

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
try {
  val audioCustomTrack: CustomStreamTrack = VideoSDK.createAudioTrack("high_quality",this)
} catch (e: JSONException) {
   e.printStackTrace()
}
```

</TabItem>

<TabItem value="Java">

```js
try {
  CustomStreamTrack audioCustomTrack=VideoSDK.createAudioTrack("high_quality", this);
}catch (JSONException e) {
  e.printStackTrace();
}
```

</TabItem>

</Tabs>

## Using Custom Audio Track

### Custom Track while initializing the meeting

If you are passing `micEnabled: true` in the `initMeeting` of `VideoSDK` and want to use custom tracks from start of the meeting, you can pass custom track in the `initMeeting` as shown below.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
override fun onCreate(savedInstanceState: Bundle?) {
    //..

    val customTracks: MutableMap<String, CustomStreamTrack> = HashMap()

    val audioCustomTrack: CustomStreamTrack = VideoSDK.createAudioTrack("high_quality", this)
    customTracks["mic"] = audioCustomTrack  //Key must be "mic"

    // create a new meeting instance
    val meeting = VideoSDK.initMeeting(
      this@MainActivity,meetingId,participantName,
      //MicEnabled , If true, it will use the passed custom track to turn mic on
      true,
      //WebcamEnabled
      true,
      //ParticipantId
      null,
      //Mode
      null,
      //Pass the custom tracks here
      customTracks
    )
}
```

</TabItem>

<TabItem value="Java">

```js
@Override
protected void onCreate(Bundle savedInstanceState) {
    //..

    Map<String, CustomStreamTrack> customTracks = new HashMap<>();

    CustomStreamTrack audioCustomTrack = VideoSDK.createAudioTrack("high_quality", this);
    customTracks.put("mic", audioCustomTrack);  //Key must be "mic"

    // create a new meeting instance
    Meeting meeting = VideoSDK.initMeeting(
        MainActivity.this, meetingId, participantName,
       //MicEnabled , If true, it will use the passed custom track to turn mic on
        true,
        //WebcamEnabled
        true,
        //ParticipantId
        null,
        //Mode
        null,
        //Pass the custom tracks here
        customTracks
    );

}
```

</TabItem>

</Tabs>

### Custom Track with `unmuteMic()`

In order to switch tracks during the meeting, you have to pass the `CustomStreamTrack` in the `unmuteMic()` method of `Meeting`.

You can also pass custom track in `changeMic()` method of `Meeting`.

:::note

Make sure to call `muteMic()` before you create a new track as it may lead to unexpected behavior.

:::

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
try {
  val audioCustomTrack: CustomStreamTrack = VideoSDK.createAudioTrack("high_quality", this)
  meeting!!.unmuteMic(audioCustomTrack)

  //or
  meeting!!.changeMic(AppRTCAudioManager.AudioDevice.BLUETOOTH, audioCustomTrack)
} catch (e: JSONException) {
  e.printStackTrace()
}

```

</TabItem>

<TabItem value="Java">

```js
try {
  CustomStreamTrack audioCustomTrack = VideoSDK.createAudioTrack("high_quality", this);
  meeting.unmuteMic(audioCustomTrack);

  //or
  meeting.changeMic(AppRTCAudioManager.AudioDevice.BLUETOOTH,audioCustomTrack);
}catch (JSONException e) {
  e.printStackTrace();
}

```

</TabItem>

</Tabs>


---

---
title: Custom Screen Share Track
hide_title: false
hide_table_of_contents: false
description: Custom Screen Share Track features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Custom Screen Share Track
pagination_label: Custom Screen Share Track
keywords:
  - Camera on
  - Camera off
  - Webcam on
  - Webcam off
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
---

import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>

# Custom Screen Share Track - React Native

We have introduced the ability to pass a custom Screen Share track while sharing the screen of participants. This feature can be used to add custom video encoder config,background removal & video filter from external SDK(e.g., [Banuba](https://www.banuba.com/)) and send it to other participants.

## Creating a Custom Screen Share Track

- You can create a Screen Share track using `createScreenShareVideoTrack()` method of `VideoSDK`.
- This method can be used to create screen share track using different encoding parameters.

### Parameters

- **encoderConfig**:

  - type: `String`
  - required: `true`
  - default: `h720p_15fps`
  - Allowed values : `h360p_30fps` | `h720p_5fps` | `h720p_15fps` | `h1080p_15fps` | `h1080p_30fps`
  - It will be the encoderConfigs you can want to use for the Screen Share Track.

:::note

Above mentioned encoder configurations are valid for both, landscape as well as portrait mode.

:::

- **data**

  - type: `Intent`
  - required: `true`
  - It is Intent received from onActivityResult when user provide permission for ScreenShare.

- **context**

  - type: `Context`
  - required: `true`
  - Pass the Android Context for this parameter.

- **listener**
  - type: `CustomTrackListener`
  - required: `true`
  - Callback to this listener will be made when track is ready with CustomTrack as parameter.

### Example

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
// data is received from onActivityResult method.
VideoSDK.createScreenShareVideoTrack("h720p_5fps", data, this) { track ->
    meeting!!.enableScreenShare(track)
}
```

</TabItem>

<TabItem value="Java">

```javascript
// data is received from onActivityResult method.
VideoSDK.createScreenShareVideoTrack("h720p_5fps", data, this, (track)->{
    meeting.enableScreenShare(track);
});
```

</TabItem>

</Tabs>

## Using Custom Screen Share Track

### Custom Track with `enableScreenShare()`

In order to switch tracks during the meeting, you have to pass the `CustomStreamTrack` in the `enableScreenShare()` method of `Meeting`.

:::note

Make sure to call `disableScreenShare()` before you create a new track as it may lead to unexpected behavior.

:::

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
@TargetApi(21)
private fun askPermissionForScreenShare() {
    val mediaProjectionManager = application.getSystemService<Any>(
        Context.MEDIA_PROJECTION_SERVICE
    ) as MediaProjectionManager
    startActivityForResult(
        mediaProjectionManager.createScreenCaptureIntent(), CAPTURE_PERMISSION_REQUEST_CODE
    )
}

@RequiresApi(api = Build.VERSION_CODES.LOLLIPOP)
override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) {
    super.onActivityResult(requestCode, resultCode, data)
    if (requestCode != CAPTURE_PERMISSION_REQUEST_CODE) return
    if (resultCode == RESULT_OK) {
        VideoSDK.createScreenShareVideoTrack("h720p_5fps", data, this) { track ->
            meeting!!.enableScreenShare(track)
        }
    }
}

```

</TabItem>

<TabItem value="Java">

```javascript
@TargetApi(21)
private void askPermissionForScreenShare() {
    MediaProjectionManager mediaProjectionManager =
        (MediaProjectionManager) getApplication().getSystemService(
            Context.MEDIA_PROJECTION_SERVICE);
    startActivityForResult(
        mediaProjectionManager.createScreenCaptureIntent(), CAPTURE_PERMISSION_REQUEST_CODE);
}

@RequiresApi(api = Build.VERSION_CODES.LOLLIPOP)
@Override
public void onActivityResult(int requestCode, int resultCode, Intent data) {
    super.onActivityResult(requestCode, resultCode, data);
    if (requestCode != CAPTURE_PERMISSION_REQUEST_CODE)
        return;
    if (resultCode == Activity.RESULT_OK) {
        VideoSDK.createScreenShareVideoTrack("h720p_5fps", data, this, (track)->{
            meeting.enableScreenShare(track);
        });
    }
}

```

</TabItem>

</Tabs>


---

---
title: Custom Video Track
hide_title: false
hide_table_of_contents: false
description: Custom Video Track features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Custom Video Track
pagination_label: Custom Video Track
keywords:
  - Camera on
  - Camera off
  - Webcam on
  - Webcam off
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
---

import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>

# Custom Video Track - React Native

We have introduced the ability to pass a custom video track for the video of the participants. This feature can be used to add custom video encoder config, optimization mode (whether you want to focus on **motion**, **text** or **detail** of the video) and background removal & video filter from external SDK(e.g., [Banuba](https://www.banuba.com/))and send it to other participants.

## Creating a Custom Video Track

- You can create a Video Track using `createCameraVideoTrack()` method of `VideoSDK`.
- This method can be used to create video track using different encoding parameters & camera facing mode.

### Parameters

- **encoderConfig**:

  - type: `String`
  - required: `true`
  - default: `h480p_w640p`
  - Allowed values : `h144p_w176p` | `h240p_w320p` | `h480p_w640p` | `h480p_w720p` | `h720p_w960p` | `h1080p_w1440p` | `h720p_w1280p`
  - It will be the encoderConfigs you can want to use for the Video Track.

:::note

Above mentioned encoder configurations are valid for both, landscape as well as portrait mode.

:::

- **facingMode**:

  - type: `String`
  - required: `true`
  - Allowed values : `front` | `back`
  - It will specify wheater to use front or back camera for the video track.

- **optimizationMode**

  - type: `CustomStreamTrack.VideoMode`
  - required: `true`
  - Allowed values: `motion` | `text` | `detail`
  - It will specify the optimization mode for the video track being generated.

- **context**:

  - type: `Context`
  - required: `true`
  - Pass the Android Context for this parameter.

- **observer**:

  - type: `CapturerObserver`
  - required: `false`
  - If you want to use video filter from external SDK(e.g., [Banuba](https://www.banuba.com/)) then pass instance of `CapturerObserver` in this parameter.

:::note

For Banuba integraion with VideoSDK, please visit [Banuba Intergation with VideoSDK](../../video-processor/banuba-integration.md)

:::

#### Returns

- `CustomStreamTrack`

### Example

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
val videoCustomTrack: CustomStreamTrack = VideoSDK.createCameraVideoTrack("h240p_w320p", "front", CustomStreamTrack.VideoMode.MOTION, this)
```

</TabItem>

<TabItem value="Java">

```javascript
CustomStreamTrack customStreamTrack = VideoSDK.createCameraVideoTrack("h240p_w320p", "front", CustomStreamTrack.VideoMode.MOTION, this);
```

</TabItem>

</Tabs>

## Using Custom Video Track

### Custom Track while initializing the meeting

If you are passing `webcamEnabled: true` in the `initMeeting` of `VideoSDK` and want to use custom tracks from start of the meeting, you can pass custom track in the `initMeeting` as shown below.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
override fun onCreate(savedInstanceState: Bundle?) {
    //..

    val customTracks: MutableMap<String, CustomStreamTrack> = HashMap()
    val videoCustomTrack: CustomStreamTrack =
    VideoSDK.createCameraVideoTrack("h240p_w320p", "back", false, CustomStreamTrack.VideoMode.MOTION, this)
    customTracks["video"] = videoCustomTrack  //Key must be "video"

     // create a new meeting instance
    val meeting = VideoSDK.initMeeting(
      this@MainActivity, meetingId, participantName,
      //MicEnabled
      true,
      //WebcamEnabled , If true, it will use the passed custom track to turn webcam on
      true,
      // ParticipantId
      null,
      // Mode
      null,
      //Pass the custom tracks here
      customTracks
    )
}
```

</TabItem>

<TabItem value="Java">

```js
@Override
protected void onCreate(Bundle savedInstanceState) {
    //..

    Map<String, CustomStreamTrack> customTracks = new HashMap<>();

    CustomStreamTrack videoCustomTrack = VideoSDK.createCameraVideoTrack("h240p_w320p", "back", CustomStreamTrack.VideoMode.MOTION, this);
    customTracks.put("video", videoCustomTrack);  //Key must be "video"

    // create a new meeting instance
    Meeting meeting = VideoSDK.initMeeting(
        MainActivity.this, meetingId, participantName,
       //MicEnabled
        true,
        //WebcamEnabled , If true, it will use the passed custom track to turn webcam on
        true,
        // ParticipantId
        null,
        // Mode
        null,
        //Pass the custom tracks here
        customTracks
        );
}
```

</TabItem>

</Tabs>

### Custom Track with `enableWebcam()`

In order to switch tracks during the meeting, you have to pass the `CustomStreamTrack` in the `enableWebcam()` method of `Meeting`.

:::note

Make sure to call `disableWebcam()` before you create a new track as it may lead to unexpected behavior.

:::

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
val customStreamTrack: CustomStreamTrack = VideoSDK.createCameraVideoTrack("h240p_w320p", "back", CustomStreamTrack.VideoMode.MOTION, this)
meeting!!.enableWebcam(customStreamTrack)
```

</TabItem>

<TabItem value="Java">

```javascript
CustomStreamTrack customStreamTrack=VideoSDK.createCameraVideoTrack("h240p_w320p", "back", CustomStreamTrack.VideoMode.MOTION, this);
meeting.enableWebcam(customStreamTrack);
```

</TabItem>

</Tabs>


---

---
sidebar_label: Error Event
pagination_label: Error Event
---

import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>

# Error Event - Android

This event is helpful for development level troubleshooting while integrating SDK.

Whenever any invalid configuration provided or server/network errors arise, this event will trigger with a specific error code and message.

This event can ease your development process.

We have depicted a specific constant with code and message in the below table.

| Constant                              | Code | Message                                                                                                                     |
| ------------------------------------- | ---- | --------------------------------------------------------------------------------------------------------------------------- |
| **INVALID_API_KEY**                   | 4001 | `apikey` provided in the token is empty or invalid, please verify it on the dashboard.                                      |
| **INVALID_TOKEN**                     | 4002 | `token` is empty or invalid or might have expired.                                                                          |
| **INVALID_MEETING_ID**                | 4003 | `meetingId` is empty or invalid, please verify it or generate new meetingId using the API.                                  |
| **INVALID_PARTICIPANT_ID**            | 4004 | `participantId` is empty or invalid, it shouldn't contain any whitespaces.                                                  |
| **DUPLICATE_PARTICIPANT**             | 4005 | Leaving meeting, since this `participantId` joined from another device.                                                     |
| **ACCOUNT_DEACTIVATED**               | 4006 | It seems your account is deactivated by VideoSDK for some reason, you can reach out to us at `support@videosdk.live`.       |
| **ACCOUNT_DISCONTINUED**              | 4007 | Server will respond you with specific message.\_                                                                            |
| **INVALID_PERMISSIONS**               | 4008 | `permissions` provided in the token are invalid, please don't use `allow_join` or `allow_mod` with `ask_join`.              |
| **START_RECORDING_FAILED**            | 4011 | Recording start request failed due to an unknown error.                                                                     |
| **STOP_RECORDING_FAILED**             | 4012 | Recording stop request failed due to an unknown error.                                                                      |
| **START_LIVESTREAM_FAILED**           | 4013 | Livestream start request failed due to an unknown error.                                                                    |
| **STOP_LIVESTREAM_FAILED**            | 4014 | Livestream stop request failed due to an unknown error.                                                                     |
| **MAX_SPEAKER_LIMIT_REACHED_ON_ORGANIZATION**    | 4026 | You have reached max speaker limit on organization. To increase contact at support@videosdk.live".                                                               |
| **MAX_VIEWER_LIMIT_REACHED_ON_ORGANIZATION**    | 4027 | You have reached max viewer limit on organization. To increase contact at support@videosdk.live".                                                               |
| **MAX_RECORDING_LIMIT_REACHED_ON_ORGANIZATION**    | 4028 | You have reached max limit of recording on organization. To increase contact at support@videosdk.live.                                                               |
| **MAX_HLS_LIMIT_REACHED_ON_ORGANIZATION**    | 4029 | You have reached max limit of hls on organization. To increase contact at support@videosdk.live.                                                               |
| **MAX_LIVESTREAM_LIMIT_REACHED_ON_ORGANIZATION**    | 4030 | You have reached max limit of livestream on organization. To increase contact at support@videosdk.live.                                                               |
| **INVALID_LIVESTREAM_CONFIG**         | 4015 | Livestream 'outputs' configuration provided was invalid.                                                                    |
| **PREV_RECORDING_PROCESSING**         | 4018 | Previous recording session is being processed, please try again after few seconds.                                          |
| **RECORDING_FAILED**                  | 5001 | Recording stopped due to an unknown error.                                                                                  |
| **LIVESTREAM_FAILED**                 | 5002 | Livestream stopped due to an unknown error.                                                                                 |
| **RECORDING_DURATION_LIMIT_REACHED**  | 5004 | Recording has been automatically stopped by the system, due to max duration limit of 2 hours reached for a single Recording |
| **LIVESTREAM_DURATION_LIMIT_REACHED** | 5005 | Livestream has been automatically stopped by the system, due to max duration limit of 2 hours reached for a single RTMP     |
| **HLS_DURATION_LIMIT_REACHED**        | 5006 | Hls has been automatically stopped by the system, due to max duration limit of 2 hours reached for a single HLS             |

### Event Code

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
private val meetingEventListener: MeetingEventListener = object : MeetingEventListener() {
    //..
    override fun onError(error: JSONObject) {
    try {
        val errorCodes: JSONObject = VideoSDK.getErrorCodes()
        val code = error.getInt("code")
        if (code == errorCodes.getInt("START_LIVESTREAM_FAILED")) {
            Log.d("#error", "Error is: " + error["message"])
        } else if (code == errorCodes.getInt("START_RECORDING_FAILED")) {
            Log.d("#error", "Error is: " + error["message"])
        }
    } catch (e: Exception) {
            e.printStackTrace()
        }
    }
}
```

</TabItem>

<TabItem value="Java">

```js
private final MeetingEventListener meetingEventListener = new MeetingEventListener() {
    //..
    @Override
    public void onError(JSONObject error) {
        try {
            JSONObject errorCodes = VideoSDK.getErrorCodes();
            int code = error.getInt("code");
            if (code == errorCodes.getInt("START_LIVESTREAM_FAILED")) {
                Log.d("#error", "Error is: " + error.get("message"));
            }else if(code == errorCodes.getInt("START_RECORDING_FAILED"))
            {
                Log.d("#error", "Error is: " + error.get("message"));
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
};
```

</TabItem>

</Tabs>


---

---
title: External Call Detection Video & Audio Call - Video SDK Docs
hide_title: false
hide_table_of_contents: false
sidebar_label: External Call Detection
pagination_label: External Call Detection
keywords:
  - External Call Detection
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: external-call-detection
---

import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>

# External Call Detection - Android

External call detection feature in VideoSDK let you know, participant is on the call during meeting.

Whenever local participant accept the incoming call or place outgoing call, `externalcall-started` event will trigger.`externalcall-started` event only received by localParticipant.

For example, the meeting is running with **Alice** and **Bob**. Whenever **Alice** receives the call or she call someone, **Alice** will receive `externalcall-started` event.

We can access `externalcall-started` event through [meeting object](/android/guide/video-and-audio-calling-api-sdk/features/start-join-meeting).

### externalcall-started Event

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
private val meetingEventListener: MeetingEventListener = object : MeetingEventListener() {
     // ...
    override fun onExternalCallStarted() {
      Log.d("#meeting", "onExternalCallAnswered")
    }
};
```

</TabItem>

<TabItem value="Java">

```js
private final MeetingEventListener meetingEventListener = new MeetingEventListener() {
     // ...
    @Override
    public void onExternalCallStarted() {
        Log.d("#meeting", "onExternalCallStarted");
    }
};
```

</TabItem>

</Tabs>


---

---
title: RTMP Live Social Media Video & Audio Call - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: RTMP Live Social Media features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Go Live On Social Media
pagination_label: Go Live On Social Media
keywords:
  - Facebook Live
  - Youtube Live
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: go-live-social-media
---

import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>

# Go Live On Social Media - Android

This feature allows participant to broadcast meeting on various social media platforms such as Facebook or Youtube.
This guide will provide an overview of how participant can start and stop broadcasting meeting.

1. **Start LiveStream** - By using `startLivestream()` function, a participant can start broadcasting meeting on various platforms by provding url and stream keys as an argument.
2. **Stop LiveStream** - By using `stopLivestream()` function, a participant can stop broadcasting on all platforms.

### Start And Stop Live Stream

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
private val YOUTUBE_RTMP_URL: String? = null
private val YOUTUBE_RTMP_STREAM_KEY: String? = null

//
findViewById<View>(R.id.btnLivestream).setOnClickListener {
    if (!livestreaming) {
        if (YOUTUBE_RTMP_URL == null || YOUTUBE_RTMP_STREAM_KEY == null) {
            throw Error("RTMP url or stream key missing.")
        }
        val outputs: MutableList<LivestreamOutput> = ArrayList()
        outputs.add(LivestreamOutput(YOUTUBE_RTMP_URL, YOUTUBE_RTMP_STREAM_KEY))

        meeting!!.startLivestream(outputs)
    } else {
        meeting!!.stopLivestream()
    }
}
```

</TabItem>

<TabItem value="Java">

```js
private static final String YOUTUBE_RTMP_URL = null;
private static final String YOUTUBE_RTMP_STREAM_KEY = null;

//
findViewById(R.id.btnLivestream).setOnClickListener(view -> {
    if (!livestreaming) {
        if (YOUTUBE_RTMP_URL == null || YOUTUBE_RTMP_STREAM_KEY == null) {
            throw new Error("RTMP url or stream key missing.");
        }

        List<LivestreamOutput> outputs = new ArrayList<>();
        outputs.add(new LivestreamOutput(YOUTUBE_RTMP_URL, YOUTUBE_RTMP_STREAM_KEY));

        meeting.startLivestream(outputs);
    } else {
        meeting.stopLivestream();
    }
});
```

</TabItem>

</Tabs>

### Events

- **onLiveStreamStateChanged** - A `onLiveStreamStateChanged` event will be triggered any time the broadcasting state of a meeting changes.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
object : MeetingEventListener() {
  override fun onLivestreamStateChanged(livestreamState: String?) {
    when (livestreamState) {
        "LIVESTREAM_STARTING" -> Log.d( "LivestreamStateChanged",
            "Meeting livestream is starting"
        )
        "LIVESTREAM_STARTED" -> Log.d( "LivestreamStateChanged",
            "Meeting livestream is started"
        )
        "LIVESTREAM_STOPPING" -> Log.d("LivestreamStateChanged",
            "Meeting livestream is stopping"
        )
        "LIVESTREAM_STOPPED" -> Log.d("LivestreamStateChanged",
            "Meeting livestream is stopped"
        )
    }
  }

}
```

</TabItem>

<TabItem value="Java">

```js
new MeetingEventListener() {
  @Override
  public void onLivestreamStateChanged(String livestreamState) {
      switch (livestreamState) {
          case "LIVESTREAM_STARTING":
              Log.d("LivestreamStateChanged", "Meeting livestream is starting");
              break;
          case "LIVESTREAM_STARTED":
              Log.d("LivestreamStateChanged", "Meeting livestream is started");
              break;
          case "LIVESTREAM_STOPPING":
              Log.d("LivestreamStateChanged", "Meeting livestream is stopping");
              break;
          case "LIVESTREAM_STOPPED":
              Log.d("LivestreamStateChanged", "Meeting livestream is stopped");
              break;
      }
  }
}
```

</TabItem>

</Tabs>


---

---
title: Leave End Meeting Video & Audio Call - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: Leave or End Meeting features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Leave or End Meeting
pagination_label: Leave or End Meeting
keywords:
  - Exit Meeting
  - Leave Meeting
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: leave-end-meeting
---

import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>

# Leave or End Meeting - Android

Whenever participant wishes to end their communication in the meeting, they can simply leave the meeting.

This guide will provide an overview of how to implement leave or end feature in VideoSDK meetings.

1. **Leave** - By using `leave()` function, only a participant will leave/exit the meeting, the rest of the meeting will continue with other participants.
2. **End** - By using `end()` function, meeting will end for each and every participant. So, use this function according to your use cases.

### Leave And End Meeting

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
  btnLeave!!.setOnClickListener { _: View? ->
    meeting!!.leave()
  }

  btnEnd!!.setOnClickListener { _: View? ->
    meeting!!.end()
  }
```

</TabItem>

<TabItem value="Java">

```js
  btnLeave.setOnClickListener(new View.OnClickListener() {
      @Override
      public void onClick(View v) {
        meeting.leave();
      }
  });

  btnEnd.setOnClickListener(new View.OnClickListener() {
      @Override
      public void onClick(View v) {
        meeting.end();
      }
  });
```

</TabItem>

</Tabs>

### Events

**Events associated with `leave()`:**

- Local participant will receive a callback on[`onMeetingLeft`](../../../api/sdk-reference/meeting-class/meeting-event-listener-class.md#onmeetingleft) of `Meeting`.
- All remote participants will receive a callback [`onParticipantLeft`](../../../api/sdk-reference/meeting-class/meeting-event-listener-class.md#onparticipantleft) with Participant object.

**Event associated with `end()`:**

- All remote participants and local participant will receive a callback on [`onParticipantLeft`](../../../api/sdk-reference/meeting-class/meeting-event-listener-class.md#onparticipantleft) with Participant object.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
private final MeetingEventListener meetingEventListener = new MeetingEventListener() {
  override fun onMeetingLeft() {
    Log.d("#meeting", "onMeetingleft()")
  }

  override fun onParticipantLeft(participant: Participant) {
    Log.d("#meeting", participant.displayName + " left");
  }
}
```

</TabItem>

<TabItem value="Java">

```javascript
private final MeetingEventListener meetingEventListener = new MeetingEventListener() {
  @Override
  public void onMeetingLeft() {
    Log.d("#meeting", "onMeetingleft()")
  }

  @Override
  public void onParticipantLeft(Participant participant) {
    Log.d("#meeting", participant.getDisplayName() + " left");
  }
}
```

</TabItem>

</Tabs>


---

---
title: Manage Participants Video & Audio Call - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: Manage Participants features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Manage Participants
pagination_label: Manage Participants
keywords:
  - Exit Meeting
  - Leave Meeting
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: manage-participants
---

import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>

# Manage Participants - Android

## 1. Local Participant (self)

Local participant is used to consume your video & audio streams.
it contains information about local participant such as displayName, id, quality and streams Map.

You can acces localParticipant from the [meeting object](/android/guide/video-and-audio-calling-api-sdk/features/start-join-meeting#2-initialization).

### Participant object properties

| Property Name | Type          | Description                                            |
| ------------- | ------------- | ------------------------------------------------------ |
| id            | string        | Unique id of the participant.                          |
| displayName   | string        | The name you define during the meeting initialization. |
| local         | boolean       | Indicates the participant is local or not.             |
| quality       | string        | Indicates the participant streams quality.             |
| Streams       | Map of Stream | Returns Video & Audio Streams.                         |

### Stream Object properties

| Property Name | Type   | Description        |
| ------------- | ------ | ------------------ |
| id            | string | Unique id          |
| codec         | string | Video/Audio codec. |
| kind          | string | Stream Kind.       |
| track         | string | MediaStreamTrack   |

## 2. Other Participants (Except You)

Other participants Map is used to get all the participants (except you) in the meeting at any given time.

Other participants Map contains same properties as [LocalParticipant](/android/guide/video-and-audio-calling-api-sdk/features/manage-participants#participant-object-properties).

### Local And Other Participants

```xml title="activity_main.xml"
  <live.videosdk.rtc.android.VideoView
      android:id="@+id/localView"
      android:layout_width="80dp"
      android:layout_height="100dp"
      android:layout_gravity="end" />

  <androidx.recyclerview.widget.RecyclerView
      android:id="@+id/rvParticipants"
      android:layout_width="match_parent"
      android:layout_height="match_parent" />
```

:::info

- Here the participant's video is displayed using `VideoView`, but you may also use `SurfaceViewRender` for the same.
- For `VideoView`, SDK version should be `0.1.13` or higher.
- To know more about `VideoView`, please visit [here](/android/guide/video-and-audio-calling-api-sdk/components/videoView)

:::

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js title="MainActivity.kt"
  import live.videosdk.rtc.android.VideoView
  import org.webrtc.VideoTrack

  private fun displayLocalParticipant() {
    var localView: VideoView = findViewById(R.id.localView)

    // display local video when stream available
    meeting!!.localParticipant.addEventListener(
       object : ParticipantEventListener() {
         override fun onStreamEnabled(stream: Stream) {
           if (stream.kind.equals("video", ignoreCase = true)) {
             val videoTrack = stream.track as VideoTrack
             localView.addTrack(videoTrack)
            }
         }
      }
    )
  }

  private fun displayRemoteParticipants() {
    val rvParticipants = findViewById<RecyclerView>(R.id.rvParticipants)
    rvParticipants.layoutManager = GridLayoutManager(this, 2)
    rvParticipants.adapter = ParticipantAdapter(meeting!!)
  }

```

</TabItem>

<TabItem value="Java">

```js title="MainActivity.java"
  import live.videosdk.rtc.android.VideoView;
  import org.webrtc.VideoTrack;

  private void displayLocalParticipant() {
    final VideoView localView = findViewById(R.id.localView);

    // display local video when stream available
    meeting.getLocalParticipant().addEventListener(
        new ParticipantEventListener() {
          @Override
          public void onStreamEnabled(Stream stream) {
            if (stream.getKind().equalsIgnoreCase("video")) {
              VideoTrack track = (VideoTrack) stream.getTrack();
              localView.addTrack(track);
            }
          }
        }
      );
  }

  private void displayRemoteParticipants() {
    final RecyclerView rvParticipants = findViewById(R.id.rvParticipants);
    rvParticipants.setLayoutManager(new GridLayoutManager(this, 2));
    rvParticipants.setAdapter(new ParticipantAdapter(meeting));
  }

```

</TabItem>

</Tabs>

```xml title="item_remote_peer.xml"
<?xml version="1.0" encoding="utf-8"?>
<FrameLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="wrap_content">

    <live.videosdk.rtc.android.VideoView
        android:id="@+id/participantView"
        android:layout_width="match_parent"
        android:layout_height="match_parent" />

</FrameLayout>
```

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js title="ParticipantAdapter.kt"

class ParticipantAdapter(meeting: Meeting) : RecyclerView.Adapter<ParticipantAdapter.PeerViewHolder>() {
    private val participants: MutableList<Participant> = ArrayList()
    private var containerHeight = 0

    init {
        participants.add(meeting.localParticipant)
        meeting.addEventListener(object : MeetingEventListener() {
            override fun onParticipantJoined(participant: Participant) {
                participants.add(participant)
                notifyItemInserted(participants.size - 1)
            }

            override fun onParticipantLeft(participant: Participant) {
                // remove participant from grid
            }
        })
    }

    override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): PeerViewHolder {
        containerHeight = parent.height
        return PeerViewHolder(
            LayoutInflater.from(parent.context)
                .inflate(R.layout.item_remote_peer, parent, false)
        )
    }

    override fun onBindViewHolder(holder: PeerViewHolder, position: Int) {
        val participant = participants[position]

        val layoutParams = holder.itemView.layoutParams
        layoutParams.height = containerHeight / 3
        holder.itemView.layoutParams = layoutParams

        for ((_, stream) in participant.streams) {
            if (stream.kind.equals("video", ignoreCase = true)) {
                val videoTrack = stream.track as VideoTrack
                holder.participantView.addTrack(videoTrack)
                break
            }
        }

        participant.addEventListener(object : ParticipantEventListener() {
            override fun onStreamEnabled(stream: Stream) {
                if (stream.kind.equals("video", ignoreCase = true)) {
                    val videoTrack = stream.track as VideoTrack
                    holder.participantView.addTrack(videoTrack)
                }
            }
        })
    }

    override fun getItemCount(): Int {
        return participants.size
    }

    class PeerViewHolder(view: View) : RecyclerView.ViewHolder(view) {
        var participantView: VideoView = view.findViewById(R.id.participantView)
    }
}

```

Please refer the [example code](https://github.com/videosdk-live/videosdk-rtc-android-kotlin-sdk-example) on Github for more details.

</TabItem>

<TabItem value="Java">

```js title="ParticipantAdapter.java"

public class ParticipantAdapter extends RecyclerView.Adapter<ParticipantAdapter.PeerViewHolder> {

    private final List<Participant> participants = new ArrayList<>();
    private int containerHeight;

    public ParticipantAdapter(Meeting meeting) {
        Handler mHandler = new Handler(Looper.getMainLooper());

        meeting.addEventListener(new MeetingEventListener() {
            @Override
            public void onParticipantJoined(Participant participant) {
                participants.add(participant);
                mHandler.post(() -> notifyItemInserted(participants.size() - 1));
            }

            @Override
            public void onParticipantLeft(Participant participant) {
                // remove participant from grid
            }
        });
    }

    @NonNull
    @Override
    public PeerViewHolder onCreateViewHolder(@NonNull ViewGroup parent, int viewType) {
        containerHeight = parent.getHeight();

        return new PeerViewHolder(LayoutInflater.from(parent.getContext())
                .inflate(R.layout.item_remote_peer, parent, false));
    }

    @Override
    public void onBindViewHolder(@NonNull PeerViewHolder holder, int position) {
        final Participant participant = participants.get(position);

        ViewGroup.LayoutParams layoutParams = holder.itemView.getLayoutParams();
        layoutParams.height = containerHeight / 3;
        holder.itemView.setLayoutParams(layoutParams);

        for (Map.Entry<String, Stream> entry : participant.getStreams().entrySet()) {
            Stream stream = entry.getValue();
            if (stream.getKind().equalsIgnoreCase("video")) {
                VideoTrack videoTrack = (VideoTrack) stream.getTrack();
                holder.participantView.addTrack(videoTrack);
                break;
            }
        }

        participant.addEventListener(new ParticipantEventListener() {
            @Override
            public void onStreamEnabled(Stream stream) {
                if (stream.getKind().equalsIgnoreCase("video")) {
                    VideoTrack videoTrack = (VideoTrack) stream.getTrack();
                    holder.participantView.addTrack(videoTrack);
                }
            }
        });

    }

    @Override
    public int getItemCount() {
        return participants.size();
    }

    static class PeerViewHolder extends RecyclerView.ViewHolder {
        public VideoView participantView;
        public View itemView;

        PeerViewHolder(@NonNull View view) {
            super(view);

            itemView = view;

            participantView = view.findViewById(R.id.participantView);
        }
    }
}
```

Please refer the [example code](https://github.com/videosdk-live/videosdk-rtc-android-java-sdk-example/blob/master/app/src/main/java/live/videosdk/rtc/android/java) on Github for more details.

</TabItem>

</Tabs>

## 3. Participant Related Events

1. **onParticipantJoined** - Whenever any new participant join the meeting, `onParticipantJoined` event will trigger. For example, the meeting is running with **Alice** and **Bob**, then **Eve** join that meeting, after that `onParticipantJoined` event trigger and return the [participant object](/android/guide/video-and-audio-calling-api-sdk/features/manage-participants#participant-object-properties).

2. **onParticipantLeft** - Whenever any participant leave/exit the meeting, `onParticipantLeft` event will trigger.For example, the meeting is running with **Alice** and **Bob**, then **Bob** leave that meeting, after that `onParticipantLeft` event trigger and return the [participant object](/android/guide/video-and-audio-calling-api-sdk/features/manage-participants#participant-object-properties)

3. **onPresenterChanged** - Whenever any participant present/screenshare their screen/window in meeting, `onPresenterChanged` event will trigger and return the presenter `participantId`.

4. **onStreamEnabled** - Whenever any participant enabled mic/webcam in meeting, `onStreamEnabled` event will trigger and return [Stream](/android/guide/video-and-audio-calling-api-sdk/features/manage-participants#stream-object-properties).

5. **onStreamDisabled** - Whenever any participant disabled mic/webcam in meeting, `onStreamDisabled` event will trigger and return [Stream](/android/guide/video-and-audio-calling-api-sdk/features/manage-participants#stream-object-properties).

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
 meeting.addEventListener(object : MeetingEventListener() {
    override fun onParticipantJoined(participant: Participant) {
        participant.addEventListener(object : ParticipantEventListener() {
                override fun onStreamEnabled(stream: Stream) {
                    if (stream.kind.equals("video", ignoreCase = true)) {
                         // participant video enabled
                    } else if (stream.kind.equals("audio", ignoreCase = true)) {
                         // participant mic enabled
                    }
                }
                override fun onStreamDisabled(stream: Stream) {
                    if (stream.kind.equals("video", ignoreCase = true)) {
                         // participant video disabled
                    } else if (stream.kind.equals("audio", ignoreCase = true)) {
                        // participant mic disabled
                    }
                }
        })
    }

    override fun onParticipantLeft(participant: Participant) {
        Toast.makeText(this@MainActivity, participant.displayName + " left", Toast.LENGTH_SHORT).show()
    }

    override fun onPresenterChanged(presenterId: String) {
        Toast.makeText(this@MainActivity, presenterId + " started presenting", Toast.LENGTH_SHORT).show()
    }
 })
```

</TabItem>

<TabItem value="Java">

```js
 meeting.addEventListener(new MeetingEventListener() {
    @Override
    public void onParticipantJoined(Participant participant) {
      participant.addEventListener(new ParticipantEventListener() {
          @Override
          public void onStreamEnabled(Stream stream) {
              if (stream.getKind().equalsIgnoreCase("video")) {
                  // participant video enabled
              } else if (stream.getKind().equalsIgnoreCase("audio")) {
                  // participant mic enabled
              }
          }

          @Override
          public void onStreamDisabled(Stream stream) {
              if (stream.getKind().equalsIgnoreCase("video")) {
                  // participant video disabled
              } else if (stream.getKind().equalsIgnoreCase("audio")) {
                  // participant mic disabled
              }
          }
      });
    }

    @Override
    public void onParticipantLeft(Participant participant) {
      Toast
        .makeText(
          MainActivity.this,
          participant.getDisplayName() + " left",
          Toast.LENGTH_SHORT
        )
        .show();
    }
    @Override
    public void onPresenterChanged(String presenterId) {
      Toast
        .makeText(
          MainActivity.this,
          presenterId + " started presenting",
          Toast.LENGTH_SHORT
        )
        .show();
    }
 });
```

</TabItem>

</Tabs>


---

---
title: Mic Controls Video & Audio Call - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: Mic Controls features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Mic Controls
pagination_label: Mic Controls
keywords:
  - Mic on
  - Mic off
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: mic-controls
---

import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>

# Mic Controls - Android

Whenever any participant wants to start / stop broadcasting their audio to other participant in meeting, they can simply do it with VideoSDK Meeting.

This guide will provide an overview of how to use enable and disable Mic in a meeting.

1. **Enable Mic** - By using `unmuteMic()` function, a participant can publish audio to other participants.
2. **Disable Mic** - By using `muteMic()` function, a participant can stop publishing audio to other participants.

### 1. Enable, Disable Mic

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
  private var micEnabled = false

  btnMic!!.setOnClickListener { _: View? ->
    // Toggle participant mic in meeting
     if (micEnabled) {
       meeting!!.muteMic()
       micEnabled=false
     } else {
      meeting!!.unmuteMic()
      micEnabled=true
     }
  }
```

</TabItem>

<TabItem value="Java">

```js
  private boolean micEnabled = false;

  btnMic.setOnClickListener(new View.OnClickListener() {
      @Override
      public void onClick(View v) {
          // Toggle participant mic in meeting
          if (micEnabled) {
              meeting.muteMic();
              micEnabled = false;
          } else {
              meeting.unmuteMic();
              micEnabled = true;
          }
      }
  });
```

</TabItem>

</Tabs>

### Events

**Event associated with `unmuteMic()`:**

- Every Participant will receive a callback on [`onStreamEnabled()`](../../../api/sdk-reference/participant-class/participant-event-listener-class.md#onstreamenabled) of the [`Participant`](../../../api/sdk-reference/participant-class//introduction.md) with `Stream` object.

**Event associated with `muteMic()`:**

- Every Participant will receive a callback on [`onStreamDisabled()`](../../../api/sdk-reference/participant-class/participant-event-listener-class.md#onstreamenabled) of the [`Participant`](../../../api/sdk-reference/participant-class//introduction.md) with `Stream` object.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
  meeting!!.localParticipant.addEventListener(object : ParticipantEventListener() {
    override fun onStreamEnabled(stream: Stream) {
        //
        if(stream.getKind().equals("audio")){
          //participant turned on audio
        }
    }

    override fun onStreamDisabled(stream: Stream) {
        //
        if(stream.getKind().equals("audio")){
          //participant turned off audio
        }
    }
  });
```

</TabItem>

<TabItem value="Java">

```js
  participant.addEventListener(new ParticipantEventListener() {
    @Override
    public void onStreamEnabled(Stream stream) {
        //
        if(stream.getKind().equals("audio")){
          //participant turned on audio
        }
    }

    @Override
    public void onStreamDisabled(Stream stream) {
        //
        if(stream.getKind().equals("audio")){
          //participant turned off audio
        }
    }
  });
```

</TabItem>

</Tabs>

### 2. Change Audio Device

#### Get all audio Devices

- By using `meeting.getMics()` function, a participant can get all the connected mics.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
  private fun getMics(): MutableSet<AppRTCAudioManager.AudioDevice>? {
    val mics= meeting!!.mics
    return mics  // returns all mics
  }
```

</TabItem>

<TabItem value="Java">

```js
  private Set<AppRTCAudioManager.AudioDevice> getMics() {
    Set<AppRTCAudioManager.AudioDevice> mics = meeting.getMics();
    return mics; // returns all mics
  }
```

</TabItem>

</Tabs>

#### Select audio Device

- Local participant can change the audio device using `changeMic(AppRTCAudioManager.AudioDevice device)` method of meeting class.

- Parameters that can be passed to `changeMic` are

  | Audio Devices                                | Usage                        |
  | -------------------------------------------- | ---------------------------- |
  | AppRTCAudioManager.AudioDevice.BLUETOOTH     | For Bluetooth Device.        |
  | AppRTCAudioManager.AudioDevice.WIRED_HEADSET | For Wired Handset Device.    |
  | AppRTCAudioManager.AudioDevice.SPEAKER_PHONE | For Inbuilt - Speaker Device |
  | AppRTCAudioManager.AudioDevice.EARPIECE      | For Earpiece Device          |

- When a Local participant changes the Mic, `AppRTCAudioManager.AudioManagerEvents()` is triggered which can be set to `Meeting` class by using `meeting.setAudioDeviceChangeListener()`

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js

  btnChangeMic!!.setOnClickListener { _: View? ->
  // Change Mic in Meeting
    meeting!!.changeMic(AppRTCAudioManager.AudioDevice.BLUETOOTH)
  }

  private fun setAudioDeviceListeners() {
    meeting!!.setAudioDeviceChangeListener(object : AudioManagerEvents {
      override fun onAudioDeviceChanged(
        selectedAudioDevice: AppRTCAudioManager.AudioDevice,
        availableAudioDevices: Set<AppRTCAudioManager.AudioDevice>
      ) {
          when (selectedAudioDevice) {
            AppRTCAudioManager.AudioDevice.BLUETOOTH ->
              Toast.makeText(this@MainActivity, "Selected AudioDevice: BLUETOOTH", Toast.LENGTH_SHORT).show()

            AppRTCAudioManager.AudioDevice.WIRED_HEADSET ->
              Toast.makeText(this@MainActivity, "Selected AudioDevice: WIRED_HEADSET", Toast.LENGTH_SHORT).show()

            AppRTCAudioManager.AudioDevice.SPEAKER_PHONE ->
              Toast.makeText(this@MainActivity, "Selected AudioDevice: SPEAKER_PHONE", Toast.LENGTH_SHORT).show()

            AppRTCAudioManager.AudioDevice.EARPIECE ->
              Toast.makeText(this@MainActivity, "Selected AudioDevice: EARPIECE", Toast.LENGTH_SHORT).show()
          }
        }
    })
  }

  override fun onCreate(savedInstanceState: Bundle?) {
       // ...
       setAudioDeviceListeners()
  }
```

</TabItem>

<TabItem value="Java">

```js

  btnChangeMic.setOnClickListener(new View.OnClickListener() {
      @Override
      public void onClick(View v) {
        // Change Mic in Meeting
        meeting.changeMic(AppRTCAudioManager.AudioDevice.BLUETOOTH);
      }
  });

  private void setAudioDeviceListeners() {
    meeting.setAudioDeviceChangeListener(new AppRTCAudioManager.AudioManagerEvents() {
         @Override
        public void onAudioDeviceChanged(AppRTCAudioManager.AudioDevice selectedAudioDevice, Set<AppRTCAudioManager.AudioDevice> availableAudioDevices) {
            switch (selectedAudioDevice) {
                case BLUETOOTH:
                  Toast.makeText(MainActivity.this, "Selected AudioDevice: BLUETOOTH", Toast.LENGTH_SHORT).show();
                  break;
                case WIRED_HEADSET:
                  Toast.makeText(MainActivity.this, "Selected AudioDevice: WIRED_HEADSET", Toast.LENGTH_SHORT).show();
                  break;
                case SPEAKER_PHONE:
                  Toast.makeText(MainActivity.this, "Selected AudioDevice: SPEAKER_PHONE", Toast.LENGTH_SHORT).show();
                  break;
                case EARPIECE:
                  Toast.makeText(MainActivity.this, "Selected AudioDevice: EARPIECE", Toast.LENGTH_SHORT).show();
                  break;
               }
        }
    });
  }

  @Override
    protected void onCreate(Bundle savedInstanceState) {
       // ...
       setAudioDeviceListeners();
    }
```

</TabItem>

</Tabs>

- To use Bluetooth device, you must declare `BLUETOOTH` permission in `AndroidManifest.xml` file.

```js
<manifest ... >

<!-- Needed to communicate with already-paired Bluetooth devices. (Legacy up to Android 11) -->
<uses-permission android:name="android.permission.BLUETOOTH" />
<uses-permission android:name="android.permission.BLUETOOTH_ADMIN" />
<uses-permission android:name="android.permission.BLUETOOTH_CONNECT" />
//...
</manifest>
```


---

---
title: Pause/Resume Video Stream - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: Pause/Resume Video Stream features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Pause/Resume Video Stream
pagination_label: Pause/Resume Video Stream
keywords:
  - pause/resume video stream
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: pause-resume-video-stream
---

import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>

# Pause/Resume Video Stream - Android

Whenver you wish to stop/resume downlaod stream(webcam, screenShare and mic) of participant, you can simply do it by using `pause`, `resume` methods.

## Pause video stream

- `pause()` method is used for pause stream(webcam, screenShare and mic) of a particular participant.

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
  btnPause!!.setOnClickListener { _: View? ->
    for ((_, stream) in participant.streams) {
      stream.pause()
    }
  }
```

</TabItem>

<TabItem value="Java">

```js
  btnPause.setOnClickListener(new View.OnClickListener() {
      @Override
      public void onClick(View v) {
        for (Map.Entry<String, Stream> entry : participant.getStreams().entrySet()) {
                Stream stream = entry.getValue();
                stream.pause();
        }
      }
  });
```

</TabItem>

</Tabs>

## Resume video stream

- `resume()` method is used to resume stream(webcam, screenShare and mic) of a particular participant.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
  btnResume!!.setOnClickListener { _: View? ->
    for ((_, stream) in participant.streams) {
      stream.resume()
    }
  }
```

</TabItem>

<TabItem value="Java">

```js
  btnResume.setOnClickListener(new View.OnClickListener() {
      @Override
      public void onClick(View v) {
        for (Map.Entry<String, Stream> entry : participant.getStreams().entrySet()) {
            Stream stream = entry.getValue();
            stream.resume();
        }
      }
  });
```

</TabItem>

</Tabs>


---

---
title: Pin Participants Video & Audio Call - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: Pin Participant features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Pin Participants
pagination_label: Pin Participants
keywords:
  - pin
  - unpin
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: pin-participants
---

import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>

# Pin Participants - Android

In any meeting with large number of participants, if you want to show only one or two participant(s) on main screen then you can pin that perticipants so that viewers can only focus upon that participants only.

This guide will provide an overview of how to pin or unpin any participants in a meeting.

:::note
`pin()` and `unpin()` functions will take `string` or `null` as an argument. Pin will be effective for both webcam and screenshare of that participant.

Suppose you want to pin or unpin only webcam of that participant then you can pass `CAM`, else if you want to pin or unpin only screenshare of that participant then you can pass `SHARE`.

You can also pass `SHARE_AND_CAM` if you want to `pin` or `unpin` both webcam and screenshare media of that user, or passing `null` or nothing as an argument will also work in the same way.

If any participant's webcam is pinned but not screenshare, then calling `pin("SHARE")` the new pinState of that participant will be `{ cam: true, share: true }`.  
:::

### Pin And Unpin a Participant

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
  // Pin both webcam and screenshare of that participant
  meeting!!.participants[participantId].pin("SHARE_AND_CAM")

  // Pin webcam of that participant
  meeting!!.participants[participantId].pin("CAM")

  // Pin screenshare of that participant
  meeting!!.participants[participantId].pin("SHARE")

  //
  // Unpin both webcam and screenshare of that participant
  meeting!!.participants[participantId].unpin("SHARE_AND_CAM");

  // Unpin webcam of that participant
  meeting!!.participants[participantId].unpin("CAM");

  // Unpin screenshare of that participant
  meeting!!.participants[participantId].unpin("SHARE");
```

</TabItem>

<TabItem value="Java">

```js
// Pin both webcam and screenshare of that participant
meeting.getParticipants().get(participantId).pin("SHARE_AND_CAM");

// Pin webcam of that participant
meeting.getParticipants().get(participantId).pin("CAM");

// Pin screenshare of that participant
meeting.getParticipants().get(participantId).pin("SHARE");

//
// Unpin both webcam and screenshare of that participant
meeting.getParticipants().get(participantId).unpin(null);

// Unpin webcam of that participant
meeting.getParticipants().get(participantId).unpin("CAM");

// Unpin screenshare of that participant
meeting.getParticipants().get(participantId).unpin("SHARE");
```

</TabItem>

</Tabs>

### onPinStateChanged Event

Whenever any participant got pinned or unpinned by any participant, `onPinStateChanged` event will be triggered.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
 override fun onPinStateChanged(pinStateData: JSONObject?) {
   Log.d("onPinStateChanged: ", pinStateData.getString("peerId")) // id of participant who were pinned
   Log.d("onPinStateChanged: ", pinStateData.getJSONObject("state")) // { cam: true, share: true }
   Log.d("onPinStateChanged: ", pinStateData.getString("pinnedBy")) // id of participant who pinned that participant
  }
```

</TabItem>

<TabItem value="Java">

```javascript
@Override
  public void onPinStateChanged(JSONObject pinStateData) {
    Log.d("onPinStateChanged: ", pinStateData.getString("peerId")); // id of participant who were pinned
    Log.d("onPinStateChanged: ", pinStateData.getJSONObject("state")); // { cam: true, share: true }
    Log.d("onPinStateChanged: ", pinStateData.getString("pinnedBy")); // id of participant who pinned that participant
  }

```

</TabItem>

</Tabs>


---

---
sidebar_label: Send Message using PubSub
pagination_label: PubSub
---

import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>

# PubSub - Android

PubSub feature allows the participant to send and receive messages of the topics which he has subscribed.

## Methods

### publish()

This method is use for publishing message of specific topic.

#### Syntax

```js
public void publish(String topic, String message, PubSubPublishOptions options)
```

| Parameter Name | Type                 | Description                                                                                                                                       |
| -------------- | -------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------- |
| topic          | String               | This should be the topic for which you are publishing a message.                                                                                  |
| message        | String               | This is the actual message, which will be published to participants, who had subscribed to a particular topic.                                    |
| options        | PubSubPublishOptions | This is an object of PubSubPublishOptions, which provides an option, such as `persist`, which persists message history for upcoming participants. |

#### Example

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
private fun sendMessage() {
  val options = PubSubPublishOptions()
  options.isPersist = true
  meeting!!.pubSub.publish("CHAT", "Hello from Android", options)
}
```

</TabItem>

<TabItem value="Java">

```js
protected void sendMessage() {
  PubSubPublishOptions options = new PubSubPublishOptions();
  options.setPersist(true);
  meeting.pubSub.publish("CHAT", "Hello from Android", options);
}
```

</TabItem>

</Tabs>

### subscribe()

This method is used to subscribe for particular topic. This method returns a list of messages which were sent earlier.

#### Syntax

```js
public List<PubSubMessage> subscribe(String topic, PubSubMessageListener listener)
```

| Parameter Name | Type                  | Description                                                                                                                                      |
| -------------- | --------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------ |
| topic          | String                | This should be the topic to be subscribed.                                                                                                       |
| listener       | PubSubMessageListener | This is an object of PubSubMessageListener, which listens for upcoming messages and calls onMessageReceived function, when new message received. |

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
var pubSubMessageListener =
  PubSubMessageListener { message ->
    // Logs new message
    Log.v("New Message Received", "Message : " + message.message)
  }

@Override
protected void onCreate(Bundle savedInstanceState) {
  //...

  // Subscribe for 'CHAT' topic
  val pubSubMessageList = meeting!!.pubSub.subscribe("CHAT", pubSubMessageListener)

  // Logs persisted message list
  for (message in pubSubMessageList) {
    Log.v("Message List: ", "Message : " + message.message)
  }
}
```

</TabItem>

<TabItem value="Java">

```js
PubSubMessageListener pubSubMessageListener = new PubSubMessageListener() {
  @Override
  public void onMessageReceived(PubSubMessage message) {
    // Logs new message
    Log.v("New Message Received", "Message : " + message.getMessage());
  }
};

@Override
protected void onCreate(Bundle savedInstanceState) {
  //...

  // Subscribe for 'CHAT' topic
  List<PubSubMessage> pubSubMessageList = meeting.pubSub.subscribe("CHAT",pubSubMessageListener);

  // Logs persisted message list
  for(PubSubMessage message : pubSubMessageList){
    Log.v("Message List: ", "Message : " + message.getMessage());
  }
}
```

</TabItem>

</Tabs>

### unsubscribe()

This method is used to unsubscribe the message topic.

#### Syntax

```js
public void unsubscribe(String topic, PubSubMessageListener listener)
```

| Parameter Name | Type                  | Description                                                                    |
| -------------- | --------------------- | ------------------------------------------------------------------------------ |
| topic          | String                | This should be the topic to be unsubscribed.                                   |
| listener       | PubSubMessageListener | This is an object of PubSubMessageListener, which was passed in `subscribe()`. |

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
fun unsubscribe() {
  // Unsubscribe 'CHAT' topic
  meeting!!.pubSub.unsubscribe("CHAT", pubSubMessageListener)
}
```

</TabItem>

<TabItem value="Java">

```js
public void unsubscribe(){
  // Unsubscribe 'CHAT' topic
  meeting.pubSub.unsubscribe("CHAT", pubSubMessageListener);
}
```

</TabItem>

</Tabs>

## Sample Code

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
package live.videosdk.rtc.android.kotlin

import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle
import android.view.View
import android.widget.EditText
import android.widget.Toast
import androidx.appcompat.widget.Toolbar
import androidx.recyclerview.widget.LinearLayoutManager
import androidx.recyclerview.widget.RecyclerView
import live.videosdk.rtc.android.Meeting
import live.videosdk.rtc.android.listeners.PubSubMessageListener
import live.videosdk.rtc.android.model.PubSubPublishOptions

class ChatActivity : AppCompatActivity() {

    // Meeting
    var meeting: Meeting? = null

    // PubSubMessageListener
    var pubSubMessageListener =
      PubSubMessageListener { message ->
        // Logs new message
        Log.v("New Message Received", "Message : " + message.message)
    }

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_chat)

        /**
         * Here, we have created 'MainApplication' class, which extends android.app.Application class.
         * It has Meeting property and getter and setter methods of Meeting property.
         * In your android manifest, you must declare the class implementing android.app.Application (add the android:name=".MainApplication" attribute to the existing application tag):
         * In MainActivity.kt, we have set Meeting property.
         *
         * For Example: (MainActivity.kt)
         * var meeting = VideoSDK.initMeeting(context, meetingId, ParticipantName, micEnabled, webcamEnabled, paricipantId, mode, customTrack, metaData,signalingBaseUrl,preferredProtocol)
         * (this.application as MainApplication).meeting = meeting
        */

        // Get Meeting
        meeting = (this.application as MainApplication).meeting

        // Subscribe for 'CHAT' topic
        val pubSubMessageList = meeting!!.pubSub.subscribe("CHAT", pubSubMessageListener)

        for (message in pubSubMessageList) {
          // Logs persisted messages
           Log.v("Message List: ", "Message : " + message.message)
        }

        sendMessage()
    }

    private fun sendMessage() {
      val options = PubSubPublishOptions()
      options.isPersist = true
      meeting!!.pubSub.publish("CHAT", "Hello from Android", options)
    }

    override fun onDestroy() {
      // Unsubscribe for 'CHAT' topic
      meeting!!.pubSub.unsubscribe("CHAT", pubSubMessageListener)
      super.onDestroy()
    }
}
```

</TabItem>

<TabItem value="Java">

```js
package live.videosdk.rtc.android.java;

import androidx.appcompat.app.AppCompatActivity;
import android.os.Bundle;
import android.util.Log;
import java.util.List;
import live.videosdk.rtc.android.Meeting;
import live.videosdk.rtc.android.lib.PubSubMessage;
import live.videosdk.rtc.android.listeners.PubSubMessageListener;
import live.videosdk.rtc.android.model.PubSubPublishOptions;

public class ChatActivity extends AppCompatActivity {

    // Meeting
    Meeting meeting;

    // PubSubMessageListener
    private PubSubMessageListener pubSubMessageListener = new PubSubMessageListener() {
      @Override
      public void onMessageReceived(PubSubMessage message) {
          // Logs new message
          Log.v("New Message Received : ", "Message : " + message.getMessage());
      }
    };

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_chat);

        /**
         * Here, we have created 'MainApplication' class, which extends android.app.Application class.
         * It has Meeting property and getter and setter methods of Meeting property.
         * In your android manifest, you must declare the class implementing android.app.Application (add the android:name=".MainApplication" attribute to the existing application tag):
         * In MainActivity.java, we have set Meeting property.
         *
         * For Example: (MainActivity.java)
         * Meeting meeting = VideoSDK.initMeeting(context, meetingId, ParticipantName, micEnabled, webcamEnabled, participantId, mode, customTrack, metaData, signalingBaseUrl,preferredProtocol);
         * ((MainApplication) this.getApplication()).setMeeting(meeting);
        */

        // Get Meeting
        meeting = ((MainApplication) this.getApplication()).getMeeting();

        // Subscribe for 'CHAT' topic
        List<PubSubMessage> pubSubMessageList = meeting.pubSub.subscribe("CHAT", pubSubMessageListener);
        for(PubSubMessage message : pubSubMessageList){
            // Logs persisted messages
            Log.v("Message List : ", "Message : " + message.getMessage());
        }

        sendMessage();
    }

    protected void sendMessage() {
      PubSubPublishOptions publishOptions = new PubSubPublishOptions();
      publishOptions.setPersist(true);
      meeting.pubSub.publish("CHAT", "Hello from Android", publishOptions);
    }

    @Override
    protected void onDestroy() {
      // Unsubscribe for 'CHAT' topic
      meeting.pubSub.unsubscribe("CHAT", pubSubMessageListener);
      super.onDestroy();
    }
}
```

</TabItem>

</Tabs>


---

---
title: Record Meeting Video & Audio Call - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: Record Meeting features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Record Meeting
pagination_label: Record Meeting
keywords:
  - Start Recording meeting
  - Stop Recording meeting
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: recording-meeting
---

import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>

# Record Meeting - Android

Record meeting allows participants to record video & audio during the meeting. The recording files are available in developer dashboard.
Any participant can start / stop recording any time during the meeting.

This guide will provide an overview of how to implement start and stop Meeting Recording.

1. **Start Recording** - By using `startRecording()` function, a participant can start meeting recording.
2. **Stop Recording** - By using `stopRecording()` function, a participant can stop meeting recording.

### Start And Stop Recording

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
// TODO: change webhookUrl
val webhookUrl = "<webhook-url-here>"

// keep track of recording
val recording = false

findViewById<View>(R.id.btnRecording).setOnClickListener { view: View? ->
    if (!recording) {
        meeting!!.startRecording(webhookUrl)
    } else {
        meeting!!.stopRecording()
    }
}
```

</TabItem>

<TabItem value="Java">

```js
// TODO: change webhookUrl
String webhookUrl = "<webhook-url-here>";

// keep track of recording
boolean recording = false;

findViewById(R.id.btnRecording).setOnClickListener(view -> {
    if (!recording) {
        meeting.startRecording(webhookUrl);
    } else {
        meeting.stopRecording();
    }
});
```

</TabItem>

</Tabs>

### Events

- **onRecordingStateChanged** - A `onRecordingStateChanged` event will be triggered any time the recording state of a meeting changes.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
object : MeetingEventListener() {
  override fun onRecordingStateChanged(recordingState: String) {
    when (recordingState) {
        "RECORDING_STARTING" -> {
            Log.d("onRecordingStateChanged", "Meeting recording is starting")
        }
        "RECORDING_STARTED" -> {
            Log.d("onRecordingStateChanged", "Meeting recording is started")
        }
        "RECORDING_STOPPING" -> {
            Log.d("onRecordingStateChanged", "Meeting recording is stopping")
        }
        "RECORDING_STOPPED" -> {
            Log.d("onRecordingStateChanged", "Meeting recording is stopped")
        }
    }
  }
}
```

</TabItem>

<TabItem value="Java">

```js
new MeetingEventListener() {
  @Override
  public void onRecordingStateChanged(String recordingState) {
      switch (recordingState) {
          case "RECORDING_STARTING":
              Log.d("onRecordingStateChanged", "Meeting recording is starting");
              break;
          case "RECORDING_STARTED":
              Log.d("onRecordingStateChanged", "Meeting recording is started");
              break;
          case "RECORDING_STOPPING":
              Log.d("onRecordingStateChanged", "Meeting recording is stopping");
              break;
          case "RECORDING_STOPPED":
              Log.d("onRecordingStateChanged", "Meeting recording is stopped");
              break;
      }
  }
}
```

</TabItem>

</Tabs>


---

---
title: Remove participant from the meeting - Android SDK
hide_title: false
hide_table_of_contents: false
description: Remove a participant or a peer from the meeting while it is still in progress. It helps in meeting moderation.
sidebar_label: Remove Participant
pagination_label: Remove Participant
keywords:
  - remove participant
  - block participant
  - android
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: remove-participant
---

import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>

# Remove Participant - Android

Remove participant allows removing participant while session is on-going. This can be helpful when moderation in particular meeting is required.

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
val participant = meeting!!.participants.get("<participant-id>")

// This will emit an event called "onParticipantLeft" to that particular participant
participant.remove()
```

</TabItem>

<TabItem value="Java">

```js
Participant participant = meeting.getParticipants().get("<participant-id>");

// Remove participant from active session
// This will emit an event called "onParticipantLeft" to that particular participant
participant.remove();
```

</TabItem>

</Tabs>

### Events

**onParticipantLeft** - Removing participant will trigger `onParticipantLeft` event.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
private final MeetingEventListener meetingEventListener = new MeetingEventListener() {

  override fun onParticipantLeft(participant: Participant) {
    // Triggers when a participant is removed or leaves the meeting.
    Log.d("#meeting", participant.displayName + " left");
  }
}
```

</TabItem>

<TabItem value="Java">

```javascript
private final MeetingEventListener meetingEventListener = new MeetingEventListener() {
  @Override
  public void onParticipantLeft(Participant participant) {
    // Triggers when a participant is removed or leaves the meeting.
    Log.d("#meeting", participant.getDisplayName() + " left");
  }
}
```

</TabItem>

</Tabs>


---

---
title: Share your Screen Video & Audio Call - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: Share your Screen features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Share Your Screen
pagination_label: Share Your Screen
keywords:
  - Start Screen share
  - Stop Screen share
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: screenshare
---

import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>

# Share Your Screen - Android

- Whenever any participant wants to share a complete screen of mobile, they can simply do it with VideoSDK Meeting.

- This guide will provide an overview of how to enable or disable Screen Share in a meeting.

## How Screen share works?

- The following diagram shows flow of the screen sharing in android using VideoSDK:

<div style={{textAlign: 'center'}}>

![VideoSDK Android Screenshare Flow Diagram](/img/android/screenshare/flow_diagram.png)

</div>

## Enable Screen Share

- A participant’s Screen share stream is provided via the `MediaProjection` API. This API is only compatible with `Build.VERSION_CODES.LOLLIPOP` or higher.

- Get an instance of the `MediaProjectionManager` and Call the `createScreenCaptureIntent()` method in an activity. This initiates a prompt dialog for the user to confirm screen projection.

- One will get a prompt dialog like this:

<div style={{textAlign: 'center'}}>

<img
src={require('/img/android/screenshare/user_permission.jpg').default}
alt="user permission"
width="450"
/>

</div>

<br/>

- After permission is received from the user, call `meeting.enableScreenShare()` method.

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
private fun enableScreenShare() {
    val mediaProjectionManager = application.getSystemService(
        MEDIA_PROJECTION_SERVICE
    ) as MediaProjectionManager
    startActivityForResult(
        mediaProjectionManager.createScreenCaptureIntent(), CAPTURE_PERMISSION_REQUEST_CODE
    )
}

public override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) {
    super.onActivityResult(requestCode, resultCode, data)
    if (requestCode != CAPTURE_PERMISSION_REQUEST_CODE) return
    if (resultCode == RESULT_OK) {
        meeting!!.enableScreenShare(data)
    }
}
```

</TabItem>

<TabItem value="Java">

```js
private void enableScreenShare() {
    MediaProjectionManager mediaProjectionManager =
        (MediaProjectionManager) getApplication().getSystemService(
            Context.MEDIA_PROJECTION_SERVICE);
    startActivityForResult(
        mediaProjectionManager.createScreenCaptureIntent(), CAPTURE_PERMISSION_REQUEST_CODE);
}

@Override
public void onActivityResult(int requestCode, int resultCode, Intent data) {
    super.onActivityResult(requestCode, resultCode, data);
    if (requestCode != CAPTURE_PERMISSION_REQUEST_CODE)
        return;
    if (resultCode == Activity.RESULT_OK) {
        meeting.enableScreenShare(data);
    }
}
```

</TabItem>

</Tabs>

### Customise notification

- When a presenter starts screen share, presenter will receive a notification with a pre-defined title and message.

- Notification with pre-defined title and message will look like this:

<div style={{textAlign: 'center'}}>

<img
src={require('/img/android/screenshare/notification.jpg').default}
alt="notification"
width="450"
/>

</div>

- You can Customise those title, message and icon as per your requirements using `<meta-data>` specified in `app/src/main/AndroidManifest.xml`.

```js
<application>
  <meta-data
    android:name="notificationTitle"
    android:value="@string/notificationTitle"
  />
  <meta-data
    android:name="notificationContent"
    android:value="@string/notificationContent"
  />
  <meta-data
    android:name="notificationIcon"
    android:resource="@mipmap/ic_launcher_round"
  />
</application>
```

## Disable Screen Share

By using `meeting.disableScreenShare()` function, a participant can stop publishing screen stream to other participants.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
private fun disableScreenShare() {
    meeting!!.disableScreenShare()
}
```

</TabItem>

<TabItem value="Java">

```js
private void disableScreenShare(){
    meeting.disableScreenShare();
}
```

</TabItem>

</Tabs>

## Display Screen Share Stream

#### Local Participant

When a Local participant share the screen, `onStreamEnabled()` of `ParticipantEventListener` is triggered with the `Stream` which can be added to a `VideoView`.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
private fun setLocalListeners() {
    meeting!!.localParticipant.addEventListener(object : ParticipantEventListener() {
        override fun onStreamEnabled(stream: Stream) {
           if (stream.kind.equals("share", ignoreCase = true)) {
                // display share video
                val videoTrack = stream.track as VideoTrack
                shareView!!.addTrack(videoTrack)
            }
        }
        override fun onStreamDisabled(stream: Stream) {
            if (stream.kind.equals("share", ignoreCase = true)) {
               shareView!!.removeTrack()
            }
        }
    });
}
```

</TabItem>

<TabItem value="Java">

```js
private void setLocalListeners() {
    meeting.getLocalParticipant().addEventListener(new ParticipantEventListener() {
        @Override
        public void onStreamEnabled(Stream stream) {
            if (stream.getKind().equalsIgnoreCase("share")) {
                // display share video
                VideoTrack videoTrack = (VideoTrack) stream.getTrack();
                shareView.addTrack(videoTrack);
            }
        }
        @Override
        public void onStreamDisabled(Stream stream) {
            if (stream.getKind().equalsIgnoreCase("share")) {
                shareView.removeTrack();
            }
        }
    });
}
```

</TabItem>

</Tabs>

#### Other Participants

When other participant(Except you) share their screen, `onPresenterChanged()` in the `MeetingEventListener` is triggered with the `participantId` of the screen share.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
private val meetingEventListener: MeetingEventListener = object : MeetingEventListener() {
    override fun onPresenterChanged(participantId: String) {
        updatePresenter(participantId)
    }
}

//Getting the stream from the participantId
private fun updatePresenter(participantId: String?) {
    // find participant
    val participant = meeting!!.participants.get(participantId) ?: return

    // find share stream in participant
    var shareStream: Stream? = null
    for (stream: Stream in participant.streams.values) {
        if ((stream.kind == "share")) {
            shareStream = stream
            break
        }
    }
    if (shareStream == null) return

    // display share video
    val videoTrack = shareStream.track as VideoTrack
    shareView!!.addTrack(videoTrack)

    // listen for share stop event
    participant.addEventListener(object : ParticipantEventListener() {
        override fun onStreamDisabled(stream: Stream) {
            if ((stream.kind == "share")) {
                shareView!!.removeTrack()
            }
        }
    })
}
```

</TabItem>

<TabItem value="Java">

```js
private final MeetingEventListener meetingEventListener = new MeetingEventListener() {
    //Triggered when Presenter changes
    @Override
    public void onPresenterChanged(String participantId) {
        updatePresenter(participantId);
    }
};

//Getting the stream from the participantId
private void updatePresenter(String participantId) {
    // find participant
    Participant participant = meeting.getParticipants().get(participantId);
    if (participant == null) return;

    // find share stream in participant
    Stream shareStream = null;
    for (Stream stream: participant.getStreams().values()) {
        if (stream.getKind().equals("share")) {
            shareStream = stream;
            break;
        }
    }
    if (shareStream == null) return;

    // display share video
    VideoTrack videoTrack = (VideoTrack) shareStream.getTrack();
    shareView.addTrack(videoTrack)

    // listen for share stop event
    participant.addEventListener(new ParticipantEventListener() {
        @Override
        public void onStreamDisabled(Stream stream) {
            if (stream.getKind().equals("share")) {
                shareView.removeTrack();
            }
        }
    });
}
```

</TabItem>

</Tabs>

:::info

- Here screenShare stream is displayed using `VideoView`, but you may also use `SurfaceViewRender` for the same.
- For `VideoView`, SDK version should be `0.1.13` or higher.
- To know more about `VideoView`, please visit [here](/android/guide/video-and-audio-calling-api-sdk/components/videoView)

:::


---

---
title: Set Participant Video Quality - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: Set Participant Video Quality features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Set Participant Video Quality
pagination_label: Set Participant Video Quality
keywords:
  - set video quality
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: set-participant-video-quality
---

import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>

# Set Participant Video Quality - Android

This feature allows participants to set other participant's video quality during the meeting.

:::info

MultiStream is not supported by the Android SDK. Use `customTrack` instead of `setQuality()` if you want to change participant's quality who joined using our Android SDK.

To know more about customTrack visit [here](/android/guide/video-and-audio-calling-api-sdk/features/custom-track/custom-video-track)

:::

## Set Quality

- `setQuality` method will accept `low`, `med` or `high` as string parameter.

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
private fun setQuality()
{
  val participants: Iterator<Participant> = meeting!!.participants.values.iterator()
  for (i in 0 until meeting!!.participants.size) {
    val participant = participants.next()

    participant.quality = "low"
    //or
    participant.quality = "med"
    //or
    participant.quality = "high"
  }
}
```

</TabItem>

<TabItem value="Java">

```js
private void setQuality() {
  final Iterator<Participant> participants = meeting.getParticipants().values().iterator();

  for (int i = 0; i < meeting.getParticipants().size(); i++) {
    Participant participant = participants.next();

    participant.setQuality("low");
    //or
    participant.setQuality("med");
    //or
    participant.setQuality("high");
  }
}
```

</TabItem>

</Tabs>


---

---
title: Set Viewport
hide_title: false
hide_table_of_contents: false
sidebar_label: Set Viewport
pagination_label: Set Viewport
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: set-viewport
---

import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>

# Set Viewport - Android

When you are working with Video Calling, video quality is the most important part of communication. When a participant is shown on the screen, consuming multiple high quality although not required, will result in more memory and CPU usage of the device, eventually degrading quality.

The way to optimze around these situation is to consume the video quality which is required to fit the view of a particular participant, resulting in better quality, less usage of network bandwith and providing a better experience.

Viewport is the size of window or visible area in which video for the participant is shown. We can optimize the consuming video quality based on the viewport size of the participant. For example if the viewport size of a particular participant view is `480x360`, VideoSDK will download a `480x360` stream. If a participant on screen is present in bigger size, VideoSDK will provide a higher quality video for that particular participant only.

import ReactPlayer from 'react-player'

<div style={{textAlign: 'center'}}>

<ReactPlayer autoplay muted loop playing url='/img/viewport_illustration.mp4' width={"100%"}/>

</div>

<br/>

:::info

MultiStream is not supported by the Android SDK. Use `customTrack` instead of `setViewPort()` if you want to change participant's quality who joined using our Android SDK.

To know more about customTrack visit [here](/android/guide/video-and-audio-calling-api-sdk/features/custom-track/custom-video-track)

:::

### setViewPort()

`setViewPort()` can be used to achieve the best optimization of the video. This method is called with the `width` and `height` of the participant view on the `Participant` object and VideoSDK will handle the rest.

##### Parameters

- `width`

  - type: `int`
  - Width of the participant view for which the quliaty of video is to be adjusted.

- `height`
  - type: `int`
  - Height of the participant view for which the quliaty of video is to be adjusted.

### Example

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
class ParticipantAdapter(meeting: Meeting) : RecyclerView.Adapter<ParticipantAdapter.PeerViewHolder() {

  //Your variables here

  override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): PeerViewHolder {
    containerHeight = parent.height
    return PeerViewHolder(
      LayoutInflater.from(parent.context)
        .inflate(R.layout.item_remote_peer, parent, false)
    )
  }

  override fun onBindViewHolder(holder: PeerViewHolder, position: Int) {
    val participant = participants[position]

    //View updates here

    //Update Consuming quality using setViewPort
    participant.setViewPort(holder.itemView.getWidth(), holder.itemView.getHeight());
  }
}

```

</TabItem>

<TabItem value="Java">

```js

public class ParticipantAdapter extends RecyclerView.Adapter<ParticipantAdapter.PeerViewHolder> {

  //Your variables here

  @NonNull
  @Override
  public PeerViewHolder onCreateViewHolder(@NonNull ViewGroup parent, int viewType) {
    containerHeight = parent.getHeight();

    return new PeerViewHolder(LayoutInflater.from(parent.getContext())
            .inflate(R.layout.item_remote_peer, parent, false));
  }

  @Override
  public void onBindViewHolder(@NonNull PeerViewHolder holder, int position) {
    final Participant participant = participants.get(position);

    //View updates here

    //Update Consuming quality using setViewPort
    participant.setViewPort(holder.itemView.getWidth(), holder.itemView.getHeight());
  }
}

```

</TabItem>

</Tabs>

The complete usage of this method can be seen here in the [code sample](https://github.com/videosdk-live/videosdk-rtc-android-java-sdk-example/blob/master/app/src/main/java/live/videosdk/rtc/android/java/ParticipantAdapter.java#L134)


---

---
title: Speaker Indication Video & Audio Call - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: Speaker Indication features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Speaker Indication
pagination_label: Speaker Indication
keywords:
  - Active Speaker
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: speaker-indication
---

import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>

# Speaker Indication - Android

Speaker indication feature in VideoSDK let you know, which participant is active speaker in a meeting.

Whenever any participant speaks in meeting, `onSpeakerChanged` event will trigger.

For example, the meeting is running with **Alice** and **Bob**. Whenever any of them speaks, `onSpeakerChanged` event will trigger and return the speaker `participantId`.

We can access `onSpeakerChanged` event through [meeting object](../../../api/sdk-reference/meeting-class/introduction.md).

### onSpeakerChanged Event

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
private val meetingEventListener: MeetingEventListener = object : MeetingEventListener() {
     // ...
    override fun onSpeakerChanged(participantId: String?) {
        Toast.makeText(this@MainActivity, "active Speaker Id" + participantId, Toast.LENGTH_SHORT).show();
        super.onSpeakerChanged(participantId)
    }
};
```

</TabItem>

<TabItem value="Java">

```js
private final MeetingEventListener meetingEventListener = new MeetingEventListener() {
     // ...
    @Override
    public void onSpeakerChanged(String participantId) {
        Toast.makeText(MainActivity.this, "active Speaker Id" + participantId, Toast.LENGTH_SHORT).show();
        super.onSpeakerChanged(participantId);
    }
};
```

</TabItem>

</Tabs>


---

---
title: Start join Meeting Video & Audio Call - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: Start or join Meeting features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Start or Join Meeting
pagination_label: Start or Join Meeting
keywords:
  - Join audio calling
  - Join video calling
  - Join real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: start-join-meeting
---

import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>

# Start or Join Meeting - Android

<div style={{display:'flex',flexDirection:'row',alignItems:'stretch',}}>
<div style={{}}>
<p>After the successful installation of VideoSDK, the next step is to integrate VideoSDK features with your webApp/MobileApp.</p>

<p>To Communicate with other participant's audio or video call, you will need to join the meeting.</p>

<p>This guide will provide an overview of how to configure, initialize and join a VideoSDK meeting.</p>

</div>
<div>
<img src="/img/gif/new-meeting.gif"/>
</div>

</div>

## 1. Configuration

To configure a meeting, you will need [generated token](/android/guide/video-and-audio-calling-api-sdk/server-setup) and [meetingId](/api-reference/realtime-communication/create-room), we had discussed in [Server Setup](/android/guide/video-and-audio-calling-api-sdk/server-setup).
This code snippet calls API from local server

**Scenario 1** - Suppose you **don't have** any meetingId, you can simply generate meetingId by invoking `create-meeting` API.

**Scenario 2** - Suppose you **have** meetingId, now you don't have to call `create-meeting` API to generate meetingId, instead you can call `validate-meeting` API to validate meetingId.

**Token generation API is necessary for both scenario.**

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
package live.videosdk.rtc.android.java;

import com.androidnetworking.AndroidNetworking;
import com.androidnetworking.error.ANError;
import com.androidnetworking.interfaces.JSONObjectRequestListener;
import org.json.JSONException;
import org.json.JSONObject;

class JoinActivity : AppCompatActivity() {
  private val apiServerUrl = "http://localhost:9000"

  // ...
  // onCreate() and other methods
  private fun getToken(@Nullable meetingId: String?) {
    AndroidNetworking
      .get("$apiServerUrl/get-token")
      .build()
      .getAsJSONObject(
        object : JSONObjectRequestListener {
          override fun onResponse(response: JSONObject) {
            try
            {
              token = response.getString("token")
              if (meetingId == null) {
                createMeeting(token)
              } else {
                joinMeeting(token, meetingId)
              }
            } catch (e: JSONException) {
              e.printStackTrace()
            }
          }

          override fun onError(anError: ANError) {
            anError.printStackTrace()
          }
        }
      )
  }

  private fun createMeeting(token: String) {
    AndroidNetworking
      .post("$apiServerUrl/create-meeting")
      .addBodyParameter("token", token)
      .build()
      .getAsJSONObject(
        object : JSONObjectRequestListener {
          override fun onResponse(response: JSONObject) {
            try {
              // final String meetingId = response.getString("meetingId");

              // Intent intent = new Intent(JoinActivity.this, MainActivity.class);
              // intent.putExtra("token", token);
              // intent.putExtra("meetingId", meetingId);

              // startActivity(intent);
            } catch (e: JSONException) {
                e.printStackTrace()
            }
          }

          override fun onError(anError: ANError) {
            anError.printStackTrace()
          }
        }
      )
  }

  private fun joinMeeting(token: String, meetingId: String) {
    AndroidNetworking
      .post("$apiServerUrl/validate-meeting/{meetingId}")
      .addPathParameter("meetingId", meetingId)
      .addBodyParameter("token", token)
      .build()
      .getAsJSONObject(
        object : JSONObjectRequestListener {
          override fun onResponse(response: JSONObject) {
            // Intent intent = new Intent(JoinActivity.this, MainActivity.class);
            // intent.putExtra("token", token);
            // intent.putExtra("meetingId", meetingId);

            // startActivity(intent);
          }

          override fun onError(anError: ANError) {
            anError.printStackTrace()
          }
        }
      )
  }
}

```

</TabItem>

<TabItem value="Java">

```js
package live.videosdk.rtc.android.java;

import com.androidnetworking.AndroidNetworking;
import com.androidnetworking.error.ANError;
import com.androidnetworking.interfaces.JSONObjectRequestListener;
import org.json.JSONException;
import org.json.JSONObject;

public class JoinActivity extends AppCompatActivity {
  private String apiServerUrl = "http://localhost:9000";

  // ...
  // onCreate() and other methods

  private void getToken(@Nullable String meetingId) {
    AndroidNetworking
      .get(apiServerUrl + "/get-token")
      .build()
      .getAsJSONObject(
        new JSONObjectRequestListener() {
          @Override
          public void onResponse(JSONObject response) {
            try {
              String token = response.getString("token");

              if (meetingId == null) {
                createMeeting(token);
              } else {
                joinMeeting(token, meetingId);
              }
            } catch (JSONException e) {
              e.printStackTrace();
            }
          }

          @Override
          public void onError(ANError anError) {
            anError.printStackTrace();
          }
        }
      );
  }

  private void createMeeting(String token) {
    AndroidNetworking
      .post(apiServerUrl + "/create-meeting")
      .addBodyParameter("token", token)
      .build()
      .getAsJSONObject(
        new JSONObjectRequestListener() {
          @Override
          public void onResponse(JSONObject response) {
            try {
              // final String meetingId = response.getString("meetingId");

              // Intent intent = new Intent(JoinActivity.this, MainActivity.class);
              // intent.putExtra("token", token);
              // intent.putExtra("meetingId", meetingId);

              // startActivity(intent);
            } catch (JSONException e) {
              e.printStackTrace();
            }
          }

          @Override
          public void onError(ANError anError) {
            anError.printStackTrace();
          }
        }
      );
  }

  private void joinMeeting(String token, String meetingId) {
    AndroidNetworking
      .post(apiServerUrl + "/validate-meeting/{meetingId}")
      .addPathParameter("meetingId", meetingId)
      .addBodyParameter("token", token)
      .build()
      .getAsJSONObject(
        new JSONObjectRequestListener() {
          @Override
          public void onResponse(JSONObject response) {
            // Intent intent = new Intent(JoinActivity.this, MainActivity.class);
            // intent.putExtra("token", token);
            // intent.putExtra("meetingId", meetingId);

            // startActivity(intent);
          }

          @Override
          public void onError(ANError anError) {
            anError.printStackTrace();
          }
        }
      );
  }
}

```

</TabItem>

</Tabs>

## 2. Initialization

import CautionMessage from '@site/src/theme/CautionMessage';


<CautionMessage sdk="Android SDK" version="v0.2.0" />

<div style={{display:'flex',flexDirection:'row',alignItems:'stretch',}}>
<div style={{}}>
<p>
After configuration, you will have to Initialize 
<p>
meeting by providing name, meetingId, micEnabled, webcamEnabled & maxResolution.
</p>
</p>

<p>
NOTE : For React & React native developer, you have

<p>to be familiar with hooks concept. You can understand hooks concept on <a href={'https://reactjs.org/docs/hooks-intro.html'}>React Hooks</a>.</p>

</p>
</div>
<div>
<img src="/img/gif/add-participant.gif"/>
</div>

</div>

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
import live.videosdk.rtc.android.VideoSDK;
import live.videosdk.rtc.android.Meeting;

class MainActivity : AppCompatActivity() {
  private var meeting: Meeting? = null

  override fun onCreate(savedInstanceState: Bundle?) {
    // Configure parameters
    val token = intent.getStringExtra("token")
    val meetingId = intent.getStringExtra("meetingId")
    val participantName = "John Doe"
    val micEnabled = true
    val webcamEnabled = true
    val paticipantId="demo@123"  // If you passed `null` then SDK will create an Id by itself and will use that id.
    val mode="SEND_AND_RECV"

    // Configure authentication token
    VideoSDK.config(token)

    // create a new meeting instance
    meeting = VideoSDK.initMeeting(
      this@MainActivity,
      meetingId,
      participantName,
      micEnabled,
      webcamEnabled,
      paticipantId,
      mode,
      null
    )
  }
}

```

</TabItem>

<TabItem value="Java">

```js
import live.videosdk.rtc.android.VideoSDK;
import live.videosdk.rtc.android.Meeting;

public class MainActivity extends AppCompatActivity {
    private Meeting meeting;

    @Override
    protected void onCreate(Bundle savedInstanceState) {

        // Configure parameters
        final String token = getIntent().getStringExtra("token");
        final String meetingId = getIntent().getStringExtra("meetingId");
        final String participantName = "John Doe";
        final boolean micEnabled = true;
        final boolean webcamEnabled = true;
        final String participantId = "demo@123"; // If you passed `null` then SDK will create an Id by itself and will use that id.
        final String mode="SEND_AND_RECV";

        // Configure authentication token
        VideoSDK.config(token);

        // create a new meeting instance
        meeting = VideoSDK.initMeeting(
                MainActivity.this,
                meetingId,
                participantName,
                micEnabled,
                webcamEnabled,
                participantId,
                mode,
                null
        );
    }
}

```

</TabItem>

</Tabs>

## 3. Join

<div style={{display:'flex',flexDirection:'row',alignItems:'stretch',}}>
<div style={{}}>
<p>
After configuration & initialization, the third step is to call join() to join a meeting.
</p>

<p>
After joining, you will be able to Manage Participant in a meeting.
</p>

</div>
<div>
<img src="/img/gif/join-meeting.gif"/>
</div>

</div>

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
// After receiving mic and webcam access permissions
// join the meeting
meeting!!.join()
```

</TabItem>

<TabItem value="Java">

```js
// After receiving mic and webcam access permissions
// join the meeting
meeting.join();
```

</TabItem>

</Tabs>

## Events

Following events are emitted on the `meeting` when it is successfully joined.

- Local Participant will receive a [`onMeetingJoined`](../../../api/sdk-reference/meeting-class/meeting-event-listener-class.md#onmeetingjoined) event when successfully joined.
- Remote Participant will receive a [`onParticipantJoined`](../../../api/sdk-reference/meeting-class/meeting-event-listener-class.md#onparticipantjoined) event with the newly joined [`Participant`](../../../api/sdk-reference/participant-class/introduction.md) object from the event callback.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
private final MeetingEventListener meetingEventListener = new MeetingEventListener() {
  override fun onMeetingJoined() {
    Log.d("#meeting", "onMeetingJoined()")
  }

  override fun onParticipantJoined(participant: Participant) {
    Log.d("#meeting", participant.displayName + " left");
  }
}
```

</TabItem>

<TabItem value="Java">

```javascript
private final MeetingEventListener meetingEventListener = new MeetingEventListener() {

  @Override
  public void onMeetingJoined() {
    Log.d("#meeting", "onMeetingJoined()");
  }

  @Override
  public void onParticipantJoined(Participant participant) {
    Log.d("#meeting", participant.getDisplayName() + " left");
  }
}
```

</TabItem>

</Tabs>


---

---
title: Toggle Participant Media
hide_title: false
hide_table_of_contents: false
description: Camera Controls features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Toggle Participant Media
pagination_label: Toggle Participant Media
keywords:
  - Camera on
  - Camera off
  - Webcam on
  - Webcam off
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: toggle-participant-media
---

import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>

# Toggle Participant Media - Android

Control other participant's webcam and mic.
For better idea, let's understand this with a real case scenario

**Scenario 1 (Online Class)** - In this scenario, the lecturer(Local Participant) will control the student's(Other Participant) webcam and mic as per his/her needs.

**Scenario 2 (Online Events)** - In this scenario, the event hosts will control the audience webcam and mic when someone wants to speak.

This guide will provide an overview of how to control other participant webcam and mic in a meeting.

1. **Enable Webcam of Participant** - By using `enableWebcam()` function, a `onWebcamRequested` event will trigger on requested participant side.

   **Example** : Meeting is running with **User A** and **User B**. Now **User A** wants to Enable Webcam of **User B**, so **User A** will use `enableWebcam()` function to request **User B**, after that **User B** recieve the `onWebcamRequested` event, from there user can either accept or reject the incoming request.

2. **Disable Webcam of Participant** - By using `disableWebcam()` function, webcam of that participant will be turned off.

   **Example** : **User A** wants to Disable Webcam of **User B**, so **User A** will use `disableWebcam()` function to Disable it without any request.

3. **Enable Mic of Participant** - By using `enableMic()` function, a `onMicRequested` event will trigger on requested participant side.

   **Example** : Meeting is running with **User A** and **User B**. Now **User A** wants to Enable Mic of **User B**, so **User A** will use `enableMic()` function to request **User B**, after that **User B** will receive the `onMicRequested` event, from there user can either accept or reject the incoming request.

4. **Disable Mic of Participant** - By using `disableMic()` function, Mic of that participant will disable.

   **Example** : **User A** wants to Disable Mic of **User B**, so **User A** will use `disableMic()` function to Disable it without any request.

:::note

To achieve this feature, you need to pass `allow_join` persmission while genearting token for meeting initialization. After that you will be able to access participant media methods.

[How to apply permission while generating token?](/android/guide/video-and-audio-calling-api-sdk/server-setup)

:::

### Request Media Methods

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
val participant = meeting!!.participants.get("<participant-id>")

// This will emit an event called "onWebcamRequested" to that particular participant
participant.enableWebcam()

// This will directly disable webcam of particular participant
participant.disableWebcam()

// This will emit an event called "onMicRequested" to that particular participant
participant.enableMic()

// This will directly disable mic of particular participant
participant.disableMic()
```

</TabItem>

<TabItem value="Java">

```js
Participant participant = meeting.getParticipants().get("<participant-id>");

// This will emit an event called "onWebcamRequested" to that particular participant
participant.enableWebcam();

// This will directly disable webcam of particular participant
participant.disableWebcam();

// This will emit an event called "onMicRequested" to that particular participant
participant.enableMic();

// This will directly disable mic of particular participant
participant.disableMic();
```

</TabItem>

</Tabs>

### Manage Requested Media Events

1. **onWebcamRequested** - This event will be emitted to the participant `B` when any other participant `A` requests to enable webcam of that participant `B`. This event handler will receieve following three arguments:

   - `accept()` - Callback function to accept the request.
   - `reject()` - Callback function to reject the request.

<div style={{height: "10px"}}></div>

2. **onMicRequested** - This event will be emitted to the participant `B` when any other participant `A` requests to enable mic of that participant `B`. This event handler will receieve following three arguments:

   - `accept()` - Callback function to accept the request.
   - `reject()` - Callback function to reject the request.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
object : MeetingEventListener() {
  override fun onMicRequested(participantId: String, listener: MicRequestListener) {
      // TODO: show dialog before accepting request
      listener.accept()
  }

  override fun onWebcamRequested(participantId: String, listener: WebcamRequestListener) {
      // TODO: show dialog before accepting request
      listener.accept()
  }
}
```

</TabItem>

<TabItem value="Java">

```js
new MeetingEventListener() {
  @Override
  public void onMicRequested(String participantId, MicRequestListener listener) {
      // TODO: show dialog before accepting request
      listener.accept();
  }

  @Override
  public void onWebcamRequested(String participantId, WebcamRequestListener listener) {
      // TODO: show dialog before accepting request
      listener.accept();
  }
}
```

</TabItem>

</Tabs>


---

---
title: Cloud Proxy | Secure and Manage Streaming Traffic | Video SDK
hide_title: true
hide_table_of_contents: false
description: Leverage Video SDK's Cloud Proxy to securely manage and optimize your video streaming traffic. Ideal for enhancing performance and securing data.
sidebar_label: Cloud Proxy
pagination_label: Cloud Proxy
keywords:
  - cloud proxy
  - secure streaming
  - video SDK security
  - traffic management
image: img/videosdklive-thumbnail.jpg
sidebar_position: 2
slug: cloud-proxy
---

# Cloud Proxy - Android

import CloudProxy from '../../../../../mdx/\_cloud-proxy.mdx';

<CloudProxy/>

## Implementation

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
val meeting: Meeting = VideoSDK.initMeeting(
      this@MainActivity, "meetingId", "John Due", true,
      true, null, null, false, null, null,"proxy.yourwebsite.com", VideoSDK.PreferredProtocol.UDP_ONLY
);
```

</TabItem>

<TabItem value="Java">

```java
Meeting meeting = VideoSDK.initMeeting(
      MainActivity.this, "meetingId", "John Due",true,
      true, null, null, false, null,null,"proxy.yourwebsite.com", VideoSDK.PreferredProtocol.UDP_ONLY
);
```

</TabItem>

</Tabs>
### Parameters
- preferredProtocol:
    - UDP_OVER_TCP (default): Initially the server attempts to establish a connection using UDP, if that fails it automatically switches to TCP protocol.
    - UDP_ONLY: Force UDP protocol
    - TCP_ONLY: Force TCP protocol
- signalingBaseUrl: Proxy URL to origin signaling and media.

## API Reference

The API references for all the methods and events utilized in this guide are provided below.

- [initMeeting()](/android/api/sdk-reference/initMeeting)


---

---
title: Geo Fencing | Location based Restrictions | Video SDK
hide_title: true
hide_table_of_contents: false
description: Implement geographic content restrictions with Video SDK's Geo Fencing feature. Essential for compliance and tailored content delivery based on user location.
sidebar_label: Geo Fencing
pagination_label: Geo Fencing
keywords:
- geo fencing
- geographic restrictions
- location based restrictions
- regional access
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: geo-fencing
---

# Geo Fencing - Android

import GeoFencing from '../../../../../mdx/\_geo-fencing.mdx';

<GeoFencing/>



---

---
title: Geo IP Restriction | Location Based Access Control | Video SDK
hide_title: true
hide_table_of_contents: false
description: Utilize Video SDK’s Geo IP Restriction to enforce access based on user geography. This feature is crucial for adhering to location-specific regulations and ensuring content is appropriately localized.
sidebar_label: Geo IP Restriction
pagination_label: Geo IP Restriction
keywords:
- geo ip restriction
- geographic access control
- location based security
- regional compliance
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: geo-ip-restriction
---

# Geo IP Restrictions  - Android

import GeoIpRestriction from '../../../../../mdx/\_geo-ip-restriction.mdx';

<GeoIpRestriction/>



---

---
title: Error Events | Video SDK
hide_title: true
hide_table_of_contents: false
description: Video SDK and Audio SDK, developers need to implement a token server. This requires efforts on both the front-end and backend.
sidebar_label: Error Events
pagination_label: Error Events
keywords:
  - audio calling
  - video calling
  - real-time communication
  - collaboration
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: error-events
---

import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>

# Error Events - Android

VideoSDK provides `onError` event which will notify you of any error happening during the meeting.

### onError

- This event will be triggered whenever any invalid configuration provided or server/network errors arise, this event will trigger with a specific error code and message.
- This event is helpful for development level troubleshooting while integrating SDK.
- You can implement this method of the abstract Class `MeetingEventListener` and add the listener to `Meeting` class using the `addEventListener()` method of `Meeting` Class.

### Example

Here is the usage of the event mentioned in this page.

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
private val meetingEventListener: MeetingEventListener = object : MeetingEventListener() {
  //..
  override fun onError(error: JSONObject) {
  try {
      val errorCodes: JSONObject = VideoSDK.getErrorCodes()
      val code = error.getInt("code")
      Log.d("#error", "Error is: " + error["message"])
  } catch (e: Exception) {
          e.printStackTrace()
      }
  }
}
```

</TabItem>

<TabItem value="Java">

```js
private final MeetingEventListener meetingEventListener = new MeetingEventListener() {
  //..
  @Override
  public void onError(JSONObject error) {
      try {
          JSONObject errorCodes = VideoSDK.getErrorCodes();
          int code = error.getInt("code");
          Log.d("#error", "Error is: " + error.get("message"));
      } catch (Exception e) {
          e.printStackTrace();
      }
  }
};
```

</TabItem>

</Tabs>

### Error Codes

We have depicted a specific constant with code and message in the below table.

import ServerErrorCodes from '../../../../../mdx/\_server-error-codes.mdx'
import SDKErrorCodes from '../../../data/\_sdk-error-codes.mdx'

<ServerErrorCodes />

<SDKErrorCodes/>

### API Reference

The API references for all the methods and events utilised in this guide are provided below.

- [onError()](/android/api/sdk-reference/error-codes)


---

---
title: External Call Detection Video & Audio Call - Video SDK Docs
hide_title: false
hide_table_of_contents: false
sidebar_label: External Call Detection Event
pagination_label: External Call Detection Event
keywords:
  - External Call Detection
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: external-call-detection-event
---

# External Call Detection Event - Android

External call detection event in VideoSDK let you know, participant is on the call during meeting.

Whenever local participant accept the incoming call or place outgoing call, `externalcall-started` event will trigger.`externalcall-started` event only received by localParticipant.

For example, the meeting is running with **Alice** and **Bob**. Whenever **Alice** receives the call or she call someone, **Alice** will receive `externalcall-started` event.

We can access `externalcall-started` event through `Meeting` class.

### externalcall-started Event

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
private val meetingEventListener: MeetingEventListener = object : MeetingEventListener() {
     // ...
    override fun onExternalCallStarted() {
      Log.d("#VideoSDK", "onExternalCallAnswered")
    }
};

override fun onCreate(savedInstanceState: Bundle?) {
  //...

  // add listener to meeting
  //highlight-next-line
  meeting!!.addEventListener(meetingEventListener)
}
```

</TabItem>

<TabItem value="Java">

```js
private final MeetingEventListener meetingEventListener = new MeetingEventListener() {
     // ...
    @Override
    public void onExternalCallStarted() {
        Log.d("#VideoSDK", "onExternalCallStarted");
    }
};

@Override
protected void onCreate(Bundle savedInstanceState) {
  //...

  // add listener to meeting
  //highlight-next-line
  meeting.addEventListener(meetingEventListener);
}
```

</TabItem>

</Tabs>


---

---
title: HLS Events | Video SDK
hide_title: true
hide_table_of_contents: false
description: Video SDK and Audio SDK, developers need to implement a token server. This requires efforts on both the front-end and backend.
sidebar_label: HLS Events
pagination_label: HLS Events
keywords:
  - audio calling
  - video calling
  - real-time communication
  - collaboration
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: hls-events
---

# HLS Events - Android

VideoSDK provides `onHlsStateChanged` event which will notify you of the current state of HLS for the meeting.

### onHlsStateChanged

- This event will be triggered when the meeting's HLS status changed.
- You can implement this method of the abstract Class `MeetingEventListener` and add the listener to `Meeting` class using the `addEventListener()` method of `Meeting` Class.
- when you receive `HLS_PLAYABLE` status you will receive 2 urls in response
  - `playbackHlsUrl` - Live HLS with playback support
  - `livestreamUrl` - Live HLS without playback support

:::note
`downstreamUrl` is now depecated. Use `playbackHlsUrl` or `livestreamUrl` in place of `downstreamUrl`
:::

### Example

Here is the usage of the event mentioned in this page.

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
private val meetingEventListener: MeetingEventListener = object : MeetingEventListener() {
  override fun onHlsStateChanged(HlsState: JSONObject) {
    when (HlsState.getString("status")) {
        "HLS_STARTING" -> Log.d("onHlsStateChanged", "Meeting hls is starting")
        "HLS_STARTED" -> Log.d("onHlsStateChanged", "Meeting hls is started")
        "HLS_PLAYABLE" -> {
            Log.d("onHlsStateChanged", "Meeting hls is playable now")
            // on hls playable you will receive playbackHlsUrl and livestreamUrl
            val playbackHlsUrl = HlsState.getString("playbackHlsUrl")
            val livestreamUrl = HlsState.getString("livestreamUrl")
        }
        "HLS_STOPPING" -> Log.d("onHlsStateChanged", "Meeting hls is stopping")
        "HLS_STOPPED" -> Log.d("onHlsStateChanged", "Meeting hls is stopped")
    }
  }
}

override fun onCreate(savedInstanceState: Bundle?) {
  //...

  // add listener to meeting
  //highlight-next-line
  meeting!!.addEventListener(meetingEventListener)
}
```

</TabItem>

<TabItem value="Java">

```js
private final MeetingEventListener meetingEventListener = new MeetingEventListener() {
  @Override
  public void onHlsStateChanged(JSONObject HlsState) {
      switch (HlsState.getString("status")) {
          case "HLS_STARTING":
              Log.d("onHlsStateChanged", "Meeting hls is starting");
              break;
          case "HLS_STARTED":
              Log.d("onHlsStateChanged", "Meeting hls is started");
              break;
          case "HLS_PLAYABLE":
              Log.d("onHlsStateChanged", "Meeting hls is playable now");
              // on hls started you will receive playbackHlsUrl and livestreamUrl
              String playbackHlsUrl = HlsState.getString("playbackHlsUrl");
              String livestreamUrl = HlsState.getString("livestreamUrl");
              break;
          case "HLS_STOPPING":
              Log.d("onHlsStateChanged", "Meeting hls is stopping");
              break;
          case "HLS_STOPPED":
              Log.d("onHlsStateChanged", "Meeting hls is stopped");
              break;
      }
  }
}

@Override
protected void onCreate(Bundle savedInstanceState) {
  //...

  // add listener to meeting
  //highlight-next-line
  meeting.addEventListener(meetingEventListener);
}
```

</TabItem>

</Tabs>

### API Reference

The API references for all the methods and events utilised in this guide are provided below.

- [onHlsStateChanged()](/android/api/sdk-reference/meeting-class/meeting-event-listener-class#onhlsstatechanged)


---

---
title: Media Events | Video SDK
hide_title: true
hide_table_of_contents: false
description: Video SDK and Audio SDK, developers need to implement a token server. This requires efforts on both the front-end and backend.
sidebar_label: Media Events
pagination_label: Media Events
keywords:
  - audio calling
  - video calling
  - real-time communication
  - collaboration
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: media-events
---

# Media Events - Android

VideoSDK provides multiple types of events which can be listened to know the about the participant's media status in the meeting.

You can implement all the methods of `ParticipantEventListener` abstract Class and add the listener to `Participant` class using the `addEventListener()` method of `Participant` Class.

Here are the events which specifically relate to the stream.

### onStreamEnabled

- This event is triggered whenever a participant's video, audio or screen share stream is enabled.

### onStreamDisabled

- This event is triggered whenever a participant's video, audio or screen share stream is disabled.

### Example

Here is the usage of all the events mentioned in this page.

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
participant.addEventListener(object : ParticipantEventListener() {
  override fun onStreamEnabled(stream: Stream) {
    Log.d("VideoSDK","onStreamEnabled $stream");
  }

  override fun onStreamDisabled(stream: Stream) {
    Log.d("VideoSDK","onStreamDisabled $stream");
  }
});
```

</TabItem>

<TabItem value="Java">

```js
participant.addEventListener(new ParticipantEventListener() {
  @Override
  public void onStreamEnabled(Stream stream) {
    Log.d("VideoSDK","onStreamEnabled" + stream);
  }

  @Override
  public void onStreamDisabled(Stream stream) {
    Log.d("VideoSDK","onStreamDisabled" + stream);
  }
});
```

</TabItem>

</Tabs>

### API Reference

The API references for all the methods and events utilised in this guide are provided below.

- [onStreamEnabled()](/android/api/sdk-reference/participant-class/participant-event-listener-class#onstreamenabled)
- [onStreamDisabled()](/android/api/sdk-reference/participant-class/participant-event-listener-class#onstreamdisabled)


---

---
title: Meeting Connection Events | Video SDK
hide_title: true
hide_table_of_contents: false
description: Video SDK and Audio SDK, developers need to implement a token server. This requires efforts on both the front-end and backend.
sidebar_label: Meeting Connection Events
pagination_label: Meeting Connection Events
keywords:
  - audio calling
  - video calling
  - real-time communication
  - collaboration
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: meeting-connection-events
---

# Meeting Connection Events - Android

VideoSDK provides `onMeetingStateChanged` event which will notify you of the current connection state of the meeting.

### onMeetingStateChanged

- This event will be triggered when state of meeting changes.
- It will pass **`state`** as an event callback parameter which will indicate current state of the meeting.
- All available states are `CONNECTING`, `CONNECTED`, `FAILED`, `DISCONNECTED`, `CLOSING`, `CLOSED`.
- You can implement this method of the abstract Class `MeetingEventListener` and add the listener to `Meeting` class using the `addEventListener()` method of `Meeting` Class.

### Example

Here is the usage of the event mentioned in this page.

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
private val meetingEventListener: MeetingEventListener = object : MeetingEventListener() {
  override fun onMeetingStateChanged(state: String?) {
      when (state) {
        "CONNECTING" -> Log.d("onMeetingStateChanged: ", "Meeting is Connecting")
        "CONNECTED" -> Log.d("onMeetingStateChanged: ", "Meeting is Connected")
        "FAILED" -> Log.d("onMeetingStateChanged: ", "Meeting connection failed")
        "DISCONNECTED" -> Log.d("onMeetingStateChanged: ","Meeting connection disconnected abruptly")
        "CLOSING" -> Log.d("onMeetingStateChanged: ", "Meeting is closing")
        "CLOSED" -> Log.d("onMeetingStateChanged: ", "Meeting connection closed")
      }
  }
}

override fun onCreate(savedInstanceState: Bundle?) {
  //...

  // add listener to meeting
  //highlight-next-line
  meeting!!.addEventListener(meetingEventListener)
}
```

</TabItem>

<TabItem value="Java">

```javascript
private final MeetingEventListener meetingEventListener = new MeetingEventListener() {
  @Override
  public void onMeetingStateChanged(String state) {
    switch (state) {
        case "CONNECTING":
          Log.d("onMeetingStateChanged: ", "Meeting is Connecting");
          break;
        case "CONNECTED":
          Log.d("onMeetingStateChanged: ", "Meeting is Connected");
          break;
        case "FAILED":
          Log.d("onMeetingStateChanged: ", "Meeting connection failed");
          break;
        case "DISCONNECTED":
          Log.d("onMeetingStateChanged: ", "Meeting connection disconnected abruptly");
          break;
        case "CLOSING":
          Log.d("onMeetingStateChanged: ", "Meeting is closing");
          break;
        case "CLOSED":
          Log.d("onMeetingStateChanged: ", "Meeting connection closed");
          break;
    }
  }
}

@Override
protected void onCreate(Bundle savedInstanceState) {
  //...

  // add listener to meeting
  //highlight-next-line
  meeting.addEventListener(meetingEventListener);
}
```

</TabItem>

</Tabs>

### API Reference

The API references for all the methods and events utilised in this guide are provided below.

- [onMeetingStateChanged()](/android/api/sdk-reference/meeting-class/meeting-event-listener-class#onmeetingstatechanged)


---

---
title: Meeting Events | Video SDK
hide_title: true
hide_table_of_contents: false
description: Video SDK and Audio SDK, developers need to implement a token server. This requires efforts on both the front-end and backend.
sidebar_label: Meeting Events
pagination_label: Meeting Events
keywords:
  - audio calling
  - video calling
  - real-time communication
  - collaboration
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: meeting-events
---

# Meeting Events - Android

VideoSDK provides multiple types of events which can be listened to know the current state of the meeting.

You can implement all the methods of `MeetingEventListener` abstract Class and add the listener to `Meeting` class using the `addEventListener()` method of `Meeting` Class.

Here are the events which specifically relate to the meeting.

### onMeetingJoined

- This event is triggered when the meeting is successfully joined.

### onMeetingLeft

- This event is triggered when the meeting is left.

### onSpeakerChanged

- This event is triggered when the active speaker in the meeting gets changed.

### onPresenterChanged

- This event is triggered when the presenter in the meeting gets changed.

### Example

Here is the usage of all the events mentioned in this page.

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
private val meetingEventListener: MeetingEventListener = object : MeetingEventListener() {
  override fun onMeetingJoined() {
      Log.d("VideoSDK", "onMeetingJoined: ")
  }

  override fun onMeetingLeft() {
      Log.d("VideoSDK", "onMeetingLeft: ")
  }

  override fun onSpeakerChanged(participantId: String) {
      Log.d("VideoSDK", "onSpeakerChanged: $participantId")
  }

  override fun onPresenterChanged(participantId: String) {
      Log.d("VideoSDK", "onPresenterChanged: $participantId")
  }
}

override fun onCreate(savedInstanceState: Bundle?) {
  //...

  // add listener to meeting
  //highlight-next-line
  meeting!!.addEventListener(meetingEventListener)
}
```

</TabItem>

<TabItem value="Java">

```js
private final MeetingEventListener meetingEventListener = new MeetingEventListener() {
  @Override
  public void onMeetingJoined() {
    Log.d("VideoSDK", "onMeetingJoined: ");
  }

  @Override
  public void onMeetingLeft() {
    Log.d("VideoSDK", "onMeetingLeft: ");
  }

  @Override
  public void onSpeakerChanged(String participantId) {
    Log.d("VideoSDK", "onSpeakerChanged: " + participantId);
  }

  @Override
  public void onPresenterChanged(String participantId) {
    Log.d("VideoSDK", "onPresenterChanged: " + participantId);
  }
};

@Override
protected void onCreate(Bundle savedInstanceState) {
  //...

  // add listener to meeting
  //highlight-next-line
  meeting.addEventListener(meetingEventListener);
}
```

</TabItem>

</Tabs>

### API Reference

The API references for all the methods and events utilised in this guide are provided below.

- [onMeetingJoined()](/android/api/sdk-reference/meeting-class/meeting-event-listener-class#onmeetingjoined)
- [onMeetingLeft()](/android/api/sdk-reference/meeting-class/meeting-event-listener-class#onmeetingleft)
- [onSpeakerChanged()](/android/api/sdk-reference/meeting-class/meeting-event-listener-class#onspeakerchanged)
- [onPresenterChanged()](/android/api/sdk-reference/meeting-class/meeting-event-listener-class#onpresenterchanged)


---

---
title: Participant Events | Video SDK
hide_title: true
hide_table_of_contents: false
description: Video SDK and Audio SDK, developers need to implement a token server. This requires efforts on both the front-end and backend.
sidebar_label: Participant Events
pagination_label: Participant Events
keywords:
  - audio calling
  - video calling
  - real-time communication
  - collaboration
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: participant-events
---

# Participant Events - Android

VideoSDK provides multiple types of events which can be listened to know the about the participants in the meeting.

You can implement all the methods of `MeetingEventListener` abstract Class and add the listener to `Meeting` class using the `addEventListener()` method of `Meeting` Class.

Here are the events which specifically relate to the participants.

### onParticipantJoined

- This event is triggered when someone joins the meeting and return the `Participant` object as parameter.

### onParticipantLeft

- This event is triggered when the someone leaves the meeting.

### onWebcamRequested

- This event will be triggered to the participant `B` when any other participant `A` requests to enable webcam of participant `B`.
- On accepting the request, webcam of participant `B` will be enabled.

### onMicRequested

- This event will be triggered to the participant `B` when any other participant `A` requests to enable mic of participant `B`.
- On accepting the request, mic of participant `B` will be enabled.
- This event can be subscribed from the `useMeeting` hook.

### Example

Here is the usage of all the events mentioned in this page.

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
private val meetingEventListener: MeetingEventListener = object : MeetingEventListener() {
  override fun onParticipantJoined(participant: Participant) {
    Log.d("VideoSDK", participant.displayName + " joined");
  }

  override fun onParticipantLeft(participant: Participant) {
    Log.d("VideoSDK", participant.displayName + " left");
  }

  override fun onWebcamRequested(participantId: String, listener: WebcamRequestListener) {

    // participantId, will be the id of participant who requested to enable mic

    // if accept request
    listener.accept()

    // if reject request
    listener.reject()
  }

  override fun onMicRequested(participantId: String, listener: MicRequestListener) {

    // participantId, will be the id of participant who requested to enable mic

    // if accept request
    listener.accept()

    // if reject request
    listener.reject()
  }
}

override fun onCreate(savedInstanceState: Bundle?) {
  //...

  // add listener to meeting
  //highlight-next-line
  meeting!!.addEventListener(meetingEventListener)
}
```

</TabItem>

<TabItem value="Java">

```javascript
private final MeetingEventListener meetingEventListener = new MeetingEventListener() {
  @Override
  public void onParticipantJoined(Participant participant) {
      Log.d("VideoSDK", participant.getDisplayName() + " joined");
  }

  @Override
  public void onParticipantLeft(Participant participant) {
      Log.d("VideoSDK", participant.getDisplayName() + " left");
  }

  @Override
  public void onWebcamRequested(String participantId, WebcamRequestListener listener) {

    // participantId, will be the id of participant who requested to enable webcam

    // if accept request
    listener.accept();

    // if reject request
    listener.reject();
  }

  @Override
  public void onMicRequested(String participantId, MicRequestListener listener) {

    // participantId, will be the id of participant who requested to enable mic

    // if accept request
    listener.accept();

    // if reject request
    listener.reject();
 }
}

@Override
protected void onCreate(Bundle savedInstanceState) {
  //...

  // add listener to meeting
  //highlight-next-line
  meeting.addEventListener(meetingEventListener);
}
```

</TabItem>

</Tabs>

### API Reference

The API references for all the methods and events utilised in this guide are provided below.

- [onParticipantJoined()](/android/api/sdk-reference/meeting-class/meeting-event-listener-class#onparticipantjoined)
- [onParticipantLeft()](/android/api/sdk-reference/meeting-class/meeting-event-listener-class#onparticipantleft)
- [onWebcamRequested()](/android/api/sdk-reference/meeting-class/meeting-event-listener-class#onwebcamrequested)
- [onMicRequested()](/android/api/sdk-reference/meeting-class/meeting-event-listener-class#onmicrequested)


---

---
title: Recording Events | Video SDK
hide_title: true
hide_table_of_contents: false
description: Video SDK and Audio SDK, developers need to implement a token server. This requires efforts on both the front-end and backend.
sidebar_label: Recording Events
pagination_label: Recording Events
keywords:
  - audio calling
  - video calling
  - real-time communication
  - collaboration
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: recording-events
---

# Recording Events - Android

VideoSDK provides `onRecordingStateChanged` event which will notify you of the current state of recording for the meeting.

### onRecordingStateChanged

- This event will be triggered when the meeting's recording status changed.
- You can implement this method of the abstract Class `MeetingEventListener` and add the listener to `Meeting` class using the `addEventListener()` method of `Meeting` Class.

### Example

Here is the usage of the event mentioned in this page.

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
private val meetingEventListener: MeetingEventListener = object : MeetingEventListener() {
  override fun onRecordingStateChanged(recordingState: String) {
    when (recordingState) {
        "RECORDING_STARTING" -> {
            Log.d("onRecordingStateChanged", "Meeting recording is starting")
        }
        "RECORDING_STARTED" -> {
            Log.d("onRecordingStateChanged", "Meeting recording is started")
        }
        "RECORDING_STOPPING" -> {
            Log.d("onRecordingStateChanged", "Meeting recording is stopping")
        }
        "RECORDING_STOPPED" -> {
            Log.d("onRecordingStateChanged", "Meeting recording is stopped")
        }
    }
  }
}

override fun onCreate(savedInstanceState: Bundle?) {
  //...

  // add listener to meeting
  //highlight-next-line
  meeting!!.addEventListener(meetingEventListener)
}
```

</TabItem>

<TabItem value="Java">

```js
private final MeetingEventListener meetingEventListener = new MeetingEventListener() {
  @Override
  public void onRecordingStateChanged(String recordingState) {
      switch (recordingState) {
          case "RECORDING_STARTING":
              Log.d("onRecordingStateChanged", "Meeting recording is starting");
              break;
          case "RECORDING_STARTED":
              Log.d("onRecordingStateChanged", "Meeting recording is started");
              break;
          case "RECORDING_STOPPING":
              Log.d("onRecordingStateChanged", "Meeting recording is stopping");
              break;
          case "RECORDING_STOPPED":
              Log.d("onRecordingStateChanged", "Meeting recording is stopped");
              break;
      }
  }
}

@Override
protected void onCreate(Bundle savedInstanceState) {
  //...

  // add listener to meeting
  //highlight-next-line
  meeting.addEventListener(meetingEventListener);
}
```

</TabItem>

</Tabs>

### API Reference

The API references for all the methods and events utilised in this guide are provided below.

- [onRecordingStateChanged()](/android/api/sdk-reference/meeting-class/meeting-event-listener-class#onrecordingstatechanged)


---

---
title: RTMP Events | Video SDK
hide_title: true
hide_table_of_contents: false
description: Video SDK and Audio SDK, developers need to implement a token server. This requires efforts on both the front-end and backend.
sidebar_label: RTMP Events
pagination_label: RTMP Events
keywords:
  - audio calling
  - video calling
  - real-time communication
  - collaboration
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: rtmp-events
---

# RTMP Events - Android

VideoSDK provides `onLivestreamStateChanged` event which will notify you of the current state of livestream for the meeting.

### onLivestreamStateChanged

- This event will be triggered when the meeting's livestream status changed.
- You can implement this method of the abstract Class `MeetingEventListener` and add the listener to `Meeting` class using the `addEventListener()` method of `Meeting` Class.

### Example

Here is the usage of the event mentioned in this page.

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
private val meetingEventListener: MeetingEventListener = object : MeetingEventListener() {
  override fun onLivestreamStateChanged(livestreamState: String?) {
    when (livestreamState) {
      "LIVESTREAM_STARTING" -> Log.d( "LivestreamStateChanged",
          "Meeting livestream is starting"
      )
      "LIVESTREAM_STARTED" -> Log.d( "LivestreamStateChanged",
          "Meeting livestream is started"
      )
      "LIVESTREAM_STOPPING" -> Log.d("LivestreamStateChanged",
          "Meeting livestream is stopping"
      )
      "LIVESTREAM_STOPPED" -> Log.d("LivestreamStateChanged",
          "Meeting livestream is stopped"
      )
    }
  }
}

override fun onCreate(savedInstanceState: Bundle?) {
  //...

  // add listener to meeting
  //highlight-next-line
  meeting!!.addEventListener(meetingEventListener)
}
```

</TabItem>

<TabItem value="Java">

```js
private final MeetingEventListener meetingEventListener = new MeetingEventListener() {
  @Override
  public void onLivestreamStateChanged(String livestreamState) {
    switch (livestreamState) {
      case "LIVESTREAM_STARTING":
          Log.d("LivestreamStateChanged", "Meeting livestream is starting");
          break;
      case "LIVESTREAM_STARTED":
          Log.d("LivestreamStateChanged", "Meeting livestream is started");
          break;
      case "LIVESTREAM_STOPPING":
          Log.d("LivestreamStateChanged", "Meeting livestream is stopping");
          break;
      case "LIVESTREAM_STOPPED":
          Log.d("LivestreamStateChanged", "Meeting livestream is stopped");
          break;
    }
  }
}

@Override
protected void onCreate(Bundle savedInstanceState) {
  //...

  // add listener to meeting
  //highlight-next-line
  meeting.addEventListener(meetingEventListener);
}
```

</TabItem>

</Tabs>

### API Reference

The API references for all the methods and events utilised in this guide are provided below.

- [onLivestreamStateChanged()](/android/api/sdk-reference/meeting-class/meeting-event-listener-class#onlivestreamstatechanged)


---

---
title: Get Started with Video & Audio Call - Video SDK Documentation
hide_title: true
hide_table_of_contents: false
description: Video SDK enables the opportunity to integrate native IOS, Android & Web SDKs to add live video & audio conferencing to your applications.
sidebar_label: Getting Started
pagination_label: Getting Started
keywords:
  - audio calling
  - video calling
  - real-time communication
  - collaboration
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: getting-started
---

import Mermaid from '@theme/Mermaid';
import GettingStarted from '/mdx/introduction/\_getting-started.mdx';
import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>
<GettingStarted title="Get Started with Android" />

## Steps

import Card from '@theme/Card';

<div class="container guide-steps-block">
  <div class="row ">
    <div class="col col--6">
      <Card heading="1. Get your API key and Secret" link="/android/guide/video-and-audio-calling-api-sdk/signup-and-create-api" description="Generate your API key and Secret from Video SDK." />
    </div>
     <div class="col col--6">
      <Card heading="2. Client Setup for Android" link="/android/guide/video-and-audio-calling-api-sdk/android-sdk" description="Easy to integrate SDK with cross-channel support." />
    </div>
  </div>
  <div class="row ">
   <div class="col col--6" >
      <Card heading="3. Authentication and Tokens" link="/android/guide/video-and-audio-calling-api-sdk/server-setup" description="Setup secured server authentication and authorization."  />
    </div>
    <div class="col col--6">
      <Card heading="4. Start a Audio / Video Call" link="/android/guide/video-and-audio-calling-api-sdk/quick-start" description="Get started with step by step guide of integrating Video SDK." />
    </div>
  </div>
  <div class="row ">
   <div class="col col--6" >
      <Card heading="5. Basic Features" link="/android/guide/video-and-audio-calling-api-sdk/features/start-join-meeting" description="Explore basic features such as join, leave and customise sessions."  />
    </div>
    <div class="col col--6">
      <Card heading="6. Advanced Features" link="/android/guide/video-and-audio-calling-api-sdk/features/error-event" description="Explore advanced features such as screen sharing, recording and live streaming." />
    </div>
  </div>
</div>

## Architecture

This diagram demonstrates end-to-end flow to implement video & audio calling, record calls and go-live on social media.

![Video-sdk-architecture!](/img/video-sdk-archietecture.svg)


---

---
title: Active Speaker Indication | Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: Speaker Indication features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Active Speaker Indication
pagination_label: Active Speaker Indication
keywords:
  - Active Speaker
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: active-speaker-indication
---

# Active Speaker Indication - Android

Active Speaker indication feature in VideoSDK let you know, which participant in a meeting is active speaker. This feature can be particularly useful in larger meetings or webinars, where there may be many participants and it can be difficult to tell who is speaking.

Whenever any participant speaks in meeting, `onSpeakerChanged` event will trigger with the participant id of the active speaker.

For example, the meeting is running with **Alice** and **Bob**. Whenever any of them speaks, `onSpeakerChanged` event will trigger and return the speaker `participantId`.

### Event

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
private val meetingEventListener: MeetingEventListener = object : MeetingEventListener() {
    override fun onSpeakerChanged(participantId: String?) {
        Toast.makeText(this@MainActivity, "Active Speaker participantId" + participantId, Toast.LENGTH_SHORT).show();
        super.onSpeakerChanged(participantId)
    }
};
```

</TabItem>

<TabItem value="Java">

```js
private final MeetingEventListener meetingEventListener = new MeetingEventListener() {
    @Override
    public void onSpeakerChanged(String participantId) {
        Toast.makeText(MainActivity.this, "Active Speaker participantId" + participantId, Toast.LENGTH_SHORT).show();
        super.onSpeakerChanged(participantId);
    }
};
```

</TabItem>

</Tabs>

### API Reference

The API references for all the methods and events utilised in this guide are provided below.

- [onSpeakerChanged()](/android/api/sdk-reference/meeting-class/meeting-event-listener-class#onspeakerchanged)


---

---
title: Change Input/Output Device | Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: Speaker Indication features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Change Input/Output Device
pagination_label: Change Input/Output Device
keywords:
  - Active Speaker
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: change-input-output-device
---

# Change Input/Output Device - Android

During the meeting at any point a participant wishes to switch his/her audio or video device, it can be done using the below mentioned methods.

## Changing Input/Output Audio Device

### `getMics()`

- The `getMics()` method will return a list of all available microphones that are connected to the mobile device.

- This method will return a Set of `AppRTCAudioManager.AudioDevice`.

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
  private fun getMics(): MutableSet<AppRTCAudioManager.AudioDevice>? {
    //highlight-next-line
    val mics= meeting!!.mics
    return mics  // returns all connected mics
  }
```

</TabItem>

<TabItem value="Java">

```js
  private Set<AppRTCAudioManager.AudioDevice> getMics() {
    //highlight-next-line
    Set<AppRTCAudioManager.AudioDevice> mics = meeting.getMics();
    return mics; // returns all connected mics
  }
```

</TabItem>

</Tabs>

### `changeMic()`

- Participant can change the audio device using `changeMic(AppRTCAudioManager.AudioDevice device)` method of `Meeting` class.

- Parameters that can be passed to `changeMic` are

  | Audio Devices                                | Usage                        |
  | -------------------------------------------- | ---------------------------- |
  | AppRTCAudioManager.AudioDevice.BLUETOOTH     | For Bluetooth Device.        |
  | AppRTCAudioManager.AudioDevice.WIRED_HEADSET | For Wired Handset Device.    |
  | AppRTCAudioManager.AudioDevice.SPEAKER_PHONE | For Inbuilt - Speaker Device |
  | AppRTCAudioManager.AudioDevice.EARPIECE      | For Earpiece Device          |

- When participant changes the Mic, `AppRTCAudioManager.AudioManagerEvents()` is triggered which can be set to `Meeting` class by using `setAudioDeviceChangeListener()`.

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js

  btnChangeMic!!.setOnClickListener { _: View? ->
  // Change Mic during Meeting
  //highlight-next-line
    meeting!!.changeMic(AppRTCAudioManager.AudioDevice.BLUETOOTH)
  }

  private fun setAudioDeviceListeners() {
    //highlight-start
    meeting!!.setAudioDeviceChangeListener(object : AudioManagerEvents {
      override fun onAudioDeviceChanged(
        selectedAudioDevice: AppRTCAudioManager.AudioDevice,
        availableAudioDevices: Set<AppRTCAudioManager.AudioDevice>
      ) {
          when (selectedAudioDevice) {
            AppRTCAudioManager.AudioDevice.BLUETOOTH ->
              Toast.makeText(this@MainActivity, "Selected AudioDevice: BLUETOOTH", Toast.LENGTH_SHORT).show()

            AppRTCAudioManager.AudioDevice.WIRED_HEADSET ->
              Toast.makeText(this@MainActivity, "Selected AudioDevice: WIRED_HEADSET", Toast.LENGTH_SHORT).show()

            AppRTCAudioManager.AudioDevice.SPEAKER_PHONE ->
              Toast.makeText(this@MainActivity, "Selected AudioDevice: SPEAKER_PHONE", Toast.LENGTH_SHORT).show()

            AppRTCAudioManager.AudioDevice.EARPIECE ->
              Toast.makeText(this@MainActivity, "Selected AudioDevice: EARPIECE", Toast.LENGTH_SHORT).show()
          }
        }
    })
    //highlight-end
  }

  override fun onCreate(savedInstanceState: Bundle?) {
       // ...
       setAudioDeviceListeners()
  }
```

</TabItem>

<TabItem value="Java">

```js
  btnChangeMic.setOnClickListener(new View.OnClickListener() {
      @Override
      public void onClick(View v) {
        // Change Mic during Meeting
        //highlight-next-line
        meeting.changeMic(AppRTCAudioManager.AudioDevice.BLUETOOTH);
      }
  });

  private void setAudioDeviceListeners() {
    //highlight-start
    meeting.setAudioDeviceChangeListener(new AppRTCAudioManager.AudioManagerEvents() {
         @Override
        public void onAudioDeviceChanged(AppRTCAudioManager.AudioDevice selectedAudioDevice, Set<AppRTCAudioManager.AudioDevice> availableAudioDevices) {
            switch (selectedAudioDevice) {
                case BLUETOOTH:
                  Toast.makeText(MainActivity.this, "Selected AudioDevice: BLUETOOTH", Toast.LENGTH_SHORT).show();
                  break;
                case WIRED_HEADSET:
                  Toast.makeText(MainActivity.this, "Selected AudioDevice: WIRED_HEADSET", Toast.LENGTH_SHORT).show();
                  break;
                case SPEAKER_PHONE:
                  Toast.makeText(MainActivity.this, "Selected AudioDevice: SPEAKER_PHONE", Toast.LENGTH_SHORT).show();
                  break;
                case EARPIECE:
                  Toast.makeText(MainActivity.this, "Selected AudioDevice: EARPIECE", Toast.LENGTH_SHORT).show();
                  break;
               }
        }
    });
    //highlight-end
  }

  @Override
    protected void onCreate(Bundle savedInstanceState) {
       // ...
       setAudioDeviceListeners();
    }
```

</TabItem>

</Tabs>

- To use Bluetooth device, you must declare `BLUETOOTH` permission in `AndroidManifest.xml` file.

```js
<manifest ... >
//...
<uses-permission android:name="android.permission.BLUETOOTH" />
<uses-permission android:name="android.permission.BLUETOOTH_ADMIN" />
<uses-permission android:name="android.permission.BLUETOOTH_CONNECT" />
</manifest>
```

## Changing Camera Input Device

### `changeWebcam()`

- By using `changeWebcam()` function, a participant can stream from front / rear camera during the meeting.

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
  btnWebcam!!.setOnClickListener {
    // Change Webcam during Meeting
    //highlight-next-line
    meeting!!.changeWebcam()
  }
```

</TabItem>

<TabItem value="Java">

```js
  btnWebcam.setOnClickListener(new View.OnClickListener() {
      @Override
      public void onClick(View v) {
        // Change Webcam during Meeting
        //highlight-next-line
        meeting.changeWebcam();
      }
  });
```

</TabItem>

</Tabs>

### API Reference

The API references for all the methods and events utilised in this guide are provided below.

- [getMics()](/android/api/sdk-reference/meeting-class/methods#getmics)
- [changeMic()](/android/api/sdk-reference/meeting-class/methods#changemic)
- [changeWebcam()](/android/api/sdk-reference/meeting-class/methods#changewebcam)


---

---
title: Image Capturer | Video SDK
hide_title: true
hide_table_of_contents: false
description: Stream Image Capturer.
sidebar_label: Image Capturer
pagination_label: Image Capturer
keywords:
  - image capturer
  - stream image capturer
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: image-capturer
--- 

# Image Capturer - Android

This guide provides instructions on capturing images of participants from a video stream. 

This capability proves particularly valuable in Video KYC scenarios, enabling the capture of images where users can hold up their identity for verification.

### `captureImage()`

- By using the `captureImage()` method of the `Participant` class, you can capture image of a local participant from their video stream.
- You have the option to specify the desired height and width in the `captureImage()` method; however, these parameters are optional. If not provided, the VideoSDK will automatically use the dimensions of the local participant's webcamStream. 
- You need to pass an implementation of `TaskCompletionListener` as a parameter in the `captureImage()` method. This listener will handle the result of the image capture task.
- When the image capture task is complete, the `onComplete()` method will provide the image in the form of a `base64` string. If an error occurs, the `onError()` method will provide the error details.

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
private fun imageCapture() {
  meeting!!.localParticipant.
    .captureImage(400, 400, object : TaskCompletionListener<String?, String?> {
      override fun onComplete(data: String?) {
          Log.d("VideoSDK", "capturedImage in base64 format: $data")
      }

      override fun onError(error: String?) {
          Log.d("VideoSDK", "Error in imageCapture $error")
      }
  })
}
```

</TabItem>

<TabItem value="Java">

```js
private void imageCapture() {
  meeting.getLocalParticipant().captureImage(400, 400, new TaskCompletionListener<String,String>() {
    @Override
    public void onComplete(@Nullable String data) {
        Log.d("VideoSDK", "capturedImage in base64 format: " + data);
    }

    @Override
    public void onError(@Nullable String error) {
        Log.d("VideoSDK", "Error in imageCapture " + error);
    }
  });
}
```

</TabItem>

</Tabs>


:::note

You can only capture an image of the local participant. If you called `captureImage()` method on a remote participant, you will receive an error. To capture an image of a remote participant, refer to the documentation below.

:::

### How to capture image of a remote participant ?

- Before proceeding, it's crucial to understand [VideoSDK's temporary file storage system](/android/guide/video-and-audio-calling-api-sdk/collaboration-in-meeting/upload-fetch-temporary-file) and the underlying [pubsub mechanism](/android/guide/video-and-audio-calling-api-sdk/collaboration-in-meeting/pubsub).

- Here's a break down of the steps, using the names Participant A and Participant B for clarity:

#### Step 1 : Initiate Image Capture Request

- In this step, you have to first send a request to Participant B, whose image you want to capture, using pubsub.
- In order to do that, you have to publish a message. Here, `IMAGE_CAPTURE` pubsub topic is used.
- Also, you will be using the `sendOnly` property of the `PubSubPublishOptions` class. Therefore, the request will be sent to that participant only.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
class MainActivity : AppCompatActivity() {

  //..
  
  private fun sendRequest(participantId: String) {
    if (participantId != meeting.localParticipant.id) {
      val publishOptions = PubSubPublishOptions()
      publishOptions.isPersist = false
      //highlight-start
      // Pass the participantId of the participant whose image you want to capture
      // Here, it will be Participant B's id, as you want to capture the the image of Participant B
      val sendOnly = arrayOf(participantId)
      publishOptions.setSendOnly(sendOnly)
      //highlight-end

      // send request to participant using the publish method
      //highlight-next-line
      meeting.pubSub.publish("IMAGE_CAPTURE", "Sending request to capture image", publishOptions)
    }
  }
}
```

</TabItem>

<TabItem value="Java">

```js
public class MainActivity extends AppCompatActivity {
 
  //...

  private void sendRequest(String participantId) {
    if (!participantId.equals(meeting.getLocalParticipant().getId())) {
      PubSubPublishOptions publishOptions = new PubSubPublishOptions();
      publishOptions.setPersist(false);
      //highlight-start
      // Pass the participantId of the participant whose image you want to capture
      // Here, it will be Participant B's id, as you want to capture the the image of Participant B
      String[] sendOnly = {participantId};
      publishOptions.setSendOnly(sendOnly);
      //highlight-end

      // send request to participant using the publish method
      //highlight-next-line
      meeting.pubSub.publish("IMAGE_CAPTURE", "Sending request to capture image", publishOptions);
    }
  }
}
```

</TabItem>

</Tabs>

#### Step 2 : Capture and Upload File

- To capture an image from a remote participant [Participant B], you will filter out the request from the `onMessageReceived` event of the `PubSubMessageListener`. For that, you need to subscribe to a topic called `IMAGE_CAPTURE`. When you receive an image capture request, you will capture the image using the `captureImage()` method of the `Participant` class.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
class MainActivity : AppCompatActivity() {
  override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    setContentView(R.layout.activity_main)

    //...

    // add listener to meeting
    //highlight-next-line
    meeting!!.addEventListener(meetingEventListener) 
  }

  private val meetingEventListener: MeetingEventListener = object : MeetingEventListener() {

    override fun onMeetingJoined() {
      Log.d("#meeting", "onMeetingJoined()")
      val pubSubMessageListener =
        PubSubMessageListener { message ->
          if (message.senderId != meeting!!.localParticipant.id) {
            //highlight-start
            // capture and store image when message received
            captureAndStoreImage(message.senderId)
            //highlight-end
          }
        }
      // subscribe for 'IMAGE_CAPTURE' topic to receive request
      //highlight-next-line
      meeting!!.pubSub.subscribe("IMAGE_CAPTURE", pubSubMessageListener)
    }

    //...
  }

  private fun captureAndStoreImage(senderId: String) {
    //highlight-start
    // capture image
    meeting!!.localParticipant
      .captureImage(object : TaskCompletionListener<String?, String?> {
        override fun onComplete(@Nullable base64Data: String?) {
            Log.d("VideoSDK", "capturedImage in base64 format: $base64Data")
        }

        override fun onError(@Nullable error: String?) {
            Log.d("VideoSDK", "Error in image capture: $error")
        }
    })
    //highlight-end
  }
}
```

</TabItem>

<TabItem value="Java">

```js
public class MainActivity extends AppCompatActivity {
 @Override
  protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);

    //...

    // add listener to meeting
    //highlight-next-line
    meeting.addEventListener(meetingEventListener);
  }

   private final MeetingEventListener meetingEventListener = new MeetingEventListener() {
      @Override
      public void onMeetingJoined() {
        Log.d("#meeting", "onMeetingJoined()");

        PubSubMessageListener pubSubMessageListener = new PubSubMessageListener() {
          @Override
          public void onMessageReceived(PubSubMessage message) {
            if (!message.getSenderId().equals(meeting.getLocalParticipant().getId())) 
            {
              //highlight-start
              // capture and store image when message received
              captureAndStoreImage(message.getSenderId());
              //highlight-end
            }
          }
        }  
        // subscribe for 'IMAGE_CAPTURE' topic to receive request
        //highlight-next-line
        meeting.pubSub.subscribe("IMAGE_CAPTURE", pubSubMessageListener);
      }

      //...
    };

  private void captureAndStoreImage(String senderId) {
    //highlight-start
    // capture image
    meeting.getLocalParticipant().captureImage(new TaskCompletionListener<String, String>() {
      @Override
      public void onComplete(@Nullable String base64Data) {   
        Log.d("VideoSDK", "capturedImage in base64 format: " + base64Data);    
      }

      @Override
      public void onError(@Nullable String error) {
          Log.d("VideoSDK", "Error in image capture: " + error);
      }
    });
    //highlight-end
  }
}
```

</TabItem>

</Tabs>

- After capturing the image of the remote participant, you need to store this image in VideoSDK's temporary file storage system. This will allow you to send the image to the participant who initiated the request.
- Utilize the `uploadBase64File()` method of the `Meeting` class to store the captured image in VideoSDK's temporary file storage system.
- When the upload is complete, the `onComplete()` method of `TaskCompletionListener` will provide the corresponding `fileUrl`, which can be used to retrieve the uploaded file.
- If an error occurs during the upload process, the `onError()` method of `TaskCompletionListener` will provide the error details.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
class MainActivity : AppCompatActivity() {
  override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    setContentView(R.layout.activity_main)
    //...
  }

  private fun captureAndStoreImage(senderId: String) {
    // listener for file-upload
    val fileUploadListener: TaskCompletionListener<String, String> =
      object : TaskCompletionListener<String?, String?> {
        override fun onComplete(@Nullable fileUrl: String?) {
          //highlight-next-line
          Log.d("VideoSDK", "Uploaded file url: $fileUrl")
        }

        override fun onError(@Nullable error: String?) {
          Log.d("VideoSDK", "Error in upload file: $error")
        }
    }

    // capture image
    meeting!!.localParticipant
      .captureImage(object : TaskCompletionListener<String?, String?> {
        override fun onComplete(@Nullable base64Data: String?) {
          Log.d("VideoSDK", "capturedImage in base64 format: $base64Data")
          val token = "<VIDEOSDK_TOKEN>"
          val fileName = "myCapture.jpeg" // specify a name for image file with extension
          //highlight-start
          // upload image to videosdk storage system
          meeting!!.uploadBase64File(base64Data, token, fileName, fileUploadListener)
          //highlight-end
        }

        override fun onError(@Nullable error: String?) {
            Log.d("VideoSDK", "Error in image capture: $error")
        }
      })
  }
}
```

</TabItem>

<TabItem value="Java">

```js
public class MainActivity extends AppCompatActivity {
  @Override
  protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);
    //...
  }

  private void captureAndStoreImage(String senderId) {
    // listener for file-upload
    TaskCompletionListener<String, String> fileUploadListener = new TaskCompletionListener<>() {
      @Override
      public void onComplete(@Nullable String fileUrl) {
        //highlight-next-line
        Log.d("VideoSDK", "Uploaded file url: " + fileUrl);
      }

      @Override
      public void onError(@Nullable String error) {
        Log.d("VideoSDK", "Error in upload file: " + error);
      }
    };

    // capture image
    meeting.getLocalParticipant().captureImage(new TaskCompletionListener<String, String>() {
        @Override
        public void onComplete(@Nullable String base64Data) {   
          Log.d("VideoSDK", "capturedImage in base64 format: " + base64Data); 
          String token = "<VIDEOSDK_TOKEN>";
          String fileName = "myCapture.jpeg"; // specify a name for image file with extension
          //highlight-start
          // upload image to videosdk storage system
          meeting.uploadBase64File(base64Data, token, fileName, fileUploadListener); 
          //highlight-end 
        }

        @Override
        public void onError(@Nullable String error) {
            Log.d("VideoSDK", "Error in image capture: " + error);
        }
    });
  }
}
```

</TabItem>

</Tabs>


- Next, the `fileUrl` is sent back to the participant who initiated the request using the `IMAGE_TRANSFER` topic.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
class MainActivity : AppCompatActivity() {

  //..
  
  private fun captureAndStoreImage(senderId: String) {
    // listener for file-upload
    val fileUploadListener: TaskCompletionListener<String, String> =
      object : TaskCompletionListener<String?, String?> {
        override fun onComplete(@Nullable fileUrl: String?) {
          //highlight-start
          Log.d("VideoSDK", "Uploaded file url: $fileUrl")
          imageTransfer(fileUrl, senderId)
          //highlight-end
        }

        override fun onError(@Nullable error: String?) {
          Log.d("VideoSDK", "Error in upload file: $error")
        }
    }

    //...
  }

  private fun imageTransfer(fileUrl: String?, senderId: String) {
    val publishOptions = PubSubPublishOptions()
    publishOptions.isPersist = false
    //highlight-start
    // Pass the participantId who initiated the request
    val sendOnly = arrayOf(senderId)
    publishOptions.setSendOnly(sendOnly)
    //highlight-end

    // send fileUrl to the participant who request for image using the publish method
    //highlight-next-line
    meeting!!.pubSub.publish("IMAGE_TRANSFER", fileUrl, publishOptions)
  }
}
```

</TabItem>

<TabItem value="Java">

```js
public class MainActivity extends AppCompatActivity {

  //...

  private void captureAndStoreImage(String senderId) {
      // listener for file-upload
      TaskCompletionListener<String, String> fileUploadListener = new TaskCompletionListener<>() {
          @Override
          public void onComplete(@Nullable String fileUrl) {
            //highlight-start
            Log.d("VideoSDK", "Uploaded file url: " + fileUrl);
            imageTransfer(fileUrl, senderId);
            //highlight-end
          }

          @Override
          public void onError(@Nullable String error) {
            Log.d("VideoSDK", "Error in upload file: " + error);
          }
      };

      //...

    }

    private void imageTransfer(String fileUrl,String senderId) {
      PubSubPublishOptions publishOptions = new PubSubPublishOptions();
      publishOptions.setPersist(false);
      //highlight-start
      // Pass the participantId who initiated the request
      String[] sendOnly = {senderId};
      publishOptions.setSendOnly(sendOnly);
      //highlight-end

      // send fileUrl to the participant who request for image using the publish method
      //highlight-next-line
      meeting.pubSub.publish("IMAGE_TRANSFER", fileUrl, publishOptions);
    }
}
```

</TabItem>

</Tabs>

#### Step 3 : Fetch and Display Image

- To display a captured image, the `showCapturedImage()` method is used. Here's how it works:

- Within the `showCapturedImage()` method, subscribe to the `IMAGE_TRANSFER` topic to receive the `fileUrl` associated with the captured image.

- Once the `fileUrl` is obtained, use the `fetchBase64File()` method from the `Meeting` class to retrieve the file in `base64` format from VideoSDK's temporary storage.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
class MainActivity : AppCompatActivity() {

  @Override
  protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);
    
    showCapturedImage()
  }
  
  private fun showCapturedImage() {
    val pubSubMessageListener =
      PubSubMessageListener { message: PubSubMessage ->
        if (message.senderId != meeting!!.localParticipant.id) {
          // fetch the image when message received
          val url = message.message
          val token = "<VIDEOSDK_TOKEN>"
          meeting!!.fetchBase64File(
            url,
            token,
            object : TaskCompletionListener<String?, String?> {
              override fun onComplete(@Nullable base64Data: String?) {
                  // here is your image in the form of base64
                  Log.d("VideoSDK", "Fetched file in base64:$base64Data")
                  // coverting base64 to bitmap to display an image in the imageView
                  val capturedImage =
                      findViewById<ImageView>(R.id.capturedImage)
                  val decodedString: ByteArray =
                      Base64.decode(base64Data, Base64.DEFAULT)
                  val decodedByte =
                      BitmapFactory.decodeByteArray(
                          decodedString,
                          0,
                          decodedString.size
                      )
                  capturedImage.setImageBitmap(decodedByte)
              }

              override fun onError(@Nullable error: String?) {
                  Log.d("VideoSDK", "Error in fetch file: $error")
              }
            }
          )
        }
      }

    // Subscribe for 'IMAGE_TRANSFER' topic to receive fileUrl
    meeting!!.pubSub.subscribe("IMAGE_TRANSFER", pubSubMessageListener)
  }
}
```

</TabItem>

<TabItem value="Java">

```js
public class MainActivity extends AppCompatActivity {
  @Override
  protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);

    //...
    
    showCapturedImage();
  }

  private void showCapturedImage(){
    PubSubMessageListener pubSubMessageListener = message -> {
      if (!message.getSenderId().equals(meeting.getLocalParticipant().getId())) {
        // fetch the image when message received
        String url = message.getMessage();
        String token = "<VIDEOSDK_TOKEN>";
        meeting.fetchBase64File(url, token, new TaskCompletionListener<String, String>() {
          @Override
          public void onComplete(@Nullable String base64Data) {
            // here is your image in the form of base64
            Log.d("VideoSDK", "Fetched file in base64:" + base64Data); 
            // coverting base64 to bitmap to display an image in the imageView
            ImageView capturedImage = findViewById(R.id.capturedImage);
            byte[] decodedString = Base64.decode(base64Data, Base64.DEFAULT);
            Bitmap decodedByte = BitmapFactory.decodeByteArray(decodedString, 0, decodedString.length);
            capturedImage.setImageBitmap(decodedByte);
          }

          @Override
          public void onError(@Nullable String error) {
              Log.d("VideoSDK", "Error in fetch file: " + error);
          }
        });
      }
    };

    // Subscribe for 'IMAGE_TRANSFER' topic to receive fileUrl
    meeting.pubSub.subscribe("IMAGE_TRANSFER", pubSubMessageListener);
  }
}
```

</TabItem>

</Tabs>

:::note

The file stored in the [VideoSDK's temporary file storage system](/react/guide/video-and-audio-calling-api-sdk/collaboration-in-meeting/upload-fetch-temporary-file) will be automatically deleted once the current room/meeting comes to an end.

:::

## API Reference

The API references for all the methods utilized in this guide are provided below.

- [captureImage()](/android/api/sdk-reference/participant-class/methods#captureimage)
- [pubSub()](/android/api/sdk-reference/pubsub-class/introduction)
- [uploadBase64File()](/android/api/sdk-reference/meeting-class/methods#uploadbase64file)
- [fetchBase64File()](/android/api/sdk-reference/meeting-class/methods#fetchbase64file)


---

---
title: Mute / Unmute Mic | Video SDK
hide_title: true
hide_table_of_contents: false
description: Mic Controls features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Mute / Unmute Mic
pagination_label: Mute / Unmute Mic
keywords:
  - audio calling
  - video calling
  - real-time communication
  - collaboration
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: mute-unmute-mic
---

# Mute / Unmute Mic - Android

Muting and Unmuting your microphone refers to turning your microphone off and on, respectively.

When you mute your microphone, you prevent any sound from your microphone from being transmitted to other meeting participants, while unmuting it allows others to hear you.

### `unmuteMic()`

- By using `unmuteMic()` function of `Meeting` class, local participant can publish audio to other participants.

  - You can call this method when the local participant is not broadcasting any audio to others.

- You can pass customised audio track in `unmuteMic()` by using [Custom Audio Track](/android/guide/video-and-audio-calling-api-sdk/render-media/optimize-audio-track).

- Audio stream of the participant can be accessed from the `onStreamEnabled` event of `ParticipantEventListener`.

### `muteMic()`

- By using `muteMic()` function of `Meeting` class, local participant can stop publish audio to other participants.

- You can call this method when the local participant is broadcasting any audio to others.

#### Example

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
  private var micEnabled = false

  btnMic!!.setOnClickListener { _: View? ->
     if (micEnabled) {
      // Muting Mic
      //highlight-next-line
       meeting!!.muteMic()
       micEnabled=false
     } else {
      // Unmuting Mic
      //highlight-next-line
      meeting!!.unmuteMic()
      micEnabled=true
     }
  }
```

</TabItem>

<TabItem value="Java">

```js
  private boolean micEnabled = false;

  btnMic.setOnClickListener(new View.OnClickListener() {
      @Override
      public void onClick(View v) {
          if (micEnabled) {
              // Muting Mic
              //highlight-next-line
              meeting.muteMic();
              micEnabled = false;
          } else {
            // Unmuting Mic
            //highlight-next-line
              meeting.unmuteMic();
              micEnabled = true;
          }
      }
  });
```

</TabItem>

</Tabs>

### Events associated with `unmuteMic`

- Every Participant will receive a callback on [`onStreamEnabled()`](/android/api/sdk-reference/participant-class/participant-event-listener-class#onstreamenabled) of the [`Participant`](/android/api/sdk-reference/participant-class/introduction) with `Stream` object.

### Events associated with `muteMic`

- Every Participant will receive a callback on [`onStreamDisabled()`](/android/api/sdk-reference/participant-class/participant-event-listener-class#onstreamdisabled) of the [`Participant`](/android/api/sdk-reference/participant-class/introduction) with `Stream` object.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
  meeting!!.localParticipant.addEventListener(object : ParticipantEventListener() {
    //Callback for when the participant starts a stream
    //highlight-start
    override fun onStreamEnabled(stream: Stream) {
        if(stream.getKind().equals("audio")){
          Log.d("VideoSDK","Audio Stream On: onStreamEnabled $stream");
        }
    }
    //highlight-end

    //Callback for when the participant stops a stream
    //highlight-start
    override fun onStreamDisabled(stream: Stream) {
        if(stream.getKind().equals("audio")){
          Log.d("VideoSDK","Audio Stream On: onStreamDisabled $stream");
        }
    }
    //highlight-end
  });
```

</TabItem>

<TabItem value="Java">

```js
  participant.addEventListener(new ParticipantEventListener() {
    //Callback for when the participant starts a stream
    //highlight-start
    @Override
    public void onStreamEnabled(Stream stream) {
        if(stream.getKind().equals("audio")){
          Log.d("VideoSDK","Audio Stream On: onStreamEnabled" + stream);
        }
    }
    //highlight-end

    //Callback for when the participant stops a stream
    //highlight-start
    @Override
    public void onStreamDisabled(Stream stream) {
        if(stream.getKind().equals("audio")){
          Log.d("VideoSDK","Audio Stream Off: onStreamDisabled" + stream);
        }
    }
    //highlight-end
  });
```

</TabItem>

</Tabs>

### Audio Permissions

- To use the microphone in a meeting, you need to add permission in `app/src/main/AndroidManifest.xml` after `</application>`.

```xml title="AndroidManifest.xml"
<uses-permission android:name="android.permission.RECORD_AUDIO" />
```

- You need to set up a permission request that provides this access.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
import android.Manifest
import android.content.pm.PackageManager
import android.os.Bundle
import android.widget.Toast
import androidx.appcompat.app.AppCompatActivity
import androidx.core.app.ActivityCompat
import androidx.core.content.ContextCompat

class MainActivity : AppCompatActivity() {
    private val PERMISSION_REQUEST_CODE: Int = 1;

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        //highlight-start
        if (checkPermission()) {
            // . write your main code to execute, It will execute if the permission is already given.
        } else {
            requestPermission()
        }
        //highlight-end
    }
    private fun checkPermission(): Boolean {
        //highlight-next-line
        return ContextCompat.checkSelfPermission(this, Manifest.permission.RECORD_AUDIO) == PackageManager.PERMISSION_GRANTED
    }

    private fun requestPermission() {
      //highlight-start
        ActivityCompat.requestPermissions(
            this, arrayOf(Manifest.permission.RECORD_AUDIO),
            PERMISSION_REQUEST_CODE
        )
      //highlight-end
    }

    override
    fun onRequestPermissionsResult(
        requestCode: Int,
        permissions: Array<out String>,
        grantResults: IntArray
    ) {
        super.onRequestPermissionsResult(requestCode, permissions, grantResults)
        when (requestCode) {
            PERMISSION_REQUEST_CODE -> if (grantResults.isNotEmpty() && grantResults[0] == PackageManager.PERMISSION_GRANTED) {
                Toast.makeText(applicationContext, "Permission Granted", Toast.LENGTH_SHORT).show()
                // main logic
            } else {
                Toast.makeText(applicationContext, "Permission Denied", Toast.LENGTH_SHORT).show()
            }
        }
    }
}
```

</TabItem>

<TabItem value="Java">

```js
import androidx.annotation.NonNull;
import androidx.appcompat.app.AppCompatActivity;
import androidx.core.app.ActivityCompat;
import androidx.core.content.ContextCompat;

import android.Manifest;
import android.content.pm.PackageManager;
import android.os.Bundle;
import android.widget.Toast;

import java.util.ArrayList;
import java.util.List;

public class MainActivity extends AppCompatActivity {

    private static final int PERMISSION_REQUEST_CODE = 1;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        //highlight-start
        if (checkPermission()) {
            // . write your main code to execute, It will execute if the permission is already given.
        } else {
            requestPermission();
        }
        //highlight-end
    }

    private boolean checkPermission() {
        //highlight-next-line
        return ContextCompat.checkSelfPermission(this, Manifest.permission.RECORD_AUDIO) == PackageManager.PERMISSION_GRANTED;
    }

    private void requestPermission() {
        List<String> permissionList = new ArrayList<String>();
        String[] permissions = {};
        permissionList.add(Manifest.permission.RECORD_AUDIO);
        //highlight-start
        ActivityCompat.requestPermissions(
                this, permissionList.toArray(permissions),
                PERMISSION_REQUEST_CODE
        );
        //highlight-end
    }

    @Override
    public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
        super.onRequestPermissionsResult(requestCode, permissions, grantResults);
        switch (requestCode) {
            case PERMISSION_REQUEST_CODE:
                if (grantResults.length > 0 && grantResults[0] == PackageManager.PERMISSION_GRANTED) {
                    Toast.makeText(MainActivity.this, "Permission Granted", Toast.LENGTH_SHORT).show();
                    // main logic
                } else {
                    Toast.makeText(MainActivity.this, "Permission Denied", Toast.LENGTH_SHORT).show();
                }
                break;
        }
    }
}
```

</TabItem>

</Tabs>

### API Reference

The API references for all the methods and events utilised in this guide are provided below.

- [unmuteMic()](/android/api/sdk-reference/meeting-class/methods#unmutemic)
- [muteMic()](/android/api/sdk-reference/meeting-class/methods#mutemic)
- [onStreamEnabled()](/android/api/sdk-reference/participant-class/participant-event-listener-class#onstreamenabled)
- [onStreamDisabled()](/android/api/sdk-reference/participant-class/participant-event-listener-class#onstreamdisabled)


---

---
title: On / Off Camera | Video SDK
hide_title: true
hide_table_of_contents: false
description: Camera Controls features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: On / Off Camera
pagination_label: On / Off Camera
keywords:
  - audio calling
  - video calling
  - real-time communication
  - collaboration
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: on-off-camera
---

# On / Off Camera - Android

Any participant can turn on or off his camera in the meeting using below methods.

### `enableWebcam()`

- By using `enableWebcam()` function of `Meeting` class, local participant can publish video to other participants.

- You can call this method when the local participant is not broadcasting any video to others.

- You can pass customised video track in `enableWebcam()` by using [Custom Video Track](/android/guide/video-and-audio-calling-api-sdk/render-media/optimize-video-track#custom-video-track).

- Video stream of the participant can be accessed from the `onStreamEnabled` event of `ParticipantEventListener`.

### `disableWebcam()`

- By using `disableWebcam()` function of `Meeting` class, local participant can stop publish video to other participants.

- You can call this method when the local participant is broadcasting any video to others.

#### Example

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
  btnWebcam!!.setOnClickListener {
    if (webcamEnabled) {
      // Disabling camera
      //highlight-next-line
      meeting!!.disableWebcam()
    } else {
      // Enabling camera
      //highlight-next-line
      meeting!!.enableWebcam()
    }
    webcamEnabled=!webcamEnabled
  }
```

</TabItem>

<TabItem value="Java">

```js
  btnWebcam.setOnClickListener(new View.OnClickListener() {
      @Override
      public void onClick(View v) {
        if (webcamEnabled) {
          // Disabling camera
          //highlight-next-line
          meeting.disableWebcam();
        } else {
          // Enabling camera
          //highlight-next-line
          meeting.enableWebcam();
        }
        webcamEnabled=!webcamEnabled;
      }
  });
```

</TabItem>

</Tabs>

:::important
To learn, how to render video in the meeting, [follow this](/android/guide/video-and-audio-calling-api-sdk/render-media/display-video/render-participant) detailed guide.
:::

### Events associated with `enableWebcam`

- Every Participant will receive a callback on [`onStreamEnabled()`](/android/api/sdk-reference/participant-class/participant-event-listener-class#onstreamenabled) of the [`Participant`](/android/api/sdk-reference/participant-class/introduction) with `Stream` object.

### Events associated with `disableWebcam`

- Every Participant will receive a callback on [`onStreamDisabled()`](/android/api/sdk-reference/participant-class/participant-event-listener-class#onstreamdisabled) of the [`Participant`](/android/api/sdk-reference/participant-class/introduction) with `Stream` object.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
  meeting!!.localParticipant.addEventListener(object : ParticipantEventListener() {
    //Callback for when the participant starts a stream
    //highlight-start
    override fun onStreamEnabled(stream: Stream) {
        if(stream.getKind().equals("video")){
          Log.d("VideoSDK","Video Stream On: onStreamEnabled $stream");
        }
    }
    //highlight-end

    //Callback for when the participant stops a stream
    //highlight-start
    override fun onStreamDisabled(stream: Stream) {
        if(stream.getKind().equals("video")){
          Log.d("VideoSDK","Video Stream On: onStreamDisabled $stream");
        }
    }
    //highlight-end
  });
```

</TabItem>

<TabItem value="Java">

```js
  participant.addEventListener(new ParticipantEventListener() {
    //Callback for when the participant starts a stream
    //highlight-start
    @Override
    public void onStreamEnabled(Stream stream) {
        if(stream.getKind().equals("video")){
          Log.d("VideoSDK","Video Stream On: onStreamEnabled" + stream);
        }
    }
    //highlight-end

    //Callback for when the participant stops a stream
    //highlight-start
    @Override
    public void onStreamDisabled(Stream stream) {
        if(stream.getKind().equals("video")){
          Log.d("VideoSDK","Video Stream Off: onStreamDisabled" + stream);
        }
    }
    //highlight-end
  });
```

</TabItem>

</Tabs>

### Video Permissions

- To use the camera in a meeting, you need to add permission in `app/src/main/AndroidManifest.xml` after `</application>`.

```xml title="AndroidManifest.xml"
<uses-permission android:name="android.permission.CAMERA" />
```

- You need to set up a permission request that provides this access.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
import android.Manifest
import android.content.pm.PackageManager
import android.os.Bundle
import android.widget.Toast
import androidx.appcompat.app.AppCompatActivity
import androidx.core.app.ActivityCompat
import androidx.core.content.ContextCompat

class MainActivity : AppCompatActivity() {
    private val PERMISSION_REQUEST_CODE: Int = 1;

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        //highlight-start
        if (checkPermission()) {
            // . write your main code to execute, It will execute if the permission is already given.
        } else {
            requestPermission()
        }
        //highlight-end
    }
    private fun checkPermission(): Boolean {
        //highlight-next-line
        return ContextCompat.checkSelfPermission(this, Manifest.permission.CAMERA) == PackageManager.PERMISSION_GRANTED
    }

    private fun requestPermission() {
      //highlight-start
        ActivityCompat.requestPermissions(
            this, arrayOf(Manifest.permission.CAMERA),
            PERMISSION_REQUEST_CODE
        )
      //highlight-end
    }

    override
    fun onRequestPermissionsResult(
        requestCode: Int,
        permissions: Array<out String>,
        grantResults: IntArray
    ) {
        super.onRequestPermissionsResult(requestCode, permissions, grantResults)
        when (requestCode) {
            PERMISSION_REQUEST_CODE -> if (grantResults.isNotEmpty() && grantResults[0] == PackageManager.PERMISSION_GRANTED) {
                Toast.makeText(applicationContext, "Permission Granted", Toast.LENGTH_SHORT).show()
                // main logic
            } else {
                Toast.makeText(applicationContext, "Permission Denied", Toast.LENGTH_SHORT).show()
            }
        }
    }
}
```

</TabItem>

<TabItem value="Java">

```js
import androidx.annotation.NonNull;
import androidx.appcompat.app.AppCompatActivity;
import androidx.core.app.ActivityCompat;
import androidx.core.content.ContextCompat;

import android.Manifest;
import android.content.pm.PackageManager;
import android.os.Bundle;
import android.widget.Toast;

import java.util.ArrayList;
import java.util.List;

public class MainActivity extends AppCompatActivity {

    private static final int PERMISSION_REQUEST_CODE = 1;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        //highlight-start
        if (checkPermission()) {
            // . write your main code to execute, It will execute if the permission is already given.
        } else {
            requestPermission();
        }
        //highlight-end
    }

    private boolean checkPermission() {
        //highlight-next-line
        return ContextCompat.checkSelfPermission(this, Manifest.permission.CAMERA) == PackageManager.PERMISSION_GRANTED;
    }

    private void requestPermission() {
        List<String> permissionList = new ArrayList<String>();
        String[] permissions = {};
        permissionList.add(Manifest.permission.CAMERA);
        //highlight-start
        ActivityCompat.requestPermissions(
                this, permissionList.toArray(permissions),
                PERMISSION_REQUEST_CODE
        );
        //highlight-end
    }

    @Override
    public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
        super.onRequestPermissionsResult(requestCode, permissions, grantResults);
        switch (requestCode) {
            case PERMISSION_REQUEST_CODE:
                if (grantResults.length > 0 && grantResults[0] == PackageManager.PERMISSION_GRANTED) {
                    Toast.makeText(MainActivity.this, "Permission Granted", Toast.LENGTH_SHORT).show();
                    // main logic
                } else {
                    Toast.makeText(MainActivity.this, "Permission Denied", Toast.LENGTH_SHORT).show();
                }
                break;
        }
    }
}
```

</TabItem>

</Tabs>

:::important
If the app goes to the background, VideoSDK detectes this event based on activity lifecycle and release the camera so that it can be used by other apps. In order to make sure this functionality works properly use  `VideoSDK.setActivityForLifeCycle(activity)` to specify which activity VideoSDK should monitor for lifecycle changes.
:::

### API Reference

The API references for all the methods and events utilised in this guide are provided below.

- [enableWebcam()](/android/api/sdk-reference/meeting-class/methods#enablewebcam)
- [disableWebcam()](/android/api/sdk-reference/meeting-class/methods#disablewebcam)
- [onStreamEnabled()](/android/api/sdk-reference/participant-class/participant-event-listener-class#onstreamenabled)
- [onStreamDisabled()](/android/api/sdk-reference/participant-class/participant-event-listener-class#onstreamdisabled)


---

---
title: Screen Share | Video SDK
hide_title: true
hide_table_of_contents: false
description: Share your Screen features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Screen Share
pagination_label: Screen Share
keywords:
  - audio calling
  - video calling
  - real-time communication
  - collaboration
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: screen-share
---

# Screen Share - Android

Screen sharing in a meeting is the process of sharing your mobile screen with other participants in the meeting. It allows everyone in the meeting to see exactly what you are seeing on your screen, which can be helpful for presentations, demonstrations, or collaborations.

## How Screen share works?

- The following diagram shows flow of the screen sharing in android using VideoSDK :

<div style={{textAlign: 'center'}}>

![VideoSDK Android Screenshare Flow Diagram](/img/android/screenshare/flow_diagram.png)

</div>

### `enableScreenShare()`

- By using `enableScreenShare()` function of `Meeting` class, local participant can share his/her mobile screen to other participants.

- You can pass customised screenshare track in `enableScreenShare()` by using [Custom Screen Share Track](/android/guide/video-and-audio-calling-api-sdk/render-media/optimize-video-track#custom-screen-share-track).

- Screen Share stream of the participant can be accessed from the `onStreamEnabled` event of `ParticipantEventListener`.

### Screenshare permission

- A participant’s Screen share stream is provided via the `MediaProjection` API. This API is only compatible with `Build.VERSION_CODES.LOLLIPOP` or higher.

- Get an instance of the `MediaProjectionManager` and Call the `createScreenCaptureIntent()` method in an activity. This initiates a prompt dialog for the user to confirm screen projection.

- One will get a prompt dialog like this:

<div style={{textAlign: 'center'}}>

<img
src={require('/img/android/screenshare/user_permission.jpg').default}
alt="user permission"
width="450"
/>

</div>

<br/>

- After permission is received from the user, you can call `enableScreenShare()` method.

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
private fun enableScreenShare() {
    val mediaProjectionManager = application.getSystemService(
        MEDIA_PROJECTION_SERVICE
    ) as MediaProjectionManager
    startActivityForResult(
        mediaProjectionManager.createScreenCaptureIntent(), CAPTURE_PERMISSION_REQUEST_CODE
    )
}

public override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) {
    super.onActivityResult(requestCode, resultCode, data)
    if (requestCode != CAPTURE_PERMISSION_REQUEST_CODE) return
    if (resultCode == RESULT_OK) {
        // Enabling screen share
        //highlight-next-line
        meeting!!.enableScreenShare(data)
    }
}
```

</TabItem>

<TabItem value="Java">

```js
private void enableScreenShare() {
    MediaProjectionManager mediaProjectionManager =
        (MediaProjectionManager) getApplication().getSystemService(
            Context.MEDIA_PROJECTION_SERVICE);
    startActivityForResult(
        mediaProjectionManager.createScreenCaptureIntent(), CAPTURE_PERMISSION_REQUEST_CODE);
}

@Override
public void onActivityResult(int requestCode, int resultCode, Intent data) {
    super.onActivityResult(requestCode, resultCode, data);
    if (requestCode != CAPTURE_PERMISSION_REQUEST_CODE)
        return;
    if (resultCode == Activity.RESULT_OK) {
        // Enabling screen share
        //highlight-next-line
        meeting.enableScreenShare(data);
    }
}
```

</TabItem>

</Tabs>

### Customise notification

- When a presenter starts screen share, presenter will receive a notification with a pre-defined title and message.

- Notification with pre-defined title and message will look like this:

<div style={{textAlign: 'center'}}>

<img
src={require('/img/android/screenshare/notification.jpg').default}
alt="notification"
width="450"
/>

</div>

- You can Customise those title, message and icon as per your requirements using `<meta-data>` specified in `app/src/main/AndroidManifest.xml`.

```js
<application>
  <meta-data
    android:name="notificationTitle"
    //highlight-next-line
    android:value="@string/notificationTitle"
  />
  <meta-data
    android:name="notificationContent"
    //highlight-next-line
    android:value="@string/notificationContent"
  />
  <meta-data
    android:name="notificationIcon"
    //highlight-next-line
    android:resource="@mipmap/ic_launcher_round"
  />
</application>
```

### `disableScreenShare()`

- By using `disableScreenShare()` function of `Meeting` class, local participant can stop sharing his/her mobile screen to other participants.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
private fun disableScreenShare() {
    // Disabling screen share
    //highlight-next-line
    meeting!!.disableScreenShare()
}
```

</TabItem>

<TabItem value="Java">

```js
private void disableScreenShare(){
    // Disabling screen share
    //highlight-next-line
    meeting.disableScreenShare();
}
```

</TabItem>

</Tabs>

### Events associated with enableScreenShare

- Participant who share their mobile screen will receive a callback on [`onStreamEnabled()`](/android/api/sdk-reference/participant-class/participant-event-listener-class#onstreamenabled) of the [`Participant`](/android/api/sdk-reference/participant-class/introduction) with `Stream` object.

- While other Participants will receive [`onPresenterChanged()`](/android/api/sdk-reference/meeting-class/meeting-event-listener-class#onpresenterchanged) callback of the [`Meeting`](/android/api/sdk-reference/meeting-class/introduction) class with the participantId as `presenterId` who started the screen share.

### Events associated with disableScreenShare

- Participant who shared their mobile screen will receive a callback on [`onStreamDisabled()`](/android/api/sdk-reference/participant-class/participant-event-listener-class#onstreamdisabled) of the [`Participant`](/android/api/sdk-reference/participant-class/introduction) with `Stream` object.

- While other Participants will receive [`onPresenterChanged()`](/android/api/sdk-reference/meeting-class/meeting-event-listener-class#onpresenterchanged) callback of the [`Meeting`](/android/api/sdk-reference/meeting-class/introduction) class with the `presenterId` as `null` indicating there is no presenter.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
private fun setLocalListeners() {
    meeting!!.localParticipant.addEventListener(object : ParticipantEventListener() {
        //Callback for when the participant starts a stream
        //highlight-start
        override fun onStreamEnabled(stream: Stream) {
           if (stream.kind.equals("share", ignoreCase = true)) {
              Log.d("VideoSDK","Share Stream On: onStreamEnabled $stream");
            }
        }
        //highlight-end

        //Callback for when the participant stops a stream
        //highlight-start
        override fun onStreamDisabled(stream: Stream) {
            if (stream.kind.equals("share", ignoreCase = true)) {
               Log.d("VideoSDK","Share Stream On: onStreamDisabled $stream");
            }
        }
        //highlight-end
    });
}

private val meetingEventListener: MeetingEventListener = object : MeetingEventListener() {
    //Callback for when the presenter changes
    //highlight-start
    override fun onPresenterChanged(participantId: String) {
        if(!TextUtils.isEmpty(participantId))
        {
          Log.d("VideoSDK","$participantId started screen share");
        }else{
          Log.d("VideoSDK","some one stopped screen share");
        }
    }
    //highlight-end
}
```

</TabItem>

<TabItem value="Java">

```js
private void setLocalListeners() {
    meeting.getLocalParticipant().addEventListener(new ParticipantEventListener() {
        //Callback for when the participant starts a stream
        //highlight-start
        @Override
        public void onStreamEnabled(Stream stream) {
            if (stream.getKind().equalsIgnoreCase("share")) {
                Log.d("VideoSDK","Share Stream On: onStreamEnabled" + stream);
            }
        }
        //highlight-end

        //Callback for when the participant stops a stream
        //highlight-start
        @Override
        public void onStreamDisabled(Stream stream) {
            if (stream.getKind().equalsIgnoreCase("share")) {
                Log.d("VideoSDK","Share Stream Off: onStreamDisabled" + stream);
            }
        }
        //highlight-end
    });
}

private final MeetingEventListener meetingEventListener = new MeetingEventListener() {
    //Callback for when the presenter changes
    //highlight-start
    @Override
    public void onPresenterChanged(String participantId) {
      if(participantId != null){
        Log.d("VideoSDK",participantId + "started screen share");
      }else{
        Log.d("VideoSDK","some one stopped screen share");
      }
    }
    //highlight-end
};
```

</TabItem>

</Tabs>

### Rendering Screen Share Stream

- When a local participant shares their screen, the `onStreamEnabled()` function of the `ParticipantEventListener` is triggered, allowing the `Stream` to be added to a `VideoView`.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
private fun setLocalListeners() {
    meeting!!.localParticipant.addEventListener(object : ParticipantEventListener() {
        override fun onStreamEnabled(stream: Stream) {
           if (stream.kind.equals("share", ignoreCase = true)) {
                // display share video
                val videoTrack = stream.track as VideoTrack
                shareView!!.addTrack(videoTrack)
            }
        }
        override fun onStreamDisabled(stream: Stream) {
            if (stream.kind.equals("share", ignoreCase = true)) {
               shareView!!.removeTrack()
            }
        }
    });
}
```

</TabItem>

<TabItem value="Java">

```js
private void setLocalListeners() {
    meeting.getLocalParticipant().addEventListener(new ParticipantEventListener() {
        @Override
        public void onStreamEnabled(Stream stream) {
            if (stream.getKind().equalsIgnoreCase("share")) {
                // display share video
                VideoTrack videoTrack = (VideoTrack) stream.getTrack();
                shareView.addTrack(videoTrack);
            }
        }
        @Override
        public void onStreamDisabled(Stream stream) {
            if (stream.getKind().equalsIgnoreCase("share")) {
                shareView.removeTrack();
            }
        }
    });
}
```

</TabItem>

</Tabs>


- When another participant (excluding the local participant) shares their screen, the `onPresenterChanged()` function in the `MeetingEventListener` is triggered, providing the `participantId` of the screen sharer.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
private val meetingEventListener: MeetingEventListener = object : MeetingEventListener() {
    override fun onPresenterChanged(participantId: String) {
        updatePresenter(participantId)
    }
}

//Getting the stream from the participantId
private fun updatePresenter(participantId: String?) {
    // find participant
    val participant = meeting!!.participants.get(participantId) ?: return

    // find share stream in participant
    var shareStream: Stream? = null
    for (stream: Stream in participant.streams.values) {
        if ((stream.kind == "share")) {
            shareStream = stream
            break
        }
    }
    if (shareStream == null) return

    // display share video
    val videoTrack = shareStream.track as VideoTrack
    shareView!!.addTrack(videoTrack)

    // listen for share stop event
    participant.addEventListener(object : ParticipantEventListener() {
        override fun onStreamDisabled(stream: Stream) {
            if ((stream.kind == "share")) {
                shareView!!.removeTrack()
            }
        }
    })
}
```

</TabItem>

<TabItem value="Java">

```js
private final MeetingEventListener meetingEventListener = new MeetingEventListener() {
    //Triggered when Presenter changes
    @Override
    public void onPresenterChanged(String participantId) {
        updatePresenter(participantId);
    }
};

//Getting the stream from the participantId
private void updatePresenter(String participantId) {
    // find participant
    Participant participant = meeting.getParticipants().get(participantId);
    if (participant == null) return;

    // find share stream in participant
    Stream shareStream = null;
    for (Stream stream: participant.getStreams().values()) {
        if (stream.getKind().equals("share")) {
            shareStream = stream;
            break;
        }
    }
    if (shareStream == null) return;

    // display share video
    VideoTrack videoTrack = (VideoTrack) shareStream.getTrack();
    shareView.addTrack(videoTrack)

    // listen for share stop event
    participant.addEventListener(new ParticipantEventListener() {
        @Override
        public void onStreamDisabled(Stream stream) {
            if (stream.getKind().equals("share")) {
                shareView.removeTrack();
            }
        }
    });
}
```

</TabItem>

</Tabs>

:::info

- Here screenShare stream is displayed using `VideoView`, but you may also use `SurfaceViewRender` for the same.
- For `VideoView`, SDK version should be `0.1.13` or higher.
- To know more about `VideoView`, please visit [here](/android/guide/video-and-audio-calling-api-sdk/render-media/display-video/understand-videoView-component)

:::

### API Reference

The API references for all the methods and events utilised in this guide are provided below.

- [enableScreenShare()](/android/api/sdk-reference/meeting-class/methods#enablescreenshare)
- [disableScreenShare()](/android/api/sdk-reference/meeting-class/methods#disablescreenshare)
- [onStreamEnabled()](/android/api/sdk-reference/participant-class/participant-event-listener-class#onstreamenabled)
- [onStreamDisabled()](/android/api/sdk-reference/participant-class/participant-event-listener-class#onstreamdisabled)
- [onPresenterChanged()](/android/api/sdk-reference/meeting-class/meeting-event-listener-class#onpresenterchanged)


---

---
title: Integrating Android SDK - Video SDK
hide_title: false
hide_table_of_contents: false
description: Create customizable real-time video & audio calling applications with Android SDK with Video SDK add live Video & Audio conferencing to your applications.
sidebar_label: "Integrate Android SDK"
pagination_label: "Integrate Android SDK"
keywords:
  - android sdk
  - video call
  - audio call
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: integrate-sdk
---

Android SDK is a Java-based native SDK. It is compatible with both Java and Kotlin. It makes it extremely simple to integrate video and audio calls into your app.

### Installing Android SDK

#### Step 1: Add the repositories into your project

You can install our Android SDK by using Maven Central or [Jitpack](https://central.sonatype.com/artifact/live.videosdk/rtc-android-sdk/0.1.14) package repositories.

Add the repository to `settings.gradle` file in your project.

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Maven Central"
groupId={"android-repositories"}
values={[{label: 'Maven Central', value: 'Maven Central'},{label: 'Jitpack', value: 'Jitpack'},]}>

<TabItem value="Maven Central">

```js title="settings.gradle"
dependencyResolutionManagement{
  repositories {
    // ...
    google()
    mavenCentral()
    maven { url "https://maven.aliyun.com/repository/jcenter" }
  }
}
```

</TabItem>

<TabItem value="Jitpack">

```js title="settings.gradle"
dependencyResolutionManagement{
  repositories {
    // ...
    google()
    maven { url 'https://jitpack.io' }
    mavenCentral()
    maven { url "https://maven.aliyun.com/repository/jcenter" }
  }
}
```

</TabItem>

</Tabs>

:::note
You can use imports with Maven Central after rtc-android-sdk version `0.1.12`.

Whether on Maven or Jitpack, the same version numbers always refer to the same SDK.
:::

#### Step 2: Add the dependency in `app/build.gradle`

```js title="app/build.gradle"
dependencies {
		implementation 'live.videosdk:rtc-android-sdk:0.1.38'
		// other app dependencies
}
```


:::important

- Android SDK compatible with armeabi-v7a, arm64-v8a, x86_64 architectures. If you want to run the application in an emulator, choose ABI x86_64 when creating a device.

:::


---

---
sidebar_label: Known Issues
pagination_label: Known Issues
---

# Known Issues - Android

This page will let you updated with Android SDK known issues with better solution.

## Issue : 1

```
Missing Class kotlin.jvm.internal.SourceDebugExtension (referenced from: io.github.crow_misia.mediasoup.Consumer and 8 other contexts)
```

### Solution

To resolve the issue related to the missing class `kotlin.jvm.internal.SourceDebugExtension` when building an APK with ProGuard, you can follow these steps:

#### Step 1: Update Kotlin Version (Optional)

If you are using Kotlin version 1.7.20, consider upgrading it to version 1.8.0. This update may resolve the error you're facing. Check if your project is compatible with Kotlin 1.8.0 and update the Kotlin version in your project configuration accordingly.

#### Step 2: Modify proguard-rules.pro

Open the proguard-rules.pro file in your project and add the following rule:

```java
-dontwarn kotlin.jvm.internal.SourceDebugExtension
```

This rule tells ProGuard to suppress warnings related to the missing class "kotlin.jvm.internal.SourceDebugExtension". By adding this rule, the build process will no longer show the error associated with this class.


---

---
title: Custom Template
sidebar_position: 1
sidebar_label: Custom Template
hide_table_of_contents: false
---

import CustomTemplate from '../../../../../mdx/\_custom-template.mdx';

<CustomTemplate title="Custom Template With LiveStreaming"/>


---

---
title: Interactive Livestream - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: Interactive Livestream features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Interactive Livestream (HLS)
pagination_label: Interactive Livestream (HLS)
keywords:
  - Start HLS meeting
  - Stop HLS meeting
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: interactive-livestream
---

# Interactive Livestream (HLS) - Android

Interactive live streaming (HLS) refers to a type of live streaming where viewers can actively engage with the content being streamed and with other viewers in real-time.

In an interactive live stream (HLS), viewers can take part in a variety of activities like live polling, Q&A sessions, and even sending virtual gifts to the content creator or each other.

<center>

<img src='https://cdn.videosdk.live/website-resources/docs-resources/mobile_hls.png' />

</center>

VideoSDK also allows you to configure the interactive livestream layouts in numerous ways like by simply setting different prebuilt layouts in the configuration or by providing your own custom template to do the livestream according to your layout choice.

This guide will provide an overview of how to implement start and stop Interactive live streaming (HLS).

:::important

To initiate automatic Interactive live streaming (HLS) at the beginning of a `session`, simply provide the `autoStartConfig` feature `hls` during `room` creation. For more information on configuring the `autoStartConfig`, please refer to the provided documentation **[<u>here</u>](/api-reference/realtime-communication/create-room#autoStartConfig)**.

:::

### `startHls()`

`startHls()` can be used to start a interactive livestream of the meeting which can be accessed from the `Meeting` class. This method accepts two parameter:

- `config`: This parameter will define how the interactive livestream layout should look like.

- `transcription`: This parameter lets you start post transcription for the Livestreaming.

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
val config = JSONObject()

//highlight-next-line
// Layout Configuration
val layout = JSONObject()
JsonUtils.jsonPut(layout, "type", "GRID") // "SPOTLIGHT" | "SIDEBAR",  Default : "GRID"
JsonUtils.jsonPut(layout, "priority", "SPEAKER") // "PIN", Default : "SPEAKER"
JsonUtils.jsonPut(layout, "gridSize", 4) // MAX : 25
JsonUtils.jsonPut(config, "layout", layout)

//highlight-next-line
// Theme of interactive livestream layout
JsonUtils.jsonPut(config, "theme", "DARK") //  "LIGHT" | "DEFAULT"

//highlight-next-line
// `mode` is used to either interactive livestream video & audio both or only audio.
JsonUtils.jsonPut(config, "mode", "video-and-audio") // "audio", Default : "video-and-audio"

//highlight-next-line
// Quality of interactive livestream and is only applicable to `video-and-audio` type mode.
JsonUtils.jsonPut(config, "quality", "high") // "low" | "med",  Default : "med"

//highlight-start
// This mode refers to orientation of interactive livestream.
// landscape : Start interactive livestream of the meeting in horizontally
// portrait : Start interactive livestream of the meeting in vertically (Best for mobile view)
//highlight-end
JsonUtils.jsonPut(config, "orientation", "portrait") // "landscape",  Default : "landscape"

//highlight-next-line
// Post Transcription Configuration
val prompt = "Write summary in sections like Title, Agenda, Speakers, Action Items, Outlines, Notes and Summary"
val summaryConfig = SummaryConfig(true, prompt)
val modelId = "raman_v1"
val transcription = PostTranscriptionConfig(true, summaryConfig, modelId)

meeting.startHls(config, transcription)
```

</TabItem>

<TabItem value="Java">

```js
JSONObject config = new JSONObject();

//highlight-next-line
// Layout Configuration
JSONObject layout = new JSONObject();
JsonUtils.jsonPut(layout, "type", "GRID"); // "SPOTLIGHT" | "SIDEBAR",  Default : "GRID"
JsonUtils.jsonPut(layout, "priority", "SPEAKER");  // "PIN", Default : "SPEAKER"
JsonUtils.jsonPut(layout, "gridSize", 4); // MAX : 25
JsonUtils.jsonPut(config, "layout", layout);

//highlight-next-line
// Theme of interactive livestream layout
JsonUtils.jsonPut(config, "theme", "DARK"); //  "LIGHT" | "DEFAULT"

//highlight-next-line
// `mode` is used to either interactive livestream video & audio both or only audio.
JsonUtils.jsonPut(config, "mode", "video-and-audio"); // "audio", Default : "video-and-audio"

//highlight-next-line
// Quality of interactive livestream and is only applicable to `video-and-audio` type mode.
JsonUtils.jsonPut(config, "quality", "high"); // "low" | "med",  Default : "med"

//highlight-start
// This mode refers to orientation of interactive livestream.
// landscape : Start interactive livestream of the meeting in horizontally
// portrait : Start interactive livestream of the meeting in vertically (Best for mobile view)
//highlight-end
JsonUtils.jsonPut(config, "orientation", "portrait"); // "landscape",  Default : "landscape"

//highlight-next-line
// Post Transcription Configuration
String prompt = "Write summary in sections like Title, Agenda, Speakers, Action Items, Outlines, Notes and Summary";
SummaryConfig summaryConfig = new SummaryConfig(true, prompt);
String modelId = "raman_v1";
PostTranscriptionConfig transcription = new PostTranscriptionConfig(true, summaryConfig, modelId);

meeting.startHls(config, transcription);
```

</TabItem>

</Tabs>

### `stopHls()`

- `stopHls()` is used to stop interactive livestream of the meeting which can be accessed from the `Meeting` class.

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
// keep track of hls
val hls = false

findViewById<View>(R.id.btnHls).setOnClickListener { view: View? ->
  if (!hls) {
    //highlight-start
    val config = JSONObject()
    val layout = JSONObject()
    JsonUtils.jsonPut(layout, "type", "GRID")
    JsonUtils.jsonPut(layout, "priority", "SPEAKER")
    JsonUtils.jsonPut(layout, "gridSize", 4)
    JsonUtils.jsonPut(config, "layout", layout)
    JsonUtils.jsonPut(config, "theme", "DARK")
    JsonUtils.jsonPut(config, "mode", "video-and-audio")
    JsonUtils.jsonPut(config, "quality", "high")
    JsonUtils.jsonPut(config, "orientation", "portrait")
    //highlight-end

    //highlight-next-line
    // Post Transcription Configuration
    val prompt = "Write summary in sections like Title, Agenda, Speakers, Action Items, Outlines, Notes and Summary"
    val summaryConfig = SummaryConfig(true, prompt)
    val modelId = "raman_v1"
    val transcription = PostTranscriptionConfig(true, summaryConfig, modelId)

    // Start Hls
    //highlight-next-line
    meeting!!.startHls(config)
  } else {
    // Stop Hls
    //highlight-next-line
    meeting!!.stopHls()
  }
}
```

</TabItem>

<TabItem value="Java">

```js
// keep track of hls
boolean hls = false;

findViewById(R.id.btnHls).setOnClickListener(view -> {
  if (!hls) {
    //highlight-start
    JSONObject config = new JSONObject();
    JSONObject layout = new JSONObject();
    JsonUtils.jsonPut(layout, "type", "GRID");
    JsonUtils.jsonPut(layout, "priority", "SPEAKER");
    JsonUtils.jsonPut(layout, "gridSize", 4);
    JsonUtils.jsonPut(config, "layout", layout);
    JsonUtils.jsonPut(config, "theme", "DARK");
    JsonUtils.jsonPut(config, "mode", "video-and-audio");
    JsonUtils.jsonPut(config, "quality", "high");
    JsonUtils.jsonPut(config, "orientation", "portrait");
    //highlight-end

    //highlight-next-line
    // Post Transcription Configuration
    String prompt = "Write summary in sections like Title, Agenda, Speakers, Action Items, Outlines, Notes and Summary";
    SummaryConfig summaryConfig = new SummaryConfig(true, prompt);
    String modelId = "raman_v1";
    PostTranscriptionConfig transcription = new PostTranscriptionConfig(true, summaryConfig, modelId);

    // Start Hls
    //highlight-next-line
    meeting.startHls(config);
  } else {
    // Stop Hls
    //highlight-next-line
    meeting.stopHls();
  }
});
```

</TabItem>

</Tabs>

:::tip
If you want to learn more about the Interactive Livestream and how you can implement it in your own platform, you can checkout this [guide](/android/guide/interactive-live-streaming/integrate-hls/overview).
:::

### Event associated with HLS

- **onHlsStateChanged** - Whenever meeting HLS state changes, then `onHlsStateChanged` event will trigger.

- You can get the `playbackHlsUrl` and `livestreamUrl` of the HLS to play it on the Viewer side when the state changes to `HLS_PLAYABLE`.
  - `playbackHlsUrl` - Live HLS with playback support
  - `livestreamUrl` - Live HLS without playback support

:::note
`downstreamUrl` is now depecated. Use `playbackHlsUrl` or `livestreamUrl` in place of `downstreamUrl`
:::

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
private val meetingEventListener: MeetingEventListener = object : MeetingEventListener() {
  override fun onHlsStateChanged(HlsState: JSONObject) {
    when (HlsState.getString("status")) {
        "HLS_STARTING" -> Log.d("onHlsStateChanged", "Meeting hls is starting")
        "HLS_STARTED" -> Log.d("onHlsStateChanged", "Meeting hls is started")
        "HLS_PLAYABLE" -> {
            Log.d("onHlsStateChanged", "Meeting hls is playable now")
            //highlight-start
             // on hls playable you will receive playbackHlsUrl and livestreamUrl
            val playbackHlsUrl = HlsState.getString("playbackHlsUrl")
            val livestreamUrl = HlsState.getString("livestreamUrl")
            //highlight-end
        }
        "HLS_STOPPING" -> Log.d("onHlsStateChanged", "Meeting hls is stopping")
        "HLS_STOPPED" -> Log.d("onHlsStateChanged", "Meeting hls is stopped")
    }
  }
}

override fun onCreate(savedInstanceState: Bundle?) {
  //...

  // add listener to meeting
  //highlight-next-line
  meeting!!.addEventListener(meetingEventListener)
}
```

</TabItem>

<TabItem value="Java">

```js
private final MeetingEventListener meetingEventListener = new MeetingEventListener() {
  @Override
  public void onHlsStateChanged(JSONObject HlsState) {
      switch (HlsState.getString("status")) {
          case "HLS_STARTING":
              Log.d("onHlsStateChanged", "Meeting hls is starting");
              break;
          case "HLS_STARTED":
              Log.d("onHlsStateChanged", "Meeting hls is started");
              break;
          case "HLS_PLAYABLE":
              Log.d("onHlsStateChanged", "Meeting hls is playable now");
              //highlight-start
              // on hls started you will receive playbackHlsUrl and livestreamUrl
              String playbackHlsUrl = HlsState.getString("playbackHlsUrl");
              String livestreamUrl = HlsState.getString("livestreamUrl");
              //highlight-end
              break;
          case "HLS_STOPPING":
              Log.d("onHlsStateChanged", "Meeting hls is stopping");
              break;
          case "HLS_STOPPED":
              Log.d("onHlsStateChanged", "Meeting hls is stopped");
              break;
      }
  }
}

@Override
protected void onCreate(Bundle savedInstanceState) {
  //...

  // add listener to meeting
  //highlight-next-line
  meeting.addEventListener(meetingEventListener);
}
```

</TabItem>

</Tabs>

### API Reference

The API references for all the methods utilised in this guide are provided below.

- [startHls()](/android/api/sdk-reference/meeting-class/methods#starthls)
- [stopHls()](/android/api/sdk-reference/meeting-class/methods#stophls)
- [onHlsStateChanged](/android/api/sdk-reference/meeting-class/meeting-event-listener-class#onhlsstatechanged)
- [autoStartConfig](/api-reference/realtime-communication/create-room#autoStartConfig)


---

---
title: RTMP Livestream - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: RTMP Livestream features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: RTMP Livestream
pagination_label: RTMP Livestream
keywords:
  - Start Livestream meeting
  - Stop Livestream meeting
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: rtmp-livestream
---

# RTMP Livestream - Android

RTMP is a popular protocol for live streaming video content from a VideoSDK to platforms such as YouTube, Twitch, Facebook, and others.

By providing the platform-specific stream key and stream URL, the VideoSDK can connect to the platform's RTMP server and transmit the live video stream.

VideoSDK allows you to livestream your meeting to platform which support RTMP ingestion just by providing the platform-specific stream key and stream URL, we can connect to the platform's RTMP server and transmit the live video stream.

VideoSDK also allows you to configure the livestream layouts in numerous ways like by simply setting different prebuilt layouts in the configuration or by providing your own custom template to do the livestream according to your layout choice.

This guide will provide an overview of how to implement start and stop RTMP Livestreaming.

### `startLivestream()`

`startLivestream()` can be used to start a RTMP livestream of the meeting which can be accessed from the `Meeting` class. This method accepts two parameters:

- `1. outputs`: This parameter accepts a list of `LivestreamOutput` objects which contains the RTMP `url` and `streamKey` of the platforms you want to start the livestream.

- `2. config`: This parameter will define how the livestream layout should look like. You can pass `null` for default layout.

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
val config = JSONObject()

//highlight-next-line
// Layout Configuration
val layout = JSONObject()
JsonUtils.jsonPut(layout, "type", "GRID") // "SPOTLIGHT" | "SIDEBAR",  Default : "GRID"
JsonUtils.jsonPut(layout, "priority", "SPEAKER") // "PIN", Default : "SPEAKER"
JsonUtils.jsonPut(layout, "gridSize", 4) // MAX : 4
JsonUtils.jsonPut(config, "layout", layout)

//highlight-next-line
// Theme of livestream layout
JsonUtils.jsonPut(config, "theme", "DARK") //  "LIGHT" | "DEFAULT"

val outputs: MutableList<LivestreamOutput> = ArrayList()
outputs.add(LivestreamOutput(RTMP_URL, RTMP_STREAM_KEY))

meeting!!.startLivestream(outputs,config)
```

</TabItem>

<TabItem value="Java">

```js
JSONObject config = new JSONObject();

//highlight-next-line
// Layout Configuration
JSONObject layout = new JSONObject();
JsonUtils.jsonPut(layout, "type", "GRID"); // "SPOTLIGHT" | "SIDEBAR",  Default : "GRID"
JsonUtils.jsonPut(layout, "priority", "SPEAKER");  // "PIN", Default : "SPEAKER"
JsonUtils.jsonPut(layout, "gridSize", 4); // MAX : 4
JsonUtils.jsonPut(config, "layout", layout);

//highlight-next-line
// Theme of livestream layout
JsonUtils.jsonPut(config, "theme", "DARK"); //  "LIGHT" | "DEFAULT"

List<LivestreamOutput> outputs = new ArrayList<>();
outputs.add(new LivestreamOutput(RTMP_URL, RTMP_STREAM_KEY));

meeting.startLivestream(outputs,config);
```

</TabItem>

</Tabs>

### `stopLivestream()`

- `stopLivestream()` is used to stop the meeting livestream which can be accessed from the `Meeting` class.

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
// keep track of livestream status
val liveStream = false

findViewById<View>(R.id.btnLiveStream).setOnClickListener { view: View? ->
  if (!liveStream) {
    //highlight-start
    val config = JSONObject()
    val layout = JSONObject()
    JsonUtils.jsonPut(layout, "type", "GRID")
    JsonUtils.jsonPut(layout, "priority", "SPEAKER")
    JsonUtils.jsonPut(layout, "gridSize", 4)
    JsonUtils.jsonPut(config, "layout", layout)
    JsonUtils.jsonPut(config, "theme", "DARK")
    //highlight-end

    val outputs: MutableList<LivestreamOutput> = ArrayList()
    //highlight-next-line
    outputs.add(LivestreamOutput(RTMP_URL, RTMP_STREAM_KEY))

    // Start LiveStream
    //highlight-next-line
    meeting!!.startLivestream(outputs,config)
  } else {
    // Stop LiveStream
    //highlight-next-line
    meeting!!.stopLivestream()
  }
}
```

</TabItem>

<TabItem value="Java">

```js
// keep track of livestream status
boolean liveStream = false;

findViewById(R.id.btnLiveStream).setOnClickListener(view -> {
  if (!liveStream) {
    //highlight-start
    JSONObject config = new JSONObject();
    JSONObject layout = new JSONObject();
    JsonUtils.jsonPut(layout, "type", "GRID");
    JsonUtils.jsonPut(layout, "priority", "SPEAKER");
    JsonUtils.jsonPut(layout, "gridSize", 4);
    JsonUtils.jsonPut(config, "layout", layout);
    JsonUtils.jsonPut(config, "theme", "DARK");
    //highlight-end

    List<LivestreamOutput> outputs = new ArrayList<>();
    //highlight-next-line
    outputs.add(new LivestreamOutput(RTMP_URL, RTMP_STREAM_KEY));

    // Start LiveStream
    //highlight-next-line
    meeting.startLivestream(outputs,config);
  } else {
    // Stop LiveStream
    //highlight-next-line
    meeting.stopLivestream();
  }
});
```

</TabItem>

</Tabs>

### Event associated with Livestream

- **onLivestreamStateChanged** - Whenever meeting livestream state changes, then `onLivestreamStateChanged` event will trigger.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
private val meetingEventListener: MeetingEventListener = object : MeetingEventListener() {
  override fun onLivestreamStateChanged(livestreamState: String?) {
    when (livestreamState) {
      "LIVESTREAM_STARTING" -> Log.d( "LivestreamStateChanged",
          "Meeting livestream is starting"
      )
      "LIVESTREAM_STARTED" -> Log.d( "LivestreamStateChanged",
          "Meeting livestream is started"
      )
      "LIVESTREAM_STOPPING" -> Log.d("LivestreamStateChanged",
          "Meeting livestream is stopping"
      )
      "LIVESTREAM_STOPPED" -> Log.d("LivestreamStateChanged",
          "Meeting livestream is stopped"
      )
    }
  }
}

override fun onCreate(savedInstanceState: Bundle?) {
  //...

  // add listener to meeting
  //highlight-next-line
  meeting!!.addEventListener(meetingEventListener)
}
```

</TabItem>

<TabItem value="Java">

```js
private final MeetingEventListener meetingEventListener = new MeetingEventListener() {
  @Override
  public void onLivestreamStateChanged(String livestreamState) {
    switch (livestreamState) {
      case "LIVESTREAM_STARTING":
          Log.d("LivestreamStateChanged", "Meeting livestream is starting");
          break;
      case "LIVESTREAM_STARTED":
          Log.d("LivestreamStateChanged", "Meeting livestream is started");
          break;
      case "LIVESTREAM_STOPPING":
          Log.d("LivestreamStateChanged", "Meeting livestream is stopping");
          break;
      case "LIVESTREAM_STOPPED":
          Log.d("LivestreamStateChanged", "Meeting livestream is stopped");
          break;
    }
  }
}

@Override
protected void onCreate(Bundle savedInstanceState) {
  //...

  // add listener to meeting
  //highlight-next-line
  meeting.addEventListener(meetingEventListener);
}
```

</TabItem>

</Tabs>

### API Reference

The API references for all the methods utilised in this guide are provided below.

- [startLivestream()](/android/api/sdk-reference/meeting-class/methods#startlivestream)
- [stopLivestream()](/android/api/sdk-reference/meeting-class/methods#stoplivestream)
- [onLivestreamStateChanged](/android/api/sdk-reference/meeting-class/meeting-event-listener-class#onlivestreamstatechanged)


---

---
title: Quick Start With Http Live Streaming
hide_title: true
hide_table_of_contents: false
description: Video SDK enables the opportunity to integrate native IOS, Android & Web SDKs to add live video & audio conferencing to your applications.
sidebar_label: Start With Http Live Streaming(HLS)
pagination_label: Quick Start With Interactive Live Streaming
keywords:
  - audio calling
  - video calling
  - real-time communication
  - collaboration
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: quick-start-ILS
---

# Quick Start for Http Live Streaming(HLS) in Android

<ReactPlayer controls url="https://www.youtube.com/watch?v=KdiXs9w7qVE" height="500px" width={"100%"} />

VideoSDK empowers you to seamlessly integrate the Http Live Streaming(HLS) feature into your React Native application within minutes.

In this quickstart, you'll explore this feature of VideoSDK. Follow the step-by-step guide to integrate it within your application.

:::info

For low-latency interactive live streaming (under 100ms), follow this [documentation](./quick-start-android-ils.md).
:::

## Prerequisites

Before proceeding, ensure that your development environment meets the following requirements:

- Java Development Kit.
- Android Studio 3.0 or later.
- Android SDK API Level 21 or higher.
- A mobile device that runs Android 5.0 or later.

:::important

One should have a VideoSDK account to generate token.
Visit VideoSDK **[dashboard](https://app.videosdk.live/api-keys)** to generate token

:::

## Getting Started with the Code!

Follow the steps to create the environment necessary to add video calls into your app. Also you can find the code sample for [quickstart here](https://github.com/videosdk-live/quickstart/tree/main/android-hls).

import CautionMessage from '@site/src/theme/CautionMessage';

<CautionMessage sdk="Android SDK" version="v0.2.0" />

### Create new Android Project

For a new project in **Android Studio**, create a **Phone and Tablet** Android project with an **Empty Activity**.

![VideoSDK Android Quick Start New Project](/img/quick-start/android_newProject.png)

:::caution
After creating the project, Android Studio automatically starts gradle sync. Ensure that the sync succeeds before you continue.
:::

### Integrate Video SDK

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Maven Central"
groupId={"android-repositories"}
values={[{label: 'Maven Central', value: 'Maven Central'},{label: 'Jitpack', value: 'Jitpack'},]}>

<TabItem value="Maven Central">

```js title="settings.gradle"
dependencyResolutionManagement{
  repositories {
    // ...
    google()
    mavenCentral()
    maven { url "https://maven.aliyun.com/repository/jcenter" }
  }
}
```

</TabItem>

<TabItem value="Jitpack">

```js title="settings.gradle"
dependencyResolutionManagement{
  repositories {
    // ...
    google()
    maven { url 'https://jitpack.io' }
    mavenCentral()
    maven { url "https://maven.aliyun.com/repository/jcenter" }
  }
}
```

</TabItem>

</Tabs>

:::note

You can use imports with Maven Central after rtc-android-sdk version `0.1.12`.

Whether on Maven or Jitpack, the same version numbers always refer to the same SDK.

:::

- Add the following dependency in your app's `app/build.gradle`.

```js title="app/build.gradle"
dependencies {
  implementation 'live.videosdk:rtc-android-sdk:0.1.38'

  // library to perform Network call to generate a meeting id
  implementation 'com.amitshekhar.android:android-networking:1.0.2'

  // other app dependencies
  }
```

:::important

Android SDK compatible with armeabi-v7a, arm64-v8a, x86_64 architectures. If you want to run the application in an emulator, choose ABI x86_64 when creating a device.

:::

### Add permissions into your project

- In `/app/Manifests/AndroidManifest.xml`, add the following permissions after `</application>`.

```xml title="AndroidManifest.xml"
<uses-permission android:name="android.permission.RECORD_AUDIO" />
<uses-permission android:name="android.permission.MODIFY_AUDIO_SETTINGS" />
<uses-permission android:name="android.permission.INTERNET" />
<uses-permission android:name="android.permission.CAMERA" />
```

:::note

If your project has set `android.useAndroidX=true`, then set `android.enableJetifier=true` in the `gradle.properties` file to migrate your project to AndroidX and avoid duplicate class conflict.

:::

### Structure of the project

Your project structure should look like this.

```jsx title="Project Structure"
   app
   ├── java
   │    ├── packagename
   │         ├── JoinActivity
   │         ├── MeetingActivity
   │         ├── SpeakerAdapter
   │         ├── SpeakerFragment
   |         ├── ViewerFragment
   ├── res
   │    ├── layout
   │    │    ├── activity_join.xml
   │    │    ├── activity_meeting.xml
   |    |    ├── fragment_speaker.xml
   |    |    ├── fragment_viewer.xml
   │    │    ├── item_remote_peer.xml
```

:::note

You have to set JoinActivity as Launcher activity.

:::

### App Architecture

<center>

<img src='https://cdn.videosdk.live/website-resources/docs-resources/android_ils_quickstart_app_structure.png' />

</center>

### Step 1: Creating Joining Screen

Create a new Activity named `JoinActivity`.

#### Creating UI

The Joining screen will include :

1. **Create Button** - This button will create a new meeting for you.
2. **TextField for Meeting Id** - This text field will contain the meeting Id you want to join.
3. **Join as Host Button** - This button will join the meeting as **host** with `meetingId` you provided.
4. **Join as Viewer Button** - This button will join the meeting as **viewer** with `meetingId` you provided.

In `/app/res/layout/activity_join.xml` file, replace the content with the following.

```xml title="activity_join.xml"
<?xml version="1.0" encoding="utf-8"?>

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:id="@+id/createorjoinlayout"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:background="@color/black"
    android:gravity="center"
    android:orientation="vertical">

    <Button
        android:id="@+id/btnCreateMeeting"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Create Meeting"
        android:textAllCaps="false" />

    <TextView
        android:id="@+id/tvText"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:paddingVertical="5sp"
        android:text="OR"
        android:textColor="@color/white"
        android:textSize="20sp" />

    <EditText
        android:id="@+id/etMeetingId"
        android:theme="@android:style/Theme.Holo"
        android:layout_width="250dp"
        android:layout_height="wrap_content"
        android:hint="Enter Meeting Id"
        android:textColor="@color/white"
        android:textColorHint="@color/white" />

    <Button
        android:id="@+id/btnJoinHostMeeting"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_marginTop="8sp"
        android:text="Join as Host"
        android:textAllCaps="false" />

    <Button
        android:id="@+id/btnJoinViewerMeeting"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Join as Viewer"
        android:textAllCaps="false" />

</LinearLayout>
```

#### Integration of Create Meeting API

1. Create field `sampleToken` in `JoinActivity` which will hold the generated token from the [VideoSDK dashboard](https://app.videosdk.live/api-keys). This token will use in VideoSDK config as well as in generating meetingId.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js title="JoinActivity.kt"
class JoinActivity : AppCompatActivity() {

  //highlight-next-line
  //Replace with the token you generated from the VideoSDK Dashboard
  private var sampleToken = ""

  override fun onCreate(savedInstanceState: Bundle?) {
    //...
  }
}
```

</TabItem>

<TabItem value="Java">

```java title="JoinActivity.java"
public class JoinActivity extends AppCompatActivity {

  //highlight-next-line
  //Replace with the token you generated from the VideoSDK Dashboard
  private String sampleToken ="";

  @Override
  protected void onCreate(Bundle savedInstanceState) {
    //...
  }
}
```

</TabItem>

</Tabs>

2. On **Join Button as Host** `onClick` events, we will naviagte to `MeetingActivity` with token, meetingId and mode as `SEND_AND_RECV`.

3. On **Join Button as Viewer** `onClick` events, we will naviagte to `MeetingActivity` with token, meetingId and mode as `Viewer`.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js title="JoinActivity.kt"
class JoinActivity : AppCompatActivity() {

   //Replace with the token you generated from the VideoSDK Dashboard
   private var sampleToken = "";

   override fun onCreate(savedInstanceState: Bundle?) {
      super.onCreate(savedInstanceState)
      setContentView(R.layout.activity_join)

      val btnCreate = findViewById<Button>(R.id.btnCreateMeeting)
      val btnJoinHost = findViewById<Button>(R.id.btnJoinHostMeeting)
      val btnJoinViewer = findViewById<Button>(R.id.btnJoinViewerMeeting)
      val etMeetingId = findViewById<EditText>(R.id.etMeetingId)

      //highlight-next-line
      // create meeting and join as Host
      btnCreate.setOnClickListener {
          createMeeting(
              sampleToken
          )
      }

      //highlight-next-line
      // Join as Host
      btnJoinHost.setOnClickListener {
          val intent = Intent(this@JoinActivity, MeetingActivity::class.java)
          intent.putExtra("token", sampleToken)
          intent.putExtra("meetingId", etMeetingId.text.toString().trim { it <= ' ' })
          //highlight-next-line
          intent.putExtra("mode", "SEND_AND_RECV")
          startActivity(intent)
      }

      //highlight-next-line
      // Join as Viewer
      btnJoinViewer.setOnClickListener {
          val intent = Intent(this@JoinActivity, MeetingActivity::class.java)
          intent.putExtra("token", sampleToken)
          intent.putExtra("meetingId", etMeetingId.text.toString().trim { it <= ' ' })
          //highlight-next-line
          intent.putExtra("mode", "SIGNALLING_ONLY")
          startActivity(intent)
      }
    }

    private fun createMeeting(token: String) {
      // we will explore this method in the next step
    }
}
```

</TabItem>

<TabItem value="Java">

```java title="JoinActivity.java"
public class JoinActivity extends AppCompatActivity {

  //Replace with the token you generated from the VideoSDK Dashboard
  private String sampleToken ="";

  @Override
  protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_join);

    final Button btnCreate = findViewById(R.id.btnCreateMeeting);
    final Button btnJoinHost = findViewById(R.id.btnJoinHostMeeting);
    final Button btnJoinViewer = findViewById(R.id.btnJoinViewerMeeting);
    final EditText etMeetingId = findViewById(R.id.etMeetingId);

    //highlight-next-line
    // create meeting and join as Host
    btnCreate.setOnClickListener(v -> createMeeting(sampleToken));

    //highlight-next-line
    // Join as Host
    btnJoinHost.setOnClickListener(v -> {
        Intent intent = new Intent(JoinActivity.this, MeetingActivity.class);
        intent.putExtra("token", sampleToken);
        intent.putExtra("meetingId", etMeetingId.getText().toString().trim());
        //highlight-next-line
        intent.putExtra("mode", "SEND_AND_RECV");
        startActivity(intent);
    });

    //highlight-next-line
    // Join as Viewer
    btnJoinViewer.setOnClickListener(v -> {
        Intent intent = new Intent(JoinActivity.this, MeetingActivity.class);
        intent.putExtra("token", sampleToken);
        intent.putExtra("meetingId", etMeetingId.getText().toString().trim());
        //highlight-next-line
        intent.putExtra("mode", "SIGNALLING_ONLY");
        startActivity(intent);
    });
  }

  private void createMeeting(String token) {
    // we will explore this method in the next step
  }
}
```

</TabItem>

</Tabs>

4. For **Create Button**, under `createMeeting` method we will generate meetingId by calling API and navigate to `MeetingActivity` with token, generated meetingId and mode as `SEND_AND_RECV`.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js title="JoinActivity.kt"
class JoinActivity : AppCompatActivity() {
  //...onCreate
 private fun createMeeting(token: String) {
  // we will make an API call to VideoSDK Server to get a roomId
  AndroidNetworking.post("https://api.videosdk.live/v2/rooms")
      .addHeaders("Authorization", token) //we will pass the token in the Headers
      .build()
      .getAsJSONObject(object : JSONObjectRequestListener {
          override fun onResponse(response: JSONObject) {
            try {
              // response will contain `roomId`
              val meetingId = response.getString("roomId")

              // starting the MeetingActivity with received roomId and our sampleToken
              val intent = Intent(this@JoinActivity, MeetingActivity::class.java)
              intent.putExtra("token", sampleToken)
              intent.putExtra("meetingId", meetingId)
              //highlight-next-line
              intent.putExtra("mode", "SEND_AND_RECV")
              startActivity(intent)
            } catch (e: JSONException) {
                e.printStackTrace()
            }
          }

          override fun onError(anError: ANError) {
            anError.printStackTrace()
            Toast.makeText(this@JoinActivity, anError.message, Toast.LENGTH_SHORT)
                .show()
          }
      })
  }
}
```

</TabItem>

<TabItem value="Java">

```java title="JoinActivity.java"
public class JoinActivity extends AppCompatActivity {
  //...onCreate

  private void createMeeting(String token) {
    // we will make an API call to VideoSDK Server to get a roomId
    AndroidNetworking.post("https://api.videosdk.live/v2/rooms")
          .addHeaders("Authorization", token) //we will pass the token in the Headers
          .build()
          .getAsJSONObject(new JSONObjectRequestListener() {
              @Override
              public void onResponse(JSONObject response) {
                try {
                  // response will contain `roomId`
                  final String meetingId = response.getString("roomId");

                  // starting the MeetingActivity with received roomId and our sampleToken
                  Intent intent = new Intent(JoinActivity.this, MeetingActivity.class);
                  intent.putExtra("token", sampleToken);
                  intent.putExtra("meetingId", meetingId);
                  //highlight-next-line
                  intent.putExtra("mode", "SEND_AND_RECV");
                  startActivity(intent);
                } catch (JSONException e) {
                    e.printStackTrace();
                }
              }

              @Override
              public void onError(ANError anError) {
                anError.printStackTrace();
                Toast.makeText(JoinActivity.this, anError.getMessage(), Toast.LENGTH_SHORT).show();
              }
          });
  }
}
```

</TabItem>

</Tabs>

:::note

Don't confuse with Room and Meeting keyword, both are same thing 😃

:::

5. Our App is completely based on audio and video communicatation, that's why we need to ask for runtime permissions `RECORD_AUDIO` and `CAMERA`. So, we will implement permission logic on `JoinActivity`.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js title="JoinActivity.kt"
class JoinActivity : AppCompatActivity() {
  companion object {
    private const val PERMISSION_REQ_ID = 22
    private val REQUESTED_PERMISSIONS = arrayOf(
        Manifest.permission.RECORD_AUDIO,
        Manifest.permission.CAMERA
    )
  }

  private fun checkSelfPermission(permission: String, requestCode: Int) {
    if (ContextCompat.checkSelfPermission(this, permission) !=
        PackageManager.PERMISSION_GRANTED
    ) {
        ActivityCompat.requestPermissions(this, REQUESTED_PERMISSIONS, requestCode)
    }
  }

  override fun onCreate(savedInstanceState: Bundle?) {
    //... button listeneres
    //highlight-start
    checkSelfPermission(REQUESTED_PERMISSIONS[0], PERMISSION_REQ_ID)
    checkSelfPermission(REQUESTED_PERMISSIONS[1], PERMISSION_REQ_ID)
    //highlight-end
  }
}
```

</TabItem>

<TabItem value="Java">

```java title="JoinActivity.java"
public class JoinActivity extends AppCompatActivity {
  private static final int PERMISSION_REQ_ID = 22;

  private static final String[] REQUESTED_PERMISSIONS = {
    Manifest.permission.RECORD_AUDIO,
    Manifest.permission.CAMERA
  };

  private void checkSelfPermission(String permission, int requestCode) {
    if (ContextCompat.checkSelfPermission(this, permission) !=
            PackageManager.PERMISSION_GRANTED) {
      ActivityCompat.requestPermissions(this, REQUESTED_PERMISSIONS, requestCode);
    }
  }

  @Override
  protected void onCreate(Bundle savedInstanceState) {
    //... button listeneres
   //highlight-start
   checkSelfPermission(REQUESTED_PERMISSIONS[0], PERMISSION_REQ_ID);
   checkSelfPermission(REQUESTED_PERMISSIONS[1], PERMISSION_REQ_ID);
   //highlight-end
  }
}
```

</TabItem>

</Tabs>

#### Output

<center>

<img style={{height: '450px'}} src="https://cdn.videosdk.live/website-resources/docs-resources/android_ils_quickstart_join_screen.jpg" />

</center>

### Step 2: Creating Meeting Screen

Create a new Activity named `MeetingActivity`.

#### Creating the UI for Meeting Screen

In `/app/res/layout/activity_meeting.xml` file, replace the content with the following.

```xml title="activty_meeting.xml"
<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:id="@+id/mainLayout"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:background="@color/black"
    tools:context=".MeetingActivity">

    <TextView
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:gravity="center"
        android:text="Creating a meeting for you"
        android:textColor="@color/white"
        android:textFontWeight="700"
        android:textSize="20sp" />

</RelativeLayout>
```

#### Initializing the Meeting

After getting token, meetigId and mode from `JoinActivity`,

1. Initialize **VideoSDK**.
2. Configure **VideoSDK** with token.
3. Initialize the meeting with required params such as `meetingId`, `participantName`, `micEnabled`, `webcamEnabled` , `mode` and more.
4. Join the room with `meeting.join()` method.
5. Add `MeetingEventListener` for listening **Meeting Join** event.
6. Check mode of `localParticipant`, If mode is **SEND_AND_RECV** than we will replace mainLayout with `SpeakerFragment` otherwise replace with `ViewerFragment`.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js title="MeetingActivity.kt"
class MeetingActivity : AppCompatActivity() {
  var meeting: Meeting? = null
      private set

  override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    setContentView(R.layout.activity_meeting)

    val meetingId = intent.getStringExtra("meetingId")
    val token = intent.getStringExtra("token")
    val mode = intent.getStringExtra("mode")
    val localParticipantName = "John Doe"
    val streamEnable = mode == "SEND_AND_RECV"

    //highlight-next-line
    // initialize VideoSDK
    VideoSDK.initialize(applicationContext)

    //highlight-next-line
    // Configuration VideoSDK with Token
    VideoSDK.config(token)

    //highlight-next-line
    // Initialize VideoSDK Meeting
    meeting = VideoSDK.initMeeting(
        this@MeetingActivity, meetingId, localParticipantName,
        streamEnable, streamEnable, null, mode, false, null, null
    )

    //highlight-next-line
    // join Meeting
    meeting!!.join()

    //highlight-next-line
    // if mode is SEND_AND_RECV than replace mainLayout with SpeakerFragment otherwise with ViewerFragment
    meeting!!.addEventListener(object : MeetingEventListener() {
      override fun onMeetingJoined() {
          if (meeting != null) {
            if (mode == "SEND_AND_RECV") {
              //highlight-next-line
              //pin the local participant
              meeting!!.localParticipant.pin("SHARE_AND_CAM")
              supportFragmentManager
                  .beginTransaction()
                  .replace(R.id.mainLayout, SpeakerFragment(), "MainFragment")
                  .commit()
              } else if (mode == "SIGNALLING_ONLY") {
                supportFragmentManager
                    .beginTransaction()
                    .replace(R.id.mainLayout, ViewerFragment(), "viewerFragment")
                    .commit()
              }
          }
      }
    })
  }
}
```

</TabItem>

<TabItem value="Java">

```java title="MeetingActivity.java"
public class MeetingActivity extends AppCompatActivity {
  private Meeting meeting;

  @Override
  protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_meeting);

    final String meetingId = getIntent().getStringExtra("meetingId");
    String token = getIntent().getStringExtra("token");
    String mode = getIntent().getStringExtra("mode");
    String localParticipantName = "John Doe";
    boolean streamEnable = mode.equals("SEND_AND_RECV");

    //highlight-next-line
    // initialize VideoSDK
    VideoSDK.initialize(getApplicationContext());

    //highlight-next-line
    // Configuration VideoSDK with Token
    VideoSDK.config(token);

    //highlight-next-line
    // Initialize VideoSDK Meeting
    meeting = VideoSDK.initMeeting(
            MeetingActivity.this, meetingId, localParticipantName,
            streamEnable, streamEnable, null, mode, false, null, null);

    //highlight-next-line
    // join Meeting
    meeting.join();

    //highlight-next-line
    // if mode is SEND_AND_RECV than replace mainLayout with SpeakerFragment otherwise with ViewerFragment
    meeting.addEventListener(new MeetingEventListener() {
        @Override
        public void onMeetingJoined() {
          if (meeting != null) {
            if (mode.equals("SEND_AND_RECV")) {
              //highlight-next-line
              //pin the local participant
              meeting.getLocalParticipant().pin("SHARE_AND_CAM");
              getSupportFragmentManager()
                  .beginTransaction()
                  .replace(R.id.mainLayout, new SpeakerFragment(), "MainFragment")
                  .commit();
            } else if (mode.equals("SIGNALLING_ONLY")) {
              getSupportFragmentManager()
                  .beginTransaction()
                  .replace(R.id.mainLayout, new ViewerFragment(), "viewerFragment")
                  .commit();
            }
          }
        }
      });
  }
  public Meeting getMeeting() {
      return meeting;
  }
}
```

</TabItem>

</Tabs>

#### Output

<center>

<img style={{height: '450px'}} src="https://cdn.videosdk.live/website-resources/docs-resources/android_ils_quickstart_meeting_screen.jpg" />

</center>

### Step 3: Implement SpeakerView

After successfully enter into the meeting, it's time to render speaker's view and manage controls such as toggle webcam/mic,start/stop HLS and leave the meeting.

1. Create a new fragment named `SpeakerFragment`.

2. In `/app/res/layout/fragment_speaker.xml` file, replace the content with the following.

```xml title="fragment_speaker.xml"
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:background="@color/black"
    android:gravity="center"
    android:orientation="vertical"
    tools:context=".SpeakerFragment">

    <LinearLayout
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:layout_marginVertical="8sp"
        android:paddingHorizontal="10sp">

        <TextView
            android:id="@+id/tvMeetingId"
            android:layout_width="0dp"
            android:layout_height="wrap_content"
            android:text="Meeting Id : "
            android:textColor="@color/white"
            android:textSize="18sp"
            android:layout_weight="3"/>

        <Button
            android:id="@+id/btnLeave"
            android:layout_width="0dp"
            android:layout_height="wrap_content"
            android:text="Leave"
            android:textAllCaps="false"
            android:layout_weight="1"/>

    </LinearLayout>

    <TextView
        android:id="@+id/tvHlsState"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Current HLS State : NOT_STARTED"
        android:textColor="@color/white"
        android:textSize="18sp" />

    <androidx.recyclerview.widget.RecyclerView
        android:id="@+id/rvParticipants"
        android:layout_width="match_parent"
        android:layout_height="0dp"
        android:layout_marginVertical="10sp"
        android:layout_weight="1" />

    <LinearLayout
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:gravity="center">

        <Button
            android:id="@+id/btnHLS"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:text="Start HLS"
            android:textAllCaps="false" />

        <Button
            android:id="@+id/btnWebcam"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:layout_marginHorizontal="5sp"
            android:text="Toggle Webcam"
            android:textAllCaps="false" />

        <Button
            android:id="@+id/btnMic"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:text="Toggle Mic"
            android:textAllCaps="false" />

    </LinearLayout>

</LinearLayout>
```

3. Now, let's set listener for buttons which will allow the participant to toggle media.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js title="SpeakerFragment.kt"
class SpeakerFragment : Fragment() {
  private var micEnabled = true
  private var webcamEnabled = true
  private var hlsEnabled = false
  private var btnMic: Button? = null
  private var btnWebcam: Button? = null
  private var btnHls: Button? = null
  private var btnLeave: Button? = null
  private var tvMeetingId: TextView? = null
  private var tvHlsState: TextView? = null
  override fun onAttach(context: Context) {
    super.onAttach(context)
    mContext = context
    if (context is Activity) {
      mActivity = context
      //highlight-next-line
      // getting meeting object from Meeting Activity
      meeting = (mActivity as MeetingActivity?)!!.meeting
    }
  }

  override fun onCreateView(
      inflater: LayoutInflater, container: ViewGroup?,
      savedInstanceState: Bundle?
  ): View? {
    // Inflate the layout for this fragment
    val view = inflater.inflate(R.layout.fragment_speaker, container, false)
    btnMic = view.findViewById(R.id.btnMic)
    btnWebcam = view.findViewById(R.id.btnWebcam)
    btnHls = view.findViewById(R.id.btnHLS)
    btnLeave = view.findViewById(R.id.btnLeave)
    tvMeetingId = view.findViewById(R.id.tvMeetingId)
    tvHlsState = view.findViewById(R.id.tvHlsState)
    if (meeting != null) {
      tvMeetingId!!.text = "Meeting Id : " + meeting!!.meetingId
      //highlight-next-line
      setActionListeners()
    }
    return view
  }

  private fun setActionListeners() {
    btnMic!!.setOnClickListener {
      if (micEnabled) {
        //highlight-next-line
        meeting!!.muteMic()
        Toast.makeText(mContext, "Mic Muted", Toast.LENGTH_SHORT).show()
      } else {
        //highlight-next-line
        meeting!!.unmuteMic()
        Toast.makeText(
            mContext,
            "Mic Enabled",
            Toast.LENGTH_SHORT
        ).show()
      }
      micEnabled = !micEnabled
    }
    btnWebcam!!.setOnClickListener {
      if (webcamEnabled) {
        //highlight-next-line
        meeting!!.disableWebcam()
        Toast.makeText(
            mContext,
            "Webcam Disabled",
            Toast.LENGTH_SHORT
        ).show()
      } else {
        //highlight-next-line
        meeting!!.enableWebcam()
        Toast.makeText(
            mContext,
            "Webcam Enabled",
            Toast.LENGTH_SHORT
        ).show()
      }
      webcamEnabled = !webcamEnabled
    }
    //highlight-next-line
    btnLeave!!.setOnClickListener { meeting!!.leave() }
    btnHls!!.setOnClickListener {
      if (!hlsEnabled) {
        //highlight-start
        val config = JSONObject()
        val layout = JSONObject()
        JsonUtils.jsonPut(layout, "type", "SPOTLIGHT")
        JsonUtils.jsonPut(layout, "priority", "PIN")
        JsonUtils.jsonPut(layout, "gridSize", 4)
        JsonUtils.jsonPut(config, "layout", layout)
        JsonUtils.jsonPut(config, "orientation", "portrait")
        JsonUtils.jsonPut(config, "theme", "DARK")
        JsonUtils.jsonPut(config, "quality", "high")
        meeting!!.startHls(config)
        //highlight-end
      } else {
        //highlight-next-line
        meeting!!.stopHls()
      }
    }
  }

  companion object {
    private var mActivity: Activity? = null
    private var mContext: Context? = null
    private var meeting: Meeting? = null
  }
}
```

</TabItem>

<TabItem value="Java">

```java title="SpeakerFragment.java"
public class SpeakerFragment extends Fragment {

  private static Activity mActivity;
  private static Context mContext;
  private static Meeting meeting;
  private boolean micEnabled = true;
  private boolean webcamEnabled = true;
  private boolean hlsEnabled = false;
  private Button btnMic, btnWebcam, btnHls, btnLeave;
  private TextView tvMeetingId, tvHlsState;

  public SpeakerFragment() {
    // Required empty public constructor
  }

  @Override
  public void onAttach(@NonNull Context context) {
    super.onAttach(context);
    mContext = context;
    if (context instanceof Activity) {
      mActivity = (Activity) context;
      //highlight-next-line
      // getting meeting object from Meeting Activity
      meeting = ((MeetingActivity) mActivity).getMeeting();
    }
  }

  @Override
  public View onCreateView(LayoutInflater inflater, ViewGroup container,
                            Bundle savedInstanceState) {
    // Inflate the layout for this fragment
    View view = inflater.inflate(R.layout.fragment_speaker, container, false);
    btnMic = view.findViewById(R.id.btnMic);
    btnWebcam = view.findViewById(R.id.btnWebcam);
    btnHls = view.findViewById(R.id.btnHLS);
    btnLeave = view.findViewById(R.id.btnLeave);

    tvMeetingId = view.findViewById(R.id.tvMeetingId);
    tvHlsState = view.findViewById(R.id.tvHlsState);

    if (meeting != null) {
        tvMeetingId.setText("Meeting Id : " + meeting.getMeetingId());
        //highlight-next-line
        setActionListeners();
    }
    return view;
  }

  private void setActionListeners() {
    btnMic.setOnClickListener(v -> {
        if (micEnabled) {
          //highlight-next-line
          meeting.muteMic();
          Toast.makeText(mContext,"Mic Muted",Toast.LENGTH_SHORT).show();
        } else {
          //highlight-next-line
          meeting.unmuteMic();
          Toast.makeText(mContext,"Mic Enabled",Toast.LENGTH_SHORT).show();
        }
        micEnabled=!micEnabled;
    });

    btnWebcam.setOnClickListener(v -> {
        if (webcamEnabled) {
          //highlight-next-line
          meeting.disableWebcam();
          Toast.makeText(mContext,"Webcam Disabled",Toast.LENGTH_SHORT).show();
        } else {
          //highlight-next-line
          meeting.enableWebcam();
          Toast.makeText(mContext,"Webcam Enabled",Toast.LENGTH_SHORT).show();
        }
        webcamEnabled=!webcamEnabled;
    });

    //highlight-next-line
    btnLeave.setOnClickListener(v -> meeting.leave());

    btnHls.setOnClickListener(v -> {
      if (!hlsEnabled) {
        //highlight-start
        JSONObject config = new JSONObject();
        JSONObject layout = new JSONObject();
        JsonUtils.jsonPut(layout, "type", "SPOTLIGHT");
        JsonUtils.jsonPut(layout, "priority", "PIN");
        JsonUtils.jsonPut(layout, "gridSize", 4);
        JsonUtils.jsonPut(config, "layout", layout);
        JsonUtils.jsonPut(config, "orientation", "portrait");
        JsonUtils.jsonPut(config, "theme", "DARK");
        JsonUtils.jsonPut(config, "quality", "high");
        meeting.startHls(config);
        //highlight-end
      } else {
        //highlight-next-line
        meeting.stopHls();
      }
    });
  }
}
```

</TabItem>

</Tabs>

4. After adding listners for buttons, let's add `MeetingEventListener` to the meeting and remove all listners in `onDestroy()` method.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js title="SpeakerFragment.kt"
class SpeakerFragment : Fragment() {

  override fun onCreateView(
      inflater: LayoutInflater, container: ViewGroup?,
      savedInstanceState: Bundle?
  ): View? {
    //...
    if (meeting != null) {
      //...
      //highlight-next-line
      // add Listener to the meeting
      meeting!!.addEventListener(meetingEventListener)
    }
    return view
  }

  private val meetingEventListener: MeetingEventListener = object : MeetingEventListener() {
      override fun onMeetingLeft() {
        //highlight-next-line
        // unpin the local participant
        meeting!!.localParticipant.unpin("SHARE_AND_CAM")
        if (isAdded) {
          val intents = Intent(mContext, JoinActivity::class.java)
          intents.addFlags(
              Intent.FLAG_ACTIVITY_NEW_TASK
                      or Intent.FLAG_ACTIVITY_CLEAR_TOP or Intent.FLAG_ACTIVITY_CLEAR_TASK
          )
          startActivity(intents)
          mActivity!!.finish()
        }
      }

      @RequiresApi(api = Build.VERSION_CODES.P)
      override fun onHlsStateChanged(HlsState: JSONObject) {
        if (HlsState.has("status")) {
          try {
              tvHlsState!!.text = "Current HLS State : " + HlsState.getString("status")
              //highlight-next-line
              if (HlsState.getString("status") == "HLS_STARTED") {
                hlsEnabled = true
                btnHls!!.text = "Stop HLS"
              }
              //highlight-next-line
              if (HlsState.getString("status") == "HLS_STOPPED") {
                hlsEnabled = false
                btnHls!!.text = "Start HLS"
              }
            } catch (e: JSONException) {
                e.printStackTrace()
            }
        }
      }
  }

  override fun onDestroy() {
      mContext = null
      mActivity = null
      if (meeting != null) {
          meeting!!.removeAllListeners()
          meeting = null
      }
      super.onDestroy()
  }
}
```

</TabItem>

<TabItem value="Java">

```java title="SpeakerFragment.java"
public class SpeakerFragment extends Fragment {

  @Override
  public View onCreateView(LayoutInflater inflater, ViewGroup container,
                            Bundle savedInstanceState) {
    //...
    if (meeting != null) {
        //...
        //highlight-next-line
        // add Listener to the meeting
        meeting.addEventListener(meetingEventListener);
    }
    return view;
  }

  private final MeetingEventListener meetingEventListener = new MeetingEventListener() {
    @Override
    public void onMeetingLeft() {
      //highlight-next-line
      //unpin local participant
      meeting.getLocalParticipant().unpin("SHARE_AND_CAM");
      if (isAdded()) {
        Intent intents = new Intent(mContext, JoinActivity.class);
        intents.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK
                | Intent.FLAG_ACTIVITY_CLEAR_TOP | Intent.FLAG_ACTIVITY_CLEAR_TASK);
        startActivity(intents);
        mActivity.finish();
      }
    }

    @RequiresApi(api = Build.VERSION_CODES.P)
    @Override
    public void onHlsStateChanged(JSONObject HlsState) {
        if (HlsState.has("status")) {
          try {
            tvHlsState.setText("Current HLS State : " + HlsState.getString("status"));
            //highlight-next-line
            if (HlsState.getString("status").equals("HLS_STARTED")) {
                hlsEnabled=true;
                btnHls.setText("Stop HLS");
            }
            //highlight-next-line
            if (HlsState.getString("status").equals("HLS_STOPPED")) {
                hlsEnabled = false;
                btnHls.setText("Start HLS");
            }
          } catch (JSONException e) {
              e.printStackTrace();
          }
        }
    }
  };

  @Override
  public void onDestroy() {
    mContext = null;
    mActivity = null;
    if (meeting != null) {
        meeting.removeAllListeners();
        meeting = null;
    }
    super.onDestroy();
  }

}
```

</TabItem>

</Tabs>

5. Next step is to render speaker's view. With `RecyclerView`, we will be display list of participant who joined the meeting as a `host`.

:::info

- Here the participant's video is displayed using `VideoView`, but you may also use `SurfaceViewRender` for the same.
- For `VideoView`, SDK version should be `0.1.13` or higher.
- To know more about `VideoView`, please visit [here](/android/guide/video-and-audio-calling-api-sdk/render-media/display-video/understand-videoView-component)

:::

- Create a new layout for the participant view named `item_remote_peer.xml` in the `res/layout` folder.

```xml title="item_remote_peer.xml"
<?xml version="1.0" encoding="utf-8"?>
<FrameLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="200dp"
    android:background="@color/cardview_dark_background"
    tools:layout_height="200dp">

    <live.videosdk.rtc.android.VideoView
        android:id="@+id/participantView"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:visibility="gone" />

    <LinearLayout
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:layout_gravity="bottom"
        android:background="#99000000"
        android:orientation="horizontal">

        <TextView
            android:id="@+id/tvName"
            android:layout_width="0dp"
            android:layout_height="wrap_content"
            android:layout_weight="1"
            android:gravity="center"
            android:padding="4dp"
            android:textColor="@color/white" />

    </LinearLayout>

</FrameLayout>
```

- Create a recycler view adapter named `SpeakerAdapter` which will show the participant list. Create `PeerViewHolder` in the adapter which will extend `RecyclerView.ViewHolder`.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js title="SpeakerAdapter.kt"
class SpeakerAdapter(private val meeting: Meeting) :
    RecyclerView.Adapter<SpeakerAdapter.PeerViewHolder?>() {
    private var participantList: MutableList<Participant> = ArrayList()

    init {
      updateParticipantList()
      //highlight-next-line
      // adding Meeting Event listener to get the participant join/leave event in the meeting.
      meeting.addEventListener(object : MeetingEventListener() {
        override fun onParticipantJoined(participant: Participant) {
          //highlight-next-line
          // check participant join as Host/Speaker or not
          if (participant.mode == "SEND_AND_RECV") {
              //highlight-next-line
              // pin the participant
              participant.pin("SHARE_AND_CAM")
              //highlight-next-line
              // add participant in participantList
              participantList.add(participant)
          }
          notifyDataSetChanged()
        }

        override fun onParticipantLeft(participant: Participant) {
          var pos = -1
          for (i in participantList.indices) {
              if (participantList[i].id == participant.id) {
                  pos = i
                  break
              }
          }
          if (participantList.contains(participant)) {
              //highlight-next-line
              // unpin participant who left the meeting
              participant.unpin("SHARE_AND_CAM")
              //highlight-next-line
              // remove participant from participantList
              participantList.remove(participant)
          }
          if (pos >= 0) {
              notifyItemRemoved(pos)
          }
        }
      })
    }

    private fun updateParticipantList() {
      //highlight-next-line
      // adding the local participant(You) to the list
      participantList.add(meeting.localParticipant)

      //highlight-next-line
      // adding participants who join as Host/Speaker
      val participants: Iterator<Participant> = meeting.participants.values.iterator()
      for (i in 0 until meeting.participants.size) {
        val participant = participants.next()
        if (participant.mode == "SEND_AND_RECV") {
            //highlight-next-line
            // pin the participant
            participant.pin("SHARE_AND_CAM")
            //highlight-next-line
            // add participant in participantList
            participantList.add(participant)
        }
      }
    }

    override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): PeerViewHolder {
      return PeerViewHolder(
          LayoutInflater.from(parent.context).inflate(R.layout.item_remote_peer, parent, false)
      )
    }

    override fun onBindViewHolder(holder: PeerViewHolder, position: Int) {
      val participant = participantList[position]
      holder.tvName.text = participant.displayName

      // adding the initial video stream for the participant into the 'VideoView'
      for ((_, stream) in participant.streams) {
        if (stream.kind.equals("video", ignoreCase = true)) {
          holder.participantView.visibility = View.VISIBLE
          val videoTrack = stream.track as VideoTrack
          //highlight-next-line
          holder.participantView.addTrack(videoTrack)
          break
        }
      }

      // add Listener to the participant which will update start or stop the video stream of that participant
      participant.addEventListener(object : ParticipantEventListener() {
        override fun onStreamEnabled(stream: Stream) {
          if (stream.kind.equals("video", ignoreCase = true)) {
            holder.participantView.visibility = View.VISIBLE
            val videoTrack = stream.track as VideoTrack
            //highlight-next-line
            holder.participantView.addTrack(videoTrack)
          }
        }

        override fun onStreamDisabled(stream: Stream) {
          if (stream.kind.equals("video", ignoreCase = true)) {
            //highlight-next-line
            holder.participantView.removeTrack()
            holder.participantView.visibility = View.GONE
          }
        }
      })
    }

    override fun getItemCount(): Int {
      //highlight-next-line
      return participantList.size
    }

    class PeerViewHolder(view: View) : RecyclerView.ViewHolder(view) {
      // 'VideoView' to show Video Stream
      var participantView: VideoView
      var tvName: TextView

      init {
        tvName = view.findViewById(R.id.tvName)
        participantView = view.findViewById(R.id.participantView)
      }
    }
}
```

</TabItem>

<TabItem value="Java">

```java title="SpeakerAdapter.java"
public class SpeakerAdapter extends RecyclerView.Adapter<SpeakerAdapter.PeerViewHolder> {
  private List<Participant> participantList = new ArrayList<>();
  private final Meeting meeting;
  public SpeakerAdapter(Meeting meeting) {
    this.meeting = meeting;

    updateParticipantList();

    //highlight-next-line
    // adding Meeting Event listener to get the participant join/leave event in the meeting.
    meeting.addEventListener(new MeetingEventListener() {
      @Override
      public void onParticipantJoined(Participant participant) {
        //highlight-next-line
        // check participant join as Host/Speaker or not
        if (participant.getMode().equals("SEND_AND_RECV")) {
          //highlight-next-line
          // pin the participant
          participant.pin("SHARE_AND_CAM");
          //highlight-next-line
          // add participant in participantList
          participantList.add(participant);
        }
        notifyDataSetChanged();
      }

      @Override
      public void onParticipantLeft(Participant participant) {
        int pos = -1;
        for (int i = 0; i < participantList.size(); i++) {
          if (participantList.get(i).getId().equals(participant.getId())) {
            pos = i;
            break;
          }
        }
        if(participantList.contains(participant)) {
          //highlight-next-line
          // unpin participant who left the meeting
          participant.unpin("SHARE_AND_CAM");
          //highlight-next-line
          // remove participant from the list
          participantList.remove(participant);
        }
        if (pos >= 0) {
            notifyItemRemoved(pos);
        }
      }
    });
  }

  private void updateParticipantList() {
    participantList = new ArrayList<>();

    //highlight-next-line
    // adding the local participant(You) to the list
    participantList.add(meeting.getLocalParticipant());

    //highlight-next-line
    // adding participants who join as Host/Speaker
    Iterator<Participant> participants = meeting.getParticipants().values().iterator();
    for (int i = 0; i < meeting.getParticipants().size(); i++) {
      final Participant participant = participants.next();
      if (participant.getMode().equals("SEND_AND_RECV")) {
        //highlight-next-line
        // pin the participant
        participant.pin("SHARE_AND_CAM");
        //highlight-next-line
        // add participant in participantList
        participantList.add(participant);
      }
    }
  }

  @NonNull
  @Override
  public PeerViewHolder onCreateViewHolder(@NonNull ViewGroup parent, int viewType) {
    return new PeerViewHolder(LayoutInflater.from(parent.getContext()).inflate(R.layout.item_remote_peer, parent, false));
  }

  @Override
  public void onBindViewHolder(@NonNull PeerViewHolder holder, int position) {
    Participant participant = participantList.get(position);

    holder.tvName.setText(participant.getDisplayName());

    // adding the initial video stream for the participant into the 'VideoView'
    for (Map.Entry<String, Stream> entry : participant.getStreams().entrySet()) {
      Stream stream = entry.getValue();
      if (stream.getKind().equalsIgnoreCase("video")) {
        holder.participantView.setVisibility(View.VISIBLE);
        VideoTrack videoTrack = (VideoTrack) stream.getTrack();
        //highlight-next-line
        holder.participantView.addTrack(videoTrack);
        break;
      }
    }

    // add Listener to the participant which will update start or stop the video stream of that participant
    participant.addEventListener(new ParticipantEventListener() {
        @Override
        public void onStreamEnabled(Stream stream) {
          if (stream.getKind().equalsIgnoreCase("video")) {
            holder.participantView.setVisibility(View.VISIBLE);
            VideoTrack videoTrack = (VideoTrack) stream.getTrack();
            //highlight-next-line
            holder.participantView.addTrack(videoTrack);
          }
        }

        @Override
        public void onStreamDisabled(Stream stream) {
          if (stream.getKind().equalsIgnoreCase("video")) {
            //highlight-next-line
            holder.participantView.removeTrack();
            holder.participantView.setVisibility(View.GONE);
          }
        }
    });
  }

  @Override
  public int getItemCount() {
    //highlight-next-line
    return participantList.size();
  }

  static class PeerViewHolder extends RecyclerView.ViewHolder {
    // 'VideoView' to show Video Stream
    public VideoView participantView;
    public TextView tvName;
    public View itemView;

    PeerViewHolder(@NonNull View view) {
        super(view);
        itemView = view;
        tvName = view.findViewById(R.id.tvName);
        participantView = view.findViewById(R.id.participantView);
    }
  }
}
```

</TabItem>

</Tabs>

6. Add this adapter to the `SpeakerFragment`

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js title="SpeakerFragment.kt"
 override fun onCreateView(
      inflater: LayoutInflater, container: ViewGroup?,
      savedInstanceState: Bundle?
  ): View? {
    //...
    if (meeting != null) {
      //...
      val rvParticipants = view.findViewById<RecyclerView>(R.id.rvParticipants)
      rvParticipants.layoutManager = GridLayoutManager(mContext, 2)
      rvParticipants.adapter = SpeakerAdapter(meeting!!)
  }
}
```

</TabItem>

<TabItem value="Java">

```java title="SpeakerFragment.java"
 @Override
  public View onCreateView(LayoutInflater inflater, ViewGroup container,
                            Bundle savedInstanceState) {
    //...
    if (meeting != null) {
      //...
      final RecyclerView rvParticipants = view.findViewById(R.id.rvParticipants);
      rvParticipants.setLayoutManager(new GridLayoutManager(mContext, 2));
      rvParticipants.setAdapter(new SpeakerAdapter(meeting));
    }
}
```

</TabItem>

</Tabs>

#### Output

<center>

<img style={{height: '450px'}} src="https://cdn.videosdk.live/website-resources/docs-resources/android_ils_quickstart_speaker_screen.jpg" />

</center>

### Step 4: Implement ViewerView

When host start the live streaming, viewer will be able to see the live streaming.

To implement player view, we are going to use `ExoPlayer`. It will be helpful to play hls stream.

Let's first add dependency into the project.

```js title="app/build.gradle"
dependencies {
  implementation 'com.google.android.exoplayer:exoplayer:2.18.5'
  // other app dependencies
  }
```

Create a new Fragment named `ViewerFragment`

#### Creating UI

The Viewer Fragment will include :

1. **TextView for Meeting Id** - The meeting Id that you joined will be displayed in this text view.
2. **Leave Button** - This button will leave the meeting.
3. **waitingLayout** - This is textView that will be shown when there is no active HLS.
4. **StyledPlayerView** - This is mediaplayer which will display livestreaming.

In `/app/res/layout/fragment_viewer.xml` file, replace the content with the following.

```xml title="fragment_viewer.xml"
<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:background="@color/black"
    tools:context=".ViewerFragment">

    <LinearLayout
        android:id="@+id/meetingLayout"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:paddingHorizontal="12sp"
        android:paddingVertical="5sp">

        <TextView
            android:id="@+id/meetingId"
            android:layout_width="0dp"
            android:layout_height="wrap_content"
            android:layout_weight="3"
            android:text="Meeting Id : "
            android:textColor="@color/white"
            android:textSize="20sp" />

        <Button
            android:id="@+id/btnLeave"
            android:layout_width="0dp"
            android:layout_height="wrap_content"
            android:layout_weight="1"
            android:text="Leave" />

    </LinearLayout>

    <TextView
        android:id="@+id/waitingLayout"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:text="Waiting for host \n to start the live streaming"
        android:textColor="@color/white"
        android:textFontWeight="700"
        android:textSize="20sp"
        android:gravity="center"/>

    <com.google.android.exoplayer2.ui.StyledPlayerView
        android:id="@+id/player_view"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:visibility="gone"
        app:resize_mode="fixed_width"
        app:show_buffering="when_playing"
        app:show_subtitle_button="false"
        app:use_artwork="false"
        app:show_next_button="false"
        app:show_previous_button="false"
        app:use_controller="true"
        android:layout_below="@id/meetingLayout"/>

</RelativeLayout>
```

#### Initialize player and Playing HLS stream

1. Initialize player and play the HLS when the meeting HLS state is `HLS_PLAYABLE`, and release it when the HLS state is `HLS_STOPPED`. Whenever the meeting HLS state changes, the event `onHlsStateChanged` will be triggered.

- when you receive `HLS_PLAYABLE` status you will receive 2 urls
  - `playbackHlsUrl` - Live HLS with playback support
  - `livestreamUrl` - Live HLS without playback support

:::note
`downstreamUrl` is now depecated. Use `playbackHlsUrl` or `livestreamUrl` in place of `downstreamUrl`
:::

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js title="ViewerFragment.kt"
class ViewerFragment : Fragment() {
  private var meeting: Meeting? = null
  private var playerView: StyledPlayerView? = null
  private var waitingLayout: TextView? = null
  private var player: ExoPlayer? = null
  private var dataSourceFactory: DefaultHttpDataSource.Factory? = null
  private val startAutoPlay = true
  private var playbackHlsUrl: String? = ""


  override fun onCreateView(
    inflater: LayoutInflater, container: ViewGroup?,
    savedInstanceState: Bundle?
  ): View? {
    // Inflate the layout for this fragment
    val view = inflater.inflate(R.layout.fragment_viewer, container, false)
    playerView = view.findViewById(R.id.player_view)
    waitingLayout = view.findViewById(R.id.waitingLayout)
    if (meeting != null) {
        //highlight-next-line
        // set MeetingId to TextView
        (view.findViewById<View>(R.id.meetingId) as TextView).text =
            "Meeting Id : " + meeting!!.meetingId
        //highlight-next-line
        // leave the meeting on btnLeave click
        (view.findViewById<View>(R.id.btnLeave) as Button).setOnClickListener { meeting!!.leave() }
        //highlight-next-line
        // add listener to meeting
        meeting!!.addEventListener(meetingEventListener)
    }
    return view
  }

  override fun onAttach(context: Context) {
      super.onAttach(context)
      mContext = context
      if (context is Activity) {
        mActivity = context
        //highlight-next-line
        // get meeting object from MeetingActivity
        meeting = (mActivity as MeetingActivity?)!!.meeting
      }
  }

  private val meetingEventListener: MeetingEventListener = object : MeetingEventListener() {
      override fun onMeetingLeft() {
        if (isAdded) {
          val intents = Intent(mContext, JoinActivity::class.java)
          intents.addFlags(
              Intent.FLAG_ACTIVITY_NEW_TASK
                      or Intent.FLAG_ACTIVITY_CLEAR_TOP or Intent.FLAG_ACTIVITY_CLEAR_TASK
          )
          startActivity(intents)
          mActivity!!.finish()
        }
      }

      //highlight-start
      @RequiresApi(api = Build.VERSION_CODES.P)
      override fun onHlsStateChanged(HlsState: JSONObject) {
        if (HlsState.has("status")) {
            try {
              if (HlsState.getString("status") == "HLS_PLAYABLE" && HlsState.has("playbackHlsUrl")) {
                playbackHlsUrl = HlsState.getString("playbackHlsUrl")
                waitingLayout!!.visibility = View.GONE
                playerView!!.visibility = View.VISIBLE
                // initialize player
                initializePlayer()
              }
              if (HlsState.getString("status") == "HLS_STOPPED") {
                // release the player
                releasePlayer()
                playbackHlsUrl = null
                waitingLayout!!.text = "Host has stopped \n the live streaming"
                waitingLayout!!.visibility = View.VISIBLE
                playerView!!.visibility = View.GONE
              }
            } catch (e: JSONException) {
                e.printStackTrace()
            }
          }
      }
      //highlight-end
  }

  private fun initializePlayer() {
    if (player == null) {
      dataSourceFactory = DefaultHttpDataSource.Factory()
      val mediaSource = HlsMediaSource.Factory(dataSourceFactory!!).createMediaSource(
          MediaItem.fromUri(Uri.parse(playbackHlsUrl))
      )
      val playerBuilder = ExoPlayer.Builder( /* context = */mContext!!)
      player = playerBuilder.build()
      // auto play when player is ready
      player!!.playWhenReady = startAutoPlay
      player!!.setMediaSource(mediaSource)
      // if you want display setting for player then remove this line
      playerView!!.findViewById<View>(com.google.android.exoplayer2.ui.R.id.exo_settings).visibility =
          View.GONE
      playerView!!.player = player
    }
    player!!.prepare()
  }

  private fun releasePlayer() {
    if (player != null) {
      player!!.release()
      player = null
      dataSourceFactory = null
      playerView!!.player = null
    }
  }

  override fun onDestroy() {
    mContext = null
    mActivity = null
    playbackHlsUrl = null
    releasePlayer()
    if (meeting != null) {
        meeting!!.removeAllListeners()
        meeting = null
    }
    super.onDestroy()
  }

  companion object {
    private var mActivity: Activity? = null
    private var mContext: Context? = null
  }
}
```

</TabItem>

<TabItem value="Java">

```java title="ViewerFragment.java"
public class ViewerFragment extends Fragment {

  private Meeting meeting;
  protected StyledPlayerView playerView;
  private TextView waitingLayout;
  protected @Nullable
  ExoPlayer player;

  private DefaultHttpDataSource.Factory dataSourceFactory;
  private boolean startAutoPlay=true;
  private String playbackHlsUrl = "";
  private static Activity mActivity;
  private static Context mContext;

  public ViewerFragment() {
      // Required empty public constructor
  }

  @Override
  public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
  }

  @Override
  public View onCreateView(LayoutInflater inflater, ViewGroup container,
                            Bundle savedInstanceState) {
    // Inflate the layout for this fragment
    View view = inflater.inflate(R.layout.fragment_viewer, container, false);

    playerView = view.findViewById(R.id.player_view);

    waitingLayout = view.findViewById(R.id.waitingLayout);
    if(meeting != null) {
      //highlight-next-line
      // set MeetingId to TextView
      ((TextView) view.findViewById(R.id.meetingId)).setText("Meeting Id : " + meeting.getMeetingId());
      //highlight-next-line
      // leave the meeting on btnLeave click
      ((Button) view.findViewById(R.id.btnLeave)).setOnClickListener(v -> meeting.leave());
      //highlight-next-line
      // add listener to meeting
      meeting.addEventListener(meetingEventListener);
    }
    return view;
  }


  @Override
  public void onAttach(@NonNull Context context) {
    super.onAttach(context);
    mContext = context;
    if (context instanceof Activity) {
      mActivity = (Activity) context;
      //highlight-next-line
      // get meeting object from MeetingActivity
      meeting = ((MeetingActivity) mActivity).getMeeting();
    }
  }

  private final MeetingEventListener meetingEventListener = new MeetingEventListener() {

      @Override
      public void onMeetingLeft() {
        if (isAdded()) {
          Intent intents = new Intent(mContext, JoinActivity.class);
          intents.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK
                  | Intent.FLAG_ACTIVITY_CLEAR_TOP | Intent.FLAG_ACTIVITY_CLEAR_TASK);
          startActivity(intents);
          mActivity.finish();
        }
      }

      //highlight-start
      @RequiresApi(api = Build.VERSION_CODES.P)
      @Override
      public void onHlsStateChanged(JSONObject HlsState) {
        if (HlsState.has("status")) {
          try {
            if (HlsState.getString("status").equals("HLS_PLAYABLE") && HlsState.has("playbackHlsUrl")) {
              playbackHlsUrl = HlsState.getString("playbackHlsUrl");
              waitingLayout.setVisibility(View.GONE);
              playerView.setVisibility(View.VISIBLE);
              // initialize player
              initializePlayer();
            }
            if (HlsState.getString("status").equals("HLS_STOPPED")) {
              // release the player
              releasePlayer();
              playbackHlsUrl = null;
              waitingLayout.setText("Host has stopped \n the live streaming");
              waitingLayout.setVisibility(View.VISIBLE);
              playerView.setVisibility(View.GONE);
            }
          } catch (JSONException e) {
              e.printStackTrace();
          }
        }
    }
    //highlight-end
  };

  protected void initializePlayer() {
    if (player == null) {
      dataSourceFactory = new DefaultHttpDataSource.Factory();
      HlsMediaSource mediaSource = new HlsMediaSource.Factory(dataSourceFactory).createMediaSource(
              MediaItem.fromUri(Uri.parse(this.playbackHlsUrl)));
      ExoPlayer.Builder playerBuilder =
              new ExoPlayer.Builder(/* context= */ mContext);
      player = playerBuilder.build();
      // auto play when player is ready
      player.setPlayWhenReady(startAutoPlay);
      player.setMediaSource(mediaSource);
      // if you want display setting for player then remove this line
      playerView.findViewById(com.google.android.exoplayer2.ui.R.id.exo_settings).setVisibility(View.GONE);
      playerView.setPlayer(player);
    }
    player.prepare();
  }

  protected void releasePlayer() {
    if (player != null) {
      player.release();
      player = null;
      dataSourceFactory = null;
      playerView.setPlayer(/* player= */ null);
    }
  }

  @Override
  public void onDestroy() {
    mContext = null;
    mActivity = null;
    playbackHlsUrl = null;
    releasePlayer();
    if (meeting != null) {
      meeting.removeAllListeners();
      meeting = null;
    }
    super.onDestroy();
  }

}
```

</TabItem>

</Tabs>

#### Output

<center>

<img style={{height: '450px',marginRight:'15px'}} src="https://cdn.videosdk.live/website-resources/docs-resources/android_ils_quickstart_viewer_screen_waiting.jpg" />

<img style={{height: '450px'}} src="https://cdn.videosdk.live/website-resources/docs-resources/android_ils_quickstart_viewer_screen.jpg" />

</center>

<br/>

## Final Output

We are done with implementation of customised video calling app in Android using Video SDK. To explore more features go through Basic and Advanced features.

import ReactPlayer from 'react-player'

<div style={{textAlign: 'center'}}>

<ReactPlayer muted controls url="https://cdn.videosdk.live/website-resources/docs-resources/android_ils_quickstart.mp4" height="500px" width={"100%"} />

</div>

<br/>

:::tip
You can checkout the complete [quick start example here](https://github.com/videosdk-live/quickstart/tree/main/android-hls).
:::


---

---
title: Quick Start With Interactive Live Streaming | VideoSDK Android
hide_title: true
hide_table_of_contents: false
description: Learn how to quickly integrate interactive live streaming features using VideoSDK's Android SDK. Step-by-step guide for implementing real-time video & audio streaming in mobile applications with code examples.
sidebar_label: Start With Interactive Live Streaming
pagination_label: Start With Interactive Live Streaming
keywords:
  - android sdk
  - live streaming api
  - webrtc streaming
  - interactive livestream
  - video streaming
  - audio streaming
  - real-time communication
  - video conferencing
  - streaming tutorial
  - web sdk
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: quick-start-android-ils
---

import CautionMessage from '@site/src/theme/CautionMessage';

# Quick Start for Interactive Live Streaming in Android

**VideoSDK** empowers you to seamlessly integrate **interactive live streaming** features into your Android application in minutes. While built for meetings, the SDK is easily adaptable for live streaming with support for up to **100 hosts/co-hosts** and **2,000 viewers** in **real-time**. Perfect for social use cases, this guide will walk you through integrating live streaming into your app.

:::info

For standard live streaming with 6-7 second latency and playback support, follow this [documentation](./quick-start-ILS.md).
:::

## Prerequisites

Before proceeding, ensure that your development environment meets the following requirements:

- Android Studio Arctic Fox (2020.3.1) or later.
- Android SDK API Level 21 or higher.
- A mobile device that runs Android 5.0 or later.

## Getting Started with the Code!

Follow the steps to create the environment necessary to add video calls into your app. Also you can find the code sample for [quickstart here](https://github.com/videosdk-live/quickstart/tree/main/interactive-live-streaming/android-ils).

<CautionMessage sdk="Android SDK" version="v0.2.0" />

### Create new Android Project

For a new project in **Android Studio**, create a **Phone and Tablet** Android project with an **Empty Activity**.

![VideoSDK Android Quick Start New Project](https://cdn.videosdk.live/docs/images/android/quickstart/android_compose_newProject.jpg)

:::caution
After creating the project, Android Studio automatically starts gradle sync. Ensure that the sync succeeds before you continue.
:::

### Integrate Video SDK

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Maven Central"
groupId={"android-repositories"}
values={[{label: 'Maven Central', value: 'Maven Central'},{label: 'Jitpack', value: 'Jitpack'},]}>

<TabItem value="Maven Central">

```js title="settings.gradle"
dependencyResolutionManagement {
    repositories {
    google()
    mavenCentral()
    maven {url= uri("https://maven.aliyun.com/repository/jcenter")}
  }
}
```

</TabItem>

<TabItem value="Jitpack">

```js title="settings.gradle"
dependencyResolutionManagement{
  repositories {
    google()
    maven { url = uri("https://www.jitpack.io") }
    mavenCentral()
    maven {url= uri("https://maven.aliyun.com/repository/jcenter")}
  }
}
```

</TabItem>

</Tabs>

:::note

You can use imports with Maven Central after rtc-android-sdk version `0.1.12`.

Whether on Maven or Jitpack, the same version numbers always refer to the same SDK.

:::

- Add the following dependency in your app's `app/build.gradle`.

```js title="app/build.gradle"
dependencies {
  implementation ("live.videosdk:rtc-android-sdk:0.1.38")

  // library to perform Network call to generate a stream id
  implementation ("com.amitshekhar.android:android-networking:1.0.2")

  // other app dependencies
  }
```

:::important

Android SDK compatible with armeabi-v7a, arm64-v8a, x86_64 architectures. If you want to run the application in an emulator, choose ABI x86_64 when creating a device.

:::

### Add permissions into your project

- In `/app/Manifests/AndroidManifest.xml`, add the following permissions.

```xml title="AndroidManifest.xml"
<uses-feature android:name="android.hardware.camera" android:required="false" />
<uses-permission android:name="android.permission.INTERNET"/>
<uses-permission android:name="android.permission.CAMERA"/>
<uses-permission android:name="android.permission.RECORD_AUDIO"/>
<uses-permission android:name="android.permission.MODIFY_AUDIO_SETTINGS"/>
```

:::note

If your project has set `android.useAndroidX=true`, then set `android.enableJetifier=true` in the `gradle.properties` file to migrate your project to AndroidX and avoid duplicate class conflict.

:::

### Structure of the project

Your project structure should look like this.

```jsx title="Project Structure"
app/
├── src/main/
│   ├── java/com/example/app/
│   │   ├── components/
│   │   ├── screens/
│   │   ├── ui/
│   │   │   └── theme/
│   │   ├── model/
│   │   ├── MainApplication.kt
│   │   ├── MainActivity.kt
│   │   └── NetworkClass.kt
|   |   └── StreamingMode.kt
│   ├── res/
│   └── AndroidManifest.xml
├── build.gradle
└── settings.gradle
```

### App Architecture

<center>

<img src='https://cdn.videosdk.live/website-resources/docs-resources/ils_qs_android_app_ architecture.png' />

</center>

### Step 1: Initialize VideoSDK

1. Create `MainApplication` class which will extend the `android.app.Application`.

- Create field `sampleToken` in `MainApplication` which will hold the generated token from the [VideoSDK dashboard](https://app.videosdk.live/api-keys). This token will use in VideoSDK config as well as generating meetingId.

```js title="MainApplication.kt"
import android.app.Application
import live.videosdk.rtc.android.VideoSDK

class MainApplication: Application() {

    val sampleToken = "YOUR_TOKEN" //paste your token here

    override fun onCreate() {
        super.onCreate()
        VideoSDK.initialize(applicationContext)
    }
}
```

2. Add `MainApplication` to `AndroidManifest.xml`

```xml title="AndroidManifest.xml"
<application
    android:name=".MainApplication"
   <!-- ... -->
</application>
```

### Step 2: Managing Permissions and Setting Up Navigation

The `MainActivity` handles permission requests for the camera and microphone and sets up navigation using Jetpack Compose.

Upon creation, it checks for required permissions (RECORD_AUDIO and CAMERA). If not granted, it requests them. Once permissions are granted, the MyApp composable is initialized, which contains the navigation logic through the NavigationGraph.

The NavigationGraph defines two screens:

- JoinScreen: For joining or create stream.
- StreamingScreen: For participating in a stream, passing meetingId and mode as arguments.

```js title="MainActivity.kt"
class MainActivity : ComponentActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        checkSelfPermission(REQUESTED_PERMISSIONS[0], PERMISSION_REQ_ID)
        checkSelfPermission(REQUESTED_PERMISSIONS[1], PERMISSION_REQ_ID)

        setContent {
            Videosdk_android_modes_quickstartTheme {
                MyApp(this) } }
    }

    private fun checkSelfPermission(permission: String, requestCode: Int): Boolean {
        if (ContextCompat.checkSelfPermission(this, permission) != PackageManager.PERMISSION_GRANTED) {
            ActivityCompat.requestPermissions(this, REQUESTED_PERMISSIONS, requestCode)
            return false
        }
        return true
    }

    companion object {
        private const val PERMISSION_REQ_ID = 22
        private val REQUESTED_PERMISSIONS = arrayOf(Manifest.permission.RECORD_AUDIO, Manifest.permission.CAMERA)
    }
}

@Composable
fun MyApp(context: Context) {
    NavigationGraph(context = context)
}

@Composable
fun NavigationGraph(navController: NavHostController = rememberNavController(), context: Context) {
    NavHost(navController = navController, startDestination = "join_screen") {
        composable("join_screen") { JoinScreen(navController, context) }
        composable("stream_screen?streamId={streamId}&mode={mode}") { backStackEntry ->
            val streamId = backStackEntry.arguments?.getString("streamId")
            val modeStr = backStackEntry.arguments?.getString("mode")
            val mode = StreamingMode.valueOf(modeStr ?: StreamingMode.SendAndReceive.name)

            streamId?.let {
                StreamingScreen(viewModel = StreamViewModel(), navController, streamId, mode, context)
            }
        }
    }
}
```

### Step 3: Creating Reusable Components

- Before building the individual screens, it's essential to develop reusable composable components that will be used throughout the project.

1. Create a `ReusableComponents.kt` file to organize all reusable components for the project, such as buttons, spacers, and customizable text.

```js title="ReusableComponents.kt"
@Composable
fun MyAppButton(task: () -> Unit, buttonName: String) {
    Button(onClick = task) {
        Text(text = buttonName) }
}

@Composable
fun MySpacer() {
    Spacer(modifier = Modifier.fillMaxWidth()
            .height(1.dp)
            .background(color = Color.Gray)) }

@Composable
fun MyText(text: String, fontSize: TextUnit = 23.sp) {
    Text(text = text,
        fontSize = fontSize,
        fontWeight = FontWeight.Normal,
        modifier = Modifier.padding(4.dp),
        style = MaterialTheme.typography.bodyMedium.copy(fontSize = 16.sp),
        color = MaterialTheme.colorScheme.onSurface.copy(alpha = 0.7f))
}
```

2. Create a `ParticipantVideoView.kt` file that includes two composable functions: `ParticipantVideoView` for rendering individual participant video streams, and `ParticipantsGrid` for displaying a grid of participant videos.

:::info

- Here the participant's video is displayed using `VideoView`. To know more about `VideoView`, please visit [here](/android/guide/video-and-audio-calling-api-sdk/render-media/display-video/understand-videoView-component)
- `VideoView` is a custom View. Since Jetpack Compose does not natively support traditional `View` objects, we need to integrate the `VideoView` into the Compose layout using the `AndroidView` wrapper.
- `AndroidView()` is a composable that can be used to add Android views inside a @Composable function.

:::

```js title="ParticipantVideoView.kt"
@Composable
fun ParticipantVideoView(
    participant: Participant
) {
        var isVideoEnabled by remember { mutableStateOf(false) }
        // Remember the event listener to prevent recreation on each recomposition
        val eventListener = remember(participant) {
            object : ParticipantEventListener() {
                override fun onStreamEnabled(stream: Stream) {
                    if (stream.kind.equals("video", ignoreCase = true)) {
                        val videoTrack = stream.track as VideoTrack
                        isVideoEnabled = true
                    }
                }
                override fun onStreamDisabled(stream: Stream) {
                    if (stream.kind.equals("video", ignoreCase = true)) {
                        isVideoEnabled = false
                    }
                }
            }
        }

        // Add and remove the event listener using side effects
        DisposableEffect(participant, eventListener) {
            participant.addEventListener(eventListener)
            onDispose { participant.removeEventListener(eventListener) }
        }

        // Initial video state check
        LaunchedEffect(participant) {
            val hasVideoStream = participant.streams.any { (_, stream) ->
                stream.kind.equals("video", ignoreCase = true) && stream.track != null
            }
            isVideoEnabled = hasVideoStream
        }

        Box(
            modifier = Modifier.fillMaxWidth()
                .height(200.dp)
                .background(if (isVideoEnabled) Color.DarkGray else Color.Gray)
        ) {
            AndroidView(
                factory = { context ->
                    VideoView(context).apply {
                        for ((_, stream) in participant.streams) {
                            if (stream.kind.equals("video", ignoreCase = true)) {
                                val videoTrack = stream.track as VideoTrack
                                addTrack(videoTrack)
                                isVideoEnabled = true
                            }
                        }
                    }
                },
                update = { videoView ->
                    // Handle video track updates only
                    // The event listener is now managed separately
                    for ((_, stream) in participant.streams) {
                        if (stream.kind.equals(
                                "video",
                                ignoreCase = true
                            ) && stream.track != null
                        ) {
                            val videoTrack = stream.track as VideoTrack
                            videoView.addTrack(videoTrack)
                        }
                    }
                },
                modifier = Modifier.fillMaxSize()
            )

            if (!isVideoEnabled) {
                Box(
                    modifier = Modifier.fillMaxSize()
                        .background(Color.DarkGray),
                    contentAlignment = Alignment.Center
                ) {
                    Text(text = "Camera Off", color = Color.White)
                }
            }

            Box(
                modifier = Modifier.align(Alignment.BottomCenter)
                    .fillMaxWidth()
                    .background(Color(0x99000000))
                    .padding(4.dp)
            ) {
                Text(
                    text = participant.displayName,
                    color = Color.White,
                    modifier = Modifier.align(Alignment.Center)
                )
            }
        }
}

@Composable
fun ParticipantsGrid(
    participants: List<Participant>,
    modifier: Modifier = Modifier
) {
    LazyVerticalGrid(columns = GridCells.Fixed(2),
        verticalArrangement = Arrangement.spacedBy(16.dp),
        horizontalArrangement = Arrangement.spacedBy(16.dp),
        modifier = modifier.fillMaxWidth()
            .padding(8.dp)
    ) {
        items(participants.size) { index ->
            ParticipantVideoView(participant = participants[index])
        }
    }
}
```

Before proceeding, let's understand the two modes of a Live Stream:

<div style={{textAlign: 'center'}}>
<img
  src="https://cdn.videosdk.live/website-resources/docs-resources/ils_mode_demonstration-compressed.jpg"
  alt="ILS Mode Demonstration"
  width="550"
  height="450"
/>
</div>

1. SEND_AND_RECV:

- Designed primarily for the Host or Co-host.
- Allows sending and receiving media.
- Hosts can broadcast their audio/video and interact directly with the audience.

2. RECV_ONLY:

- Tailored for the Audience.
- Enables receiving media shared by the Host.
- Audience members can view and listen but cannot share their own media.

```js title="StreamingMode"
enum class StreamingMode {
    SendAndReceive,
    ReceiveOnly
}
```

### Step 4: Creating Joining Screen

Join screen will serve as a medium to either Create a new Live Stream or join an existing one as a host or a audience.

We will create a simple UI for the Join screen that includes three action buttons for joining or creating a Live Stream:

1. **`Create Stream`**: Lets the user initiate a new Live Stream in SEND_AND_RECV mode, granting full host controls.
2. **`Join as Host`**: Allows the user to join an existing Live Stream using the provided meetingId with the SEND_AND_RECV mode, enabling full host privileges.
3. **`Join as Audience`**: Enables the user to join an existing Live Stream using the provided meetingId with the RECV_ONLY mode, allowing view-only access.

```js title="JoinScreen.kt"
@Composable
fun JoinScreen(
    navController: NavController, context: Context
) {
    val app = context.applicationContext as MainApplication
    val token = app.sampleToken
    Box(
        modifier = Modifier.fillMaxSize()
            .padding(8.dp),
        contentAlignment = Alignment.Center
    ) {
        Column(
            modifier = Modifier.padding(4.dp),
            horizontalAlignment = Alignment.CenterHorizontally,
            verticalArrangement = Arrangement.SpaceEvenly
        ) {
            var input by rememberSaveable { mutableStateOf("") }
            CreateStreamBtn(navController, token)
            Text(text = "OR")
            InputMeetingId(input) { updateInput -> input = updateInput }
            JoinHostBtn(navController, input)
            JoinAudienceBtn(navController, input)
        }
    }
}


@Composable
fun JoinHostBtn(navController: NavController, streamId: String) {
    MyAppButton({
        if (streamId.isNotEmpty()) {
            navController.navigate("stream_screen?streamId=$streamId&mode=${StreamingMode.SendAndReceive.name}")
        }
    }, "Join as Host")
}

@Composable
fun JoinAudienceBtn(navController: NavController, streamId: String) {
    MyAppButton({
        if (streamId.isNotEmpty()) {
            navController.navigate("stream_screen?streamId=$streamId&mode=${StreamingMode.ReceiveOnly.name}")
        }
    }, "Join as Audience")
}

@Composable
fun CreateStreamBtn(navController: NavController, token: String) {
    MyAppButton({
        NetworkManager.createStreamId(token) { streamId ->
            navController.navigate("stream_screen?streamId=$streamId&mode=${StreamingMode.SendAndReceive.name}")
        }
    }, "Create Stream")
}

@Composable
fun InputMeetingId(input: String, onInputChange: (String) -> Unit) {
    OutlinedTextField(value = input,
        onValueChange = onInputChange,
        label = { Text(text = "Enter Stream Id") })
}
```

#### Output

<div style={{ textAlign: 'center' }}>
    <img 
        src='https://cdn.videosdk.live/website-resources/docs-resources/ils_qs_android_join_screen.png' 
        alt="VideoSDK Android Quick Start joining Screen" 
         style={{height: '450px'}}
    />
</div>

### Step 5: Creating StreamId

The `NetworkManager` singleton handles stream creation by making a POST request to the [VideoSDK API](https://docs.videosdk.live/api-reference/realtime-communication/create-room):

- stream Creation: Sends a request to the API with an authorization token to create a stream.
- Response Handling: Extracts the roomId from the response and triggers the `onMeetingCreated` callback.

```js title="NetworkManager"
object NetworkManager {
    fun createStreamId(token: String, onStreamIdCreated: (String) -> Unit) {
        AndroidNetworking.post("https://dev-api.videosdk.live/v2/rooms")
            .addHeaders("Authorization", token)
            .build()
            .getAsJSONObject(object : JSONObjectRequestListener {
                override fun onResponse(response: JSONObject) {
                    try {
                        val streamId = response.getString("roomId")
                        onStreamIdCreated(streamId)
                    } catch (e: JSONException) {
                        e.printStackTrace()
                    }
                }
                override fun onError(anError: ANError) {
                    anError.printStackTrace()
                    Log.d("TAG", "onError: $anError")
                }
            })
    }
}
```

:::note

Don't confuse with Room and stream keyword, both are same thing 😃

:::

### Step 6: Creating Streaming Screen

We will create a simple Streaming screen UI with two main sections:

1. `Header`: Displays the stream ID and current streaming mode at the top of the screen for reference.
2. `ParticipantsGrid`: Shows the list of participants in a grid layout, adjusting dynamically.

:::note

In Step 3, we created the ParticipantsGrid component.

:::

```js title="StreamingScreen.kt"
@Composable
fun StreamingScreen(viewModel: StreamViewModel, navController: NavController,
    streamId: String,
    mode: StreamingMode,
    context: Context
) {
    val app = context.applicationContext as MainApplication
    val isStreamLeft = viewModel.isStreamLeft
    val currentMode = viewModel.currentMode
    val isJoined = viewModel.isJoined

    LaunchedEffect(isStreamLeft) {
        if (isStreamLeft) {
            navController.navigate("join_screen") }
    }

    Column(modifier = Modifier.fillMaxSize()) {
        Header(streamId, currentMode)
        MySpacer()
        ParticipantsGrid(
            participants = viewModel.currentParticipants,
            modifier = Modifier.weight(1f)
        )
        MySpacer()
        MediaControlButtons(
            onJoinClick = { viewModel.initStream(context, app.sampleToken, streamId, mode)},
            onMicClick = { viewModel.toggleMic() },
            onCamClick = { viewModel.toggleWebcam()},
            onModeToggleClick = { viewModel.toggleMode() },
            showMediaControls = currentMode == StreamingMode.SendAndReceive,
            currentMode = currentMode,
            onLeaveClick = { viewModel.leaveStream() },
            isJoined = isJoined )
    }
}
@Composable
fun Header(streamId: String, mode: StreamingMode) {
    val context = LocalContext.current
    val clipboardManager = context.getSystemService(Context.CLIPBOARD_SERVICE) as ClipboardManager

    Box(modifier = Modifier.fillMaxWidth()
                        .padding(8.dp),
        contentAlignment = Alignment.TopStart
    ) {
        Row( modifier = Modifier.fillMaxWidth(),
            horizontalArrangement = Arrangement.SpaceBetween,
            verticalAlignment = Alignment.CenterVertically
        ) {
            Column {
                Row(verticalAlignment = Alignment.CenterVertically) {
                    MyText("StreamID: ", 28.sp)
                    MyText(streamId, 25.sp)
                    IconButton( onClick = {
                            val clip = ClipData.newPlainText("Stream ID", streamId)
                            clipboardManager.setPrimaryClip(clip)
                        })
                    {
                        //get baseline_content_copy_24 icon from Vector Asset
                        Icon( painter = painterResource(R.drawable.baseline_content_copy_24),
                            contentDescription = "Copy Stream ID",
                            modifier = Modifier.size(40.dp).padding(start = 8.dp)
                        )
                    }
                }
                Row {
                    MyText("Mode: ", 20.sp)
                    MyText(mode.name, 18.sp)
                }
            }
        }
    }
}
//...
```

### Step 7: Implementing Mode Switch and Media Toggles

Implement interactive controls to leave the stream, toggle microphone and webcam, and switch between Host (SEND_AND_RECV) and Audience (RECV_ONLY) modes for a seamless experience.

```js title="StreamingScreen.kt"
@Composable
fun MediaControlButtons(
    onJoinClick: () -> Unit,
    onMicClick: () -> Unit,
    onCamClick: () -> Unit,
    onModeToggleClick: () -> Unit,
    onLeaveClick: () -> Unit,
    showMediaControls: Boolean = true,
    currentMode: StreamingMode,
    isJoined: Boolean
) {
    Column( modifier = Modifier.fillMaxWidth()
                        .padding(6.dp),
        horizontalAlignment = Alignment.CenterHorizontally,
        verticalArrangement = Arrangement.spacedBy(8.dp)
    ) {
        Row( modifier = Modifier.fillMaxWidth(),
            horizontalArrangement = Arrangement.SpaceEvenly,
            verticalAlignment = Alignment.CenterVertically
        ) {
            if (!isJoined) {
                MyAppButton(onJoinClick, "Join")
            }
            if (showMediaControls && isJoined) {  // Only show media controls if joined
                MyAppButton(onMicClick, "ToggleMic")
                MyAppButton(onCamClick, "ToggleCam")
            }
        }

        Row( modifier = Modifier.fillMaxWidth(),
            horizontalArrangement = Arrangement.SpaceEvenly,
            verticalAlignment = Alignment.CenterVertically
        ) {
            if (isJoined) {
                MyAppButton(onLeaveClick, "Leave")
                MyAppButton(
                    task = onModeToggleClick,
                    buttonName = if (currentMode == StreamingMode.SendAndReceive)
                        "Switch to Audience"
                    else
                        "Switch to Host"
                )
            }
        }
    }
}
```

### Step 8: Setting Up StreamViewModel

The `StreamViewModel` manages the core functionality of Interactive Live Streaming (ILS), serving as the central state manager:

1. **Stream State Management**

   - Handles stream initialization with appropriate mode (Conference/Audience)
   - Tracks stream lifecycle (joined, left, current mode)

2. **Media Control Integration**

   - Provides microphone toggle (mute/unmute)
   - Controls webcam state (enable/disable)

3. **Mode Switching**
   - Enables seamless transitions between Conference and Audience modes

```js title="StreamViewModel"
class StreamViewModel : ViewModel() {
    private var stream: Meeting? = null
    private var micEnabled by mutableStateOf(true)
    private var webcamEnabled by mutableStateOf(true)
    var isConferenceMode by mutableStateOf(true)
    val currentParticipants = mutableStateListOf<Participant>()

    var localParticipantId by mutableStateOf("")
        private set

    var isStreamLeft by mutableStateOf(false)
        private set

    var currentMode by mutableStateOf(StreamingMode.SendAndReceive)
        private set

    var isJoined by mutableStateOf(false)
        private set

    fun initStream(context: Context, token: String, streamId: String, mode: StreamingMode) {
        VideoSDK.config(token)
        currentMode = mode
        if (stream == null) {
            stream = if (mode.name == StreamingMode.SendAndReceive.name) {
                VideoSDK.initMeeting(
                    context,"54dr-h8c5-hsif", "John Doe",
                    micEnabled, webcamEnabled, null, null, true, null, null
                )
            } else {
                VideoSDK.initMeeting(
                    context, "54dr-h8c5-hsif", "John Doe",
                    micEnabled, webcamEnabled, null, "RECV_ONLY", true, null, null
                )
            }
        }
        stream!!.addEventListener(meetingEventListener)
        stream!!.join()
        isJoined = true
    }

    private val meetingEventListener: MeetingEventListener = object : MeetingEventListener() {
        override fun onMeetingJoined() {
            stream?.let {
                if (it.localParticipant.mode != "RECV_ONLY") {
                    if (!currentParticipants.contains(it.localParticipant)) {
                        currentParticipants.add(it.localParticipant)
                    }
                }
                localParticipantId = it.localParticipant.id
            }
        }

        override fun onMeetingLeft() {
            currentParticipants.clear()
            stream = null
            isStreamLeft = true
        }

        override fun onParticipantJoined(participant: Participant) {
            if (participant.mode != "RECV_ONLY") {
                currentParticipants.add(participant)
            }
        }

        override fun onParticipantLeft(participant: Participant) {
            currentParticipants.remove(participant)
        }

        override fun onParticipantModeChanged(data: JSONObject?) {
            try {
                val participantId = data?.getString("peerId")
                val participant = if (stream?.localParticipant?.id == participantId) {
                    stream?.localParticipant
                } else {
                    stream?.participants?.get(participantId)
                }

                participant?.let {
                    when (it.mode) {
                        "RECV_ONLY" -> {
                            currentParticipants.remove(it)
                        }
                        "SEND_AND_RECV" -> {
                            if (!currentParticipants.contains(it)) {
                                currentParticipants.add(it)
                            } else { }
                        }
                        else -> {}
                    }
                }
            } catch (e: JSONException) {
                e.printStackTrace()
            }
        }
    }

    fun toggleMic() {
        if (micEnabled) stream?.muteMic() else stream?.unmuteMic()
        micEnabled = !micEnabled
    }

    fun toggleWebcam() {
        if (webcamEnabled) stream?.disableWebcam() else stream?.enableWebcam()
        webcamEnabled = !webcamEnabled
    }

    fun leaveStream() {
        currentParticipants.clear()
        stream?.leave()
        stream?.removeAllListeners()
        isStreamLeft = true
        isJoined = false
    }

    fun toggleMode() {
        val newMode = if (currentMode == StreamingMode.SendAndReceive) {
            stream?.disableWebcam()
            stream?.changeMode("RECV_ONLY")
            isConferenceMode = false
            StreamingMode.ReceiveOnly
        } else {
            stream?.changeMode("SEND_AND_RECV")
            isConferenceMode = true
            StreamingMode.SendAndReceive
        }

        // Clear all participants first
        currentParticipants.clear()

        // Wait briefly for mode change to complete
        stream?.let { it ->
            // Add back all non-viewer participants
            it.participants.values.forEach { participant ->
                if (participant.mode != "RECV_ONLY") {
                    currentParticipants.add(participant)
                }
            }

            // Add local participant only if in SEND_AND_RECV mode
            if (newMode == StreamingMode.SendAndReceive) {
                it.localParticipant?.let { localParticipant ->
                    if (!currentParticipants.contains(localParticipant)) {
                        currentParticipants.add(localParticipant)
                    }
                }
                // Re-enable webcam if it was enabled before
                if (webcamEnabled) {
                    it.enableWebcam() }
            }
        }
        currentMode = newMode
    }
}
```

<div style={{ textAlign: 'center' }}>
    <img 
        src='https://cdn.videosdk.live/website-resources/docs-resources/ils_qs_android_send_and_receive_screen.png'  
        alt="VideoSDK Android Quick Start Meeting Screen" 
       style={{height: '450px'}}
    />
</div>

## Final Output

We are done with implementation of customised video calling app in Android using Video SDK. To explore more features go through Basic and Advanced features.

#### Final Output

import ReactPlayer from 'react-player'

<div style={{textAlign: 'center'}}>

<ReactPlayer autoplay muted loop playing controls url="https://cdn.videosdk.live/website-resources/docs-resources/ils_qs_android_screen_recording.mp4" playbackRate={1.8} height="500px" width={"100%"} />

</div>

:::tip
You can checkout the complete [quick start example here](https://github.com/videosdk-live/quickstart/tree/main/interactive-live-streaming/android-ils).
:::


---

---
title: ComposeUI Quick Start with Android
hide_title: false
hide_table_of_contents: false
description: Video SDK enables the opportunity to integrate native IOS, Android & Web SDKs to add live video & audio conferencing to your applications.
sidebar_label: Start a Audio / Video Call (Compose)
pagination_label: Quick Start with Android
keywords:
  - audio calling
  - video calling
  - real-time communication
  - collaboration
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: quick-start-compose-ui
---

# Quick Start for Conference in Android

VideoSDK enables you to embed the video calling feature into your Android application in minutes.

In this quickstart, we are going to explore group calling feature of Video SDK. We will go through step by step guide of integrating video calling with Android Video SDK.

This guide will get you running with the VideoSDK video & audio calling in minutes.

## Prerequisites

Before proceeding, ensure that your development environment meets the following requirements:

- Android Studio Arctic Fox (2020.3.1) or later.
- Android SDK API Level 21 or higher.
- A mobile device that runs Android 5.0 or later.

:::important

One should have a VideoSDK account to generate token.
Visit VideoSDK **[dashboard](https://app.videosdk.live/api-keys)** to generate token

:::

## Getting Started with the Code!

Follow the steps to create the environment necessary to add video calls into your app. Also you can find the code sample for [quickstart here](https://github.com/videosdk-live/quickstart/tree/main/android-rtc/Videosdk_android_compose_quickstart/).

### Create new Android Project

For a new project in **Android Studio**, create a **Phone and Tablet** Android project with an **Empty Activity**.

![VideoSDK Android Quick Start New Project](https://cdn.videosdk.live/docs/images/android/quickstart/android_compose_newProject.jpg )

:::caution
After creating the project, Android Studio automatically starts gradle sync. Ensure that the sync succeeds before you continue.
:::

### Integrate Video SDK

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Maven Central"
groupId={"android-repositories"}
values={[{label: 'Maven Central', value: 'Maven Central'},{label: 'Jitpack', value: 'Jitpack'},]}>

<TabItem value="Maven Central">

```js title="settings.gradle"
dependencyResolutionManagement {
    repositories {
    google()
    mavenCentral()
    maven {url= uri("https://maven.aliyun.com/repository/jcenter")}
  }
}
```

</TabItem>

<TabItem value="Jitpack">

```js title="settings.gradle"
dependencyResolutionManagement{
  repositories {
    google()
    maven { url = uri("https://www.jitpack.io") }
    mavenCentral()
    maven {url= uri("https://maven.aliyun.com/repository/jcenter")}
  }
}
```

</TabItem>

</Tabs>

:::note

You can use imports with Maven Central after rtc-android-sdk version `0.1.12`.

Whether on Maven or Jitpack, the same version numbers always refer to the same SDK.

:::

- Add the following dependency in your app's `app/build.gradle`.

```js title="app/build.gradle"
dependencies {
  implementation ("live.videosdk:rtc-android-sdk:0.1.38")

  // library to perform Network call to generate a meeting id
  implementation ("com.amitshekhar.android:android-networking:1.0.2")

  // other app dependencies
  }
```

:::important

Android SDK compatible with armeabi-v7a, arm64-v8a, x86_64 architectures. If you want to run the application in an emulator, choose ABI x86_64 when creating a device.

:::

### Add permissions into your project

- In `/app/Manifests/AndroidManifest.xml`, add the following permissions.

```xml title="AndroidManifest.xml"
<uses-feature android:name="android.hardware.camera" android:required="false" />
<uses-permission android:name="android.permission.INTERNET"/>
<uses-permission android:name="android.permission.CAMERA"/>
<uses-permission android:name="android.permission.RECORD_AUDIO"/>
<uses-permission android:name="android.permission.MODIFY_AUDIO_SETTINGS"/>
```

:::note

If your project has set `android.useAndroidX=true`, then set `android.enableJetifier=true` in the `gradle.properties` file to migrate your project to AndroidX and avoid duplicate class conflict.

:::

### Structure of the project

Your project structure should look like this.

```jsx title="Project Structure"
app/
├── src/main/
│   ├── java/com/example/app/
│   │   ├── components/          
│   │   ├── screens/            
│   │   ├── navigation/          
│   │   ├── ui/                  
│   │   │   └── theme/           
│   │   ├── model/               
│   │   ├── MainApplication.kt   
│   │   ├── MainActivity.kt      
│   │   └── NetworkClass.kt      
│   ├── res/                     
│   └── AndroidManifest.xml      
├── build.gradle
└── settings.gradle
```


### App Architecture

<center>

<img src='https://cdn.videosdk.live/docs/images/android/quickstart/android_compose_quickstart_app_structure.jpg ' />

</center>

### Step 1: Initialize VideoSDK

1. Create `MainApplication` class which will extend the `android.app.Application`.

- Create field `sampleToken` in `MainApplication` which will hold the generated token from the [VideoSDK dashboard](https://app.videosdk.live/api-keys). This token will use in VideoSDK config as well as in generating meetingId.


```js title="MainApplication.kt"
import android.app.Application
import live.videosdk.rtc.android.VideoSDK

class MainApplication: Application() {

    val sampleToken = "YOUR_TOKEN" //paste your token here

    override fun onCreate() {
        super.onCreate()
        VideoSDK.initialize(applicationContext)
    }
}
```

2. Add `MainApplication` to `AndroidManifest.xml`

```xml title="AndroidManifest.xml"
<application
    android:name=".MainApplication" >
   <!-- ... -->
</application>
```

### Step 2: Managing Permissions

The `MainActivity` is the entry point of the application. It handles permission requests for accessing the camera and microphone.

On creation, it checks if the required permissions (RECORD_AUDIO and CAMERA) are granted.

If not, it requests them. Once permissions are granted, it sets the content view using Jetpack Compose and initializes the MyApp composable, which contains the app's navigation and UI logic.

```js title="MainActivity.kt"
class MainActivity : ComponentActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        checkSelfPermission(REQUESTED_PERMISSIONS[0], PERMISSION_REQ_ID)
        checkSelfPermission(REQUESTED_PERMISSIONS[1], PERMISSION_REQ_ID)

        setContent {
            Videosdk_android_compose_quickstartTheme {
                MyApp(this)
            }
        }
    }

    private fun checkSelfPermission(permission: String, requestCode: Int): Boolean {
        if (ContextCompat.checkSelfPermission(this, permission) !=
            PackageManager.PERMISSION_GRANTED
        ) {
            ActivityCompat.requestPermissions(this,
                REQUESTED_PERMISSIONS, requestCode)
            return false
        }
        return true
    }

    companion object {
        private const val PERMISSION_REQ_ID = 22
        private val REQUESTED_PERMISSIONS = arrayOf(
            Manifest.permission.RECORD_AUDIO,
            Manifest.permission.CAMERA
        )
    }
}

@Composable
fun MyApp(context: Context) {
    NavigationGraph(context = context)
}
```



### Step 3: Setting Up Navigation

The `NavigationGraph` composable manages navigation between the `JoinScreen` and `MeetingScreen` using `NavController`.

```js title="NavigationGraph.kt"
@Composable
fun NavigationGraph(navController: NavHostController = rememberNavController(),context: Context) {
    NavHost(navController = navController, startDestination = "join_screen") {
        composable("join_screen") {
            JoinScreen(navController,context)
        }
        composable("meeting_screen?meetingId={meetingId}") { backStackEntry ->
            val meetingId = backStackEntry.arguments?.getString("meetingId")
            meetingId?.let {
                MeetingScreen(viewModel = MeetingViewModel(),navController, meetingId, context)
            }
        }
    }
}
```

### Step 4: Creating Components

- Before building the individual screens, it's essential to develop reusable composable components that will be used throughout the project.

1. Create a `ReusableComponents.kt` file to organize all reusable components for the project, such as buttons, spacers, and customizable text.

```js title="ReusableComponents.kt"
@Composable
fun MyAppButton(task: () -> Unit, buttonName: String) {
    Button(onClick = task) {
        Text(text = buttonName)
    }
}
@Composable
fun MySpacer() {
    Spacer(
        modifier = Modifier
            .fillMaxWidth()
            .height(1.dp)
            .background(color = Color.Gray))}
@Composable
fun MyText(text: String, fontSize: TextUnit = 23.sp) {
    Text(
        text = text,
        fontSize = fontSize,
        fontWeight = FontWeight.Normal,
        modifier = Modifier.padding(4.dp),
        style = MaterialTheme.typography.bodyMedium.copy(fontSize = 16.sp),
        color = MaterialTheme.colorScheme.onSurface.copy(alpha = 0.7f)
    )}
```
2. Create a `ParticipantVideoView.kt` file that includes two composable functions: `ParticipantVideoView` for rendering individual participant video streams, and `ParticipantsGrid` for displaying a grid of participant videos.

:::info

- Here the participant's video is displayed using `VideoView`. To know more about `VideoView`, please visit [here](/android/guide/video-and-audio-calling-api-sdk/render-media/display-video/understand-videoView-component)
- `VideoView` is a custom View. Since Jetpack Compose does not natively support traditional `View` objects, we need to integrate the `VideoView` into the Compose layout using the `AndroidView` wrapper.
- `AndroidView()` is a composable that can be used to add Android views inside a @Composable function.

:::

```js title="ParticipantVideoView.kt"
@Composable
fun ParticipantVideoView(
    participant: Participant
) {
    var isVideoEnabled by remember { mutableStateOf(false) }

    LaunchedEffect(participant) {
        isVideoEnabled = participant.streams.any { (_, stream) ->
            stream.kind.equals("video", ignoreCase = true) && stream.track != null
        }
    }
    Box(
        modifier = Modifier
            .fillMaxWidth()
            .height(200.dp)
            .background(if (isVideoEnabled) Color.DarkGray else Color.Gray)
    ) {
        AndroidView(
            factory = { context ->
                VideoView(context).apply {
                    for ((_, stream) in participant.streams) {
                        if (stream.kind.equals("video", ignoreCase = true)) {
                            val videoTrack = stream.track as VideoTrack
                            addTrack(videoTrack)
                            isVideoEnabled = true
                        }
                    }
                }
            },
            update = { videoView ->
                participant.addEventListener(object : ParticipantEventListener() {
                    override fun onStreamEnabled(stream: Stream) {
                        if (stream.kind.equals("video", ignoreCase = true)) {
                            val videoTrack = stream.track as VideoTrack
                            videoView.addTrack(videoTrack)
                            isVideoEnabled = true
                        }
                    }

                    override fun onStreamDisabled(stream: Stream) {
                        if (stream.kind.equals("video", ignoreCase = true)) {
                            videoView.removeTrack()
                            isVideoEnabled = false
                        }
                    }
                })
            },
            onRelease = { videoView ->
                videoView.releaseSurfaceViewRenderer()
            },
            modifier = Modifier.fillMaxSize()
        )

        if (!isVideoEnabled) {
            Box(
                modifier = Modifier
                    .fillMaxSize()
                    .background(Color.DarkGray),
                contentAlignment = Alignment.Center
            ) {
                Text(
                    text = "Camera Off",
                    color = Color.White
                )
            }
        }

        Box(
            modifier = Modifier
                .align(Alignment.BottomCenter)
                .fillMaxWidth()
                .background(Color(0x99000000))
                .padding(4.dp)
        ) {
            Text(
                text = participant.displayName,
                color = Color.White,
                modifier = Modifier.align(Alignment.Center)
            )
        }
    }
}
@Composable
fun ParticipantsGrid(
    participants: List<Participant>,
    modifier: Modifier = Modifier
) {
    LazyVerticalGrid(
        columns = GridCells.Fixed(2),
        verticalArrangement = Arrangement.spacedBy(16.dp),
        horizontalArrangement = Arrangement.spacedBy(16.dp),
        modifier = modifier
            .fillMaxWidth()
            .padding(8.dp)
    ) {
        items(participants.size) { index ->
            ParticipantVideoView(
                participant = participants[index],
            )
        }
    }
}
```


### Step 5: Creating Joining Screen

We will create a simple Join screen UI that supports two primary roles:

- Create Meeting: Starts a new meeting.
- Join Meeting: Enter a Meeting ID to join an existing meeting.

#### Creating UI

The Joining screen will include :

1. **Create Button** - This button will create a new meeting for you.
2. **TextField for Meeting Id** - This text field will contain the meeting Id you want to join.
3. **Join Button** - This button will join the meeting with `meetingId` you provided.

```js title="JoinScreen.kt"
@Composable
fun JoinScreen(
    navController: NavController, context: Context
) {
    val app = context.applicationContext as MainApplication
    val token = app.sampleToken
    Box(
        modifier = Modifier
            .fillMaxSize()
            .padding(8.dp),
        contentAlignment = Alignment.Center
    ) {
        Column(
            modifier = Modifier.padding(4.dp),
            horizontalAlignment = Alignment.CenterHorizontally,
            verticalArrangement = Arrangement.SpaceEvenly
        ) {
            var input by rememberSaveable { mutableStateOf("") }
            CreateMeetingBtn(navController, token)
            Text(text = "OR")
            InputMeetingId(input) { updateInput ->
                input = updateInput
            }
            JoinMeetingBtn(navController, input)
        }
    }
}

@Composable
fun CreateMeetingBtn(navController: NavController, token: String) {
    MyAppButton({
        NetworkManager.createMeetingId(token) { meetingId ->
            navController.navigate("meeting_screen?meetingId=$meetingId")
        }
    }, "Create Meeting")
}

@Composable
fun InputMeetingId(input: String, onInputChange: (String) -> Unit) {
    OutlinedTextField(value = input,
        onValueChange = onInputChange,
        label = { Text(text = "Enter Meeting Id") })
}

@Composable
fun JoinMeetingBtn(navController: NavController, meetingId: String) {
    MyAppButton({
        if (meetingId.isNotEmpty()) {
            navController.navigate("meeting_screen?meetingId=$meetingId")
        }
    }, "Join Meeting")
}
```

#### Output

<div style={{ textAlign: 'center' }}>
    <img 
        src="https://cdn.videosdk.live/docs/images/android/quickstart/android_compose-join-screen.jpg" 
        alt="VideoSDK Android Quick Start joining Screen" 
         style={{height: '450px'}}
    />
</div>

### Step 6: Creating MeetingId

The `NetworkManager` singleton handles meeting creation by making a POST request to the [VideoSDK API](https://docs.videosdk.live/api-reference/realtime-communication/create-room):

- Meeting Creation: Sends a request to the API with an authorization token to create a meeting.
- Response Handling: Extracts the roomId from the response and triggers the `onMeetingCreated` callback.


```js title="NetworkManager.kt"
object NetworkManager {
    fun createMeetingId(token: String, onMeetingIdCreated: (String) -> Unit) {
        AndroidNetworking.post("https://api.videosdk.live/v2/rooms")
            .addHeaders("Authorization", token)
            .build()
            .getAsJSONObject(object : JSONObjectRequestListener {
                override fun onResponse(response: JSONObject) {
                    try {
                        val meetingId = response.getString("roomId")
                        onMeetingIdCreated(meetingId)
                    } catch (e: JSONException) {
                        e.printStackTrace()
                    }
                }

                override fun onError(anError: ANError) {
                    anError.printStackTrace()
                    Log.d("TAG", "onError: $anError")
                }
            })
    }
}
```

:::note

Don't confuse with Room and Meeting keyword, both are same thing 😃

:::

### Step 7: Creating Meeting Screen

We will create a simple Meeting screen UI with two main sections:

- Participants' Video Streams: Displays video feeds of meeting participants.
- Media Control Buttons: Includes buttons to control the mic, camera, and leave the meeting.

#### Creating UI

The `MeetingScreen` composable is the main UI for a video call meeting, handling meeting details and user actions.

- The `MeetingScreen` composable is organized into three sections, each serving a specific purpose:

1. `Header`: Displays the meeting ID at the top of the screen for reference.
2. `ParticipantsGrid`: Shows the list of participants in a grid layout, adjusting dynamically.
3. `MediaControlButtons`: A set of buttons to control the microphone, camera, and leave the meeting.


```js title="MeetingScreen.kt"
@Composable
fun MeetingScreen(viewModel: MeetingViewModel, navController: NavController, meetingId: String, context: Context) {

    val app = context.applicationContext as MainApplication
    val isMeetingLeft = viewModel.isMeetingLeft

    LaunchedEffect(isMeetingLeft) {
        if (isMeetingLeft) {
            navController.navigate("join_screen")
        }
    }
    Column(modifier = Modifier.fillMaxSize()) {
        Header(meetingId)
        MySpacer()
        ParticipantsGrid(viewModel.participants, Modifier.weight(1f))
        MySpacer()
        MediaControlButtons(
            onJoinClick = {
                viewModel.initMeeting(context, app.sampleToken, meetingId)
            },
            onMicClick = { viewModel.toggleMic() },
            onCamClick = { viewModel.toggleWebcam() },
            onLeaveClick = {
                viewModel.leaveMeeting()
            }
        )
    }
}
@Composable
fun Header(meetingId: String) {
    Box(
        modifier = Modifier
            .fillMaxWidth()
            .padding(8.dp),
        contentAlignment = Alignment.TopStart
    ) {
        Row {
            MyText("MeetingID: ", 28.sp)
            MyText(meetingId, 25.sp)
        }
    }
}
@Composable
fun MediaControlButtons(onJoinClick:()->Unit,onMicClick: () -> Unit, onCamClick: () -> Unit, onLeaveClick: () -> Unit) {
    Row(
        modifier = Modifier
            .fillMaxWidth()
            .padding(6.dp),
        verticalAlignment = Alignment.CenterVertically,
        horizontalArrangement = Arrangement.SpaceAround
    ) {
        MyAppButton(onJoinClick,"Join")
        MyAppButton(onMicClick,"ToggleMic")
        MyAppButton(onCamClick,"ToggleCam")
        MyAppButton(onLeaveClick,"Leave")
    }
}
```

### Step 8: Setting Up MeetingViewModel

The `MeetingViewModel` manages the meeting state, handles participants, and controls microphone and camera settings to ensure a smooth video call experience.

Managing Meeting State and Media Control:

1. Meeting Initialization: Initializes the meeting with the VideoSDK and adds an event listener.
2. Participant Management: Tracks participants, adding/removing them as they join/leave.
3. Media Control: Toggles microphone and webcam states.
4. Leave Meeting: Allows users to leave the meeting.

```js title="MeetingViewModel.kt"
class MeetingViewModel : ViewModel() {

    private var meeting: Meeting? = null
    private var micEnabled by mutableStateOf(true)
    private var webcamEnabled by mutableStateOf(true)
    val participants = mutableStateListOf<Participant>()

    //used in MeetingScreen to handle navigation
    var isMeetingLeft by mutableStateOf(false)
        private set

    fun initMeeting(context: Context, token: String, meetingId: String ) {
        VideoSDK.config(token)
        if(meeting==null){
            meeting = VideoSDK.initMeeting(
                context, meetingId, "John Doe",
                micEnabled, webcamEnabled, null, null, true, null, null)
        }
        meeting!!.addEventListener(meetingEventListener)
        meeting!!.join()
    }

    private val meetingEventListener: MeetingEventListener = object : MeetingEventListener() {
        override fun onMeetingJoined() {
            Log.d("#meeting", "onMeetingJoined()")
            meeting?.let { participants.add(it.localParticipant) }
        }
        override fun onMeetingLeft() {
            Log.d("#meeting", "onMeetingLeft()")
            meeting = null
            isMeetingLeft = true
        }

        override fun onParticipantJoined(participant: Participant) {
                participants.add(participant)
        }

        override fun onParticipantLeft(participant: Participant) {
            participants.remove(participant)
        }
    }

    fun toggleMic() {
        if (micEnabled) {
            meeting?.muteMic()
        } else {
            meeting?.unmuteMic()
        }
        micEnabled = !micEnabled
    }

    fun toggleWebcam() {
        if (webcamEnabled) {
            meeting?.disableWebcam()
        } else {
            meeting?.enableWebcam()
        }
        webcamEnabled = !webcamEnabled
    }

    fun leaveMeeting() {
        meeting?.leave()
    }
}
```

<div style={{ textAlign: 'center' }}>
    <img 
        src="https://cdn.videosdk.live/docs/images/android/quickstart/android_compose-meeting-screen.jpg" 
        alt="VideoSDK Android Quick Start Meeting Screen" 
       style={{height: '450px'}}
    />
</div>



## Final Output

We are done with implementation of customised video calling app in Android using Video SDK. To explore more features go through Basic and Advanced features.

import ReactPlayer from 'react-player'

<div style={{textAlign: 'center'}}>

<ReactPlayer muted controls url="https://cdn.videosdk.live/docs/images/android/quickstart/android_compose_quickstart.mp4 " height="500px" width={"100%"} />

</div>

:::tip
You can checkout the complete [quick start example here](https://github.com/videosdk-live/quickstart/tree/main/android-rtc/Videosdk_android_compose_quickstart/).
:::


---

---
title: Quick Start with Android
hide_title: false
hide_table_of_contents: false
description: Video SDK enables the opportunity to integrate native IOS, Android & Web SDKs to add live video & audio conferencing to your applications.
sidebar_label: Start a Audio / Video Call (XML)
pagination_label: Quick Start with Android
keywords:
  - audio calling
  - video calling
  - real-time communication
  - collaboration
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: quick-start
---

# Quick Start for Conference in Android

<ReactPlayer controls url="https://www.youtube.com/watch?v=Kj7jS3dbJFA" height="500px" width={"100%"} />

VideoSDK enables you to embed the video calling feature into your Android application in minutes.

In this quickstart, we are going to explore group calling feature of Video SDK. We will go through step by step guide of integrating video calling with Android Video SDK.

This guide will get you running with the VideoSDK video & audio calling in minutes.

## Prerequisites

Before proceeding, ensure that your development environment meets the following requirements:

- Java Development Kit.
- Android Studio 3.0 or later.
- Android SDK API Level 21 or higher.
- A mobile device that runs Android 5.0 or later.

:::important

One should have a VideoSDK account to generate token.
Visit VideoSDK **[dashboard](https://app.videosdk.live/api-keys)** to generate token

:::

## Getting Started with the Code!

Follow the steps to create the environment necessary to add video calls into your app. Also you can find the code sample for [quickstart here](https://github.com/videosdk-live/quickstart/tree/main/android-rtc).

### Create new Android Project

For a new project in **Android Studio**, create a **Phone and Tablet** Android project with an **Empty Activity**.

![VideoSDK Android Quick Start New Project](/img/quick-start/android_newProject.png)

:::caution
After creating the project, Android Studio automatically starts gradle sync. Ensure that the sync succeeds before you continue.
:::

### Integrate Video SDK

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Maven Central"
groupId={"android-repositories"}
values={[{label: 'Maven Central', value: 'Maven Central'},{label: 'Jitpack', value: 'Jitpack'},]}>

<TabItem value="Maven Central">

```js title="settings.gradle"
dependencyResolutionManagement{
  repositories {
    // ...
    google()
    mavenCentral()
    maven { url "https://maven.aliyun.com/repository/jcenter" }
  }
}
```

</TabItem>

<TabItem value="Jitpack">

```js title="settings.gradle"
dependencyResolutionManagement{
  repositories {
    // ...
    google()
    maven { url 'https://jitpack.io' }
    mavenCentral()
    maven { url "https://maven.aliyun.com/repository/jcenter" }
  }
}
```

</TabItem>

</Tabs>

:::note

You can use imports with Maven Central after rtc-android-sdk version `0.1.12`.

Whether on Maven or Jitpack, the same version numbers always refer to the same SDK.

:::

- Add the following dependency in your app's `app/build.gradle`.

```js title="app/build.gradle"
dependencies {
  implementation 'live.videosdk:rtc-android-sdk:0.1.38'

  // library to perform Network call to generate a meeting id
  implementation 'com.amitshekhar.android:android-networking:1.0.2'

  // other app dependencies
  }
```

:::important

Android SDK compatible with armeabi-v7a, arm64-v8a, x86_64 architectures. If you want to run the application in an emulator, choose ABI x86_64 when creating a device.

:::

### Add permissions into your project

- In `/app/Manifests/AndroidManifest.xml`, add the following permissions after `</application>`.

```xml title="AndroidManifest.xml"
<uses-permission android:name="android.permission.RECORD_AUDIO" />
<uses-permission android:name="android.permission.MODIFY_AUDIO_SETTINGS" />
<uses-permission android:name="android.permission.INTERNET" />
<uses-permission android:name="android.permission.CAMERA" />
```

:::note

If your project has set `android.useAndroidX=true`, then set `android.enableJetifier=true` in the `gradle.properties` file to migrate your project to AndroidX and avoid duplicate class conflict.

:::

### Structure of the project

Your project structure should look like this.

```jsx title="Project Structure"
   app
   ├── java
   │    ├── packagename
   │         ├── JoinActivity
   │         ├── MainApplication
   │         ├── MeetingActivity
   │         ├── ParticipantAdapter
   ├── res
   │    ├── layout
   │    │    ├── activity_join.xml
   │    │    ├── activity_meeting.xml
   │    │    ├── item_remote_peer.xml
```

:::note

You have to set JoinActivity as Launcher activity.

:::

### App Architecture

<center>

<img src='https://cdn.videosdk.live/website-resources/docs-resources/android_quickstart_app_structure.png' />

</center>

### Step 1: Initialize VideoSDK

1. Create `MainApplication` class which will extend the `android.app.Application`.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js title="MainApplication.kt"
import live.videosdk.rtc.android.VideoSDK

class MainApplication : Application() {
  override fun onCreate() {
      super.onCreate()
      //highlight-next-line
      VideoSDK.initialize(applicationContext)
  }
}
```

</TabItem>

<TabItem value="Java">

```java title="MainApplication.java"
import android.app.Application;
import live.videosdk.rtc.android.VideoSDK;

public class MainApplication extends Application {
  @Override
  public void onCreate() {
    super.onCreate();
    //highlight-next-line
    VideoSDK.initialize(getApplicationContext());
  }
}
```

</TabItem>

</Tabs>

2. Add `MainApplication` to `AndroidManifest.xml`

```xml title="AndroidManifest.xml"
<application
    android:name=".MainApplication" >
   <!-- ... -->
</application>
```

### Step 2: Creating Joining Screen

Create a new Activity named `JoinActivity`.

#### Creating UI

The Joining screen will include :

1. **Create Button** - This button will create a new meeting for you.
2. **TextField for Meeting Id** - This text field will contain the meeting Id you want to join.
3. **Join Button** - This button will join the meeting with `meetingId` you provided.

In `/app/res/layout/activity_join.xml` file, replace the content with the following.

```xml title="activity_join.xml"
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:gravity="center"
    android:orientation="vertical"
    tools:context=".JoinActivity">

    <Button
        android:id="@+id/btnCreateMeeting"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_marginBottom="16dp"
        android:text="Create Meeting" />

    <TextView
        style="@style/TextAppearance.AppCompat.Headline"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="OR" />

    <com.google.android.material.textfield.TextInputLayout
        style="@style/Widget.MaterialComponents.TextInputLayout.OutlinedBox"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_marginVertical="16dp"
        android:hint="Enter Meeting ID">

        <EditText
            android:id="@+id/etMeetingId"
            android:layout_width="250dp"
      android:layout_height="wrap_content" />
    </com.google.android.material.textfield.TextInputLayout>

    <Button
        android:id="@+id/btnJoinMeeting"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Join Meeting" />
</LinearLayout>
```

#### Integration of Create Meeting API

1. Create field `sampleToken` in `JoinActivity` which will hold the generated token from the [VideoSDK dashboard](https://app.videosdk.live/api-keys). This token will use in VideoSDK config as well as in generating meetingId.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js title="JoinActivity.kt"
class JoinActivity : AppCompatActivity() {

  //highlight-next-line
  //Replace with the token you generated from the VideoSDK Dashboard
  private var sampleToken = ""

  override fun onCreate(savedInstanceState: Bundle?) {
    //...
  }
}
```

</TabItem>

<TabItem value="Java">

```java title="JoinActivity.java"
public class JoinActivity extends AppCompatActivity {

  //highlight-next-line
  //Replace with the token you generated from the VideoSDK Dashboard
  private String sampleToken ="";

  @Override
  protected void onCreate(Bundle savedInstanceState) {
    //...
  }
}
```

</TabItem>

</Tabs>

2. On **Join Button** `onClick` events, we will naviagte to `MeetingActivity` with token and meetingId.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js title="JoinActivity.kt"
class JoinActivity : AppCompatActivity() {

   //Replace with the token you generated from the VideoSDK Dashboard
   private var sampleToken = ""

   override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_join)

        val btnCreate = findViewById<Button>(R.id.btnCreateMeeting)
        val btnJoin = findViewById<Button>(R.id.btnJoinMeeting)
        val etMeetingId = findViewById<EditText>(R.id.etMeetingId)

        btnCreate.setOnClickListener { v: View? ->
            createMeeting(sampleToken)
        }
        btnJoin.setOnClickListener { v: View? ->
            val intent = Intent(this@JoinActivity, MeetingActivity::class.java)
            intent.putExtra("token", sampleToken)
            intent.putExtra("meetingId", etMeetingId.text.toString())
            startActivity(intent)
        }
    }

    private fun createMeeting(token: String) {
      // we will explore this method in the next step
    }
}
```

</TabItem>

<TabItem value="Java">

```java title="JoinActivity.java"
public class JoinActivity extends AppCompatActivity {

  //Replace with the token you generated from the VideoSDK Dashboard
  private String sampleToken ="";

  @Override
  protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_join);

    final Button btnCreate = findViewById(R.id.btnCreateMeeting);
    final Button btnJoin = findViewById(R.id.btnJoinMeeting);
    final EditText etMeetingId = findViewById(R.id.etMeetingId);

    btnCreate.setOnClickListener(v -> {
      createMeeting(sampleToken);
    });

    btnJoin.setOnClickListener(v -> {
      Intent intent = new Intent(JoinActivity.this, MeetingActivity.class);
      intent.putExtra("token", sampleToken);
      intent.putExtra("meetingId", etMeetingId.getText().toString());
      startActivity(intent);
    });
  }

  private void createMeeting(String token) {
    // we will explore this method in the next step
  }
}
```

</TabItem>

</Tabs>

3. For **Create Button**, under `createMeeting` method we will generate meetingId by calling API and navigate to `MeetingActivity` with token and generated meetingId.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js title="JoinActivity.kt"
class JoinActivity : AppCompatActivity() {
  //...onCreate
 private fun createMeeting(token: String) {
    // we will make an API call to VideoSDK Server to get a roomId
    AndroidNetworking.post("https://api.videosdk.live/v2/rooms")
      .addHeaders("Authorization", token) //we will pass the token in the Headers
      .build()
      .getAsJSONObject(object : JSONObjectRequestListener {
          override fun onResponse(response: JSONObject) {
              try {
                  // response will contain `roomId`
                  val meetingId = response.getString("roomId")

                  // starting the MeetingActivity with received roomId and our sampleToken
                  val intent = Intent(this@JoinActivity, MeetingActivity::class.java)
                  intent.putExtra("token", sampleToken)
                  intent.putExtra("meetingId", meetingId)
                  startActivity(intent)
              } catch (e: JSONException) {
                  e.printStackTrace()
              }
          }

          override fun onError(anError: ANError) {
              anError.printStackTrace()
                    Toast.makeText(
                        this@JoinActivity, anError.message,
                        Toast.LENGTH_SHORT
                    ).show()
          }
      })
  }
}
```

</TabItem>

<TabItem value="Java">

```java title="JoinActivity.java"
public class JoinActivity extends AppCompatActivity {
  //...onCreate

  private void createMeeting(String token) {
      // we will make an API call to VideoSDK Server to get a roomId
      AndroidNetworking.post("https://api.videosdk.live/v2/rooms")
        .addHeaders("Authorization", token) //we will pass the token in the Headers
        .build()
        .getAsJSONObject(new JSONObjectRequestListener() {
            @Override
            public void onResponse(JSONObject response) {
                try {
                    // response will contain `roomId`
                    final String meetingId = response.getString("roomId");

                    // starting the MeetingActivity with received roomId and our sampleToken
                    Intent intent = new Intent(JoinActivity.this, MeetingActivity.class);
                    intent.putExtra("token", sampleToken);
                    intent.putExtra("meetingId", meetingId);
                    startActivity(intent);
                } catch (JSONException e) {
                    e.printStackTrace();
                }
            }

            @Override
            public void onError(ANError anError) {
                anError.printStackTrace();
                Toast.makeText(JoinActivity.this, anError.getMessage(), Toast.LENGTH_SHORT).show();
            }
        });
  }
}
```

</TabItem>

</Tabs>

:::note

Don't confuse with Room and Meeting keyword, both are same thing 😃

:::

4. Our App is completely based on audio and video commutation, that's why we need to ask for runtime permissions `RECORD_AUDIO` and `CAMERA`. So, we will implement permission logic on `JoinActivity`.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js title="JoinActivity.kt"
class JoinActivity : AppCompatActivity() {
    companion object {
        private const val PERMISSION_REQ_ID = 22
        private val REQUESTED_PERMISSIONS = arrayOf(
            Manifest.permission.RECORD_AUDIO,
            Manifest.permission.CAMERA
        )
    }

  private fun checkSelfPermission(permission: String, requestCode: Int): Boolean {
        if (ContextCompat.checkSelfPermission(this, permission) !=
            PackageManager.PERMISSION_GRANTED)
        {
            ActivityCompat.requestPermissions(this, REQUESTED_PERMISSIONS, requestCode)
            return false
        }
        return true
    }

  override fun onCreate(savedInstanceState: Bundle?) {
    //... button listeneres
    //highlight-start
    checkSelfPermission(REQUESTED_PERMISSIONS[0], PERMISSION_REQ_ID)
    checkSelfPermission(REQUESTED_PERMISSIONS[1], PERMISSION_REQ_ID)
    //highlight-end
  }
}
```

</TabItem>

<TabItem value="Java">

```java title="JoinActivity.java"
public class JoinActivity extends AppCompatActivity {
  private static final int PERMISSION_REQ_ID = 22;

  private static final String[] REQUESTED_PERMISSIONS = {
    Manifest.permission.RECORD_AUDIO,
    Manifest.permission.CAMERA
  };

  private boolean checkSelfPermission(String permission, int requestCode) {
    if (ContextCompat.checkSelfPermission(this, permission) != PackageManager.PERMISSION_GRANTED) {
      ActivityCompat.requestPermissions(this, REQUESTED_PERMISSIONS, requestCode);
      return false;
    }
    return true;
  }

  @Override
  protected void onCreate(Bundle savedInstanceState) {
    //... button listeneres
    //highlight-start
    checkSelfPermission(REQUESTED_PERMISSIONS[0], PERMISSION_REQ_ID);
    checkSelfPermission(REQUESTED_PERMISSIONS[1], PERMISSION_REQ_ID);
    //highlight-end
  }
}
```

</TabItem>

</Tabs>

#### Output

<div style={{textAlign: 'center'}}>

![VideoSDK Android Quick Start joining Screen](/img/quick-start/android-join-screen.jpg)

</div>

### Step 3: Creating Meeting Screen

Create a new Activity named `MeetingActivity`.

#### Creating the UI for Meeting Screen

In `/app/res/layout/activity_meeting.xml` file, replace the content with the following.

```xml title="activty_meeting.xml"
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:gravity="center"
    android:orientation="vertical"
    tools:context=".MeetingActivity">

    <TextView
        android:id="@+id/tvMeetingId"
        style="@style/TextAppearance.AppCompat.Display1"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Meeting Id" />

    <androidx.recyclerview.widget.RecyclerView
        android:id="@+id/rvParticipants"
        android:layout_width="match_parent"
        android:layout_height="0dp"
        android:layout_weight="1" />

    <LinearLayout
        android:layout_width="wrap_content"
        android:layout_height="wrap_content">

        <Button
            android:id="@+id/btnMic"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:layout_marginVertical="8dp"
            android:text="Mic"/>

        <Button
            android:id="@+id/btnLeave"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:layout_marginVertical="8dp"
            android:layout_marginHorizontal="8dp"
            android:text="Leave"/>

        <Button
            android:id="@+id/btnWebcam"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:layout_marginVertical="8dp"
            android:text="Webcam" />

    </LinearLayout>

</LinearLayout>
```

#### Initializing the Meeting

After getting token and meetigId from `JoinActivity`,

1. Configure **VideoSDK** with token.
2. Initialize the meeting with required params such as `meetingId`, `participantName`, `micEnabled`, `webcamEnabled` and more.
3. Add `MeetingEventListener` for listening events such as **Meeting Join/Left** and **Participant Join/Left**.
4. Join the room with `meeting.join()` method.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js title="MeetingActivity.kt"
class MeetingActivity : AppCompatActivity() {
  // declare the variables we will be using to handle the meeting
  private var meeting: Meeting? = null
  private var micEnabled = true
  private var webcamEnabled = true

  override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    setContentView(R.layout.activity_meeting)

    val token = intent.getStringExtra("token")
    val meetingId = intent.getStringExtra("meetingId")
    val participantName = "John Doe"

    //highlight-next-line
    // 1. Configuration VideoSDK with Token
    VideoSDK.config(token)

    //highlight-next-line
    // 2. Initialize VideoSDK Meeting
    meeting = VideoSDK.initMeeting(
      this@MeetingActivity, meetingId, participantName,
      micEnabled, webcamEnabled, null, null, false, null, null)

    //highlight-next-line
    // 3. Add event listener for listening upcoming events
    meeting!!.addEventListener(meetingEventListener)

    //highlight-next-line
    //4. Join VideoSDK Meeting
    meeting!!.join()

    (findViewById<View>(R.id.tvMeetingId) as TextView).text = meetingId
  }

  //highlight-next-line
  // creating the MeetingEventListener
  private val meetingEventListener: MeetingEventListener = object : MeetingEventListener() {
    override fun onMeetingJoined() {
      Log.d("#meeting", "onMeetingJoined()")
    }

    override fun onMeetingLeft() {
      Log.d("#meeting", "onMeetingLeft()")
      meeting = null
      if (!isDestroyed) finish()
    }

    override fun onParticipantJoined(participant: Participant) {
      Toast.makeText(
        this@MeetingActivity, participant.displayName + " joined",
        Toast.LENGTH_SHORT
      ).show()
    }

    override fun onParticipantLeft(participant: Participant) {
      Toast.makeText(
         this@MeetingActivity, participant.displayName + " left",
         Toast.LENGTH_SHORT
      ).show()
    }
  }
}
```

</TabItem>

<TabItem value="Java">

```java title="MeetingActivity.java"
public class MeetingActivity extends AppCompatActivity {
  // declare the variables we will be using to handle the meeting
  private Meeting meeting;
  private boolean micEnabled = true;
  private boolean webcamEnabled = true;

  @Override
  protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_meeting);

    final String token = getIntent().getStringExtra("token");
    final String meetingId = getIntent().getStringExtra("meetingId");
    final String participantName = "John Doe";

    //highlight-next-line
    // 1. Configuration VideoSDK with Token
    VideoSDK.config(token);

    //highlight-next-line
    // 2. Initialize VideoSDK Meeting
    meeting = VideoSDK.initMeeting(
            MeetingActivity.this, meetingId, participantName,
            micEnabled, webcamEnabled, null, null, false, null, null);

    //highlight-next-line
    // 3. Add event listener for listening upcoming events
    meeting.addEventListener(meetingEventListener);

    //highlight-next-line
    //4. Join VideoSDK Meeting
    meeting.join();

    ((TextView)findViewById(R.id.tvMeetingId)).setText(meetingId);
  }

  //highlight-next-line
  // creating the MeetingEventListener
  private final MeetingEventListener meetingEventListener = new MeetingEventListener() {
    @Override
    public void onMeetingJoined() {
      Log.d("#meeting", "onMeetingJoined()");
    }

    @Override
    public void onMeetingLeft() {
      Log.d("#meeting", "onMeetingLeft()");
      meeting = null;
      if (!isDestroyed()) finish();
    }

    @Override
    public void onParticipantJoined(Participant participant) {
      Toast.makeText(MeetingActivity.this, participant.getDisplayName() + " joined", Toast.LENGTH_SHORT).show();
    }

    @Override
    public void onParticipantLeft(Participant participant) {
      Toast.makeText(MeetingActivity.this, participant.getDisplayName() + " left", Toast.LENGTH_SHORT).show();
    }
  };
}
```

</TabItem>

</Tabs>

### Step 4: Handle Local Participant Media

After successfully enter into the meeting, it's time to **enable/disable** local participant(You) webcam and mic, for that we will use `Meeting` class method `enableWebcam` / `disableWebcam` for camera and `muteMic` / `unmuteMic` for mic.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js title="MeetingActivity.kt"
class MeetingActivity : AppCompatActivity() {
  override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    setContentView(R.layout.activity_meeting)
    //...Meeting Setup is Here

    // actions
    setActionListeners()
  }

  private fun setActionListeners() {
    // toggle mic
    findViewById<View>(R.id.btnMic).setOnClickListener { view: View? ->
      if (micEnabled) {
        // this will mute the local participant's mic
        //highlight-next-line
        meeting!!.muteMic()
        Toast.makeText(this@MeetingActivity, "Mic Muted", Toast.LENGTH_SHORT).show()
      } else {
        // this will unmute the local participant's mic
        //highlight-next-line
        meeting!!.unmuteMic()
        Toast.makeText(this@MeetingActivity, "Mic Enabled", Toast.LENGTH_SHORT).show()
      }
        micEnabled=!micEnabled
    }

    // toggle webcam
    findViewById<View>(R.id.btnWebcam).setOnClickListener { view: View? ->
      if (webcamEnabled) {
        // this will disable the local participant webcam
        //highlight-next-line
        meeting!!.disableWebcam()
        Toast.makeText(this@MeetingActivity, "Webcam Disabled", Toast.LENGTH_SHORT).show()
      } else {
        // this will enable the local participant webcam
        //highlight-next-line
        meeting!!.enableWebcam()
        Toast.makeText(this@MeetingActivity, "Webcam Enabled", Toast.LENGTH_SHORT).show()
      }
       webcamEnabled=!webcamEnabled
    }

    // leave meeting
    findViewById<View>(R.id.btnLeave).setOnClickListener { view: View? ->
      // this will make the local participant leave the meeting
      //highlight-next-line
      meeting!!.leave()
    }
  }
}
```

</TabItem>

<TabItem value="Java">

```java title="MeetingActivity.java"
public class MeetingActivity extends AppCompatActivity {
  @Override
  protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_meeting);
    //...Meeting Setup is Here

    // actions
    setActionListeners();
  }

  private void setActionListeners() {
    // toggle mic
    findViewById(R.id.btnMic).setOnClickListener(view -> {
      if (micEnabled) {
        // this will mute the local participant's mic
        //highlight-next-line
        meeting.muteMic();
        Toast.makeText(MeetingActivity.this, "Mic Disabled", Toast.LENGTH_SHORT).show();
      } else {
        // this will unmute the local participant's mic
        //highlight-next-line
        meeting.unmuteMic();
        Toast.makeText(MeetingActivity.this, "Mic Enabled", Toast.LENGTH_SHORT).show();
      }
      micEnabled=!micEnabled;
    });

    // toggle webcam
    findViewById(R.id.btnWebcam).setOnClickListener(view -> {
      if (webcamEnabled) {
        // this will disable the local participant webcam
        //highlight-next-line
        meeting.disableWebcam();
        Toast.makeText(MeetingActivity.this, "Webcam Disabled", Toast.LENGTH_SHORT).show();
      } else {
        // this will enable the local participant webcam
        //highlight-next-line
        meeting.enableWebcam();
        Toast.makeText(MeetingActivity.this, "Webcam Enabled", Toast.LENGTH_SHORT).show();
      }
      webcamEnabled=!webcamEnabled;
    });

    // leave meeting
    findViewById(R.id.btnLeave).setOnClickListener(view -> {
      // this will make the local participant leave the meeting
      //highlight-next-line
      meeting.leave();
    });
  }
}
```

</TabItem>

</Tabs>

#### Output

<div style={{textAlign: 'center'}}>

<img style={{height: '200px'}} src="/img/quick-start/android_controls.jpeg" />

</div>

### Step 5: Handling the Participants View

We will be showing the list of participant in a `RecyclerView`.

:::info

- Here the participant's video is displayed using `VideoView`, but you may also use `SurfaceViewRender` for the same.
- For `VideoView`, SDK version should be `0.1.13` or higher.
- To know more about `VideoView`, please visit [here](/android/guide/video-and-audio-calling-api-sdk/render-media/display-video/understand-videoView-component)

:::

1. Create a new layout for the participant view named `item_remote_peer.xml` in the `res/layout` folder.

```xml title="item_remote_peer.xml"
<?xml version="1.0" encoding="utf-8"?>
<FrameLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="200dp"
    android:background="@color/cardview_dark_background"
    tools:layout_height="200dp">

    <live.videosdk.rtc.android.VideoView
        android:id="@+id/participantView"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:visibility="gone" />

    <LinearLayout
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:layout_gravity="bottom"
        android:background="#99000000"
        android:orientation="horizontal">

        <TextView
            android:id="@+id/tvName"
            android:layout_width="0dp"
            android:layout_height="wrap_content"
            android:layout_weight="1"
            android:gravity="center"
            android:padding="4dp"
            android:textColor="@color/white" />

    </LinearLayout>

</FrameLayout>
```

2. Create a recycler view adapter named `ParticipantAdapter` which will show the participant list. Create `PeerViewHolder` in the adapter which will extend `RecyclerView.ViewHolder`.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js title="ParticipantAdapter.kt"
class ParticipantAdapter(meeting: Meeting) : RecyclerView.Adapter<ParticipantAdapter.PeerViewHolder>() {

  override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): PeerViewHolder {
    return PeerViewHolder(
      LayoutInflater.from(parent.context)
        .inflate(R.layout.item_remote_peer, parent, false)
    )
  }

  override fun onBindViewHolder(holder: PeerViewHolder, position: Int) {
  }

  override fun getItemCount(): Int {
    return 0
  }

  class PeerViewHolder(view: View) : RecyclerView.ViewHolder(view) {
    // 'VideoView' to show Video Stream
    var participantView: VideoView
    var tvName: TextView

    init {
        tvName = view.findViewById(R.id.tvName)
        participantView = view.findViewById(R.id.participantView)
    }
  }
}
```

</TabItem>

<TabItem value="Java">

```java title="ParticipantAdapter.java"
public class ParticipantAdapter extends RecyclerView.Adapter<ParticipantAdapter.PeerViewHolder> {

  @NonNull
  @Override
  public PeerViewHolder onCreateViewHolder(@NonNull ViewGroup parent, int viewType) {
      return new PeerViewHolder(LayoutInflater.from(parent.getContext()).inflate(R.layout.item_remote_peer, parent, false));
  }

  @Override
  public void onBindViewHolder(@NonNull PeerViewHolder holder, int position) {
  }

  @Override
  public int getItemCount() {
      return 0;
  }

  static class PeerViewHolder extends RecyclerView.ViewHolder {
    // 'VideoView' to show Video Stream
    public VideoView participantView;
    public TextView tvName;
    public View itemView;

    PeerViewHolder(@NonNull View view) {
        super(view);
        itemView = view;
        tvName = view.findViewById(R.id.tvName);
        participantView = view.findViewById(R.id.participantView);
    }
  }
}
```

</TabItem>

</Tabs>

3. Now, we will render a list of `Participant` for the meeting.
   We will initialize this list in the constructor of the `ParticipantAdapter`

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js title="ParticipantAdapter.kt"
class ParticipantAdapter(meeting: Meeting) :
    RecyclerView.Adapter<ParticipantAdapter.PeerViewHolder>() {

  // creating a empty list which will store all participants
  private val participants: MutableList<Participant> = ArrayList()

  init {
    //highlight-next-line
    // adding the local participant(You) to the list
    participants.add(meeting.localParticipant)

    //highlight-next-line
    // adding Meeting Event listener to get the participant join/leave event in the meeting.
    meeting.addEventListener(object : MeetingEventListener() {
      override fun onParticipantJoined(participant: Participant) {
        // add participant to the list
        participants.add(participant)
        notifyItemInserted(participants.size - 1)
      }

      override fun onParticipantLeft(participant: Participant) {
        var pos = -1
        for (i in participants.indices) {
          if (participants[i].id == participant.id) {
            pos = i
            break
          }
        }
        // remove participant from the list
        participants.remove(participant)
        if (pos >= 0) {
          notifyItemRemoved(pos)
        }
      }
    })
  }

  // replace getItemCount() method with following.
  // this method returns the size of total number of participants
  override fun getItemCount(): Int {
    //highlight-next-line
    return participants.size
  }
  //...
}
```

</TabItem>

<TabItem value="Java">

```java title="ParticipantAdapter.java"
public class ParticipantAdapter extends RecyclerView.Adapter<ParticipantAdapter.PeerViewHolder> {

  // creating a empty list which will store all participants
  private final List<Participant> participants = new ArrayList<>();

  public ParticipantAdapter(Meeting meeting) {
    //highlight-next-line
    // adding the local participant(You) to the list
    participants.add(meeting.getLocalParticipant());

    //highlight-next-line
    // adding Meeting Event listener to get the participant join/leave event in the meeting.
    meeting.addEventListener(new MeetingEventListener() {
      @Override
      public void onParticipantJoined(Participant participant) {
        // add participant to the list
        participants.add(participant);
        notifyItemInserted(participants.size() - 1);
      }

      @Override
      public void onParticipantLeft(Participant participant) {
        int pos = -1;
        for (int i = 0; i < participants.size(); i++) {
          if (participants.get(i).getId().equals(participant.getId())) {
            pos = i;
            break;
          }
        }
        // remove participant from the list
        participants.remove(participant);

        if (pos >= 0) {
          notifyItemRemoved(pos);
        }
      }
    });
  }

  // replace getItemCount() method with following.
  // this method returns the size of total number of participants
  @Override
  public int getItemCount() {
    //highlight-next-line
    return participants.size();
  }
  //...
}
```

</TabItem>

</Tabs>

4. We have listed our participants. Let's set up the view holder to display a participant video.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js title="PartipantAdapter.kt"
class ParticipantAdapter(meeting: Meeting) :
    RecyclerView.Adapter<ParticipantAdapter.PeerViewHolder>() {

  // replace onBindViewHolder() method with following.
  override fun onBindViewHolder(holder: PeerViewHolder, position: Int) {
    val participant = participants[position]

    holder.tvName.text = participant.displayName

    // adding the initial video stream for the participant into the 'VideoView'
    for ((_, stream) in participant.streams) {
      if (stream.kind.equals("video", ignoreCase = true)) {
        holder.participantView.visibility = View.VISIBLE
        val videoTrack = stream.track as VideoTrack
        //highlight-next-line
        holder.participantView.addTrack(videoTrack)
        break
      }
    }

    // add Listener to the participant which will update start or stop the video stream of that participant
    participant.addEventListener(object : ParticipantEventListener() {
      override fun onStreamEnabled(stream: Stream) {
        if (stream.kind.equals("video", ignoreCase = true)) {
          holder.participantView.visibility = View.VISIBLE
          val videoTrack = stream.track as VideoTrack
          //highlight-next-line
          holder.participantView.addTrack(videoTrack)
       }
      }

      override fun onStreamDisabled(stream: Stream) {
        if (stream.kind.equals("video", ignoreCase = true)) {
          //highlight-next-line
          holder.participantView.removeTrack()
          holder.participantView.visibility = View.GONE
        }
      }
    })
  }
}
```

</TabItem>

<TabItem value="Java">

```java title="PartipantAdapter.java"
public class ParticipantAdapter extends RecyclerView.Adapter<ParticipantAdapter.PeerViewHolder> {

  // replace onBindViewHolder() method with following.
  @Override
  public void onBindViewHolder(@NonNull PeerViewHolder holder, int position) {
    Participant participant = participants.get(position);

    holder.tvName.setText(participant.getDisplayName());

    // adding the initial video stream for the participant into the 'VideoView'
    for (Map.Entry<String, Stream> entry : participant.getStreams().entrySet()) {
      Stream stream = entry.getValue();
      if (stream.getKind().equalsIgnoreCase("video")) {
        holder.participantView.setVisibility(View.VISIBLE);
        VideoTrack videoTrack = (VideoTrack) stream.getTrack();
        //highlight-next-line
        holder.participantView.addTrack(videoTrack)
        break;
      }
    }
    // add Listener to the participant which will update start or stop the video stream of that participant
    participant.addEventListener(new ParticipantEventListener() {
      @Override
      public void onStreamEnabled(Stream stream) {
        if (stream.getKind().equalsIgnoreCase("video")) {
          holder.participantView.setVisibility(View.VISIBLE);
          VideoTrack videoTrack = (VideoTrack) stream.getTrack();
          //highlight-next-line
          holder.participantView.addTrack(videoTrack)
        }
      }

      @Override
      public void onStreamDisabled(Stream stream) {
        if (stream.getKind().equalsIgnoreCase("video")) {
          //highlight-next-line
          holder.participantView.removeTrack();
          holder.participantView.setVisibility(View.GONE);
        }
      }
    });
  }
}
```

</TabItem>

</Tabs>

5. Add this adapter to the `MeetingActivity`

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js title="MeetingActivity.kt"
override fun onCreate(savedInstanceState: Bundle?) {
  //Meeting Setup...
  //...
  val rvParticipants = findViewById<RecyclerView>(R.id.rvParticipants)
  rvParticipants.layoutManager = GridLayoutManager(this, 2)
  rvParticipants.adapter = ParticipantAdapter(meeting!!)
}
```

</TabItem>

<TabItem value="Java">

```java title="MeetingActivity.java"
@Override
protected void onCreate(Bundle savedInstanceState) {
  //Meeting Setup...
  //...
  final RecyclerView rvParticipants = findViewById(R.id.rvParticipants);
  rvParticipants.setLayoutManager(new GridLayoutManager(this, 2));
  rvParticipants.setAdapter(new ParticipantAdapter(meeting));
}
```

</TabItem>

</Tabs>

:::tip

Stuck anywhere? Check out this [example code](https://github.com/videosdk-live/videosdk-rtc-android-java-sdk-example) on GitHub.

:::

## Final Output

We are done with implementation of customised video calling app in Android using Video SDK. To explore more features go through Basic and Advanced features.

import ReactPlayer from 'react-player'

<div style={{textAlign: 'center'}}>

<ReactPlayer muted controls url="https://cdn.videosdk.live/website-resources/docs-resources/android_quickstart.mp4" height="500px" width={"100%"} />

</div>

:::tip
You can checkout the complete [quick start example here](https://github.com/videosdk-live/quickstart/tree/main/android-rtc).
:::


---

---
title: Understanding Usage Quota Limits
hide_title: true
hide_table_of_contents: false
description: Explore VideoSDK quota limits and subscription plans. Learn how to optimize usage and choose the right plan for your video development needs.
sidebar_label: Understanding Usage Quota Limits
pagination_label: Understanding Usage Quota Limits
keywords:
  - videosdk plans
  - videosdk quota
  - videosdk limit
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: quotas-and-limit
---

import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>

## Understanding Usage Quota Limits - Android

In this documentation, you will find detailed information about the quotas associated with each plan, including usage limits for various features and functionalities. Understanding these quotas will help you optimize your usage, selecting the best pricing plan and make the most of your VideoSDK experience.

## How VideoSDK limits concurrent usage quota

VideoSDK's approach to limiting usage focuses on concurrent usage rather than overall usage. Concurrent usage refers to the number of participants or requests that can be hosted or processed simultaneously. 

For example, if there's a limit of 50 concurrent participants per organization, users can run multiple calls (sessions) simultaneously, with a maximum of 50 participants across all sessions combined.

## How to view my current plan’s quota limits?

To view the current quota limits on your organization, simply navigate to the [VideoSDK Dashboard](https://app.videosdk.live/), go to your Profile section, and click on the Billing tab.

## Free Plan

Since, we’ve designed Free Plan for developers who are just exploring, we’ve kept the limits that would get you started without a hitch.

Organisations on Free Plan have the following limits on concurrent usage:

| Feature | Concurrent Limit |
| --- | --- |
| Participants in Video Calls | 50 concurrent participants |
| Viewers in Live Streams | 100 concurrent viewers |
| Recording Request | 1 concurrent request at a time |
| HLS Encoding Request | 1 concurrent request at a time |
| RTMP-Out Request | 1 concurrent request at a time |

 
### How to increase my limits?

To increase your limits, simply upgrade your plan by providing billing details and credit card information.

## Pay-as-you-Go Plan

We've increased participant limits for this paid plan. This way, it won't significantly impact users heavily involved in production or integration.

Organisations on Pay-as-you-Go have the following limits on concurrent usage:

| Feature | Concurrent Limit |
| --- | --- |
| Participants in Video Calls | 100 concurrent participants |
| Viewers in Live Streams | 500 concurrent viewers |
| Recording Request | 5 concurrent request at a time |
| HLS Encoding Request | 5 concurrent request at a time |
| RTMP-Out Request | 5 concurrent request at a time |

### How to increase my limits?

To increase your limits further more, simply get in touch with us. [Contact us](https://www.videosdk.live/contact) directly or reach out via email at [support@videosdk.live](mailto:support@videosdk.live), and we'll handle the rest gladly.

## Enterprise Plan

For Enterprise users, all limits are tailored to the specific needs. Customised limits ensure optimal performance for your unique requirements.

To get started as an Enterprise user, simply get in touch with us, explain your requirements and use case, and we’ll customise the quota and limits according to your needs.

## Examples to understand concurrent limits

**Example #1**

Let's say you're using video callings (RTC) in your organization on the Free Plan. In this scenario, you can concurrently host up to 50 participants. However, the number of calls (sessions) you initiate is unrestricted.

To simplify, you can run multiple sessions simultaneously, but concurrently, you can only accommodate a maximum of 50 participants across all sessions. If a 51st participant attempts to join, they won't be able to access the session until you upgrade your plan to increase your participant limits.

**Example #2**

Let’s say you're using live streaming in your organization on the Free Plan. In this setup, you can concurrently host up to 100 viewers joining the sessions. While you have the flexibility to host multiple live streaming sessions, the number of viewers joining session concurrently is restricted.

**Example #3**

Lets say you’re using video callings (RTC) in your organization on the Pay-as-you-Go Plan and you're hosting 5 concurrent calls (sessions), all of which are being recorded. Now, when you initiate the 6th call (session) and request recording, VideoSDK will not process your recording request. Instead, it will throw an error because you've reached your recording request limit.

If you have any questions regarding quota limits and pricing plan, post in our [Discord community](https://discord.com/invite/Qfm8j4YAUJ), [contact us](https://www.videosdk.live/contact) directly, or reach out to us on [support@videosdk.live](mailto:support@videosdk.live).

---

---
title: Custom Template - Android
sidebar_position: 1
sidebar_label: Customize Recording UI
hide_table_of_contents: false
---

import CustomTemplate from '../../../../../mdx/\_custom-template.mdx';

<CustomTemplate title="Custom Template With Recording"/>


---

---
title: Geo Tag Meeting recordings - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: Geo Tag meeting recordings feature quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Geo Tag Recording
pagination_label: Geo Tag Recording
keywords:
  - Start Recording meeting
  - Stop Recording meeting
  - audio calling
  - video calling
  - geo tag
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: geo-tag-recording
---

# Geo Tag Meeting Recordings - Android

To ensure compliance for BFSIs doing vKYC, it very important to include the co-ordinates(location) of the customer in the recordings. VideoSDK provides a very customizable solution to implement this feature. You will be using custom templates for this purpose.

We have created a ready to use template for this use case which can be found [here](https://github.com/videosdk-live/videosdk-rtc-react-prebuilt-ui/tree/template/geo-tag-watermark). To integrate this template with your recordings follow the below mentiond instructions.

### Host the template

1. Clone the template repository and switch to the branch `template/geo-tag-watermark`.

```bash
git clone https://github.com/videosdk-live/videosdk-rtc-react-prebuilt-ui.git
cd videosdk-rtc-react-prebuilt-ui
git checkout template/geo-tag-watermark
```

2. Install the dependencies and create a build of the project using below mentioned commands.

```bash
npm install
npm run build
```

3. Host the contents of the build folder on your server and check if the template is up and running.

:::note

If you want to create the complete template from scratch you can [follow this guide.](./custom-template.md)

:::

### Using the template for recording

1. To use the template that we deployed earlier, we will be using the `templateUrl` feature in the `startRecording` API.
   To generate the template URL, you will have to append the `meetingId`, and `token` has to be added in the query parameters. Also if you are using the template provided above you need to added a few extra paramters mentioned below. Here is the code snippet to generate the URL.

```js
async function main() {
  let meetingId = "Your MeetingID";
  let token = "Your Token";
  const templateUrl = `https://${YOUR Template URL}/?meetingId=${meetingId}&token=${token}&name=recorder&isRecorder=true&joinWithoutUserInteraction=true`;

  console.log(templateUrl);
}

main();
```

2. Now that we have the template URL, we will use this URL to start the recording using the below provided API call.

```js
async function main() {
  let meetingId = "Your MeetingID";
  let token = "Your Token";
  const templateUrl = `https://${YOUR Template URL}/?meetingId=${meetingId}&token=${token}&name=recorder&isRecorder=true&joinWithoutUserInteraction=true`;

  console.log(templateUrl);

  //Using the previouly created template URL and starting the recording using the API.
  const options = {
    method: "POST",
    headers: {
      Authorization: "$YOUR_TOKEN",
      "Content-Type": "application/json",
    },
    body: JSON.stringify({
      roomId: "Your MeetingId",
      templateUrl: templateUrl,
    }),
  };
  const url = `https://api.videosdk.live/v2/recordings/start`;
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
}

main();
```

### Updating the Geo Tagging Coordinates

We will be using the PubSub feature of VideoSDK to update the data of latitude and longitude. For the predefined template provided by us we are using `GEO_TAG` as topic name. We will be publishing the `participantName`, `latitude` and `longitude` of the participant for whom we want to show in the recording.

:::note

You will have to fetch the longitude and latitude of the participant before sending it using the pubsub.

:::

Here is the code how you will have to publish the message:

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
private fun sendMessage() {
  // publish message
  val options = PubSubPublishOptions()
  options.isPersist = true
  val geoTagData = JSONObject()
  JsonUtils.jsonPut(geoTagData, "latitude", "PARTICIPANT LATITUDE")
  JsonUtils.jsonPut(geoTagData, "longitude", "PARTICIPANT LONGITUDE")
  JsonUtils.jsonPut(geoTagData, "participantName", "PARTICIPANT NAME")

  //highlight-next-line
  meeting!!.pubSub.publish("GEO_TAG", "GEO_TAG_DATA", options, geoTagData)
}
```

</TabItem>

<TabItem value="Java">

```js
protected void sendMessage() {
  // publish message
  PubSubPublishOptions options = new PubSubPublishOptions();
  options.setPersist(true);
  JSONObject geoTagData = JSONObject()
  JsonUtils.jsonPut(geoTagData, "latitude", "YOUR LATITUDE")
  JsonUtils.jsonPut(geoTagData, "longitude", "YOUR LONGITUDE")
  JsonUtils.jsonPut(geoTagData, "participantName", "PARTICIPANT NAME")
  //highlight-next-line
  meeting.pubSub.publish("GEO_TAG", "GEO TAG DATA", options, geoTagData);
}
```

</TabItem>

</Tabs>

After implementing this, you should get the recording in the following format:

![Geo Tagging Recoridng](https://cdn.videosdk.live/website-resources/docs-resources/geo-tag-recording-template.png)

If you wish to change how UI looks on recording, you can change it by updating the layout in the template itself.

### API Reference

The API references for all the methods utilized in this guide are provided below.

- [Start Recording API](/api-reference/realtime-communication/start-recording)
- [Learn more about Custom Templates](./custom-template.md)


---

---
title: Recording Overview - Android
hide_title: false
hide_table_of_contents: false
description: Record Meeting features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Overview
pagination_label: Overview
keywords:
  - Overview
  - Start Recording meeting
  - Stop Recording meeting
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: Overview
---

import Overview from '../../../../../mdx/\_recording-overview.mdx';

<Overview title="Recording Overview"/>


---

---
title: Generate presigned URL - Android
hide_title: false
hide_table_of_contents: false
description: presigned URL features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Generate presigned URL
pagination_label: Generate presigned URL
keywords:
  - Start Recording meeting
  - Stop Recording meeting
  - audio calling
  - video calling
  - real-time communication
  - presigned URL
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: presigned-URL
---

import PreSignedUrl from '../../../../../mdx/\_presigned-url.mdx';

<PreSignedUrl title="Generate presigned URL - Android"/>


---

---
title: Record Meeting Video & Audio Call - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: Record Meeting features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Start and Stop
pagination_label: Start and Stop
keywords:
  - Start Recording meeting
  - Stop Recording meeting
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: record-meeting
---

# Start and Stop - Android

This guide will provide an overview of how to implement start and stop Meeting Recording.

### `startRecording()`

`startRecording()` can be used to start a recording of the meeting which can be accessed from the `Meeting` class. This method accepts four parameters:

- `1. webhookUrl`: This would the webhook URL where you would like to listen to event happening for the recording like starting and stopping of recording. It will be triggered when the recording is completed and stored into server. Read more about webhooks [here](https://en.wikipedia.org/wiki/Webhook)

- `2. awsDirPath`: This parameter accepts the path for the your S3 bucket where you want to store recordings to. To allow us to store recording in your S3 bucket, you will need to fill this form by providing the required values. ([VideoSDK Cloud (AWS S3, Azure Blob or GCP ) Integration](/android/guide/video-and-audio-calling-api-sdk/recording/recording-storage-config))

- `3. config`: This parameter will define how the meeting should be recorded.

- `4. transcription`: This parameter lets you start post transcription for the recording.

:::note

If you don't have a value for `webhookUrl`,`awsDirPath` or `config`, you should pass `null` in place of the missing value. If you pass `null` in `awsDirPath` parameter then by default recordings will be store on the VideoSDK's storage.
:::

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
val config = JSONObject()

//highlight-next-line
// Layout Configuration
val layout = JSONObject()
JsonUtils.jsonPut(layout, "type", "GRID") // "SPOTLIGHT" | "SIDEBAR",  Default : "GRID"
JsonUtils.jsonPut(layout, "priority", "SPEAKER") // "PIN", Default : "SPEAKER"
JsonUtils.jsonPut(layout, "gridSize", 4) // MAX : 4
JsonUtils.jsonPut(config, "layout", layout)

//highlight-next-line
// Theme of recording
JsonUtils.jsonPut(config, "theme", "DARK") //  "LIGHT" | "DEFAULT"

//highlight-next-line
// `mode` is used to either record video & audio both or only audio.
JsonUtils.jsonPut(config, "mode", "video-and-audio") // "audio", Default : "video-and-audio"

//highlight-next-line
// Quality of recording and is only applicable to `video-and-audio` type mode.
JsonUtils.jsonPut(config, "quality", "high") // "low" | "med",  Default : "med"

//highlight-start
// This mode refers to orientation of recording.
// landscape : Record the meeting in horizontally
// portrait : Record the meeting in vertically (Best for mobile view)
//highlight-end
JsonUtils.jsonPut(config, "orientation", "portrait") // "landscape",  Default : "landscape"

//highlight-next-line
// Post Transcription Configuration
val prompt = "Write summary in sections like Title, Agenda, Speakers, Action Items, Outlines, Notes and Summary"
val summaryConfig = SummaryConfig(true, prompt)
val modelId = "raman_v1"
val transcription = PostTranscriptionConfig(true, summaryConfig, modelId)

meeting.startRecording(null, null, config, transcription)
```

</TabItem>

<TabItem value="Java">

```js
JSONObject config = new JSONObject();

//highlight-next-line
// Layout Configuration
JSONObject layout = new JSONObject();
JsonUtils.jsonPut(layout, "type", "GRID"); // "SPOTLIGHT" | "SIDEBAR",  Default : "GRID"
JsonUtils.jsonPut(layout, "priority", "SPEAKER");  // "PIN", Default : "SPEAKER"
JsonUtils.jsonPut(layout, "gridSize", 4); // MAX : 4
JsonUtils.jsonPut(config, "layout", layout);

//highlight-next-line
// Theme of recording
JsonUtils.jsonPut(config, "theme", "DARK"); //  "LIGHT" | "DEFAULT"

//highlight-next-line
// `mode` is used to either record video & audio both or only audio.
JsonUtils.jsonPut(config, "mode", "video-and-audio"); // "audio", Default : "video-and-audio"

//highlight-next-line
// Quality of recording and is only applicable to `video-and-audio` type mode.
JsonUtils.jsonPut(config, "quality", "high"); // "low" | "med",  Default : "med"

//highlight-start
// This mode refers to orientation of recording.
// landscape : Record the meeting in horizontally
// portrait : Record the meeting in vertically (Best for mobile view)
//highlight-end
JsonUtils.jsonPut(config, "orientation", "portrait"); // "landscape",  Default : "landscape"

//highlight-next-line
// Post Transcription Configuration
String prompt = "Write summary in sections like Title, Agenda, Speakers, Action Items, Outlines, Notes and Summary";
SummaryConfig summaryConfig = new SummaryConfig(true, prompt);
String modelId = "raman_v1";
PostTranscriptionConfig transcription = new PostTranscriptionConfig(true, summaryConfig, modelId);

meeting.startRecording(null, null, config, transcription);
```

</TabItem>

</Tabs>

### `stopRecording()`

- `stopRecording()` is used to stop the meeting recording which can be accessed from the `Meeting` class.

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
// keep track of recording
val recording = false

findViewById<View>(R.id.btnRecording).setOnClickListener { view: View? ->
    if (!recording) {
      //highlight-start
      val config = JSONObject()
      val layout = JSONObject()
      JsonUtils.jsonPut(layout, "type", "GRID")
      JsonUtils.jsonPut(layout, "priority", "SPEAKER")
      JsonUtils.jsonPut(layout, "gridSize", 4)
      JsonUtils.jsonPut(config, "layout", layout)
      JsonUtils.jsonPut(config, "theme", "DARK")
      JsonUtils.jsonPut(config, "mode", "video-and-audio")
      JsonUtils.jsonPut(config, "quality", "high")
      JsonUtils.jsonPut(config, "orientation", "portrait")
      //highlight-end

      //highlight-next-line
      // Post Transcription Configuration
      val prompt = "Write summary in sections like Title, Agenda, Speakers, Action Items, Outlines, Notes and Summary"
      val summaryConfig = SummaryConfig(true, prompt)
      val modelId = "raman_v1"
      val transcription = PostTranscriptionConfig(true, summaryConfig, modelId)

      // Start Recording
      // If you don't have a `webhookUrl` or `awsDirPath`, you should pass null.
      // If you don't want to enable transcription, you can pass null as parameter.
      //highlight-next-line
      meeting!!.startRecording("YOUR WEB HOOK URL", "AWS Directory Path", config, transcription)
    } else {
      // Stop Recording
      //highlight-next-line
      meeting!!.stopRecording()
    }
}
```

</TabItem>

<TabItem value="Java">

```js
// keep track of recording
boolean recording = false;

findViewById(R.id.btnRecording).setOnClickListener(view -> {
    if (!recording) {
      //highlight-start
      JSONObject config = new JSONObject();
      JSONObject layout = new JSONObject();
      JsonUtils.jsonPut(layout, "type", "GRID");
      JsonUtils.jsonPut(layout, "priority", "SPEAKER");
      JsonUtils.jsonPut(layout, "gridSize", 4);
      JsonUtils.jsonPut(config, "layout", layout);
      JsonUtils.jsonPut(config, "theme", "DARK");
      JsonUtils.jsonPut(config, "mode", "video-and-audio");
      JsonUtils.jsonPut(config, "quality", "high");
      JsonUtils.jsonPut(config, "orientation", "portrait");
      //highlight-end

      //highlight-next-line
      // Post Transcription Configuration
      String prompt = "Write summary in sections like Title, Agenda, Speakers, Action Items, Outlines, Notes and Summary";
      SummaryConfig summaryConfig = new SummaryConfig(true, prompt);
      String modelId = "raman_v1";
      PostTranscriptionConfig transcription = new PostTranscriptionConfig(true, summaryConfig, modelId);

      // Start Recording
      // If you don't have a `webhookUrl` or `awsDirPath`, you should pass null.
      // If you don't want to enable transcription, you can pass null as parameter.
      //highlight-next-line
      meeting.startRecording("YOUR WEB HOOK URL", "AWS Directory Path", config, transcription);
    } else {
      // Stop Recording
      //highlight-next-line
      meeting.stopRecording();
    }
});
```

</TabItem>

</Tabs>

:::important

To initiate automatic recording at the beginning of a `session`, simply provide the `autoStartConfig` feature `recording` during `room` creation. For more information on configuring the `autoStartConfig`, please refer to the provided documentation **[<u>here</u>](/api-reference/realtime-communication/create-room#autoStartConfig)**.

:::

### API Reference

The API references for all the methods utilised in this guide are provided below.

- [startRecording()](/android/api/sdk-reference/meeting-class/methods#startrecording)
- [stopRecording()](/android/api/sdk-reference/meeting-class/methods#stoprecording)
- [onRecordingStateChanged](/android/api/sdk-reference/meeting-class/meeting-event-listener-class#onrecordingstatechanged)
- [autoStartConfig](/api-reference/realtime-communication/create-room#autoStartConfig)


---

---
title: Participant Recording (Individual) - Android
hide_title: false
hide_table_of_contents: false
description: Individual participant recording features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Participant Recording (Individual)
pagination_label: Participant Recording
keywords:
  - Start Participant Recording
  - Stop Participant Recording
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: record-participant
---

import RecordParticipant from '../../../../../mdx/\_intro-participant-recording.mdx';
import WebhookParticipantRecording from '../../../../../mdx/\_webhook-participant-recording.mdx';

<RecordParticipant title="Record Participant"/>

## Start Individual Participant Recording

To start a participant recording, you will have to call `/v2/recordings/participant/start` API with following body parameters.

- `roomId`: RoomId for which the participant recording is to be started
- `participantId`: participantId of the participant to be recorder.
- `fileFormat`: Currently only `webm` is supported as file format. We will add the support for other formats in future.
- `webhookUrl`: The webhook URL where you would like to get the status updates of the recording. To learn more about webhooks refer [here](#participant-track-recording-starting).
- `bucketDirPath`: If you are using your own storage, you can provide the directory path where you want to store the recording. To configure the storage please [refere this quide](/javascript/guide/video-and-audio-calling-api-sdk/recording/recording-storage-config).

The usual recording path would look like `${sessionId}/${participantId}/${filename}`.

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'}]}>

<TabItem value="Kotlin">

```kotlin
import org.json.JSONObject
import java.io.OutputStream
import java.net.HttpURLConnection
import java.net.URL
import java.io.IOException

fun StartParticipantRecording() {
    val roomId = "<YOUR ROOM ID>"
    val participantId = "<PARTICIPANT ID>"
    val fileFormat = "<YOUR FILE FORMAT>" // (Optional) default: webm
    val bucketDirPath = "<YOUR CLOUD STORAGE BUCKET PATH>" // (Optional) test/abc
    val webhookUrl = "<YOUR WEBHOOK URL>" // (Optional)

    try {
        val url = URL("https://api.videosdk.live/v2/recordings/participant/start")
        val conn = url.openConnection() as HttpURLConnection
        conn.requestMethod = "POST"
        conn.setRequestProperty("Authorization", "$YOUR_TOKEN")
        conn.setRequestProperty("Content-Type", "application/json")
        conn.doOutput = true

        val json = JSONObject()
        json.put("roomId", roomId)
        json.put("participantId", participantId)
        json.put("fileFormat", fileFormat)
        json.put("bucketDirPath", bucketDirPath)
        json.put("webhookUrl", webhookUrl)

        conn.outputStream.use { os: OutputStream ->
            val input = json.toString().toByteArray(Charsets.UTF_8)
            os.write(input, 0, input.size)
        }

        val responseCode = conn.responseCode
        if (responseCode == HttpURLConnection.HTTP_OK) {
            println("Participant Recording started successfully.")
        } else {
            println("Failed to start participant recording.")
        }
    } catch (e: Exception) {
        e.printStackTrace()
    }
}

```

</TabItem>

<TabItem value="Java">

```java
import java.io.OutputStream;
import java.net.HttpURLConnection;
import java.net.URL;
import org.json.JSONObject;

private void StartParticipantRecording() {
    String roomId = "<YOUR ROOM ID>";
    String participantId = "<PARTICIPANT ID>";
    String fileFormat = "<YOUR FILE FORMAT>"; // (Optional) default: webm
    String bucketDirPath = "<YOUR CLOUD STORAGE BUCKET PATH>"; // (Optional) test/abc
    String webhookUrl = "<YOUR WEBHOOK URL>"; // (Optional)

    try {
        URL url = new URL("https://api.videosdk.live/v2/recordings/participant/start");
        HttpURLConnection conn = (HttpURLConnection) url.openConnection();
        conn.setRequestMethod("POST");
        conn.setRequestProperty("Authorization", "$YOUR_TOKEN");
        conn.setRequestProperty("Content-Type", "application/json");
        conn.setDoOutput(true);

        JSONObject json = new JSONObject();
        json.put("roomId", roomId);
        json.put("participantId", participantId);
        json.put("fileFormat", fileFormat);
        json.put("bucketDirPath", bucketDirPath);
        json.put("webhookUrl", webhookUrl);

        try (OutputStream os = conn.getOutputStream()) {
            byte[] input = json.toString().getBytes("utf-8");
            os.write(input, 0, input.length);
        }

        int responseCode = conn.getResponseCode();
        if (responseCode == HttpURLConnection.HTTP_OK) {
            System.out.println("Participant Recording started successfully.");
        } else {
            System.out.println("Failed to start participant recording.");
        }
    } catch (Exception e) {
        e.printStackTrace();
    }
}

```

</TabItem>

</Tabs>

## Stop Individual Participant Recording

To stop a participant recording, you will have to call `/v2/recordings/participant/stop` API with following body parameters.

- `roomId`: RoomId for which the participant recording is to be stopped
- `participantId`: participantId for which the recording is to be stopped.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```kotlin
import org.json.JSONObject
import java.io.OutputStream
import java.net.HttpURLConnection
import java.net.URL

fun StopParticipantRecording() {
val roomId = "<YOUR ROOM ID>"
val participantId = "<PARTICIPANT ID>"

    try {
        val url = URL("https://api.videosdk.live/v2/recordings/participant/stop")
        val conn = url.openConnection() as HttpURLConnection
        conn.requestMethod = "POST"
        conn.setRequestProperty("Authorization", "$YOUR_TOKEN")
        conn.setRequestProperty("Content-Type", "application/json")
        conn.doOutput = true

        val json = JSONObject()
        json.put("roomId", roomId)
        json.put("participantId", participantId)

        conn.outputStream.use { os: OutputStream ->
            val input = json.toString().toByteArray(Charsets.UTF_8)
            os.write(input, 0, input.size)
        }

        val responseCode = conn.responseCode
        if (responseCode == HttpURLConnection.HTTP_OK) {
            println("Participant Recording stopped successfully.")
        } else {
            println("Failed to stop participant recording.")
        }
    } catch (e: Exception) {
        e.printStackTrace()
    }

}

```

</TabItem>

<TabItem value="Java">

```java
import java.io.OutputStream;
import java.net.HttpURLConnection;
import java.net.URL;
import org.json.JSONObject;

private void StopParticipantRecording() {
    String roomId = "<YOUR ROOM ID>";
    String participantId = "<PARTICIPANT ID>";

    try {
        URL url = new URL("https://api.videosdk.live/v2/recordings/participant/stop");
        HttpURLConnection conn = (HttpURLConnection) url.openConnection();
        conn.setRequestMethod("POST");
        conn.setRequestProperty("Authorization", "$YOUR_TOKEN");
        conn.setRequestProperty("Content-Type", "application/json");
        conn.setDoOutput(true);

        JSONObject json = new JSONObject();
        json.put("roomId", roomId);
        json.put("participantId", participantId);

        try (OutputStream os = conn.getOutputStream()) {
            byte[] input = json.toString().getBytes("utf-8");
            os.write(input, 0, input.length);
        }

        int responseCode = conn.getResponseCode();
        if (responseCode == HttpURLConnection.HTTP_OK) {
            System.out.println("Participant Recording stopped successfully.");
        } else {
            System.out.println("Failed to stop participant recording.");
        }
    } catch (Exception e) {
        e.printStackTrace();
    }
}


```

</TabItem>

</Tabs>

<WebhookParticipantRecording title="Webhooks"/>


---

---
title: Participant Track Recording - Android
hide_title: false
hide_table_of_contents: false
description: Participant track recording features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Participant Track Recording
pagination_label: Participant Track Recording
keywords:
  - Start Track Recording
  - Start Track Recording
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: record-track
---

import RecordTrack from '../../../../../mdx/\_intro-track-recording.mdx';
import WebhookTrackRecording from '../../../../../mdx/\_webhook-track-recording.mdx';

<RecordTrack title="Record Track"/>

## Start Participant Track Recording

To start a participant track recording, you will have to call `/v2/recordings/participant/track/start` API with following body parameters.

- `roomId`: RoomId for which the participant track recording is to be started
- `participantId`: participantId of the participant to be recorder.
- `kind`: The kind of tracks you want to record.
  - You can pass following values: _`audio`_ | _`video`_ | _`screen_audio`_ | _`screen_video`_
- `fileFormat`: Currently only `webm` is supported as file format. We will add the support for other formats in future.
- `webhookUrl`: The webhook URL where you would like to get the status updates of the recording. To learn more about webhooks refer [here](#participant-track-recording-starting).
- `bucketDirPath`: If you are using your own storage, you can provide the directory path where you want to store the recording. To configure the storage please [refere this quide](/javascript/guide/video-and-audio-calling-api-sdk/recording/recording-storage-config).

The usual recording path would look like `${sessionId}/${participantId}/${kind}/${filename}`.

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'}]}>

<TabItem value="Kotlin">

```kotlin
import org.json.JSONObject
import java.io.OutputStream
import java.net.HttpURLConnection
import java.net.URL
import java.io.IOException

fun StartTrackRecording() {
    val roomId = "<YOUR ROOM ID>"
    val participantId = "<PARTICIPANT ID>"
    val kind = "<YOUR STREAM KIND>"
    val fileFormat = "<YOUR FILE FORMAT>"
    val bucketDirPath = "<YOUR CLOUD STORAGE BUCKET PATH>"
    val webhookUrl = "<YOUR WEBHOOK URL>"

    try {
        val url = URL("https://api.videosdk.live/v2/recordings/participant/track/start")
        val conn = url.openConnection() as HttpURLConnection
        conn.requestMethod = "POST"
        conn.setRequestProperty("Authorization", "$YOUR_TOKEN")
        conn.setRequestProperty("Content-Type", "application/json")
        conn.doOutput = true

        val jsonBody = JSONObject()
        jsonBody.put("roomId", roomId)
        jsonBody.put("participantId", participantId)
        jsonBody.put("kind", kind)
        jsonBody.put("fileFormat", fileFormat)
        jsonBody.put("bucketDirPath", bucketDirPath)
        jsonBody.put("webhookUrl", webhookUrl)

        conn.outputStream.use { os: OutputStream ->
            val input = json.toString().toByteArray(Charsets.UTF_8)
            os.write(input, 0, input.size)
        }

        val responseCode = conn.responseCode
        if (responseCode == HttpURLConnection.HTTP_OK) {
            println("Track Recording started successfully.")
        } else {
            println("Failed to start track recording.")
        }
    } catch (e: Exception) {
        e.printStackTrace()
    }
}



```

</TabItem>

<TabItem value="Java">

```java
import java.io.OutputStream;
import java.net.HttpURLConnection;
import java.net.URL;
import org.json.JSONObject;

public void StartTrackRecording() {
    String roomId = "<YOUR ROOM ID>";
    String participantId = "<PARTICIPANT ID>";
    String kind = "<YOUR STREAM KIND>";
    String fileFormat = "<YOUR FILE FORMAT>";
    String bucketDirPath = "<YOUR CLOUD STORAGE BUCKET PATH>";
    String webhookUrl = "<YOUR WEBHOOK URL>";

    try {
        URL url = new URL("https://api.videosdk.live/v2/recordings/participant/track/start");
        HttpURLConnection conn = (HttpURLConnection) url.openConnection();
        conn.setRequestMethod("POST");
        conn.setRequestProperty("Authorization", "$YOUR_TOKEN");
        conn.setRequestProperty("Content-Type", "application/json");
        conn.setDoOutput(true);

        JSONObject jsonBody = new JSONObject();
        jsonBody.put("roomId", roomId);
        jsonBody.put("participantId", participantId);
        jsonBody.put("kind", kind);
        jsonBody.put("fileFormat", fileFormat);
        jsonBody.put("bucketDirPath", bucketDirPath);
        jsonBody.put("webhookUrl", webhookUrl);

        try (OutputStream os = conn.getOutputStream()) {
        byte[] input = json.toString().getBytes("utf-8");
        os.write(input, 0, input.length);
        }

        int responseCode = conn.getResponseCode();
        if (responseCode == HttpURLConnection.HTTP_OK) {
            System.out.println("Track Recording started successfully.");
        } else {
            System.out.println("Failed to start track recording.");
        }
    } catch (Exception e) {
        e.printStackTrace();
    }
}

```

</TabItem>

</Tabs>

## Stop Participant Track Recording

To stop a participant track recording, you will have to call `/v2/recordings/participant/track/stop` API with following body parameters.

- `roomId`: RoomId for which the participant track recording is to be stopped
- `participantId`: participantId for which the recording is to be stopped.
- `kind`: The kind of track recording you want to stop for the given participant.
  - You can pass following values: _`audio`_ | _`video`_ | _`screen_audio`_ | _`screen_video`_

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```kotlin
import org.json.JSONObject
import java.io.OutputStream
import java.net.HttpURLConnection
import java.net.URL

fun StopTrackRecording() {
    val roomId = "<YOUR ROOM ID>"
    val participantId = "<PARTICIPANT ID>"
    val kind = "<YOUR STREAM KIND>"

    try {
        val url = URL("https://api.videosdk.live/v2/recordings/participant/track/stop")
        val conn = url.openConnection() as HttpURLConnection
        conn.requestMethod = "POST"
        conn.setRequestProperty("Authorization", "$YOUR_TOKEN")
        conn.setRequestProperty("Content-Type", "application/json")
        conn.doOutput = true

        val jsonBody = JSONObject()
        jsonBody.put("roomId", roomId)
        jsonBody.put("participantId", participantId)
        jsonBody.put("kind", kind)

        conn.outputStream.use { os: OutputStream ->
            val input = json.toString().toByteArray(Charsets.UTF_8)
            os.write(input, 0, input.size)
        }

        val responseCode = conn.responseCode
        if (responseCode == HttpURLConnection.HTTP_OK) {
            println("Track Recording stopped successfully.")
        } else {
            println("Failed to stop track recording.")
        }
    } catch (e: Exception) {
        e.printStackTrace()
    }
}

```

</TabItem>

<TabItem value="Java">

```java
import java.io.OutputStream;
import java.net.HttpURLConnection;
import java.net.URL;
import org.json.JSONObject;

public void StopTrackRecording() {
    String roomId = "<YOUR ROOM ID>";
    String participantId = "<PARTICIPANT ID>";
    String kind = "<YOUR STREAM KIND>";


    try {
        URL url = new URL("https://api.videosdk.live/v2/recordings/participant/track/stop");
        HttpURLConnection conn = (HttpURLConnection) url.openConnection();
        conn.setRequestMethod("POST");
        conn.setRequestProperty("Authorization", "$YOUR_TOKEN");
        conn.setRequestProperty("Content-Type", "application/json");
        conn.setDoOutput(true);

        JSONObject jsonBody = new JSONObject();
        jsonBody.put("roomId", roomId);
        jsonBody.put("participantId", participantId);
        jsonBody.put("kind", kind);

        try (OutputStream os = conn.getOutputStream()) {
        byte[] input = json.toString().getBytes("utf-8");
        os.write(input, 0, input.length);
        }

        int responseCode = conn.getResponseCode();
        if (responseCode == HttpURLConnection.HTTP_OK) {
            System.out.println("Track Recording stopped successfully.");
        } else {
            System.out.println("Failed to stop track recording.");
        }
    } catch (Exception e) {
        e.printStackTrace();
    }
}

```

</TabItem>

</Tabs>

<WebhookTrackRecording title="Webhooks" />


---

---
title: Configure Recording Storage - Android
hide_title: false
hide_table_of_contents: false
sidebar_label: Configure Recording Storage
sidebar_position: 1
pagination_label: Configure Recording Storage
keywords:
  - configure recording storage
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
slug: recording-storage-config
---

### Storage Configuration

While recording your meetings, you have the flexibility to store them either on VideoSDK's storage or configure your own storage solution such as **`AWS S3 Storage, Azure Blob or GCP Cloud Storage`**. To set up your own storage, you can navigate to the [API section](https://app.videosdk.live/api-keys) in the VideoSDK Dashboard.

- This feature allows you to configure storage provider for your meeting recordings.

- You can configure multiple storage provider with multiple API Keys.

- Currently, we support `AWS S3`, `Azure Blob` and `GCP Cloud Storage`. We will add support for other storage provider soon !!

## Prerequisites

- An active [VideoSDK Developer Account](https://app.videosdk.live)
- `Aws S3`, `Azure Blob Storage` or `GCP Cloud Storage` Credentials

## How to setup ?

### Step 1 : Select Api Key

![Dashboard](/img/tutorial/dashboard/api-key-dashboard.png)

- Go to [VideoSDK Dashboard](https://app.videosdk.live/api-keys).
- Select API Key for which, you want to set storage configuration.
- Then click on `Storage Config` Icon in Actions.

### Step 2 : Choose Cloud Storage Provider

![Dashboard](/img/tutorial/dashboard/storage-config.png)

- As you can see in the image, there are 3 Cloud Storage Provider (`Aws`, `Azure`, `GCP`).
- You can select a Cloud Storage Provider as per your requirements.

### Step 3 : Configure Bucket or Container

<h4> For Aws S3 Storage </h4>

![Aws S3](/img/tutorial/dashboard/s3.png)

- You will need AWS S3 Bucket. [Learn to create S3 Bucket](https://docs.aws.amazon.com/AmazonS3/latest/userguide/creating-bucket.html).

- As you can see in the image, you will need enter `accessKeyId`, `secretAccessKey`, `region`, `bucket`, and `ACL` to setup for Aws S3 Storage.

- Click on `Save` button.

<hr />

<h4> For Azure Blob Storage: </h4>

![Azure Blob](/img/tutorial/dashboard/blob.png)

- You will need Azure Blob Container. [Learn to create Blob Container](https://docs.microsoft.com/en-us/azure/storage/blobs/storage-quickstart-blobs-portal#create-a-container).

- As you can see in the image, you will need to enter `connectionString` and `containerName` to setup for Azure Blob.

- Click on `Save` button.

<hr />

<h4> For Google Cloud Storage: </h4>

<img src="/img/tutorial/dashboard/gcp.png" alt="GCP Cloud Storage" width="436" height="632"/>

1. You will need Google Cloud Storage Bucket. [Learn to create Google Cloud Storage Bucket](https://cloud.google.com/storage/docs/creating-buckets).

2. After creation, click on the <b> &#xFE19; </b>button in the upper right corner and select **`Project settings`**.

3. Under **`IAM and Admin`**, select **`Service Accounts`**. In the service account list, click on the <b> &#xFE19; </b> button for the account just added or created before, and select **`Manage keys`**.

4. Click **`ADD KEY > Create new key`**. Select **`JSON`** in the pop-up box and click **`CREATE`**. A json file is downloaded with the name format `projectId-xxxxxxxx.json`.

5. Open the downloaded json file, which looks like the following example:

```
{
  "type": "service_account",
  "project_id": "videosdk-12345",
  "private_key_id": "yourprivateidkeyyourprivateidkeyyourprivateidkey",
  "private_key": "-----BEGIN PRIVATE KEY-----\nThisisYourPrivateKeyThisisYourPrivateKeyThisisYourPrivateKey\nThisisYourPrivateKey\nThisisYourPrivateKey\nThisisYourPrivateKey\n-----END PRIVATE KEY-----\n",
  "client_email": "xxxx-xxxx@videosdk-12345.iam.gserviceaccount.com",
  "client_id": "123456789012345678901",
  "auth_uri": "https://accounts.google.com/o/oauth2/auth",
  "token_uri": "https://oauth2.googleapis.com/token",
  "auth_provider_x509_cert_url": "https://www.googleapis.com/oauth2/v1/certs",
  "client_x509_cert_url": "https://www.googleapis.com/robot/v1/metadata/x509/videosdk%40videosdk-404307.iam.gserviceaccount.com",
  "universe_domain": "googleapis.com"
}
```

- As you can see in the image, you will need to enter `Project Id`, `Client Email`, `Bucket`, `Private Key` to setup for Google Cloud Storage Bucket. You can retrieve these details from the json file.

- Click on `Save` button.

### Step 4 : Test

- It's time to test !!
- [Create Room](https://docs.videosdk.live/api-reference/realtime-communication/create-room) with token generated with the API Key, you have configured for.
- Start meeting with the roomId created and Start Recording !!
- Then, you can see that recording will be available in your Bucket or Container.

:::note

- Only a single Recording Storage Config can be possible for a particular Api Key at a time.
- In order to add new Recording Configuration, first you need to delete current configuration.

:::


---

---
title: Record Meeting Video & Audio Call - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: Record Meeting features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Webhook and Events
pagination_label: Webhook and Events
keywords:
  - Start Recording meeting
  - Stop Recording meeting
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: webhook-and-events
---

# Webhooks and Events - Android

### Event associated with Recording

- **onRecordingStateChanged** - Whenever meeting recording state changes, then `onRecordingStateChanged` event will trigger.

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
private val meetingEventListener: MeetingEventListener = object : MeetingEventListener() {
  override fun onRecordingStateChanged(recordingState: String) {
    when (recordingState) {
        "RECORDING_STARTING" -> {
            Log.d("onRecordingStateChanged", "Meeting recording is starting")
        }
        "RECORDING_STARTED" -> {
            Log.d("onRecordingStateChanged", "Meeting recording is started")
        }
        "RECORDING_STOPPING" -> {
            Log.d("onRecordingStateChanged", "Meeting recording is stopping")
        }
        "RECORDING_STOPPED" -> {
            Log.d("onRecordingStateChanged", "Meeting recording is stopped")
        }
    }
  }
}

override fun onCreate(savedInstanceState: Bundle?) {
  //...

  // add listener to meeting
  //highlight-next-line
  meeting!!.addEventListener(meetingEventListener)
}
```

</TabItem>

<TabItem value="Java">

```js
private final MeetingEventListener meetingEventListener = new MeetingEventListener() {
  @Override
  public void onRecordingStateChanged(String recordingState) {
      switch (recordingState) {
          case "RECORDING_STARTING":
              Log.d("onRecordingStateChanged", "Meeting recording is starting");
              break;
          case "RECORDING_STARTED":
              Log.d("onRecordingStateChanged", "Meeting recording is started");
              break;
          case "RECORDING_STOPPING":
              Log.d("onRecordingStateChanged", "Meeting recording is stopping");
              break;
          case "RECORDING_STOPPED":
              Log.d("onRecordingStateChanged", "Meeting recording is stopped");
              break;
      }
  }
}

@Override
protected void onCreate(Bundle savedInstanceState) {
  //...

  // add listener to meeting
  //highlight-next-line
  meeting.addEventListener(meetingEventListener);
}
```

</TabItem>

</Tabs>

## Webhook associated with Recording

### recording-starting

- A "Recording Starting" webhook is triggered when the recording process for a meeting is initiated.

###### Example

```javascript
{
    "webhookType": "recording-starting",
    "data": {
        "meetingId": "jvsg-8rjn-j304",
        "sessionId": "613731342f27f56e4fc4b6d0",
    },
}
```

---

### recording-started

- Recording started webhook will be received when successfully recording is started in meeting

###### Example

```javascript
{
    "webhookType": "recording-started",
    "data": {
        "meetingId": "jvsg-8rjn-j304",
        "sessionId": "613731342f27f56e4fc4b6d0",
    },
}
```

---

### recording-stopping

- A "Recording Stopping" webhook is triggered when the recording end process for a meeting is initiated.

###### Example

```javascript
{
    "webhookType": "recording-stopping",
    "data": {
        "meetingId": "jvsg-8rjn-j304",
        "sessionId": "613731342f27f56e4fc4b6d0",
    },
}
```

---

### recording-stopped

- Recording stopped webhook will be received when recording is successfully stopped in meeting.

###### Example

```javascript
{
    "webhookType": "recording-stopped",
    "data": {
        "meetingId": "jvsg-8rjn-j304",
        "sessionId": "613731342f27f56e4fc4b6d0",
        "filePath" : "/encoded/videos/62d148951a1eb20029fc9b05.mp4",
        "fileUrl" : "https://cdn.videosdk.live/encoded/videos/62d148951a1eb20029fc9b05.mp4",

    },
}
```

---

### recording-failed

- A "Recording Failed" webhook is generated when the recording process encounters an interruption or issue during either the starting or stopping phases.

###### Example

```javascript
{
    "webhookType": "recording-failed",
    "data": {
        "meetingId": "jvsg-8rjn-j304",
        "sessionId": "613731342f27f56e4fc4b6d0",
    },
}
```


---

---
title: Interactive Livestream - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: Interactive Livestream features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Interactive Livestream (HLS)
pagination_label: Interactive Livestream (HLS)
keywords:
  - Start HLS meeting
  - Stop HLS meeting
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: interactive-livestream
---

# Interactive Livestream (HLS) - Android

Interactive live streaming (HLS) refers to a type of live streaming where viewers can actively engage with the content being streamed and with other viewers in real-time.

In an interactive live stream (HLS), viewers can take part in a variety of activities like live polling, Q&A sessions, and even sending virtual gifts to the content creator or each other.

<center>

<img src='https://cdn.videosdk.live/website-resources/docs-resources/mobile_hls.png' />

</center>

VideoSDK also allows you to configure the interactive livestream layouts in numerous ways like by simply setting different prebuilt layouts in the configuration or by providing your own custom template to do the livestream according to your layout choice.

This guide will provide an overview of how to implement start and stop Interactive live streaming (HLS).

:::important

To initiate automatic Interactive live streaming (HLS) at the beginning of a `session`, simply provide the `autoStartConfig` feature `hls` during `room` creation. For more information on configuring the `autoStartConfig`, please refer to the provided documentation **[<u>here</u>](/api-reference/realtime-communication/create-room#autoStartConfig)**.

:::

### `startHls()`

`startHls()` can be used to start a interactive livestream of the meeting which can be accessed from the `Meeting` class. This method accepts two parameter:

- `config`: This parameter will define how the interactive livestream layout should look like.

- `transcription`: This parameter lets you start post transcription for the Livestreaming.


import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
val config = JSONObject()

//highlight-next-line
// Layout Configuration
val layout = JSONObject()
JsonUtils.jsonPut(layout, "type", "GRID") // "SPOTLIGHT" | "SIDEBAR",  Default : "GRID"
JsonUtils.jsonPut(layout, "priority", "SPEAKER") // "PIN", Default : "SPEAKER"
JsonUtils.jsonPut(layout, "gridSize", 4) // MAX : 25
JsonUtils.jsonPut(config, "layout", layout)

//highlight-next-line
// Theme of interactive livestream layout
JsonUtils.jsonPut(config, "theme", "DARK") //  "LIGHT" | "DEFAULT"

//highlight-next-line
// `mode` is used to either interactive livestream video & audio both or only audio.
JsonUtils.jsonPut(config, "mode", "video-and-audio") // "audio", Default : "video-and-audio"

//highlight-next-line
// Quality of interactive livestream and is only applicable to `video-and-audio` type mode.
JsonUtils.jsonPut(config, "quality", "high") // "low" | "med",  Default : "med"

//highlight-start
// This mode refers to orientation of interactive livestream.
// landscape : Start interactive livestream of the meeting in horizontally
// portrait : Start interactive livestream of the meeting in vertically (Best for mobile view)
//highlight-end
JsonUtils.jsonPut(config, "orientation", "portrait") // "landscape",  Default : "landscape"

//highlight-next-line
// Post Transcription Configuration
val prompt = "Write summary in sections like Title, Agenda, Speakers, Action Items, Outlines, Notes and Summary"
val summaryConfig = SummaryConfig(true, prompt)
val modelId = "raman_v1"
val transcription = PostTranscriptionConfig(true, summaryConfig, modelId)

meeting.startHls(config, transcription)
```

</TabItem>

<TabItem value="Java">

```js
JSONObject config = new JSONObject();

//highlight-next-line
// Layout Configuration
JSONObject layout = new JSONObject();
JsonUtils.jsonPut(layout, "type", "GRID"); // "SPOTLIGHT" | "SIDEBAR",  Default : "GRID"
JsonUtils.jsonPut(layout, "priority", "SPEAKER");  // "PIN", Default : "SPEAKER"
JsonUtils.jsonPut(layout, "gridSize", 4); // MAX : 25
JsonUtils.jsonPut(config, "layout", layout);

//highlight-next-line
// Theme of interactive livestream layout
JsonUtils.jsonPut(config, "theme", "DARK"); //  "LIGHT" | "DEFAULT"

//highlight-next-line
// `mode` is used to either interactive livestream video & audio both or only audio.
JsonUtils.jsonPut(config, "mode", "video-and-audio"); // "audio", Default : "video-and-audio"

//highlight-next-line
// Quality of interactive livestream and is only applicable to `video-and-audio` type mode.
JsonUtils.jsonPut(config, "quality", "high"); // "low" | "med",  Default : "med"

//highlight-start
// This mode refers to orientation of interactive livestream.
// landscape : Start interactive livestream of the meeting in horizontally
// portrait : Start interactive livestream of the meeting in vertically (Best for mobile view)
//highlight-end
JsonUtils.jsonPut(config, "orientation", "portrait"); // "landscape",  Default : "landscape"

//highlight-next-line
// Post Transcription Configuration
String prompt = "Write summary in sections like Title, Agenda, Speakers, Action Items, Outlines, Notes and Summary";
SummaryConfig summaryConfig = new SummaryConfig(true, prompt);
String modelId = "raman_v1";
PostTranscriptionConfig transcription = new PostTranscriptionConfig(true, summaryConfig, modelId);

meeting.startHls(config, transcription);
```

</TabItem>

</Tabs>

### `stopHls()`

- `stopHls()` is used to stop interactive livestream of the meeting which can be accessed from the `Meeting` class.

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
// keep track of hls
val hls = false

findViewById<View>(R.id.btnHls).setOnClickListener { view: View? ->
  if (!hls) {
    //highlight-start
    val config = JSONObject()
    val layout = JSONObject()
    JsonUtils.jsonPut(layout, "type", "GRID")
    JsonUtils.jsonPut(layout, "priority", "SPEAKER")
    JsonUtils.jsonPut(layout, "gridSize", 4)
    JsonUtils.jsonPut(config, "layout", layout)
    JsonUtils.jsonPut(config, "theme", "DARK")
    JsonUtils.jsonPut(config, "mode", "video-and-audio")
    JsonUtils.jsonPut(config, "quality", "high")
    JsonUtils.jsonPut(config, "orientation", "portrait")
    //highlight-end

    //highlight-next-line
    // Post Transcription Configuration
    val prompt = "Write summary in sections like Title, Agenda, Speakers, Action Items, Outlines, Notes and Summary"
    val summaryConfig = SummaryConfig(true, prompt)
    val modelId = "raman_v1"
    val transcription = PostTranscriptionConfig(true, summaryConfig, modelId)

    // Start Hls
    //highlight-next-line
    meeting!!.startHls(config)
  } else {
    // Stop Hls
    //highlight-next-line
    meeting!!.stopHls()
  }
}
```

</TabItem>

<TabItem value="Java">

```js
// keep track of hls
boolean hls = false;

findViewById(R.id.btnHls).setOnClickListener(view -> {
  if (!hls) {
    //highlight-start
    JSONObject config = new JSONObject();
    JSONObject layout = new JSONObject();
    JsonUtils.jsonPut(layout, "type", "GRID");
    JsonUtils.jsonPut(layout, "priority", "SPEAKER");
    JsonUtils.jsonPut(layout, "gridSize", 4);
    JsonUtils.jsonPut(config, "layout", layout);
    JsonUtils.jsonPut(config, "theme", "DARK");
    JsonUtils.jsonPut(config, "mode", "video-and-audio");
    JsonUtils.jsonPut(config, "quality", "high");
    JsonUtils.jsonPut(config, "orientation", "portrait");
    //highlight-end

    //highlight-next-line
    // Post Transcription Configuration
    String prompt = "Write summary in sections like Title, Agenda, Speakers, Action Items, Outlines, Notes and Summary";
    SummaryConfig summaryConfig = new SummaryConfig(true, prompt);
    String modelId = "raman_v1";
    PostTranscriptionConfig transcription = new PostTranscriptionConfig(true, summaryConfig, modelId);
    
    // Start Hls
    //highlight-next-line
    meeting.startHls(config);
  } else {
    // Stop Hls
    //highlight-next-line
    meeting.stopHls();
  }
});
```

</TabItem>

</Tabs>

:::tip
If you want to learn more about the Interactive Livestream and how you can implement it in your own platform, you can checkout this [guide](/android/guide/interactive-live-streaming/integrate-hls/overview).
:::

### Event associated with HLS

- **onHlsStateChanged** - Whenever meeting HLS state changes, then `onHlsStateChanged` event will trigger.

- You can get the `playbackHlsUrl` and `livestreamUrl` of the HLS to play it on the Viewer side when the state changes to `HLS_PLAYABLE`.
  - `playbackHlsUrl` - Live HLS with playback support
  - `livestreamUrl` - Live HLS without playback support

:::note
`downstreamUrl` is now depecated. Use `playbackHlsUrl` or `livestreamUrl` in place of `downstreamUrl`
:::

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
private val meetingEventListener: MeetingEventListener = object : MeetingEventListener() {
  override fun onHlsStateChanged(HlsState: JSONObject) {
    when (HlsState.getString("status")) {
        "HLS_STARTING" -> Log.d("onHlsStateChanged", "Meeting hls is starting")
        "HLS_STARTED" -> Log.d("onHlsStateChanged", "Meeting hls is started")
        "HLS_PLAYABLE" -> {
            Log.d("onHlsStateChanged", "Meeting hls is playable now")
            //highlight-start
             // on hls playable you will receive playbackHlsUrl and livestreamUrl
            val playbackHlsUrl = HlsState.getString("playbackHlsUrl")
            val livestreamUrl = HlsState.getString("livestreamUrl")
            //highlight-end
        }
        "HLS_STOPPING" -> Log.d("onHlsStateChanged", "Meeting hls is stopping")
        "HLS_STOPPED" -> Log.d("onHlsStateChanged", "Meeting hls is stopped")
    }
  }
}

override fun onCreate(savedInstanceState: Bundle?) {
  //...

  // add listener to meeting
  //highlight-next-line
  meeting!!.addEventListener(meetingEventListener)
}
```

</TabItem>

<TabItem value="Java">

```js
private final MeetingEventListener meetingEventListener = new MeetingEventListener() {
  @Override
  public void onHlsStateChanged(JSONObject HlsState) {
      switch (HlsState.getString("status")) {
          case "HLS_STARTING":
              Log.d("onHlsStateChanged", "Meeting hls is starting");
              break;
          case "HLS_STARTED":
              Log.d("onHlsStateChanged", "Meeting hls is started");
              break;
          case "HLS_PLAYABLE":
              Log.d("onHlsStateChanged", "Meeting hls is playable now");
              //highlight-start
              // on hls started you will receive playbackHlsUrl and livestreamUrl
              String playbackHlsUrl = HlsState.getString("playbackHlsUrl");
              String livestreamUrl = HlsState.getString("livestreamUrl");
              //highlight-end
              break;
          case "HLS_STOPPING":
              Log.d("onHlsStateChanged", "Meeting hls is stopping");
              break;
          case "HLS_STOPPED":
              Log.d("onHlsStateChanged", "Meeting hls is stopped");
              break;
      }
  }
}

@Override
protected void onCreate(Bundle savedInstanceState) {
  //...

  // add listener to meeting
  //highlight-next-line
  meeting.addEventListener(meetingEventListener);
}
```

</TabItem>

</Tabs>

### Custom Template

With VideoSDK, you can also use your own custom designed layout template to livestream the meetings. In order to use the custom template, you need to create a template for which you can [follow this guide](/react/guide/interactive-live-streaming/custom-template). Once you have setup the template, you can use the [REST API to start](/api-reference/realtime-communication/start-livestream) the livestream with the `templateURL` parameter.

### API Reference

The API references for all the methods utilised in this guide are provided below.

- [startHls()](/android/api/sdk-reference/meeting-class/methods#starthls)
- [stopHls()](/android/api/sdk-reference/meeting-class/methods#stophls)
- [onHlsStateChanged](/android/api/sdk-reference/meeting-class/meeting-event-listener-class#onhlsstatechanged)
- [autoStartConfig](/api-reference/realtime-communication/create-room#autoStartConfig)


---

---
title: Record Meeting Video & Audio Call - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: Record Meeting features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Record Meeting
pagination_label: Record Meeting
keywords:
  - Start Recording meeting
  - Stop Recording meeting
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: record-meeting
---

# Record Meeting - Android

VideoSDK allows you to record video & audio during the meeting. The recording files are available in developer dashboard or you can also choose to store them in your own cloud storage.

VideoSDK also allows you to configure the recording layouts in numerous ways like by simply setting different prebuilt layouts in the configuration or by providing your own custom template to do the recording according to your layout choice.

This guide will provide an overview of how to implement start and stop Meeting Recording.

:::important

To initiate automatic recording at the beginning of a `session`, simply provide the `autoStartConfig` feature `recording` during `room` creation. For more information on configuring the `autoStartConfig`, please refer to the provided documentation **[<u>here</u>](/api-reference/realtime-communication/create-room#autoStartConfig)**.

:::

### `startRecording()`

`startRecording()` can be used to start a recording of the meeting which can be accessed from the `Meeting` class. This method accepts four parameters:

- `1. webhookUrl`: This would the webhook URL where you would like to listen to event happening for the recording like starting and stopping of recording. It will be triggered when the recording is completed and stored into server. Read more about webhooks [here](https://en.wikipedia.org/wiki/Webhook)

- `2. awsDirPath`: This parameter accepts the path for the your S3 bucket where you want to store recordings to. To allow us to store recording in your S3 bucket, you will need to fill this form by providing the required values. ([VideoSDK Cloud (AWS S3, Azure Blob or GCP ) Integration](/android/guide/video-and-audio-calling-api-sdk/recording/recording-storage-config))

- `3. config`: This parameter will define how the meeting should be recorded.

- `4. transcription`: This parameter lets you start post transcription for the recording.

:::note

If you don't have a value for `webhookUrl`,`awsDirPath` or `config`, you should pass `null` in place of the missing value. If you pass `null` in `awsDirPath` parameter then by default recordings will be store on the VideoSDK's storage.
:::

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
val config = JSONObject()

//highlight-next-line
// Layout Configuration
val layout = JSONObject()
JsonUtils.jsonPut(layout, "type", "GRID") // "SPOTLIGHT" | "SIDEBAR",  Default : "GRID"
JsonUtils.jsonPut(layout, "priority", "SPEAKER") // "PIN", Default : "SPEAKER"
JsonUtils.jsonPut(layout, "gridSize", 4) // MAX : 4
JsonUtils.jsonPut(config, "layout", layout)

//highlight-next-line
// Theme of recording
JsonUtils.jsonPut(config, "theme", "DARK") //  "LIGHT" | "DEFAULT"

//highlight-next-line
// `mode` is used to either record video & audio both or only audio.
JsonUtils.jsonPut(config, "mode", "video-and-audio") // "audio", Default : "video-and-audio"

//highlight-next-line
// Quality of recording and is only applicable to `video-and-audio` type mode.
JsonUtils.jsonPut(config, "quality", "high") // "low" | "med",  Default : "med"

//highlight-start
// This mode refers to orientation of recording.
// landscape : Record the meeting in horizontally
// portrait : Record the meeting in vertically (Best for mobile view)
//highlight-end
JsonUtils.jsonPut(config, "orientation", "portrait") // "landscape",  Default : "landscape"

//highlight-next-line
// Post Transcription Configuration
val prompt = "Write summary in sections like Title, Agenda, Speakers, Action Items, Outlines, Notes and Summary"
val summaryConfig = SummaryConfig(true, prompt)
val modelId = "raman_v1"
val transcription = PostTranscriptionConfig(true, summaryConfig, modelId)

meeting.startRecording(null, null, config, transcription)
```

</TabItem>

<TabItem value="Java">

```js
JSONObject config = new JSONObject();

//highlight-next-line
// Layout Configuration
JSONObject layout = new JSONObject();
JsonUtils.jsonPut(layout, "type", "GRID"); // "SPOTLIGHT" | "SIDEBAR",  Default : "GRID"
JsonUtils.jsonPut(layout, "priority", "SPEAKER");  // "PIN", Default : "SPEAKER"
JsonUtils.jsonPut(layout, "gridSize", 4); // MAX : 4
JsonUtils.jsonPut(config, "layout", layout);

//highlight-next-line
// Theme of recording
JsonUtils.jsonPut(config, "theme", "DARK"); //  "LIGHT" | "DEFAULT"

//highlight-next-line
// `mode` is used to either record video & audio both or only audio.
JsonUtils.jsonPut(config, "mode", "video-and-audio"); // "audio", Default : "video-and-audio"

//highlight-next-line
// Quality of recording and is only applicable to `video-and-audio` type mode.
JsonUtils.jsonPut(config, "quality", "high"); // "low" | "med",  Default : "med"

//highlight-start
// This mode refers to orientation of recording.
// landscape : Record the meeting in horizontally
// portrait : Record the meeting in vertically (Best for mobile view)
//highlight-end
JsonUtils.jsonPut(config, "orientation", "portrait"); // "landscape",  Default : "landscape"

//highlight-next-line
// Post Transcription Configuration
String prompt = "Write summary in sections like Title, Agenda, Speakers, Action Items, Outlines, Notes and Summary";
SummaryConfig summaryConfig = new SummaryConfig(true, prompt);
String modelId = "raman_v1";
PostTranscriptionConfig transcription = new PostTranscriptionConfig(true, summaryConfig, modelId);

meeting.startRecording(null, null, config, transcription);
```

</TabItem>

</Tabs>

### `stopRecording()`

- `stopRecording()` is used to stop the meeting recording which can be accessed from the `Meeting` class.

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
// keep track of recording
val recording = false

findViewById<View>(R.id.btnRecording).setOnClickListener { view: View? ->
    if (!recording) {
      //highlight-start
      val config = JSONObject()
      val layout = JSONObject()
      JsonUtils.jsonPut(layout, "type", "GRID")
      JsonUtils.jsonPut(layout, "priority", "SPEAKER")
      JsonUtils.jsonPut(layout, "gridSize", 4)
      JsonUtils.jsonPut(config, "layout", layout)
      JsonUtils.jsonPut(config, "theme", "DARK")
      JsonUtils.jsonPut(config, "mode", "video-and-audio")
      JsonUtils.jsonPut(config, "quality", "high")
      JsonUtils.jsonPut(config, "orientation", "portrait")
      //highlight-end

      //highlight-next-line
      // Post Transcription Configuration
      val prompt = "Write summary in sections like Title, Agenda, Speakers, Action Items, Outlines, Notes and Summary"
      val summaryConfig = SummaryConfig(true, prompt)
      val modelId = "raman_v1"
      val transcription = PostTranscriptionConfig(true, summaryConfig, modelId)

      // Start Recording
      // If you don't have a `webhookUrl` or `awsDirPath`, you should pass null.
      // If you don't want to enable transcription, you can pass null as parameter.
      //highlight-next-line
      meeting!!.startRecording("YOUR WEB HOOK URL", "AWS Directory Path", config, transcription)
    } else {
      // Stop Recording
      //highlight-next-line
      meeting!!.stopRecording()
    }
}
```

</TabItem>

<TabItem value="Java">

```js
// keep track of recording
boolean recording = false;

findViewById(R.id.btnRecording).setOnClickListener(view -> {
    if (!recording) {
      //highlight-start
      JSONObject config = new JSONObject();
      JSONObject layout = new JSONObject();
      JsonUtils.jsonPut(layout, "type", "GRID");
      JsonUtils.jsonPut(layout, "priority", "SPEAKER");
      JsonUtils.jsonPut(layout, "gridSize", 4);
      JsonUtils.jsonPut(config, "layout", layout);
      JsonUtils.jsonPut(config, "theme", "DARK");
      JsonUtils.jsonPut(config, "mode", "video-and-audio");
      JsonUtils.jsonPut(config, "quality", "high");
      JsonUtils.jsonPut(config, "orientation", "portrait");
      //highlight-end

      //highlight-next-line
      // Post Transcription Configuration
      String prompt = "Write summary in sections like Title, Agenda, Speakers, Action Items, Outlines, Notes and Summary";
      SummaryConfig summaryConfig = new SummaryConfig(true, prompt);
      String modelId = "raman_v1";
      PostTranscriptionConfig transcription = new PostTranscriptionConfig(true, summaryConfig, modelId);

      // Start Recording
      // If you don't have a `webhookUrl` or `awsDirPath`, you should pass null.
      // If you don't want to enable transcription, you can pass null as parameter.
      //highlight-next-line
      meeting.startRecording("YOUR WEB HOOK URL", "AWS Directory Path", config, transcription);
    } else {
      // Stop Recording
      //highlight-next-line
      meeting.stopRecording();
    }
});
```

</TabItem>

</Tabs>

### Event associated with Recording

- **onRecordingStateChanged** - Whenever meeting recording state changes, then `onRecordingStateChanged` event will trigger.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
private val meetingEventListener: MeetingEventListener = object : MeetingEventListener() {
  override fun onRecordingStateChanged(recordingState: String) {
    when (recordingState) {
        "RECORDING_STARTING" -> {
            Log.d("onRecordingStateChanged", "Meeting recording is starting")
        }
        "RECORDING_STARTED" -> {
            Log.d("onRecordingStateChanged", "Meeting recording is started")
        }
        "RECORDING_STOPPING" -> {
            Log.d("onRecordingStateChanged", "Meeting recording is stopping")
        }
        "RECORDING_STOPPED" -> {
            Log.d("onRecordingStateChanged", "Meeting recording is stopped")
        }
    }
  }
}

override fun onCreate(savedInstanceState: Bundle?) {
  //...

  // add listener to meeting
  //highlight-next-line
  meeting!!.addEventListener(meetingEventListener)
}
```

</TabItem>

<TabItem value="Java">

```js
private final MeetingEventListener meetingEventListener = new MeetingEventListener() {
  @Override
  public void onRecordingStateChanged(String recordingState) {
      switch (recordingState) {
          case "RECORDING_STARTING":
              Log.d("onRecordingStateChanged", "Meeting recording is starting");
              break;
          case "RECORDING_STARTED":
              Log.d("onRecordingStateChanged", "Meeting recording is started");
              break;
          case "RECORDING_STOPPING":
              Log.d("onRecordingStateChanged", "Meeting recording is stopping");
              break;
          case "RECORDING_STOPPED":
              Log.d("onRecordingStateChanged", "Meeting recording is stopped");
              break;
      }
  }
}

@Override
protected void onCreate(Bundle savedInstanceState) {
  //...

  // add listener to meeting
  //highlight-next-line
  meeting.addEventListener(meetingEventListener);
}
```

</TabItem>

</Tabs>

### Storage Configuration

While recording your meetings, you can choose to store them on the VideoSDK's storage or you can also configure your own **`AWS S3 Storage, Azure Blob or GCP Cloud Storage`** to store the meeting recordings directly on your storage.

You can configure your own **`AWS S3 Storage, Azure Blob or GCP Cloud Storage`** from the [VideoSDK Dashboard's API section](https://app.videosdk.live/api-keys).

You can also go through this [guide to setup](/docs/tutorials/user-dashboard/recording-storage-config) the storage or watch this [video to configure](https://www.loom.com/share/23a2617f824a4a5da004d14d1a541a9d) your storage.

### Custom Template

With VideoSDK, you can also use your own custom designed layout template to record the meetings. In order to use the custom template, you need to create a template for which you can [follow this guide](/react/guide/interactive-live-streaming/custom-template). Once you have setup the template, you can use the [REST API to start](/api-reference/realtime-communication/start-recording) the recording with the `templateURL` parameter.

### API Reference

The API references for all the methods utilised in this guide are provided below.

- [startRecording()](/android/api/sdk-reference/meeting-class/methods#startrecording)
- [stopRecording()](/android/api/sdk-reference/meeting-class/methods#stoprecording)
- [onRecordingStateChanged](/android/api/sdk-reference/meeting-class/meeting-event-listener-class#onrecordingstatechanged)
- [autoStartConfig](/api-reference/realtime-communication/create-room#autoStartConfig)


---

---
title: RTMP Livestream - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: RTMP Livestream features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: RTMP Livestream
pagination_label: RTMP Livestream
keywords:
  - Start Livestream meeting
  - Stop Livestream meeting
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: rtmp-livestream
---

# RTMP Livestream - Android

RTMP is a popular protocol for live streaming video content from a VideoSDK to platforms such as YouTube, Twitch, Facebook, and others.

By providing the platform-specific stream key and stream URL, the VideoSDK can connect to the platform's RTMP server and transmit the live video stream.

VideoSDK allows you to livestream your meeting to platform which support RTMP ingestion just by providing the platform-specific stream key and stream URL, we can connect to the platform's RTMP server and transmit the live video stream.

VideoSDK also allows you to configure the livestream layouts in numerous ways like by simply setting different prebuilt layouts in the configuration or by providing your own custom template to do the livestream according to your layout choice.

This guide will provide an overview of how to implement start and stop RTMP Livestreaming.

### `startLivestream()`

`startLivestream()` can be used to start a RTMP livestream of the meeting which can be accessed from the `Meeting` class. This method accepts two parameters:

- `1. outputs`: This parameter accepts a list of `LivestreamOutput` objects which contains the RTMP `url` and `streamKey` of the platforms you want to start the livestream.

- `2. config`: This parameter will define how the livestream layout should look like. You can pass `null` for default layout.

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
val config = JSONObject()

//highlight-next-line
// Layout Configuration
val layout = JSONObject()
JsonUtils.jsonPut(layout, "type", "GRID") // "SPOTLIGHT" | "SIDEBAR",  Default : "GRID"
JsonUtils.jsonPut(layout, "priority", "SPEAKER") // "PIN", Default : "SPEAKER"
JsonUtils.jsonPut(layout, "gridSize", 4) // MAX : 4
JsonUtils.jsonPut(config, "layout", layout)

//highlight-next-line
// Theme of livestream layout
JsonUtils.jsonPut(config, "theme", "DARK") //  "LIGHT" | "DEFAULT"

val outputs: MutableList<LivestreamOutput> = ArrayList()
outputs.add(LivestreamOutput(RTMP_URL, RTMP_STREAM_KEY))

meeting!!.startLivestream(outputs,config)
```

</TabItem>

<TabItem value="Java">

```js
JSONObject config = new JSONObject();

//highlight-next-line
// Layout Configuration
JSONObject layout = new JSONObject();
JsonUtils.jsonPut(layout, "type", "GRID"); // "SPOTLIGHT" | "SIDEBAR",  Default : "GRID"
JsonUtils.jsonPut(layout, "priority", "SPEAKER");  // "PIN", Default : "SPEAKER"
JsonUtils.jsonPut(layout, "gridSize", 4); // MAX : 4
JsonUtils.jsonPut(config, "layout", layout);

//highlight-next-line
// Theme of livestream layout
JsonUtils.jsonPut(config, "theme", "DARK"); //  "LIGHT" | "DEFAULT"

List<LivestreamOutput> outputs = new ArrayList<>();
outputs.add(new LivestreamOutput(RTMP_URL, RTMP_STREAM_KEY));

meeting.startLivestream(outputs,config);
```

</TabItem>

</Tabs>

### `stopLivestream()`

- `stopLivestream()` is used to stop the meeting livestream which can be accessed from the `Meeting` class.

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
// keep track of livestream status
val liveStream = false

findViewById<View>(R.id.btnLiveStream).setOnClickListener { view: View? ->
  if (!liveStream) {
    //highlight-start
    val config = JSONObject()
    val layout = JSONObject()
    JsonUtils.jsonPut(layout, "type", "GRID")
    JsonUtils.jsonPut(layout, "priority", "SPEAKER")
    JsonUtils.jsonPut(layout, "gridSize", 4)
    JsonUtils.jsonPut(config, "layout", layout)
    JsonUtils.jsonPut(config, "theme", "DARK")
    //highlight-end

    val outputs: MutableList<LivestreamOutput> = ArrayList()
    //highlight-next-line
    outputs.add(LivestreamOutput(RTMP_URL, RTMP_STREAM_KEY))

    // Start LiveStream
    //highlight-next-line
    meeting!!.startLivestream(outputs,config)
  } else {
    // Stop LiveStream
    //highlight-next-line
    meeting!!.stopLivestream()
  }
}
```

</TabItem>

<TabItem value="Java">

```js
// keep track of livestream status
boolean liveStream = false;

findViewById(R.id.btnLiveStream).setOnClickListener(view -> {
  if (!liveStream) {
    //highlight-start
    JSONObject config = new JSONObject();
    JSONObject layout = new JSONObject();
    JsonUtils.jsonPut(layout, "type", "GRID");
    JsonUtils.jsonPut(layout, "priority", "SPEAKER");
    JsonUtils.jsonPut(layout, "gridSize", 4);
    JsonUtils.jsonPut(config, "layout", layout);
    JsonUtils.jsonPut(config, "theme", "DARK");
    //highlight-end

    List<LivestreamOutput> outputs = new ArrayList<>();
    //highlight-next-line
    outputs.add(new LivestreamOutput(RTMP_URL, RTMP_STREAM_KEY));

    // Start LiveStream
    //highlight-next-line
    meeting.startLivestream(outputs,config);
  } else {
    // Stop LiveStream
    //highlight-next-line
    meeting.stopLivestream();
  }
});
```

</TabItem>

</Tabs>

### Event associated with Livestream

- **onLivestreamStateChanged** - Whenever meeting livestream state changes, then `onLivestreamStateChanged` event will trigger.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
private val meetingEventListener: MeetingEventListener = object : MeetingEventListener() {
  override fun onLivestreamStateChanged(livestreamState: String?) {
    when (livestreamState) {
      "LIVESTREAM_STARTING" -> Log.d( "LivestreamStateChanged",
          "Meeting livestream is starting"
      )
      "LIVESTREAM_STARTED" -> Log.d( "LivestreamStateChanged",
          "Meeting livestream is started"
      )
      "LIVESTREAM_STOPPING" -> Log.d("LivestreamStateChanged",
          "Meeting livestream is stopping"
      )
      "LIVESTREAM_STOPPED" -> Log.d("LivestreamStateChanged",
          "Meeting livestream is stopped"
      )
    }
  }
}

override fun onCreate(savedInstanceState: Bundle?) {
  //...

  // add listener to meeting
  //highlight-next-line
  meeting!!.addEventListener(meetingEventListener)
}
```

</TabItem>

<TabItem value="Java">

```js
private final MeetingEventListener meetingEventListener = new MeetingEventListener() {
  @Override
  public void onLivestreamStateChanged(String livestreamState) {
    switch (livestreamState) {
      case "LIVESTREAM_STARTING":
          Log.d("LivestreamStateChanged", "Meeting livestream is starting");
          break;
      case "LIVESTREAM_STARTED":
          Log.d("LivestreamStateChanged", "Meeting livestream is started");
          break;
      case "LIVESTREAM_STOPPING":
          Log.d("LivestreamStateChanged", "Meeting livestream is stopping");
          break;
      case "LIVESTREAM_STOPPED":
          Log.d("LivestreamStateChanged", "Meeting livestream is stopped");
          break;
    }
  }
}

@Override
protected void onCreate(Bundle savedInstanceState) {
  //...

  // add listener to meeting
  //highlight-next-line
  meeting.addEventListener(meetingEventListener);
}
```

</TabItem>

</Tabs>

### Custom Template

With VideoSDK, you can also use your own custom designed layout template to livestream the meetings. In order to use the custom template, you need to create a template for which you can [follow this guide](/react/guide/interactive-live-streaming/custom-template). Once you have setup the template, you can use the [REST API to start](/api-reference/realtime-communication/start-livestream) the livestream with the `templateURL` parameter.

### API Reference

The API references for all the methods utilised in this guide are provided below.

- [startLivestream()](/android/api/sdk-reference/meeting-class/methods#startlivestream)
- [stopLivestream()](/android/api/sdk-reference/meeting-class/methods#stoplivestream)
- [onLivestreamStateChanged](/android/api/sdk-reference/meeting-class/meeting-event-listener-class#onlivestreamstatechanged)


---

---
sidebar_label: Release Notes
pagination_label: Release Notes
---

# Release Notes - Android

This page will keep you update all the releases of Android SDK.

## v0.2.0

**Release Date** : 22nd Jan 2025

Change Log :

- **Deprecated Modes:** Replaced `CONFERENCE` with `SEND_AND_RECV` and `VIEWER` with `SIGNALLING_ONLY`.
- **New Mode:** Added `RECV_ONLY` for live streaming, allowing participants to receive media only.
- **Role Switching:** Enabled seamless role switching between `SEND_AND_RECV` (host) and `RECV_ONLY` (audience) using `changeMode()` of Meeting Class.

**Docs:** [Quick Start for Interactive Live Streaming](./quick-start-android-ils)

---

## v0.1.38

**Release Date** : 27th December 2024

**Change Log** :

- Added `h360p_w640p` encode configuration for `oneSixNine` aspect ratio.
- Updated video profile configurations to support adaptive bitrate.
- Updated layer configurations for simulcast.

**Bug Fix** :

- Resolved screen sharing issue on Android 14.
- Fixed an ANR issue occurring when the app resumes from the background.

---

## v0.1.37

**Release Date** : 30th October 2024

**Change Log** :

- Provided Methods and Events for Managing the Whiteboard.

  **Docs** : [Start/Stop Whiteboard](/android/guide/video-and-audio-calling-api-sdk/collaboration-in-meeting/whiteboard)  
  **Docs** : [Render Whiteboard](/android/guide/video-and-audio-calling-api-sdk/collaboration-in-meeting/render-whiteboard)

**Bug Fix** :

- Handle the case when the camera list is empty or no camera found with specified facingMode.

---

## v0.1.36

**Release Date** : 24th September 2024

**Change Log** :

- Update internal dependency
- Added the `setEnableActivityLifecycle()` method to control whether the camera is turned off when the app goes to the background.

---

## v0.1.34

**Release Date** : 20th August 2024

**Change Log** :

- Provided methods to set custom video processor.

  **Docs** : [Video Processor](../../guide/video-and-audio-calling-api-sdk/video-processor/overview.md)

- Provided methods for Virtual Background Effect through `MediaEffects` library.

  **Docs** : [Virtual Background](../../guide/video-and-audio-calling-api-sdk/render-media/virtual-background.md)

---

## v0.1.33

**Release Date** : 10th August 2024

**Change Log** :

- Added `RendererEvents` parameter in `addTrack()` method.

- Change the default value of `PreferredProtocol` to `UDP_OVER_TCP`

---

## v0.1.32

**Release Date** : 26th July 2024

**Change Log** :

- Improved error handling and emitting more precise errors on `onError` event.

**Docs** : [Error Event](../video-and-audio-calling-api-sdk/get-notified/error-events.md)

| Constant                                     | Code | Message                                                                                                                  |
| -------------------------------------------- | ---- | ------------------------------------------------------------------------------------------------------------------------ |
| ERROR_ACTION_PERFORMED_BEFORE_MEETING_JOINED | 3001 | The meeting is not connected yet. All actions on meeting should be performed after meeting is joined successfully.       |
| ERROR_CAMERA_ACCESS                          | 3002 | Something went wrong. Unable to access camera.                                                                           |
| ERROR_MIC_ACCESS_DENIED                      | 3003 | It seems like microphone access was denied or dismissed. To proceed, kindly grant access through your device's settings. |
| ERROR_CAMERA_ACCESS_DENIED                   | 3004 | It seems like camera access was denied or dismissed. To proceed, kindly grant access through your device's settings.     |
| ERROR_CUSTOM_SCREEN_SHARE_TRACK_ENDED        | 3005 | The provided custom track is in an ended state. Please try again with new custom track.                                  |
| ERROR_CUSTOM_SCREEN_SHARE_TRACK_DISPOSED     | 3006 | The provided custom track was disposed. Please try again with new custom track.                                          |
| ERROR_CHANGE_WEBCAM                          | 3007 | Something went wrong, and the camera could not be changed. Please try again.                                             |

**Bug Fix** :

- Fixed the issue of the application crashing during the `onFail()` meeting state.

---

## v0.1.31

**Release Date** : 14th July 2024

**Change Log** :

- The `changeWebcam()` method only allows switching between primary cameras.

  **Docs** : [changeWebcam()](../../api/sdk-reference/meeting-class/methods.md#changewebcam)

---

## v0.1.30

**Release Date** : 5th July 2024

**Bug Fix** :

- Fixed the issue of switching camera from front to back in devices with multiple cameras.

  **Docs** : [changeWebcam()](../../api/sdk-reference/meeting-class/methods.md#changewebcam)

**Change Log** :

- Provided `PreferredProtocol` parameter in the `initMeeting` method to specify a protocol to be used in the meeting and made `signalingBaseUrl` parameter optional.

  **Docs** : [initMeeting()](../../api/sdk-reference/videosdk-class/methods.md#initmeeting)

- Provided `modelId` parameter in post-transcription functionality for selecting a transcription model.

- Removed an internal dependency.

- Provided Pre-Call Screen features.

  - Provided `getDevices()` method in `VideoSDK` class to get list of media devices.

    **Docs** : [getDevices()](../../api/sdk-reference/videosdk-class/methods.md#getdevices)

  - Provided `getVideoDevices()` method in `VideoSDK` class to get list of camera devices.

    **Docs** : [getVideoDevices()](../../api/sdk-reference/videosdk-class/methods.md#getvideodevices)

  - Provided `getAudioDevices()` method in `VideoSDK` class to get list of audio devices.

    **Docs** : [getAudioDevices()](../../api/sdk-reference/videosdk-class/methods.md#getaudiodevices)

  - Provided `AudioDeviceChanged()` event in `VideoSDK` class, which gets triggered whenever an audio device is connected or removed from the system.

    **Docs** : [onAudioDeviceChanged()](../../api/sdk-reference/videosdk-class/events.md#onaudiodevicechanged)

  - Provided `checkPermissions()` method in `VideoSDK` class to check and request media permissions.

    **Docs** : [checkPermissions()](../../api/sdk-reference/videosdk-class/methods.md#checkpermissions)

  - Provided `setSelectedAudioDevice()` method in `VideoSDK` class to set an audio device to be used in the meeting.

    **Docs** : [setSelectedAudioDevice()](../../api/sdk-reference/videosdk-class/methods.md#setselectedaudiodevice)

  - Provided `setSelectedVideoDevice()` method in `VideoSDK` class to set a video device to be used in the meeting.

    **Docs** : [setSelectedVideoDevice()](../../api/sdk-reference/videosdk-class/methods.md#setselectedvideodevice)

  - Provided `getSelectedAudioDevice()` method in `VideoSDK` class to get the audio device, which is currently in use.

    **Docs** : [getSelectedAudioDevice()](../../api/sdk-reference/videosdk-class/properties.md#getselectedaudiodevice)

  - Provided `getSelectedVideoDevice()` method in `VideoSDK` class to get the video device, which is currently in use.

    **Docs** : [getSelectedVideoDevice()](../../api/sdk-reference/videosdk-class/properties.md#getselectedvideodevice)

---

## v0.1.29

**Release Date** : 15th June 2024

**Change Log** :

- Added `captureImage()` method in the `Participant` object to capture the image of the user from MediaStream.

  **Docs** : [captureImage()](../../api/sdk-reference/participant-class/methods#captureimage)

- Added methods `uploadBase64File()` and `fetchBase64File()` to upload and download a temporary file.

  **Docs** : [uploadBase64File()](../../api/sdk-reference/meeting-class/methods#uploadbase64file)

  **Docs** : [fetchbase64file()](../../api/sdk-reference/meeting-class/methods#fetchbase64file)

---

## v0.1.28

**Release Date** : 12th May 2024

**Change log** :

1. Introducing real-time transcription capabilities with the following methods:

   ##### Methods:

   - `startTranscription:` Easily begin real-time transcription with a single method call.

     **SDK Reference** : [startTranscription](../../api/sdk-reference/meeting-class/methods#starttranscription)

   - `stopTranscription:` Stops ongoing transcription processes seamlessly when necessary.

     **SDK Reference** : [stopTranscription](../../api/sdk-reference/meeting-class/methods#stoptranscription)

   ##### Events:

   - `onTranscriptionStateChanged:` Receive updates on transcription states, including started, stopped, and failed states.

     **SDK Reference** : [onTranscriptionStateChanged](../../api/sdk-reference/meeting-class/meeting-event-listener-class#ontranscriptionstatechanged)

   - `onTranscriptionText:` Get real-time updates of transcription text as it is generated, ensuring a responsive transcription experience.

     **SDK Reference** : [onTranscriptionText](../../api/sdk-reference/meeting-class/meeting-event-listener-class#ontranscriptiontext)

2. Introducing post-meeting transcription and summary capabilities with the recording and HLS methods:

   - `startRecording():` Begins recording the meeting and supports post-transcription and summary configuration.

     **SDK Reference** : [startRecording](../../api/sdk-reference/meeting-class/methods#startrecording)

   - `startHls():` Starts HLS streaming with options for post-transcription and summary settings.

     **SDK Reference** : [startHls](../../api/sdk-reference/meeting-class/methods#starthls)

3. Added new error code for better debugging. Checkout the list of available error codes [here](/android/api/sdk-reference/error-codes)

**Docs:** [Post Transcription & Summary](../../guide/video-and-audio-calling-api-sdk/transcription-and-summary/post-transcription.md)

**Docs:** [Realtime Transcription](../../guide/video-and-audio-calling-api-sdk/transcription-and-summary/realtime-transcription.md)

4. Provide `signalingBaseUrl` parameter in `initMeeting()` method of `VideoSDK` class to enable the usage of a proxy server with the VideoSDK.

---

## v0.1.27

**Release Date** : 25th April 2024

**Bug Fix** :

- Fixed screenShare issue for android version 14

---

## v0.1.26

**Release Date** : 12th Jan 2024

**Bug Fix** :

- Fixed landscape video issue between Firefox browser and native android SDK

---

## v0.1.25

**Release Date** : 27th Oct 2023

**Change log** :

- Added `metaData` property associated with `Participant` to pass additional information.
- Added `payload` feature in PubSub to pass additional payload data.
- Added `sendOnly` feature to PubSub to Publish data for only Participants mentioned.
- Provide `setActivityForLifeCycle()` to control camera only for specified activity.

---

## v0.1.24

**Release Date** : 6th Oct 2023

**Change log** :

- Fixed meeting end issue

---

## v0.1.23

**Release Date** : 5th Oct 2023

**Change log** :

- Change default videoTrack

**Bug Fix** :

- Fix crash issue on socket fail
- Fix Bluetooth issue for android version 13

---

## v0.1.22

**Release Date** : 24th august 2023

**Change log** :

- remove PCMU codec
- add consumer-rules

---

## v0.1.21

**Release Date** : 13th July 2023

**Bug Fix** :

- enable the camera when `onActivityResumed()` triggered

---

## v0.1.20

**Release Date** : 10th June 2023

**Bug Fix** :

- Fix bluetooth permission issue for android version 12 and higher.

---

## v0.1.18

**Release Date** : 10th May 2023

**Bug Fix** :

- Fix clash between `initMeeting` customTrack property and `enableWebcam()` customTrack property.

---

## v0.1.17

**Release Date** : 2nd May 2023

**Change log** :

- Provide `multistream` parameter for sending multiple resolution layers or single resolution layer.

  **Docs** : [Multi Stream](/android/api/sdk-reference/custom-tracks#custom-video-track---android)

---

## v0.1.15

**Release Date** : 31st March 2023

**Change log** :

- Add `HLS_PLAYABLE` state in `onHlsStateChanged` event.

  **Docs** : [onHlsStateChanged](https://docs.videosdk.live/android/api/sdk-reference/meeting-class/meeting-event-listener-class#onhlsstatechanged)

---

## v0.1.14

**Release Date** : 28th February 2023

**Change log** :

- Participant can toggle between the `CONFERENCE` and `VIEWER` mode using `changeMode()` method.

  **Docs** : [changeMode()](https://docs.videosdk.live/android/api/sdk-reference/meeting-class/methods#changemode)

- Provide `startHLS()` and `stopHLS()` method for live streaming.

  **Docs** : [startHLS()](https://docs.videosdk.live/android/api/sdk-reference/meeting-class/methods#starthls)

  **Docs** : [stopHLS()](https://docs.videosdk.live/android/api/sdk-reference/meeting-class/methods#stophls)

- Provide `pin()`/`unpin()` method for Pining / Unpining the participant.

  **Docs** : [pin()/unpin()](https://docs.videosdk.live/android/guide/video-and-audio-calling-api-sdk/features/pin-participants)

- Update `startRecording()`,`startLiveStream()` method

  **Docs** : [startRecording()](https://docs.videosdk.live/android/api/sdk-reference/meeting-class/methods#startrecording)

  **Docs** : [startLiveStream()](https://docs.videosdk.live/android/api/sdk-reference/meeting-class/methods#startlivestream)

---

## v0.1.13

**Release Date** : 13th january 2023

**Change log** :

- Provide `VideoView` component which can render video stream.

  **Docs** : [VideoView](/android/guide/video-and-audio-calling-api-sdk/render-media/display-video/understand-videoView-component)

---

## v0.1.12

**Release Date** : 3rd Janurary 2023

**Change log** :

- Provide support of [`mavenCentral()`](https://search.maven.org/artifact/live.videosdk/rtc-android-sdk)

---

## v0.1.11

**Release Date** : 28th December 2022

**Bug Fix** :

- Fix jitpack issue.

---

## v0.1.10

**Release Date** : 24th December 2022

**Change log** :

1. To obtain video, audio and screen sharing statistics, the `Participant` class now has a [`getVideoStats()`](../../api/sdk-reference/participant-class/methods.md#getvideostats),[`getAudioStats()`](/android/api/sdk-reference/participant-class/methods#getaudiostats),[`getShareStats()`](/android/api/sdk-reference/participant-class/methods#getsharestats) methods.

2. Remove `multiStream` Support.

---

## v0.1.9

**Release Date** : 9th December 2022

**Change log** :

1. Provide `multistream` parameter for sending multiple resolution layers or single resolution layer.

   **Docs** : [Multi Stream](https://docs.videosdk.live/android/guide/video-and-audio-calling-api-sdk/features/custom-track/custom-video-track)

**Bug Fix** :

1. Fix echo issue.

---

## v0.1.8

**Release Date** : 10th November 2022

**Change log** :

1. Added recordingState and liveStreamState event.

   **Docs** : [onRecordingStateChanged()](https://docs.videosdk.live/android/api/sdk-reference/meeting-class/meeting-event-listener-class#onrecordingstatechanged)

   **Docs** : [onLivestreamStateChanged()](https://docs.videosdk.live/android/api/sdk-reference/meeting-class/meeting-event-listener-class#onlivestreamstatechanged)

**Bug Fix** :

1. Fix camera automatically enable when enable screenshare.

2. Handle crash on not providing empty screenshare notification title, content or icon.

---

## v0.1.7

**Release Date** : 1st November 2022

**Change log** :

1. Provide support for banuba integration.

   **Code Sample** : [videosdk-rtc-android-sdk-banuba-example](https://github.com/videosdk-live/videosdk-rtc-android-sdk-banuba-example)

   **Docs** : [Banuba Intergation with VideoSDK](/android/guide/video-and-audio-calling-api-sdk/video-processor/banuba-integration)

---

## v0.1.4

**Release Date** : 21st October 2022

**Change log** :

1. Add support of customTrack in changeMic() method.

---

## v0.1.3

**Release Date** : 18th October 2022

**Change log** : None

**Bug Fix** :

1. Null Pointer Exception crash on meeting leave.

---

## v0.1.2

**Release Date** : 17th October 2022

**Change log** :

1.  CustomTrack for audio,video and screenshare.

    **Docs** : [Custom Video Track](/android/guide/video-and-audio-calling-api-sdk/render-media/optimize-video-track#custom-video-track)

    **Docs** : [Custom Audio Track](/android/guide/video-and-audio-calling-api-sdk/render-media/optimize-audio-track)

    **Docs** : [Custom Screen Share Track](/android/guide/video-and-audio-calling-api-sdk/render-media/optimize-video-track#custom-screen-share-track)

---

## v0.1.0 & v0.1.1

**Release Date** : 29th June 2022

**Change log** :

1. Updated internal dependency.


---

---
title: Render Participant | Video SDK
hide_title: true
hide_table_of_contents: false
description: Video SDK and Audio SDK, developers need to implement a token server. This requires efforts on both the front-end and backend.
sidebar_label: Render Participant
pagination_label: Render Participant
keywords:
  - audio calling
  - video calling
  - real-time communication
  - collaboration
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: render-participant
---

# Render Participant - Android

In this guide, we will take a look at how to render the participant's video on the screen.

:::info

- Here the participant's video is displayed using `VideoView`, but you may also use `SurfaceViewRender` for the same.
- For `VideoView`, SDK version should be `0.1.13` or higher.
- To know more about `VideoView`, please visit [here](./understand-videoView-component)

:::

## Steps to render panticipant

**`Step 1:`** Create a new layout for the participant view named `item_participant.xml` in the `res/layout` folder.

```xml title="item_participant.xml"
<?xml version="1.0" encoding="utf-8"?>
<FrameLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="200dp"
    android:background="#616161"
    tools:layout_height="200dp">

    <ImageView
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_gravity="center"
        android:background="#99000000"
        android:contentDescription="webcam_turned_off"
        android:gravity="center"
        android:padding="4dp"
        android:src="@drawable/ic_outline_videocam_off_24"
        app:tint="@color/white" />

    <live.videosdk.rtc.android.VideoView
        android:id="@+id/participantView"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:visibility="gone" />

    <LinearLayout
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:layout_gravity="bottom"
        android:background="#99000000"
        android:orientation="horizontal">

        <TextView
            android:id="@+id/tvName"
            android:layout_width="0dp"
            android:layout_height="wrap_content"
            android:layout_weight="1"
            android:gravity="center"
            android:padding="4dp"
            android:textColor="@color/white" />

    </LinearLayout>
</FrameLayout>
```

**`Step 2:`** Now, Create a recycler view adapter named `ParticipantAdapter` which will show the participant list. Create `PeerViewHolder` in the adapter which will extend `RecyclerView.ViewHolder`

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js title="ParticipantAdapter.kt"
class ParticipantAdapter(meeting: Meeting) : RecyclerView.Adapter<ParticipantAdapter.PeerViewHolder>() {

  override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): PeerViewHolder {
      //highlight-start
      return PeerViewHolder(
        LayoutInflater.from(parent.context)
          .inflate(R.layout.item_participant, parent, false)
        )
      //highlight-end
  }

  override fun onBindViewHolder(holder: PeerViewHolder, position: Int) {
  }

  override fun getItemCount(): Int {
    return 0
  }

  class PeerViewHolder(view: View) : RecyclerView.ViewHolder(view) {
    // 'VideoView' to show Video Stream
    //highlight-next-line
    var participantView: VideoView = view.findViewById(R.id.participantView)
    var tvName: TextView = view.findViewById(R.id.tvName)
  }
}
```

</TabItem>

<TabItem value="Java">

```java title="ParticipantAdapter.java"
public class ParticipantAdapter extends RecyclerView.Adapter<ParticipantAdapter.PeerViewHolder> {

  @NonNull
  @Override
  public PeerViewHolder onCreateViewHolder(@NonNull ViewGroup parent, int viewType) {
    //highlight-next-line
    return new PeerViewHolder(LayoutInflater.from(parent.getContext()).inflate(R.layout.item_participant, parent, false));
  }

  @Override
  public void onBindViewHolder(@NonNull PeerViewHolder holder, int position) {

  }

  @Override
  public int getItemCount() {
      return 0;
  }

  static class PeerViewHolder extends RecyclerView.ViewHolder {
    // 'VideoView' to show Video Stream
    //highlight-next-line
    public VideoView participantView;
    public TextView tvName;
    public View itemView;

    PeerViewHolder(@NonNull View view) {
      super(view);
      itemView = view;
      tvName = view.findViewById(R.id.tvName);
      participantView = view.findViewById(R.id.participantView);
    }
  }
}
```

</TabItem>

</Tabs>

**`Step 3:`** Next, we will render a list of `Participant` for the meeting.
We will initialize this list in the constructor of the `ParticipantAdapter`

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js title="ParticipantAdapter.kt"
class ParticipantAdapter(meeting: Meeting) :
    RecyclerView.Adapter<ParticipantAdapter.PeerViewHolder>() {

  //highlight-next-line
  // creating a empty list which will store all participants
  private val participants: MutableList<Participant> = ArrayList()

  init {
    //highlight-next-line
    // adding the local participant(You) to the list
    participants.add(meeting.localParticipant)

    //highlight-next-line
    // adding Meeting Event listener to get the participant join/leave event in the meeting.
    meeting.addEventListener(object : MeetingEventListener() {
      override fun onParticipantJoined(participant: Participant) {
        // add participant to the list
        participants.add(participant)
        notifyItemInserted(participants.size - 1)
      }

      override fun onParticipantLeft(participant: Participant) {
        var pos = -1
        for (i in participants.indices) {
          if (participants[i].id == participant.id) {
            pos = i
            break
          }
        }
        // remove participant from the list
        participants.remove(participant)
        if (pos >= 0) {
          notifyItemRemoved(pos)
        }
      }
    })
  }

  // replace getItemCount() method with following.
  // this method returns the size of total number of participants
  override fun getItemCount(): Int {
    //highlight-next-line
    return participants.size
  }
  //...
}
```

</TabItem>

<TabItem value="Java">

```java title="ParticipantAdapter.java"
public class ParticipantAdapter extends RecyclerView.Adapter<ParticipantAdapter.PeerViewHolder> {

  //highlight-next-line
  // creating a empty list which will store all participants
  private final List<Participant> participants = new ArrayList<>();

  public ParticipantAdapter(Meeting meeting) {
    //highlight-next-line
    // adding the local participant(You) to the list
    participants.add(meeting.getLocalParticipant());

    //highlight-next-line
    // adding Meeting Event listener to get the participant join/leave event in the meeting.
    meeting.addEventListener(new MeetingEventListener() {
      @Override
      public void onParticipantJoined(Participant participant) {
        // add participant to the list
        participants.add(participant);
        notifyItemInserted(participants.size() - 1);
      }

      @Override
      public void onParticipantLeft(Participant participant) {
        int pos = -1;
        for (int i = 0; i < participants.size(); i++) {
          if (participants.get(i).getId().equals(participant.getId())) {
            pos = i;
            break;
          }
        }
        // remove participant from the list
        participants.remove(participant);

        if (pos >= 0) {
          notifyItemRemoved(pos);
        }
      }
    });
  }

  // replace getItemCount() method with following.
  // this method returns the size of total number of participants
  @Override
  public int getItemCount() {
    //highlight-next-line
    return participants.size();
  }
  //...
}
```

</TabItem>

</Tabs>

**`Step 4:`** Now, We have listed our participants. Let's set up the view holder to display a participant video.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js title="PartipantAdapter.kt"
class ParticipantAdapter(meeting: Meeting) :
    RecyclerView.Adapter<ParticipantAdapter.PeerViewHolder>() {

  //highlight-next-line
  // replace onBindViewHolder() method with following.
  override fun onBindViewHolder(holder: PeerViewHolder, position: Int) {
    val participant = participants[position]

    holder.tvName.text = participant.displayName

    //highlight-next-line
    // adding the initial video stream for the participant into the 'VideoView'
    for ((_, stream) in participant.streams) {
      if (stream.kind.equals("video", ignoreCase = true)) {
        holder.participantView.visibility = View.VISIBLE
        val videoTrack = stream.track as VideoTrack
        //highlight-next-line
        holder.participantView.addTrack(videoTrack)
        break
      }
    }

    //highlight-next-line
    // add Listener to the participant which will update start or stop the video stream of that participant
    participant.addEventListener(object : ParticipantEventListener() {
      override fun onStreamEnabled(stream: Stream) {
        if (stream.kind.equals("video", ignoreCase = true)) {
          holder.participantView.visibility = View.VISIBLE
          val videoTrack = stream.track as VideoTrack
          //highlight-next-line
          holder.participantView.addTrack(videoTrack)
       }
      }

      override fun onStreamDisabled(stream: Stream) {
        if (stream.kind.equals("video", ignoreCase = true)) {
          //highlight-next-line
          holder.participantView.removeTrack()
          holder.participantView.visibility = View.GONE
        }
      }
    })
  }
}
```

</TabItem>

<TabItem value="Java">

```java title="PartipantAdapter.java"
public class ParticipantAdapter extends RecyclerView.Adapter<ParticipantAdapter.PeerViewHolder> {

  //highlight-next-line
  // replace onBindViewHolder() method with following.
  @Override
  public void onBindViewHolder(@NonNull PeerViewHolder holder, int position) {
    Participant participant = participants.get(position);

    holder.tvName.setText(participant.getDisplayName());

    //highlight-next-line
    // adding the initial video stream for the participant into the 'VideoView'
    for (Map.Entry<String, Stream> entry : participant.getStreams().entrySet()) {
      Stream stream = entry.getValue();
      if (stream.getKind().equalsIgnoreCase("video")) {
        holder.participantView.setVisibility(View.VISIBLE);
        VideoTrack videoTrack = (VideoTrack) stream.getTrack();
        //highlight-next-line
        holder.participantView.addTrack(videoTrack)
        break;
      }
    }

    //highlight-next-line
    // add Listener to the participant which will update start or stop the video stream of that participant
    participant.addEventListener(new ParticipantEventListener() {
      @Override
      public void onStreamEnabled(Stream stream) {
        if (stream.getKind().equalsIgnoreCase("video")) {
          holder.participantView.setVisibility(View.VISIBLE);
          VideoTrack videoTrack = (VideoTrack) stream.getTrack();
          //highlight-next-line
          holder.participantView.addTrack(videoTrack)
        }
      }

      @Override
      public void onStreamDisabled(Stream stream) {
        if (stream.getKind().equalsIgnoreCase("video")) {
          //highlight-next-line
          holder.participantView.removeTrack();
          holder.participantView.setVisibility(View.GONE);
        }
      }
    });
  }
}
```

</TabItem>

</Tabs>

**`Step 5:`** Final step is to add this adapter to the `MeetingActivity`

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js title="MeetingActivity.kt"
override fun onCreate(savedInstanceState: Bundle?) {
  //Meeting Setup...
  //...
  val rvParticipants = findViewById<RecyclerView>(R.id.rvParticipants)
  rvParticipants.layoutManager = GridLayoutManager(this, 2)
  //highlight-next-line
  rvParticipants.adapter = ParticipantAdapter(meeting!!)
}
```

</TabItem>

<TabItem value="Java">

```java title="MeetingActivity.java"
@Override
protected void onCreate(Bundle savedInstanceState) {
  //Meeting Setup...
  //...
  final RecyclerView rvParticipants = findViewById(R.id.rvParticipants);
  rvParticipants.setLayoutManager(new GridLayoutManager(this, 2));
  //highlight-next-line
  rvParticipants.setAdapter(new ParticipantAdapter(meeting));
}
```

</TabItem>

</Tabs>

<center>

<img style={{height: '450px'}} src="https://cdn.videosdk.live/website-resources/docs-resources/android_display_video.jpeg" />

</center>

## Mirror Local Video View

If you wish to show the mirror view of the local participant, you can set `setMirror` property to `true` of `VideoView` class.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js title="PartipantAdapter.kt"
class ParticipantAdapter(meeting: Meeting) :
    RecyclerView.Adapter<ParticipantAdapter.PeerViewHolder>() {

  override fun onBindViewHolder(holder: PeerViewHolder, position: Int) {
    //...
    holder.tvName.text = participant.displayName
    //highlight-next-line
    holder.participantView.setMirror(true)
    //...
  }
}
```

</TabItem>

<TabItem value="Java">

```java title="PartipantAdapter.java"
public class ParticipantAdapter extends RecyclerView.Adapter<ParticipantAdapter.PeerViewHolder> {

  @Override
  public void onBindViewHolder(@NonNull PeerViewHolder holder, int position) {
    //...
    holder.tvName.setText(participant.getDisplayName());
    //highlight-next-line
    holder.participantView.setMirror(true);
    //...
  };
}
```

</TabItem>

</Tabs>

##### Sample of mirror view video

![mirror view](/img/mirror-view.jpg)

## API Reference

The API references for all the methods and events utilised in this guide are provided below.

- [Participant](/android/api/sdk-reference/participant-class/introduction)
- [VideoView](./understand-videoView-component)


---

---
title: VideoView Video & Audio Call - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: VideoView component quick integrate in Android with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Understand VideoView Componenet
pagination_label: Understand VideoView Componenet
keywords:
  - SurfaceViewRender
  - VideoView
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: understand-videoView-component
---

# What is SurfaceViewRender ?

`SurfaceViewRender` is a very powerful component of `WebRTC` since it is used to display the video stream on a SurfaceView. You can use `SurfaceViewRender` to show video of participant in your screen.

Here's the lifecycle of a SurfaceViewRenderer:

<div style={{textAlign: 'center'}}>

<img style={{height: '200px'}} src="/img/android/VideoView/life-cycle.png" />

</div>

Which means:

1. The SurfaceViewRenderer must be first initialised after being created and before it can be use at all. It starts a render thread.

2. `addSink()` needs to be called when you are having VideoTrack to render. addSink is method of `VideoTrack` that you want to add to it. You have to pass `surfaceViewRender` as parameter.

3. `removeSink()` should only be called when you're done showing the video. Another method of `VideoTrack`, and it takes the `surfaceViewRenderer` as a parameter.

4. Release at last to allow the render thread to terminate. This function should be called before the activity is destroyed and/or before init it again.

#### Mistakes you might make and stuck :

###### 1. Not initialised surfaceViewRender

The video never appears since a render thread was never start and you will see black view.

###### 2. Init it again before releasing it.

If you are not releasing surfaceViewRender before calling `init()` again, you will get this error.

```js
java.lang.IllegalStateException: svrParticipant Already initialized
        at org.webrtc.EglRenderer.init(EglRenderer.java:212)
```

###### 3. Two videos render on same SurfaceViewRender

If you called `addSink()` on the same `SurfaceViewRenderer` for two different tracks and did not call `removeSink` before that, then you will see two different videos on same SurfaceViewRenderer with flickers which would look like this :

import ReactPlayer from 'react-player'

<div style={{textAlign: 'center'}}>

<ReactPlayer controls url="/img/android/VideoView/android-flicker.mp4" height="500px" width={"100%"} />

</div>

<br/>

Too complicated right? However, VideoSDK makes it simple for you. You can use `VideoView` instead of `SurfaceViewRenderer`.

:::info

- If you want to use `VideoView`, please update SDK version to `0.1.13` or higher.

:::

### VideoView

`VideoView` provides a better abstraction to render live video and handles edge cases like managing init state, render more than one videos on same surfaceViewRender.

### Methods

1. **addTrack(VideoTrack videoTrack)** - `addTrack` will initialised SurfaceViewRender for you and render videoTrack that you provided.

2. **removeTrack()** - `removeTrack` should only be called when you're done showing the video.

3. **releaseSurfaceViewRenderer()** - `releaseSurfaceViewRenderer` should be called before the activity is destroyed.

#### How to use VideoView ?

##### Layout

```js
// <org.webrtc.SurfaceViewRenderer
//        android:id="@+id/svrParticipant"
//        android:layout_width="match_parent"
//        android:layout_height="match_parent" />

<live.videosdk.rtc.android.VideoView
  android:id="@+id/participantView"
  android:layout_width="match_parent"
  android:layout_height="match_parent"
/>
```

##### Initalising and adding video track

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
// svrParticipant.init(PeerConnectionUtils.getEglContext(), null)
// var track = stream.getTrack() as VideoTrack
// track!!.addSink(svrParticipant)

val track = stream.track as VideoTrack
participantView!!.addTrack(track);
```

</TabItem>

<TabItem value="Java">

```js
// svrParticipant.init(PeerConnectionUtils.getEglContext(), null);
// VideoTrack track = (VideoTrack) stream.getTrack();
// track.addSink(svrParticipant);

VideoTrack track = (VideoTrack) stream.getTrack();
participantView.addTrack(track);
```

</TabItem>

</Tabs>

##### removeTrack

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
// var track = stream.track as VideoTrack
// track!!.removeSink(svrParticipant);

participantView.removeTrack();
```

</TabItem>

<TabItem value="Java">

```js
// VideoTrack track = (VideoTrack) stream.getTrack();
// if (track != null) track.removeSink(svrParticipant);

participantView.removeTrack();
```

</TabItem>

</Tabs>

#### release

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
override fun onDestroy() {
        participantView.releaseSurfaceViewRenderer()
        super.onDestroy()
}
```

</TabItem>

<TabItem value="Java">

```js
@Override
protected void onDestroy() {
    participantView.releaseSurfaceViewRenderer();
    super.onDestroy();
}
```

</TabItem>

</Tabs>


---

---
title: Layout and Grid Management | Video SDK
hide_title: true
hide_table_of_contents: false
description: Video SDK and Audio SDK, developers need to implement a token server. This requires efforts on both the front-end and backend.
sidebar_label: Layout and Grid Management
pagination_label: Layout and Grid Management
keywords:
  - audio calling
  - video calling
  - pause/resume video stream
  - real-time communication
  - collaboration
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: layout-and-grid-management
---

# Layout and Grid Management - Android

In this guide, we will take a look at how to efficiently manage the participants in different types of layout.

## Grid Layout

The most usual way to showing participants within a grid. There are multiple things you should keep in mind when showing participants in the grid.

This includes the number of participants being shown on the screens, number of participants in the background(in the meeting but not on the grid), quality which is being consumed for each and every participant in the grid.

### Quality of Participant's Video

When there are large number of participants present on the screen, it is best to consume them in lower resolutions. For this we recommend you to call the `setQuality` method on the participants present in the grid with dynamic values based on the number of participants on the screen.

Here is the recommended video quality:

1. Participants less than 3: `setQuality("high")`
2. Participants between 3 to 4: `setQuality("med")`
3. Participants greater than 4: `setQuality("low")`

<center>
<img src='https://cdn.videosdk.live/website-resources/docs-resources/grid_quality_mobile.png' />
</center>

### Grid with Screen Share

When you are rendering a small grid along with the screen share of the presenter or you are showing a simple sidebar video of the participants while the screenshare is on, it is recommended to do `setQuality("low")` for the participants who are present in the sidebar.

## Grid with Pagination

If you are having large video calls where there are multiple speakers with video turned on, it is best to implement a pagination type setup where only a few (4-6) participants are shown on the grid and rest can be seen by changing the page.

To best utilize the resourses, you should pause the streams of the participants who are not present in the grid and resume them when the come in to the grid. You can [follow this guide](#pauseresume-stream) to pause/resume the stream.

<center>
<img src='https://cdn.videosdk.live/website-resources/docs-resources/grid_pagination.png' />
</center>

:::note
You can get the sample code for grid with pagination [here](https://github.com/videosdk-live/videosdk-rtc-android-kotlin-sdk-example/tree/main/app/src/main/java/live/videosdk/rtc/android/kotlin/GroupCall).
:::

## Pause/Resume Stream

Whenver you wish to stop/resume download stream(webcam, screenShare and mic) of participant, you can simply do it by using `pause`, `resume` methods.

### Pause stream

- `pause()` method is used for pause stream(webcam, screenShare and mic) of a particular participant.

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
for ((_, stream) in participant.streams) {
  //highlight-next-line
  stream.pause()
}
```

</TabItem>

<TabItem value="Java">

```js
for (Map.Entry<String, Stream> entry : participant.getStreams().entrySet()) {
  Stream stream = entry.getValue();
  //highlight-next-line
  stream.pause();
}
```

</TabItem>

</Tabs>

### Resume stream

- `resume()` method is used to resume stream(webcam, screenShare and mic) of a particular participant.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
for ((_, stream) in participant.streams) {
  //highlight-next-line
  stream.resume()
}
```

</TabItem>

<TabItem value="Java">

```js
for (Map.Entry<String, Stream> entry : participant.getStreams().entrySet()) {
  Stream stream = entry.getValue();
  //highlight-next-line
  stream.resume();
}
```

</TabItem>

</Tabs>

## API Reference

The API references for all the methods and events utilised in this guide are provided below.

- [setQuality](/android/api/sdk-reference/participant-class/methods#setquality)


---

---
title: Optimize Audio Track | VideoSDK Docs
hide_title: false
hide_table_of_contents: false
description: Optimize Audio Tracks features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Optimize Audio Track
pagination_label: Optimize Audio Track
keywords:
  - Mic on
  - Mic off
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
---

# Optimize Audio Track - Android

While optimizing for the best listening experience, it is necessary to fine-tune the audio track that is being used during the calls.

For the best fine-tuning experience, we have introduced the ability to pass a custom audio track for the participant's media before and during the meeting.

## Custom Audio Track

This feature can be used to create a custom Audio track for the Audio of the participants with different encoder configuration and send it to other participants.

### `How to Create Custom Audio Track ?`

- You can create a Audio Track using `createAudioTrack()` method of `VideoSDK`.

- This method can be used to create audio track using different encoding parameters.

#### Example

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
val audioCustomTrack: CustomStreamTrack = VideoSDK.createAudioTrack("speech_standard",this)
// `high_quality` | `music_standard`,  Default : `speech_standard`
```

</TabItem>

<TabItem value="Java">

```js
CustomStreamTrack audioCustomTrack=VideoSDK.createAudioTrack("speech_standard", this);
// `high_quality` | `music_standard`,  Default : `speech_standard`
```

</TabItem>

</Tabs>

- `speech_standard` : This config is optimised for normal voice communication.

- `high_quality` : This config is used for getting RAW audio, where you can apply your `noiseConfig`.

- `music_standard` : This config is optimised for communication, where sharing of musical notes such as songs or instrumental sounds, is important.

### `How to Setup Custom Audio Track ?`

The custom track can be set up both before and after the initialization of the meeting.

1. [Setting up a Custom Track during the initialization of a meeting](/android/guide/video-and-audio-calling-api-sdk/render-media/optimize-audio-track#1-setting-up-a-custom-track-during-the-initialization-of-a-meeting)
2. [Setting up a Custom Track with methods](/android/guide/video-and-audio-calling-api-sdk/render-media/optimize-audio-track#2-setting-up-a-custom-track-with-methods)

##### 1. Setting up a Custom Track during the initialization of a meeting

If you are passing `micEnabled: true` in the `initMeeting` of `VideoSDK` and want to use custom tracks from start of the meeting, you can pass custom track in the `initMeeting` as shown below.

:::caution
Custom Track will not apply on `micEnabled: false` configuration.
:::

##### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
override fun onCreate(savedInstanceState: Bundle?) {
  //..

  val customTracks: MutableMap<String, CustomStreamTrack> = HashMap()

  //highlight-start
  val audioCustomTrack: CustomStreamTrack = VideoSDK.createAudioTrack("high_quality", this)
  customTracks["mic"] = audioCustomTrack  //Key must be "mic"
  //highlight-end

  // create a new meeting instance
  val meeting = VideoSDK.initMeeting(
    this@MainActivity,meetingId,participantName,
    //MicEnabled , If true, it will use the passed custom track to turn mic on
    true,
    //WebcamEnabled
    true,
    //ParticipantId
    null,
    //Mode
    null,
    //MultiStream
    false,
    //Pass the custom tracks here
    //highlight-next-line
    customTracks,
    //MetaData
    null
  )
}
```

</TabItem>

<TabItem value="Java">

```js
@Override
protected void onCreate(Bundle savedInstanceState) {
  //..

  Map<String, CustomStreamTrack> customTracks = new HashMap<>();

  //highlight-start
  CustomStreamTrack audioCustomTrack = VideoSDK.createAudioTrack("high_quality", this);
  customTracks.put("mic", audioCustomTrack);  //Key must be "mic"
  //highlight-end

  // create a new meeting instance
  Meeting meeting = VideoSDK.initMeeting(
      MainActivity.this, meetingId, participantName,
      //MicEnabled , If true, it will use the passed custom track to turn mic on
      true,
      //WebcamEnabled
      true,
      //ParticipantId
      null,
      //Mode
      null,
      //MultiStream
      false,
      //Pass the custom tracks here
      //highlight-next-line
      customTracks,
      //MetaData
      null
  );
}
```

</TabItem>

</Tabs>

#### 2. Setting up a Custom Track with methods

In order to switch tracks during the meeting, you have to pass the `CustomStreamTrack` in the `unmuteMic()` method of `Meeting`.

You can also pass custom track in `changeMic()` method of `Meeting`.

:::tip
Make sure to call `muteMic()` before you create a new track as it may lead to unexpected behavior.
:::

##### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
try {
  val audioCustomTrack: CustomStreamTrack = VideoSDK.createAudioTrack("high_quality", this)
  meeting!!.unmuteMic(audioCustomTrack)

  //or
  meeting!!.changeMic(AppRTCAudioManager.AudioDevice.BLUETOOTH, audioCustomTrack)
} catch (e: JSONException) {
  e.printStackTrace()
}
```

</TabItem>

<TabItem value="Java">

```js
try {
  CustomStreamTrack audioCustomTrack = VideoSDK.createAudioTrack("high_quality", this);
  meeting.unmuteMic(audioCustomTrack);

  //or
  meeting.changeMic(AppRTCAudioManager.AudioDevice.BLUETOOTH,audioCustomTrack);
}catch (JSONException e) {
  e.printStackTrace();
}
```

</TabItem>

</Tabs>

## API Reference

The API references for all the methods and events utilised in this guide are provided below.

- [Custom Audio Track](/android/api/sdk-reference/custom-tracks#custom-audio-track---android)


---

---
title: Optimize Video Tracks | VideoSDK Docs
hide_title: false
hide_table_of_contents: false
description: Optimize Video Tracks features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Optimize Video Tracks
pagination_label: Optimize Video Tracks
keywords:
  - Camera on
  - Camera off
  - Webcam on
  - Webcam off
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
---

# Optimize Video Tracks - Android

While optimizing for the best viewing experience, it is necessary to fine-tune the video tracks that are being used during the calls.

For the best fine-tuning experience, we have introduced the ability to pass a custom video track for the participant's media before and during the meeting.

1. [Custom Video Track](#custom-video-track)
2. [Custom Screen Share Track](#custom-screen-share-track)

## Custom Video Track

This feature can be used to add custom video encoder configurations, optimization mode (whether you want to focus on **motion**, **text** or **detail** of the video) and background removal & video filter from external SDK(e.g., [Banuba](https://www.banuba.com/))and send it to other participants.

### `How to Create a Custom Video Track ?`

- You can create a Video Track using `createCameraVideoTrack()` method of `VideoSDK`.
- This method can be used to create video track using different encoding parameters, camera facing mode, and optimization mode and return `CustomStreamTrack`.

#### Example

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
val videoCustomTrack: CustomStreamTrack = VideoSDK.createCameraVideoTrack(

  // highlight-next-line
  // This will accept the resolution (height x width) of video you want to capture.
  "h720p_w960p", // "h720p_w960p" | "h720p_w1280p" ... // Default : "h480p_w720p"

  // highlight-next-line
  // It will specify whether to use front or back camera for the video track.
  "front", "back",  Default : "front"

  // highlight-next-line
  // We will discuss this parameter in next step.
  CustomStreamTrack.VideoMode.MOTION, // CustomStreamTrack.VideoMode.TEXT, CustomStreamTrack.VideoMode.DETAIL ,  Default : CustomStreamTrack.VideoMode.MOTION

  // highlight-next-line
  // multiStream - we will discuss this parameter in next step.
  false, // true

  // highlight-next-line
  // Pass Context
  this,

  // highlight-next-line
  // This is Optional parameter. We will discuss this parameter in next step.
  observer)
```

</TabItem>

<TabItem value="Java">

```javascript
CustomStreamTrack customStreamTrack = VideoSDK.createCameraVideoTrack(

  // highlight-next-line
  // This will accept the resolution (height x width) of video you want to capture.
  "h480p_w640p", // "h720p_w960p" | "h720p_w1280p" ... // Default : "h480p_w640p"

  // highlight-next-line
  // It will specify whether to use front or back camera for the video track.
  "front", // "back,  Default : "front""

  // highlight-next-line
  // We will discuss this parameter in next step.
  CustomStreamTrack.VideoMode.MOTION, // CustomStreamTrack.VideoMode.TEXT, CustomStreamTrack.VideoMode.DETAIL ,  Default : CustomStreamTrack.VideoMode.MOTION

  // highlight-next-line
  // multiStream - we will discuss this parameter in next step.
  false, // true

  // highlight-next-line
  // Pass Context
  this

  // highlight-next-line
  // This is Optional parameter. We will discuss this parameter in next step.
  observer);
```

</TabItem>

</Tabs>

:::caution
The capabilities of the device have a significant impact on how custom track configurations behave. Assuming a case where you set encoder configuration to 1080p but the camera only supports 720p, then encoder configuration will automatically switch to the highest resolution that the device can handle, which is 720p.
:::

##### What is `optimizationMode`?

- It will specify the optimization mode for the video track being generated.

- `motion` : This type of track should more focus on motion video. For example, webcam video, movies or video games.

  - This type of track will degrade `resolution` in order to maintain `frame rate`.

- `text` : This type of track should more focus on significant sharp edges and areas of consistent color that can change frequently. For example, presentations or web pages with text content.

  - This type of track will degrade `frame rate` in order to maintain `resolution`.

- `detail` : This type of track should more focus on details of the video. For example, presentations, painting or line art.

  - This type of track will degrade `frame rate` in order to maintain `resolution`.

##### What is `multiStream`?

- It will specify if the stream should send multiple resolution layers or single resolution layer.

**`multiStream : true`** By default, VideoSDK sends multiple resolution video streams to the server (whether you are using custom video track or not), For instance, user device capabilty is 720p, so VideoSDK sends 720p along with 640p and 480p streams. This allows VideoSDK to deliver the appropriate stream to each participant based on their network bandwidth.

<center>

![Multi Stream False](/img/multistream_true.png)

</center>

**`multiStream : false`** If you want to restrict the VideoSDK to send only one stream to maintain quality, you can set `multiStream` to `false`.

<center>

![Multi Stream False](/img/multistream_false.png)

</center>

:::danger
`setQuality` would not have any effect if multiStream is set to `false`.
:::

##### What is `observer`?

- If you want to use video filter from external SDK(e.g., [Banuba](https://www.banuba.com/)) then pass instance of `CapturerObserver` in this parameter.

:::note

For Banuba integraion with VideoSDK, please visit [Banuba Intergation with VideoSDK](../video-processor/banuba-integration.md)

:::

### `How to Setup a Custom Video Track ?`

The custom track can be set up both before and after the initialization of the meeting.

1. [Setting up a Custom Track during the initialization of a meeting](/android/guide/video-and-audio-calling-api-sdk/render-media/optimize-video-track#1-setting-up-a-custom-track-during-the-initialization-of-a-meeting)
2. [Setting up a Custom Track with methods](/android/guide/video-and-audio-calling-api-sdk/render-media/optimize-video-track#2-setting-up-a-custom-track-with-methods)

##### 1. Setting up a Custom Track during the initialization of a meeting

If you are passing `webcamEnabled: true` in the `initMeeting` of `VideoSDK` and want to use custom tracks from start of the meeting, you can pass custom track in the `initMeeting` as shown below.

:::caution
Custom Track will not apply on `webcamEnabled: false` configuration.
:::

##### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
override fun onCreate(savedInstanceState: Bundle?) {
  //..

  //highlight-start
  val customTracks: MutableMap<String, CustomStreamTrack> = HashMap()
  val videoCustomTrack: CustomStreamTrack =
  VideoSDK.createCameraVideoTrack("h720p_w960p", "front", CustomStreamTrack.VideoMode.MOTION, false, this)
  customTracks["video"] = videoCustomTrack  //Key must be "video"
  //highlight-end

  // create a new meeting instance
  val meeting = VideoSDK.initMeeting(
    this@MainActivity, meetingId, participantName,
    //MicEnabled
    true,
    //WebcamEnabled , If true, it will use the passed custom track to turn webcam on
    true,
    // ParticipantId
    null,
    // Mode
    null,
    // MultiStream
    false,
    //Pass the custom tracks here
    //highlight-next-line
    customTracks,
    //MetaData
    null
  )
}
```

</TabItem>

<TabItem value="Java">

```js
@Override
protected void onCreate(Bundle savedInstanceState) {
  //..

  //highlight-start
  Map<String, CustomStreamTrack> customTracks = new HashMap<>();
  CustomStreamTrack videoCustomTrack = VideoSDK.createCameraVideoTrack("h720p_w960p", "front", CustomStreamTrack.VideoMode.MOTION, false, this);
  customTracks.put("video", videoCustomTrack);  //Key must be "video"
  //highlight-end

  // create a new meeting instance
  Meeting meeting = VideoSDK.initMeeting(
    MainActivity.this, meetingId, participantName,
    //MicEnabled
    true,
    //WebcamEnabled , If true, it will use the passed custom track to turn webcam on
    true,
    // ParticipantId
    null,
    // Mode
    null,
    // MultiStream
    false,
    //Pass the custom tracks here
    //highlight-next-line
    customTracks,
    //MetaData
    null
    );
}
```

</TabItem>

</Tabs>

#### 2. Setting up a Custom Track with methods

In order to switch tracks during the meeting, you have to pass the `CustomStreamTrack` in the `enableWebcam()` method of `Meeting`.

:::tip
Make sure to call `disableWebcam()` before you create a new track as it may lead to unexpected behavior.
:::

##### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
val customStreamTrack: CustomStreamTrack = VideoSDK.createCameraVideoTrack("h720p_w960p", "back", CustomStreamTrack.VideoMode.MOTION, false, this)
meeting!!.enableWebcam(customStreamTrack)
```

</TabItem>

<TabItem value="Java">

```javascript
CustomStreamTrack customStreamTrack=VideoSDK.createCameraVideoTrack("h720p_w960p", "back", CustomStreamTrack.VideoMode.MOTION, false, this);
meeting.enableWebcam(customStreamTrack);
```

</TabItem>

</Tabs>

### `Which Configuration is suitable for Device ?`

In this section, we will understand participant size wise `encoder(Resolution)` and `multiStream` configuration.

<center>
<img src='https://cdn.videosdk.live/website-resources/docs-resources/mobile_device_config.png' />
</center>

## Custom Screen Share Track

This feature can be used to customise screenshare streams with enhanced optimization mode and predefined encoderConfig(Resolution + FPS) for specific use-case and send it to other participants.

### `How to Create Custom Screen Share Track ?`

- You can create a Screen Share track using `createScreenShareVideoTrack()` method of `VideoSDK`.
- This method can be used to create video track using different encoding parameters and optimization mode.

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
// data is received from onActivityResult method.
VideoSDK.createScreenShareVideoTrack(

  //highlight-next-line
  // This will accept the  height & FPS of video you want to capture.
  "h720p_15fps", //  `h360p_30fps` | `h1080p_30fps` // Default : `h720p_15fps`

  //highlight-next-line
  // It is Intent received from onActivityResult when user provide permission for ScreenShare.
  data,

  //highlight-next-line
  // Pass Conext
  this)

  //highlight-next-line
  //Callback to this listener will be made when track is ready with CustomTrack as parameter
  {
    track ->
    meeting!!.enableScreenShare(track)
  }
```

</TabItem>

<TabItem value="Java">

```javascript
// data is received from onActivityResult method.
VideoSDK.createScreenShareVideoTrack(
  //highlight-next-line
  // This will accept the  height & FPS of video you want to capture.
  "h720p_15fps", //  `h360p_30fps` | `h1080p_30fps` // Default : `h720p_15fps`

  /highlight-next-line
  // It is Intent received from onActivityResult when user provide permission for ScreenShare
  data,

  //highlight-next-line
  // Pass Conext
  this,

  //highlight-next-line
  //Callback to this listener will be made when track is ready with CustomTrack as parameter
  (track)->{meeting.enableScreenShare(track);}
);
```

</TabItem>

</Tabs>

### `How to Setup Custom Screen Share Track ?`

In order to switch tracks during the meeting, you have to pass the `CustomStreamTrack` in the `enableScreenShare()` method of `Meeting`.

:::note

Make sure to call `disableScreenShare()` before you create a new track as it may lead to unexpected behavior.

:::

##### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
@TargetApi(21)
private fun askPermissionForScreenShare() {
  val mediaProjectionManager = application.getSystemService<Any>(
      Context.MEDIA_PROJECTION_SERVICE
  ) as MediaProjectionManager
  startActivityForResult(
      mediaProjectionManager.createScreenCaptureIntent(), CAPTURE_PERMISSION_REQUEST_CODE
  )
}

@RequiresApi(api = Build.VERSION_CODES.LOLLIPOP)
override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) {
  super.onActivityResult(requestCode, resultCode, data)
  if (requestCode != CAPTURE_PERMISSION_REQUEST_CODE) return
  if (resultCode == RESULT_OK) {
    //highlight-start
    VideoSDK.createScreenShareVideoTrack("h720p_15fps", data, this) { track ->
        meeting!!.enableScreenShare(track)
    }
    //highlight-end
  }
}

```

</TabItem>

<TabItem value="Java">

```javascript
@TargetApi(21)
private void askPermissionForScreenShare() {
  MediaProjectionManager mediaProjectionManager =
      (MediaProjectionManager) getApplication().getSystemService(
          Context.MEDIA_PROJECTION_SERVICE);
  startActivityForResult(
      mediaProjectionManager.createScreenCaptureIntent(), CAPTURE_PERMISSION_REQUEST_CODE);
}

@RequiresApi(api = Build.VERSION_CODES.LOLLIPOP)
@Override
public void onActivityResult(int requestCode, int resultCode, Intent data) {
  super.onActivityResult(requestCode, resultCode, data);
  if (requestCode != CAPTURE_PERMISSION_REQUEST_CODE)
      return;
  if (resultCode == Activity.RESULT_OK) {
    //highlight-start
    VideoSDK.createScreenShareVideoTrack("h720p_15fps", data, this, (track)->{
        meeting.enableScreenShare(track);
    });
    //highlight-end
  }
}

```

</TabItem>

</Tabs>

## API Reference

The API references for all the methods and events utilised in this guide are provided below.

- [Custom Video Track](/react/api/sdk-reference/custom-tracks#custom-video-track---react)
- [Custom Screen Share Track](/react/api/sdk-reference/custom-tracks#custom-screen-share-track---react)


---

---
title: Picture-in-Picture Mode | Video SDK
hide_title: true
hide_table_of_contents: false
description: Picture-in-picture (PiP) is a feature that is commonly used in video conferencing software. It allows you to continue your video conference while also performing other tasks on your device.
sidebar_label: Picture-in-Picture Mode
pagination_label: Picture-in-Picture Mode
keywords:
  - audio calling
  - video calling
  - real-time communication
  - collaboration
  - Picture In Picture Mode 
  - Android Application 
  - Kotlin 
  - WebRTC PiP Mode
  - Android Picture In Picture Mode 
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: picture-in-picture
--- 


# Picture-in-Picture Mode - Android

## Overview

Picture-in-Picture (PiP) mode enables users to continue video calls while interacting with other apps. This native Android feature is particularly valuable for video conferencing applications, allowing seamless multitasking. Our implementation uses Android's built-in PiP API without third-party dependencies.

This guide will help you integrate PiP mode into your app, ensuring it activates both when the user presses the PiP button and when the app is sent to the background.

<center>
<img src='https://cdn.videosdk.live/docs/images/android/pip-mode/join_screen.png' style={{height: '500px'}}/>
</center>

:::note 
You can check out the complete implementation in the [Github repository](https://github.com/videosdk-live/videosdk-android-pip-mode-example).
:::

## Prerequisites

- Clone our [Quick Start Repository](https://github.com/videosdk-live/quickstart/tree/main/android-rtc/Videosdk_android_compose_quickstart)
- Run the base application
- Ensure Android API level 26+ (Oreo) for PiP support

## Android Manifest Setup

Add these essential attributes to your `AndroidManifest.xml`:

```xml title="AndroidManifest. xml"
<activity 
    android:name=".MainActivity"
    android:configChanges="orientation|screenSize|smallestScreenSize|screenLayout"
    android:resizeableActivity="true"
    android:supportsPictureInPicture="true">
</activity>
```

## Getting Started with the Code!

### ViewModel

The `MeetingViewModel` manages two key variables: `pipMode` and `meetingJoined`.

- `pipMode` tracks whether the app is currently in Picture-in-Picture (PiP) mode. This variable is primarily used in the UI to show or hide relevant controls based on the PiP state.

- `meetingJoined` indicates whether the user is currently in a meeting. This is useful in various scenarios, such as determining whether to allow PiP mode when `onPictureInPictureRequested` is called.


```kotlin title="MeetingViewModel.kt"
class MeetingViewModel : ViewModel() {

    // Track PiP activation state
    var pipMode = mutableStateOf(false)

    // Monitor meeting connection status
    var meetingJoined = mutableStateOf(false)

    private val meetingEventListener: MeetingEventListener = object : MeetingEventListener() {

        override fun onMeetingJoined() {
            meetingJoined.value = true
        }

        override fun onMeetingLeft() {
            meetingJoined.value = false
        }
    }
}
```

### MainActivity


1. **Handling PiP Mode Changes (`onPictureInPictureModeChanged`)**

- This method is triggered whenever the activity enters or exits PiP mode (e.g., when the user minimizes the app or returns to full-screen mode).
- The system passes a `Boolean` flag (`isInPictureInPictureMode`), which indicates whether the activity is currently in PiP mode.
- Here, we update the `pipMode` state in `MeetingViewModel` to notify the UI.

2. **Handling PiP Mode Requests (`onPictureInPictureRequested`)**

- This method is called when the system suggests entering PiP mode, typically when the user presses the home button or switches to another app.
- It checks whether the user is in a meeting (`meetingJoined == true`) before allowing PiP mode.

```kotlin title="MainActivity.kt"
class MainActivity : ComponentActivity() {

    // ViewModel instance for managing meeting state
    private lateinit var viewModel: MeetingViewModel

    @RequiresApi(Build.VERSION_CODES.O)
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)

        // Initialize the ViewModel using ViewModelProvider
        viewModel = ViewModelProvider(this)[MeetingViewModel::class.java]
    }

    override fun onPictureInPictureModeChanged(
        isInPictureInPictureMode: Boolean,
        newConfig: Configuration
    ) {
        // Update the ViewModel state when PiP mode changes
        viewModel.pipMode.value = isInPictureInPictureMode
        super.onPictureInPictureModeChanged(isInPictureInPictureMode, newConfig)
    }

    override fun onPictureInPictureRequested(): Boolean {
        // Allow PiP mode only if the meeting is active
        viewModel.pipMode.value = viewModel.meetingJoined.value
        return super.onPictureInPictureRequested()
    }
}
```

### MeetingScreen

The `MeetingScreen` UI includes a Picture-in-Picture (PiP) mode button, allowing users to switch to PiP mode when a meeting is joined. The screen displays meeting participants in a grid layout. If the user is alone, a message is shown. If there are more than two participants, only the first two are displayed.

- When not in PiP mode, the full meeting UI is shown, including the header, participant grid, and media control buttons (Join, Mic, Cam, Leave, PiP).

- When in PiP mode, the UI adapts by hiding the header and buttons. If the user is alone, a message is displayed. Otherwise, up to two participants are shown.


```kotlin title="MeetingScreen.kt"
@RequiresApi(Build.VERSION_CODES.O)
@Composable
fun MeetingScreen(
    viewModel: MeetingViewModel, 
    navController: NavController, 
    meetingId: String, 
    context: Context
) {

    // Observing the Picture-in-Picture (PiP) mode state from the ViewModel
    val pipMode = viewModel.pipMode

    // If PiP mode is not enabled, show the full meeting UI
    if (!pipMode.value) {
        Column(modifier = Modifier.fillMaxSize()) {
            Header(meetingId)
            MySpacer()
            ParticipantsGrid(
                gridCells = GridCells.Fixed(2),
                participants = viewModel.participants,
                modifier = Modifier.weight(1f)
            )
            MySpacer()
            // Media control buttons (Join, Mic, Cam, Leave, PiP)
            MediaControlButtons(
                onJoinClick = { viewModel.initMeeting(
                    context, app.sampleToken, meetingId
                ) },
                onMicClick = { viewModel.toggleMic() },
                onCamClick = { viewModel.toggleWebcam() },
                onLeaveClick = { viewModel.leaveMeeting() },
                // Enable PiP if meeting is joined
                onPiPClick = { pipMode.value = viewModel.meetingJoined.value } 
            )
        }
    }
    // If PiP mode is enabled, adjust UI accordingly
    if (pipMode.value) {
        activity?.enterPictureInPictureMode(
            PictureInPictureParams.Builder()
            // Custom aspect ratio for PiP window
            .setAspectRatio(Rational(16, 9)) .build()
        )
        if (viewModel.participants.size == 1) {
            Row(modifier = Modifier.fillMaxSize()) {
                // Display the single participant
                Box(modifier = Modifier.weight(1f)) {
                    ParticipantsGrid(
                        gridCells = GridCells.Fixed(1),
                        participants = viewModel.participants.take(1),
                    )
                }
                // Display a message when the user is alone in the meeting
                Box(
                    modifier = Modifier
                        .weight(1f)
                        .fillMaxHeight()
                        .wrapContentSize(Alignment.Center),
                    contentAlignment = Alignment.Center
                ) {
                    Text(
                        text = "You are alone \n in the \n meeting",
                        color = Color.Black,
                        textAlign = TextAlign.Center,
                        fontSize = 12.sp,
                        maxLines = 3,
                        overflow = TextOverflow.Ellipsis,
                        modifier = Modifier.fillMaxWidth()
                    )
                }
            }
        } else {
            // Display up to two participants in PiP mode
            ParticipantsGrid(
                gridCells = GridCells.Fixed(2),
                participants = viewModel.participants.take(2),
                modifier = Modifier.fillMaxSize()
            )
        }
    }
}

@Composable
fun MediaControlButtons(
    // .....
    onPiPClick: () -> Unit
) {
    Row {
        // Other buttons (Join, Mic, Cam, Leave) can be placed here
        // Button to toggle Picture-in-Picture mode
        MyAppButton(onPiPClick, "PiP Mode")
    }
}
```

## Final Output

The final output of Picture-in-Picture (PiP) Mode in the Android application using VideoSDK, without relying on any third-party packages. You can further customize the view and optimize it as per your requirements.

import ReactPlayer from 'react-player'

<div style={{ textAlign: 'center', marginBottom: '50px' }}> 
  <ReactPlayer 
    autoplay 
    muted 
    loop 
    playing 
    controls 
    url="https://cdn.videosdk.live/docs/images/android/pip-mode/pip-mode.mp4" 
    height="500px" 
    width="100%" 
  />
</div>

<div>
  :::tip  
  Stuck anywhere? Check out this [example code](https://github.com/videosdk-live/videosdk-android-pip-mode-example) on GitHub  
  :::  
</div>


---

---
title: Understanding Analytics Dashboard | Video SDK
hide_title: true
hide_table_of_contents: false
description: Video SDK and Audio SDK, developers need to implement a token server. This requires efforts on both the front-end and backend.
sidebar_label: Understanding Analytics Dashboard
pagination_label: Understanding Analytics Dashboard
keywords:
  - audio calling
  - video calling
  - real-time communication
  - collaboration
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: understanding-analytics-dashboard
---

import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>

# Understanding Analytics Dashboard - Android

Welcome to the world of actionable insights and empowered decision-making. VideoSDK's session analytics dashboard is your gateway to understanding, optimizing, and elevating every aspect of your sessions.

## Accessing Analytics Made Easy

Navigating through session data is a breeze with VideoSDK. Simply head to your session page at https://app.videosdk.live/meetings/sessions, where a treasure trove of session information awaits.

### How to Access Analytics?

Open Session Analytics effortlessly by following these steps:

1. **Click on Meeting-ID:**
    - Directly access analytics by clicking on the meeting-ID within the session table.
2. **Hover and Click View Analytics:**
    - Hover over a specific meeting row to reveal the **View Analytics** button in the Actions Column.
    - Click on **View Analytics** to open the Session Overview sidebar, unlocking a wealth of insights.

![Access Analytics](https://cdn.videosdk.live/website-resources/docs-resources/access_analytics.png)

---

There are three tabs available within the session analytics view:

## **1. Session Overview**

This tab provides an overview of the session, including its duration and participant details. You can explore individual participant statistics to understand their session performance better.

## **2. Errors**

In this tab, you can find information about any errors encountered during the session. It helps you identify and address issues like network problems or technical glitches promptly.

:::note

Session errors are visible with JS SDK v0.0.82 or higher, React SDK v0.1.85 or higher, and React Native v0.1.6 or newer versions.

:::

## **3. Session Stats**

Explore data and metrics sent and received by participants to measure performance of the session in this tab. It offers insights into data exchange among participants, including metrics on jitter, RTT, and packet loss, resolutions, and fps aiding in assessing communication efficiency.

Let's dive deeper into each of these tabs to gain a better understanding of session analytics.

# Session Overview

The session overview page is your compass in the sea of data. Here's what you'll uncover:

- **Meeting ID:** Unique identifier for the meeting in the format of `abcd-efgh-ijkl`.
- **Session ID:** Unique identifier for each session, uniquely identified by its `sessionId`.
- **Session Status:** Indicates if the session is ongoing or ended.
- **Session Initiating Time:** Time taken by the first participant to establish the connection.
- **Start and End Time:** Marks the start and end of the session.
- **Total Unique Participants Joined:** Total number of unique participants in the session.
- **Total Session Duration:** Overall duration of the session from start to end.
- **Total Participant Minutes:** A sum of all participant duration.
- **Recording, HLS, RTMP:** Additional services used in the session.

### Participant Table List

- **Participant ID:** Unique identifier for each participant.
- **Participant Name:** Personalized identification for each participant.
- **Join Time:** Time taken by the participant to establish connection.
- **Duration:** Total time spent by this participant in the session.

### Efficient Session Management with Actions

Enhance your session management with streamlined actions:

- **Kick Out Participants:** Effortlessly remove/kickout participants from ongoing sessions.
- **Detailed Participant Analytics:**
- Hover over a specific participant row to reveal the `View Stats` button at the end of the row.
- Click on `View Stats` to open the Participant Overview sidebar.


![View Stats](https://cdn.videosdk.live/website-resources/docs-resources/view_stats.png)


## Explore Participant Insights

Discover valuable participant data that provides a clear view of engagement and experience:

- **Participant ID:** Unique identifier for each participant.
- **Participant Name:** Personalized identification for better interaction.
- **Joined At:** Indicates the precise moment when participant connects to the session.
- **Left At:** Indicates the precise moment when participant left the session.
- **Total Duration:** Total duration of participant within that session.
- **Joining Time:** Time taken by the this participant to establish the connection.
- **Location:** Approx. geographic location from where the participant joined.
- **Platform:** Specifies whether participants are using a desktop or mobile device.
- **Device Info:** Offers details regarding the participant's device.
- **OS:** Provides information about the participant's OS.
- **Browser:** Provides specifics about the participant's browser
- **SDK Version:** Indicates the version of the SDK used by participants.

### Understanding Participant Call Health

We've developed call health to offer a rapid assessment of participant performance during calls. This feature highlights the performance of audio, video, and screen sharing audio-video separately. We've utilized color theory, with green indicating good performance, orange for moderate, and red for poor performance, to enhance clarity. For detailed insights, simply hover over the bars

![Participant Call Health](https://cdn.videosdk.live/website-resources/docs-resources/participant_call_health.png)

## Participant Session Stats

Dive into Participant Session Stats for valuable insights into your session experience! With just a click on `View Session Stats` at the bottom of the page, unlock a treasure trove of data crucial for understanding audio and video experiences.

Within this section, you can observe quality metrics for the selected participant, comparing them to others. Additionally, the `Sessions Stats` covers quality stats comparison for every participant. Keep reading to explore more about Session Stats.

**Visualizing Session Performance from Both Sides**

This section provides a two-sided view of your session's metrics.

- **Left Side: Sender Participant Graph** This section displays graphs representing the metrics sent by the sender participant.. Here, you can see how the various factors impacted the data you transmitted.
- **Right Side: Receiver Participant Graph** On the right side, you'll find a dropdown menu where you can select a specific participant. Choosing a receiver will display graphs showcasing the metrics **received by that participant**. This allows you to compare the sending experience (left side) with the receiving experience (right side) for different participants.

![VideoSDK Jitter Graph](https://cdn.videosdk.live/website-resources/docs-resources/video_jitter_graph.png)

**See How Your Session Performed**

These metrics give you a clear picture of your session's quality. Understanding them helps you spot any issues and keep things running smoothly. Let's dive into what each metric means!

**Jitter:** Imagine your internet connection like a bumpy road. Jitter is how much those bumps cause your signal to bounce around. Less jitter means a smoother ride for your data (audio and video, threshold ≤ 30ms).

**RTT (Latency):** This is how long it takes for data to travel between you and the server you're connected to. Think of it like the time it takes for a message to get delivered – a lower RTT means a faster delivery (affects both audio and video, threshold ≤ 300ms).

**Bitrate:** This measures the amount of data flowing through your connection per second. Imagine it like the width of a water pipe – a higher bitrate allows for more data to flow, which can be good for high-quality audio/video or fast downloads.

**Packet Loss:** Think of data traveling in tiny packets. Packet loss is when some of those packets get dropped along the way. More packet loss means information might be missing, affecting things like audio/video quality or lag in games (threshold ≤ 5%).

**Resolution:** This refers to the sharpness and detail of an image or video. Think of it like the number of pixels on your screen – a higher resolution means a crisper picture (**Video Only**).

**FPS (Frames Per Second):** This measures how many images (frames) are displayed on your screen every second. Imagine it like a flipbook – a higher FPS creates a smoother and more fluid animation or video experience (**Video Only**).

![VideoSDK FPS Graph](https://cdn.videosdk.live/website-resources/docs-resources/video_fps_graph.png)

![VideoSDK Resolution Graph](https://cdn.videosdk.live/website-resources/docs-resources/video_resolution_graph.png)

---

# **Analyse Session Stats**

Similar to `Participant Session Stats`, this tab covers quality statistics sent by individual participants. You can select any participant to compare effectively with others.

Choose a sender participant from the dropdown menu on the left and select a recipient on the right to compare data over different time frames. This allows you to identify and explore issues within specific durations.

This tab covers the same metrics as covered in the `participant session stats`: Jitter, RTT (Latency), Bitrate, Packet-loss, Resolution (Video only), and FPS (Video only).

![VideoSDK Session Stats](https://cdn.videosdk.live/website-resources/docs-resources/session_stats.png)

---

---
title: Understanding Call Quality | Video SDK
hide_title: true
hide_table_of_contents: false
description: Video SDK and Audio SDK, developers need to implement a token server. This requires efforts on both the front-end and backend.
sidebar_label: Understanding Call Quality
pagination_label: Understanding Call Quality
keywords:
  - audio calling
  - video calling
  - real-time communication
  - collaboration
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: understanding-call-quality
---

# Understanding Call Quality - Android

When developing a video call app, customer satisfaction heavily depends on your app's video and audio quality and its fluctuation.

## Call Quality

If we look at the video quality from the user's perspective, a good video quality can be defined as smooth and clear video, along with a crystal clear audio. If the same is viewed from the developer's perspective, a good video quality can be determined as a high resolution, high frame rate video with minimal latency along with a high bitrate audio with minimal audio loss.

## Factors affecting Quality

When it comes to measuring the video and audio quality of a call, there are multiple variables to consider, and the most common factors which affect the video and audio quality are:

### `1. Network Bandwidth`

- Network bandwidth is a measurement of a user's network capability to how large data can be received and send.
- If the bandwidth is low at participant side, he/she is likely to get pixelated or frozen video along with robotic voice or minor breaking in the audio.
- Frequent change in the network providers can also result in high fluctuation of the internet bandwidth, which can also result in poor quality video.

### `2. Latency`

- Latency basically means the time it takes for data to transfer from one machine to another.
- If the meeting is hosted in `Ohio` region, and users are joining from `Singapore` region, so this will create long delay for data to transfer from one machine to another, thus you should pick a server according to your user base.
- In VideoSDK you can set the server during creation of Meeting/Room.

### `3. CPU Usage`

- CPU Usage is an also quite determining factor as all the audio and video streams which are going out and coming in will have to encoded or decoded which will require a significant amount of computation.
- The high the resolution and frame rate of the videos, the larger would be the computation required, which can be a reason for the bottleneck of delivering a good quality video.
- If the CPU is being consumed heavily, it can also result in a choppy or robotic audio.

### `4. Camera and Mic Quality`

- The camera and microphone should capture good quality of streams so that remote user doesn't get low quality stream even if he/she has good network bandwidth

## Identifying the Quality Issues

In order to identify quality issues, VideoSDK collects multiple audio and video related metrics which can help in pinpointing the quality issues. Let's have a look at those metrics and understand what the indicates.

### `1. Resolutions and Framerates`

- Resolution and frame rate are key metrics for video quality in a video call app. Resolution refers to the number of pixels in a video image, while frame rate refers to the number of frames displayed per second.

- Higher resolutions and frame rates can provide better video quality, but they also require more bandwidth and processing power. It's important to optimize this metrics for the devices and network conditions of your users.

- For example, if most of your users are on mobile devices, a lower resolution and frame rate may be more appropriate to ensure smooth playback and minimize bandwidth usage.

- If most of your users are on mobile and desktop devices, having higher resolution for desktop and mid-resolutions for mobile devices can help in improving the performance and quality as we will be saving the bandwidth on the mobile end.

### `2. Bitrate`

- Bitrate is the number of bits per second send or received during the transmission of audio or video streams. Bitrate can be a key parameter to determine the quality of the audio or video streams, as it should be fine-tuned for each resolution to achieve the best match of performance and bandwidth utilization.

- If the users are having excellent network conditions, higher bitrate can result in much better video quality but on the other hand, having very high bitrates on the mobile devices can result in heating issues due to high computation required to encode and decode the videos.

##### Example

We joined using the same phone **(iPhone 14)**, but the resolution and bitrate were different, first participant having resolution **`1280x720`** with bitrate **`1442 kbps`** and second participant having resolution **`960x540`** with bitrate **`642 kbps`**, so as we can see both participants' video appeared to be of equal quality even though resolution and bitrate are different.

![resolution-and-bitrate](/img/resolution-and-bitrate.png)

### `3. Packet Loss`

- Packet loss is a metric that indicates how many data packets are lost during transmission from the sender to the receiver. Packet loss can occur due to network congestion, hardware or software issues, or network latency. Higher packet loss can result in poor video and audio quality, as the missing packets can cause gaps or distortions in the media stream.

import ReactPlayer from 'react-player'

<div style={{textAlign: 'center'}}>

<ReactPlayer autoplay muted loop playing url='/video/packet-loss-burst.mp4' width={"100%"}/>

</div>

### `4. Jitter`

- The audio and video packets are sent out at random intervals over a specified time frame as they are being sent between the server and client. Nevertheless, jitter is produced when there is a variation in transmitting or receiving this data packets as a result of a faulty network connection.

- When data packets delay while being transmitted to the participant, usually because the network is busy. They'll display as pixelated video on a video call or sound choppy, distorted, or robotic on a voice call as they arrive. They'll arrive at random intervals, creating jitter.

### `5. Round Trip Time (Latency)`

- Round trip time is the amount of time required to transmit the data packets to send or receive from the server. If the servers are located very far from the user's location, they can observe a high latency (delay).

- With VideoSDK, this factor is taken care of as we automatically choose the nearest available server for participants. But if you are geofencing to a certain region, you should make sure that you choose the server which will be nearest to your users.

<center>

![resolution-and-bitrate](/img/rtt.png)

</center>

## Checking Realtime Statistics

VideoSDK provides methods to check the realtime statistics of the audio and video of all the participants.

### `getVideoStats()`

- `getVideoStats()` returns an array of object containing the different quality parameters for video stream which can be accessed through the `useParticipant` hook.

- This objects will have values for the specific participant's video stream resolution, frame rate, bitrate, jitter, round trip time, and packet loss.

<div style={{textAlign: 'center'}}>

<ReactPlayer autoplay muted loop playing url='/video/realtime-stats.mp4' width={"100%"}/>

</div>

### `getAudioStats()`

- `getAudioStats()` returns an array of object containing the different quality parameters for audio stream which can be accessed through the `useParticipant` hook.

- This objects will have values for the specific participant's audio stream bitrate, jitter, round trip time and packet loss.

### `getShareStats()`

- `getShareStats()` returns an array of object containing the different quality parameters for screen share stream which can be accessed through the `useParticipant` hook.

- This objects will have values for the specific participant's screen share stream resolution, frame rate, bitrate, jitter, round trip time, and packet loss.

:::note
To show the popup dialog for the participant's realtime stats, you can [refer to this component](https://github.com/videosdk-live/videosdk-rtc-react-sdk-example/blob/main/src/utils/common.js#L142).
:::

## Quality analysis Graphs

For all the sessions taken using the VideoSDK, you can find the quality analysis graphs from the [VideoSDK Dashboard](https://app.videosdk.live/meetings/sessions) which can help you visualize the data you are seeing in realtime and identify the spikes of a few parameters happing during call which can help figure out the reason for the quality issue.

![quality analysis](/img/quality-analysis.png)

## API Reference

The API references for all the methods and events utilised in this guide are provided below.

- [getVideoStats()](/android/api/sdk-reference/participant-class/methods#getvideostats)
- [getAudioStats()](/android/api/sdk-reference/participant-class/methods#getaudiostats)
- [getShareStats()](/android/api/sdk-reference/participant-class/methods#getsharestats)


---

---
sidebar_label: Virtual Background
pagination_label: Virtual Background
---

# Virtual Background - Android

Virtual backgrounds allow you to replace your actual background during video calls or meetings with an image, a solid color, or even a blur effect. This can be useful for:

- Privacy: Hide your messy room or anything you don't want others to see.

- Focus: Minimize distractions and keep the focus on the conversation.

- Fun: Liven up the call with a cool background theme.

import ReactPlayer from 'react-player'

<ReactPlayer controls autoplay muted loop playing url='https://assets.videosdk.live/images/android-video-processor.mp4' width={"100%"} />

## Virtual Background using `MediaEffects` library

The `MediaEffects` library enables the integration of sophisticated virtual background effects within your video applications. By leveraging this library, users can replace their physical backgrounds with custom images or static backdrops, creating a more immersive and engaging experience. 

:::info

The Virtual Background feature in VideoSDK can be utilized regardless of the meeting environment, including the pre-call screen.

:::

### Install the library 
You can install our Android library by using Maven Central package repositories.

- Add the dependency in your `app/build.gradle` file.

```js title="app/build.gradle"
dependencies {
	implementation 'live.videosdk:videosdk-media-effects:0.0.2'
	// other app dependencies
}
```
### Apply Virtual Background

- The `applyVideoProcessor()` method of the `VideoSDK` class enables dynamic changes to the video background during a live session.
- This method accepts an instance of the `VideoFrameProcessor` class as its parameter.
- The following classes implement the `VideoFrameProcessor` interface. Depending on your requirements, you can create an instance of the appropriate class and pass it to the `applyVideoProcessor()` method:

    1. `BackgroundImageProcessor` : The `BackgroundImageProcessor` class takes a `Uri` as a parameter and uses it as the video stream background.
    2. `BackgroundBlurProcessor`: The `BackgroundBlurProcessor` class takes a `float` value for the blur radius and a `Context` to apply a blur effect to the video stream background. It supports range between 0 to 25.
    3. `BackgroundColorProcessor`: The `BackgroundColorProcessor` class takes an `int` value for the color and sets it as the background for the video stream.

### Change Virtual Background

- To change the virtual background, users can utilize a set of setters that allow easy switching between a new image, a blur effect, or a solid color. This functionality supports dynamic customization, enhancing the user's video experience by enabling seamless background updates in real-time.

- You can use following setters to change Virtual Background:

    1. `setBackgroundSource(Uri uri)`: This method of the `BackgroundImageProcessor` class takes a `Uri` as a parameter to update the current background image for the video stream.
    2. `setBlurRadius(float opacity)`: This method of the `BackgroundBlurProcessor` class takes a `float` value for the blur radius to adjust the blur effect of the current background.
    3. `setBackgroundColor(int color)`: This method of the `BackgroundColorProcessor` class takes an `int` value as a parameter to update the current background color for the video stream.
### Remove Virtual Background

- The `removeVideoProcessor()` method from the `VideoSDK` class provides users with a convenient way to revert their video background to its original state, removing any previously applied virtual background. This functionality ensures flexibility for users to switch between virtual and real backgrounds as needed.

#### Example

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
Class MeetingActivity : AppCompatActivity() {
    private var backgroundImageProcessor: BackgroundImageProcessor? = null
    private var backgroundBlurProcessor: BackgroundBlurProcessor? = null
    private var backgroundColorProcessor: BackgroundColorProcessor? = null

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)

        //...

        //To Apply Virtual Background
        findViewById<View>(R.id.applyBackground).setOnClickListener { view: View? ->
            val uri =
                Uri.parse("https://st.depositphotos.com/2605379/52364/i/450/depositphotos_523648932-stock-photo-concrete-rooftop-night-city-view.jpg")
            backgroundImageProcessor = BackgroundImageProcessor(uri)
      //    backgroundBlurProcessor = BackgroundBlurProcessor(25f, this)
      //    backgroundColorProcessor = BackgroundColorProcessor(Color.BLUE)
            VideoSDK.applyVideoProcessor(backgroundColorProcessor)
        }

        //To Change Virtual Background
        findViewById<View>(R.id.changeBackground).setOnClickListener { view: View? ->
            val newUri =
                Uri.parse("https://images.pexels.com/photos/531880/pexels-photo-531880.jpeg?cs=srgb&dl=pexels-pixabay-531880.jpg&fm=jpg")
            backgroundImageProcessor!!.setBackgroundSource(newUri)
      //    backgroundColorProcessor!!.setBackgroundColor(Color.CYAN)
      //    backgroundBlurProcessor!!.setBlurRadius(17f)
        }
        
        //To Remove Virtual Background
        findViewById<View>(R.id.changeBackground).setOnClickListener { view: View? ->
            VideoSDK.removeVideoProcessor()
        }
    }
}
```

</TabItem>

<TabItem value="Java">

```java
public class MeetingActivity extends AppCompatActivity {

    private BackgroundImageProcessor backgroundImageProcessor;
    private BackgroundBlurProcessor backgroundBlurProcessor;
    private BackgroundColorProcessor backgroundColorProcessor;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        //...

        //To Apply Virtual Background
        findViewById(R.id.applyBackground).setOnClickListener(view -> {
            Uri uri = Uri.parse("https://st.depositphotos.com/2605379/52364/i/450/depositphotos_523648932-stock-photo-concrete-rooftop-night-city-view.jpg");
            backgroundImageProcessor = new BackgroundImageProcessor(uri);
        //   backgroundBlurProcessor = new BackgroundBlurProcessor(25,this);
        //   backgroundColorProcessor = new BackgroundColorProcessor(Color.BLUE);
            VideoSDK.applyVideoProcessor(backgroundColorProcessor);
        });

        //To Change Virtual Background
        findViewById(R.id.changeBackground).setOnClickListener(view -> {
            Uri newUri = Uri.parse("https://images.pexels.com/photos/531880/pexels-photo-531880.jpeg?cs=srgb&dl=pexels-pixabay-531880.jpg&fm=jpg");
            backgroundImageProcessor.setBackgroundSource(newUri);
        //    backgroundColorProcessor.setBackgroundColor(Color.CYAN);
        //    backgroundBlurProcessor.setBlurRadius(17);    
        });
        
        //To Remove Virtual Background
        findViewById(R.id.removeBackground).setOnClickListener(view -> {
            VideoSDK.removeVideoProcessor();
        });
    }
}
```

</TabItem>

</Tabs>

## API Reference

The API references for all the methods utilized in this guide are provided below.

- [applyVideoProcessor()](/android/api/sdk-reference/videosdk-class/methods#applyvideoprocessor)
- [removeVideoProcessor()](/android/api/sdk-reference/videosdk-class/methods#removevideoprocessor)



---

---
title: Run the HLS Sample Android Project - Video SDK Docs
hide_title: true
hide_table_of_contents: false
description: Create customizable real-time video & audio calling applications with React JS SDK with Video SDK add live Video & Audio conferencing to your applications.
sidebar_label: Run Http Live Streaming Project
pagination_label: Run Http Live Streaming Project
keywords:
  - android sdk
  - sample project
  - android app
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: run-a-sample-android-hls-project
---

# Run a Sample HLS Project - Android

Video SDK provides open-source sample project [videosdk-hls-android-kotlin-example](https://github.com/videosdk-live/videosdk-hls-android-kotlin-example) on Github. This document introduces how to run this project.

## Prerequisites

- Development environment requirements:
  - [Java Development Kit](https://www.oracle.com/java/technologies/downloads/)
  - Android Studio 3.0 or later
- A physical or virtual mobile device running Android 5.0 or later
- Valid Video SDK [Account](https://app.videosdk.live/)

import APISecret from '../../../../mdx/introduction/\_api-key.mdx';

<APISecret title="Get your API key and Secret key" />

## Run the Sample Project

### Step 1: Clone the sample project

Clone the repository to your local environment.

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
git clone https://github.com/videosdk-live/videosdk-hls-android-kotlin-example.git
```

</TabItem>

<TabItem value="Java">

```js
git clone https://github.com/videosdk-live/videosdk-hls-android-java-example.git
```

</TabItem>

</Tabs>

### Step 2: Modify local.properties

Open your favorite code editor, add `auth_token` in `local.properties` file and paste the earlier generated temporary token as value.

```js title="local.properties"
auth_token = "TEMPORARY-TOKEN";
```

### Step 3: Run the sample app

Run the android app with **Shift+F10** or the ** ▶ Run ** from toolbar.


---

---
title: Run the ILS Sample Android Project - Video SDK Docs
hide_title: true
hide_table_of_contents: false
description: Create customizable real-time video & audio calling applications with React JS SDK with Video SDK add live Video & Audio conferencing to your applications.
sidebar_label: Run Interactive Live Streaming Project
pagination_label: Run the ILS Project
keywords:
  - android sdk
  - sample project
  - android app
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: run-a-sample-android-ils-project
---

# Run Interactive Live Streaming Project - Android

Video SDK provides open-source sample project [videosdk-ils-android-kotlin-example](https://github.com/videosdk-live/videosdk-ils-android-sdk-example) on Github. This document introduces how to run this project.

## Prerequisites

- Development environment requirements:
  - [Java Development Kit](https://www.oracle.com/java/technologies/downloads/)
  - Android Studio 3.0 or later
- A physical or virtual mobile device running Android 5.0 or later
- Valid Video SDK [Account](https://app.videosdk.live/)

import APISecret from '../../../../mdx/introduction/\_api-key.mdx';

<APISecret title="Get your API key and Secret key" />

## Run the Sample Project

### Step 1: Clone the sample project

Clone the repository to your local environment.

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
git clone https://github.com/videosdk-live/videosdk-ils-android-sdk-example
```

</TabItem>

<TabItem value="Java">

```js
git clone https://github.com/videosdk-live/videosdk-ils-android-sdk-example
```

</TabItem>

</Tabs>

### Step 2: Modify local.properties

Open your favorite code editor, add `auth_token` in `local.properties` file and paste the earlier generated temporary token as value.

```js title="local.properties"
auth_token = "TEMPORARY-TOKEN";
```

### Step 3: Run the sample app

Run the android app with **Shift+F10** or the ** ▶ Run ** from toolbar.


---

---
title: Run a sample Android Project - Video SDK Docs
hide_title: true
hide_table_of_contents: false
description: Create customizable real-time video & audio calling applications with Android SDK with Video SDK add live Video & Audio conferencing to your applications.
sidebar_label: "Run Audio & Video Call Project"
pagination_label: "Run Audio & Video Call Project"
keywords:
  - android sdk
  - java sdk
  - kotlin sdk
  - sample project
  - android app
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: run-a-sample-android-project
---

# Run Audio & Video Call Project - Android

Video SDK provides open-source sample project [videosdk-rtc-android-kotlin-sdk-example](https://github.com/videosdk-live/videosdk-rtc-android-kotlin-sdk-example) on Github. This document introduces how to run this project.

## Prerequisites

- Development environment requirements:
  - [Java Development Kit](https://www.oracle.com/java/technologies/downloads/)
  - Android Studio 3.0 or later
- A physical or virtual mobile device running Android 5.0 or later
- Valid Video SDK [Account](https://app.videosdk.live/)

import APISecret from '../../../../mdx/introduction/\_api-key.mdx';

<APISecret title="Get your API key and Secret key" />

## Run the Sample Project

### Step 1: Clone the sample project

Clone the repository to your local environment.

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
git clone https://github.com/videosdk-live/videosdk-rtc-android-kotlin-sdk-example.git
```

</TabItem>

<TabItem value="Java">

```js
git clone https://github.com/videosdk-live/videosdk-rtc-android-java-sdk-example.git
```

</TabItem>

</Tabs>

### Step 2: Modify local.properties

Open your favorite code editor, add `auth_token` in `local.properties` file and paste the earlier generated temporary token as value.

```js title="local.properties"
auth_token = "TEMPORARY-TOKEN";
```

### Step 3: Run the sample app

Run the android app with **Shift+F10** or the ** ▶ Run ** from toolbar.


---

---
title: Just Click Setup - Testing Token Server | Video SDK
hide_title: true
hide_table_of_contents: false
description: Video SDK and Audio SDK, developers need to implement a token server. This requires efforts on both the front-end and backend.
sidebar_label: Authentication and Tokens
pagination_label: Authentication and Tokens
keywords:
  - audio calling
  - video calling
  - real-time communication
  - collaboration
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: server-setup
---

import ServerSetup from '../../../../mdx/introduction/\_server-setup.mdx';
import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>
<ServerSetup />


---

---
title: Initialize Meeting | Video SDK
hide_title: true
hide_table_of_contents: false
description: Video SDK and Audio SDK, developers need to implement a token server. This requires efforts on both the front-end and backend.
sidebar_label: Initialize Meeting
pagination_label: Initialize Meeting
keywords:
  - audio calling
  - video calling
  - real-time communication
  - collaboration
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: initialize-meeting
---

# Initialize Meeting - Android

To configure a VideoSDK meeting you require two things, first the `token` which will be used for **Authentication** purpose and a `meetingId` which will be used to specify where a participant will join. Let's see each of the steps closely.

### Generating Token

You can generate a `token` in two ways:

1. **`Temporary Token`** : You can visit [Dashboard's API Key section](https://app.videosdk.live/api-keys) and generate the temporary token from there.

2. **`Server`** : You can setup **JWT** in backend and make an API call to get the token from your server.

To learn more about **Authentication** and token in detail you can follow [this guide](../authentication-and-token).

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
// With Temporary Token
fun getToken(): String? {
  // Update the token here from the VideoSDK dashboard
  // highlight-next-line
  return "YOUR_TOKEN"
}

// Server
fun getToken(): String? {
  val token = arrayOfNulls<String>(1)
  // highlight-start
  AndroidNetworking.get("http://localhost:3000/get-token")
      .build()
      .getAsJSONObject(object : JSONObjectRequestListener() {
          fun onResponse(response: JSONObject) {
              try {
                  token[0] = response.getString("token")
              } catch (e: JSONException) {
                  e.printStackTrace()
              }
          }

          fun onError(anError: ANError) {
              anError.printStackTrace()
          }
      })
  // highlight-end
  return token[0]
}
```

</TabItem>

<TabItem value="Java">

```java
// With Temporary Token
public String getToken()
{
  // Update the token here from the VideoSDK dashboard
  // highlight-next-line
  String token = "YOUR_TOKEN";
  return token;
}

// Server
public String getToken()
{
  final String[] token = new String[1];
  // highlight-start
  AndroidNetworking.get("http://localhost:3000/get-token")
      .build()
      .getAsJSONObject(new JSONObjectRequestListener() {
          @Override
          public void onResponse(JSONObject response) {
              try {
                  token[0] = response.getString("token");
              } catch (JSONException e) {
                  e.printStackTrace();
              }
          }
          @Override
          public void onError(ANError anError) {
              anError.printStackTrace();
          }
      });
  // highlight-end
  return token[0];
}
```

</TabItem>

</Tabs>

### Generating Meeting Id

With the token ready, we can get the `meetingId` from the [VideoSDK's rooms API](/api-reference/realtime-communication/create-room).

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
fun getMeetingId(token: String?): String? {
  var meetingId: String? =null;
  // We will use VideoSDK rooms API endpoint to create a meetingId
  // highlight-start
  AndroidNetworking.post("https://api.videosdk.live/v2/rooms")
      .addHeaders("Authorization", token) // We will pass the token in the headers
      .build()
      .getAsJSONObject(object : JSONObjectRequestListener() {
          fun onResponse(response: JSONObject) {
              try {
                  meetingId = response.getString("roomId")
              } catch (e: Exception) {
                  e.printStackTrace()
              }
          }

          fun onError(anError: ANError) {
              anError.printStackTrace()
          }
      })
  // highlight-end
  //we will return the meetingId which we got from the response of the api
  return meetingId
}
```

</TabItem>

<TabItem value="Java">

```java
public String getMeetingId(String token) {
  final String[] meetingId = new String[1];
  // We will use VideoSDK rooms API endpoint to create a meetingId
  // highlight-start
  AndroidNetworking.post("https://api.videosdk.live/v2/rooms")
      .addHeaders("Authorization", token) // We will pass the token in the headers
      .build()
      .getAsJSONObject(new JSONObjectRequestListener() {
          @Override
          public void onResponse(JSONObject response) {
              try {
                  meetingId[0] = response.getString("roomId");
              } catch (Exception e) {
                  e.printStackTrace();
              }
          }
          @Override
          public void onError(ANError anError) {
              anError.printStackTrace();
          }
      });
  // highlight-end
  //we will return the meetingId which we got from the response of the api
  return meetingId[0];
}
```

</TabItem>

</Tabs>

:::tip
To perform Network call you need to add [Fast Android Networking Library](https://github.com/amitshekhariitbhu/Fast-Android-Networking) in your application.
:::

### Initialization of Meeting

1. To initialize the meeting, first we have to initialize the VideoSDK.
   We can initialize the VideoSDK using `initialize()` method provided by the SDK.

```js title="initialize"
  VideoSDK.initialize(Context context)
```

2. Next, we have to set token property of VideoSDK class.
   By using `config()` method, you can set the token property of VideoSDK class.

```js title="config"
 VideoSDK.config(String token)
```

3. Now, we can initialize the meeting using a factory method provided by the SDK called `initMeeting()`.

`initMeeting()` is responsible for initializing the meeting with the provided configuration, which includes the `meetingId`, `name`, `participantId` and many more.

:::tip
When conducting one-to-one meetings, it is recommended to set `multistream:false`.For more information on multistream, refer to the [multistream documentation](/android/guide/video-and-audio-calling-api-sdk/render-media/optimize-video-track#what-is-multistream).
:::

Let's take a deeper look at the available configuration options first.

```js title="initMeeting"
  VideoSDK.initMeeting(
      Context context,  // context of activity
      String meetingId,  // id of meeting
      String name, // name of participant
      boolean micEnabled, // flag to enable-mic
      boolean webcamEnabled, // flag to enable-webcam
      String participantId,  // id of participant
      String mode, // mode of participant
      boolean multiStream, // multiStream
      Map<String, CustomStreamTrack> customTracks, // map of customTracks
      JSONObject metaData, // metaData
      String signalingBaseUrl // signalingBaseUrl
      PreferredProtocol preferredProtocol //preferredProtocol
  )
```

- **`context`** :

  - Context of activity.
  - It will accept `Context` type value.

- **`meetingId`** :

  - meetingId is unique identifiers that allow participants to join a specific meeting or room.
  - It will accept `String` type value.
  - It will be in the format of `xxx-yyy-zzz` and will be generated using the [VideoSDK's Room API](/api-reference/realtime-communication/create-room).

- **`name`**:

  - This will represent the name of the participant in the meeting.
  - It will accept `String` type value.

- **`micEnabled`**:

  - This is a `boolean` flag, indicating whether a participant's microphone will be automatically enabled when they join a meeting.

- **`webcamEnabled`**:

  - This is a `boolean` flag, indicating whether a participant's webcam will be automatically enabled when they join a meeting.

- **`participantId`**:

  - This will be the unique identifier for the participant inside the meeting.
  - It can be used to specify the **unique identifier** which can be linked with **your own database** service.
  - It has to be of `String` type.
  - If you passed `null` then by default VideoSDK will generate unique id for each participant.

- **`multistream`**:

  - This is a `boolean` flag, indicating if the stream should send multiple resolution layers or single resolution layer.

:::caution
You must ensure that the `participantId` is not repeated in the same meeting or room, It will enable VideoSDK to eliminate any participant respect to that `participantId`.
:::

- **`mode`**:

  - There are 3 types of modes:

    1. `SEND_AND_RECV` : Both audio and video streams will be produced and consumed in this mode.

    2. `SIGNALLING_ONLY` : Audio and video streams will not be produced or consumed in this mode.

    3. `RECV_ONLY`: This mode allows only the consumption of audio and video streams without producing any.

  - It has to be of `String` type.
  - If you passed `null` then by default VideoSDK will set `SEND_AND_RECV` mode.

import CautionMessage from '@site/src/theme/CautionMessage';

<CautionMessage sdk="Android SDK" version="v0.2.0" />

- **`multiStream`**:

  - It will specify if the stream should send multiple resolution layers or single resolution layer.

  - It has to be of `boolean` type.

- **`customTracks`**:

  - If you want to set the initial custom tracks, then you can pass map of custom tracks in this paramater.

  - It has to be of `Map<String, CustomStreamTrack>` type.

- **`metaData`**:

  - If you want to provide additional details about a user joining a meeting, such as their profile image, you can pass that information in this parameter.

  - It has to be of `JsonObject` type.

- **`signalingBaseUrl`**:

  - If you want to use a proxy server with the VideoSDK, you can specify your base URL here.

  - It has to be of `String` type.

  - It is Optional parameter.

:::note

If you intend to use a proxy server with the VideoSDK, priorly inform us at support@videosdk.live

:::

- **`preferredProtocol`**:

  - If you want to provide a preferred network protocol for communication, you can specify that in `PreferredProtocol`, with options including `UDP_ONLY`, `UDP_OVER_TCP`, and `TCP_ONLY`.

  - It has to be of `PreferredProtocol` type.

  - It is Optional parameter.

With all the configuration options explained, here is how you can initialize the meeting.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
class MainActivity : AppCompatActivity() {

  fun getToken(): String? {
    //highlight-next-line
    ...
  }

  fun getMeetingId(token: String?): String? {
    //highlight-next-line
    ...
  }

 override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    setContentView(R.layout.activity_main)

    // initialize AndroidNetworking to perform Network call
    AndroidNetworking.initialize(applicationContext)

    //We will fetch token and meetingId and store it in local variables
    val token: String = getToken()
    val meetingId = getMeetingId(token)

    // highlight-start
    // initialize the VideoSDK
    VideoSDK.initialize(this@MainActivity)

    // set token property of VideoSDK
    VideoSDK.config(token)

    // create a new meeting instance
    val meeting: Meeting = VideoSDK.initMeeting(
        this@MainActivity, meetingId, "NAME HERE",
        true, true, null, null, false, null, null
    )
    // highlight-end

    Log.d("VideoSDK", "onCreate: $meetingId")
  }
}
```

</TabItem>

<TabItem value="Java">

```java
public class MainActivity extends AppCompatActivity {

  public String getToken()
  {
    //highlight-next-line
    ...
  }

  public String getMeetingId(String token) {
    //highlight-next-line
    ...
  }

  @Override
  protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);

    // initialize AndroidNetworking to perform Network call
    AndroidNetworking.initialize(getApplicationContext());

    //We will fetch token and meetingId and store it in local variables
    String token = getToken();
    String meetingId = getMeetingId(token);

    // highlight-start
    // initialize the VideoSDK
    VideoSDK.initialize(MainActivity.this);

    // set token property of VideoSDK
    VideoSDK.config(token);

    // create a new meeting instance
    Meeting meeting = VideoSDK.initMeeting(
            MainActivity.this, meetingId, "NAME HERE",
            true, true, null, null, false, null, null
    // highlight-end

    Log.d("VideoSDK", "onCreate: " + meetingId);
  }
}
```

</TabItem>

</Tabs>

### API Reference

The API references for all the methods utilised in this guide are provided below.

- [initMeeting](/android/api/sdk-reference/initMeeting)


---

---
title: Join Meeting | Video SDK
hide_title: true
hide_table_of_contents: false
description: Video SDK and Audio SDK, developers need to implement a token server. This requires efforts on both the front-end and backend.
sidebar_label: Join Meeting
pagination_label: Join Meeting
keywords:
  - audio calling
  - video calling
  - real-time communication
  - collaboration
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: join-meeting
---

# Join Meeting - Android

### Overview

After meeting initialization by `initMeeting()` it returns a new instance of `Meeting`. If you have not initialized a meeting yet, you can [follow the guide here.](./initialize-meeting) However, by default, it will not automatically join the meeting. Hence, to join the meeting you have to call `join()` .

### `join()`

- To join the meeting you can call the `join()` method of `Meeting` class.
- This method can be called after the meeting is initialized using `VideoSDK` class.

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
class MainActivity : AppCompatActivity() {
 override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    setContentView(R.layout.activity_main)
    // initialize the meeting
    ...

    // join meeting
    // highlight-next-line
    meeting!!.join()
  }
}
```

</TabItem>

<TabItem value="Java">

```java
public class MainActivity extends AppCompatActivity {
  @Override
  protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);
    // initialize the meeting
    ...

    // join meeting
    // highlight-next-line
    meeting.join();
  }
}
```

</TabItem>

</Tabs>

### Events associated with Join

Following callbacks are received when a participant is successfully joined.

- [Local Participant](../concept-and-architecture#2-participant) will receive a [`onMeetingJoined`](/android/api/sdk-reference/meeting-class/meeting-event-listener-class#onmeetingjoined) event, when successfully joined.
- [Remote Participant](../concept-and-architecture#2-participant) will receive a [`onParticipantJoined`](/android/api/sdk-reference/meeting-class/meeting-event-listener-class#onparticipantjoined) event with the newly joined `Participant` object from the event callback.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
class MainActivity : AppCompatActivity() {
 override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    setContentView(R.layout.activity_main)
    // initialize the meeting
    ...

    // join meeting
    meeting!!.join()

    // Add event listener for listening upcoming events of meeting
    // highlight-next-line
    meeting!!.addEventListener(meetingEventListener)
  }

  private val meetingEventListener: MeetingEventListener = object : MeetingEventListener(){
    // Event to know meeting is joined
    //highlight-start
    fun onMeetingJoined() {
        Log.d("VideoSDK", "onMeetingJoined")
    }
    //highlight-end
    // Event to know some other participant joined
    //highlight-start
    fun onParticipantJoined(participant: Participant) {
        Log.d("#VideoSDK", participant.displayName + " joined");
    }
    //highlight-end
  }
}
```

</TabItem>

<TabItem value="Java">

```java
public class MainActivity extends AppCompatActivity {
  @Override
  protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);
    // initialize the meeting
    ...

    // join meeting
    meeting.join();

    // Add event listener for listening upcoming events of meeting
    //highlight-next-line
    meeting.addEventListener(meetingEventListener);
  }

  private final MeetingEventListener meetingEventListener=new MeetingEventListener() {
    // Event to know meeting is joined
    //highlight-start
    @Override
    public void onMeetingJoined() {
        Log.d("VideoSDK", "onMeetingJoined");
    }
    //highlight-end

    // Event to know some other participant joined
    //highlight-start
    @Override
    public void onParticipantJoined(Participant participant) {
        Log.d("#VideoSDK", participant.getDisplayName() + " joined");
    }
    //highlight-end
  };
}
```

</TabItem>

</Tabs>

### API Reference

The API references for all the methods and events utilised in this guide are provided below.

- [initMeeting](/android/api/sdk-reference/initMeeting)
- [join()](/android/api/sdk-reference/meeting-class/methods#join)
- [onMeetingJoined()](/android/api/sdk-reference/meeting-class/meeting-event-listener-class#onmeetingjoined)
- [onParticipantJoined()](/android/api/sdk-reference/meeting-class/meeting-event-listener-class#onparticipantjoined)


---

---
title: Leave or End Meeting | Video SDK
hide_title: true
hide_table_of_contents: false
description: Video SDK and Audio SDK, developers need to implement a token server. This requires efforts on both the front-end and backend.
sidebar_label: Leave or End Meeting
pagination_label: Leave or End Meeting
keywords:
  - audio calling
  - video calling
  - real-time communication
  - collaboration
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: leave-end-meeting
---

# Leave or End Meeting - Android

Participant can choose to leave the meeting without removing all the other participants. This is typically done by `Leave Meeting`.

Alternatively, if the participant is the host and the last person remaining in the session, they can choose `End Meeting` by removing all other participants, which will end the session for everyone.

### `leave()`

To leave the meeting without removing all the participant you need to call `leave()` method of `Meeting` class.

### `end()`

To leave the meeting by removing all the participant you need to call `end()` method of `Meeting` class.

:::note
This methods can be called after the meeting is joined successfully.
:::

#### Example

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
  btnLeave!!.setOnClickListener { _: View? ->
    //highlight-next-line
    meeting!!.leave() // Leaving Meeting
  }

  btnEnd!!.setOnClickListener { _: View? ->
    //highlight-next-line
    meeting!!.end() // Ending Meeting
  }
```

</TabItem>

<TabItem value="Java">

```js
  btnLeave.setOnClickListener(new View.OnClickListener() {
      @Override
      public void onClick(View v) {
        //highlight-next-line
        meeting.leave(); // Leaving Meeting
      }
  });

  btnEnd.setOnClickListener(new View.OnClickListener() {
      @Override
      public void onClick(View v) {
        //highlight-next-line
        meeting.end(); // Ending Meeting
      }
  });
```

</TabItem>

</Tabs>

### Events associated with Leave

Following callbacks are received when a participant leaves the meeting.

- [Local Participant](../concept-and-architecture#2-participant) will receive a callback[`onMeetingLeft`](/android/api/sdk-reference/meeting-class/meeting-event-listener-class#onmeetingleft).
- All [remote participants](../concept-and-architecture#2-participant) will receive a callback [`onParticipantLeft`](/android/api/sdk-reference/meeting-class/meeting-event-listener-class#onparticipantleft) with Participant object.

### Events associated with End

Following callbacks are received when a participant ends the meeting.

- All [remote participants](../concept-and-architecture#2-participant) and local participant will receive a callback on [`onMeetingLeft`](/android/api/sdk-reference/meeting-class/meeting-event-listener-class#onmeetingleft) of [`MeetingEventListener`](/android/api/sdk-reference/meeting-class/meeting-event-listener-class) class.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
private final MeetingEventListener meetingEventListener = new MeetingEventListener() {
  //Event to know meeting is left
  //highlight-start
  override fun onMeetingLeft() {
    Log.d("#VideoSDK", "onMeetingleft()")
  }
  //highlight-end

  //Event to know some other participant left
  //highlight-start
  override fun onParticipantLeft(participant: Participant) {
    Log.d("#VideoSDK", participant.displayName + " left");
  }
  //highlight-end
}
```

</TabItem>

<TabItem value="Java">

```javascript
private final MeetingEventListener meetingEventListener = new MeetingEventListener() {
  //Event to know meeting is left
  //highlight-start
  @Override
  public void onMeetingLeft() {
    Log.d("#VideoSDK", "onMeetingleft()")
  }
  //highlight-end

  //Event to know some other participant left
  //highlight-start
  @Override
  public void onParticipantLeft(Participant participant) {
    Log.d("#VideoSDK", participant.getDisplayName() + " left");
  }
  //highlight-end
}
```

</TabItem>

</Tabs>

### API Reference

The API references for all the methods and events utilised in this guide are provided below.

- [leave()](/android/api/sdk-reference/meeting-class/methods#leave)
- [end()](/android/api/sdk-reference/meeting-class/methods#end)
- [onMeetingLeft()](/android/api/sdk-reference/meeting-class/meeting-event-listener-class#onmeetingleft)
- [onParticipantLeft()](/android/api/sdk-reference/meeting-class/meeting-event-listener-class#onparticipantleft)


---

---
title: Precall Setup | Video SDK
hide_title: true
hide_table_of_contents: false
description: The precall feature allows users to configure their audio and video settings,  before starting a video call, ensuring a smooth and tailored communication experience.
sidebar_label: Precall Setup
pagination_label: Precall Setup
keywords:
  - audio calling
  - video calling
  - real-time communication
  - precall
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: precall
---

# Precall Setup - Android 

Picture this: before diving into the depths of a video call, imagine giving your setup a quick check-up, like a tech-savvy doctor ensuring all systems are a go. That's essentially what a precall experience does- it’s like your extensive debug session before the main code execution—a crucial step in ensuring your app's performance is top-notch.

## Why is it necessary?

Why invest time and effort into crafting a precall experience, you wonder? Well, picture this scenario: your users eagerly join a video call, only to encounter a myriad of technical difficulties—muted microphones, pixelated cameras, and laggy connections. Not exactly the smooth user experience you had in mind, right?

By integrating a robust precall process into your app, developers become the unsung heroes, preemptively addressing potential pitfalls and ensuring that users step into their video calls with confidence.

## Step-by-Step Guide: Integrating Precall Feature

### Step 1: Check and Request Permissions

- Begin by ensuring that your application has the necessary permissions to access user devices, such as the camera, microphone and Bluetooth.
- Utilize the `checkPermissions()` method of the `VideoSDK` class to verify if permissions are granted.
- If the permissions are not granted, the method will request the required permissions.
- `PermissionHandler` is used to manage and handle permission-related events (such as granting, denying, or blocking permissions).
  - `onGranted()`: This method is called when all requested permissions are granted.
  - `onBlocked()`: This method is called when one or more permissions are permanently blocked (i.e., the user has checked "Don't ask   again").
  - `onDenied()`: This method is called when one or more permissions are denied.
  - `onJustBlocked()`: This method is called when one or more permissions are just blocked (i.e., the user has just checked "Don't ask again" for the first time).

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
private fun checkPermissions() {
    val permissionList: MutableList<Permission> = ArrayList()
    permissionList.add(Permission.audio)
    permissionList.add(Permission.video)
    permissionList.add(Permission.bluetooth)
    val options = Permissions.Options()
                  .setRationaleDialogTitle("Info")
                  .setSettingsDialogTitle("Warning")
    VideoSDK.checkPermissions(this,
        permissionList,
        options,
        permissionHandler
    )
}

private val permissionHandler: PermissionHandler = object : PermissionHandler() {
    override fun onGranted() {
      Log.d("VideoSDK Permission", "onGranted: All permissions granted")          
    }
    override fun onBlocked(
      context: Context,
      blockedList: java.util.ArrayList<Permission>
    ): Boolean {
        for (blockedPermission in blockedList) {
              Log.d("VideoSDK Permission", "onBlocked: $blockedPermission")
            }
      return super.onBlocked(context, blockedList)
    }

    override fun onDenied(
      context: Context,
      deniedPermissions: java.util.ArrayList<Permission>
    ) {
        for (deniedPermission in deniedPermissions) {
              Log.d("VideoSDK Permission", "onDenied: $deniedPermission")
            }
      super.onDenied(context, deniedPermissions)
    }

    override fun onJustBlocked(
      context: Context,
      justBlockedList: java.util.ArrayList<Permission>,
      deniedPermissions: java.util.ArrayList<Permission>
      ) {
          for (justBlockedPermission in justBlockedList) {
              Log.d("VideoSDK Permission", "onJustBlocked: $justBlockedPermission")
            }
      super.onJustBlocked(context, justBlockedList, deniedPermissions)
    }
  }
```
</TabItem>

<TabItem value="Java">

```java
private void checkPermissions() {
    List<Permission> permissionList = new ArrayList<>();
    permissionListSDK.add(Permission.audio);
    permissionListSDK.add(Permission.video);
    permissionListSDK.add(Permission.bluetooth);

    Permissions.Options options = new Permissions
      .Options()
      .setRationaleDialogTitle("Info")
      .setSettingsDialogTitle("Warning");

    VideoSDK.checkPermissions(this, permissionList, options, permissionHandler);
}

PermissionHandler permissionHandler = new PermissionHandler() {
    @Override
    public void onGranted() {
      Log.d("VideoSDK Permission", "onGranted: All permissions granted")   
    }

    @Override
    public boolean onBlocked(Context context, ArrayList<Permission> blockedList) {
        for (Permission blockedPermission : blockedList) {
                Log.d("VideoSDK Permission", "onBlocked: " + blockedPermission);
            }
            return super.onBlocked(context, blockedList);
        }

      @Override
      public void onDenied(Context context, ArrayList<Permission> deniedPermissions) {
        for (Permission deniedPermission : deniedPermissions) {
                Log.d("VideoSDK Permission", "onDenied: " + deniedPermission);
            }
            super.onDenied(context, deniedPermissions);
        }

      @Override
      public void onJustBlocked(Context context, ArrayList<Permission> justBlockedList, ArrayList<Permission> deniedPermissions) {
        for (Permission justBlockedPermission : justBlockedList) {
                Log.d("VideoSDK Permission", "onJustBlocked: " + justBlockedPermission);
            }
            super.onJustBlocked(context, justBlockedList, deniedPermissions);
        }
};
```
</TabItem>

</Tabs>


<center>

<img src="https://cdn.videosdk.live/website-resources/docs-resources/android-precall-checkPermission.png" />

</center>


### Step 2: Render Device Lists

- You can fetch and render lists of available video and audio devices using the `getVideoDevices()` and `getAudioDevices()` methods of the VideoSDK class, respectively.
  
<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
private fun getAudioaDevices() {
  
  val audioDevices: Set<AudioDeviceInfo> = VideoSDK.getAudioDevices()
    for (audioDevice in audioDevices) {
        Log.d("VideoSDK", "Audio Device's DeviceId " + audioDevice.deviceId)
        Log.d("VideoSDK", "Audio Device's Label " + audioDevice.label)
        Log.d("VideoSDK", "Audio Device's Kind " + audioDevice.kind)
    }
}

private fun getVideoDevices() {
    val videoDevices: Set<VideoDeviceInfo> = VideoSDK.getVideoDevices()
    for (videoDevice in videoDevices) {
        Log.d("VideoSDK", "Video Device's DeviceId " + videoDevice.deviceId)
        Log.d("VideoSDK", "Video Device's Label " + videoDevice.label)
        Log.d("VideoSDK", "Video Device's Kind " + videoDevice.kind)
      }
}
```
</TabItem>

<TabItem value="Java">

```java

private void getAudioDevices() {
    Set<AudioDeviceInfo> audioDevices = VideoSDK.getAudioDevices();
    for (AudioDeviceInfo audioDevice:
        audioDevices) {
        Log.d("VideoSDK", "Audio Device's DeviceId " + audioDevice.getDeviceId());
        Log.d("VideoSDK", "Audio Device's Label " + audioDevice.getLabel());
        Log.d("VideoSDK", "Audio Device's Kind " + audioDevice.getKind());
    }
}

private void getVideoDevices() {
    Set<VideoDeviceInfo> videoDevices = VideoSDK.getVideoDevices();
    for (VideoDeviceInfo videoDevice:
            videoDevices) {
        Log.d("VideoSDK", "Video Device's DeviceId " + videoDevice.getDeviceId());
        Log.d("VideoSDK", "Video Device's Label " + videoDevice.getLabel());
        Log.d("VideoSDK", "Video Device's Kind " + videoDevice.getKind());
    }        
}
```
</TabItem>

</Tabs>


<center>
<img src="https://cdn.videosdk.live/website-resources/docs-resources/android-precall-audioDeviceList-new.png"  width="300" height="600"/>
</center>


### Step 3: Handle Audio Device Changes

- Implement the `onAudioDeviceChanged()` callback of the `VideoSDK` class to dynamically re-render audio device lists whenever new devices are attached or removed from the system.
- Ensure that users can seamlessly interact with newly connected devices without disruptions.


<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
VideoSDK.setAudioDeviceChangeListener(object : VideoSDK.AudioDeviceChangeEvent {
    override fun onAudioDeviceChanged(
        selectedAudioDevice: AudioDeviceInfo?,
        audioDevices: MutableSet<AudioDeviceInfo>?
    ) {
        Log.d(
            "VideoSDK",
            "Selected Audio Device: " + selectedAudioDevice.label
        )
        for (audioDevice in audioDevices) {
            Log.d("VideoSDK", "Audio Devices" + audioDevice.label)
        }
    }
})
```

</TabItem>

<TabItem value="Java">

```java
VideoSDK.setAudioDeviceChangeListener((selectedAudioDevice, audioDevices) -> {
    Log.d("VideoSDK", "Selected Audio Device: " + selectedAudioDevice.getLabel());
    for (AudioDeviceInfo audioDevice :
            audioDevices) {
        Log.d("VideoSDK", "Audio Devices" + audioDevice.getLabel());
    }
});
```

</TabItem>

</Tabs>



import ReactPlayer from 'react-player'

<ReactPlayer controls autoplay muted loop playing url='https://cdn.videosdk.live/website-resources/docs-resources/handle-new-device-android.mp4' width={"100%"} />

### Step 4: Ensuring the selected devices are used in the Meeting

- Ensure that the status of all relevant devices, such as the microphone and camera (on/off), as well as the selected devices, are correctly configured and passed into the meeting from the precall screen.
- To select a video device, you can either create a custom track with the chosen `VideoDeviceInfo` and pass it to the `initMeeting` method of the `VideoSDK` class, or you can use the `setSelectedVideoDevice()` method of the `VideoSDK` class.
- To select an audio device, use the `setSelectedAudioDevice()` method of the `VideoSDK` class.  
- By ensuring this integration, users can seamlessly transition from the precall setup to the actual meeting while preserving their preferred settings.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
class MainActivity : AppCompatActivity() {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)

        val customTracks: MutableMap<String, CustomStreamTrack> = HashMap()

        // Specify the video device to use in the meeting
        val videoDeviceInfo: VideoDeviceInfo = selectedVideoDeviceInfo

        val videoCustomTrack = VideoSDK.createCameraVideoTrack(
            "h720p_w960p", "front", CustomStreamTrack.VideoMode.TEXT, true,
            this, VideoSDK.getSelectedVideoDevice()
        )
        customTracks["video"] = videoCustomTrack

        VideoSDK.setSelectedVideoDevice(videoDeviceInfo)

        // Specify the audio device to use in the meeting
        val audioDeviceInfo: AudioDeviceInfo = selectedAudioDeviceInfo

        VideoSDK.setSelectedAudioDevice(audioDeviceInfo)

        val meeting: Meeting = VideoSDK.initMeeting(
            this@MainActivity, "meetingId", "John Due", true,
            true, null, null, false, customTracks, null
        );
    }
}
```
</TabItem>

<TabItem value="Java">

```java
public class MainActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        Map<String, CustomStreamTrack> customTracks = new HashMap<>();

        // Specify the video device to use in the meeting
        VideoDeviceInfo videoDeviceInfo = selectedVideoDeviceInfo; 

        CustomStreamTrack videoCustomTrack = VideoSDK.createCameraVideoTrack(
            "h720p_w960p", "front", CustomStreamTrack.VideoMode.TEXT, true,
            this, VideoSDK.getSelectedVideoDevice()
        );        
        customTracks.put("video", videoCustomTrack);

        VideoSDK.setSelectedVideoDevice(videoDeviceInfo);

        // Specify the audio device to use in the meeting
        AudioDeviceInfo audioDeviceInfo = selectedAudioDeviceInfo; 
 
        VideoSDK.setSelectedAudioDevice(audioDeviceInfo);

        Meeting meeting = VideoSDK.initMeeting(
            MainActivity.this, "meetingId", "John Due",true,
            true, null, null, false, customTracks,null
        );
    }
}
```
</TabItem>

</Tabs>

### Step 5: Get Selected Devices

- VideoSDK library provides two methods, `getSelectedVideoDevice()` and `getSelectedAudioDevice()`, which allow us to determine which video and audio devices are currently selected on our Android device.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
private fun getSelectedVideoDevice(){
    Log.d("TAG", "onCreate: " + VideoSDK.getSelectedVideoDevice().label)
}

private fun getSelectedAudioDevice(){
    Log.d("TAG", "onCreate: " + VideoSDK.getSelectedAudioDevice().label)
}
```

</TabItem>

<TabItem value="Java">

```java
private void getSelectedVideoDevice() {
  VideoDeviceInfo selectedVideoDevice = VideoSDK.getSelectedVideoDevice();
  Log.d("TAG", "Selected Video Device Label: " + selectedVideoDevice.getLabel());
}

private void getSelectedAudioDevice() {
  AudioDeviceInfo selectedAudioDevice = VideoSDK.getSelectedAudioDevice();
  Log.d("TAG", "Selected Audio Device Label: " + selectedAudioDevice.getLabel());
}
```

</TabItem>

</Tabs>


By following these step-by-step instructions, you can seamlessly integrate a precall feature into your application, empowering users to optimize their audio and video setup for a superior communication experience.

:::note

You can explore the complete implementation of the Precall feature in the official Android SDK example [available here.](https://github.com/videosdk-live/videosdk-rtc-android-kotlin-sdk-example)

:::

## API Reference

The API references for all the methods utilized in this guide are provided below.

- [checkPermissions](/android/api/sdk-reference/videosdk-class/methods#checkpermissions)
- [getAudioDevices](/android/api/sdk-reference/videosdk-class/methods#getaudiodevices)
- [getVideoDevices](/android/api/sdk-reference/videosdk-class/methods#getvideodevices)
- [setAudioDeviceChangeListener](/android/api/sdk-reference/videosdk-class/events)
- [getSelectedVideoDevice](/android/api/sdk-reference/videosdk-class/properties#getselectedvideodevice)
- [getSelectedAudioDevice](/android/api/sdk-reference/videosdk-class/properties#getselectedaudiodevice)






---

---
title: Sign up for free account Custom Video SDK
hide_title: false
hide_table_of_contents: false
description: Video SDK Sign up. Get started with 10,000 minutes free every month! Programmable Video SDKs and Rest APIs to build up scalable video conferencing applications.
sidebar_label: Get your API key and Secret key
pagination_label: Get your API key and Secret key
keywords:
  - authentication audio calling
  - authentication video calling
  - authentication real-time communication
  - tokens
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: signup-and-create-api
---

import APISecret from '../../../../mdx/introduction/\_api-key.mdx';
import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>
<APISecret title="Get your API key and Secret key" />


---

---
title: Supported Device OS And Architecture
hide_title: false
hide_table_of_contents: false
description: Build customizable real-time video & audio calling applications in Android SDK using Video SDK add live Video & Audio conferencing to your applications.
sidebar_label: Supported Device OS And Architecture
pagination_label: Supported Device OS And Architecture
keywords:
  - android sdk
  - java sdk
  - kotlin sdk
  - chromebook sdk
  - supported device os and architecture
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: supported-device-os-architecture
---

# Supported Device OS and Architecture

:::note
The following device OS version represent the minimum required version to ensure full support for the listed features.
:::

import SupportList from '../../../../src/theme/SupportedListContainer'

<SupportList renderOnlySDKList={true} isiOSSDKInclude={false}/>

<br/>

# Supported ABIs

import SupportABIList from '../../../../src/theme/SupportedABIContainer'

<SupportABIList />


---

---
title: Post Transcription & Summary - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: Post Transcription features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add support for post transcription or captioning to your applications.
sidebar_label: Post Transcription & Summary
pagination_label: Post Transcription & Summary
keywords:
  - Start Post Transcription meeting
  - Stop Post Transcription meeting
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: post-transcribe-meeting
---

# Post Transcription & Summary - Android

This guide will walk you through the necessary steps to enable post-transcription functionality in your application, allowing users to access transcriptions of recorded meetings.

Moreover, VideoSDK offers flexibility in configuring post-time transcription, allowing you to set up webhooks for this purpose.

## Integrating Post Transcription Feature

![alt text](/img/transcription/post-transcription.png)

In the image above, the recording begins with transcription and summary features turned on. This triggers a webhook call for the start of recording. When the recording stops, another webhook is activated. After the recording, our transcriber starts transcribing, which in turn activates a webhook. Once the transcription is finished, it's sent to the summarizer for summary generation, and then another webhook is triggered.

### **Step 1: Configure Post Transcription & Summary**

- In this step, we set up the configuration for post transcription and summary generation. We define the webhook URL where the webhooks will be received.

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
// Webhook URL where, webhooks are received
val webhookUrl = "https://www.example.com"

//highlight-next-line
// Post Transcription Configuration
val prompt = "Write summary in sections like Title, Agenda, Speakers, Action Items, Outlines, Notes and Summary"
val summaryConfig = SummaryConfig(true, prompt)
val modelId = "raman_v1"
val transcription = PostTranscriptionConfig(true, summaryConfig, modelId)
```

</TabItem>

<TabItem value="Java">

```js
// Webhook URL where, webhooks are received
final String webhookUrl = "https://www.example.com";

//highlight-next-line
// Post Transcription Configuration
String prompt = "Write summary in sections like Title, Agenda, Speakers, Action Items, Outlines, Notes and Summary";
SummaryConfig summaryConfig = new SummaryConfig(true, prompt);
String modelId = "raman_v1";
PostTranscriptionConfig transcription = new PostTranscriptionConfig(true, summaryConfig, modelId);
```

</TabItem>

</Tabs>

### **Step 2: Start Recording with Transcription Configuration**

- Once the configuration is set, we initiate the recording process for the meeting, incorporating the transcription configuration we defined earlier.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
// Start Recording
meeting!!.startRecording(webhookUrl, "AWS Directory Path", null, transcription)
```

</TabItem>

<TabItem value="Java">

```js
// Start Recording
meeting.startRecording(webhookUrl, "AWS Directory Path", null, transcription);
```

</TabItem>

</Tabs>

### **Step 3: Stop Recording**

- When the meeting concludes or recording is no longer needed, we stop the recording process.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
// Stop Recording
meeting!!.stopRecording()
```

</TabItem>

<TabItem value="Java">

```js
// Stop Recording
meeting.stopRecording();
```

</TabItem>

</Tabs>

### **Step 4: Fetch Post Transcriptions**

- After the meeting recording is stopped, post transcription and summary data can be obtained using the [Post Transcription API](/api-reference/realtime-communication/fetch-post-transcriptions-summary).

- The API provides information such as the status of transcription, file paths for transcription data in various formats (JSON, SRT, TXT, TSV, VTT), and a summarized text file.

- The transcription document is structured as follows:

```json
{
  "id": "40b0a4ed-9842-40c9-a288-e4b1bf98a90a",
  "status": "completed",
  "roomId": "abc-xyzw-lmno",
  "sessionId": "621497578bea0d0404c35c4c",
  "recordingId": "65d303d6d2c373dfd71b38a2",
  "filePath": "https://cdn.videosdk.live/encoded/videos/dummy.mp4",
  "transcriptionFilePaths": {
    "json": "https://cdn.videosdk.live/transcriptions/dummy/dummy.json",
    "srt": "https://cdn.videosdk.live/transcriptions/dummy/dummy.srt",
    "txt": "https://cdn.videosdk.live/transcriptions/dummy/dummy.txt",
    "tsv": "https://cdn.videosdk.live/transcriptions/dummy/dummy.tsv",
    "vtt": "https://cdn.videosdk.live/transcriptions/dummy/dummy.vtt"
  },
  "summarizedFilePaths": {
    "txt": "https://cdn.videosdk.live/transcriptions/dummy/dummy-summary.txt"
  },
  "userStorage": null,
  "start": "2024-02-27T16:00:36.828Z",
  "end": "2024-02-27T16:01:46.939Z"
}
```

### Example

- The following code snippet allows you to start and stop recording meetings with just a click. When you click the "Start Recording" button, it begins recording the meeting and enables post-transcription, which generates a summary of the meeting's content. Clicking the "Stop Recording" button ends the recording.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
import android.os.Bundle
import android.widget.Button
import android.widget.Toast
import androidx.appcompat.app.AppCompatActivity

class MeetingActivity : AppCompatActivity() {
    private lateinit var meeting: Meeting

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_meeting)

        //initialize a meeting
        //...

        val startButton = findViewById<Button>(R.id.startRecording)
        val stopButton = findViewById<Button>(R.id.stopRecording)

        startButton.setOnClickListener {
            //highlight-start
            // Configuration for post transcription
            val prompt = "Write summary in sections like Title, Agenda, Speakers, Action Items, Outlines, Notes and Summary"
            val summaryConfig = SummaryConfig(true, prompt)
            val modelId = "raman_v1"
            val transcription = PostTranscriptionConfig(true, summaryConfig, modelId)

            // If you don't have a `webhookUrl` or `awsDirPath`, you have to pass null.
            // Start recording with post transcription
            meeting.startRecording("YOUR WEB HOOK URL", "AWS Directory Path", null, transcription)
            //highlight-end
        }

        stopButton.setOnClickListener {
            //highlight-start
            // Stop recording
            meeting.stopRecording()
            //highlight-end
        }
    }
}
```

</TabItem>

<TabItem value="Java">

```js
import android.os.Bundle;
import android.widget.Button;
import android.widget.Toast;
import androidx.appcompat.app.AppCompatActivity;

public class MeetingActivity extends AppCompatActivity {
    private Meeting meeting;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_meeting);

        //initialize a meeting
        //...

        Button startButton = findViewById(R.id.startRecording);
        Button stopButton = findViewById(R.id.stopRecording);

        startButton.setOnClickListener(v -> {
            //highlight-start
            // Configuration for post transcription
            String prompt = "Write summary in sections like Title, Agenda, Speakers, Action Items, Outlines, Notes and Summary";
            SummaryConfig summaryConfig = new SummaryConfig(true, prompt);
            String modelId = "raman_v1";
            PostTranscriptionConfig transcription = new PostTranscriptionConfig(true, summaryConfig, modelId);

            // If you don't have a `webhookUrl` or `awsDirPath`, you have to pass null.
            // Start recording with post transcription
            meeting.startRecording("YOUR WEB HOOK URL", "AWS Directory Path", null, transcription);
            //highlight-end
        });

        stopButton.setOnClickListener(v -> {
            //highlight-start
            // Stop recording
            meeting.stopRecording();
            //highlight-end
        });
    }
}
```

</TabItem>

</Tabs>

:::important

Please be aware that there may be a delay in processing the transcription data after the recording has been stopped. This delay could vary depending on factors such as server load and the duration of the meeting.

:::

### API Reference

The API references for all the methods utilized in this guide are provided below.

- [startRecording()](/android/api/sdk-reference/meeting-class/methods#startrecording)
- [stopRecording()](/android/api/sdk-reference/meeting-class/methods#stoprecording)
- [fetchPostTranscriptions](/api-reference/realtime-communication/fetch-post-transcriptions-summary)


---

---
title: Realtime Transcription - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: Realtime Transcription features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with VideoSDK to add support for realtime transcription or captioning to your applications.
sidebar_label: Realtime Transcription
pagination_label: Realtime Transcription
keywords:
  - Start Realtime Transcription meeting
  - Stop Realtime Transcription meeting
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: realtime-transcribe-meeting
---

# Realtime Transcription - Android

Realtime transcription allows you to transcribe audio content into text in real-time during a session. This guide will walk you through using the `startTranscription()` and `stopTranscription()` functions to manage realtime transcription in your application.

Moreover, VideoSDK offers flexibility in configuring real-time transcription, allowing you to set up webhooks for this purpose.

## Integrating Realtime Transcription Feature

![alt text](/img/transcription/realtime-transcription.png)

The above image represents,

1. **Start Transcription:** The SDK Client initiates real-time transcription using the `startTranscription` method.

2. **Resource Acquisition:** VideoSDK server requests necessary resources from transcription service.

   - If the request is denied, the server sends a `transcription-failed` event to the SDK Client.
   - If the request is successful, the server sends a `onTranscriptionStateChanged` event with status `TRANSCRIPTION_STARTED` to the client, indicating that transcription has begun.

3. **Transcription Data:** As transcription progresses, the client receives `onTranscriptionText` event with data such as the text itself, participant ID, and timestamp.

4. **Stop Transcription:** When the client decides to stop transcription, it informs the VideoSDK server to release resources.
   - The server then sends a `onTranscriptionStateChanged` event with status `TRANSCRIPTION_STOPPED` to confirm that transcription has ended and resources are released.

### **Step 1: Configure Realtime Transcription**

- In this step, we set up the configuration for realtime transcription. We define the webhook URL where the webhooks will be received.

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
// Webhook URL where, webhooks are received
val webhookUrl = "YOUR_WEBHOOK_URL"

//highlight-next-line
// Realtime Transcription Configuration
val summaryConfig = SummaryConfig(
    true,
    "Write summary in sections like Title, Agenda, Speakers, Action Items, Outlines, Notes and Summary"
)
val transcription = TranscriptionConfig(
    webhookUrl,
    summaryConfig
)
```

</TabItem>

<TabItem value="Java">

```js
// Webhook URL where, webhooks are received
final String webhookUrl = "YOUR_WEBHOOK_URL";

//highlight-next-line
// Realtime Transcription Configuration
SummaryConfig summaryConfig = new SummaryConfig(
    true,
    "Write summary in sections like Title, Agenda, Speakers, Action Items, Outlines, Notes and Summary"
);
TranscriptionConfig transcription = new TranscriptionConfig(
    webhookUrl,
    summaryConfig
);
```

</TabItem>

</Tabs>

### **Step 2: Listen for the transcription events**

- Here, we configure the callback methods for transcription events.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
private val meetingEventListener: MeetingEventListener = object : MeetingEventListener() {
  override fun onTranscriptionStateChanged(data: JSONObject) {
    try {
        val status = data.getString("status")
        val id = data.getString("id")
        when (status) {
            TranscriptionState.TRANSCRIPTION_STARTING.name -> Log.d("onTranscriptionStateChanged", "Realtime Transcription is starting, ID: $id")
            TranscriptionState.TRANSCRIPTION_STARTED.name -> Log.d("onTranscriptionStateChanged", "Realtime Transcription is started, ID: $id")
            TranscriptionState.TRANSCRIPTION_STOPPING.name -> Log.d("onTranscriptionStateChanged", "Realtime Transcription is stopping, ID: $id")
            TranscriptionState.TRANSCRIPTION_STOPPED.name -> Log.d("onTranscriptionStateChanged", "Realtime Transcription is stopped, ID: $id")
            else -> Log.d("onTranscriptionStateChanged", "Unknown transcription state: $status, ID: $id")
        }
    } catch (e: JSONException) {
        Log.e("onTranscriptionStateChanged", "Error parsing transcription state", e)
    }
  }

  override fun onTranscriptionText(data: TranscriptionText) {
    val participantId: String = data.participantId
    val participantName: String = data.participantName
    val text: String = data.text
    val timestamp: Int = data.timestamp
    val type: String = data.type

    Log.d("onTranscriptionText", "$participantName: $text $timestamp")
  }
}

override fun onCreate(savedInstanceState: Bundle?) {
  //...

  // add listener to meeting
  //highlight-next-line
  meeting!!.addEventListener(meetingEventListener)
}
```

</TabItem>

<TabItem value="Java">

```js
private final MeetingEventListener meetingEventListener = new MeetingEventListener() {
  @Override
    public void onTranscriptionStateChanged(JSONObject data) {
        try {
            String status = data.getString("status");
            String id = data.getString("id");

            if (TranscriptionState.TRANSCRIPTION_STARTING.name().equals(status)) {
                Log.d("onTranscriptionStateChanged", "Realtime Transcription is starting, ID: " + id);
            }
            else if (TranscriptionState.TRANSCRIPTION_STARTED.name().equals(status)) {
                Log.d("onTranscriptionStateChanged", "Realtime Transcription is started, ID: " + id);
            }
            else if (TranscriptionState.TRANSCRIPTION_STOPPING.name().equals(status)) {
                Log.d("onTranscriptionStateChanged", "Realtime Transcription is stopping, ID: " + id);
            }
            else if (TranscriptionState.TRANSCRIPTION_STOPPED.name().equals(status)) {
                Log.d("onTranscriptionStateChanged", "Realtime Transcription is stopped, ID: " + id);
            }
            else {
                Log.d("onTranscriptionStateChanged", "Unknown transcription state: " + status + ", ID: " + id);
            }
        } catch (JSONException e) {
            Log.e("onTranscriptionStateChanged", "Error parsing transcription state", e.getMessage());
        }
    }

    @Override
    public void onTranscriptionText(TranscriptionText data) {
        String participantId = data.getParticipantId();
        String participantName = data.getParticipantName();
        String text = data.getText();
        int timestamp = data.getTimestamp();
        String type = data.getType();

        Log.d("onTranscriptionText", participantName + ": " + text + " " + timestamp);
    }
}

@Override
protected void onCreate(Bundle savedInstanceState) {
  //...

  // add listener to meeting
  //highlight-next-line
  meeting.addEventListener(meetingEventListener);
}
```

</TabItem>

</Tabs>

### **Step 3: Start realtime transcription**

- Initiate the realtime transcription using the `startTranscription()` method.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
fun startRealtimeTranscription() {
    // Webhook URL where, webhooks are received
    val webhookUrl = "YOUR_WEBHOOK_URL"

    //highlight-next-line
    // Realtime Transcription Configuration
    val summaryConfig = SummaryConfig(
        true,
        "Write summary in sections like Title, Agenda, Speakers, Action Items, Outlines, Notes and Summary"
    )
    val transcription = TranscriptionConfig(
        webhookUrl,
        summaryConfig
    )

    //highlight-next-line
    meeting!!.startTranscription(transcription)
}
```

</TabItem>

<TabItem value="Java">

```js
private void startRealtimeTranscription() {
    // Webhook URL where, webhooks are received
    final String webhookUrl = "YOUR_WEBHOOK_URL";

    //highlight-next-line
    // Realtime Transcription Configuration
    SummaryConfig summaryConfig = new SummaryConfig(
        true,
        "Write summary in sections like Title, Agenda, Speakers, Action Items, Outlines, Notes and Summary"
    );
    TranscriptionConfig transcription = new TranscriptionConfig(
        webhookUrl,
        summaryConfig
    );

    //highlight-next-line
    meeting.startTranscription(transcription);
}
```

</TabItem>

</Tabs>

### **Step 4: Stop realtime transcription**

- Terminate the realtime transcription using the `stopTranscription() `method.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
fun stopRealtimeTranscription() {
    meeting!!.stopTranscription()
}
```

</TabItem>

<TabItem value="Java">

```js
private void stopRealtimeTranscription() {
    meeting.stopTranscription();
}
```

</TabItem>

</Tabs>

:::important

You can access a summary of your realtime transcription using the **[<u>Fetch Realtime Transcription API</u>](/api-reference/realtime-communication/fetch-a-realtime-transcription)**.

:::

### Example

- The following code snippet allows you to start and stop realtime transcription with just a click. When you click the "Start Realtime Transcription" button, it begins realtime transcription. Clicking the "Stop Realtime Transcription" button ends the realtime transcription.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
import android.os.Bundle
import android.util.Log
import android.widget.Button
import androidx.appcompat.app.AppCompatActivity
import org.json.JSONObject

class MeetingActivity : AppCompatActivity() {
    private lateinit var meeting: Meeting

    // add meetingEventListener to handle transcription events
    private val meetingEventListener = object : MeetingEventListener {
        override fun onTranscriptionStateChanged(data: JSONObject) {
            val status = data.getString("status")
            Log.d("MeetingActivity", "Transcription status: $status")
        }

        override fun onTranscriptionText(data: TranscriptionText) {
            val participantId = data.participantId
            val participantName = data.participantName
            val text = data.text
            val timestamp = data.timestamp
            val type = data.type

            Log.d("MeetingActivity", "$participantName: $text $timestamp")
        }
    }

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_meeting)

        //initialize a meeting
        //...

        val startButton: Button = findViewById(R.id.startTranscriptionButton)
        val stopButton: Button = findViewById(R.id.stopTranscriptionButton)

        startButton.setOnClickListener { startRealtimeTranscription() }
        stopButton.setOnClickListener { stopRealtimeTranscription() }

        // add listener to meeting
        meeting!!.setEventListener(meetingEventListener)
    }

    private fun startRealtimeTranscription() {
        // Configuration for realtime transcription
        val summaryConfig = SummaryConfig(
            true,
            "Write summary in sections like Title, Agenda, Speakers, Action Items, Outlines, Notes and Summary"
        )
        val transcriptionConfig = TranscriptionConfig(
            null,
            summaryConfig
        )

        // Call to start transcription with the specified configuration
        meeting!!.startTranscription(transcriptionConfig)
    }

    private fun stopRealtimeTranscription() {
        // Call to stop transcription
        meeting!!.stopTranscription()
    }
}
```

</TabItem>

<TabItem value="Java">

```js
import android.os.Bundle;
import android.util.Log;
import android.widget.Button;
import android.widget.Toast;
import androidx.appcompat.app.AppCompatActivity;

public class MeetingActivity extends AppCompatActivity {
    private Meeting meeting;

    // add meetingEventListener to handle transcription events
    private final MeetingEventListener meetingEventListener = new MeetingEventListener() {
        @Override
        public void onTranscriptionStateChanged(JSONObject data) {
            String status = data.getString("status");
            Log.d("MeetingActivity", "Transcription status: " + status);
        }

        @Override
        public void onTranscriptionText(TranscriptionText data) {
            String participantId = data.getParticipantId();
            String participantName = data.getParticipantName();
            String text = data.getText();
            int timestamp = data.getTimestamp();
            String type = data.getType();

            Log.d("MeetingActivity", participantName + ": " + text + " " + timestamp);
        }
    };

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_meeting);

        //initialize a meeting
        //...

        Button startButton = findViewById(R.id.startTranscriptionButton);
        Button stopButton = findViewById(R.id.stopTranscriptionButton);

        startButton.setOnClickListener(v -> startRealtimeTranscription());
        stopButton.setOnClickListener(v -> stopRealtimeTranscription());

        // add listener to meeting
        meeting.setEventListener(meetingEventListener);
    }

    private void startRealtimeTranscription() {
        // Configuration for realtime transcription
        SummaryConfig summaryConfig = new SummaryConfig(
            true,
            "Write summary in sections like Title, Agenda, Speakers, Action Items, Outlines, Notes and Summary"
        );
        TranscriptionConfig transcriptionConfig = new TranscriptionConfig(
            null,
            summaryConfig
        );

        // Call to start transcription with the specified configuration
        meeting.startTranscription(transcriptionConfig);
    }

    private void stopRealtimeTranscription() {
        // Call to stop transcription
        meeting.stopTranscription();
    }
}
```

</TabItem>

</Tabs>

### API Reference

The API references for all the methods utilized in this guide are provided below.

- [startTranscription()](/android/api/sdk-reference/meeting-class/methods#starttranscription)
- [stopTranscription()](/android/api/sdk-reference/meeting-class/methods#stoptranscription)
- [onTranscriptionStateChanged](/android/api/sdk-reference/meeting-class/meeting-event-listener-class#ontranscriptionstatechanged)
- [onTranscriptionText](/android/api/sdk-reference/meeting-class/meeting-event-listener-class#ontranscriptiontext)


---

---
title: Integrate Banuba SDK with Android SDK - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: Describes how to integrate Banuba SDK with videosdk.live using Android SDK to enhance video calls with real-time face filters and virtual backgrounds.
sidebar_label: "Banuba Integration"
pagination_label: "Banuba Integration"
keywords:
  - android sdk
  - java sdk
  - kotlin sdk
  - banuba
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: banuba-integration
---

# How to integrate Banuba SDK with Android Video SDK?

The Banuba SDK is a software development kit that enables developers to integrate advanced augmented reality (AR) features, such as real-time face filters and effects, into their apps. It is widely used for creating engaging video experiences in applications like video conferencing, live streaming, and social media platforms.

<center>
<img src='https://assets.videosdk.live/images/android-banuba.png' style={{height: '400px'}}/>
</center>

To integrate the Banuba SDK with Android Video SDK, follow these steps:

### Step 1: Get Banuba Token

- To begin working with the Banuba SDK in your project, you'll need Banuba's client token.
- You can obtain this token by following the instructions in Banuba's documentation at [banuba.com](https://www.banuba.com/)

### Step 2: Add Banuba SDK dependencies

- Add custom maven repo to your `settings.gradle`:

```js title="settings.gradle"
dependencyResolutionManagement {
    repositoriesMode.set(RepositoriesMode.FAIL_ON_PROJECT_REPOS)
    repositories {
        google()
        mavenCentral()
        maven {
            name = "GitHubPackages"
            url = uri("https://maven.pkg.github.com/sdk-banuba/banuba-sdk-android")
            credentials {
                username = "sdk-banuba"
                password = "\u0067\u0068\u0070\u005f\u004a\u0067\u0044\u0052\u0079\u0049\u0032\u006d\u0032\u004e\u0055\u0059\u006f\u0033\u0033\u006b\u0072\u0034\u0049\u0069\u0039\u0049\u006f\u006d\u0077\u0034\u0052\u0057\u0043\u0064\u0030\u0052\u0078\u006d\u0045\u0069"
            }
        }
        maven { url 'https://jitpack.io' }
        maven { url "https://maven.aliyun.com/repository/jcenter" }
}}
```

- Add Banuba SDK and VideoSDK dependencies in `app/build.gradle` file.

```js title="app/build.gradle"
dependencies {
  // Banuba SDK dependencies
    implementation "com.banuba.sdk:banuba_sdk:1+"
  // Video SDK dependencies
    implementation 'live.videosdk:rtc-android-sdk:0.3.0'
  // other app dependencies
  }
```
### Step 3: Initialization of Banuba SDK

1. Create a `MainApplication` class that extends `android.app.Application`.

2. Within the `MainApplication` class, create a KEY field to store the token you generated from Banuba. This token will be used to initialize the `BanubaSdkManager`.

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js title="MainApplication.kt"
class MainApplication : Application() {
    override fun onCreate() {
        super.onCreate()

        //...
        val key = "Banuba Client Token"
        BanubaSdkManager.initialize(requireNonNull(applicationContext), key)
    }

    override fun onTerminate() {
        BanubaSdkManager.deinitialize()
        super.onTerminate()
    }
}
```

</TabItem>

<TabItem value="Java">
  
```js title="MainApplication.java"
public class MainApplication extends Application {
    @Override
    public void onCreate() {
        super.onCreate();

        //...
        String KEY ="Banuba Client Token";
        BanubaSdkManager.initialize(requireNonNull(getApplicationContext()), KEY);
    }
    @Override
    public void onTerminate() {
        BanubaSdkManager.deinitialize();
        super.onTerminate();
    }
}
```

</TabItem>

</Tabs>

### Step 4: Add effects into your project

- Create an effects folder under the assets directory in your project and add the filters you want to use. You can download test filters from here [Effects](https://docs.banuba.com/face-ar-sdk-v1/overview/demo_face_filters)

<div style={{textAlign: 'center'}}>

![Banuba SDK effects folder](/img/android/banuba/banuba_effects.png)

</div>

### Step 5: Integration of BanubaProcessor

- The `BanubaProcessor` class will implement the `VideoFrameProcessor` interface from VideoSDK.
- The `VideoFrameProcessor` interface provides `onFrameCaptured()` method, which is invoked when a new video frame is captured.
- The `onFrameCaptured()` method is used to manipulate the `VideoFrame` in order to achieve the desired effects.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js title="BanubaProcessor.kt"
class BanubaProcessor : VideoFrameProcessor {
    private var mPlayer: Player = Player()
    private var mFrameOutput: FrameOutput? = null
    private val eglContext: EglBase.Context = EglBase.create().eglBaseContext
    private var mSurfaceTextureHelper: SurfaceTextureHelper? = null
    private var videoFrame: VideoFrame? = null
    private val streamInput: StreamInput = StreamInput()

    init {
        mSurfaceTextureHelper = SurfaceTextureHelper.create("CaptureThread", eglContext, false)
    }

    // set a visual effect in the Banuba Player
    fun setEffect(effect: String) {
        mPlayer.loadAsync("effects/$effect")
        mPlayer.play()
    }

    // remove any applied effects
    fun removeEffect() {
        mPlayer.loadAsync("")
    }

    fun removePlayer() {
        // close the player when it's no longer needed
        mPlayer.close()
    }

    // method to initialize the frame output for video processing
    private fun initOutput(): VideoFrame? {
        val handler = mSurfaceTextureHelper!!.handler
        mFrameOutput = FrameOutput { iOutput, framePixelBuffer ->
            handler.post {
                val i420Buffer = JavaI420Buffer.wrap(
                    framePixelBuffer.width,
                    framePixelBuffer.height,
                    framePixelBuffer.getPlane(0),
                    framePixelBuffer.getBytesPerRowOfPlane(0),
                    framePixelBuffer.getPlane(1),
                    framePixelBuffer.getBytesPerRowOfPlane(1),
                    framePixelBuffer.getPlane(2),
                    framePixelBuffer.getBytesPerRowOfPlane(2),
                    null
                )
                videoFrame = VideoFrame(i420Buffer, 0, System.nanoTime())
            }
        }
        mFrameOutput!!.format = FramePixelBufferFormat.I420_BT601_FULL

        handler.postDelayed({
            mFrameOutput?.close()
        }, 2000)

        // attach the FrameOutput to the player for rendering
        mPlayer.use(mFrameOutput)

        // Return the processed video frame
        return videoFrame
    }

     // called whenever a new video frame is captured
    override fun onFrameCaptured(videoFrame: VideoFrame?): VideoFrame? {
        if (videoFrame != null) {
            // Determine the camera orientation based on the rotation of the video frame
            val cameraOrientation = CameraOrientation.values()[(videoFrame.rotation / 90) % 4]
            val orientation = FullImageData.Orientation(cameraOrientation, true, 0)
            val i420Buffer = videoFrame.buffer.toI420()

            // create FullImageData using the frame data and orientation
            val fullImageData = FullImageData(
                Size(i420Buffer.width, i420Buffer.height),
                i420Buffer.dataY,
                i420Buffer.dataU,
                i420Buffer.dataV,
                i420Buffer.strideY,
                i420Buffer.strideU,
                i420Buffer.strideV,
                1, 1, 1,
                orientation
            )

            val frameData = FrameData.create() ?: return null
            frameData.addFullImg(fullImageData)
            i420Buffer.release()
            streamInput.push(frameData, videoFrame.timestampNs)

            // attach the StreamInput to the player for further processing
            mPlayer.use(streamInput)

            // return the processed video frame
            return initOutput()
        }
        return null
    }
}
```

</TabItem>

<TabItem value="Java">

```js title="BanubaProcessor.java"
public class BanubaProcessor implements VideoFrameProcessor {
    private Player mPlayer;
    private FrameOutput mFrameOutput;
    private final EglBase.Context eglContext = EglBase.create().getEglBaseContext();
    private SurfaceTextureHelper mSurfaceTextureHelper;
    VideoFrame videoFrame;
    final StreamInput streamInput = new StreamInput();

    public BanubaProcessor (){
        mSurfaceTextureHelper = SurfaceTextureHelper.create("CaptureThread", eglContext, false);
        mPlayer = new Player();
    }
    // set a visual effect in the Banuba Player
    public void setEffect(String effect)
    {
        mPlayer.loadAsync("effects/" + effect);
        mPlayer.play();
    }
    // remove any applied effects
    public void removeEffect()
    {
        mPlayer.loadAsync("");
    }
    public void removePlayer()
    {
        // close the player when it's no longer needed
        mPlayer.close();
    }
    // method to initialize the frame output for video processing
    private VideoFrame initOutput() {
        final Handler handler = mSurfaceTextureHelper.getHandler();
        mFrameOutput = new FrameOutput((iOutput, framePixelBuffer) -> {
            handler.post(() -> {

                final JavaI420Buffer i420buffer = JavaI420Buffer.wrap(
                        framePixelBuffer.getWidth(),
                        framePixelBuffer.getHeight(),
                        framePixelBuffer.getPlane(0),
                        framePixelBuffer.getBytesPerRowOfPlane(0),
                        framePixelBuffer.getPlane(1),
                        framePixelBuffer.getBytesPerRowOfPlane(1),
                        framePixelBuffer.getPlane(2),
                        framePixelBuffer.getBytesPerRowOfPlane(2),
                        null);
                videoFrame = new VideoFrame(i420buffer, 0, System.nanoTime());
            });
        });
        mFrameOutput.setFormat(FramePixelBufferFormat.I420_BT601_FULL);
        
        handler.postDelayed(() -> {
            mFrameOutput.close();
        },2000);

        // attach the FrameOutput to the player for rendering
        mPlayer.use(mFrameOutput);

        // return the processed video frame
        return videoFrame;
    }
    // called whenever a new video frame is captured
    @Override
    public VideoFrame onFrameCaptured(VideoFrame videoFrame) {
        if(videoFrame != null) {
            // determine the camera orientation based on the rotation of the video frame
            final CameraOrientation cameraOrientation = CameraOrientation.values()[(videoFrame.getRotation() / 90) % 4];
            final FullImageData.Orientation orientation = new FullImageData.Orientation(cameraOrientation, true, 0);
            final VideoFrame.I420Buffer i420Buffer = videoFrame.getBuffer().toI420();
            // create FullImageData using the frame data and orientation
            final FullImageData fullImageData = new FullImageData(
                    new Size(i420Buffer.getWidth(), i420Buffer.getHeight()),
                    i420Buffer.getDataY(),
                    i420Buffer.getDataU(),
                    i420Buffer.getDataV(),
                    i420Buffer.getStrideY(),
                    i420Buffer.getStrideU(),
                    i420Buffer.getStrideV(),
                    1, 1, 1,
                    orientation);
            final FrameData frameData = Objects.requireNonNull(FrameData.create());
            frameData.addFullImg(fullImageData);
            i420Buffer.release();
            streamInput.push(frameData, videoFrame.getTimestampNs());
            // attach the StreamInput to the player for further processing
            mPlayer.use(streamInput);
            // return the processed video frame
            return initOutput();
        }
        return null;
    }
}
```

</TabItem>

</Tabs>

### Step 5: Use filters in the Meeting

- First, create an instance of `BanubaProcessor` class and pass it to the `applyVideoProcessor()` method of `VideoSDK` class.
- Next, use the `setEffect` method on the instance of `BanubaProcessor` class apply the desired effect.
- To apply video filters from the beginning of the meeting, you can call `setEffect` method in `onMeetingJoined` event.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">


```js title="MainActivity.kt"
private val meetingEventListener = object : MeetingEventListener {
    override fun onMeetingJoined() {
        val banubaProcessor = BanubaProcessor()
        VideoSDK.applyVideoProcessor(banubaProcessor)
        //here you can pass any effect that you want to apply
        banubaProcessor.setEffect("PineappleGlasses")
    }
}
```

</TabItem>

<TabItem value="Java">

```js title="MainActivity.java"
private final MeetingEventListener meetingEventListener = new MeetingEventListener() {
    @Override
    public void onMeetingJoined() {
        BanubaProcessor banubaProcessor = new BanubaProcessor();
        VideoSDK.applyVideoProcessor(banubaProcessor);
        //here you can pass any effect that you want to apply
        banubaProcessor.setEffect("PineappleGlasses");
    }
};
```

</TabItem>

</Tabs>

:::tip

Stuck anywhere? Check out this [Code Sample of Banuba Intergation with Android-SDK](https://github.com/videosdk-live/videosdk-rtc-android-sdk-banuba-example.git) on GitHub

:::


---

---
sidebar_label: Overview
pagination_label: Overview
---

# Video Processor - Android

VideoSDK allows you to add custom effects to your video stream before it's transmitted during video calls. This lets you enhance your video in creative ways or achieve specific functionalities.

### Understanding Video Processing

Video processing involves manipulating raw video data (frames) captured by your camera. You can create native processors to enhance video streams during meetings.


### The `VideoFrameProcessor` Interface

The `VideoFrameProcessor` interface defines a way for your code to interact with the video stream. It essentially lets you intercept each frame before it's sent and apply your processing logic.

#### Key Function: `onFrameCaptured`

This is the heart of video processing with VideoSDK. Whenever a new video frame is captured by your camera, the `onFrameCaptured` function is called. This function provides you with the raw frame data, allowing you to modify it as needed.

### How it Works:

1. **Implement the Interface:** Create a class that implements the `VideoFrameProcessor` interface. Within this class, define the `onFrameCaptured` function.

2. **Process the Frame:** In the `onFrameCaptured` function, access the raw video frame data. Apply your desired effects or manipulations to this data.

3. **Return the Processed Frame:** After processing the frame, return the modified version to VideoSDK. This processed frame will then be transmitted during the video call.

4. **Apply the Processor:** To apply a processor, pass an object of your class as a parameter to the `applyVideoProcessor()` method of the `VideoSDK` class.

5. **Remove the Processor:** To stop applying the selected video processor, use the `removeVideoProcessor()` method of the `VideoSDK` class.

## API Reference

The API references for all the methods utilized in this guide are provided below.

- [applyVideoProcessor()](/android/api/sdk-reference/videosdk-class/methods#applyvideoprocessor)
- [removeVideoProcessor()](/android/api/sdk-reference/videosdk-class/methods#removevideoprocessor)


---

---
title: Custom Tracks
hide_title: true
hide_table_of_contents: false
description: Custom Video Track features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Custom Tracks
pagination_label: Custom Tracks
keywords:
  - custom Track
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
---

## Custom Video Track - Android

- You can create a Video Track using `createCameraVideoTrack()` method of `VideoSDK`.
- This method can be used to create video track using different encoding parameters, camera facing mode, and optimization mode.

### Parameters

- **encoderConfig**:

  - type: `String`
  - required: `true`
  - default: `h480p_w720p`
  - You can chose from the below mentioned list of values for the encoder config.

| Encoder Config | Resolution | Frame Rate |   Bitrate    |
| -------------- | :--------: | :--------: | :----------: |
| h144p_w176p    |  176x144   |   15 fps   | 120000 kbps  |
| h240p_w320p    |  320x240   |   15 fps   | 150000 kbps  |
| h480p_w640p    |  640x480   |   25 fps   | 300000 kbps  |
| h480p_w720p    |  720x480   |   30 fps   | 450000 kbps  |
| h720p_w960p    |  720x960   |   30 fps   | 1500000 kbps |
| h1080p_w1440p  | 1080x1440  |   30 fps   | 2500000 kbps |
| h720p_w1280p   |  720x1280  |   30 fps   | 2000000 kbps |
| h360p_w640p    |  360x640   |   30 fps   | 400000 kbps  |  

:::note

Above mentioned encoder configurations are valid for both, landscape as well as portrait mode.

:::

- **facingMode**:

  - type: `String`
  - required: `true`
  - Allowed values : `front` | `back`
  - It will specify wheater to use front or back camera for the video track.

- **optimizationMode**

  - type: `CustomStreamTrack.VideoMode`
  - required: `true`
  - Allowed values: `motion` | `text` | `detail`
  - It will specify the optimization mode for the video track being generated.

- **multiStream**:

  - type: `boolean`
  - required: `true`
  - It will specify if the stream should send multiple resolution layers or single resolution layer.

- **context**:

  - type: `Context`
  - required: `true`
  - Pass the Android Context for this parameter.

- **observer**:

  - type: `CapturerObserver`
  - required: `false`
  - If you want to use video filter from external SDK(e.g., [Banuba](https://www.banuba.com/)) then pass instance of `CapturerObserver` in this parameter.

- **videoDeviceInfo**:

  - type: `VideoDeviceInfo`
  - required: `false`
  - If you want to specify a camera device to be used in the meeting.

:::note

For Banuba integraion with VideoSDK, please visit [Banuba Intergation with VideoSDK](/android/guide/video-and-audio-calling-api-sdk/video-processor/banuba-integration)

:::

:::info

- To learn more about optimizations and best practices for using custom video tracks, [follow this guide](/android/guide/video-and-audio-calling-api-sdk/render-media/optimize-video-track).

:::

#### Returns

- `CustomStreamTrack`

### Example

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
val videoCustomTrack: CustomStreamTrack = VideoSDK.createCameraVideoTrack("h720p_w960p", "front", CustomStreamTrack.VideoMode.MOTION, false, this)
```

</TabItem>

<TabItem value="Java">

```javascript
CustomStreamTrack customStreamTrack = VideoSDK.createCameraVideoTrack("h720p_w960p", "front", CustomStreamTrack.VideoMode.MOTION, false, this);
```

</TabItem>

</Tabs>

## Custom Audio Track - Android

- You can create a Audio Track using `createAudioTrack()` method of `VideoSDK`.
- This method can be used to create audio track using different encoding parameters.

### Parameters

- **encoderConfig**:

  - type: `String`
  - required: `true`
  - default: `speech_standard`
  - You can chose from the below mentioned list of values for the encoder config.

| Encoder Config      | Bitrate  | Auto Gain | Echo Cancellation | Noise Suppression |
| ------------------- | :------: | :-------: | :---------------: | :---------------: |
| speech_low_quality  | 16 kbps  |   TRUE    |       TRUE        |       TRUE        |
| speech_standard     | 24 kbps  |   TRUE    |       TRUE        |       TRUE        |
| music_standard      | 32 kbps  |   FALSE   |       FALSE       |       FALSE       |
| standard_stereo     | 64 kbps  |   FALSE   |       FALSE       |       FALSE       |
| high_quality        | 128 kbps |   FALSE   |       FALSE       |       FALSE       |
| high_quality_stereo | 192 kbps |   FALSE   |       FALSE       |       FALSE       |

- **context**

  - type: `Context`
  - required: `true`
  - Pass the Android Context for this parameter.

#### Returns

- `CustomStreamTrack`

### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
val audioCustomTrack: CustomStreamTrack = VideoSDK.createAudioTrack("speech_standard",this)
```

</TabItem>

<TabItem value="Java">

```js
CustomStreamTrack audioCustomTrack=VideoSDK.createAudioTrack("speech_standard", this);
```

</TabItem>

</Tabs>

## Custom Screen Share Track - Android

- You can create a Screen Share track using `createScreenShareVideoTrack()` method of `VideoSDK`.
- This method can be used to create screen share track using different encoding parameters.

### Parameters

- **encoderConfig**:

  - type: `String`
  - required: `true`
  - default: `h720p_15fps`
  - You can chose from the below mentioned list of values for the encoder config.

| Encoder Config | Resolution | Frame Rate |   Bitrate    |
| -------------- | :--------: | :--------: | :----------: |
| h360p_30fps    |  640x360   |   3 fps    | 200000 kbps  |
| h720p_5fps     |  1280x720  |   5 fps    | 400000 kbps  |
| h720p_15fps    |  1280x720  |   15 fps   | 1000000 kbps |
| h1080p_15fps   | 1920x1080  |   15 fps   | 1500000 kbps |
| h1080p_30fps   | 1920x1080  |   15 fps   | 1000000 kbps |

:::note

Above mentioned encoder configurations are valid for both, landscape as well as portrait mode.

:::

- **data**

  - type: `Intent`
  - required: `true`
  - It is Intent received from onActivityResult when user provide permission for ScreenShare.

- **context**

  - type: `Context`
  - required: `true`
  - Pass the Android Context for this parameter.

- **listener**
  - type: `CustomTrackListener`
  - required: `true`
  - Callback to this listener will be made when track is ready with CustomTrack as parameter.

### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
// data is received from onActivityResult method.
VideoSDK.createScreenShareVideoTrack("h720p_15fps", data, this) { track ->
    meeting!!.enableScreenShare(track)
}
```

</TabItem>

<TabItem value="Java">

```javascript
// data is received from onActivityResult method.
VideoSDK.createScreenShareVideoTrack("h720p_15fps", data, this, (track)->{
    meeting.enableScreenShare(track);
});
```

</TabItem>

</Tabs>


---

---
sidebar_position: 2
sidebar_label: Meeting Error Codes
pagination_label: Meeting Error Codes
title: Meeting Error Codes
---

# Meeting Error Codes - Android

If you encounter any of the errors listed below, refer to the [Developer Experience Guide](../../guide/best-practices/developer-experience.md#listen-for-error-events), which offers recommended solutions based on common error categories.

import ServerErrorCodes from '../../../../mdx/\_server-error-codes.mdx'
import SDKErrorCodes from '../../data/\_sdk-error-codes.mdx'

<ServerErrorCodes />

<SDKErrorCodes/>





---

---
sidebar_position: 2
sidebar_label: Initializing a Meeting
pagination_label: Initializing a Meeting
title: Initializing a Meeting
---

# Initializing a Meeting - Android

<div class="sdk-api-ref">

## initialize()

To initialize the meeting, first you have to initialize the `VideoSDK`.
You can initialize the `VideoSDK` using `initialize()` method provided by the SDK.

#### Parameters

- **context**: Context

#### Returns

- _`void`_

```js title="initialize"
  VideoSDK.initialize(Context context)
```

---

## config()

Now, you have to set `token` property of `VideoSDK` class.
By using `config()` method, you can set the `token` property of `VideoSDK` class.

Please refer this [documentation](/api-reference/realtime-communication/intro/) to generate a token.

#### Parameters

- **token**: String

#### Returns

- _`void`_

```js title="config"
 VideoSDK.config(String token)
```

---

## initMeeting()

- Now, you can initialize the meeting using a factory method provided by the SDK called `initMeeting()`.
- `initMeeting()` will generate a new [`Meeting`](./meeting-class/introduction.md) class and the initiated meeting will be returned.

```js title="initMeeting"
   VideoSDK.initMeeting(
        Context context,
        String meetingId,
        String name,
        boolean micEnabled,
        boolean webcamEnabled,
        String participantId,
        String mode,
        boolean multiStream,
        Map<String, CustomStreamTrack> customTracks
        JSONObject metaData,
        String signalingBaseUrl,
        PreferredProtocol preferredProtocol
      )
```

## Parameters

### context

- Context of activity.

  - type : Context
  - `REQUIRED`

### meetingId

- Unique Id of the meeting where that participant will be joining.

  - type : `String`
  - `REQUIRED`

Please refer this [documentation](/api-reference/realtime-communication/create-room) to create a room.

### name

- Name of the participant who will be joining the meeting, this name will be displayed to other participants in the same meeting.

  - type : String
  - `REQUIRED`

### micEnabled

- Whether `mic` of the participant will be on while joining the meeting. If it is set to `false`, then mic of that participant will be `disabled` by default, but can be `enabled` or `disabled` later.

  - type: `Boolean`
  - `REQUIRED`

### webcamEnabled

- Whether `webcam` of the participant will be on while joining the meeting. If it is set to `false`, then webcam of that participant will be `disabled` by default, but can be `enabled` or `disabled` later.

  - type: `Boolean`
  - `REQUIRED`

### participantId

- Unique Id of the participant. If you passed `null` then SDK will create an Id by itself and will use that id.

  - type : `String` or `null`
  - `REQUIRED`

### Modes

There are three modes available:

- **`SEND_AND_RECV`**: In this mode, both audio and video streams will be produced and consumed.

- **`SIGNALLING_ONLY`**: In this mode, no audio or video streams will be produced or consumed. It is used solely for signaling.

- **`RECV_ONLY`**: This mode allows only the consumption of audio and video streams without producing any.

**Type**: `String` or `null`  
**Default Value**: `SEND_AND_RECV`

import CautionMessage from '@site/src/theme/CautionMessage';

<CautionMessage sdk="Android SDK" version="v0.2.0" />

### multiStream

- It will specify if the stream should send multiple resolution layers or single resolution layer.

  - type: `boolean`
  - `REQUIRED`

### customTracks

- If you want to use custom tracks from start of the meeting, you can pass map of custom tracks in this paramater.

  - type : `Map<String, CustomStreamTrack>` or `null`
  - `REQUIRED`

Please refer this [documentation](../../guide/video-and-audio-calling-api-sdk/features/custom-track/custom-video-track) to know more about CustomTrack.

### metaData

- If you want to provide additional details about a user joining a meeting, such as their profile image, you can pass that information in this parameter.

  - type: `JSONObject`
  - `REQUIRED`

### signalingBaseUrl

- If you want to use a proxy server with the VideoSDK, you can specify your baseURL here.

  - type: `String`
  - `OPTIONAL`

:::note

If you intend to use a proxy server with the VideoSDK, priorly inform us at support@videosdk.live

:::

### preferredProtocol

- If you want to provide a preferred network protocol for communication, you can specify that in `PreferredProtocol`, with options including `UDP_ONLY`, `UDP_OVER_TCP`, and `TCP_ONLY`.

  - type: `PreferredProtocol`
  - `OPTIONAL`

## Returns

### meeting

- After initializing the meeting, `initMeeting()` will return a new [`Meeting`](./meeting-class/introduction.md) instance.

---

## Example

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js title="initMeeting"

VideoSDK.initialize(applicationContext)

// Configure the token
VideoSDK.config(token) // pass the token generated from VideoSDK Dashboard

// Initialize the meeting
var meeting = VideoSDK.initMeeting(
  arrayOf(
    this@MainActivity,
    "abc-1234-xyz",
    "John Doe",
    true,
    true,
    null,
    null,
    false,
    null,
    null
  )
)
```

</TabItem>

<TabItem value="Java">

```js title="initMeeting"

VideoSDK.initialize(getApplicationContext());

// Configure the token
VideoSDK.config(token);  // pass the token generated from VideoSDK Dashboard

// Initialize the meeting
Meeting meeting = VideoSDK.initMeeting({
  MainActivity.this,
  "abc-1234-xyz",
  "John Doe",
  true,
  true,
  null,
  null,
  false,
  null,
  null,
  null
});
```

</TabItem>

</Tabs>

</div>


---

---
title: MediaEffects library
hide_title: true
hide_table_of_contents: false
description: The MediaEffects library enhances video applications by providing advanced media effects, including virtual backgrounds.
sidebar_label: MediaEffects library
pagination_label: MediaEffects library
keywords:
  - Apply Virtual Background
  - Remove Virtual Background
  - Change Virtual Background
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
---

# MediaEffects library - Android

<div id="tailwind" class="sdk-api-ref">

## Introduction

- The `MediaEffects` library enhances video applications with advanced media effects, including virtual backgrounds. It supports real-time processing and is optimized for Android devices.

- The `MediaEffects` library offers three classes to customize your video background: using a custom image, applying a blur effect, or choosing a solid color.

:::info

The Virtual Background feature in VideoSDK can be utilized regardless of the meeting environment, including the pre-call screen.

:::

## 1. BackgroundImageProcessor

- `BackgroundImageProcessor` sets a specified image as the background in a video stream, allowing you to customize the visual appearance of the video.
- `BackgroundImageProcessor` class provides following method.

  - `setBackgroundSource()` method updates the virtual background by setting a new image as the background that the user wants to switch to.
  
     - **Parameters**: `Uri`: An image URI for the background image.

     - **Return Type**: `void`
  
import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
val uri = Uri.parse("https://st.depositphotos.com/2605379/52364/i/450/depositphotos_523648932-stock-photo-concrete-rooftop-night-city-view.jpg")
val backgroundImageProcessor = BackgroundImageProcessor(uri) // Sets the background image

val newUri = Uri.parse("https://img.freepik.com/free-photo/plant-against-blue-wall-mockup_53876-96052.jpg?size=626&ext=jpg&ga=GA1.1.2008272138.1723420800&semt=ais_hybrid")
backgroundImageProcessor.setBackgroundSource(newUri) // Changed background image
```

</TabItem>

<TabItem value="Java">

```java
Uri uri = Uri.parse("https://st.depositphotos.com/2605379/52364/i/450/depositphotos_523648932-stock-photo-concrete-rooftop-night-city-view.jpg");
BackgroundImageProcessor backgroundImageProcessor= new BackgroundImageProcessor(uri); // Sets the background image

Uri uri = Uri.parse("https://img.freepik.com/free-photo/plant-against-blue-wall-mockup_53876-96052.jpg?size=626&ext=jpg&ga=GA1.1.2008272138.1723420800&semt=ais_hybrid");
backgroundImageProcessor.setBackgroundSource(uri); //Changed background image
```
</TabItem>

</Tabs>


## 2. BackgroundBlurProcessor
- `BackgroundBlurProcessor` applies a blur effect to the video background, with the intensity controlled by a float value, creating a softened visual effect.
- `BackgroundBlurProcessor` class provides following method.

  - `setBlurRadius()` method adjusts the blur effect on the video background, with the blur strength controlled by the specified float value.
  

     - **Parameters**: `Float`: representing the blur strength; higher values mean stronger blur. The supported range is 0 to 25.

     - **Return Type**: `void`


<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
val backgroundBlurProcessor = BackgroundBlurProcessor(25, this) // Applies a blur with intensity 25
backgroundBlurProcessor.setBlurRadius(17) // Changes the blur intensity to 17
```

</TabItem>

<TabItem value="Java">

```java
BackgroundBlurProcessor backgroundBlurProcessor = new BackgroundBlurProcessor(25, this);// Applies a blur with intensity 25
backgroundBlurProcessor.setBlurRadius(17); // changes the blur intensity to 17
```
</TabItem>

</Tabs>

## 3. BackgroundColorProcessor
- `BackgroundColorProcessor` sets a solid color as the video background using a `Color` object, enabling you to create a uniform color backdrop for your video.
- `BackgroundColorProcessor` class provides following method.

  - `setBackgroundColor()` method sets the color that user wants to switch to, for virtual background effect.

     - **Parameters**: `Integer`: Specifies the color for the virtual background.
     - **Return Type**: `void`

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
val backgroundColorProcessor = BackgroundColorProcessor(Color.BLUE) // Sets the background color to blue
backgroundColorProcessor.setBackgroundColor(Color.CYAN) // Changes the background color to CYAN
```

</TabItem>

<TabItem value="Java">

```java
BackgroundColorProcessor backgroundColorProcessor = new BackgroundColorProcessor(Color.BLUE);// Sets the background color to blue
backgroundColorProcessor.setBackgroundColor(Color.CYAN); // changed the background color to CYAN
```
</TabItem>

</Tabs>

</div>

---

---
sidebar_position: 1
sidebar_label: Introduction
pagination_label: Intro to Video SDK Meeting Class
title: Video SDK Meeting Class
---

# Video SDK Meeting Class - Android

<div class="sdk-api-ref">

## Introduction

The `Meeting` class includes properties, methods and meeting-event-listener-class for managing a meeting, participants, video, audio and share streams, messaging and UI customization.

import LinksGrid from "../../../../../src/theme/LinksGrid";
import properties from "./../data/meeting-class/properties.json";
import methods from "./../data/meeting-class/methods.json";
import events from "./../data/meeting-class/events.json";

## Meeting Properties

<div class="row">

<div class="col col--4 margin-bottom--sm" >

- [getmeetingId()](/android/api/sdk-reference/meeting-class/properties#getmeetingid)

</div>
<div class="col col--4 margin-bottom--sm" >

- [getLocalParticipant()](./properties#getlocalparticipant)

</div>
<div class="col col--4 margin-bottom--sm" >

- [getConnectionState()](./properties#getconnectionstate)

</div>
<div class="col col--4 margin-bottom--sm" >

- [getParticipants()](./properties#getparticipants)

</div>
<div class="col col--4 margin-bottom--sm" >

- [pubSub](./properties#pubsub)

</div>

</div>

## Meeting Methods

<div class="row">

<div class="col col--4 margin-bottom--sm" >

- [join()](./methods#join)

</div>
<div class="col col--4 margin-bottom--sm" >

- [leave()](./methods#leave)

</div>
<div class="col col--4 margin-bottom--sm" >

- [end()](./methods#end)

</div>
<div class="col col--4 margin-bottom--sm" >

- [enableWebcam()](./methods#enablewebcam)

</div>
<div class="col col--4 margin-bottom--sm" >

- [disableWebcam()](./methods#disablewebcam)

</div>
<div class="col col--4 margin-bottom--sm" >

- [unmuteMic()](./methods#unmutemic)

</div>
<div class="col col--4 margin-bottom--sm" >

- [muteMic()](./methods#mutemic)

</div>
<div class="col col--4 margin-bottom--sm" >

- [enableScreenShare()](./methods#enablescreenshare)

</div>
<div class="col col--4 margin-bottom--sm" >

- [disableScreenShare()](./methods#disablescreenshare)

</div>
<div class="col col--4 margin-bottom--sm" >

- [startRecording()](./methods#startrecording)

</div>
<div class="col col--4 margin-bottom--sm" >

- [stopRecording()](./methods#stoprecording)

</div>
<div class="col col--4 margin-bottom--sm" >

- [startLiveStream()](./methods#startlivestream)

</div>
<div class="col col--4 margin-bottom--sm" >

- [stopLiveStream()](./methods#stoplivestream)

</div>
<div class="col col--4 margin-bottom--sm" >

- [startHls()](./methods#starthls)

</div>
<div class="col col--4 margin-bottom--sm" >

- [stopHls()](./methods#stophls)

</div>
<div class="col col--4 margin-bottom--sm" >

- [startTranscription()](./methods#starttranscription)

</div>
<div class="col col--4 margin-bottom--sm" >

- [stopTranscription()](./methods#stoptranscription)

</div>
<div class="col col--4 margin-bottom--sm" >

- [changeMode()](./methods#changemode)

</div>
<div class="col col--4 margin-bottom--sm" >

- [getMics()](./methods#getmics)

</div>
<div class="col col--4 margin-bottom--sm" >

- [changeMic()](./methods#changemic)

</div>
<div class="col col--4 margin-bottom--sm" >

- [setAudioDeviceChangeListener()](./methods#setaudiodevicechangelistener)

</div>
<div class="col col--4 margin-bottom--sm" >

- [changeWebcam()](./methods#changewebcam)

</div>
<div class="col col--4 margin-bottom--sm" >

- [uploadBase64File()](./methods#uploadbase64file)

</div>
<div class="col col--4 margin-bottom--sm" >

- [fetchBase64File()](./methods#fetchbase64file)

</div>
<div class="col col--4 margin-bottom--sm" >

- [addEventListener()](./methods#addeventlistener)

</div>
<div class="col col--4 margin-bottom--sm" >

- [removeEventListener()](./methods#removeeventlistener)

</div>
<div class="col col--4 margin-bottom--sm" >

- [removeAllListeners()](./methods#removealllisteners)

</div>
<div class="col col--4 margin-bottom--sm" >

- [startWhiteboard()](./methods#startwhiteboard)

</div>
<div class="col col--4 margin-bottom--sm" >

- [stopWhiteboard()](./methods#stopwhiteboard)

</div>
<div class="col col--4 margin-bottom--sm" >

- [pauseAllStreams()](./methods#pauseallstreams)

</div>
<div class="col col--4 margin-bottom--sm" >

- [resumeAllStreams()](./methods#resumeallstreams)

</div>

<div class="col col--4 margin-bottom--sm" >

- [requestMediaRelay()](./methods#requestmediarelay)

</div>

<div class="col col--4 margin-bottom--sm" >

- [stopMediaRelay()](./methods#stopmediarelay)

</div>

<div class="col col--4 margin-bottom--sm" >

- [switchTo()](./methods#switchto)

</div>

</div>

## Meeting Events

<div class="row">

<div class="col col--4 margin-bottom--sm" >

- [onMeetingJoined](./meeting-event-listener-class#onmeetingjoined)

</div>
<div class="col col--4 margin-bottom--sm" >

- [onMeetingLeft](./meeting-event-listener-class#onmeetingleft)

</div>
<div class="col col--4 margin-bottom--sm" >

- [onParticipantJoined](./meeting-event-listener-class#onparticipantjoined)

</div>
<div class="col col--4 margin-bottom--sm" >

- [onParticipantLeft](./meeting-event-listener-class#onparticipantleft)

</div>
<div class="col col--4 margin-bottom--sm" >

- [onSpeakerChanged](./meeting-event-listener-class#onspeakerchanged)

</div>
<div class="col col--4 margin-bottom--sm" >

- [onPresenterChanged](./meeting-event-listener-class#onpresenterchanged)

</div>
<div class="col col--4 margin-bottom--sm" >

- [onEntryRequested](./meeting-event-listener-class#onentryrequested)

</div>
<div class="col col--4 margin-bottom--sm" >

- [onEntryResponded](./meeting-event-listener-class#onentryresponded)

</div>
<div class="col col--4 margin-bottom--sm" >

- [onWebcamRequested](./meeting-event-listener-class#onwebcamrequested)

</div>
<div class="col col--4 margin-bottom--sm" >

- [onMicRequested](./meeting-event-listener-class#onmicrequested)

</div>
<div class="col col--4 margin-bottom--sm" >

- [onRecordingStateChanged](./meeting-event-listener-class#onrecordingstatechanged)

</div>
<div class="col col--4 margin-bottom--sm" >

- [onRecordingStarted](./meeting-event-listener-class#onrecordingstarted)

</div>
<div class="col col--4 margin-bottom--sm" >

- [onRecordingStopped](./meeting-event-listener-class#onrecordingstopped)

</div>
<div class="col col--4 margin-bottom--sm" >

- [onLivestreamStateChanged](./meeting-event-listener-class#onlivestreamstatechanged)

</div>
<div class="col col--4 margin-bottom--sm" >

- [onLivestreamStarted](./meeting-event-listener-class#onlivestreamstarted)

</div>
<div class="col col--4 margin-bottom--sm" >

- [onLivestreamStopped](./meeting-event-listener-class#onlivestreamstopped)

</div>
<div class="col col--4 margin-bottom--sm" >

- [onHlsStateChanged](./meeting-event-listener-class#onhlsstatechanged)

</div>
<div class="col col--4 margin-bottom--sm" >

- [onTranscriptionStateChanged](./meeting-event-listener-class#ontranscriptionstatechanged)

</div>
<div class="col col--4 margin-bottom--sm" >

- [onTranscriptionText](./meeting-event-listener-class#ontranscriptiontext)

</div>
<div class="col col--4 margin-bottom--sm" >

- [onExternalCallStarted](./meeting-event-listener-class#onexternalcallstarted)

</div>
<div class="col col--4 margin-bottom--sm" >

- [onMeetingStateChanged](./meeting-event-listener-class#onmeetingstatechanged)

</div>
<div class="col col--4 margin-bottom--sm" >

- [onParticipantModeChanged](./meeting-event-listener-class#onparticipantmodechanged)

</div>
<div class="col col--4 margin-bottom--sm" >

- [onPinStateChanged()](./meeting-event-listener-class#onpinstatechanged)

</div>

<div class="col col--4 margin-bottom--sm" >

- [onWhiteboardStarted()](./meeting-event-listener-class#onwhiteboardstarted)

</div>

<div class="col col--4 margin-bottom--sm" >

- [onWhiteboardStopped()](./meeting-event-listener-class#onwhiteboardstopped)

</div>

<div class="col col--4 margin-bottom--sm" >

- [onExternalCallRinging()](./meeting-event-listener-class#onexternalcallringing)

</div>

<div class="col col--4 margin-bottom--sm" >

- [onExternalCallStarted()](./meeting-event-listener-class#onexternalcallstarted-1)

</div>

<div class="col col--4 margin-bottom--sm" >

- [onExternalCallHangup()](./meeting-event-listener-class#onexternalcallhangup)

</div>

<div class="col col--4 margin-bottom--sm" >

- [onPausedAllStreams()](./meeting-event-listener-class#onpausedallstreams)

</div>

<div class="col col--4 margin-bottom--sm" >

- [onResumedAllStreams()](./meeting-event-listener-class#onresumedallstreams)

</div>

<div class="col col--4 margin-bottom--sm" >

- [onMediaRelayRequestReceived()](./meeting-event-listener-class#onmediarelayrequestreceived)

</div>

<div class="col col--4 margin-bottom--sm" >

- [onMediaRelayRequestResponse()](./meeting-event-listener-class#onmediarelayrequestreceived)

</div>

<div class="col col--4 margin-bottom--sm" >

- [onMediaRelayStarted()](./meeting-event-listener-class#onmediarelaystarted)

</div>

<div class="col col--4 margin-bottom--sm" >

- [onMediaRelayStopped()](./meeting-event-listener-class#onmediarelaystopped)

</div>

<div class="col col--4 margin-bottom--sm" >

- [onMediaRelayError()](./meeting-event-listener-class#onmediarelayerror)

</div>




</div>

</div>


---

---
sidebar_position: 1
sidebar_label: MeetingEventListener Class
pagination_label: MeetingEventListener Class
title: MeetingEventListener Class
---

# MeetingEventListener Class - Android

<div class="sdk-api-ref-only-h4">

---

### implementation

- You can implement all the methods of `MeetingEventListener` abstract Class and add the listener to `Meeting` class using the `addEventListener()` method of `Meeting` Class.

#### Example

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
private final MeetingEventListener meetingEventListener = new MeetingEventListener() {
  override fun onMeetingJoined() {
    Log.d("#meeting", "onMeetingJoined()")
  }
}
```

</TabItem>

<TabItem value="Java">

```javascript
private final MeetingEventListener meetingEventListener = new MeetingEventListener() {
  @Override
  public void onMeetingJoined() {
    Log.d("#meeting", "onMeetingJoined()");
  }
}
```

</TabItem>

</Tabs>

---

### onMeetingJoined()

- This event will be emitted when a [localParticipant](./properties#getlocalparticipant) successfully joined the meeting.

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
 override fun onMeetingJoined() {
    Log.d("#meeting", "onMeetingJoined()")
 }
```

</TabItem>

<TabItem value="Java">

```javascript
 @Override
 public void onMeetingJoined() {
     Log.d("#meeting", "onMeetingJoined()");
 }
```

</TabItem>

</Tabs>

---

### onMeetingLeft()

- This event will be emitted when a [localParticipant](./properties#getlocalparticipant) left the meeting.

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
 override fun onMeetingLeft() {
    Log.d("#meeting", "onMeetingLeft()")
 }
```

</TabItem>

<TabItem value="Java">

```javascript
 @Override
 public void onMeetingLeft() {
    Log.d("#meeting", "onMeetingLeft()");
 }
```

</TabItem>

</Tabs>

---

### onParticipantJoined()

- This event will be emitted when a new [participant](../participant-class/introduction) joined the meeting.

#### Event callback parameters

- **participant**: [Participant](../participant-class/introduction)

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
 override fun onParticipantJoined(participant: Participant) {
    Log.d("#meeting", participant.displayName + " joined");
 }
```

</TabItem>

<TabItem value="Java">

```javascript
 @Override
 public void onParticipantJoined(Participant participant) {
    Log.d("#meeting", participant.getDisplayName() + " joined");
 }
```

</TabItem>

</Tabs>

---

### onParticipantLeft

- This event will be emitted when a joined [participant](../participant-class/introduction) left the meeting.

#### Event callback parameters

- **participant**: [Participant](../participant-class/introduction)

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
 override fun onParticipantLeft(participant: Participant) {
    Log.d("#meeting", participant.displayName + " left");
 }
```

</TabItem>

<TabItem value="Java">

```javascript
 @Override
 public void onParticipantLeft(Participant participant) {
    Log.d("#meeting", participant.getDisplayName() + " left");
 }
```

</TabItem>

</Tabs>

---

### onSpeakerChanged()

- This event will be emitted when a active speaker changed.
- If you want to know which participant is actively speaking, then this event will be used.
- If no participant is actively speaking, then this event will pass `null` as en event callback parameter.

#### Event callback parameters

- **participantId**: String

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
 override fun onSpeakerChanged(participantId: String?) {
  //
 }
```

</TabItem>

<TabItem value="Java">

```javascript
 @Override
 public void onSpeakerChanged(String participantId) {
  //
 }
```

</TabItem>

</Tabs>

---

### onPresenterChanged()

- This event will be emitted when any [participant](../participant-class/introduction) starts or stops screen sharing.
- It will pass `participantId` as an event callback parameter.
- If a participant stops screensharing, then this event will pass `null` as en event callback parameter.

#### Event callback parameters

- **participantId**: String

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
 override fun onPresenterChanged(participantId: String) {
  //
 }
```

</TabItem>

<TabItem value="Java">

```javascript
 @Override
 public void onPresenterChanged(String participantId) {
  //
 }
```

</TabItem>

</Tabs>

---

### onEntryRequested()

- This event will be emitted when a new [participant](../participant-class/introduction) who is trying to join the meeting, is having permission **`ask_join`** in token.
- This event will only be emitted to the [participants](./properties#getparticipants) in the meeting, who is having the permission **`allow_join`** in token.
- This event will pass following parameters as an event parameters, `participantId` and `name` of the new participant who is trying to join the meeting, `allow()` and `deny()` to take required actions.

#### Event callback parameters

- **peerId**: String
- **name**: String

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
 override fun onEntryRequested(id: String?, name: String?) {
    //
}
```

</TabItem>

<TabItem value="Java">

```javascript
 @Override
 public void onEntryRequested(String id, String name) {
    //
}
```

</TabItem>

</Tabs>

---

### onEntryResponded()

- This event will be emitted when the `join()` request is responded.
- This event will be emitted to the [participants](./properties#getparticipants) in the meeting, who is having the permission **`allow_join`** in token.
- This event will be also emitted to the [participant](../participant-class/introduction) who requested to join the meeting.

#### Event callback parameters

- **participantId**: _String_
- **decision**: _"allowed"_ | _"denied"_

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
 override fun onEntryResponded(id: String?, decision: String?) {
    //
  }
```

</TabItem>

<TabItem value="Java">

```javascript
 @Override
 public void onEntryResponded(String id, String decision) {
    //
  }
```

</TabItem>

</Tabs>

---

### onWebcamRequested()

- This event will be emitted to the participant `B` when any other participant `A` requests to enable webcam of participant `B`.
- On accepting the request, webcam of participant `B` will be enabled.

#### Event callback parameters

- **participantId**: String
- **listener**: WebcamRequestListener \{ **accept**: Method; **reject**: Method }

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
  override fun onWebcamRequested(participantId: String, listener: WebcamRequestListener) {
     // if accept request
     listener.accept()

     // if reject request
     listener.reject()
 }
```

</TabItem>

<TabItem value="Java">

```javascript
  @Override
 public void onWebcamRequested(String participantId, WebcamRequestListener listener) {
     // if accept request
     listener.accept();

     // if reject request
     listener.reject();
 }
```

</TabItem>

</Tabs>

### onMicRequested()

- This event will be emitted to the participant `B` when any other participant `A` requests to enable mic of participant `B`.
- On accepting the request, mic of participant `B` will be enabled.

#### Event callback parameters

- **participantId**: String
- **listener**: MicRequestListener \{ **accept**: Method; **reject**: Method }

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
 override fun onMicRequested(participantId: String, listener: MicRequestListener) {
     // if accept request
     listener.accept()

     // if reject request
     listener.reject()
 }
```

</TabItem>

<TabItem value="Java">

```javascript
 @Override
 public void onMicRequested(String participantId, MicRequestListener listener) {
     // if accept request
     listener.accept();

     // if reject request
     listener.reject();
 }
```

</TabItem>

</Tabs>

---

### onRecordingStateChanged()

- This event will be emitted when the meeting's recording status changed.

#### Event callback parameters

- **recordingState**: String

`recordingState` has following values

- `RECORDING_STARTING` - Recording is in starting phase and hasn't started yet.
- `RECORDING_STARTED` - Recording has started successfully.
- `RECORDING_STOPPING` - Recording is in stopping phase and hasn't stopped yet.
- `RECORDING_STOPPED` - Recording has stopped successfully.

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
  override fun onRecordingStateChanged(recordingState: String) {
    when (recordingState) {
        "RECORDING_STARTING" -> {
            Log.d("onRecordingStateChanged", "Meeting recording is starting")
        }
        "RECORDING_STARTED" -> {
            Log.d("onRecordingStateChanged", "Meeting recording is started")
        }
        "RECORDING_STOPPING" -> {
            Log.d("onRecordingStateChanged", "Meeting recording is stopping")
        }
        "RECORDING_STOPPED" -> {
            Log.d("onRecordingStateChanged", "Meeting recording is stopped")
        }
    }
  }
```

</TabItem>

<TabItem value="Java">

```javascript
  @Override
  public void onRecordingStateChanged(String recordingState) {
      switch (recordingState) {
          case "RECORDING_STARTING":
              Log.d("onRecordingStateChanged", "Meeting recording is starting");
              break;
          case "RECORDING_STARTED":
              Log.d("onRecordingStateChanged", "Meeting recording is started");
              break;
          case "RECORDING_STOPPING":
              Log.d("onRecordingStateChanged", "Meeting recording is stopping");
              break;
          case "RECORDING_STOPPED":
              Log.d("onRecordingStateChanged", "Meeting recording is stopped");
              break;
      }
  }
```

</TabItem>

</Tabs>

---

### onRecordingStarted()

_`This event will be deprecated soon`_

- This event will be emitted when recording of the meeting is started.

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
 override fun onRecordingStarted() {
   //
 }
```

</TabItem>

<TabItem value="Java">

```javascript
 @Override
 public void onRecordingStarted() {
   //
 }
```

</TabItem>

</Tabs>

---

### onRecordingStopped()

_`This event will be deprecated soon`_

- This event will be emitted when recording of the meeting is stopped.

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
 override fun onRecordingStopped() {
   //
 }
```

</TabItem>

<TabItem value="Java">

```javascript
 @Override
 public void onRecordingStopped() {
   //
 }
```

</TabItem>

</Tabs>

---

### onLivestreamStateChanged()

- This event will be emitted when the meeting's livestream status changed.

#### Event callback parameters

- **livestreamState**: String

`livestreamState` has following values

- `LIVESTREAM_STARTING` - Livestream is in starting phase and hasn't started yet.
- `LIVESTREAM_STARTED` - Livestream has started successfully.
- `LIVESTREAM_STOPPING` - Livestream is in stopping phase and hasn't stopped yet.
- `LIVESTREAM_STOPPED` - Livestream has stopped successfully.

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
  override fun onLivestreamStateChanged(livestreamState: String?) {
    when (livestreamState) {
        "LIVESTREAM_STARTING" -> Log.d( "LivestreamStateChanged",
            "Meeting livestream is starting"
        )
        "LIVESTREAM_STARTED" -> Log.d( "LivestreamStateChanged",
            "Meeting livestream is started"
        )
        "LIVESTREAM_STOPPING" -> Log.d("LivestreamStateChanged",
            "Meeting livestream is stopping"
        )
        "LIVESTREAM_STOPPED" -> Log.d("LivestreamStateChanged",
            "Meeting livestream is stopped"
        )
    }
  }
```

</TabItem>

<TabItem value="Java">

```javascript
  @Override
  public void onLivestreamStateChanged(String livestreamState) {
      switch (livestreamState) {
          case "LIVESTREAM_STARTING":
              Log.d("LivestreamStateChanged", "Meeting livestream is starting");
              break;
          case "LIVESTREAM_STARTED":
              Log.d("LivestreamStateChanged", "Meeting livestream is started");
              break;
          case "LIVESTREAM_STOPPING":
              Log.d("LivestreamStateChanged", "Meeting livestream is stopping");
              break;
          case "LIVESTREAM_STOPPED":
              Log.d("LivestreamStateChanged", "Meeting livestream is stopped");
              break;
      }
  }
```

</TabItem>

</Tabs>

---

### onLivestreamStarted()

_`This event will be deprecated soon`_

- This event will be emitted when `RTMP` live stream of the meeting is started.

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
 override fun onLivestreamStarted() {
   //
 }
```

</TabItem>

<TabItem value="Java">

```javascript
 @Override
 public void onLivestreamStarted() {
   //
 }
```

</TabItem>

</Tabs>

---

### onLivestreamStopped()

_`This event will be deprecated soon`_

- This event will be emitted when `RTMP` live stream of the meeting is stopped.

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
 override fun onLivestreamStopped() {
   //
 }
```

</TabItem>

<TabItem value="Java">

```javascript
 @Override
 public void onLivestreamStopped() {
   //
 }
```

</TabItem>

</Tabs>

---

### onHlsStateChanged()

- This event will be emitted when the meeting's HLS(Http Livestreaming) status changed.

#### Event callback parameters

- **HlsState**: \{ **status**: String}

  - `status` has following values :
    - `HLS_STARTING` - HLS is in starting phase and hasn't started yet.
    - `HLS_STARTED` - HLS has started successfully.
    - `HLS_PLAYABLE` - HLS can be playable now.
    - `HLS_STOPPING` - HLS is in stopping phase and hasn't stopped yet.
    - `HLS_STOPPED` - HLS has stopped successfully.

- when you receive `HLS_PLAYABLE` status you will receive 2 urls in response
  - `playbackHlsUrl` - Live HLS with playback support
  - `livestreamUrl` - Live HLS without playback support

:::note
`downstreamUrl` is now depecated. Use `playbackHlsUrl` or `livestreamUrl` in place of `downstreamUrl`
:::

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
  override fun onHlsStateChanged(HlsState: JSONObject) {
    when (HlsState.getString("status")) {
        "HLS_STARTING" -> Log.d("onHlsStateChanged", "Meeting hls is starting")
        "HLS_STARTED" -> Log.d("onHlsStateChanged", "Meeting hls is started")
        "HLS_PLAYABLE" -> {
            Log.d("onHlsStateChanged", "Meeting hls is playable now")
            // on hls playable you will receive playbackHlsUrl and livestreamUrl
            val playbackHlsUrl = HlsState.getString("playbackHlsUrl")
            val livestreamUrl = HlsState.getString("livestreamUrl")

        }
        "HLS_STOPPING" -> Log.d("onHlsStateChanged", "Meeting hls is stopping")
        "HLS_STOPPED" -> Log.d("onHlsStateChanged", "Meeting hls is stopped")
    }
  }
```

</TabItem>

<TabItem value="Java">

```javascript
  @Override
  public void onHlsStateChanged(JSONObject HlsState) {
      switch (HlsState.getString("status")) {
          case "HLS_STARTING":
              Log.d("onHlsStateChanged", "Meeting hls is starting");
              break;
          case "HLS_STARTED":
              Log.d("onHlsStateChanged", "Meeting hls is started");
              break;
          case "HLS_PLAYABLE":
              Log.d("onHlsStateChanged", "Meeting hls is playable now");
              // on hls started you will receive playbackHlsUrl and livestreamUrl
              String playbackHlsUrl = HlsState.getString("playbackHlsUrl");
              String livestreamUrl = HlsState.getString("livestreamUrl");
              break;
          case "HLS_STOPPING":
              Log.d("onHlsStateChanged", "Meeting hls is stopping");
              break;
          case "HLS_STOPPED":
              Log.d("onHlsStateChanged", "Meeting hls is stopped");
              break;
      }
  }
```

</TabItem>

</Tabs>

---

### onTranscriptionStateChanged()

- This event will be triggered whenever state of realtime transcription is changed.

#### Event callback parameters

- **data**: \{ **status**: String, **id**: String }
  - **status**: String
  - **id**: String

`status` has following values

- `TRANSCRIPTION_STARTING` - Realtime Transcription is in starting phase and hasn't started yet.
- `TRANSCRIPTION_STARTED` - Realtime Transcription has started successfully.
- `TRANSCRIPTION_STOPPING` - Realtime Transcription is in stopping phase and hasn't stopped yet.
- `TRANSCRIPTION_STOPPED` - Realtime Transcription has stopped successfully.

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
override fun onTranscriptionStateChanged(data: JSONObject) {
  //Status can be :: TRANSCRIPTION_STARTING
  //Status can be :: TRANSCRIPTION_STARTED
  //Status can be :: TRANSCRIPTION_STOPPING
  //Status can be :: TRANSCRIPTION_STOPPED
  val status = data.getString("status")
  Log.d("MeetingActivity", "Transcription status: $status")
}
```

</TabItem>

<TabItem value="Java">

```javascript
@Override
public void onTranscriptionStateChanged(JSONObject data) {
  //Status can be :: TRANSCRIPTION_STARTING
  //Status can be :: TRANSCRIPTION_STARTED
  //Status can be :: TRANSCRIPTION_STOPPING
  //Status can be :: TRANSCRIPTION_STOPPED
  String status = data.getString("status");
  Log.d("MeetingActivity", "Transcription status: " + status);
}
```

</TabItem>

</Tabs>

---

### onTranscriptionText()

- This event will be emitted when text for running realtime transcription received.

#### Event callback parameters

- **data**: TranscriptionText
  - **TranscriptionText.participantId**: String
  - **TranscriptionText.participantName**: String
  - **TranscriptionText.text**: String
  - **TranscriptionText.timestamp**: int
  - **TranscriptionText.type**: String

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
override fun onTranscriptionText(data: TranscriptionText) {
  val participantId = data.participantId
  val participantName = data.participantName
  val text = data.text
  val timestamp = data.timestamp
  val type = data.type

  Log.d("MeetingActivity", "$participantName: $text $timestamp")
}
```

</TabItem>

<TabItem value="Java">

```javascript
@Override
public void onTranscriptionText(TranscriptionText data) {
  String participantId = data.getParticipantId();
  String participantName = data.getParticipantName();
  String text = data.getText();
  int timestamp = data.getTimestamp();
  String type = data.getType();

  Log.d("MeetingActivity", participantName + ": " + text + " " + timestamp);
}
```

</TabItem>

</Tabs>

---

### onWhiteboardStarted()

- This event will be triggered when the whiteboard is successfully started.

#### Event callback parameters

**url**: String

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
override fun onWhiteboardStarted(url: String) {
    super.onWhiteboardStarted(url)
    //...
}
```

</TabItem>

<TabItem value="Java">

```java
@Override
public void onWhiteboardStarted(String url) {
    super.onWhiteboardStarted(url);
    //...
}
```

</TabItem>

</Tabs>

---

### onWhiteboardStopped()

- This event will be triggered when the whiteboard session is successfully terminated.

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
override fun onWhiteboardStopped() {
    super.onWhiteboardStopped()
    //...
}
```

</TabItem>

<TabItem value="Java">

```java
@Override
public void onWhiteboardStopped() {
    super.onWhiteboardStopped();
    //...
}
```

</TabItem>

</Tabs>

---

### onExternalCallStarted()

- This event will be emitted when local particpant receive incoming call.

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
 override fun onExternalCallStarted() {
   //
 }
```

</TabItem>

<TabItem value="Java">

```javascript
 @Override
 public void onExternalCallStarted() {
   //
 }
```

</TabItem>

</Tabs>

---

### onMeetingStateChanged()

- This event will be emitted when state of meeting changes.
- It will pass **`state`** as an event callback parameter which will indicate current state of the meeting.
- All available states are `CONNECTING`, `CONNECTED`, `RECONNECTING`, `DISCONNECTED`.

#### Event callback parameters

- **state**: MeetingState

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
override fun onMeetingStateChanged(state: ConnectionState) {
    super.onMeetingStateChanged(state)
    Log.d("TAG", "onMeetingStateChanged: $state")
}
```
</TabItem>

<TabItem value="Java">

```javascript
@Override
public void onMeetingStateChanged(ConnectionState state) {
    super.onMeetingStateChanged(state);
    Log.d("TAG", "onMeetingStateChanged: "+ state);
}
```

</TabItem>

</Tabs>

---


### onExternalCallRinging()

This callback is triggered when the user's phone starts ringing. whether it’s a traditional phone call or a VoIP call (e.g., WhatsApp).

This event allows us to detect when the user is receiving an external call.
#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
override fun onExternalCallRinging() {
    Log.d("#meeting", "onExternalCallAnswered: User phone is ringing")
}

```
</TabItem>

<TabItem value="Java">

```javascript
@Override
public void onExternalCallRinging() {
    Log.d("#meeting", "onExternalCallAnswered: User phone is ringing");
}
```

</TabItem>

</Tabs>

---

### onExternalCallStarted()

This callback is triggered when the user answers an external phone call. whether it’s a traditional phone call or a VoIP call (e.g., WhatsApp).


This event allows us to detect when the user has started a call.

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
override fun onExternalCallStarted() {
    Log.d("#meeting", "onExternalCallAnswered: User call is answered")
}
```
</TabItem>

<TabItem value="Java">

```javascript
@Override
public void onExternalCallStarted() {
    Log.d("#meeting", "onExternalCallAnswered: User call is answered");
}
```

</TabItem>

</Tabs>

---

### onExternalCallHangup()

This callback is triggered when an external call ends, whether it’s a traditional phone call or a VoIP call (e.g., WhatsApp). 

This event detects when a call has ended

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
override fun onExternalCallHangup() {
    Log.d("#meeting", "onExternalCallAnswered: User call ends")
}
```
</TabItem>

<TabItem value="Java">

```javascript
@Override
public void onExternalCallHangup() {
    Log.d("#meeting", "onExternalCallAnswered: User call ends");
}
```

</TabItem>

</Tabs>

---

### onPausedAllStreams()

- This callback is triggered when all or specified media streams within the meeting are successfully paused


#### Parameters

- **`kind`**: Specifies the type of media stream that was paused.  
  - **Type**: `String`  
  - **Possible values**:
    - `"audio"`: Indicates that audio streams have been paused.
    - `"video"`: Indicates that video streams have been paused.
    - `"share"`: Indicates that screen-sharing video streams have been paused

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
override fun onPausedAllStreams(kind: String) {
    Log.d("TAG", "onPausedAllStreams: $kind")
    super.onPausedAllStreams(kind)
}
```

</TabItem>

<TabItem value="Java">

```javascript
@Override
public void onPausedAllStreams(String kind) {
    Log.d("TAG", "onPausedAllStreams: " + kind);
    super.onPausedAllStreams(kind);
}
```

</TabItem>

</Tabs>

---

### onResumedAllStreams()

- This callback is triggered when all or specified media streams within the meeting are successfully resumed


#### Parameters

- **`kind`**: Specifies the type of media stream that was resumed.  
  - **Type**: `String`  
  - **Possible values**:
    - `"audio"`: Indicates that audio streams have been resumed.
    - `"video"`: Indicates that video streams have been resumed.
    - `"share"`: Indicates that screen-sharing video streams have been resumed


#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
override fun onResumedAllStreams(kind: String) {
    Log.d("TAG", "onResumedAllStreams: $kind")
    super.onResumedAllStreams(kind)
}
```

</TabItem>

<TabItem value="Java">

```javascript
@Override
public void onResumedAllStreams(String kind) {
    Log.d("TAG", "onResumedAllStreams: " + kind);
    super.onResumedAllStreams(kind);
}
```

</TabItem>

</Tabs>

---


### onParticipantModeChanged()

This event is triggered when a participant's mode is updated.

It passes `data` as an event callback parameter, which includes the following:

- **`SEND_AND_RECV`**: Both audio and video streams will be produced and consumed.

- **`SIGNALLING_ONLY`**: Audio and video streams will not be produced or consumed. It is used solely for signaling.

- **`RECV_ONLY`**: Only audio and video streams will be consumed without producing any.
This event is triggered when a participant's mode is updated.

#### Event Callback Parameters

- **data**: `{ mode: String, participantId: String }`
  - **mode**: `String`
  - **participantId**: `String`

import CautionMessage from '@site/src/theme/CautionMessage';


<CautionMessage sdk="Android SDK" version="v0.2.0" />


#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
 override fun onParticipantModeChanged(data: JSONObject?) {
   //...
  }
```

</TabItem>

<TabItem value="Java">

```javascript
@Override
  public void onParticipantModeChanged(JSONObject data) {
    //...
  }

```

</TabItem>

</Tabs>

---

### onPinStateChanged()

- This event will be triggered when any participant got pinned or unpinned by any participant got pinned or unpinned by any participant.

#### Event callback parameters

- **pinStateData**: \{ **peerId**: String, **state**: JSONObject, **pinnedBy**: String }
  - **peerId**: String
  - **state**: JSONObject
  - **pinnedBy**: String

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
 override fun onPinStateChanged(pinStateData: JSONObject?) {
   Log.d("onPinStateChanged: ", pinStateData.getString("peerId")) // id of participant who were pinned
   Log.d("onPinStateChanged: ", pinStateData.getJSONObject("state")) // { cam: true, share: true }
   Log.d("onPinStateChanged: ", pinStateData.getString("pinnedBy")) // id of participant who pinned that participant
  }
```

</TabItem>

<TabItem value="Java">

```javascript
@Override
  public void onPinStateChanged(JSONObject pinStateData) {
    Log.d("onPinStateChanged: ", pinStateData.getString("peerId")); // id of participant who were pinned
    Log.d("onPinStateChanged: ", pinStateData.getJSONObject("state")); // { cam: true, share: true }
    Log.d("onPinStateChanged: ", pinStateData.getString("pinnedBy")); // id of participant who pinned that participant
  }

```

</TabItem>

</Tabs>

---

### onMediaRelayRequestReceived()

- This callback is triggered when a request is recieved for media relay in the destination meeting.


#### Event callback parameters

- **`participantId - (String)`**: Specifies the participantId who requested the media relay.

- **`meetingId - (String)`**: Specifies the meeting from where the media relay request was made.

- **`listener - (RelayRequestListener)`**: A callback interface with the following methods:
  - **accept()**: Call this to approve the media relay request.
  - **reject()**:  Call this to deny the media relay request.



#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
override fun onMediaRelayRequestReceived(participantId: String,liveStreamId: String,listener: RelayRequestListener) {
    // If accepting the request
    listener.accept()

    // If rejecting the request
    listener.reject()
}
```

</TabItem>

<TabItem value="Java">

```javascript
@Override
public void onMediaRelayRequestReceived(String participantId, String liveStreamId, RelayRequestListener listener) {
     // if accept request
     listener.accept();

     // if reject request
     listener.reject();
}
```

</TabItem>

</Tabs>

---

### onMediaRelayRequestResponse()

- This callback is triggered when a response is recieved for media relay request in the source meeting.


#### Event callback parameters

- **`participantId - (String)`**: Specifies the participantId who responded the request for the media relay.

- **`decision - (String)`**: Specifies the decision whether the request for media relay was accepted or not.


#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
override fun onMediaRelayRequestResponse(participantId: String, decision: String) {
    super.onMediaRelayRequestResponse(participantId, decision)

    Log.d("MediaRelay", "Participant ID: $participantId, Decision: $decision")
}
```

</TabItem>

<TabItem value="Java">

```javascript
@Override
public void onMediaRelayRequestResponse(String participantId, String decision) {
    super.onMediaRelayRequestResponse(participantId, decision);
    
    Log.d("MediaRelay", "Participant ID: " + participantId + ", Decision: " + decision);
}
```

</TabItem>

</Tabs>

---

### onMediaRelayStarted()

- This callback is triggered when the media relay to the destination meeting succesfully starts.


#### Parameters

- **`meetingId - (String)`**: Specifies the meeting where the media relay started.

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
override fun onMediaRelayStarted(relayMeetingId: String) {
    super.onMediaRelayStarted(relayMeetingId)
    Log.d("MediaRelay", "Media relay started to meeting ID: $relayMeetingId")
}
```

</TabItem>

<TabItem value="Java">

```javascript
override fun onMediaRelayStarted(relayMeetingId: String) {
    super.onMediaRelayStarted(relayMeetingId)

    Log.d("MediaRelay", "Media relay started to meeting ID: $relayMeetingId")
}
```

</TabItem>

</Tabs>

---

### onMediaRelayStopped()

- This callback is triggered when the media relay to the destination meeting stops for any reason.


#### Parameters

- **`meetingId - (String)`**: Specifies the meeting where the media relay stopped.

- **`reason - (String)`**: Specifies the reason why the media relay stopped

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
override fun onMediaRelayStopped(meetingId: String, reason: String) {
    super.onMediaRelayStopped(meetingId, reason)
    Log.d("MediaRelay", "Media relay stopped for meeting ID: $meetingId, Reason: $reason")
}
```

</TabItem>

<TabItem value="Java">

```javascript
@Override
public void onMediaRelayStopped(String meetingId, String reason) {
    super.onMediaRelayStopped(meetingId, reason);
    Log.d("MediaRelay", "Media relay stopped for meeting ID: " + meetingId + ", Reason: " + reason);
}
```

</TabItem>

</Tabs>

---

### onMediaRelayError()

- This callback is triggered when an error occurs during media relay to the destination meeting.


#### Parameters

- **`meetingId - (String)`**: Specifies the meeting where the media relay stopped.

- **`error - (String)`**: Specifies the error that occured.

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
override fun onMediaRelayError(meetingId: String, error: String) {
    super.onMediaRelayError(meetingId, error)
    Log.e("MediaRelay", "Media relay error for meeting ID: $meetingId, Error: $error")
}
```

</TabItem>

<TabItem value="Java">

```javascript
@Override
public void onMediaRelayError(String meetingId, String error) {
    super.onMediaRelayError(meetingId, error);
    Log.e("MediaRelay", "Media relay error for meeting ID: " + meetingId + ", Error: " + error);
}
```

</TabItem>

</Tabs>

---




</div>


---

---
sidebar_position: 1
sidebar_label: Methods
pagination_label: Meeting Class Methods
title: Meeting Class Methods
---

# Meeting Class Methods - Android

<div class="sdk-api-ref-only-h4">

### join()

- It is used to join a meeting.
- After meeting initialization by [`initMeeting()`](../initMeeting) it returns a new instance of [Meeting](./introduction). However by default, it will not automatically join the meeting. Hence, to join the meeting you should call `join()`.

#### Events associated with `join()`:

- Local Participant will receive a [`onMeetingJoined`](./meeting-event-listener-class#onmeetingjoined) event, when successfully joined.
- Remote Participant will receive a [`onParticipantJoined`](./meeting-event-listener-class#onparticipantjoined) event with the newly joined [`Participant`](../participant-class/introduction) object from the event callback.

#### Participant having `ask_join` permission inside token

- If a token contains the permission `ask_join`, then the participant will not join the meeting directly after calling `join()`, but an event will be emitted to the participant having the permission `allow_join` called [`onEntryRequested`](./meeting-event-listener-class#onentryrequested).

- After the decision from the remote participant, an event will be emitted to participant called [`onEntryResponded`](./meeting-event-listener-class#onentryresponded). This event will contain the decision made by the remote participant.

#### Participant having `allow_join` permission inside token

- If a token containing the permission `allow_join`, then the participant will join the meeting directly after calling `join()`.

#### Returns

- _`void`_

---

### leave()

- It is used to leave the current meeting.

#### Events associated with `leave()`:

- Local participant will receive a [`onMeetingLeft`](./meeting-event-listener-class#onmeetingleft) event.
- All remote participants will receive a [`onParticipantLeft`](./meeting-event-listener-class#onparticipantleft) event with `participantId`.

#### Returns

- _`void`_

---

### end()

- It is used to end the current running session.
- By calling `end()`, all joined [participants](properties#getparticipants) including [localParticipant](./properties.md#getlocalparticipant) of that session will leave the meeting.

#### Events associated with `end()`:

- All [participants](./properties.md#getparticipants) and [localParticipant](./properties.md#getlocalparticipant), will be emitted [`onMeetingLeft`](./meeting-event-listener-class#onmeetingleft) event.

#### Returns

- _`void`_

---

### enableWebcam()

- It is used to enable self camera.
- [`onStreamEnabled`](../participant-class/participant-event-listener-class#onstreamenabled) event of `ParticipantEventListener` will be emitted with [`stream`](../stream-class/introduction) object from the event callback.

#### Returns

- _`void`_

---

### disableWebcam()

- It is used to disable self camera.
- [`onStreamDisabled`](../participant-class/participant-event-listener-class#onstreamdisabled) event of `ParticipantEventListener` will be emitted with [`stream`](../stream-class/introduction) object from the event callback.

#### Returns

- _`void`_

---

### unmuteMic()

- It is used to enable self microphone.
- [`onStreamEnabled`](../participant-class/participant-event-listener-class#onstreamenabled) event of `ParticipantEventListener` will be emitted with [`stream`](../stream-class/introduction) object from the event callback.

#### Returns

- _`void`_

---

### muteMic()

- It is used to disable self microphone.
- [`onStreamDisabled`](../participant-class/participant-event-listener-class#onstreamdisabled) event of `ParticipantEventListener` will be emitted with [`stream`](../stream-class/introduction) object from the event callback.

#### Returns

- _`void`_

---

### enableScreenShare()

- it is used to enable screen-sharing.

- [`onStreamEnabled`](../participant-class/participant-event-listener-class#onstreamenabled) event of `ParticipantEventListener` will be emitted with [`stream`](../stream-class/introduction) object from the event callback.

- [`onPresenterChanged()`](./meeting-event-listener-class#onpresenterchanged) event will be trigget to all participant with `participantId`.

#### Parameters

- **data**: Intent

#### Returns

- _`void`_

---

### disableScreenShare()

- It is used to disable screen-sharing.

- [`onStreamDisabled`](../participant-class/participant-event-listener-class#onstreamdisabled) event of `ParticipantEventListener` will be emitted with [`stream`](../stream-class/introduction) object from the event callback.

- [`onPresenterChanged()`](./meeting-event-listener-class#onpresenterchanged) event will be trigget to all participant with `null`.

#### Returns

- _`void`_

---

### uploadBase64File()

- It is used to upload your file to Videosdk's Temporary storage.

- `base64Data` convert your file to base64 and pass here.
- `token` pass your videosdk token. Read more about token [here](/android/guide/video-and-audio-calling-api-sdk/authentication-and-token)
- `fileName` provide your fileName with extension.
- `TaskCompletionListener` will handle the result of the upload operation.

  - When the upload is complete, the `onComplete()` method of `TaskCompletionListener` will provide the corresponding `fileUrl`, which can be used to retrieve the uploaded file.

  - If an error occurs during the upload process, the `onError()` method of `TaskCompletionListener` will provide the error details.

#### Parameters

- **base64Data**: String
- **token**: String
- **fileName**: String
- **listener**: TaskCompletionListener

#### Returns

- _`void`_

#### Example

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
private fun uploadFile() {
  val base64Data = "<Your File's base64>" // Convert your file to base64 and pass here
  val token = "<VIDEOSDK_TOKEN>"
  val fileName = "myImage.jpeg" // Provide name with extension here
  meeting!!.uploadBase64File(
    base64Data,
    token,
    fileName,
    object : TaskCompletionListener<String?, String?> {
      override fun onComplete(data: String?) {
          Log.d("VideoSDK", "Uploaded file url: $data")
      }

      override fun onError(error: String?) {
          Log.d("VideoSDK", "Error in upload file: $error")
      }
    }
  )
}
```

</TabItem>

<TabItem value="Java">

```js
private void uploadFile() {
  String base64Data = "<Your File's base64>"; // Convert your file to base64 and pass here
  String token = "<VIDEOSDK_TOKEN>";
  String fileName = "myImage.jpeg"; // Provide name with extension here
  meeting.uploadBase64File(base64Data, token, fileName, new TaskCompletionListener<String, String>() {
    @Override
    public void onComplete(@Nullable String data) {
        Log.d("VideoSDK", "Uploaded file url: " + data);
    }

    @Override
    public void onError(@Nullable String error) {
        Log.d("VideoSDK", "Error in upload file: " + error);
    }
  });
}
```

</TabItem>

</Tabs>

---

### fetchBase64File()

- It is used to retrieve your file from the Videosdk's Temporary storage.

- `url` pass fileUrl which is returned by `uploadBase64File()`
- `token` pass your videosdk token. Read more about token [here](/android/guide/video-and-audio-calling-api-sdk/authentication-and-token)
- `TaskCompletionListener` will handle the result of the fetch operation.

  - When the fetch operation is complete, the `onComplete()` method of `TaskCompletionListener` will provide the file in `base64` format.

  - If an error occurs during the fetch operation, the `onError()` method of `TaskCompletionListener` will provide the error details.

#### Parameters

- **url**: String
- **token**: String
- **listener**: TaskCompletionListener

#### Returns

- _`void`_

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
private fun fetchFile() {
  val url = "<Your FileUrl>"  // Provide fileUrl which is returned by uploadBase64File()
  val token = "<VIDEOSDK_TOKEN>"
  meeting.fetchBase64File(url, token, object : TaskCompletionListener<String?, String?> {
      override fun onComplete(data: String?) {
          Log.d("VideoSDK", "Fetched file in base64:$data")
      }

      override fun onError(error: String?) {
          Log.d("VideoSDK", "Error in fetch file: $error")
      }
  })
}
```

</TabItem>

<TabItem value="Java">

```js
private void fetchFile() {
  String url = "<Your FileUrl>";  // Provide fileUrl which is returned by uploadBase64File()
  String token = "<VIDEOSDK_TOKEN>";
  meeting.fetchBase64File(url, token, new TaskCompletionListener<String, String>() {
      @Override
      public void onComplete(@Nullable String data) {
          Log.d("VideoSDK", "Fetched file in base64:" + data);
      }

      @Override
      public void onError(@Nullable String error) {
          Log.d("VideoSDK", "Error in fetch file: " + error);
      }
  });
}
```

</TabItem>

</Tabs>

---

### startRecording()

- `startRecording` is used to start meeting recording.

- `webhookUrl` will be triggered when the recording is completed and stored into server. Read more about webhooks [here](https://en.wikipedia.org/wiki/Webhook).

- `awsDirPath` will be the path for the your S3 bucket where you want to store recordings to. To allow us to store recording in your S3 bucket, you will need to fill this form by providing the required values. [VideoSDK AWS S3 Integration](https://zfrmz.in/RVlFLFiturVJ7Q97fr23)

- `config: mode` is used to either record video-and-audio both or only audio. And by default it will be video-and-audio.

- `config: quality` is only applicable to video-and-audio.

- `transcription` This parameter lets you start post transcription for the recording.

#### Parameters

- **webhookUrl**: String
- **awsDirPath**: String
- **config**:

  - **layout**:
    - **type**: _"GRID"_ | _"SPOTLIGHT"_ | _"SIDEBAR"_
    - **priority**: _"SPEAKER"_ | _"PIN"_
    - **gridSize**: Number _`max 4`_
  - **theme**: _"DARK"_ | _"LIGHT"_ | _"DEFAULT"_
  - **mode**: _"video-and-audio"_ | _"audio"_
  - **quality**: _"low"_ | _"med"_ | _"high"_
  - **orientation**: _"landscape"_ | _"portrait"_

- **transcription**: **PostTranscriptionConfig**
  - **PostTranscriptionConfig.enabled**: boolean
  - **PostTranscriptionConfig.modelId**: String
  - **PostTranscriptionConfig.summary**: SummaryConfig
    - **SummaryConfig.enabled**: boolean
    - **SummaryConfig.prompt**: String

#### Returns

- _`void`_

#### Events associated with `startRecording()`:

- Every participant will receive a callback on [`onRecordingStateChanged()`](./meeting-event-listener-class#onrecordingstatechanged)

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
val webhookUrl = "https://webhook.your-api-server.com"
var config = JSONObject()
var layout = JSONObject()
JsonUtils.jsonPut(layout, "type", "SPOTLIGHT")
JsonUtils.jsonPut(layout, "priority", "PIN")
JsonUtils.jsonPut(layout, "gridSize", 9)
JsonUtils.jsonPut(config, "layout", layout)
JsonUtils.jsonPut(config, "theme", "DARK")

val prompt = "Write summary in sections like Title, Agenda, Speakers, Action Items, Outlines, Notes and Summary"
val summaryConfig = SummaryConfig(true, prompt)
val modelId = "raman_v1"
val transcription = PostTranscriptionConfig(true, summaryConfig, modelId)

meeting!!.startRecording(webhookUrl,null,config,transcription)
```

</TabItem>

<TabItem value="Java">

```js
String webhookUrl = "https://webhook.your-api-server.com";
JSONObject config = new JSONObject();
JSONObject layout = new JSONObject();
JsonUtils.jsonPut(layout, "type", "SPOTLIGHT");
JsonUtils.jsonPut(layout, "priority", "PIN");
JsonUtils.jsonPut(layout, "gridSize", 9);
JsonUtils.jsonPut(config, "layout", layout);
JsonUtils.jsonPut(config, "theme", "DARK");

String prompt = "Write summary in sections like Title, Agenda, Speakers, Action Items, Outlines, Notes and Summary";
SummaryConfig summaryConfig = new SummaryConfig(true, prompt);
String modelId = "raman_v1";
PostTranscriptionConfig transcription = new PostTranscriptionConfig(true, summaryConfig, modelId);

meeting.startRecording(webhookUrl,null,config,transcription);
```

</TabItem>

</Tabs>

---

### stopRecording()

- It is used to stop meeting recording.

#### Returns

- _`void`_

#### Events associated with `stopRecording()`:

- Every participant will receive a callback on [`onRecordingStateChanged()`](./meeting-event-listener-class#onrecordingstatechanged)

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
meeting!!.stopRecording()
```

</TabItem>

<TabItem value="Java">

```javascript
meeting.stopRecording();
```

</TabItem>

</Tabs>

---

### startLivestream()

- `startLiveStream()` is used to start meeting livestreaming.

- You will be able to start live stream meetings to other platforms such as Youtube, Facebook, etc. that support `RTMP` streaming.

#### Parameters

- **outputs**: `List<LivestreamOutput>`
- **config**:
  - **layout**:
    - **type**: _"GRID"_ | _"SPOTLIGHT"_ | _"SIDEBAR"_
    - **priority**: _"SPEAKER"_ | _"PIN"_
    - **gridSize**: Number _`max 25`_
  - **theme**: _"DARK"_ | _"LIGHT"_ | _"DEFAULT"_

#### Returns

- _`void`_

#### Events associated with `startLiveStream()`:

- Every participant will receive a callback on [`onLivestreamStateChanged()`](./meeting-event-listener-class#onlivestreamstatechanged)

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
val YOUTUBE_RTMP_URL = "rtmp://a.rtmp.youtube.com/live2"
val YOUTUBE_RTMP_STREAM_KEY = "<STREAM_KEY>"

val outputs: MutableList<LivestreamOutput> = ArrayList()
outputs.add(LivestreamOutput(YOUTUBE_RTMP_URL, YOUTUBE_RTMP_STREAM_KEY))

var config = JSONObject()
var layout = JSONObject()
JsonUtils.jsonPut(layout, "type", "SPOTLIGHT")
JsonUtils.jsonPut(layout, "priority", "PIN")
JsonUtils.jsonPut(layout, "gridSize", 9)
JsonUtils.jsonPut(config, "layout", layout)
JsonUtils.jsonPut(config, "theme", "DARK")

meeting!!.startLivestream(outputs,config)
```

</TabItem>

<TabItem value="Java">

```javascript
final String YOUTUBE_RTMP_URL = "rtmp://a.rtmp.youtube.com/live2";
final String YOUTUBE_RTMP_STREAM_KEY = "<STREAM_KEY>";

List<LivestreamOutput> outputs = new ArrayList<>();
outputs.add(new LivestreamOutput(YOUTUBE_RTMP_URL, YOUTUBE_RTMP_STREAM_KEY));

JSONObject config = new JSONObject();
JSONObject layout = new JSONObject();
JsonUtils.jsonPut(layout, "type", "SPOTLIGHT");
JsonUtils.jsonPut(layout, "priority", "PIN");
JsonUtils.jsonPut(layout, "gridSize", 9);
JsonUtils.jsonPut(config, "layout", layout);
JsonUtils.jsonPut(config, "theme", "DARK");

meeting.startLivestream(outputs,config);
```

</TabItem>

</Tabs>

---

### stopLivestream()

- It is used to stop meeting livestreaming.

#### Returns

- _`void`_

#### Events associated with `stopLivestream()`:

- Every participant will receive a callback on [`onLivestreamStateChanged()`](./meeting-event-listener-class#onlivestreamstatechanged)

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
meeting!!.stopLivestream()
```

</TabItem>

<TabItem value="Java">

```javascript
meeting.stopLivestream();
```

</TabItem>

</Tabs>

---

### startHls()

- `startHls()` will start HLS streaming of your meeting.

- You will be able to start HLS and watch the live stream of meeting over HLS.

- `mode` is used to either start hls streaming of video-and-audio both or only audio. And by default it will be video-and-audio.

- `quality` is only applicable to video-and-audio.

- `transcription` This parameter lets you start post transcription for the recording.

#### Parameters

- **config**:

  - **layout**:
    - **type**: _"GRID"_ | _"SPOTLIGHT"_ | _"SIDEBAR"_
    - **priority**: _"SPEAKER"_ | _"PIN"_
    - **gridSize**: Number _`max 25`_
  - **theme**: _"DARK"_ | _"LIGHT"_ | _"DEFAULT"_
  - **mode**: _"video-and-audio"_ | _"audio"_
  - **quality**: _"low"_ | _"med"_ | _"high"_

- **transcription**: **PostTranscriptionConfig**
  - **PostTranscriptionConfig.enabled**: boolean
  - **PostTranscriptionConfig.modelId**: String
  - **PostTranscriptionConfig.summary**: SummaryConfig
    - **SummaryConfig.enabled**: boolean
    - **SummaryConfig.prompt**: String

#### Returns

- _`void`_

#### Events associated with `startHls()`:

- Every participant will receive a callback on [`onHlsStateChanged()`](./meeting-event-listener-class#onhlsstatechanged)

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
var config = JSONObject()
var layout = JSONObject()
JsonUtils.jsonPut(layout, "type", "SPOTLIGHT")
JsonUtils.jsonPut(layout, "priority", "PIN")
JsonUtils.jsonPut(layout, "gridSize", 9)
JsonUtils.jsonPut(config, "layout", layout)
JsonUtils.jsonPut(config, "orientation", "portrait")
JsonUtils.jsonPut(config, "theme", "DARK")

val prompt = "Write summary in sections like Title, Agenda, Speakers, Action Items, Outlines, Notes and Summary"
val summaryConfig = SummaryConfig(true, prompt)
val modelId = "raman_v1"
val transcription = PostTranscriptionConfig(true, summaryConfig,modelId)

meeting!!.startHls(config, transcription)
```

</TabItem>

<TabItem value="Java">

```javascript
JSONObject config = new JSONObject();
JSONObject layout = new JSONObject();
JsonUtils.jsonPut(layout, "type", "SPOTLIGHT");
JsonUtils.jsonPut(layout, "priority", "PIN");
JsonUtils.jsonPut(layout, "gridSize", 9);
JsonUtils.jsonPut(config, "layout", layout);
JsonUtils.jsonPut(config, "orientation", "portrait");
JsonUtils.jsonPut(config, "theme", "DARK");

String prompt = "Write summary in sections like Title, Agenda, Speakers, Action Items, Outlines, Notes and Summary";
SummaryConfig summaryConfig = new SummaryConfig(true, prompt);
String modelId = "raman_v1";
PostTranscriptionConfig transcription = new PostTranscriptionConfig(true, summaryConfig,modelId);

meeting.startHls(config,transcription);
```

</TabItem>

</Tabs>

---

### stopHls()

- `stopHls()` is used to stop the HLS streaming.

#### Returns

- _`void`_

#### Events associated with `stopHls()`:

- Every participant will receive a callback on [`onHlsStateChanged()`](./meeting-event-listener-class#onhlsstatechanged)

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
meeting!!.stopHls()
```

</TabItem>

<TabItem value="Java">

```javascript
meeting.stopHls();
```

</TabItem>

</Tabs>

---

### startTranscription()

- `startTranscription()` It is used to start realtime transcription.

#### Parameters

#### config

- type : `TranscriptionConfig`

- This specifies the configurations for realtime transcription. You can specify following properties.
  - `TranscriptionConfig.webhookUrl`: Webhooks will be triggered when the state of realtime transcription is changed. Read more about webhooks [here](https://en.wikipedia.org/wiki/Webhook)
  - `TranscriptionConfig.summary`: `SummaryConfig`
    - `enabled`: Indicates whether realtime transcription summary generation is enabled. Summary will be available after realtime transcription stopped. Default: `false`
    - `prompt`: provides guidelines or instructions for generating a custom summary based on the realtime transcription content.

#### Returns

- _`void`_

#### Events associated with `startTranscription()`:

- Every participant will receive a callback on [`onTranscriptionStateChanged()`](./meeting-event-listener-class#ontranscriptionstatechanged)

- Every participant will receive a callback on [`onTranscriptionText()`](./meeting-event-listener-class#ontranscriptiontext)

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
// Realtime Transcription Configuration
val webhookUrl = "https://www.example.com"

val summaryConfig = SummaryConfig(
    true,
    "Write summary in sections like Title, Agenda, Speakers, Action Items, Outlines, Notes and Summary"
)
val transcriptionConfig = TranscriptionConfig(
    webhookUrl,
    summaryConfig
)

meeting!!.startTranscription(transcriptionConfig)
```

</TabItem>

<TabItem value="Java">

```javascript
// Realtime Transcription Configuration
final String webhookUrl = "https://www.example.com";

SummaryConfig summaryConfig = new SummaryConfig(
    true,
    "Write summary in sections like Title, Agenda, Speakers, Action Items, Outlines, Notes and Summary"
);
TranscriptionConfig transcriptionConfig = new TranscriptionConfig(
    webhookUrl,
    summaryConfig
);

meeting.startTranscription(transcriptionConfig);
```

</TabItem>

</Tabs>

---

### stopTranscription()

- `stopTranscription()` It is used to stop realtime transcription.

#### Returns

- _`void`_

#### Events associated with `startTranscription()`:

- Every participant will receive a callback on [`onTranscriptionStateChanged()`](./meeting-event-listener-class#ontranscriptionstatechanged)

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
meeting!!.stopTranscription()
```

</TabItem>

<TabItem value="Java">

```javascript
meeting.stopTranscription();
```

</TabItem>

</Tabs>

---

### startWhiteboard()

- It is used to initilize a whiteboard session.

#### Returns

- _`void`_

---

### stopWhiteboard()

- It is used to end a whiteboard session.

#### Returns

- _`void`_

---

### changeMode()

- It is used to change the mode.
- You can toggle between the following modes:

  - **`SEND_AND_RECV`**: Both audio and video streams will be produced and consumed.

  - **`SIGNALLING_ONLY`**: Audio and video streams will not be produced or consumed. It is used solely for signaling.

  - **`RECV_ONLY`**: Only audio and video streams will be consumed without producing any.

import CautionMessage from '@site/src/theme/CautionMessage';

<CautionMessage sdk="Android SDK" version="v0.2.0" />

#### Parameters

- **mode**: `String`
- **mode**: `String`

#### Returns

- _`void`_

#### Events associated with `changeMode()`:

- Every participant will receive a callback on [`onParticipantModeChanged()`](./meeting-event-listener-class#onparticipantmodechanged)

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
meeting!!.changeMode("SIGNALLING_ONLY")
meeting!!.changeMode("SIGNALLING_ONLY")
```

</TabItem>

<TabItem value="Java">

```javascript
meeting!!.changeMode("SIGNALLING_ONLY")
meeting!!.changeMode("SIGNALLING_ONLY")
```

</TabItem>

</Tabs>

---

### getMics()

- It will return all connected mic devices.

#### Returns

- `Set<AppRTCAudioManager.AudioDevice>`

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
val mics = meeting!!.mics
var mic: String
for (i in mics.indices) {
  mic = mics.toTypedArray()[i].toString()
  Toast.makeText(this, "Mic : $mic", Toast.LENGTH_SHORT).show()
}
```

</TabItem>

<TabItem value="Java">

```javascript
Set<AppRTCAudioManager.AudioDevice> mics = meeting.getMics();
String mic;
for (int i = 0; i < mics.size(); i++) {
    mic=mics.toArray()[i].toString();
    Toast.makeText(this, "Mic : " + mic, Toast.LENGTH_SHORT).show();
}
```

</TabItem>

</Tabs>

---

### changeMic()

- It is used to change the mic device.
- If multiple mic devices are connected, by using `changeMic()` one can change the mic device.

#### Parameters

- **device**: AppRTCAudioManager.AudioDevice

#### Returns

- _`void`_

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
meeting!!.changeMic(AppRTCAudioManager.AudioDevice.BLUETOOTH)
```

</TabItem>

<TabItem value="Java">

```javascript
meeting.changeMic(AppRTCAudioManager.AudioDevice.BLUETOOTH);
```

</TabItem>

</Tabs>

---

### changeWebcam()

- It is used to change the camera device.
- If multiple camera devices are connected, by using `changeWebcam()`, one can change the camera device with its respective device id.
- You can get a list of connected video devices using [`VideoSDK.getVideoDevices()`](../videosdk-class/methods#getvideodevices)

#### Parameters

- **deviceId**:

  - The `deviceId` represents the unique identifier of the camera device you wish to switch to. If no deviceId is provided, the facing mode will toggle, from the back camera to the front camera if the back camera is currently in use, or from the front camera to the back camera if the front camera is currently in use.

    - type : String
    - `OPTIONAL`

#### Returns

- _`void`_

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
meeting!!.changeWebcam()
```

</TabItem>

<TabItem value="Java">

```javascript
meeting.changeWebcam();
```

</TabItem>

</Tabs>

---

### pauseAllStreams()

This method pauses active media streams within the meeting.

#### Parameters

- **kind**:  Specifies the type of media stream to be paused. If this parameter is omitted, all media streams (audio, video, and screen share) will be paused.

  - **Type**: `String`  
  - **Optional**: Yes

    - Possible values:
    - `"audio"`: Pauses audio streams.
    - `"video"`: Pauses video streams.
    - `"share"`: Pauses screen-sharing video streams.
  
#### Returns

- _`void`_

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
meeting!!.pauseAllStreams()
```

</TabItem>

<TabItem value="Java">

```javascript
meeting.pauseAllStreams();
```

</TabItem>

</Tabs>
---


### resumeAllStreams()

This method resumes media streams that have been paused

#### Parameters

- **kind**:  Specifies the type of media stream to be resumed. If this parameter is omitted, all media streams (audio, video, and screen share) will be resumed.
  
  - **Type**: `String`  
  - **Optional**: Yes

    - Possible values:
    - `"audio"`: Resumes audio streams.
    - `"video"`: Resumes video streams.
    - `"share"`:Resumes screen-sharing video streams.
  
#### Returns

- _`void`_

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
meeting!!.resumeAllStreams()
```

</TabItem>

<TabItem value="Java">

```javascript
meeting.resumeAllStreams();
```

</TabItem>

</Tabs>
---

### requestMediaRelay()

This method starts relaying selected media streams (like camera video, microphone audio, screen share) from the current meeting to a specified destination meeting.

#### Parameters

- **destinationMeetingId (String) – Required**: ID of the target meeting where media should be relayed.

- **token (String) – : Authentication token for the destination meeting.
  - If you pass `null`, the SDK will use the existing authentication token.

- **kinds (Array of Strings) – : Array of media types to relay. 
  - Possible values:
    - `"audio"`: Resumes audio streams.
    - `"video"`: Resumes video streams.
    - `"share"`:Resumes screen-sharing video streams.

  - If you pass `null`, all media types (audio, video, share) will be relayed by default.

#### Returns

- _`void`_

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
meeting.requestMediaRelay("<meeting-id>", null, null)

```

</TabItem>

<TabItem value="Java">

```javascript
meeting.requestMediaRelay("<meeting-id>",null,null);
```

</TabItem>

</Tabs>
---

### stopMediaRelay()

This method stops the ongoing media relay to a specific destination meeting.

#### Parameters

- **destinationMeetingId (String) – Required**: ID of the destination meeting where the media relay should be stopped.

#### Returns

- _`void`_

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
 meeting.stopMediaRelay("<meeting-id>")
```

</TabItem>

<TabItem value="Java">

```javascript
 meeting.stopMediaRelay("<meeting-id>");
```

</TabItem>

</Tabs>
---

### switchTo()

This method enables a seamless transition from the current meeting to another, without needing to disconnect and reconnect manually.

#### Parameters

- **meetingId (String) – Required**: ID of the new meeting to switch to.

- **token (String) – Optional**: Authentication token for the new meeting.

#### Returns

- _`void`_

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
meeting.switchTo("<meeting-id>")
//or
meeting.switchTo("<meeting-id>",token)
```

</TabItem>

<TabItem value="Java">

```javascript
meeting.switchTo("<meeting-id>");
//or
meeting.switchTo("<meeting-id>",token);
```

</TabItem>

</Tabs>
---

### setAudioDeviceChangeListener()

- When a Local participant changes the Mic, `AppRTCAudioManager.AudioManagerEvents()` is triggered which can be set by using `setAudioDeviceChangeListener()` method.

#### Parameters

- **audioManagerEvents**: AppRTCAudioManager.AudioManagerEvents

#### Returns

- _`void`_

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
    meeting!!.setAudioDeviceChangeListener(object : AudioManagerEvents {
      override fun onAudioDeviceChanged(
        selectedAudioDevice: AppRTCAudioManager.AudioDevice,
        availableAudioDevices: Set<AppRTCAudioManager.AudioDevice>
      ) {
          when (selectedAudioDevice) {
            AppRTCAudioManager.AudioDevice.BLUETOOTH ->
              Toast.makeText(this@MainActivity, "Selected AudioDevice: BLUETOOTH", Toast.LENGTH_SHORT).show()

            AppRTCAudioManager.AudioDevice.WIRED_HEADSET ->
              Toast.makeText(this@MainActivity, "Selected AudioDevice: WIRED_HEADSET", Toast.LENGTH_SHORT).show()

            AppRTCAudioManager.AudioDevice.SPEAKER_PHONE ->
              Toast.makeText(this@MainActivity, "Selected AudioDevice: SPEAKER_PHONE", Toast.LENGTH_SHORT).show()

            AppRTCAudioManager.AudioDevice.EARPIECE ->
              Toast.makeText(this@MainActivity, "Selected AudioDevice: EARPIECE", Toast.LENGTH_SHORT).show()
          }
        }
    })
```

</TabItem>

<TabItem value="Java">

```javascript
    meeting.setAudioDeviceChangeListener(new AppRTCAudioManager.AudioManagerEvents() {
         @Override
        public void onAudioDeviceChanged(AppRTCAudioManager.AudioDevice selectedAudioDevice, Set<AppRTCAudioManager.AudioDevice> availableAudioDevices) {
            switch (selectedAudioDevice) {
                case BLUETOOTH:
                  Toast.makeText(MainActivity.this, "Selected AudioDevice: BLUETOOTH", Toast.LENGTH_SHORT).show();
                  break;
                case WIRED_HEADSET:
                  Toast.makeText(MainActivity.this, "Selected AudioDevice: WIRED_HEADSET", Toast.LENGTH_SHORT).show();
                  break;
                case SPEAKER_PHONE:
                  Toast.makeText(MainActivity.this, "Selected AudioDevice: SPEAKER_PHONE", Toast.LENGTH_SHORT).show();
                  break;
                case EARPIECE:
                  Toast.makeText(MainActivity.this, "Selected AudioDevice: EARPIECE", Toast.LENGTH_SHORT).show();
                  break;
               }
        }
    });
```

</TabItem>

</Tabs>

---

### addEventListener()

#### Parameters

- **listener**: MeetingEventListener

#### Returns

- _`void`_

---

### removeEventListener()

#### Parameters

- **listener**: MeetingEventListener

#### Returns

- _`void`_

---

### removeAllListeners()

#### Returns

- _`void`_
</div>


---

---
sidebar_position: 1
sidebar_label: Properties
pagination_label: Meeting Class Properties
title: Meeting Class Properties
---

# Meeting Class Properties - Android

<div class="sdk-api-ref-only-h4">

### getmeetingId()

- type: `String`

- `getmeetingId()` will return `meetingId`, which is unique id of the meeting where the participant has joined.

---

### getLocalParticipant()

- type: [Participant](../participant-class/introduction)

- It will be the instance of [Participant](../participant-class/introduction) class for the local participant(You) who joined the meeting.

---

### getMeetingState()

- type: `MeetingState`

- `getMeetingState()` will return `MeetingState`, which is current connection state of the meeting.

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
meeting!!.getMeetingState()
```

</TabItem>

<TabItem value="Java">

```javascript
meeting.getMeetingState();
```

</TabItem>

</Tabs>
---

### getParticipants()

- type: [`Map`](https://developer.android.com/reference/java/util/Map) of [Participant](../participant-class/introduction)

- `Map<String, Participant>`

  - Map{'<'}`participantId`, [Participant](../participant-class/introduction)>

- It will contain all joined participants in the meeting except the `localParticipant`.

- This will be the [`Map`](https://developer.android.com/reference/java/util/Map) what will container all participants attached with the key as id of that participant.

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
val remoteParticipantId = "ajf897"

val participant = meeting!!.participants[remoteParticipantId]
```

</TabItem>

<TabItem value="Java">

```javascript
String remoteParticipantId = "ajf897";

Participant participant = meeting.getParticipants().get(remoteParticipantId);
```

</TabItem>

</Tabs>

---

### pubSub

- type: [`PubSub`](../pubsub-class/introduction)
- It is used to enable Publisher-Subscriber feature in [`meeting`](introduction) class.

Learn more about `PubSub`, [here](../pubsub-class/introduction)

</div>


---

---
title: Meeting class for android SDK.
hide_title: false
hide_table_of_contents: false
description: RTC Meeting Class provides features to implement custom meeting layout in your application.
sidebar_label: Meeting Class
pagination_label: Meeting Class
keywords:
  - RTC Android
  - Meeting Class
  - Video API
  - Video Conferencing
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: meeting-class
---

import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>

# Meeting Class

## using Meeting Class

The `Meeting Class` includes methods and events for managing meetings, participants, video & audio streams, data channels and UI customization.

import MethodListGroup from '@theme/MethodListGroup';
import MethodListItemLabel from '@theme/MethodListItemLabel';
import MethodListHeading from '@theme/MethodListHeading';

## Constructor

### Meeting(String meetingId, Participant localParticipant)

- return type : `void`

## Properties

### getmeetingId()

- `getmeetingId()` will return `meetingId`, which represents the meetingId for the current meeting
- return type : `void`

### getLocalParticipant()

- `getLocalParticipant()` will return Local participant
- return type :`Participant`

### getParticipants()

- `getParticipants()` will return all Remote participant
- return type : `void`

### pubSub()

- `pubSub()` will return object of `PubSub` class
- return type : `PubSub`

### Events

<MethodListGroup>
  <MethodListItemLabel name="__events" >
    <MethodListGroup>
      <MethodListHeading heading="Events" />
      <MethodListItemLabel name="addEventListener(MeetingEventListener listener)"  type={"void"} />
      <MethodListItemLabel name="removeEventListener(MeetingEventListener listener)"  type={"void"} />
      <MethodListItemLabel name="removeAllListeners()"  type={"void"} />
    </MethodListGroup>
  </MethodListItemLabel>
</MethodListGroup>

### Methods

<MethodListGroup>
  <MethodListItemLabel name="__methods" >
    <MethodListGroup>
      <MethodListHeading heading="Methods" />
      <MethodListItemLabel description={"join the meeting"} name="join()"  type={"void"} />
      <MethodListItemLabel description={"leave the meeting"} name="leave()"  type={"void"} />
      <MethodListItemLabel description={"end the meeting"} name="end()"  type={"void"} />
      <MethodListItemLabel description={"enable self mic"} name="muteMic()"  type={"void"} />
      <MethodListItemLabel description={"disable self mic"} name="unmuteMic()"  type={"void"} />
      <MethodListItemLabel description={"enable self webcam"} name="enableWebcam()"  type={"void"} />
      <MethodListItemLabel description={"disable self webcam"} name="disableWebcam()"  type={"void"} />
      <MethodListItemLabel description={"start meeting recording"} name="startRecording(String webhookUrl)"  type={"void"} />
      <MethodListItemLabel description={"stop meeting recording"} name="stopRecording()"  type={"void"} />
      <MethodListItemLabel description={"start meeting live streaming"} name="startLivestream(List<LivestreamOutput> outputs)"  type={"void"} />
      <MethodListItemLabel description={"stop meeting live streaming"} name="stopLivestream()"  type={"void"} />
      <MethodListItemLabel description={"get all mic devices"} name="getMics()"  type={"Set<AppRTCAudioManager.AudioDevice>"} />
      <MethodListItemLabel description={"change self mic"} name="changeMic()"  type={"void"} />
      <MethodListItemLabel description={"When a Local participant changes the Mic, `AppRTCAudioManager.AudioManagerEvents()` is triggered which can be set by using this method"} name="setAudioDeviceChangeListener(AppRTCAudioManager.AudioManagerEvents audioManagerEvents)"  type={"void"} />
      <MethodListItemLabel description={"change self webcam"} name="changeWebcam()"  type={"void"} />
      <MethodListItemLabel description={"start sharing phone screen"} name="enableScreenShare(Intent data)"  type={"void"} />
      <MethodListItemLabel description={"stop sharing phone screen"} name="disableScreenShare()"  type={"void"} />
    </MethodListGroup>
  </MethodListItemLabel>
</MethodListGroup>


---

---
title: MeetingEventListener Class for android SDK.
hide_title: false
hide_table_of_contents: false
description: The `MeetingEventListener Class` includes list of events which can be useful for the design custom user interface.
sidebar_label: MeetingEventListener Class
pagination_label: MeetingEventListener Class
keywords:
  - RTC Android
  - MeetingEventListener Class
  - Video API
  - Video Conferencing
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: meeting-event-listener-class
---

import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>

# MeetingEventListener Class

## using MeetingEventListener Class

The `MeetingEventListener Class` is responsible for listening to all the events that are related to `Meeting Class`.

import MethodListGroup from '@theme/MethodListGroup';
import MethodListItemLabel from '@theme/MethodListItemLabel';
import MethodListHeading from '@theme/MethodListHeading';

### Listeners

<MethodListGroup>
  <MethodListItemLabel name="__listeners" >
    <MethodListGroup>
      <MethodListHeading heading="Listeners" />
      <MethodListItemLabel description={"emitted when local participant joined the meeting successfully"} name="onMeetingJoined()"  type={"void"} />
      <MethodListItemLabel description={"emitted when local participant left the meeting"} name="onMeetingLeft()"  type={"void"} />
      <MethodListItemLabel description={"emitted when new participant joined the meeting"} name="onParticipantJoined(Participant participant)"  
      type={"void"} />
      <MethodListItemLabel description={"emitted when any participant left the meeting"} name="onParticipantLeft(Participant participant)"  type={"void"} />
      <MethodListItemLabel description={"emitted when remote participant requested for entry in the meeting"} name="onEntryRequested(String id, String name)"  type={"void"} />
      <MethodListItemLabel description={"emitted when meeting host responded to participant's joining request"} 
      name="onEntryResponded(String id, String decision)"  type={"void"} />
      <MethodListItemLabel description={"emitted when any participant shared the screen"} name="onPresenterChanged(String participantId)"  type={"void"} />
      <MethodListItemLabel description={"emitted when active speaker is changed"} name="onSpeakerChanged(String participantId)"  type={"void"} />
      <MethodListItemLabel description={"emitted when the meeting's recording status changed"} name="onRecordingStateChanged(String recordingState)"  type={"void"} />
      <MethodListItemLabel description={"emitted when recording of the meeting is started successfully"} name="onRecordingStarted()"  type={"void"} />
      <MethodListItemLabel description={"emitted when recording of the meeting is stopped"} name="onRecordingStopped()"  type={"void"} />
      <MethodListItemLabel description={"emitted when the meeting's livestream status changed"} name="onLivestreamStateChanged(String livestreamState)"  type={"void"} />
      <MethodListItemLabel description={"emitted when live streaming of the meeting in social media is started successfully"} name="onLivestreamStarted()"  type={"void"} />
      <MethodListItemLabel description={"emitted when live streaming of the meeting is stopped"} name="onLivestreamStopped()"  type={"void"} />
      <MethodListItemLabel description={"emitted when remote participant asked you to toggle the Mic"} name="onMicRequested(String participantId, MicRequestListener listener)"  type={"void"} />
      <MethodListItemLabel description={"emitted when remote participant asked you to toggle the Webcam"} name="onWebcamRequested(String participantId, WebcamRequestListener listener)"  type={"void"} />
      <MethodListItemLabel description={"emitted when local participant answer/dial the phone call"} name="onExternalCallStarted()"  type={"void"} />
    </MethodListGroup>
  </MethodListItemLabel>
</MethodListGroup>


---

---
title: Video SDK Participant Class
sidebar_position: 1
sidebar_label: Introduction
pagination_label: Video SDK Participant Class
---

# Video SDK Participant Class - Android

<div class="sdk-api-ref">

import properties from './../data/participant-class/properties.json'
import methods from './../data/participant-class/methods.json'
import events from './../data/participant-class/events.json'
import LinksGrid from '../../../../../src/theme/LinksGrid'

Participant class includes all the properties, methods and events related to all the participants joined in a particular meeting.

## Get local and remote participants

You can get the local streams and participant meta from `meeting.getLocalParticipant()`. And a Map of joined participants is always available via `meeting.getParticipants()`

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js title="Javascript"
val localParticipant = meeting!!.getLocalParticipant()
val participants = meeting!!.getParticipants()
```

</TabItem>

<TabItem value="Java">

```js title="Javascript"
Participant localParticipant = meeting.getLocalParticipant();
Map<String, Participant> participants = meeting.getParticipants();
```

</TabItem>

</Tabs>

## Participant Properties

<div class="row">

<div class="col col--4 margin-bottom--sm" >

- [getId()](./properties#getid)

</div>
<div class="col col--4 margin-bottom--sm" >

- [getDisplayName()](./properties#getdisplayname)

</div>
<div class="col col--4 margin-bottom--sm" >

- [getQuality()](./properties#getquality)

</div>

<div class="col col--4 margin-bottom--sm" >

- [isLocal()](./properties#islocal)

</div>

<div class="col col--4 margin-bottom--sm" >

- [getStreams()](./properties#getstreams)

</div>

<div class="col col--4 margin-bottom--sm" >

- [getMode()](./properties#getmode)

</div>

<div class="col col--4 margin-bottom--sm" >

- [getMetaData()](./properties#getmetadata)

</div>

</div>

## Participant Methods

<div class="row">

<div class="col col--4 margin-bottom--sm" >

- [enableWebcam()](./methods#enablewebcam)

</div>
<div class="col col--4 margin-bottom--sm" >

- [disableWebcam()](./methods#disablewebcam)

</div>
<div class="col col--4 margin-bottom--sm" >

- [enableMic()](./methods#enablemic)

</div>
<div class="col col--4 margin-bottom--sm" >

- [disableMic()](./methods#disablemic)

</div>
<div class="col col--4 margin-bottom--sm" >

- [remove()](./methods#remove)

</div>
<div class="col col--4 margin-bottom--sm" >

- [setQuality()](./methods#setquality)

</div>
<div class="col col--4 margin-bottom--sm" >

- [setViewPort()](./methods#setviewport)

</div>
<div class="col col--4 margin-bottom--sm" >

- [captureImage()](./methods#captureimage)

</div>

</div>

## Participant Events

<div class="row">

<div class="col col--4 margin-bottom--sm" >

- [onStreamEnabled](./participant-event-listener-class#onstreamenabled)

</div>
<div class="col col--4 margin-bottom--sm" >

- [onStreamDisabled](./participant-event-listener-class#onstreamdisabled)

</div>

</div>

</div>


---

---
title: Participant Class Methods
sidebar_position: 1
sidebar_label: Methods
pagination_label: Participant Class Methods
---

# Participant Class Methods - Android

<div class="sdk-api-ref-only-h4">

### enableWebcam()

- `enableWebcam()` is used to enable participant's camera.

#### Events associated with `enableWebcam()` :

- First the participant will get a callback on [onWebcamRequested()](../meeting-class/meeting-event-listener-class#onwebcamrequested) and once the participant accepts the request, webcam will be enabled.

- Every Participant will receive a `streamEnabled` event of `ParticipantEventListener` Class with `stream` object.

#### Returns

- `void`

---

### disableWebcam()

- `disableWebcam()` is used to disable participant camera.

#### Events associated with `disableWebcam()` :

- Every Participant will receive a `streamDisabled` event of `ParticipantEventListener` Class with `stream` object.

#### Returns

- `void`

---

### enableMic()

- `enableMic()` is used to enable participant microphone.

#### Events associated with `enableMic()` :

- First the participant will get a callback on [onMicRequested()](../meeting-class/meeting-event-listener-class#onmicrequested) and once the participant accepts the request, mic will be enabled.

- Every Participant will receive a `streamEnabled` event of `ParticipantEventListener` Class with `stream` object.

#### Returns

- `void`

---

### disableMic()

- `disableMic()` is used to disable participant microphone.

#### Events associated with `disableMic()`:

- Every Participant will receive a `streamDisabled` event of `ParticipantEventListener` Class with `stream` object.

#### Returns

- `void`

---

### pin()

- It is used to set pin state of the participant. You can use it to pin the screen share, camera or both of the participant. It accepts a paramter of type `String`. Default `SHARE_AND_CAM`

#### Parameters

- **pinType**: `SHARE_AND_CAM` | `CAM` | `SHARE`

---

### unpin()

- It is used to unpin participant. You can use it to unpin the screen share, camera or both of the participant. It accepts a paramter of type `String`. Default is `SHARE_AND_CAM`

#### Parameters

- **pinType**: `SHARE_AND_CAM` | `CAM` | `SHARE`

---

### setQuality()

- `setQuality()` is used to set the quality of the participant's video stream.

#### Parameters

- `quality`: low | med | high

#### Returns

- `void`

---

### setViewPort()

- `setViewPort()` is used to set the quality of the participant's video stream based on the viewport height and width.

#### Parameters

- **width**: int
- **height**: int

#### Returns

- `void`

:::info

MultiStream is not supported by the Android SDK. Use `customTrack` rather than `setQuality()` and `setViewPort()` if you want to change participant's quality who joined using our Android SDK.

To know more about customTrack visit [here](/android/guide/video-and-audio-calling-api-sdk/features/custom-track/custom-video-track)

:::

---

### remove()

- `remove()` is used to remove the participant from the meeting.

#### Events associated with `remove()` :

- Local participant will receive a [`onMeetingLeft`](../meeting-class/meeting-event-listener-class.md#onmeetingleft) event.
- All remote participants will receive a [`onParticipantLeft`](../meeting-class/meeting-event-listener-class.md#onparticipantleft) event with `participantId`.

#### Returns

- `void`

---

### captureImage()

- It is used to capture image of local participant's current videoStream.

- You need to pass an implementation of `TaskCompletionListener` as a parameter. This listener will handle the result of the image capture task.

- When the image capture task is complete, the `onComplete()` method will provide the image in the form of a `base64` string. If an error occurs, the `onError()` method will provide the error details.

#### Parameters

- **height**: int
- **width**: int
- **listener**: TaskCompletionListener

#### Returns

- _`void`_

---

### getVideoStats()

- `getVideoStats()` will return an JSONObject which will contain details regarding the participant's critical video metrics such as **Jitter**, **Packet Loss**, **Quality Score** etc.

#### Returns

- `JSONObject`
  - `jitter` : It represents the distortion in the stream.
  - `bitrate` : It represents the bitrate of the stream which is being transmitted.
  - `totalPackets` : It represents the total packet count which were transmitted for that particiular stream.
  - `packetsLost` : It represents the total packets lost during the transimission of the stream.
  - `rtt` : It represents the time between the stream being reached to client from the server in milliseconds(ms).
  - `codec`: It represents the codec used for the stream.
  - `network`: It represents the network used to transmit the stream
  - `size`: It is object containing the height, width and frame rate of the stream.

:::note

getVideoStats() will return the metrics for the participant at that given point of time and not average data of the complete meeting.

To view the metrics for the complete meeting using the stats API documented [here](/api-reference/realtime-communication/fetch-session-quality-stats).

:::

:::info

If you are getting `rtt` greater than 300ms, try using a different region which is nearest to your user. To know more about changing region [visit here](/api-reference/realtime-communication/create-room).

If you are getting high packet loss, try using the `customTrack` for better experience. To know more about customTrack [visit here](/android/guide/video-and-audio-calling-api-sdk/features/custom-track/custom-video-track)

:::

---

### getAudioStats()

- `getAudioStats()` will return an JSONObject which will contain details regarding the participant's critical audio metrics such as **Jitter**, **Packet Loss**, **Quality Score** etc.

#### Returns

- `JSONObject`
  - `jitter` : It represents the distortion in the stream.
  - `bitrate` : It represents the bitrate of the stream which is being transmitted.
  - `totalPackets` : It represents the total packet count which were transmitted for that particiular stream.
  - `packetsLost` : It represents the total packets lost during the transimission of the stream.
  - `rtt` : It represents the time between the stream being reached to client from the server in milliseconds(ms).
  - `codec`: It represents the codec used for the stream.
  - `network`: It represents the network used to transmit the stream

:::note

getAudioStats() will return the metrics for the participant at that given point of time and not average data of the complete meeting.

To view the metrics for the complete meeting using the stats API documented [here](/api-reference/realtime-communication/fetch-session-quality-stats).

:::

:::info

If you are getting `rtt` greater than 300ms, try using a different region which is nearest to your user. To know more about changing region [visit here](/api-reference/realtime-communication/create-room).

:::

### getShareStats()

- `getShareStats()` will return an JSONObject which will contain details regarding the participant's critical video metrics such as **Jitter**, **Packet Loss**, **Quality Score** etc.

#### Returns

- `JSONObject`
  - `jitter` : It represents the distortion in the stream.
  - `bitrate` : It represents the bitrate of the stream which is being transmitted.
  - `totalPackets` : It represents the total packet count which were transmitted for that particiular stream.
  - `packetsLost` : It represents the total packets lost during the transimission of the stream.
  - `rtt` : It represents the time between the stream being reached to client from the server in milliseconds(ms).
  - `codec`: It represents the codec used for the stream.
  - `network`: It represents the network used to transmit the stream
  - `size`: It is object containing the height, width and frame rate of the stream.

:::note

getShareStats() will return the metrics for the participant at that given point of time and not average data of the complete meeting.

To view the metrics for the complete meeting using the stats API documented [here](/api-reference/realtime-communication/fetch-session-quality-stats).

:::

:::info

If you are getting `rtt` greater than 300ms, try using a different region which is nearest to your user. To know more about changing region [visit here](/api-reference/realtime-communication/create-room).

:::

### addEventListener()

#### Parameters

- **listener**: ParticipantEventListener

#### Returns

- _`void`_

---

### removeEventListener()

#### Parameters

- **listener**: ParticipantEventListener

#### Returns

- _`void`_

---

### removeAllListeners()

#### Returns

- _`void`_

</div>


---

---
title: ParticipantEventListener Class
sidebar_position: 1
sidebar_label: ParticipantEventListener
pagination_label: ParticipantEventListener Class
---

# ParticipantEventListener Class - Android

<div class="sdk-api-ref-only-h4">

### Implementation

- You can implement all the methods of `ParticipantEventListener` abstract Class and add the listener to `Participant` class using the `addEventListener()` method of `Participant` Class.

---

### onStreamEnabled()

- `onStreamEnabled()` is a callback which gets triggered whenever a participant's video, audio or screen share stream is enabled.

#### Event callback parameters

- **stream**: [Stream](../stream-class/introduction.md)

---

### onStreamDisabled()

- `onStreamDisabled()` is a callback which gets triggered whenever a participant's video, audio or screen share stream is disabled.

#### Event callback parameters

- **stream**: [Stream](../stream-class/introduction.md)

---

### Example

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
  meeting!!.localParticipant.addEventListener(object : ParticipantEventListener() {
    override fun onStreamEnabled(stream: Stream) {
        //
    }

    override fun onStreamDisabled(stream: Stream) {
        //
    }
  });
```

</TabItem>

<TabItem value="Java">

```js
  participant.addEventListener(new ParticipantEventListener() {
    @Override
    public void onStreamEnabled(Stream stream) {
        //
    }

    @Override
    public void onStreamDisabled(Stream stream) {
        //
    }
  });
```

</TabItem>

</Tabs>

</div>


---

---
title: Participant Class Properties
sidebar_position: 1
sidebar_label: Properties
pagination_label: Participant Class Properties
---

# Participant Class Properties - Android

<div class="sdk-api-ref-only-h4">

### getId()

- type: `String`

- `getId` will return unique id of the participant who has joined the meeting.

---

### getDisplayName()

- type: `String`

- It will return the `displayName` of the participant who has joined the meeting.

---

### getQuality()

- type: `String`

- `getQuality()` will return quality of participant's stream. Stream could be `audio` , `video` or `share`.

---

### isLocal()

- type: `boolean`

- `isLocal()` will return `true` if participant is Local,`false` otherwise.

---

### getStreams()

- type: `Map<String,name>`

- It will represents the stream for that particular participant who has joined the meeting. Streams could be `audio` , `video` or `share`.

---

### getMode()

- type : `string`

- ` getMode()` will return mode of the Participant.

---

### getMetaData()

- type : `JSONObject`

- `getMetaData()` will return additional information, that you have passed in `initMeeting()`.

</div>


---

---
title: Participant class for android SDK.
hide_title: false
hide_table_of_contents: false
description: The `Participant Class` includes methods and events for participants and their associated video & audio streams, data channels and UI customization.
sidebar_label: Participant Class
pagination_label: Participant Class
keywords:
  - RTC Android
  - Participant Class
  - Video API
  - Video Conferencing
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: participant-class
---

import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>

# Participant Class

## Introduction

The `Participant Class` includes methods and events for participants and their associated video & audio streams, data channels and UI customization.

import MethodListGroup from '@theme/MethodListGroup';
import MethodListItemLabel from '@theme/MethodListItemLabel';
import MethodListHeading from '@theme/MethodListHeading';

## Properties

### getId()

- `getId()` will return participant's Id
- return type : `String`

### getDisplayName()

- `getDisplayName()` will return name of participant
- return type : `String`

### getQuality()

- `getQuality()` will return quality of participant's video stream
- return type : `String`

### isLocal()

- `isLocal()` will return `true` if participant is Local,`false` otherwise
- return type : `boolean`

### getStreams()

- `getStreams()` will return streams of participant
- return type : `Map<String, Stream>`
- Map contains `streamId` as key and `stream` as value

## Events

### addEventListener(ParticipantEventListener listener)

- By using `addEventListener(ParticipantEventListener listener)`, we can add listener to the List of `ParticipantEventListener`
- return type : `void`

### removeEventListener(ParticipantEventListener listener)

- By using `removeEventListener(ParticipantEventListener listener)`, we can remove listener from List of `ParticipantEventListener`
- return type : `void`

### removeAllListeners()

- By using `removeAllListeners()`, we can remove all listener from List
- return type : `void`

## Methods

### enableMic()

- By using `enableMic()` function, a participant can enable the Mic of any particular Remote Participant
- When `enableMic()` is called,
  - Local Participant will receive a callback on `streamEnabled()` of `ParticipantEventListener` class
  - Remote Participant will receive a callback for `onMicRequested()` and once the remote participant accepts the request, mic will be enabled for that participant
- return type : `void`

### disableMic()

- By using `disableMic()` function, a participant can disable the Mic of any particular Remote Participant
- When `enableMic()` is called,
  - Local Participant will receive a callback on `streamDisabled()` of `ParticipantEventListener` class
  - Remote Participant will receive a callback on `streamDisabled()` of `ParticipantEventListener` class
- return type : `void`

### enableWebcam()

- By using `enableWebcam()` function, a participant can enable the Webcam of any particular Remote Participant
- When `enableWebcam()` is called,
  - Local Participant will receive a callback on `streamEnabled()` of `ParticipantEventListener` class
  - Remote Participant will receive a callback for `webcamRequested()` and once the remote participant accepts the request, webcam will be enabled for that participant
- return type : `void`

### disableWebcam()

- By using `disableWebcam()` function, a participant can disable the Webcam of any particular Remote Participant
- When `disableWebcam()` is called,
  - Local Participant will receive a callback on `streamDisabled()` of `ParticipantEventListener` class
  - Remote Participant will receive a callback on `streamDisabled()` of `ParticipantEventListener` class
- return type : `void`

### remove()

- By using `remove()` function, a participant can remove any particular Remote Participant
- When `remove()` is called,
  - Local Participant will receive a callback on `meetingLeft()`
  - Remote Participant will receive a callback on `participantLeft()`
- return type : `void`

### setQuality()

- By using `setQuality()`,you can set quality of participant's video stream
- return type : `void`


---

---
title: ParticipantEventListener Class for android SDK.
hide_title: false
hide_table_of_contents: false
description: The `ParticipantEventListener Class` includes list of events which can be useful for the design custom user interface.
sidebar_label: ParticipantEventListener Class
pagination_label: ParticipantEventListener Class
keywords:
  - RTC Android
  - ParticipantEventListener Class
  - Video API
  - Video Conferencing
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: participant-event-listener-class
---

# ParticipantEventListener Class

## using ParticipantEventListener Class

The `ParticipantEventListener Class` is responsible for listening to all the events that are related to `Participant Class`.

import MethodListGroup from '@theme/MethodListGroup';
import MethodListItemLabel from '@theme/MethodListItemLabel';
import MethodListHeading from '@theme/MethodListHeading';

### Listeners

<MethodListGroup>
  <MethodListItemLabel name="__listeners" >
    <MethodListGroup>
      <MethodListHeading heading="Listeners" />
      <MethodListItemLabel name="onStreamEnabled(Stream stream)"  type={"void"} />
      <MethodListItemLabel name="onStreamDisabled(Stream stream)"  type={"void"} />
    </MethodListGroup>
  </MethodListItemLabel>
</MethodListGroup>


---

---
title: Video SDK PubSub Class
sidebar_position: 1
sidebar_label: Introduction
pagination_label: Video SDK PubSub Class
---

# Video SDK PubSub Class - Android

<div class="sdk-api-ref">

## Introduction

PubSub class provides the methods to implement Publisher-Subscriber feature in your Application.

## PubSub Methods

<div class="row">

<div  class="col col--4 margin-bottom--sm" >

- [publish()](methods#publish)

</div>

<div  class="col col--4 margin-bottom--sm" >

- [subscribe()](methods#subscribe)

</div>

<div  class="col col--4 margin-bottom--sm" >

- [unsubscribe()](methods#unsubscribe)

</div>
</div>
</div>


---

---
sidebar_position: 1
sidebar_label: Methods
pagination_label: PubSub Class Methods
title: PubSub Class Methods
---

# PubSub Class Methods - Android

<div class="sdk-api-ref-only-h4">

### publish()

- `publish()` is used to publish messages on a specified topic in the meeting.

#### Parameters

- topic

  - type: `String`
  - This is the name of the topic, for which message will be published.

- message

  - type: `String`
  - This is the actual message.

- options
  - type: [`PubSubPublishOptions`](pubsub-publish-options-class)
  - This specifies the options for publish.

- payload

  - type: `JSONObject`
  - `OPTIONAL`
  - If you need to include additional information along with a message, you can pass here as `JSONObject`. 

#### Returns

- _`void`_

#### Example

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
// Publish message for 'CHAT' topic
val publishOptions = PubSubPublishOptions()
publishOptions.isPersist = true

meeting!!.pubSub.publish("CHAT", "Hello from Android", publishOptions)
```

</TabItem>

<TabItem value="Java">

```js
// Publish message for 'CHAT' topic
PubSubPublishOptions publishOptions = new PubSubPublishOptions();
publishOptions.setPersist(true);

meeting.pubSub.publish("CHAT", "Hello from Android", publishOptions);
```

</TabItem>

</Tabs>

---

### subscribe()

- `subscribe()` is used to subscribe a particular topic to get all the messages of that particular topic in the meeting.

#### Parameters

- topic:

  - type: `String`
  - Participants can listen to messages on that particular topic.

- listener:

  - type: [`PubSubMessageListener`](pubsub-message-listener-class)

#### Returns

- [_`List<PubSubMessage>`_](pubsub-message-class)

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
var pubSubMessageListener: ubSubMessageListener =
  PubSubMessageListener { message ->
    Log.d("#message","onMessageReceived: " + message.message)
  }

  // Subscribe for 'CHAT' topic
  val pubSubMessageList = meeting!!.pubSub.subscribe("CHAT", pubSubMessageListener)
```

</TabItem>

<TabItem value="Java">

```js
PubSubMessageListener pubSubMessageListener = new PubSubMessageListener() {
    @Override
    public void onMessageReceived(PubSubMessage message) {
        Log.d("#message", "onMessageReceived: " + message.getMessage());
    }
};

 // Subscribe for 'CHAT' topic
 List<PubSubMessage> pubSubMessageList = meeting.pubSub.subscribe("CHAT", pubSubMessageListener);
```

</TabItem>

</Tabs>

---

### unsubscribe()

- `unsubscribe()` is used to unsubscribe a particular topic on which you have subscribed priviously.

#### Parameters

- topic:

  - type: `String`
  - This is the name of the topic to be unsubscribed.

- listener:

  - type: [`PubSubMessageListener`](pubsub-message-listener-class)

#### Returns

- _`void`_

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
// Unsubscribe for 'CHAT' topic
meeting!!.pubSub.unsubscribe("CHAT", pubSubMessageListener)
```

</TabItem>

<TabItem value="Java">

```js
// Unsubscribe for 'CHAT' topic
meeting.pubSub.unsubscribe("CHAT", pubSubMessageListener);
```

</TabItem>

</Tabs>

</div>


---

---
sidebar_position: 1
sidebar_label: Properties
pagination_label: Properties
title: Properties
---

# Properties - Android

<div class="sdk-api-ref-only-h4">

### getId()

- type: `String`

- `getId()` will return unique id of the pubsub message.

---

### getMessage()

- type: `String`

- `getMessage()` will return message that has been published on the specific topic.

---

### getTopic()

- type: `String`

- `getTopic()` will return name of the message topic.

---

### getSenderId()

- type: `String`

- `getSenderId()` will return id of the participant, who has sent the message.

---

### getSenderName()

- type: `String`

- `getSenderName()` will return name of the participant, who has sent the pubsub message.

---

### getTimestamp()

- type: `long`

- `getTimestamp()` will return timestamp at which, the pubsub message was sent.

---

### getPayload()

- type: `JSONObject`

- `getPayload()` will return data that you have send with message.

</div>


---

---
sidebar_position: 1
sidebar_label: PubSubMessageListener Class
pagination_label: PubSubMessageListener Class
title: PubSubMessageListener Class
---

# PubSubMessageListener Class - Android

<div class="sdk-api-ref-only-h4">

---

#### onMessageReceived()

- This event will be emitted whenever any pubsub message received.

#### Example

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
var pubSubMessageListener = PubSubMessageListener { message ->
    Log.d("#message", "onMessageReceived: " + message.message)
}
```

</TabItem>

<TabItem value="Java">

```javascript
PubSubMessageListener pubSubMessageListener = new PubSubMessageListener() {
    @Override
    public void onMessageReceived(PubSubMessage message) {
        Log.d("#message", "onMessageReceived: " + message.getMessage());
    }
};
```

</TabItem>

</Tabs>

</div>


---

---
sidebar_position: 1
sidebar_label: PubSubPublishOptions Class
pagination_label: PubSubPublishOptions Class
title: PubSubPublishOptions Class
---

# PubSubPublishOptions Class - Android

<div class="sdk-api-ref-only-h4">


## Properties

### persist

- type: `boolean`

- defaultValue: `false`

- This property specifies whether to store messages on server for upcoming participants.

- If the value of this property is true, then server will store pubsub messages for the upcoming participants.

---

### sendOnly

- type: `String[]`

- defaultValue: `null`

- If you want to send a message to specific participants, you can pass their respective `participantId` here. If you don't provide any IDs or pass a `null` value, the message will be sent to all participants by default.

:::note
Make sure that participantId present in the array must be subscribe to that specific topic.
:::

</div>


---

---
title: PubSub class for android SDK.
hide_title: false
hide_table_of_contents: false
description: PubSub Class
sidebar_label: PubSub Class
pagination_label: PubSub Class
keywords:
  - RTC Android
  - Publisher-Subscriber
  - PubSub
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: pubsub-class
---

# PubSub Class

## using PubSub Class

The `PubSub` includes methods for pubsub.

import MethodListGroup from '@theme/MethodListGroup';
import MethodListItemLabel from '@theme/MethodListItemLabel';
import MethodListHeading from '@theme/MethodListHeading';

### Methods

<MethodListGroup>
  <MethodListItemLabel name="__methods" >
    <MethodListGroup>
      <MethodListHeading heading="Methods" />
      <MethodListItemLabel name="publish(String topic, String message, PubSubPublishOptions options)"  type={"void"} />
      <MethodListItemLabel name="subscribe(String topic, PubSubMessageListener listener)"  type={"List<PubSubMessage>"} />
      <MethodListItemLabel name="unsubscribe(String topic, PubSubMessageListener listener)"  type={"void"} />
    </MethodListGroup>
  </MethodListItemLabel>
</MethodListGroup>


---

---
title: PubSubMessage class for android SDK.
hide_title: false
hide_table_of_contents: false
description: PubSubMessage Class
sidebar_label: PubSubMessage Class
pagination_label: PubSubMessage Class
keywords:
  - RTC Android
  - Publisher-Subscriber
  - PubSub
  - PubSubMessage
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: pubsub-message-class
---

# PubSubMessage Class

## using PubSubMessage Class

The `PubSubMessage` includes properties of PubSub message.

import MethodListGroup from '@theme/MethodListGroup';
import MethodListItemLabel from '@theme/MethodListItemLabel';
import MethodListHeading from '@theme/MethodListHeading';

### Properties

<MethodListGroup>
  <MethodListItemLabel name="__properties"  >
    <MethodListGroup>
      <MethodListHeading heading="Properties" />
      <MethodListItemLabel name="id" type={"String"} />
      <MethodListItemLabel name="message" type={"String"} />
      <MethodListItemLabel name="senderId" type={"String"} />
      <MethodListItemLabel name="senderName" type={"String?"} />
      <MethodListItemLabel name="timestamp" type={"DateTime"} />
      <MethodListItemLabel name="topic" type={"String"} />
      <MethodListItemLabel name="payload" type={"JSONObject"} />
    </MethodListGroup>
  </MethodListItemLabel>
</MethodListGroup>


---

---
title: PubSubPublishOptions class for android SDK.
hide_title: false
hide_table_of_contents: false
description: PubSubPublishOptions Class
sidebar_label: PubSubPublishOptions Class
pagination_label: PubSubPublishOptions Class
keywords:
  - RTC Android
  - PubSub
  - PubSubPublishOptions
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: pubsub-publish-options-class
---

# PubSubPublishOptions Class

## using PubSubPublishOptions Class

The `PubSubPublishOptions` includes properties of PubSub options.

import MethodListGroup from '@theme/MethodListGroup';
import MethodListItemLabel from '@theme/MethodListItemLabel';
import MethodListHeading from '@theme/MethodListHeading';

### Properties

<MethodListGroup>
  <MethodListItemLabel name="__properties"  >
    <MethodListGroup>
      <MethodListHeading heading="Properties" />
      <MethodListItemLabel name="persist" type={"bool"} description={"Specifies whether to store messages on server for upcoming participants"} />
      <MethodListItemLabel name="sendOnly" type={"String[]"} description={"Sends a message to only those participants which are present in array"} />
    </MethodListGroup>
  </MethodListItemLabel>
</MethodListGroup>

### Methods

<MethodListGroup>
  <MethodListItemLabel name="__methods" >
    <MethodListGroup>
      <MethodListHeading heading="Methods" />
      <MethodListItemLabel name="toJSONObject()"  type={"JSONObject"} />
    </MethodListGroup>
  </MethodListItemLabel>
</MethodListGroup>


---

---
id: setup
title: Installation steps for RTC Android SDK
hide_title: false
hide_table_of_contents: false
description: RTC Android SDK provides client for almost all Android devices. it takes less amount of cpu and memory.
sidebar_label: Setup
pagination_label: Setup
keywords:
  - RTC Android
  - Android SDK
  - Kotlin SDK
  - Java SDK
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: setup
---

# Setup - Android

## Setting up android sdk

Android SDK is client for real-time communication for android devices. It inherits the same terminology as all other SDKs does.

## Minimum OS/SDK versions

It supports the following OS/SDK versions.

### Android: minSdkVersion >= 21

## Installation

1. If your Android Studio Version is older than Android Studio Bumblebees, add the repository to project's `build.gradle` file. <br/>
   If your are using Android Studio Bumblebees or newer Version, add the repository to `settings.gradle` file.

:::note

You can use imports with Maven Central after rtc-android-sdk version `0.1.12`.

Whether on Maven or Jitpack, the same version numbers always refer to the same SDK.

:::

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Maven Central"
groupId={"android-repositories"}
values={[{label: 'Maven Central', value: 'Maven Central'},{label: 'Jitpack', value: 'Jitpack'},]}>

<TabItem value="Maven Central">

```js title="build.gradle"
allprojects {
  repositories {
    // ...
    google()
    mavenCentral()
    maven { url "https://maven.aliyun.com/repository/jcenter" }
  }
}
```

```js title="settings.gradle"
dependencyResolutionManagement{
  repositories {
    // ...
    google()
    mavenCentral()
    maven { url "https://maven.aliyun.com/repository/jcenter" }
  }
}

```

</TabItem>

<TabItem value="Jitpack">

```js title="build.gradle"
allprojects {
  repositories {
    // ...
    google()
    maven { url 'https://jitpack.io' }
    mavenCentral()
    maven { url "https://maven.aliyun.com/repository/jcenter" }
  }
}
```

```js title="settings.gradle"
dependencyResolutionManagement{
  repositories {
    // ...
    google()
    maven { url 'https://jitpack.io' }
    mavenCentral()
    maven { url "https://maven.aliyun.com/repository/jcenter" }
  }
}

```

</TabItem>

</Tabs>

### Step 2: Add the following dependency in your app's `app/build.gradle`.

```js title="app/build.gradle"
dependencies {
  implementation 'live.videosdk:rtc-android-sdk:0.3.0'

  // library to perform Network call to generate a meeting id
  implementation 'com.amitshekhar.android:android-networking:1.0.2'

  // other app dependencies
  }
```

:::important

Android SDK compatible with armeabi-v7a, arm64-v8a, x86_64 architectures. If you want to run the application in an emulator, choose ABI x86_64 when creating a device.

:::

## Integration

### Step 1: Add the following permissions in `AndroidManifest.xml`.

```xml title="AndroidManifest.xml"
<uses-permission android:name="android.permission.RECORD_AUDIO" />
<uses-permission android:name="android.permission.MODIFY_AUDIO_SETTINGS" />
<uses-permission android:name="android.permission.INTERNET" />
<uses-permission android:name="android.permission.READ_PHONE_STATE" />
<uses-permission android:name="android.permission.CAMERA" />

<uses-permission android:name="android.permission.BLUETOOTH" />
<uses-permission android:name="android.permission.BLUETOOTH_ADMIN" />
<uses-permission android:name="android.permission.BLUETOOTH_CONNECT" />

```

### Step 2: Create `MainApplication` class which will extend the `android.app.Application`.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js title="MainApplication.kt"
package live.videosdk.demo;

import live.videosdk.android.VideoSDK

class MainApplication : Application() {
    override fun onCreate() {
        super.onCreate()
        VideoSDK.initialize(applicationContext)
    }
}
```

</TabItem>

<TabItem value="Java">

```js title="MainApplication.java"
package live.videosdk.demo;

import android.app.Application;

import live.videosdk.android.VideoSDK;

public class MainApplication extends Application {
    @Override
    public void onCreate() {
        super.onCreate();
        VideoSDK.initialize(getApplicationContext());
    }
}
```

</TabItem>

</Tabs>

### Step 3: Add `MainApplication` to `AndroidManifest.xml`.

```js title="AndroidManifest.xml"
<application
        android:name=".MainApplication"
				...
>
  <!-- ... -->
</application>
```

### Step 4: In your `JoinActivity` add the following code in `onCreate()` method.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js title="JoinActivity.kt"
override fun onCreate(savedInstanceState: Bundle?) {
  super.onCreate(savedInstanceState)
  setContentView(R.layout.activity_join)

  val meetingId = "<meeting-id>"
  val participantName = "John Doe"

  var micEnabled = true
  var webcamEnabled = true

  // generate the jwt token from your api server and add it here
  VideoSDK.config("JWT TOKEN GENERATED FROM SERVER")

  // create a new meeting instance
  meeting = VideoSDK.initMeeting(
      this@MeetingActivity, meetingId, participantName,
      micEnabled, webcamEnabled, null, null, false, null, null)

  // get permissions and join the meeting with meeting.join();
  // checkPermissionAndJoinMeeting();
}
```

</TabItem>

<TabItem value="Java">

```js title="JoinActivity.java"
@Override
protected void onCreate(Bundle savedInstanceState) {
  super.onCreate(savedInstanceState);
  setContentView(R.layout.activity_join);

  final String meetingId = "<meeting-id>";
  final String participantName = "John Doe";

  final boolean micEnabled = true;
  final boolean webcamEnabled = true;

  // generate the jwt token from your api server and add it here
  VideoSDK.config("JWT TOKEN GENERATED FROM SERVER");

  // create a new meeting instance
  Meeting meeting = VideoSDK.initMeeting(
          MainActivity.this, meetingId, participantName,
          micEnabled, webcamEnabled, null, null, false, null, null
  );

  // get permissions and join the meeting with meeting.join();
  // checkPermissionAndJoinMeeting();
}
```

</TabItem>

</Tabs>

All set! Here is the link to the complete sample code on [Github](https://github.com/videosdk-live/videosdk-rtc-android-java-sdk-example). Please refer to the [documentation](initMeeting) for a full list of available methods, events and features of the SDK.


---

---
title: Video SDK Stream Class
sidebar_position: 1
sidebar_label: Introduction
pagination_label: Video SDK Stream Class
---

# Video SDK Stream Class - Android

<div id="tailwind" class="sdk-api-ref">

import properties from './../data/stream-class/properties.json'
import methods from './../data/stream-class/methods.json'
import LinksGrid from '../../../../../src/theme/LinksGrid'

Stream class is responsible for handling audio, video and screen sharing streams.

Stream class defines instance of audio, video and shared screen stream of participants.

## Stream Properties

<div class="row">

<div class="col col--4 margin-bottom--sm" >

- [getId()](./properties#getid)

</div>
<div class="col col--4 margin-bottom--sm" >

- [getKind()](./properties#getkind)

</div>
<div class="col col--4 margin-bottom--sm" >

- [getTrack()](./properties#gettrack)

</div>

</div>

## Stream Methods

<div class="row">

<div class="col col--4 margin-bottom--sm" >

- [resume()](methods#resume)

</div>
<div class="col col--4 margin-bottom--sm" >

- [pause()](./methods#pause)

</div>

</div>

</div>


---

---
title: Stream Class Methods
sidebar_position: 1
sidebar_label: Methods
pagination_label: Stream Class Methods
---

# Stream Class Methods - Android

<div class="sdk-api-ref-only-h4">

### resume()

- By using `resume()`, a participant can resume the stream of Remote Participant.

#### Returns

- `void`

---

### pause()

- By using `pause()`, a participant can pause the stream of Remote Participant.

#### Returns

- `void`

</div>


---

---
title: Stream Class Properties
sidebar_position: 1
sidebar_label: Properties
pagination_label: Stream Class Properties
---

# Stream Class Properties - Android

<div class="sdk-api-ref-only-h4">

### getId()

- type: `String`

- `getId()` will return id for that stream .

---

### getKind()

- type: `String`

- `getKind()` will return `kind`, which represents the type of stream which could be `audio` | `video` or `share` .

---

### getTrack()

- type: `MediaStreamTrack`

- `getTrack()` will return a MediaStreamTrack object stored in the MediaStream object.

</div>


---

---
title: Stream class for android SDK.
hide_title: false
hide_table_of_contents: false
description: RTC Stream Class enables opportunity to .
sidebar_label: Stream Class
pagination_label: Stream Class
keywords:
  - RTC Android
  - Stream Class
  - Video API
  - Video Conferencing
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: stream-class
---

# Stream Class

## Introduction

The `Stream Class` includes methods and events of video & audio streams.

import MethodListGroup from '@theme/MethodListGroup';
import MethodListItemLabel from '@theme/MethodListItemLabel';
import MethodListHeading from '@theme/MethodListHeading';

## Properties

### getId()

- `getId()` will return Id of stream
- return type : `String`

### getKind()

- `getKind()` will return kind of stream, which can `audio`,`video` or `share`
- return type : `String`

### getTrack()

- `getTrack()` will return a MediaStreamTrack object stored in the MediaStream object
- return type : `MediaStreamTrack`

## Methods

### pause()

- By using `pause()` function, a participant can pause the stream of Remote Participant
- return type : `void`

### resume()

- By using `resume()` function, a participant can resume the stream of Remote Participant
- return type : `void`


---

---
title: Terminology - Video SDK Documentation
hide_title: true
hide_table_of_contents: false
description: Video SDK enables the opportunity to integrate native IOS, Android & Web SDKs to add live video & audio conferencing to your applications.
sidebar_label: Terminology
pagination_label: Terminology
keywords:
  - audio calling
  - video calling
  - real-time communication
  - collaboration
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: terminology
---

import Terminology from '../../../../mdx/introduction/\_terminology.mdx';

<Terminology title="Terms related to VideoSDK - Android" />


---

---
title: Video SDK Class for android SDK.
hide_title: false
hide_table_of_contents: false
description: Video SDK Class is a factory for initialize, configure and init meetings.
sidebar_label: VideoSDK Class
pagination_label: VideoSDK Class
keywords:
  - RTC Android
  - VideoSDK Class
  - Video API
  - Video Conferencing
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: videosdk-class
---

# VideoSDK Class

The entry point into real-time communication SDK.

## using VideoSDK Class

The `VideoSDK Class` includes methods and events to initialize and configure the SDK. It is a factory class.

import MethodListGroup from '@theme/MethodListGroup';
import MethodListItemLabel from '@theme/MethodListItemLabel';
import MethodListHeading from '@theme/MethodListHeading';

### Parameters

<MethodListGroup>
  <MethodListItemLabel name="__namedParameters" option={"required"} type={"object"} >
    <MethodListGroup>
      <MethodListHeading heading="Properties" />
      <MethodListItemLabel description={"set meeting id"} name="meetingId" option={"required"} type={"string"} />
      <MethodListItemLabel description={"set local participant's name"} name="name" option={"required"} type={"string"} />
      <MethodListItemLabel description={"set local participant's mic state"} name="micEnabled" option={"required"} type={"bool"} />
      <MethodListItemLabel description={"set local participant's webcam state"} name="webcamEnabled" option={"required"} type={"bool"}/>
      <MethodListItemLabel description={"set local participant's Id"} name="paricipantId" option={"required"} type={"string"}/>
    </MethodListGroup>
  </MethodListItemLabel>
</MethodListGroup>

### Methods

<MethodListGroup>
  <MethodListItemLabel name="__methods" >
    <MethodListGroup>
      <MethodListHeading heading="Methods" />
      <MethodListItemLabel description={"initialize the MediasoupClient"} name="initialize(Context context)"  type={"void"} />
      <MethodListItemLabel description={"configure the token"} name="config(String token)"  type={"void"} />
      <MethodListItemLabel description={"initialize the meeting"} 
      name="initMeeting(
        Context context, 
        String meetingId, 
        String name, 
        boolean micEnabled,
        boolean webcamEnabled,
        String participantId
      )"  type={"Meeting"} />
    </MethodListGroup>
  </MethodListItemLabel>
</MethodListGroup>

## Example

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js title="initMeeting"
// Configure the token
VideoSDK.config(token)

// Initialize the meeting
Meeting meeting = VideoSDK.initMeeting(
      context,
      meetingId, // required
      name, // required
      micEnabled, // required
      webcamEnabled, // required
      null, // required
      null, // required
      null // required
      )
});
```

</TabItem>

<TabItem value="Java">

```js title="initMeeting"
// Configure the token
VideoSDK.config(token)

// Initialize the meeting
Meeting meeting = VideoSDK.initMeeting({
  context,
  meetingId, // required
  name, // required
  micEnabled, // required
  webcamEnabled, // required
  null, // required
  null // required
  null // required
});
```

</TabItem>

</Tabs>


---

---
sidebar_position: 1
sidebar_label: Events
pagination_label: VideoSDK Class Events
title: VideoSDK Class Events
---

# VideoSDK Class Events - Android

<div class="sdk-api-ref-only-h4">


### onAudioDeviceChanged()

- This event will be emitted when an audio device, is connected to or removed from the device.

#### Example

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
VideoSDK.setAudioDeviceChangeListener(object : VideoSDK.AudioDeviceChangeEvent {
    override fun onAudioDeviceChanged(
        selectedAudioDevice: AudioDeviceInfo?,
        audioDevices: MutableSet<AudioDeviceInfo>?
    ) {
        Log.d(
            "VideoSDK",
            "Selected Audio Device: " + selectedAudioDevice.label
        )
        for (audioDevice in audioDevices) {
            Log.d("VideoSDK", "Audio Devices" + audioDevice.label)
        }
    }
})
```

</TabItem>

<TabItem value="Java">

```javascript
VideoSDK.setAudioDeviceChangeListener(new VideoSDK.AudioDeviceChangeEvent() {
    @Override
    public void onAudioDeviceChanged(AudioDeviceInfo selectedAudioDevice, Set<AudioDeviceInfo> audioDevices) {
        Log.d("VideoSDK", "Selected Audio Device: " + selectedAudioDevice.getLabel());
        for (AudioDeviceInfo audioDevice :
                audioDevices) {
            Log.d("VideoSDK", "Audio Devices" + audioDevice.getLabel());
        }
    }
});
```

</TabItem>

</Tabs>

---

</div>


---

---
sidebar_position: 1
sidebar_label: Introduction
pagination_label: Intro to VideoSDK Class
title: VideoSDK Class
---

# VideoSDK Class - Android 

<div class="sdk-api-ref">

## Introduction

The `VideoSDK` class includes properties, methods and events for creating and configuring a meeting, and managing media devices.

import LinksGrid from "../../../../../src/theme/LinksGrid";
//import properties from "./../data/meeting-class/properties.json";
import methods from "./../data/meeting-class/methods.json";
import events from "./../data/meeting-class/events.json";

## VideoSDK Properties

<div class="row">

<div class="col col--4 margin-bottom--sm" >

- [getSelectedAudioDevice()](./properties.md#getselectedaudiodevice)

</div>
<div class="col col--4 margin-bottom--sm" >

- [getSelectedVideoDevice()](./properties#getselectedvideodevice)

</div>

</div>

## VideoSDK Methods

<div class="row">

<div class="col col--4 margin-bottom--sm" >

- [initialize()](./methods#initialize)

</div>

<div class="col col--4 margin-bottom--sm" >

- [config()](./methods#config)

</div>
<div class="col col--4 margin-bottom--sm" >

- [initMeeting()](./methods#initmeeting)

</div>
<div class="col col--4 margin-bottom--sm" >

- [getDevices()](./methods#getdevices)

</div>
<div class="col col--4 margin-bottom--sm" >

- [getVideoDevices()](./methods#getvideodevices)

</div>
<div class="col col--4 margin-bottom--sm" >

- [getAudioDevices()](./methods#getaudiodevices)

</div>
<div class="col col--4 margin-bottom--sm" >

- [checkPermissions()](./methods#checkpermissions)

</div>

<div class="col col--4 margin-bottom--sm" >

- [setAudioDeviceChangeListener()](./methods#setaudiodevicechangelistener)

</div>
<div class="col col--4 margin-bottom--sm" >

- [setSelectedAudioDevice()](./methods#setselectedaudiodevice)

</div>
<div class="col col--4 margin-bottom--sm" >

- [setSelectedVideoDevice()](./methods#setselectedvideodevice)

</div>

</div>

## VideoSDK Events

<div class="row">

<div class="col col--4 margin-bottom--sm" >

- [onAudioDeviceChanged](./events.md#onaudiodevicechanged)

</div>

</div>

</div>


---

---
sidebar_position: 1
sidebar_label: Methods
pagination_label: VideoSDK Class Methods
title: VideoSDK Class Methods
---

# VideoSDK Class Methods - Android

<div class="sdk-api-ref-only-h4">

### initialize()

To initialize the meeting, first you have to initialize the `VideoSDK`.
You can initialize the `VideoSDK` using `initialize()` method provided by the SDK.

#### Parameters

- **context**: Context

#### Returns

- _`void`_

```js title="initialize"
  VideoSDK.initialize(Context context)
```

---

### config()

By using `config()` method, you can set the `token` property of `VideoSDK` class.

Please refer this [documentation](/api-reference/realtime-communication/intro/) to generate a token.

#### Parameters

- **token**: String

#### Returns

- _`void`_

```js title="config"
 VideoSDK.config(String token)
```

---

### initMeeting()

- Initialize the meeting using a factory method provided by the SDK called `initMeeting()`.
- `initMeeting()` will generate a new [`Meeting`](../meeting-class/introduction.md) class and the initiated meeting will be returned.

```js title="initMeeting"
   VideoSDK.initMeeting(
        Context context,
        String meetingId,
        String name,
        boolean micEnabled,
        boolean webcamEnabled,
        String participantId,
        String mode,
        boolean multiStream,
        Map<String, CustomStreamTrack> customTracks
        JSONObject metaData,
        String signalingBaseUrl
        PreferredProtocol preferredProtocol
      )
```
- Please refer this [documentation](../initMeeting.md#initmeeting) to know more about `initMeeting()`.

---

### getDevices()

- The `getDevices()` method returns a list of the currently available media devices, such as microphones, cameras, headsets, and so forth. The method returns a list of `DeviceInfo` objects describing the devices.

- `DeviceInfo` class has four properties :

  1. `DeviceInfo.deviceId`

     - Returns a string that is an identifier for the represented device, persisted across sessions.

  2. `DeviceInfo.label`

     - Returns a string describing this device (for example `BLUETOOTH`).

  3. `DeviceInfo.kind`

     - Returns an enumerated value that is either `video` or `audio`.

  4. `DeviceInfo.FacingMode`

     - Returns a value of type `FacingMode` indicating which camera device is in use (front or back).

#### Returns

- `Set<DeviceInfo>`

#### Example

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
val devices: Set<DeviceInfo> = VideoSDK.getDevices()
for (deviceInfo in devices) {
    Log.d("VideoSDK", "Device's DeviceId " + deviceInfo.deviceId)
    Log.d("VideoSDK", "Device's Label " + deviceInfo.label)
    Log.d("VideoSDK", "Device's Kind " + deviceInfo.kind)
    Log.d("VideoSDK", "Device's Facing Mode " + deviceInfo.facingMode) //Value will be null for Audio Devices
}
```

</TabItem>

<TabItem value="Java">

```javascript
Set<DeviceInfo> devices = VideoSDK.getDevices();
for (DeviceInfo deviceInfo :
        devices) {
    Log.d("VideoSDK", "Device's DeviceId " + deviceInfo.getDeviceId());
    Log.d("VideoSDK", "Device's Label " + deviceInfo.getLabel());
    Log.d("VideoSDK", "Device's Kind " + deviceInfo.getKind());
    Log.d("VideoSDK", "Device's Facing Mode " + deviceInfo.getFacingMode()) //Value will be null for Audio Devices
}
```

</TabItem>

</Tabs>

---

### getVideoDevices()

- The `getVideoDevices` method returns a list of currently available video devices. The method returns a list of `VideoDeviceInfo` objects describing the video devices.

- `VideoDeviceInfo` class has four properties :

  1. `VideoDeviceInfo.deviceId`

     - Returns a string that is an identifier for the represented device, persisted across sessions.

  2. `VideoDeviceInfo.label`

     - Returns a string describing this device (for example `BLUETOOTH`).

  2. `VideoDeviceInfo.kind`

     - Returns an enumerated value that is `video` .

  4. `VideoDeviceInfo.FacingMode`

     - Returns a value of type `FacingMode` indicating which camera device is in use (front or back).


#### Returns

- `Set<VideoDeviceInfo>`

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
val videoDevices: Set<VideoDeviceInfo> = VideoSDK.getVideoDevices()
for (videoDevice in videoDevices) {
    Log.d("VideoSDK", "Video Device's DeviceId " + videoDevice.deviceId)
    Log.d("VideoSDK", "Video Device's Label " + videoDevice.label)
    Log.d("VideoSDK", "Video Device's Kind " + videoDevice.kind)
}
```

</TabItem>

<TabItem value="Java">

```js
Set<VideoDeviceInfo> videoDevices = VideoSDK.getVideoDevices();
for (VideoDeviceInfo videoDevice:
        videoDevices) {
    Log.d("VideoSDK", "Video Device's DeviceId " + videoDevice.getDeviceId());
    Log.d("VideoSDK", "Video Device's Label " + videoDevice.getLabel());
    Log.d("VideoSDK", "Video Device's Kind " + videoDevice.getKind());
}
```

</TabItem>

</Tabs>

---

### getAudioDevices()

- The `getAudioDevices` method returns a list of currently available audio devices. The method returns a list of `AudioDeviceInfo` objects describing the audio devices.

- `AudioDeviceInfo` class has three properties :

  1. `AudioDeviceInfo.deviceId`

     - Returns a string that is an identifier for the represented device, persisted across sessions.

  2. `AudioDeviceInfo.label`

     - Returns a string describing this device (for example `BLUETOOTH`).

  3. `AudioDeviceInfo.kind`

     - Returns an enumerated value that is `audio`.

#### Returns

- `Set<AudioDeviceInfo>`

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
val audioDevices: Set<AudioDeviceInfo> = VideoSDK.getAudioDevices()
for (audioDevice in audioDevices) {
    Log.d("VideoSDK", "Audio Device's DeviceId " + audioDevice.deviceId)
    Log.d("VideoSDK", "Audio Device's Label " + audioDevice.label)
    Log.d("VideoSDK", "Audio Device's Kind " + audioDevice.kind)
}
```

</TabItem>

<TabItem value="Java">

```js
Set<AudioDeviceInfo> audioDevices = VideoSDK.getAudioDevices();
for (AudioDeviceInfo audioDevice:
     audioDevices) {
    Log.d("VideoSDK", "Audio Device's DeviceId " + audioDevice.getDeviceId());
    Log.d("VideoSDK", "Audio Device's Label " + audioDevice.getLabel());
    Log.d("VideoSDK", "Audio Device's Kind " + audioDevice.getKind());
}
```

</TabItem>

</Tabs>

---

### setAudioDeviceChangeListener()

- The `AudioDeviceChangeEvent` is emitted when an audio device, is connected to or removed from the device. This event can be set by using `setAudioDeviceChangeListener()` method.

#### Parameters

- **audioDeviceChangeEvent**: AudioDeviceChangeEvent

#### Returns

- _`void`_

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
VideoSDK.setAudioDeviceChangeListener { selectedAudioDevice: AudioDeviceInfo, audioDevices: Set<AudioDeviceInfo> ->
    Log.d(
        "VideoSDK",
        "Selected Audio Device: " + selectedAudioDevice.label
    )
    for (audioDevice in audioDevices) {
        Log.d("VideoSDK", "Audio Devices" + audioDevice.label)
    }
}
```

</TabItem>

<TabItem value="Java">

```javascript
VideoSDK.setAudioDeviceChangeListener((selectedAudioDevice, audioDevices) -> {
    Log.d("VideoSDK", "Selected Audio Device: " + selectedAudioDevice.getLabel());
    for (AudioDeviceInfo audioDevice :
            audioDevices) {
        Log.d("VideoSDK", "Audio Devices" + audioDevice.getLabel());
    }
});
```

</TabItem>

</Tabs>

---

### checkPermissions()

- The `checkPermissions()` method verifies whether permissions to access camera and microphone devices have been granted. If the required permissions are not granted, the method will proceed to request these permissions from the user.

#### Parameters

- context

  - type: `Context`
  - `REQUIRED`
  - The android context.

- permission

  - type: `List<Permission>`
  - `REQUIRED`
  - The permission to be requested.

- permissionHandler

  - type: `PermissionHandler`
  - `REQUIRED`
  - The permission handler object for handling callbacks of various user actions such as permission granted, permission denied, etc.

- rationale

  - type: `String`
  - `OPTIONAL`
  - Explanation to be shown to user if they have denied permission earlier. If this parameter is not provided, permissions will be requested without showing the rationale dialog.

- options

  - type: `Permissions.Options`
  - `OPTIONAL`
  - The options object for setting title and description of dialog box that prompts users to manually grant permissions by navigating to device settings. If this parameter is not provided,the default title and decription will be used for the dialog box.

#### Returns

- _`void`_

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
private val permissionHandler: PermissionHandler = object : PermissionHandler() {
    override fun onGranted() {}
    override fun onBlocked(
        context: Context,
        blockedList: java.util.ArrayList<Permission>
    ): Boolean {
        for (blockedPermission in blockedList) {
            Log.d("VideoSDK Permission", "onBlocked: $blockedPermission")
        }
        return super.onBlocked(context, blockedList)
    }

    override fun onDenied(
        context: Context,
        deniedPermissions: java.util.ArrayList<Permission>
    ) {
        for (deniedPermission in deniedPermissions) {
            Log.d("VideoSDK Permission", "onDenied: $deniedPermission")
        }
        super.onDenied(context, deniedPermissions)
    }

    override fun onJustBlocked(
        context: Context,
        justBlockedList: java.util.ArrayList<Permission>,
        deniedPermissions: java.util.ArrayList<Permission>
    ) {
        for (justBlockedPermission in justBlockedList) {
            Log.d("VideoSDK Permission", "onJustBlocked: $justBlockedPermission")
        }
        super.onJustBlocked(context, justBlockedList, deniedPermissions)
    }
}
val permissionList: MutableList<Permission> = ArrayList()
permissionList.add(Permission.audio)
permissionList.add(Permission.video)
permissionList.add(Permission.bluetooth)
val rationale = "Please provide permissions"
val options =
    Permissions.Options().setRationaleDialogTitle("Info").setSettingsDialogTitle("Warning")
//If you wish to disable the dialog box that prompts 
//users to manually grant permissions by navigating to device settings, 
//you can set options.sendDontAskAgainToSettings(false)
VideoSDK.checkPermissions(this, permissionList, rationale, options, permissionHandler)
```

</TabItem>

<TabItem value="Java">

```js
private final PermissionHandler permissionHandler = new PermissionHandler() {
    @Override
    public void onGranted() {
    }

    @Override
    public boolean onBlocked(Context context, ArrayList<Permission> blockedList) {
        for (Permission blockedPermission :
                blockedList) {
            Log.d("VideoSDK Permission", "onBlocked: " + blockedPermission);
        }
        return super.onBlocked(context, blockedList);
    }

    @Override
    public void onDenied(Context context, ArrayList<Permission> deniedPermissions) {
        for (Permission deniedPermission :
                deniedPermissions) {
            Log.d("VideoSDK Permission", "onDenied: " + deniedPermission);
        }
        super.onDenied(context, deniedPermissions);
    }

    @Override
    public void onJustBlocked(Context context, ArrayList<Permission> justBlockedList, ArrayList<Permission> deniedPermissions) {
        for (Permission justBlockedPermission :
                justBlockedList) {
            Log.d("VideoSDK Permission", "onJustBlocked: " + justBlockedPermission);
        }
        super.onJustBlocked(context, justBlockedList, deniedPermissions);
    }
};
List<Permission> permissionList = new ArrayList<>();
permissionList.add(Permission.audio);
permissionList.add(Permission.video);
permissionList.add(Permission.bluetooth);
String rationale = "Please provide permissions";
Permissions.Options options =
        new Permissions.Options().setRationaleDialogTitle("Info").setSettingsDialogTitle("Warning");
//If you wish to disable the dialog box that prompts 
//users to manually grant permissions by navigating to device settings, 
//you can set options.sendDontAskAgainToSettings(false)
VideoSDK.checkPermissions(this, permissionList, rationale, options, permissionHandler);
```

</TabItem>

</Tabs>

---

### setSelectedAudioDevice()

- It sets the selected audio device, allowing the user to specify which audio device to use in the meeting.

#### Parameters

- **selectedAudioDevice**: AudioDeviceInfo

#### Returns

- _`void`_

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
val audioDevices: Set<AudioDeviceInfo> = VideoSDK.getAudioDevices()
val audioDeviceInfo: AudioDeviceInfo = audioDevices.toTypedArray().get(0) as AudioDeviceInfo
VideoSDK.setSelectedAudioDevice(audioDeviceInfo)
```

</TabItem>

<TabItem value="Java">

```js
Set<AudioDeviceInfo> audioDevices = VideoSDK.getAudioDevices();
AudioDeviceInfo audioDeviceInfo = (AudioDeviceInfo) audioDevices.toArray()[0];
VideoSDK.setSelectedAudioDevice(audioDeviceInfo);
```

</TabItem>

</Tabs>

---

### setSelectedVideoDevice()

- It sets the selected video device, allowing the user to specify which video device to use in the meeting.

#### Parameters

- **selectedVideoDevice**: VideoDeviceInfo

#### Returns

- _`void`_

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
val videoDevices: Set<VideoDeviceInfo> = VideoSDK.getVideoDevices()
val videoDeviceInfo: VideoDeviceInfo = videoDevices.toTypedArray().get(1) as VideoDeviceInfo
VideoSDK.setSelectedVideoDevice(videoDeviceInfo)
```

</TabItem>

<TabItem value="Java">

```js
Set<VideoDeviceInfo> videoDevices = VideoSDK.getVideoDevices();
VideoDeviceInfo videoDeviceInfo = (VideoDeviceInfo) videoDevices.toArray()[1];
VideoSDK.setSelectedVideoDevice(videoDeviceInfo);
```

</TabItem>

</Tabs>

---

### applyVideoProcessor()

- This method allows users to dynamically apply virtual background to their video stream during a live session.

#### Parameters

- videoFrameProcessor

  - type: `VideoFrameProcessor`
  - This is an object of the `VideoFrameProcessor` class, which overrides the `onFrameCaptured(VideoFrame videoFrame)` method.

#### Returns

- _`void`_

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
val uri = Uri.parse("https://st.depositphotos.com/2605379/52364/i/450/depositphotos_523648932-stock-photo-concrete-rooftop-night-city-view.jpg")
val backgroundImageProcessor = BackgroundImageProcessor(uri)
VideoSDK.applyVideoProcessor(backgroundImageProcessor)
```

</TabItem>

<TabItem value="Java">

```java
Uri uri = Uri.parse("https://st.depositphotos.com/2605379/52364/i/450/depositphotos_523648932-stock-photo-concrete-rooftop-night-city-view.jpg");
BackgroundImageProcessor backgroundImageProcessor = new BackgroundImageProcessor(uri)
VideoSDK.applyVideoProcessor(backgroundColorProcessor);
```

</TabItem>

</Tabs>

---

### removeVideoProcessor()

- This method provides users with a convenient way to revert their video background to its original state, removing any previously applied virtual background.

   - **Returns:**
      - _`void`_

#### Example

```js
VideoSDK.removeVideoProcessor();
```


</div>


---

---
sidebar_position: 1
sidebar_label: Properties
pagination_label: VideoSDK Class Properties
title: VideoSDK Class Properties
---

# VideoSDK Class Properties - Android

<div class="sdk-api-ref-only-h4">

### getSelectedAudioDevice()

- type: `AudioDeviceInfo`

- The `getSelectedAudioDevice()` method will return the object of the audio device, which is currently in use.

---

### getSelectedVideoDevice()

- type: `VideoDeviceInfo`

- The `getSelectedVideoDevice()` method will return the object of the video device, which is currently in use.



</div>


---

### 5.Errors associated with Media

These errors involve media access, device availability, or permission-related issues affecting camera, microphone, and screen sharing.

### Device access-related errors

| Type                                      | Code  | Message                                          |
|-------------------------------------------|-------|--------------------------------------------------|
| ERROR_CAMERA_ACCESS  | 3002  | Something went wrong. Unable to access camera. |
| ERROR_MIC_ACCESS_DENIED  | 3003  | It seems like microphone access was denied or dismissed. To proceed, kindly grant access through your device's settings. |
| ERROR_CAMERA_ACCESS_DENIED | 3004 | It seems like camera access was denied or dismissed. To proceed, kindly grant access through your device's settings. |

### 6.Errors associated with Track

These errors occur when there are issues with video or audio tracks, such as disconnections or invalid custom tracks.

| Type                        | Code  | Message                                          |
|-----------------------------|-------|--------------------------------------------------|
| ERROR_CUSTOM_SCREEN_SHARE_TRACK_ENDED      | 3005  | The provided custom track is in an ended state. Please try again with new custom track. |
| ERROR_CUSTOM_SCREEN_SHARE_TRACK_DISPOSED      | 3006  | The provided custom track was disposed. Please try again with new custom track. |
| ERROR_CHANGE_WEBCAM      | 3007  | Something went wrong, and the camera could not be changed. Please try again. |

### 7.Errors associated with Actions

Below error is triggered when an action is attempted before joining a meeting.

| Type                        | Code  | Message                                          |
|-----------------------------|-------|--------------------------------------------------|
| ERROR_ACTION_PERFORMED_BEFORE_MEETING_JOINED     | 3001  | Oops! Something went wrong. The room was in a connecting state, and during that time, an action encountered an issue. Please try again after joining a meeting. |

---

---
sidebar_label: App Size Optimization
pagination_label: App Size Optimization
---

# App Size Optimization - Android

This guide is designed to help developers optimize app size, enhancing performance and efficiency across different devices. By following these best practices, you can reduce load times, minimize storage requirements, and deliver a more seamless experience to users, all while preserving essential functionality.

### Deliver Leaner Apps with App Bundles

Using Android App Bundles (AAB) is an effective way to optimize the size of your application, making it lighter and more efficient for users to download and install. App Bundles allow Google Play to dynamically generate APKs tailored to each device, so users only download the resources and code relevant to their specific configuration. This approach reduces app size significantly, leading to faster installs and conserving storage space on users’ devices.

Recommended Practices:

- `Enable App Bundles`: Configure your build to use the App Bundle format instead of APKs. This will allow Google Play to optimize your app for each device type automatically.

- `Organize Resources by Device Type`: Ensure that resources (like images and layouts) are organized by device type (such as screen density or language) to maximize the benefits of App Bundles.

- `Test Modularization`: If your app contains large, optional features, use dynamic feature modules to let users download them on demand. This reduces the initial download size and provides features only as needed.

- `Monitor Size Reductions`: Regularly analyze your app size to see where the most savings occur, and make sure that App Bundle optimizations are effectively reducing your app size across different device configurations.

### Optimize Libraries for a Leaner App Experience

Managing dependencies carefully is essential for minimizing app size and improving performance. Every library or dependency included in your app adds to its overall size, so it’s crucial to only incorporate what’s necessary. Optimizing dependencies helps streamline your app, reduce load times, and enhance maintainability.

Recommended Practices:

- `Use Only Essential Libraries`: Review all libraries and dependencies, removing any that are not critical to your app’s functionality. This helps avoid unnecessary bloat.

- `Leverage Lightweight Alternatives`: Whenever possible, choose lightweight libraries or modularized versions of larger ones. For example, opt for a specific feature module rather than including an entire library.

- `Monitor Library Updates`: Regularly update your dependencies to take advantage of any optimizations or size reductions made by the library maintainers. Newer versions are often more efficient.

- `Minimize Native Libraries`: If your app uses native libraries, ensure they’re essential and compatible across platforms, as they can significantly increase app size.

- `Analyze Dependency Tree`: Use tools like Gradle’s dependency analyzer to identify unnecessary or redundant dependencies, ensuring your app’s dependency tree is as lean as possible.


### Optimize with ProGuard

ProGuard is a powerful tool for shrinking, optimizing, and obfuscating your code, which can significantly reduce your app's size and improve performance. By removing unused code and reducing the size of classes, fields, and methods, ProGuard helps to minimize the footprint of your app without sacrificing functionality. Additionally, ProGuard’s obfuscation feature enhances security by making reverse engineering more difficult. You can refer to the official [documentation](https://developer.android.com/build/shrink-code) for more information.

Recommended Practices:

- `Enable ProGuard`: To enable ProGuard in your project, ensure that your `proguard-rules.pro` file is properly configured, and add the following lines to your `build.gradle` file:

```js title="build.gradle"
buildTypes {
    release {
        minifyEnabled true
        proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'
    }
}
```

- `Customize ProGuard Rules`: Carefully review and customize ProGuard rules in the proguard-rules.pro file to avoid stripping essential code. For example, to keep a specific class, add:

```js
-keep class com.example.myapp.MyClass { *; }
```

If you encounter an issue after enabling ProGuard rules, refer to our [known issues section](https://docs.videosdk.live/android/guide/video-and-audio-calling-api-sdk/known-issues).

---

---
sidebar_label: Developer Experience Guidelines
pagination_label: Developer Experience Guidelines
---

# Developer Experience Guidelines - Android

This section provides best practices for creating a smooth and efficient development process when working with VideoSDK. From handling errors gracefully to managing resources and event subscriptions, these guidelines help developers build more reliable and maintainable applications. Following these practices can simplify troubleshooting, prevent common pitfalls, and improve overall application performance.

### Initiate Key Features After Meeting Join Event

To provide a seamless and reliable meeting experience, initiate specific features **only** after the [onMeetingJoined()](https://docs.videosdk.live/android/api/sdk-reference/meeting-class/meeting-event-listener-class#onmeetingjoined) event has been triggered.

- **Trigger Key Actions After Joining the Meeting** : Initiating crucial actions after the `onMeetingJoined()` event helps avoid errors and optimizes the meeting setup, ensuring a smoother experience for participants. If your application utilizes any of the following features or you want to perform any action as soon as meeting joins, it's recommended to call them only after the meeting has successfully started:

    - `Chat Subscription`: To enable in-meeting chat functionality, subscribe to the chat topic after the `onMeetingJoined()` event is triggered. This ensures that messages are reliably received by participants.

    <br/>
    <div style={{textAlign: 'center'}}>

    <img src="https://cdn.videosdk.live/docs/best-practices/mobile/android_chat_correct_incorrect_code.png" />

    </div>

    - `Device Management`: If you need users to use specific audio or video devices when the meeting is first joined, you can utilize the [`setSelectedAudioDevice()`](https://docs.videosdk.live/android/api/sdk-reference/videosdk-class/methods#setselectedaudiodevice) and [`setSelectedVideoDevice()`](https://docs.videosdk.live/android/api/sdk-reference/videosdk-class/methods#setselectedvideodevice) methods of `VideoSDK` class.

    - `Recording and Transcription`: To automatically start recording or transcription as soon as the meeting begins, configure the `autoStartConfig` in the `createMeeting` API. For detailed information, refer to the documentation [here](https://docs.videosdk.live/api-reference/realtime-communication/create-room#autoCloseConfig).

### Dispose Custom Tracks When Necessary

Proper disposal of custom tracks is essential for managing system resources and ensuring a smooth experience. In most scenarios, tracks are automatically disposed of by the SDK, ensuring efficient resource management. However, in specific cases outlined below, you will need to dispose of custom tracks explicitly:

1. **When Enabling/Disabling the Camera on a Precall Screen**:
    - If your application includes a precall screen and you want to ensure that the device's camera is not used when the camera is disabled, you must dispose of the custom video track. Otherwise, the device’s camera will continue to be used even when the camera is off.
    - Additionally, remember to create a new track when the user enables the camera again.
    - If you don’t need to manage the camera's usage on the device level (i.e., you’re okay with the camera being used whether it’s enabled or disabled), you can skip this step.
    - Here's how you can manage customTrack on a precall screen :

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
import live.videosdk.rtc.android.CustomStreamTrack
import live.videosdk.rtc.android.VideoSDK
import live.videosdk.rtc.android.VideoView

class JoinActivity : AppCompatActivity() {
    private var videoTrack: CustomStreamTrack? = null
    private var joinView: VideoView? = null

    private fun toggleWebcam(videoDevice: VideoDeviceInfo?) {
        if (isWebcamEnabled) {
            // check the track state is LIVE
            if(videoTrack?.track?.state()?.equals("LIVE") == true){
                videoTrack?.track?.dispose()  // Dispose the current video track
                videoTrack?.track?.setEnabled(false) // Disable the track
            }
            videoTrack = null
            joinView!!.removeTrack() // Remove the video track from the view
            joinView!!.releaseSurfaceViewRenderer()
            joinView!!.visibility = View.INVISIBLE;
        } else {
            // Re-enabling the webcam by creating a new track
            videoTrack = VideoSDK.createCameraVideoTrack(
                "h720p_w960p",
                "front",
                CustomStreamTrack.VideoMode.TEXT,
                true,
                this,
                videoDevice  // Passes the VideoDeviceInfo object of the user's selected device
            )
            // display in localView
            joinView!!.addTrack(videoTrack!!.track as VideoTrack?)
            joinView!!.visibility = View.VISIBLE
        }
        isWebcamEnabled = !isWebcamEnabled // Toggle webcam state
    }
}
```

</TabItem>

<TabItem value="Java">

```js
import live.videosdk.rtc.android.CustomStreamTrack
import live.videosdk.rtc.android.VideoSDK
import live.videosdk.rtc.android.VideoView

public class JoinActivity extends AppCompatActivity {
    private CustomStreamTrack videoTrack = null;
    private VideoView joinView = null;
    private boolean isWebcamEnabled = false;

    private void toggleWebcam(VideoDeviceInfo videoDevice) {
        if (isWebcamEnabled) {
            // Check if the track state is LIVE
            if (videoTrack != null && "LIVE".equals(videoTrack.getTrack().state())) {
                videoTrack.getTrack().dispose(); // Dispose the current video track
                videoTrack.getTrack().setEnabled(false); // Disable the track
            }
            videoTrack = null;
            joinView.removeTrack(); // Remove the video track from the view
            joinView.releaseSurfaceViewRenderer();
            joinView.setVisibility(View.INVISIBLE);
        } else {
            // Re-enabling the webcam by creating a new track
            videoTrack = VideoSDK.createCameraVideoTrack(
                "h720p_w960p",
                "front",
                CustomStreamTrack.VideoMode.TEXT,
                true,
                this,
                videoDevice // Passes the VideoDeviceInfo object of the user's selected device
            );
            // Display in the local view
            joinView.addTrack((VideoTrack) videoTrack.getTrack());
            joinView.setVisibility(View.VISIBLE);
        }
        isWebcamEnabled = !isWebcamEnabled; // Toggle webcam state
    }
}
```
</TabItem>

</Tabs>


### Listen for Error Events

Listening to error events enables your application to handle unexpected issues efficiently, providing users with clear feedback and potential solutions. Error codes pinpoint specific problems, whether from configuration settings, account restrictions, permission limitations, or device constraints. Here are recommended solutions based on common error categories:

1. [Errors associated with Organization](../../api/sdk-reference/error-codes.md#1-errors-associated-with-organization): If you encounter errors related to your organization (e.g., account status or participant limits), reach out to support at support@videosdk.live or reach out to us on [Discord](https://discord.com/invite/Qfm8j4YAUJ) for assistance.

2. [Errors associated with Token](../../api/sdk-reference/error-codes#2-errors-associated-with-token): For errors related to authentication tokens, ensure the token is valid and hasn’t expired, then try the request again.

3. [Errors associated with Meeting and Participant](../../api/sdk-reference/error-codes#3-errors-associated-with-meeting-and-participant): Check that meetingId and participantId are correctly passed and valid. Also, ensure each participant has a unique participantId to avoid duplicate entries.

4. [Errors associated with Add-on Service](../../api/sdk-reference/error-codes#4-errors-associated-with-add-on-service): If you encounter errors with add-on services (such as recording or streaming), try restarting the service after receiving a failure event. For example, if a `START_RECORDING_FAILED` error event occurs, attempt to call the `startRecording()` method again. If you're using webhooks, you can also retry on [recording-failed](https://docs.videosdk.live/api-reference/realtime-communication/user-webhooks#recording-failed) hook.

5. [Errors associated with Media](../../api/sdk-reference/error-codes#5errors-associated-with-media): Inform the user about media access issues, such as microphone or camera permissions. Design the UI to clearly indicate what is preventing the mic or camera from enabling, helping the user understand the problem.

6. [Errors associated with Track](../../api/sdk-reference/error-codes#6errors-associated-with-track): Ensure that the track you’ve created and passed to enable the mic or camera methods meets the required specifications.

7. [Errors associated with Actions](../../api/sdk-reference/error-codes#7errors-associated-with-actions): If you need to perform actions as soon as a meeting joins, only initiate them after receiving the [onMeetingJoined()](https://docs.videosdk.live/android/api/sdk-reference/meeting-class/meeting-event-listener-class#onmeetingjoined) event, otherwise it will not work well.

- Here's how to listen for the error event:

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
private val meetingEventListener: MeetingEventListener = object : MeetingEventListener() {
  //..
  override fun onError(error: JSONObject) {
  try {
      val errorCodes: JSONObject = VideoSDK.getErrorCodes()
      val code = error.getInt("code")
      Log.d("#error", "Error is: " + error["message"])
  } catch (e: Exception) {
          e.printStackTrace()
      }
  }
}
```

</TabItem>

<TabItem value="Java">

```js
private final MeetingEventListener meetingEventListener = new MeetingEventListener() {
  //..
  @Override
  public void onError(JSONObject error) {
      try {
          JSONObject errorCodes = VideoSDK.getErrorCodes();
          int code = error.getInt("code");
          Log.d("#error", "Error is: " + error.get("message"));
      } catch (Exception e) {
          e.printStackTrace();
      }
  }
};
```

</TabItem>

</Tabs>

---

---
sidebar_label: Handle Large Rooms
pagination_label: Handle Large Rooms
---

# Handle Large Rooms - Android

Managing large meetings requires specific strategies to ensure performance, stability, and a seamless user experience. This section provides best practices for optimizing VideoSDK applications to handle high participant volumes effectively. By implementing these recommendations, you can reduce lag, maintain video and audio quality, and provide a smooth experience even in large rooms.

### User Interface Optimization

When hosting large meetings, an optimized UI helps manage participant visibility and ensures smooth performance.

Recommended Practices:

- `Limit Visible Participants`: Display only a limited number of participants on screen at any given time, adapting the view based on screen size. Use pagination to allow users to browse or switch between additional participants seamlessly. For example, you could display only users whose video stream is enabled, or you could choose to display all active speakers. This approach helps manage screen space efficiently, ensuring that the most relevant participants are visible without overwhelming the interface.
- `Prioritize Active Speakers`: Ensure all active speakers are displayed on the screen to highlight who is currently talking, helping participants stay engaged and aware of ongoing discussions. To identify which participant is speaking, you can use the [onSpeakerChanged()](https://docs.videosdk.live/android/api/sdk-reference/meeting-class/meeting-event-listener-class#onspeakerchanged) event.

### Optimizing Media Streams 

In large video calls, it’s important to manage media streams effectively to optimize system resources while maintaining a smooth user experience. 

Recommended Practices:

- `Pause Streams for Non-Visible Participants`: To optimize performance, pause the video and/or audio streams of participants who are not currently visible on the screen. This reduces unnecessary resource consumption.
- `Resume Streams When Visible`: Once a participant comes into view, resume their stream to provide an uninterrupted experience as they appear on the screen.

For detailed setup instructions on how to achieve this, check out our in-depth documentation [here](https://docs.videosdk.live/android/guide/video-and-audio-calling-api-sdk/render-media/layout-and-grid-management#pauseresume-stream).

### Media Stream Quality Adjustment

In large meetings, managing media stream quality is essential to balance performance and user experience. 

Recommended Practices:

- `High Quality for Active Speakers`: For all active speakers, set the video stream quality to a higher level using the setQuality method (e.g., `setQuality("high")`). This ensures that participants will receive higher-quality video for active speakers, providing a clearer and more engaging experience.
- `Lower Quality for Non-Speaking Participants`: For other participants who are not actively speaking, set their video stream quality to a lower level (e.g., `setQuality("low")`). This helps conserve bandwidth and system resources while maintaining overall meeting performance.

Checkout the documentation for `setQuality()` method [here](https://docs.videosdk.live/android/api/sdk-reference/participant-class/methods#setquality) 

---

---
sidebar_label: User Experience Guidelines
pagination_label: User Experience Guidelines
---

# User Experience Guidelines - Android

This guide aims to help developers optimize the user experience and functionality of video conferencing applications with VideoSDK. By following these best practices, you can create smoother interactions, minimize common issues, and deliver a more reliable experience for users.

Here are our recommended best practices to enhance the user experience in your application:

| **Section**                          | **Description**                                                                                                                                                      |
|--------------------------------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| [Configure Precall for Effortless Meeting Join](#configure-precall-for-effortless-meeting-join) | Users may enter meetings unprepared due to device or connection issues. A Precall setup can help them configure devices and settings beforehand for a smooth start. |
| [Listen Key Events for Optimal User Experience](#listen-key-events-for-optimal-user-experience) | Users can feel lost without real-time updates on meeting status, events, and errors. Event monitoring and notifications keep them informed and engaged.              |
| [Handling Media Devices](#handling-media-devices)                                             | Users may want to change their audio or video setup mid-meeting but struggle to manage device controls. Providing easy device switching enhances control and flexibility. |
| [Monitoring Real-Time Participant Statistics](#monitoring-real-time-participant-statistics)   | Poor video or audio quality without real-time feedback leaves users frustrated. Real-time stats let them assess connection quality and troubleshoot issues actively.    |

### Configure Precall for Effortless Meeting Join

A Precall step is crucial for ensuring users are set up correctly and have no device before joining a meeting. This step allows users to configure their devices and settings before entering a meeting, leading to a smoother experience and minimizing technical issues once the call begins.

Recommended Practices:

- `Request Permissions`: Prompt users to grant microphone, and camera permissions before entering the meeting, ensuring seamless access to their devices.
- `Device Selection`: Allow users to select their preferred camera, and microphone giving them control over their setup from the start.
- `Entry Preferences`: Provide options to join with the microphone and camera either on or off, letting users choose their level of engagement upon entry.
- `Camera Preview`: Show a live camera preview, allowing users to adjust angles and lighting to ensure they appear clearly and professionally.
- `Virtual Backgrounds`: Allow users to choose from different virtual backgrounds or enter with a virtual background enabled, enhancing privacy and creating a more polished appearance.

For detailed setup instructions on each of these features, check out our in-depth documentation [here](https://docs.videosdk.live/android/guide/video-and-audio-calling-api-sdk/setup-call/precall).

<div style={{textAlign: 'center'}}>

<img height="400" src="https://cdn.videosdk.live/docs/best-practices/mobile/mobile_precall.gif" />

</div>

### Monitor Key Events for Optimal User Experience

Listening for crucial events is vital for providing users with a responsive and engaging experience in your application. By effectively managing state changes and user notifications, you can keep participants informed and enhance their overall experience during meetings.

Recommended Practices:

- `Monitor State Change Events`: Listen for state change events, such as `onMeetingStateChanged` and `onRecordingStateChanged`, and notify users promptly about these transitions. Keeping users informed helps them understand the current state of the meeting.

<div style={{textAlign: 'center'}}>

<img height="400" src="https://cdn.videosdk.live/docs/best-practices/mobile/mobile_meeting_state.jpg" />

</div>

- `UI Handling on Event Trigger`: Update the user interface only in response to specific events. For instance, display that the meeting is recording only when the `onRecordingStateChanged` event with the status `RECORDING_STARTED` is received, rather than when the record button is clicked. This ensures users receive accurate and timely updates.

<div style={{textAlign: 'center'}}>

<img height="400" src="https://cdn.videosdk.live/docs/best-practices/mobile/mobile_recording.gif" />

</div>

- `Notify Participants of Join/Leave Events`: Keep users informed about participant activity by notifying them when someone joins or leaves the meeting. This fosters a sense of presence and awareness of who is currently available to engage.
- `Listen for Error Events`: It is crucial to monitor error events and notify users promptly when issues arise. Clear communication about errors can help users troubleshoot and address problems quickly, minimizing disruptions to the meeting.


### Handling Media Devices

Providing seamless control over devices enhances user convenience and allows participants to adjust their setup for the best meeting experience. Proper device management within the UI also helps users stay informed about their current settings and troubleshoot issues effectively.

Recommended Practices:

- `Allow Device Switching`: Provide users with the option to switch between available microphone, and camera devices during the meeting. This flexibility is essential, especially if users want to adjust their setup mid-call.
- `Display Selected Devices`: Ensure the UI shows users which microphone, and camera devices are currently selected. Clear device labeling in the interface can reduce confusion and help users verify their setup at a glance.

<div style={{textAlign: 'center'}}>

<img height="400" src="https://cdn.videosdk.live/docs/best-practices/mobile/mobile_audio_selected_device.jpg" />

</div>

### Monitoring Real-Time Participant Statistics

Providing real-time insights into stream quality allows participants to monitor and optimize their connection for the best experience. With detailed metrics on video, audio, and screen sharing, users can assess and troubleshoot quality issues, ensuring smooth and uninterrupted meetings. To display these statistics, you can use the [getVideoStats()](https://docs.videosdk.live/android/api/sdk-reference/participant-class/methods#getvideostats), [getAudioStats()](https://docs.videosdk.live/android/api/sdk-reference/participant-class/methods#getaudiostats), and [getShareStats()](https://docs.videosdk.live/android/api/sdk-reference/participant-class/methods#getsharestats) methods.

import ReactPlayer from 'react-player'

<div style={{textAlign: 'center'}}>

<ReactPlayer autoplay muted loop playing url='https://cdn.videosdk.live/docs/best-practices/mobile/mobile_call-stats.mp4' width={"100%"}/>

</div>

<br/>

:::note
To show the popup dialog for the participant's realtime stats, you can [refer to this function](https://github.com/videosdk-live/videosdk-rtc-android-kotlin-sdk-example/blob/main/app/src/main/java/live/videosdk/rtc/android/kotlin/Common/Utils/HelperClass.kt#L91).
:::



---

---
sidebar_label: Face Match API
pagination_label: Face Match API
---

# Face Match API

import FaceMatchApi from '../../../../mdx/\_api-face-match.mdx';

<FaceMatchApi/>






---

---
sidebar_label: Face Spoof Detection API
pagination_label: Face Spoof Detection API
---

# Face Spoof Detection

import FaceSpoofDetection from '../../../../mdx/\_api-spoof-detection.mdx';

<FaceSpoofDetection/>

---

---
sidebar_label: Number of Face Detection API
pagination_label: Number of Face Detection API
---

# Number of Face Detection

import NoOfFaceDetectionApi from '../../../../mdx/\_api-number-of-face-detection.mdx';

<NoOfFaceDetectionApi/>






---

---
sidebar_label: OCR API
pagination_label: OCR API
---

# OCR API

import OcrApi from '../../../../mdx/\_api-ocr.mdx';

<OcrApi/>






---

---
title: Understanding Analytics Dashboard | Video SDK
hide_title: true
hide_table_of_contents: false
description:  Learn how to access and use VideoSDK's Analytics Dashboard to optimize session performance and diagnose issues.
sidebar_label: Understanding Analytics Dashboard
pagination_label: Understanding Analytics Dashboard
keywords:
  - audio calling
  - video calling
  - real-time communication
  - collaboration
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: understanding-analytics-dashboard
---

import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>

# Understanding Analytics Dashboard - Android

Welcome to the world of actionable insights and empowered decision-making. VideoSDK's session analytics dashboard is your gateway to understanding, optimizing, and elevating every aspect of your sessions.

## Accessing Analytics Made Easy

Navigating through session data is a breeze with VideoSDK. Simply head to your session page at https://app.videosdk.live/meetings/sessions, where a treasure trove of session information awaits.

### How to Access Analytics?

Open Session Analytics effortlessly by following these steps:

1. **Click on Meeting-ID:**
    - Directly access analytics by clicking on the meeting-ID within the session table.
2. **Hover and Click View Analytics:**
    - Hover over a specific meeting row to reveal the **View Analytics** button in the Actions Column.
    - Click on **View Analytics** to open the Session Overview sidebar, unlocking a wealth of insights.

![Access Analytics](https://cdn.videosdk.live/website-resources/docs-resources/access_analytics.png)

---

There are three tabs available within the session analytics view:

## **1. Session Overview**

This tab provides an overview of the session, including its duration and participant details. You can explore individual participant statistics to understand their session performance better.

## **2. Errors**

In this tab, you can find information about any errors encountered during the session. It helps you identify and address issues like network problems or technical glitches promptly.

## **3. Session Stats**

Explore data and metrics sent and received by participants to measure performance of the session in this tab. It offers insights into data exchange among participants, including metrics on jitter, RTT, and packet loss, resolutions, and fps aiding in assessing communication efficiency.

Let's dive deeper into each of these tabs to gain a better understanding of session analytics.

# Session Overview

The session overview page is your compass in the sea of data. Here's what you'll uncover:

- **Meeting ID:** Unique identifier for the meeting in the format of `abcd-efgh-ijkl`.
- **Session ID:** Unique identifier for each session, uniquely identified by its `sessionId`.
- **Session Status:** Indicates if the session is ongoing or ended.
- **Session Initiating Time:** Time taken by the first participant to establish the connection.
- **Start and End Time:** Marks the start and end of the session.
- **Total Unique Participants Joined:** Total number of unique participants in the session.
- **Total Session Duration:** Overall duration of the session from start to end.
- **Total Participant Minutes:** A sum of all participant duration.
- **Recording, HLS, RTMP:** Additional services used in the session.

### Participant Table List

- **Participant ID:** Unique identifier for each participant.
- **Participant Name:** Personalized identification for each participant.
- **Join Time:** Time taken by the participant to establish connection.
- **Duration:** Total time spent by this participant in the session.

### Efficient Session Management with Actions

Enhance your session management with streamlined actions:

- **Kick Out Participants:** Effortlessly remove/kickout participants from ongoing sessions.
- **Detailed Participant Analytics:**
- Hover over a specific participant row to reveal the `View Stats` button at the end of the row.
- Click on `View Stats` to open the Participant Overview sidebar.
    
![View Stats](https://cdn.videosdk.live/website-resources/docs-resources/view_stats.png)

## Explore Participant Insights

Discover valuable participant data that provides a clear view of engagement and experience:

- **Participant ID:** Unique identifier for each participant.
- **Participant Name:** Personalized identification for better interaction.
- **Joined At:** Indicates the precise moment when participant connects to the session.
- **Left At:** Indicates the precise moment when participant left the session.
- **Total Duration:** Total duration of participant within that session.
- **Joining Time:** Time taken by the this participant to establish the connection.
- **Location:** Approx. geographic location from where the participant joined.
- **Platform:** Specifies whether participants are using a desktop or mobile device.
- **Device Info:** Offers details regarding the participant's device.
- **OS:** Provides information about the participant's OS.
- **Browser:** Provides specifics about the participant's browser
- **SDK Version:** Indicates the version of the SDK used by participants.

### Understanding Participant Call Health

We've developed call health to offer a rapid assessment of participant performance during calls. This feature highlights the performance of audio, video, and screen sharing audio-video separately. We've utilized color theory, with green indicating good performance, orange for moderate, and red for poor performance, to enhance clarity. For detailed insights, simply hover over the bars

![Participant Call Health](https://cdn.videosdk.live/website-resources/docs-resources/participant_call_health.png)

## Participant Session Stats

Dive into Participant Session Stats for valuable insights into your session experience! With just a click on `View Session Stats` at the bottom of the page, unlock a treasure trove of data crucial for understanding audio and video experiences.

Within this section, you can observe quality metrics for the selected participant, comparing them to others. Additionally, the `Sessions Stats` covers quality stats comparison for every participant. Keep reading to explore more about Session Stats.

**Visualizing Session Performance from Both Sides**

This section provides a two-sided view of your session's metrics.

- **Left Side: Sender Participant Graph** This section displays graphs representing the metrics sent by the sender participant.. Here, you can see how the various factors impacted the data you transmitted.
- **Right Side: Receiver Participant Graph** On the right side, you'll find a dropdown menu where you can select a specific participant. Choosing a receiver will display graphs showcasing the metrics **received by that participant**. This allows you to compare the sending experience (left side) with the receiving experience (right side) for different participants.

![VideoSDK Jitter Graph](https://cdn.videosdk.live/website-resources/docs-resources/video_jitter_graph.png)

**See How Your Session Performed**

These metrics give you a clear picture of your session's quality. Understanding them helps you spot any issues and keep things running smoothly. Let's dive into what each metric means!

**Jitter:** Imagine your internet connection like a bumpy road. Jitter is how much those bumps cause your signal to bounce around. Less jitter means a smoother ride for your data (audio and video, threshold ≤ 30ms).

**RTT (Latency):** This is how long it takes for data to travel between you and the server you're connected to. Think of it like the time it takes for a message to get delivered – a lower RTT means a faster delivery (affects both audio and video, threshold ≤ 300ms).

**Bitrate:** This measures the amount of data flowing through your connection per second. Imagine it like the width of a water pipe – a higher bitrate allows for more data to flow, which can be good for high-quality audio/video or fast downloads.

**Packet Loss:** Think of data traveling in tiny packets. Packet loss is when some of those packets get dropped along the way. More packet loss means information might be missing, affecting things like audio/video quality or lag in games (threshold ≤ 5%).

**Resolution:** This refers to the sharpness and detail of an image or video. Think of it like the number of pixels on your screen – a higher resolution means a crisper picture (**Video Only**).

**FPS (Frames Per Second):** This measures how many images (frames) are displayed on your screen every second. Imagine it like a flipbook – a higher FPS creates a smoother and more fluid animation or video experience (**Video Only**).

![VideoSDK FPS Graph](https://cdn.videosdk.live/website-resources/docs-resources/video_fps_graph.png)

![VideoSDK Resolution Graph](https://cdn.videosdk.live/website-resources/docs-resources/video_resolution_graph.png)

---

# **Investigate Session Errors**

Get to the root of smoother sessions by addressing errors directly. Use the Errors tab to explore details of errors encountered during your session. Note: Session errors are visible with JS SDK v0.0.82 or higher, React SDK v0.1.85 or higher, and React Native v0.1.6 or newer versions.

- **Participant Name & ID:** Quickly identify the participant associated with each error for swift resolution.
- **Error Types:** Understand the different types of errors encountered, such as network issues or connection disruptions.
- **Detailed Descriptions:** Access clear explanations of errors to take actionable steps towards solution.

![VideoSDK Error Details](https://cdn.videosdk.live/website-resources/docs-resources/error_new.png)

# **Analyse Session Stats**

Similar to `Participant Session Stats`, this tab covers quality statistics sent by individual participants. You can select any participant to compare effectively with others.

Choose a sender participant from the dropdown menu on the left and select a recipient on the right to compare data over different time frames. This allows you to identify and explore issues within specific durations.

This tab covers the same metrics as covered in the `participant session stats`: Jitter, RTT (Latency), Bitrate, Packet-loss, Resolution (Video only), and FPS (Video only).

![VideoSDK Session Stats](https://cdn.videosdk.live/website-resources/docs-resources/session_stats.png)


---

---
title: Understanding Call Quality | Video SDK
hide_title: true
hide_table_of_contents: false
description: Learn how factors like bandwidth, latency, and device quality impact your app's call quality with Video SDK.
sidebar_label: Understanding Call Quality
pagination_label: Understanding Call Quality
keywords:
  - audio calling
  - video calling
  - real-time communication
  - collaboration
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: understanding-call-quality
---

# Understanding Call Quality - Android

When developing a video call app, customer satisfaction heavily depends on the app's video and audio quality and its fluctuation.

## Call Quality

From the user's perspective, good video quality is defined as smooth and clear video, along with crystal clear audio. Developers consider good video quality as high-resolution, high-frame-rate video with minimal latency and high-bitrate audio with minimal audio loss.

## Factors affecting Quality

When measuring video and audio quality, several variables come into play. The common factors affecting quality are as follows:

### `1. Network Bandwidth`

- Network bandwidth is the measure of a user's network capacity, indicating how much data can be received and sent.
- If the participant's bandwidth is low, they are likely to experience pixelated or frozen video, along with robotic voice or minor audio interruptions.
- Frequent changes in network providers can also lead to significant fluctuations in internet bandwidth, resulting in poor video quality.

### `2. Latency`

- Latency refers to the time it takes for data to transfer from one machine to another.
- If the meeting is hosted in `Ohio` region, and users are joining from `Singapore` region, this can result in a long delay for data to transfer between mackines. Therefore, it is advisable to choose a server based on your user base.
- With VideoSDK, you can specify the server during the creation of a Meeting/Room.

### `3. CPU Usage`

- CPU Usage is also a determining factor, as all the audio and video streams going out and coming in need to be encoded or decoded, requiring a significant amount of computation.
- The higher the resolution and frame rate of the videos, the greater the computation required, which can lead to a bottleneck in delivering good-quality video.
- If the CPU is heavily consumed, it can also result in choppy or robotic audio.

### `4. Camera and Mic Quality`

- The camera and microphone should capture high-quality streams to ensure that remote users don't receive a low-quality stream even if they have bad network bandwidth.

## Identifying various issues related to Quality.

In order to identify potential issues, VideoSDK collects various audio and video-related metrics that can help pinpoint quality concerns. Take a look at these metrics and understand what they indicate.

### `1. Resolution and Framerate`

- Resolution and frame rate serve as crucial metrics for video quality in a video call app. Resolution indicates the number of pixels in a video image, while frame rate denotes the number of frames displayed per second.

- While higher resolutions and frame rates can enhance video quality, they also demand more bandwidth and processing power. It's essential to optimize these metrics based on the devices and network conditions of your users.

- For instance, if the majority of your users are on mobile devices, opting for a lower resolution and frame rate may be more suitable to ensure smooth playback and minimize bandwidth usage.

- If your user base comprises both mobile and desktop devices, adopting higher resolution for desktops and mid-resolutions for mobile devices can contribute to improved performance and quality while conserving bandwidth on mobile devices.

### `2. Bitrate`

- Bitrate represents the number of bits per second transmitted or received during the transmission of audio or video streams. It is a crucial parameter for assessing the quality of audio or video streams and should be adjusted for each resolution to strike a balance between performance and bandwidth utilization.

- In scenarios with excellent network conditions, a higher bitrate can lead to significantly improved video quality. However, it's essential to be cautious when dealing with very high bitrates on mobile devices, as it may result in heating issues due to the substantial computational requirements for encoding and decoding videos.

##### Example

We used the same phone **(iPhone 14)**, for both participants, but there were differences in resolution and bitrate. The first participant had a resolution of **`1280x720`** with a bitrate of **`1442 kbps`**, while the second participant had a resolution of **`960x540`** with a bitrate of **`642 kbps`**. Surprisingly, both participants' videos appeared to be of equal quality despite variations in resolution and bitrate.

![resolution-and-bitrate](/img/resolution-and-bitrate.png)

### `3. Packet Loss`

- Packet loss is a metric that reveals the number of lost data packets during transmission from the sender to the receiver. It can happen due to network congestion, hardware or software issues, or network latency. Increased packet loss can lead to degraded video and audio quality, as the absence of packets may cause gaps or distortions in the media stream.

import ReactPlayer from 'react-player'

<div style={{textAlign: 'center'}}>

<ReactPlayer autoplay muted loop playing url='/video/packet-loss-burst.mp4' width={"100%"}/>

</div>

### `4. Jitter`

- The audio and video packets are sent out at random intervals over a specified time frame as they travel between the server and client. Jitter occurs when there is a variation in transmitting or receiving these data packets due to a faulty network connection.

- When data packets experience delays during transmission to the participant, usually because the network is busy, they may result in pixelated video during a video call or sound choppy, distorted, or robotic in a voice call upon arrival. This creates jitter, with packets arriving at random intervals.

### `5. Round Trip Time (Latency)`

- Round trip time refers to the duration it takes for data packets to be transmitted from the user's device to the server and back. If the servers are located far from the user's location, they may experience high latency (delay).

- With VideoSDK, this factor is addressed as we automatically choose the nearest available server for participants. However, if you are geofencing to a specific region, ensure that you choose the server nearest to your users.

<center>

![resolution-and-bitrate](/img/rtt.png)

</center>

## Checking Realtime Statistics

VideoSDK provides methods to check the realtime statistics of audio and video of all the participants.

### `getVideoStats()`

- The `getVideoStats()` method returns an object containing the different quality parameters for video stream, which can be accessed through the `useParticipant` hook.

- This object will contain values for the specific participant's video stream, including resolution, frame rate, bitrate, jitter, round trip time, and packet loss.

<div style={{textAlign: 'center'}}>

<ReactPlayer autoplay muted loop playing url='/video/realtime-stats.mp4' width={"100%"}/>

</div>

### `getAudioStats()`

- The `getAudioStats()` method returns an object containing the different quality parameters for audio stream, which can be accessed through the `useParticipant` hook.

- This object will contain values for the specific participant's audio stream, including bitrate, jitter, round trip time and packet loss.

### `getShareStats()`

- The `getShareStats()` method returns an object containing the different quality parameters for screen share stream, which can be accessed through the `useParticipant` hook.

- This objects will contain values for the specific participant's screen share stream, including resolution, frame rate, bitrate, jitter, round trip time, and packet loss.

### `getShareAudioStats()`

- The `getShareAudioStats()` method returns an object containing the different quality parameters for screen share audio stream, which can be accessed through the `useParticipant` hook.

- This object will contain values for the specific participant's screen share audio stream, including bitrate, jitter, round trip time and packet loss.

:::note
To show the popup dialog for the participant's realtime stats, you can [refer to this component](https://github.com/videosdk-live/videosdk-rtc-react-sdk-example/blob/main/src/utils/common.js#L142).
:::

## Quality analysis Graphs

For all sessions conducted using VideoSDK, you can access quality analysis graphs from the [VideoSDK Dashboard](https://app.videosdk.live/meetings/sessions). These graphs help you visualize real-time data and identify spikes in certain parameters during calls, aiding in understanding the reasons for quality issues.

![quality analysis](/img/quality-analysis.png)

## API Reference

The API references for all the methods and events utilized in this guide are provided below.

- [getVideoStats()](/android/api/sdk-reference/participant-class/methods#getvideostats)
- [getAudioStats()](/android/api/sdk-reference/participant-class/methods#getaudiostats)
- [getShareStats()](/android/api/sdk-reference/participant-class/methods#getsharestats)


---

---
sidebar_label: Change Mode
pagination_label: Change Mode
---

# Change Mode - Android

In a live stream, audience members usually join in `RECV_ONLY` mode, meaning they can only view and listen to the hosts. However, if a host invites an audience member to actively participate (e.g., to speak or present), the audience member can switch their mode to `SEND_AND_RECV` using the changeMode() method.

This guide explains how to use the changeMode() method and walks through a sample implementation where a host invites an audience member to become a host using PubSub.

### `changeMode()`

- The `changeMode()` method from the `Meeting` class allows a participant to switch between modes during a live stream—for example, from audience to host.

#### Example

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
class LiveStreamActivity : AppCompatActivity() {
 override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    setContentView(R.layout.activity_live_stream);
    // initialize the meeting
    liveStream = VideoSDK.initMeeting(... )
    ...

    // join meeting
    liveStream!!.join()

    // Button to change mode
    val changeModeBtn: Button = findViewById(R.id.btnChangeMode)
    changeModeBtn.setOnClickListener {
        liveStream.changeMode(MeetingMode.SEND_AND_RECV)
    }
  }
}
```

</TabItem>

<TabItem value="Java">

```java
public class LiveStreamActivity extends AppCompatActivity {
  @Override
  protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_live_stream);
    // initialize the meeting
    Meeting liveStream = VideoSDK.initMeeting( ...);
    ...

    // join meeting
    liveStream.join()  

    // Button to change mode
    Button changeModeBtn = findViewById(R.id.btnChangeMode);
    changeModeBtn.setOnClickListener(new View.OnClickListener() {
        @Override
        public void onClick(View v) {
            liveStream.changeMode(MeetingMode.SEND_AND_RECV);
        }
    });
  
  }
}
```

</TabItem>

</Tabs>

#### Implementation Guide

#### Step 1 : Create a Pubsub Topic

- Set up a PubSub topic to send a mode change request from the host to a specific audience member.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
fun sendInvite(livestream: Meeting, participantId: String) {
    val pubSubPublishOptions = PubSubPublishOptions().apply {
        isPersist = false
    }

    livestream.pubSub.publish(
        "REQUEST_TO_JOIN_AS_HOST_$participantId", // PubSub topic specific to participant
        "SEND_AND_RECV", // message
        pubSubPublishOptions
    )
}
```

</TabItem>

<TabItem value="Java">

```java
void sendInvite(Meeting livestream, String participantId) {
   PubSubPublishOptions pubSubPublishOptions = new PubSubPublishOptions(); 
   pubSubPublishOptions.setPersist(false);
   livestream.pubSub.publish(
        "REQUEST_TO_JOIN_AS_HOST_"+ participantId, // PubSub topic specific to participant
        "SEND_AND_RECV", // message
        pubSubPublishOptions
    );
}
```

</TabItem>

</Tabs>

#### Step 2 : Create an Invite Button

- Add an "Invite on Stage" button for each audience member. When clicked, it publishes a PubSub message with the mode "SEND_AND_RECV" to that participant.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
// In ParticipantListAdapter.kt, inside showPopup method
if (participant!!.mode == "RECV_ONLY") {
    popup.menu.add("Add as a co-host")
    
    popup.setOnMenuItemClickListener { item: MenuItem ->
        if (item.toString() == "Add as a co-host") {
            sendInvite(liveStream,participantId);
            holder.requestedIndicator.visibility = View.VISIBLE
            holder.btnParticipantMoreOptions.isEnabled = false
            return@setOnMenuItemClickListener true
        }
        false
    }
}
```

</TabItem>

<TabItem value="Java">

```java
// In ParticipantListAdapter.java, inside showPopup method
if ("RECV_ONLY".equals(participant.getMode())) {
    popup.getMenu().add("Add as a co-host");

    popup.setOnMenuItemClickListener(new PopupMenu.OnMenuItemClickListener() {
        @Override
        public boolean onMenuItemClick(MenuItem item) {
            if ("Add as a co-host".equals(item.toString())) {
                sendInvite(liveStream,participantId);
                holder.requestedIndicator.setVisibility(View.VISIBLE);
                holder.btnParticipantMoreOptions.setEnabled(false);
                return true;
            }
            return false;
        }
    });
}

```

</TabItem>

</Tabs>

#### Step 3 : Create a Listener to Change the Mode

- On the audience side, subscribe to the specific PubSub topic. When a mode request is received, update the participant’s mode using changeMode().

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
// In your class where you define coHostListener
val coHostListener = object : PubSubMessageListener {
    override fun onMessage(pubSubMessage: PubSubMessage) {
        showCoHostRequestDialog()
    }
}

liveStream.pubSub.subscribe(
    "REQUEST_TO_JOIN_AS_HOST_${liveStream.localParticipant.id}", 
    coHostListener
)

// In the showCoHostRequestDialog method
private fun showCoHostRequestDialog() {
    // Dialog setup code...

    acceptBtn.setOnClickListener {
        liveStream.changeMode("SEND_AND_RECV")
    }
    // Rest of the dialog code...
}
```

</TabItem>

<TabItem value="Java">

```java
// In your class where you define coHostListener
PubSubMessageListener coHostListener = new PubSubMessageListener () {
    @Override
    public void onMessage(PubSubMessage pubSubMessage) {
        showCoHostRequestDialog();
    }
};

liveStream.pubSub.subscribe("REQUEST_TO_JOIN_AS_HOST_" + liveStream.getLocalParticipant().getId(), coHostListener);

// In the showCoHostRequestDialog method
private void showCoHostRequestDialog() {
    // Dialog setup code...

    acceptBtn.setOnClickListener(new View.OnClickListener() {
        @Override
        public void onClick(View v) {
            liveStream.changeMode("SEND_AND_RECV");
        }
    });

    // Rest of the dialog code...
}
```

</TabItem>

</Tabs>

import ReactPlayer from "react-player";


<ReactPlayer autoplay muted loop playing url="/img/ils/pubsub-request-ils.mp4" height="500px" width={"100%"} />

## API Reference

The API references for all the methods and events utilized in this guide are provided below.

- [changeMode()](/android/api/sdk-reference/meeting-class/methods#changemode)
- [Participant](/android/api/sdk-reference/participant-class/properties)
- [Meeting](/android/api/sdk-reference/meeting-class/properties)
- [pubSub()](/android/api/sdk-reference/pubsub-class/introduction)


---

---
title: Remove participant from the meeting - React JS SDK
hide_title: false
hide_table_of_contents: false
description: Remove a participant or a peer from the meeting while it is still in progress. It helps in meeting moderation.
sidebar_label: Remove Participant
pagination_label: Remove Participant
keywords: 
  - remove participant
  - block participant
  - react js
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: remove-participant
---

# Remove Participant - Android

When hosting a live stream, it's essential for the host to have the capability to to remove a participant from the live stream. This can be useful in various scenarios where a participant is causing disturbance, behaving inappropriately, or is not following the guidelines. This guide focuses on this very aspect of removing a particpant from the live stream.

VideoSDK provides three ways to do so:

1. [Using SDK](#1-using-sdk)
2. [Using VideoSDK Dashboard](#2-using-videosdk-dashboard)
3. [Using Rest API](#3-using-rest-api)

## 1. Using SDK

### `remove()`

The `remove()` method allows for the removal of a participant during an on-going session. This can be helpful when moderation is required in a particular live stream.

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
btnRemoveParticipant!!.setOnClickListener { _: View? ->
  val remoteParticipantId = "<participant-id>"
  // Get specific participant instance
  val participant = meeting!!.participants[remoteParticipantId]
  // Remove participant from active session
  // This will emit an event called "onParticipantLeft" for that particular participant
  participant!!.remove()
}
```

</TabItem>

<TabItem value="Java">

```js
btnRemoveParticipant.setOnClickListener(new View.OnClickListener() {
  @Override
  public void onClick(View v) {
    String remoteParticipantId = "<participant-id>";
    // Get specific participant instance
    Participant participant = meeting.getParticipants().get(remoteParticipantId);
    // Remove participant from active session
    // This will emit an event called "onParticipantLeft" for that particular participant
    participant.remove();
  }
});
```

</TabItem>

</Tabs>

### Events associated with remove()

Following callbacks are received when a participant is removed from the meeting.

- The participant who was removed from the meeting will receive a callback on the [`onMeetingLeft`](/android/api/sdk-reference/meeting-class/meeting-event-listener-class#onmeetingleft) event of the `Meeting` class.

- All other [remote participants](/android/guide/video-and-audio-calling-api-sdk/concept-and-architecture#2-participant) will receive a callback [`onParticipantLeft`](/android/api/sdk-reference/meeting-class/meeting-event-listener-class#onparticipantleft) with Participant object.

## 2. Using VideoSDK Dashboard

- For removing a participant using the VideoSDK Dashboard, navigate to the session page on [VideoSDK Dashboard](https://app.videosdk.live/meetings/sessions). Select the specific session, and from the list of participants, choose the participant you wish to remove. Utilize the provided options to remove the selected participant from the session.

import ReactPlayer from 'react-player'

<div style={{textAlign: 'center'}}>

<ReactPlayer autoplay muted loop playing url='/video/kickout-user.mp4' width={"100%"}/>

</div>

## 3. Using Rest API

- You can also remove a particular participant from the live stream [using the REST API](/api-reference/realtime-communication/remove-participant).
- To employ this method, you need the `sessionId` of the live stream and the `participantId` of the individual you intend to remove.

## API Reference

The API references for all the methods and events utilized in this guide are provided below.

- [remove()](/android/api/sdk-reference/participant-class/methods#remove)
- [onMeetingLeft()](/android/api/sdk-reference/meeting-class/meeting-event-listener-class#onmeetingleft)
- [onParticipantLeft()](/android/api/sdk-reference/meeting-class/meeting-event-listener-class#onparticipantleft)


---

---
title: Audience Polls during Live Stream - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: PubSub features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Audience Polls
pagination_label: Audience Polls
keywords:
  - Polls during Live Stream
  - Livestream audience polls
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 2
slug: audience-polls-during-livestream
---

# Audience Polls during Live Stream - Android

Interactive polls are a great way to increase engagement during livestreams. Using VideoSDK’s PubSub mechanism, you can easily implement real-time audience polling, where viewers can vote and see live results instantly.

This guide walks you through how to create, send, and visualize poll results during a livestream.

### Step 1: Creating and Publishing a Poll

To initiate a poll, use the `PubSub` class with a `POLL` topic. The poll structure should include a question and multiple options. This message will be published to all participants.

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
class CreatePollDialog() {
    
    companion object {
        const val POLL_TOPIC = "POLL"
    }
    
    fun show() {
        // ... UI setup code ...
        
        dialog.getButton(AlertDialog.BUTTON_POSITIVE).setOnClickListener {
            // Validate inputs
            
            // Create poll object
            val options = mutableListOf(option1, option2)
            if (option3.isNotEmpty()) options.add(option3)
            if (option4.isNotEmpty()) options.add(option4)
            
            val poll = SimplePoll(question, options)
            
            // Publish poll to all participants
            val pubSubPublishOptions = PubSubPublishOptions()
            pubSubPublishOptions.isPersist = true
            liveStream.pubSub.publish(POLL_TOPIC, poll.toJsonString(), pubSubPublishOptions)
            
            // Show results dialog to host
            PollResultsDialog(context, liveStream).show(poll)
            
            dialog.dismiss()
        }
    }
}
```

</TabItem>

<TabItem value="Java">

```java
public class CreatePollDialog {
public static final String POLL_TOPIC = "POLL";

public CreatePollDialog() {
    // default constructor
}

public void show() {
    // ... UI setup code ...

    dialog.getButton(AlertDialog.BUTTON_POSITIVE).setOnClickListener(v -> {
        // Validate inputs

        // Create poll object
        List<String> options = new ArrayList<>();
        options.add(option1);
        options.add(option2);
        if (!option3.isEmpty()) options.add(option3);
        if (!option4.isEmpty()) options.add(option4);

        SimplePoll poll = new SimplePoll(question, options);

        // Publish poll to all participants
        PubSubPublishOptions pubSubPublishOptions = new PubSubPublishOptions();
        pubSubPublishOptions.setPersist(true);
        liveStream.pubSub.publish(POLL_TOPIC, poll.toJsonString(), pubSubPublishOptions);

        // Show results dialog to host
        new PollResultsDialog(context, liveStream).show(poll);

        dialog.dismiss();
    });
  }
}

```

</TabItem>

</Tabs>


### Step 2: Subscribing to Polls and Displaying Options
Participants can listen to the POLL topic and render voting options dynamically based on the incoming data.


<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
class PollVotingDialog() {
    
    companion object {
        const val POLL_RESPONSE_TOPIC = "POLL_RESPONSE"
    }
    
    fun show(poll: SimplePoll) {
        // ... UI setup code ...
        
        // Create option buttons dynamically
        poll.options.forEach { option ->
            val button = Button(context)
            button.text = option
            button.setOnClickListener {
                // Submit vote
                val response = SimplePollResponse(
                    pollId = poll.id,
                    option = option,
                    participantId = liveStream.localParticipant.id,
                    participantName = liveStream.localParticipant.displayName
                )
                
                liveStream.pubSub.publish(POLL_RESPONSE_TOPIC, response.toJsonString())
                
                // Disable all buttons after voting
                for (i in 0 until optionsContainer.childCount) {
                    optionsContainer.getChildAt(i).isEnabled = false
                }
            }
            
            optionsContainer.addView(button)
        }
    }
}
```

</TabItem>

<TabItem value="Java">

```java
public class PollVotingDialog {

    public static final String POLL_RESPONSE_TOPIC = "POLL_RESPONSE";

    public void show(SimplePoll poll) {
        // ... UI setup code ...

        // Create option buttons dynamically
        for (String option : poll.getOptions()) {
            Button button = new Button(context);
            button.setText(option);
            button.setOnClickListener(v -> {
                // Submit vote
                SimplePollResponse response = new SimplePollResponse(
                        poll.getId(),
                        option,
                        liveStream.getLocalParticipant().getId(),
                        liveStream.getLocalParticipant().getDisplayName()
                );

                liveStream.pubSub.publish(POLL_RESPONSE_TOPIC, response.toJsonString());

                // Disable all buttons after voting
                for (int i = 0; i < optionsContainer.getChildCount(); i++) {
                    optionsContainer.getChildAt(i).setEnabled(false);
                }
            });

            optionsContainer.addView(button);
        }
    }
}
```

</TabItem>

</Tabs>


### Step 3: Aggregating and Displaying Poll Results
The host can subscribe to the POLL_RESPONSE topic to collect responses and render the result in real-time.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
class PollResultsDialog() {
    
    private val pollResults = ConcurrentHashMap<String, Int>()
    private var totalVotes = 0
    
    companion object {
        const val POLL_RESPONSE_TOPIC = "POLL_RESPONSE"
    }
    
    fun show(poll: SimplePoll) {
        // ... UI setup code ...
        
        // Initialize results map with 0 votes for each option
        poll.options.forEach { option ->
            pollResults[option] = 0
        }
        
        // Create initial result bars
        updateResultBars()
        
        // Listen for poll responses
        responsesListener = PubSubMessageListener { pubSubMessage ->
            try {
                val response = SimplePollResponse.fromJsonString(pubSubMessage.message)
                val option = response.option
                
                // Update vote count
                pollResults[option] = (pollResults[option] ?: 0) + 1
                totalVotes++
                
                // Update UI on main thread
                (context as? android.app.Activity)?.runOnUiThread {
                    updateResultBars()
                }
            } catch (e: Exception) {
                e.printStackTrace()
            }
        }
        
        // Subscribe to poll responses
        liveStream.pubSub.subscribe(POLL_RESPONSE_TOPIC, responsesListener)
    }
    
    private fun updateResultBars() {
        // Clear previous results
        optionsContainer?.removeAllViews()
        
        // Create result bars for each option
        pollResults.forEach { (option, votes) ->
            val percentage = if (totalVotes > 0) (votes * 100) / totalVotes else 0
            
            // Create progress bar UI showing percentage
            // ... UI code to display results ...
        }
    }
}
```

</TabItem>

<TabItem value="Java">

```java
import java.util.concurrent.ConcurrentHashMap;
import java.util.Map;

public class PollResultsDialog {

    private ConcurrentHashMap<String, Integer> pollResults = new ConcurrentHashMap<>();
    private int totalVotes = 0;

    public static final String POLL_RESPONSE_TOPIC = "POLL_RESPONSE";

    public void show(SimplePoll poll) {
        // ... UI setup code ...

        // Initialize results map with 0 votes for each option
        for (String option : poll.options) {
            pollResults.put(option, 0);
        }

        // Create initial result bars
        updateResultBars();

        // Listen for poll responses
        responsesListener = new PubSubMessageListener() {
            @Override
            public void onMessage(PubSubMessage pubSubMessage) {
                try {
                    SimplePollResponse response = SimplePollResponse.fromJsonString(pubSubMessage.message);
                    String option = response.option;

                    // Update vote count
                    pollResults.put(option, pollResults.getOrDefault(option, 0) + 1);
                    totalVotes++;

                    // Update UI on main thread
                    if (context instanceof android.app.Activity) {
                        ((android.app.Activity) context).runOnUiThread(new Runnable() {
                            @Override
                            public void run() {
                                updateResultBars();
                            }
                        });
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        };

        // Subscribe to poll responses
        liveStream.pubSub.subscribe(POLL_RESPONSE_TOPIC, responsesListener);
    }

    private void updateResultBars() {
        // Clear previous results
        if (optionsContainer != null) {
            optionsContainer.removeAllViews();
        }

        // Create result bars for each option
        for (Map.Entry<String, Integer> entry : pollResults.entrySet()) {
            String option = entry.getKey();
            int votes = entry.getValue();

            int percentage = (totalVotes > 0) ? (votes * 100) / totalVotes : 0;

            // Create progress bar UI showing percentage
            // ... UI code to display results ...
        }
    }
}
```

</TabItem>

</Tabs>


### API Reference

The API references for all the methods and events utilized in this guide are provided below.

- [pubSub()](/android/api/sdk-reference/pubsub-class/introduction)


---

---
title: Chat during Live Stream - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: PubSub features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Chat during Live Stream
pagination_label: Chat during Live Stream
keywords:
  - Chat during Live Stream
  - Livestream 
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: chat-during-livestream
---

# Chat during Live Stream - Android

Enhance your live stream experience by enabling real-time audience chat using VideoSDK's PubSub class. Whether you’re streaming a webinar, online event, or an interactive session, integrating a chat system lets your viewers engage, ask questions, and react instantly. This guide shows how to build a group or private chat interface for a live stream using the Publish-Subscribe (PubSub) mechanism.

This guide focuses on using PubSub to implement Chat functionality. If you are not familiar with the PubSub mechanism and `PubSub` class , you can [follow this guide](/android/guide/video-and-audio-calling-api-sdk/collaboration-in-meeting/pubsub).

## Implementing Chat

### `Group Chat`

1. First step in creating a group chat is choosing the topic which all the participants will publish and subscribe to send and receive the messages. We will be using `CHAT` as the topic for this one.
2. On the send button, publish the message that the sender typed in the `EditText` field.

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle
import android.view.View
import android.widget.EditText
import android.widget.Toast
import androidx.appcompat.widget.Toolbar
import live.videosdk.rtc.android.Meeting
import live.videosdk.rtc.android.listeners.PubSubMessageListener
import live.videosdk.rtc.android.model.PubSubPublishOptions

class ChatActivity : AppCompatActivity() {
  // Meeting
  var meeting: liveStream? = null

  override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    setContentView(R.layout.activity_chat)

    /**
     * Here, we have created 'MainApplication' class, which extends android.app.Application class.
     * It has Meeting property and getter and setter methods of Meeting property.
     * In your android manifest, you must declare the class implementing android.app.Application
     * (add the android:name=".MainApplication" attribute to the existing application tag):
     * In MainActivity.kt, we have set Meeting property.
     *
     * For Example: (MainActivity.kt)
     * var meeting = VideoSDK.initMeeting(context, meetingId, ParticipantName, micEnabled, webcamEnabled, paricipantId, mode, multiStream, customTrack, metaData, signalingBaseUrl)
     * (this.application as MainApplication).meeting = meeting
    */

    // Get Meeting
    liveStream = (this.application as MainApplication).meeting

    findViewById(R.id.btnSend).setOnClickListener(view -> sendMessage());
  }

  private fun sendMessage() {
    // get message from EditText
    val message: String = etmessage.getText().toString()
    if (!TextUtils.isEmpty(message)) {
        val publishOptions = PubSubPublishOptions()
        publishOptions.setPersist(true)

        // Sending the Message using the publish method
        //highlight-next-line
        liveStream!!.pubSub.publish("CHAT", message, publishOptions)

        // Clearing the message input
        etmessage.setText("")
    } else {
        Toast.makeText(
            this@ChatActivity, "Please Enter Message",
            Toast.LENGTH_SHORT
        ).show()
    }
  }
}
```

</TabItem>

<TabItem value="Java">

```js
import androidx.appcompat.app.AppCompatActivity;
import android.os.Bundle;
import java.util.List;
import live.videosdk.rtc.android.Meeting;
import live.videosdk.rtc.android.lib.PubSubMessage;
import live.videosdk.rtc.android.listeners.PubSubMessageListener;
import live.videosdk.rtc.android.model.PubSubPublishOptions;

public class ChatActivity extends AppCompatActivity {
  // Meeting
  Meeting liveStream;

  @Override
  protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_chat);

    /**
     * Here, we have created 'MainApplication' class, which extends android.app.Application class.
     * It has Meeting property and getter and setter methods of Meeting property.
     * In your android manifest, you must declare the class implementing android.app.Application
     * (add the android:name=".MainApplication" attribute to the existing application tag):
     * In MainActivity.java, we have set Meeting property.
     *
     * For Example: (MainActivity.java)
     * Meeting meeting = VideoSDK.initMeeting(context, meetingId, ParticipantName, micEnabled, webcamEnabled, participantId, mode, mutliStream, customTrack,metaData, signalingBaseUrl, preferredProtocol);
     * ((MainApplication) this.getApplication()).setMeeting(meeting);
    */

    // Get Meeting
    liveStream = ((MainApplication) this.getApplication()).getMeeting();

    findViewById(R.id.btnSend).setOnClickListener(view -> sendMessage());
  }

  private void sendMessage()
  {
    // get message from EditText
    String message = etmessage.getText().toString();
    if (!message.equals("")) {
        PubSubPublishOptions publishOptions = new PubSubPublishOptions();
        publishOptions.setPersist(true);

        // Sending the Message using the publish method
        //highlight-next-line
        liveStream.pubSub.publish("CHAT", message, publishOptions);

        // Clearing the message input
        etmessage.setText("");
    } else {
        Toast.makeText(ChatActivity.this, "Please Enter Message",
                Toast.LENGTH_SHORT).show();
    }
  }
}
```

</TabItem>

</Tabs>

3. Next step would be to display the messages others send. For this we have to `subscribe` to that topic i.e `CHAT` and display all the messages.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
class ChatActivity : AppCompatActivity() {

  // PubSubMessageListener
  //highlight-start
  var pubSubMessageListener =
    PubSubMessageListener { message ->
      // New message
      Toast.makeText(
            this@ChatActivity, message.senderName + " says : " + message.message,
            Toast.LENGTH_SHORT
        ).show()
  }
  //highlight-end

  override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    setContentView(R.layout.activity_chat)

    //...

    // Subscribe for 'CHAT' topic
    //highlight-next-line
    val pubSubMessageList = liveStream!!.pubSub.subscribe("CHAT", pubSubMessageListener)

    for (message in pubSubMessageList) {
      // Persisted messages
      Toast.makeText(
            this@ChatActivity, message.senderName + " says : " + message.message,
            Toast.LENGTH_SHORT
        ).show()
    }
  }
}
```

</TabItem>

<TabItem value="Java">

```js
public class ChatActivity extends AppCompatActivity {

  // PubSubMessageListener
  //highlight-start
  private PubSubMessageListener pubSubMessageListener = new PubSubMessageListener() {
    @Override
    public void onMessageReceived(PubSubMessage message) {
        // New message
        Toast.makeText(
          ChatActivity.this, message.senderName + " says : "+ message.getMessag(),
          Toast.LENGTH_SHORT
        ).show();
    }
  };
  //highlight-end

  @Override
  protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_chat);

    //..

    // Subscribe for 'CHAT' topic
    //highlight-next-line
    List<PubSubMessage> pubSubMessageList = liveStream.pubSub.subscribe("CHAT", pubSubMessageListener);

    for(PubSubMessage message : pubSubMessageList){
        // Persisted messages
        Toast.makeText(
          ChatActivity.this, message.senderName + " says : "+ message.getMessag(),
          Toast.LENGTH_SHORT
        ).show();
    }
  }
}
```

</TabItem>

</Tabs>

4. Final step in the group chat would be `unsubscribe` to that topic, which you had previously subscribed but no longer needed. Here we are `unsubscribe` to `CHAT` topic on activity destroy.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
class ChatActivity : AppCompatActivity() {
  override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    setContentView(R.layout.activity_chat)

    //...
  }

  override fun onDestroy() {
    // Unsubscribe for 'CHAT' topic
    //highlight-next-line
    liveStream!!.pubSub.unsubscribe("CHAT", pubSubMessageListener)
    super.onDestroy()
  }
}
```

</TabItem>

<TabItem value="Java">

```js
public class ChatActivity extends AppCompatActivity {
  @Override
  protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_chat);

    //..
  }

  @Override
  protected void onDestroy() {
    // Unsubscribe for 'CHAT' topic
    //highlight-next-line
    liveStream.pubSub.unsubscribe("CHAT", pubSubMessageListener);
    super.onDestroy();
  }
}
```

</TabItem>

</Tabs>


### `Private Chat` (1:1 between Host and Viewer)

Private messaging is ideal when a host or moderator needs to directly respond to a viewer’s question. This can be achieved using the `sendOnly` property.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
class ChatActivity : AppCompatActivity() {

  //..
  
  private fun sendMessage() {
    // get message from EditText
    val message: String = etmessage.getText().toString()
    if (!TextUtils.isEmpty(message)) {
        val publishOptions = PubSubPublishOptions()
        publishOptions.setPersist(true)
        //highlight-start
        // Pass the participantId of the participant to whom you want to send the message.
        var sendOnly: Array<String> = arrayOf("xyz")
        publishOptions.setSendOnly(sendOnly);
        //highlight-end

        // Sending the Message using the publish method
        //highlight-next-line
        liveStream!!.pubSub.publish("CHAT", message, publishOptions)

        // Clearing the message input
        etmessage.setText("")
    } else {
        Toast.makeText(
            this@ChatActivity, "Please Enter Message",
            Toast.LENGTH_SHORT
        ).show()
    }
  }
}
```

</TabItem>

<TabItem value="Java">

```js
public class ChatActivity extends AppCompatActivity {
 
  //...

  private void sendMessage()
  {
    // get message from EditText
    String message = etmessage.getText().toString();
    if (!message.equals("")) {
        PubSubPublishOptions publishOptions = new PubSubPublishOptions();
        publishOptions.setPersist(true);
        //highlight-start
        // Pass the participantId of the participant to whom you want to send the message.
        String[] sendOnly = {
          "xyz" 
        };
        publishOptions.setSendOnly(sendOnly);
        //highlight-end

        // Sending the Message using the publish method
        //highlight-next-line
        liveStream.pubSub.publish("CHAT", message, publishOptions);

        // Clearing the message input
        etmessage.setText("");
    } else {
        Toast.makeText(ChatActivity.this, "Please Enter Message",
                Toast.LENGTH_SHORT).show();
    }
  }
}
```

</TabItem>

</Tabs>

### Downloading Chat Messages

All the messages from the PubSub which where published with `persist : true` and can be downloaded as an `.csv` file. This file will be available in the VideoSDK dashboard as well as throught the [Sessions API](/api-reference/realtime-communication/fetch-session-using-sessionid).

### API Reference

The API references for all the methods and events utilised in this guide are provided below.

- [pubSub()](/android/api/sdk-reference/pubsub-class/introduction)


---

---
title: Cloud Proxy | Secure and Manage Streaming Traffic | Video SDK
hide_title: true
hide_table_of_contents: false
description: Leverage Video SDK's Cloud Proxy to securely manage and optimize your video streaming traffic. Ideal for enhancing performance and securing data.
sidebar_label: Cloud Proxy
pagination_label: Cloud Proxy
keywords:
  - cloud proxy
  - secure streaming
  - video SDK security
  - traffic management
image: img/videosdklive-thumbnail.jpg
sidebar_position: 2
slug: cloud-proxy
---

# Cloud Proxy - Android

import CloudProxy from '../../../../mdx/\_cloud-proxy.mdx';

<CloudProxy/>

## Implementation

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
val liveStream: Meeting = VideoSDK.initMeeting(
      this@MainActivity, "meetingId", "John Due", true,
      true, null, null, false, null, null,"proxy.yourwebsite.com", VideoSDK.PreferredProtocol.UDP_ONLY
);
```

</TabItem>

<TabItem value="Java">

```java
Meeting liveStream = VideoSDK.initMeeting(
      MainActivity.this, "meetingId", "John Due",true,
      true, null, null, false, null,null,"proxy.yourwebsite.com", VideoSDK.PreferredProtocol.UDP_ONLY
);
```

</TabItem>

</Tabs>
### Parameters
- preferredProtocol:
    - UDP_OVER_TCP (default): Initially the server attempts to establish a connection using UDP, if that fails it automatically switches to TCP protocol.
    - UDP_ONLY: Force UDP protocol
    - TCP_ONLY: Force TCP protocol
- signalingBaseUrl: Proxy URL to origin signaling and media.

## API Reference

The API references for all the methods and events utilized in this guide are provided below.

- [initMeeting()](/android/api/sdk-reference/initMeeting)


---

---
title: Custom Audio Sources - React JS SDK
hide_title: false
hide_table_of_contents: false
description: Custom Audio Sources
sidebar_label: Custom Audio Sources
pagination_label: Custom Audio Sources
keywords:
  - custom audio sources
  - react js
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: custom-audio-sources
---

# Custom Audio Sources - Android

For a high-quality streaming experience, fine-tuning audio tracks becomes essential—especially when delivering content to a broader live audience.

To enhance your live audio pipeline, we've introduced the capability to provide a custom audio track for a hosts's stream both before and during a live session.


## Custom Audio Track

This feature allows you to integrate advanced audio layers like background noise suppression, echo cancellation, and more—so your stream sounds polished and professional to every viewer.

### `How to Create Custom Audio Track ?`

- You can create a Audio Track using `createAudioTrack()` method of `VideoSDK`.

- This method can be used to create audio track using different encoding parameters.

#### Example

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
val audioCustomTrack: CustomStreamTrack = VideoSDK.createAudioTrack("speech_standard",this)
// `high_quality` | `music_standard`,  Default : `speech_standard`
```

</TabItem>

<TabItem value="Java">

```js
CustomStreamTrack audioCustomTrack=VideoSDK.createAudioTrack("speech_standard", this);
// `high_quality` | `music_standard`,  Default : `speech_standard`
```

</TabItem>

</Tabs>

- `speech_standard` : This config is optimised for normal voice communication.

- `high_quality` : This config is used for getting RAW audio, where you can apply your `noiseConfig`.

- `music_standard` : This config is optimised for communication, where sharing of musical notes such as songs or instrumental sounds, is important.

### `How to Setup Custom Audio Track ?`

The custom track can be set up both before and after the initialization of the meeting.

1. [Setting up a Custom Track during the initialization of a meeting](/android/guide/video-and-audio-calling-api-sdk/render-media/optimize-audio-track#1-setting-up-a-custom-track-during-the-initialization-of-a-meeting)
2. [Setting up a Custom Track with methods](/android/guide/video-and-audio-calling-api-sdk/render-media/optimize-audio-track#2-setting-up-a-custom-track-with-methods)

##### 1. Setup during live stream initialization

If you're starting the stream with the mic enabled `(micEnabled: true)` and wish to use a custom track from the beginning, pass it through the config of MeetingProvider.

:::caution
Custom Track will not apply on `micEnabled: false` configuration.
:::

##### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
override fun onCreate(savedInstanceState: Bundle?) {
  //..

  val customTracks: MutableMap<String, CustomStreamTrack> = HashMap()

  //highlight-start
  val audioCustomTrack: CustomStreamTrack = VideoSDK.createAudioTrack("high_quality", this)
  customTracks["mic"] = audioCustomTrack  //Key must be "mic"
  //highlight-end

  // create a new meeting instance
  val liveStream = VideoSDK.initMeeting(
    this@MainActivity,meetingId,participantName,
    //MicEnabled , If true, it will use the passed custom track to turn mic on
    true,
    //WebcamEnabled
    true,
    //ParticipantId
    null,
    //Mode
    null,
    //MultiStream
    false,
    //Pass the custom tracks here
    //highlight-next-line
    customTracks,
    //MetaData
    null
  )
}
```

</TabItem>

<TabItem value="Java">

```js
@Override
protected void onCreate(Bundle savedInstanceState) {
  //..

  Map<String, CustomStreamTrack> customTracks = new HashMap<>();

  //highlight-start
  CustomStreamTrack audioCustomTrack = VideoSDK.createAudioTrack("high_quality", this);
  customTracks.put("mic", audioCustomTrack);  //Key must be "mic"
  //highlight-end

  // create a new meeting instance
  Meeting liveStream = VideoSDK.initMeeting(
      MainActivity.this, meetingId, participantName,
      //MicEnabled , If true, it will use the passed custom track to turn mic on
      true,
      //WebcamEnabled
      true,
      //ParticipantId
      null,
      //Mode
      null,
      //MultiStream
      false,
      //Pass the custom tracks here
      //highlight-next-line
      customTracks,
      //MetaData
      null
  );
}
```

</TabItem>

</Tabs>

#### 2. Setup dynamically using methods

During the live stream, you can update the audio source by passing the `CustomStreamTrack` in the `unmuteMic()` method of `Meeting`.

You can also pass custom track in `changeMic()` method of `Meeting`.

:::tip
Make sure to call the `muteMic()` method before you create a new track as it may lead to unexpected behavior.
:::

##### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
try {
  val audioCustomTrack: CustomStreamTrack = VideoSDK.createAudioTrack("high_quality", this)
  liveStream!!.unmuteMic(audioCustomTrack)

  //or
  liveStream!!.changeMic(AppRTCAudioManager.AudioDevice.BLUETOOTH, audioCustomTrack)
} catch (e: JSONException) {
  e.printStackTrace()
}
```

</TabItem>

<TabItem value="Java">

```js
try {
  CustomStreamTrack audioCustomTrack = VideoSDK.createAudioTrack("high_quality", this);
  liveStream.unmuteMic(audioCustomTrack);

  //or
  liveStream.changeMic(AppRTCAudioManager.AudioDevice.BLUETOOTH,audioCustomTrack);
}catch (JSONException e) {
  e.printStackTrace();
}
```

</TabItem>

</Tabs>

## API Reference

The API references for all the methods and events utilised in this guide are provided below.

- [Custom Audio Track](/android/api/sdk-reference/custom-tracks#custom-audio-track---android)


---

---
title: Custom ScreenShare Sources - React JS SDK
hide_title: false
hide_table_of_contents: false
description: Custom ScreenShare Sources
sidebar_label: Custom ScreenShare Sources
pagination_label: Custom ScreenShare Sources
keywords:
  - custom screenshare sources
  - react js
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: custom-screenshare-sources
---

# Custom ScreenShare Sources - Android

To deliver high-quality livestreams, it's essential to fine-tune screen share tracks being broadcasted. Whether you’re hosting a webinar, or going live with a presentation, using custom media tracks gives you better control over stream quality and performance.

## Custom Screen Share Track

This feature enables the customization of screenshare streams with enhanced optimization modes and predefined encoder configuration (resolution + FPS) for specific use cases, which can then be sent to other hosts and audience members.

### `How to Create Custom Screen Share Track ?`

- You can create a Screen Share track using `createScreenShareVideoTrack()` method of `VideoSDK`.
- This method can be used to create video track using different encoding parameters and optimization mode.

#### Example

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
// data is received from onActivityResult method.
VideoSDK.createScreenShareVideoTrack(

  //highlight-next-line
  // This will accept the  height & FPS of video you want to capture.
  "h720p_15fps", //  `h360p_30fps` | `h1080p_30fps` // Default : `h720p_15fps`

  //highlight-next-line
  // It is Intent received from onActivityResult when user provide permission for ScreenShare.
  data,

  //highlight-next-line
  // Pass Conext
  this)

  //highlight-next-line
  //Callback to this listener will be made when track is ready with CustomTrack as parameter
  {
    track ->
    meeting!!.enableScreenShare(track)
  }
```

</TabItem>

<TabItem value="Java">

```javascript
// data is received from onActivityResult method.
VideoSDK.createScreenShareVideoTrack(
  //highlight-next-line
  // This will accept the  height & FPS of video you want to capture.
  "h720p_15fps", //  `h360p_30fps` | `h1080p_30fps` // Default : `h720p_15fps`

  /highlight-next-line
  // It is Intent received from onActivityResult when user provide permission for ScreenShare
  data,

  //highlight-next-line
  // Pass Conext
  this,

  //highlight-next-line
  //Callback to this listener will be made when track is ready with CustomTrack as parameter
  (track)->{meeting.enableScreenShare(track);}
);
```

</TabItem>

</Tabs>

### `How to Setup Custom Screen Share Track ?`

In order to switch tracks during the meeting, you have to pass the `CustomStreamTrack` in the `enableScreenShare()` method of `Meeting`.

:::note

Make sure to call `disableScreenShare()` before you create a new track as it may lead to unexpected behavior.

:::

##### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
@TargetApi(21)
private fun askPermissionForScreenShare() {
  val mediaProjectionManager = application.getSystemService<Any>(
      Context.MEDIA_PROJECTION_SERVICE
  ) as MediaProjectionManager
  startActivityForResult(
      mediaProjectionManager.createScreenCaptureIntent(), CAPTURE_PERMISSION_REQUEST_CODE
  )
}

@RequiresApi(api = Build.VERSION_CODES.LOLLIPOP)
override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) {
  super.onActivityResult(requestCode, resultCode, data)
  if (requestCode != CAPTURE_PERMISSION_REQUEST_CODE) return
  if (resultCode == RESULT_OK) {
    //highlight-start
    VideoSDK.createScreenShareVideoTrack("h720p_15fps", data, this) { track ->
        liveStream!!.enableScreenShare(track)
    }
    //highlight-end
  }
}

```

</TabItem>

<TabItem value="Java">

```javascript
@TargetApi(21)
private void askPermissionForScreenShare() {
  MediaProjectionManager mediaProjectionManager =
      (MediaProjectionManager) getApplication().getSystemService(
          Context.MEDIA_PROJECTION_SERVICE);
  startActivityForResult(
      mediaProjectionManager.createScreenCaptureIntent(), CAPTURE_PERMISSION_REQUEST_CODE);
}

@RequiresApi(api = Build.VERSION_CODES.LOLLIPOP)
@Override
public void onActivityResult(int requestCode, int resultCode, Intent data) {
  super.onActivityResult(requestCode, resultCode, data);
  if (requestCode != CAPTURE_PERMISSION_REQUEST_CODE)
      return;
  if (resultCode == Activity.RESULT_OK) {
    //highlight-start
    VideoSDK.createScreenShareVideoTrack("h720p_15fps", data, this, (track)->{
        liveStream.enableScreenShare(track);
    });
    //highlight-end
  }
}

```

</TabItem>

</Tabs>

## API Reference

The API references for all the methods and events utilised in this guide are provided below.

- [Custom Video Track](/react/api/sdk-reference/custom-tracks#custom-video-track---react)
- [Custom Screen Share Track](/react/api/sdk-reference/custom-tracks#custom-screen-share-track---react)


---

---
title: Custom Video Sources - React JS SDK
hide_title: false
hide_table_of_contents: false
description: Custom Video Sources
sidebar_label: Custom Video Sources
pagination_label: Custom Video Sources
keywords:
  - custom video sources
  - react js
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: custom-video-sources
---

# Custom Video Sources - Android

To deliver high-quality livestreams, it's essential to fine-tune the video tracks being broadcasted. Whether you’re hosting a webinar, or streaming an event, using custom video tracks gives you better control over stream quality and performance.

## Custom Video Track

This feature can be used to add custom video encoder configurations, optimization mode (whether you want to focus on motion, text or detail of the video) and background removal & video filter from external SDK(e.g., Banuba)and send it to other participants.

### `How to Create a Custom Video Track ?`

- You can create a Video Track using `createCameraVideoTrack()` method of `VideoSDK`.
- This method can be used to create video track using different encoding parameters, camera facing mode, and optimization mode and return `CustomStreamTrack`.

#### Example

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
val videoCustomTrack: CustomStreamTrack = VideoSDK.createCameraVideoTrack(

  // highlight-next-line
  // This will accept the resolution (height x width) of video you want to capture.
  "h720p_w960p", // "h720p_w960p" | "h720p_w1280p" ... // Default : "h480p_w720p"

  // highlight-next-line
  // It will specify whether to use front or back camera for the video track.
  "front", "back",  Default : "front"

  // highlight-next-line
  // We will discuss this parameter in next step.
  CustomStreamTrack.VideoMode.MOTION, // CustomStreamTrack.VideoMode.TEXT, CustomStreamTrack.VideoMode.DETAIL ,  Default : CustomStreamTrack.VideoMode.MOTION

  // highlight-next-line
  // multiStream - we will discuss this parameter in next step.
  false, // true

  // highlight-next-line
  // Pass Context
  this,

  // highlight-next-line
  // This is Optional parameter. We will discuss this parameter in next step.
  observer)
```

</TabItem>

<TabItem value="Java">

```javascript
CustomStreamTrack customStreamTrack = VideoSDK.createCameraVideoTrack(

  // highlight-next-line
  // This will accept the resolution (height x width) of video you want to capture.
  "h480p_w640p", // "h720p_w960p" | "h720p_w1280p" ... // Default : "h480p_w640p"

  // highlight-next-line
  // It will specify whether to use front or back camera for the video track.
  "front", // "back,  Default : "front""

  // highlight-next-line
  // We will discuss this parameter in next step.
  CustomStreamTrack.VideoMode.MOTION, // CustomStreamTrack.VideoMode.TEXT, CustomStreamTrack.VideoMode.DETAIL ,  Default : CustomStreamTrack.VideoMode.MOTION

  // highlight-next-line
  // multiStream - we will discuss this parameter in next step.
  false, // true

  // highlight-next-line
  // Pass Context
  this

  // highlight-next-line
  // This is Optional parameter. We will discuss this parameter in next step.
  observer);
```

</TabItem>

</Tabs>

:::caution
The behavior of custom track configurations is influenced by the capabilities of the device. For example, if you set the encoder configuration to 1080p but the webcam only supports 720p, the encoder configuration will automatically adjust to the highest resolution that the device can handle, which in this case is 720p.
:::

##### What is `optimizationMode`?

- This parameter specifies the optimization mode for the video track being generated.
- `motion` : This type of track focuses more on motion video such as webcam video, movies or video games.
  - It will degrade `resolution` in order to maintain `frame rate`.
- `text` : This type of track focuses on significant sharp edges and areas of consistent color that can change frequently such as presentations or web pages with text content.
  - It will degrade `frame rate` in order to maintain `resolution`.
- `detail` : This type of track focuses more on the details of the video such as, presentations, painting or line art.
  - It will degrade `frame rate` in order to maintain `resolution`.

##### What is `multiStream`?

- By enabling multiStream, your livestream will broadcast multiple resolutions (e.g., 720p, 480p, 360p), allowing viewers to receive the best stream quality based on their network.
The **`multiStream : true`** configuration indicates that VideoSDK, by default, sends multiple resolution video streams to the server. For example, if a user's device capability is 720p, VideoSDK sends streams in 720p, 640p, and 480p resolution. This enables VideoSDK to deliver the appropriate stream to each participant based on their network bandwidth.


<center>

![Multi Stream False](/img/multistream_true.png)

</center>

Setting **`multiStream : false`** restricts VideoSDK to send only one stream, helping to maintain quality by focusing on a single resolution.

<center>

![Multi Stream False](/img/multistream_false.png)

</center>

:::danger
The `setQuality` parameter will not have any effect if multiStream is set to `false`.
:::

### `How to Setup a Custom Video Track ?`

You can plug in your custom video track either before going live or dynamically while the session is ongoing.

1. [Setup during live stream initialization](/react/guide/video-and-audio-calling-api-sdk/render-media/optimize-video-track#1-setup-during-live-stream-initialization)
2. [Setup dynamically using methods](/react/guide/video-and-audio-calling-api-sdk/render-media/optimize-video-track#2-setup-dynamically-using-methods)

##### 1. Setting up a Custom Track during the initialization of a liveStream

If you're starting the stream with the webcam enabled `(webcamEnabled: true)` and wish to use a custom track from the beginning, pass it through the config of initMeeting as shown below.

:::caution
Custom Track will not apply on the `webcamEnabled: false` configuration.
:::

##### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
override fun onCreate(savedInstanceState: Bundle?) {
  //..

  //highlight-start
  val customTracks: MutableMap<String, CustomStreamTrack> = HashMap()
  val videoCustomTrack: CustomStreamTrack =
  VideoSDK.createCameraVideoTrack("h720p_w960p", "front", CustomStreamTrack.VideoMode.MOTION, false, this)
  customTracks["video"] = videoCustomTrack  //Key must be "video"
  //highlight-end

  // create a new meeting instance
  val liveStream = VideoSDK.initMeeting(
    this@MainActivity, meetingId, participantName,
    //MicEnabled
    true,
    //WebcamEnabled , If true, it will use the passed custom track to turn webcam on
    true,
    // ParticipantId
    null,
    // Mode
    null,
    // MultiStream
    false,
    //Pass the custom tracks here
    //highlight-next-line
    customTracks,
    //MetaData
    null
  )
}
```

</TabItem>

<TabItem value="Java">

```js
@Override
protected void onCreate(Bundle savedInstanceState) {
  //..

  //highlight-start
  Map<String, CustomStreamTrack> customTracks = new HashMap<>();
  CustomStreamTrack videoCustomTrack = VideoSDK.createCameraVideoTrack("h720p_w960p", "front", CustomStreamTrack.VideoMode.MOTION, false, this);
  customTracks.put("video", videoCustomTrack);  //Key must be "video"
  //highlight-end

  // create a new meeting instance
  Meeting liveStream = VideoSDK.initMeeting(
    MainActivity.this, meetingId, participantName,
    //MicEnabled
    true,
    //WebcamEnabled , If true, it will use the passed custom track to turn webcam on
    true,
    // ParticipantId
    null,
    // Mode
    null,
    // MultiStream
    false,
    //Pass the custom tracks here
    //highlight-next-line
    customTracks,
    //MetaData
    null
    );
}
```

</TabItem>

</Tabs>

#### 2. Setting up a Custom Track with methods

In order to switch tracks during the meeting, you have to pass the `CustomStreamTrack` in the `enableWebcam()` method of `Meeting`.

:::tip
Make sure to call `disableWebcam()` before you create a new track as it may lead to unexpected behavior.
:::

##### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
val customStreamTrack: CustomStreamTrack = VideoSDK.createCameraVideoTrack("h720p_w960p", "back", CustomStreamTrack.VideoMode.MOTION, false, this)
liveStream!!.enableWebcam(customStreamTrack)
```

</TabItem>

<TabItem value="Java">

```javascript
CustomStreamTrack customStreamTrack=VideoSDK.createCameraVideoTrack("h720p_w960p", "back", CustomStreamTrack.VideoMode.MOTION, false, this);
liveStream.enableWebcam(customStreamTrack);
```

</TabItem>

</Tabs>

### `Which Configuration is suitable for Device ?`

In this section, we will understand participant size wise `encoder(Resolution)` and `multiStream` configuration.

<center>
<img src='https://cdn.videosdk.live/website-resources/docs-resources/mobile_device_config.png' />
</center>

## API Reference

The API references for all the methods and events utilised in this guide are provided below.

- [Custom Video Track](/react/api/sdk-reference/custom-tracks#custom-video-track---react)


---

---
title: Customized Live Stream
sidebar_position: 1
sidebar_label: Customized Live Stream
hide_table_of_contents: false
---

# Customized Live Stream - Android

VideoSDK is a platform that offers a range of video streaming tools and solutions for content creators, publishers, and developers.

### Custom Template

- Custom template is template for live stream, which allows users to add real-time graphics to their streams.
- With custom templates, users can create unique and engaging video experiences by overlaying graphics, text, images, and animations onto their live streams. These graphics can be customized to match the branding.
- Custom templates enable users to create engaging video content with real-time graphics, with live scoreboards, social media feeds, and other customizations, users can easily create unique and visually appealing streams that stands out from the crowd.

:::note

Custom templates can be used with recordings and RTMP service provided by VideoSDK as well.

:::

### What you can do with Custom Template

Using a custom template, you may create a variety of various modes. Here are a few of the more well-known modes that you can create.

- **`PK Host:`** Host can organise player vs player battle. Below image is example of gaming battle.

- **`Watermark:`** Host can add & update watermark anywhere in the template. In below image we have added VideoSDK watermark on top right side of the screen.

- **`News Mode:`** Host can add dynamic text in lower third banner. in below image we have added some sample text in bottom left of the screen.

![Mobile Custom Template ](https://cdn.videosdk.live/website-resources/docs-resources/mobile_custom_template.png)

### Custom template with VideoSDK

In this section, we will discuss how Custom Templates work with VideoSDK.

- **`Host`**: The host is responsible for starting the live streaming by passing the `templateURL`. The `templateURL` is the URL of the hosted template webpage. The host is also responsible for managing the template, such as changing text, logos, and switching template layout, among other things.

- **`VideoSDK Template Engine`** : The VideoSDK Template Engine accepts and opens the templateURL in the browser. It listens to all the events performed by the Host and enables customization of the template according to the Host's preferences.

- **`Viewer`**: The viewer can stream the content. They can watch the live stream with the added real-time graphics, which makes for a unique and engaging viewing experience.

![custom template](https://cdn.videosdk.live/website-resources/docs-resources/custom_template.png)

### Understanding Template URL

The template URL is the webpage that VideoSDK Template Engine will open while composing the live stream.

The template URL will appear as shown below.

![template url](https://cdn.videosdk.live/website-resources/docs-resources/custom_template_url.png)

The Template URL consists of two parts:

- Your actual page URL, which will look something like `https://example.com/videosdk-template`.
- Query parameters, which will allow the VideoSDK Template Engine to join the meeting when the URL is opened. There are a total of three query parameters:
  - `token`: This will be your token, which will be used to join the meeting.
  - `meetingId`: This will be the meeting ID that will be joined by the VideoSDK Template Engine.
  - `participantId`: This will be the participant ID of the VideoSDK Template Engine, which should be passed while joining the template engine in your template so that the tempalte engine participant is not visible to other participants. **This parameter will be added by the** **VideoSDK**.

:::info

Above mentioned query parameters are mandatory. Apart from these parameters, you can pass any other extra parameters which are required according to your use-case.

:::

### **Creating Template**

**`Step 1:`** Create a new React App using the below command

```js
npx create-react-app videosdk-custom-template
```

:::note

You can use VideoSDK's React or JavaScript SDK to create custom template. Following is the example of building custom template with React SDK.

:::

**`Step 2:`** Install the VideoSDK using the below-mentioned npm command.

Make sure you are in your react app directory before you run this command.

```js
npm install "@videosdk.live/react-sdk"

//For the Participants Video
npm install "react-player"
```

###### App Architecture

![template architechture](https://cdn.videosdk.live/website-resources/docs-resources/custom_template_arch.png)

###### Structure of the Project

```jsx title="Project Structure"
   root
   ├── node_modules
   ├── public
   ├── src
   │    ├── components
   │          ├── MeetingContainer.js
   │          ├── ParticipantsAudioPlayer.js
   │          ├── ParticipantsView.js
   │          ├── Notification.js
   │    ├── icons
   │    ├── App.js
   │    ├── index.js
   ├── package.json
   .
```

**`Step 3:`** Next we will fetch the query parameters, from the URL which we will later use to initialize the meeting

```js title=App.js
function App() {
  const { meetingId, token, participantId } = useMemo(() => {
    //highlight-start
    const location = window.location;

    const urlParams = new URLSearchParams(location.search);

    const paramKeys = {
      meetingId: "meetingId",
      token: "token",
      participantId: "participantId",
    };

    Object.keys(paramKeys).forEach((key) => {
      paramKeys[key] = urlParams.get(key)
        ? decodeURIComponent(urlParams.get(key))
        : null;
    });

    return paramKeys;
    //highlight-end
  }, []);
}
```

**`Step 4:`** Now we will initialize the meeting with the parameters we extracted from the URL. Make sure `joinWithoutUserInteraction` is specified, so that the template engine is able to join directly into the meeting, on the page load.

```js title=App.js
function App(){
//highlight-next-line
...

return meetingId && token && participantId ? (
  <div>
    <MeetingProvider
      //highlight-start
      config={{
        meetingId,
        micEnabled: false,
        webcamEnabled: false,
        name: "recorder",
        participantId,
      }}
      token={token}
      joinWithoutUserInteraction
      //highlight-end
    >
      {/* We will create this in upcoming steps */}
      <MeetingContainer />
    </MeetingProvider>
  </div>
) : null;

}
```

**`Step 5:`** Let us create the `MeetingContainer` which will render the meeting view for us.

- It will also listen to the PubSub messages from the `CHANGE_BACKGROUND` topic, which will change the background color of the meeting.
- It will have `Notification` component which will show any messages share by Host

:::note

We will be using the PubSub mechanism to communicate with the template. You can learn more about [PubSub from here](../video-and-audio-calling-api-sdk/collaboration-in-meeting/pubsub).

:::

import CautionMessage from '@site/src/theme/CautionMessage';

<CautionMessage sdk="Android SDK" version="v0.2.0" />

```js title=MeetingContainer.js
import { Constants, useMeeting, usePubSub } from "@videosdk.live/react-sdk";
import { Notification } from "./Notification";
import { ParticipantsAudioPlayer } from "./ParticipantsAudioPlayer";
import { ParticipantView } from "./ParticipantView";

export const MeetingContainer = () => {
  const { isMeetingJoined, participants, localParticipant } = useMeeting();
  //highlight-next-line
  const { messages } = usePubSub("CHANGE_BACKGROUND");

  const remoteSpeakers = [...participants.values()].filter((participant) => {
    return (
      participant.mode == Constants.modes.SEND_AND_RECV && !participant.local
    );
  });

  return isMeetingJoined ? (
    <div
      style={{
        display: "flex",
        flexDirection: "column",
        height: "100vh",
        //highlight-start
        backgroundColor:
          messages.length > 0
            ? messages.at(messages.length - 1).message
            : "#fff",
        //highlight-end
      }}
    >
      //highlight-next-line
      <ParticipantsAudioPlayer />
      <div
        style={{
          display: "grid",
          gridTemplateColumns: remoteSpeakers?.length > 1 ? "1fr 1fr" : "1fr",
          flex: 1,
          maxHeight: `100vh`,
          overflowY: "auto",
          gap: "20px",
          padding: "20px",
          alignItems: "center",
          justifyItems: "center",
        }}
      >
        {[...remoteSpeakers].map((participant) => {
          return (
            //highlight-start
            <ParticipantView
              key={participant.id}
              participantId={participant.id}
            />
            //highlight-end
          );
        })}
      </div>
      //highlight-next-line
      <Notification />
    </div>
  ) : (
    <div
      style={{
        display: "flex",
        justifyContent: "center",
        alignItems: "center",
        height: "100vh",
      }}
    >
      <div class="loader"></div>
    </div>
  );
};
```

**`Step 6:`** Let us create the `ParticipantView` and `ParticipantsAudioPlayer` which will render the video and audio of the participants respectively.

```js title=ParticipantView.js
import { useParticipant } from "@videosdk.live/react-sdk";
import { useMemo } from "react";
import ReactPlayer from "react-player";
import MicOffIcon from "../icons/MicOffIcon";

export const ParticipantView = (props) => {
  const { webcamStream, webcamOn, displayName, micOn } = useParticipant(
    props.participantId
  );

  const videoStream = useMemo(() => {
    if (webcamOn && webcamStream) {
      const mediaStream = new MediaStream();
      mediaStream.addTrack(webcamStream.track);
      return mediaStream;
    }
  }, [webcamStream, webcamOn]);

  return (
    <div
      style={{
        width: "100%",
        height: "400px",
        maxWidth: "600px",
        display: "flex",
        flex: 1,
        alignItems: "center",
        justifyContent: "center",
        position: "relative",
        backgroundColor: "#1A1C22",
        borderRadius: "10px",
        overflow: "hidden",
      }}
      class="video-cover"
    >
      {webcamOn && webcamStream ? (
        <ReactPlayer
          //
          playsinline // extremely crucial prop
          pip={false}
          light={false}
          controls={false}
          muted={true}
          playing={true}
          //
          url={videoStream}
          //
          height={"100%"}
          width={"100%"}
          onError={(err) => {
            console.log(err, "participant video error");
          }}
        />
      ) : (
        <div
          style={{
            fontSize: "50px",
            color: "#fff",
          }}
        >
          {String(displayName).charAt(0).toUpperCase()}
        </div>
      )}
      <div
        style={{
          position: "absolute",
          left: "10px",
          bottom: "10px",
          backgroundColor: "#050A0E",
          color: "#fff",
          padding: "4px",
          borderRadius: "4px",
          alignItems: "center",
          justifyItems: "center",
          display: "flex",
        }}
      >
        {displayName}{" "}
        {!micOn && <MicOffIcon fillcolor="#fff" height="18" width="18" />}
      </div>
    </div>
  );
};
```

```js title=ParticipantsAudioPlayer.js
import { useMeeting, useParticipant } from "@videosdk.live/react-sdk";
import { useEffect, useRef } from "react";

const ParticipantAudio = ({ participantId }) => {
  const { micOn, micStream, isLocal } = useParticipant(participantId);
  const audioPlayer = useRef();

  useEffect(() => {
    if (!isLocal && audioPlayer.current && micOn && micStream) {
      const mediaStream = new MediaStream();
      mediaStream.addTrack(micStream.track);

      audioPlayer.current.srcObject = mediaStream;
      audioPlayer.current.play().catch((err) => {});
    } else {
      audioPlayer.current.srcObject = null;
    }
  }, [micStream, micOn, isLocal, participantId]);

  return <audio autoPlay playsInline controls={false} ref={audioPlayer} />;
};

export const ParticipantsAudioPlayer = () => {
  const mMeeting = useMeeting();

  const participants = mMeeting?.participants;

  return participants ? (
    [...participants.keys()].map((participantId) => (
      <ParticipantAudio
        key={`participant_audio_${participantId}`}
        participantId={participantId}
      />
    ))
  ) : (
    <></>
  );
};
```

**`Step 7:`** Let us create the `Notification` component which will listen to PubSub messages for the topic `SIGNALLING_ONLY_MESSAGE` and show a notification on the lower left corner.

```js title=Notification.js
import { usePubSub } from "@videosdk.live/react-sdk";
import { useEffect, useRef, useState } from "react";

export const Notification = () => {
  const timeoutRef = useRef(null);
  const handleChatMessage = (msg) => {
    if (timeoutRef.current) {
      clearTimeout(timeoutRef.current);
    }
    setMessage(msg);
    timeoutRef.current = setTimeout(() => {
      setMessage(null);
    }, 3200);
  };
  const [message, setMessage] = useState(null);
  const { publish } = usePubSub("SIGNALLING_ONLY_MESSAGE", {
    onMessageReceived: handleChatMessage,
  });
  useEffect(() => {
    return () => {
      if (timeoutRef.current) {
        clearTimeout(timeoutRef.current);
      }
    };
  }, []);
  return message ? (
    <div
      style={{
        backgroundColor: "#232830",
        padding: "10px",
        textAlign: "center",
        color: "#fff",
        position: "absolute",
        bottom: "50px",
        left: "30px",
        borderRadius: "10px",
        animation: "fadein 0.5s",
      }}
    >
      <strong>
        {message.senderName} says {message.message}
      </strong>
    </div>
  ) : null;
};
```

:::note

For the CSS stylings and animations used in the project, please [refer to this file](https://github.com/videosdk-live/quickstart/blob/main/react-custom-template-manager/src/index.css).

:::

**`Step 9:`** Once tested, you can deploy it using your backend or host it on services like [firebase](https://www.geeksforgeeks.org/how-to-deploy-react-project-on-firebase/) or vercel.

:::tip

You can checkout the github repository for sample custom template we just [created here](https://github.com/videosdk-live/videosdk-custom-recording-template-react-example).

:::

### Setup Livestream Using Custom Template

- To use Custom Template, you will need Host and Viewer setup from where the host will start the livestream and viewer can watch them.

![Android Custom Template Example](https://cdn.videosdk.live/website-resources/docs-resources/android_custom_template.png)

- You can clone this example and run it on your system.

```bash
git clone https://github.com/videosdk-live/quickstart.git
```

- The cloned example will contain two directories under the `android-custom-template-manager` directory which has to runned.

  - **For Kotlin** : `Videosdk_android_kotlin_hls_quickstart`
  - **For Java** : `Videosdk_android_java_hls_quickstart`

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
cd android-custom-template-manager
cd Videosdk_android_kotlin_hls_quickstart
```

</TabItem>

<TabItem value="Java">

```js
cd android-custom-template-manager
cd Videosdk_android_java_hls_quickstart
```

</TabItem>

</Tabs>

- To use the custom template which we just deployed, we will call the [Start HLS API](https://docs.videosdk.live/api-reference/realtime-communication/start-hlsStream) instead of the `startHls` method from the `Meeting` class. This code has already been added in the example you cloned.

:::note
`downstreamUrl` is now depecated. Use `playbackHlsUrl` or `livestreamUrl` in place of `downstreamUrl`
:::

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
btnHls!!.setOnClickListener {
  //Update your Custom Template URL here if you have deployed your own, if not deployed you can use this template from our URL.
  //highlight-start
  val templateUrl =
      "https://lab.videosdk.live/react-custom-template-demo?meetingId=" + meeting!!.meetingId + "&token=" + token
  //highlight-end

  val bodyJson = JSONObject()
  JsonUtils.jsonPut(bodyJson, "roomId", meeting!!.meetingId)
  JsonUtils.jsonPut(bodyJson, "templateUrl", templateUrl)

  val config= new JSONObject()
  JsonUtils.jsonPut(config,"orientation","portrait")
  JsonUtils.jsonPut(bodyJson,"config",config)

  AndroidNetworking.post("https://api.videosdk.live/v2/hls/start")
    .addHeaders(
        "Authorization",
        token
    ) //we will pass the token in the Headers
    .addJSONObjectBody(bodyJson)
    .build()
    .getAsJSONObject(object : JSONObjectRequestListener {
        override fun onResponse(response: JSONObject) {
            try {
                Log.d("TAG", "onResponse: $response") // result will have playbackHlsUrl and livestreamUrl
            } catch (e: Exception) {
                e.printStackTrace()
            }
        }
        override fun onError(anError: ANError) {
            anError.printStackTrace()
            Toast.makeText(
                mContext,
                anError.message,
                Toast.LENGTH_SHORT
            ).show()
        }
    })
}
```

</TabItem>

<TabItem value="Java">

```js
btnHls.setOnClickListener(v -> {
  //Update your Custom Template URL here if you have deployed your own, if not deployed you can use this template from our URL.
  //highlight-start
  final String templateUrl =
  "https://lab.videosdk.live/react-custom-template-demo?meetingId=" + meeting.getMeetingId() + "&token=" + token;
  //highlight-end

  JSONObject bodyJson = new JSONObject();
  JsonUtils.jsonPut(bodyJson, "roomId", meeting.getMeetingId());
  JsonUtils.jsonPut(bodyJson, "templateUrl", templateUrl);

  JSONObject config= new JSONObject();
  JsonUtils.jsonPut(config,"orientation","portrait");
  JsonUtils.jsonPut(bodyJson,"config",config);

  AndroidNetworking.post("https://api.videosdk.live/v2/hls/start")
    .addHeaders("Authorization", token) //we will pass the token in the Headers
    .addJSONObjectBody(bodyJson)
    .build()
    .getAsJSONObject(new JSONObjectRequestListener() {
        @Override
        public void onResponse(JSONObject response) {
            try {
                Log.d("TAG", "onResponse: " + response.toString()); // result will have playbackHlsUrl and livestreamUrl
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        @Override
        public void onError(ANError anError) {
            anError.printStackTrace();
            Toast.makeText(mContext, anError.getMessage(), Toast.LENGTH_SHORT).show();
        }
    });
});
```

</TabItem>

</Tabs>

- This example has two option on the Host side which will allow them to change the background and send the messages to the viewer.

- Let's give this example a test run.

import ReactPlayer from 'react-player'

<div style={{textAlign: 'center'}}>

<ReactPlayer autoplay muted loop playing controls url="https://cdn.videosdk.live/website-resources/docs-resources/android_custom_template_video.mp4" height="500px" width={"100%"} />

</div>

### API Reference

The API references for all the methods utilized in this guide are provided below.

- [Start HLS API](/api-reference/realtime-communication/start-hlsStream)
- [onHlsStateChanged](/android/api/sdk-reference/meeting-class/meeting-event-listener-class#onhlsstatechanged)


---

---
sidebar_label: Manage Audio and Video Devices
pagination_label: Manage Audio and Video Devices
---

# Manage Audio and Video Devices - Android

This feature allows hosts to switch their microphone, speaker, or camera devices during a live stream. Only hosts (in `SEND_AND_RECV` mode) can change input/output devices, ensuring they maintain control over their audio and video quality, while audience members (in `RECV_ONLY` mode) continue to receive the broadcast seamlessly.

### Changing Input/Output Audio Device

###### `getMics()`

- This method of the `Meeting` class provides a list of all available microphones, which can be shown in a dropdown for selection.

- It returns an array of objects, each containing a `deviceId` and a `label` representing an audio input device.

###### `changeMic()`

- Participant can change the audio device using `changeMic(AppRTCAudioManager.AudioDevice device)` method of `Meeting` class.

- Parameters that can be passed to `changeMic` are

  | Audio Devices                                | Usage                        |
  | -------------------------------------------- | ---------------------------- |
  | AppRTCAudioManager.AudioDevice.BLUETOOTH     | For Bluetooth Device.        |
  | AppRTCAudioManager.AudioDevice.WIRED_HEADSET | For Wired Handset Device.    |
  | AppRTCAudioManager.AudioDevice.SPEAKER_PHONE | For Inbuilt - Speaker Device |
  | AppRTCAudioManager.AudioDevice.EARPIECE      | For Earpiece Device          |

- When participant changes the Mic, `AppRTCAudioManager.AudioManagerEvents()` is triggered which can be set to `Meeting` class by using `setAudioDeviceChangeListener()`.

#### Example

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
private fun getMics(): MutableSet<AppRTCAudioManager.AudioDevice>? {
  //highlight-next-line
  val mics = liveStream!!.mics
  return mics  // returns all connected mics
}

btnChangeMic!!.setOnClickListener { _: View? ->
  // Change Mic during Meeting
  //highlight-next-line
  liveStream!!.changeMic(AppRTCAudioManager.AudioDevice.BLUETOOTH)
}

private fun setAudioDeviceListeners() {
  //highlight-start
  liveStream!!.setAudioDeviceChangeListener(object : AudioManagerEvents {
    override fun onAudioDeviceChanged(
      selectedAudioDevice: AppRTCAudioManager.AudioDevice,
      availableAudioDevices: Set<AppRTCAudioManager.AudioDevice>
    ) {
      when (selectedAudioDevice) {
        AppRTCAudioManager.AudioDevice.BLUETOOTH ->
          Toast.makeText(this@MainActivity, "Selected AudioDevice: BLUETOOTH", Toast.LENGTH_SHORT).show()

        AppRTCAudioManager.AudioDevice.WIRED_HEADSET ->
          Toast.makeText(this@MainActivity, "Selected AudioDevice: WIRED_HEADSET", Toast.LENGTH_SHORT).show()

        AppRTCAudioManager.AudioDevice.SPEAKER_PHONE ->
          Toast.makeText(this@MainActivity, "Selected AudioDevice: SPEAKER_PHONE", Toast.LENGTH_SHORT).show()

        AppRTCAudioManager.AudioDevice.EARPIECE ->
          Toast.makeText(this@MainActivity, "Selected AudioDevice: EARPIECE", Toast.LENGTH_SHORT).show()
      }
    }
  })
  //highlight-end
}

override fun onCreate(savedInstanceState: Bundle?) {
  // ...
  setAudioDeviceListeners()
}
```

</TabItem>

<TabItem value="Java">

```js
private Set<AppRTCAudioManager.AudioDevice> getMics() {
  //highlight-next-line
  Set<AppRTCAudioManager.AudioDevice> mics = liveStream.getMics();
  return mics; // returns all connected mics
}

btnChangeMic.setOnClickListener(new View.OnClickListener() {
  @Override
  public void onClick(View v) {
    // Change Mic during liveStream
    //highlight-next-line
    liveStream.changeMic(AppRTCAudioManager.AudioDevice.BLUETOOTH);
  }
});

private void setAudioDeviceListeners() {
  //highlight-start
  liveStream.setAudioDeviceChangeListener(new AppRTCAudioManager.AudioManagerEvents() {
    @Override
    public void onAudioDeviceChanged(AppRTCAudioManager.AudioDevice selectedAudioDevice, Set<AppRTCAudioManager.AudioDevice> availableAudioDevices) {
      switch (selectedAudioDevice) {
        case BLUETOOTH:
          Toast.makeText(MainActivity.this, "Selected AudioDevice: BLUETOOTH", Toast.LENGTH_SHORT).show();
          break;
        case WIRED_HEADSET:
          Toast.makeText(MainActivity.this, "Selected AudioDevice: WIRED_HEADSET", Toast.LENGTH_SHORT).show();
          break;
        case SPEAKER_PHONE:
          Toast.makeText(MainActivity.this, "Selected AudioDevice: SPEAKER_PHONE", Toast.LENGTH_SHORT).show();
          break;
        case EARPIECE:
          Toast.makeText(MainActivity.this, "Selected AudioDevice: EARPIECE", Toast.LENGTH_SHORT).show();
          break;
      }
    }
  });
  //highlight-end
}

@Override
protected void onCreate(Bundle savedInstanceState) {
  // ...
  setAudioDeviceListeners();
}
```

</TabItem>

</Tabs>

- To use Bluetooth device, you must declare `BLUETOOTH` permission in `AndroidManifest.xml` file.

```js
<manifest ... >
//...
<uses-permission android:name="android.permission.BLUETOOTH" />
<uses-permission android:name="android.permission.BLUETOOTH_ADMIN" />
<uses-permission android:name="android.permission.BLUETOOTH_CONNECT" />
</manifest>
```

## Changing Camera Input Device


###### `changeWebcam()`

- To change the camera device of the host, you need to call `changeWebcam()` method.

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
  btnWebcam!!.setOnClickListener {
    // Change Webcam during liveStream
    //highlight-next-line
    liveStream!!.changeWebcam()
  }
```

</TabItem>

<TabItem value="Java">

```js
  btnWebcam.setOnClickListener(new View.OnClickListener() {
      @Override
      public void onClick(View v) {
        // Change Webcam during liveStream
        //highlight-next-line
        liveStream.changeWebcam();
      }
  });
```

</TabItem>

</Tabs>


### API Reference

The API references for all the methods and events utilised in this guide are provided below.

- [getMics()](/android/api/sdk-reference/meeting-class/methods#getmics)
- [changeMic()](/android/api/sdk-reference/meeting-class/methods#changemic)
- [changeWebcam()](/android/api/sdk-reference/meeting-class/methods#changewebcam)


---

---
title: Mute / Unmute Mic | Video SDK
hide_title: true
hide_table_of_contents: false
description: Mic Controls features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Mute / Unmute Mic
pagination_label: Mute / Unmute Mic
keywords:
  - audio calling
  - video calling
  - real-time communication
  - collaboration
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: mute-unmute-mic
---

# Mute / Unmute Mic - Android

This feature allows hosts to communicate with each other during the livestream by enabling or disabling their microphones. While only hosts (participants in SEND_AND_RECV mode) can speak, audience members (in RECV_ONLY mode) can listen to the conversation in real time.

### `unmuteMic()`

- By using the `unmuteMic()` function of the `Meeting` class, the host can publish their audio to other hosts and audience members.

- You can also pass a customised audio track in the `unmuteMic()` method by using [Custom Audio Track](/android/guide/interactive-live-streaming/custom-media-sources/custom-audio-sources).

### `muteMic()`

- By using the `muteMic()` function of the `Meeting` class, the host can stop publishing their audio to other hosts and audience members.

#### Example

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
  private var micEnabled = false

  btnMic!!.setOnClickListener { _: View? ->
     if (micEnabled) {
      // Muting Mic
      //highlight-next-line
       liveStream!!.muteMic()
       micEnabled=false
     } else {
      // Unmuting Mic
      //highlight-next-line
      liveStream!!.unmuteMic()
      micEnabled=true
     }
  }
```

</TabItem>

<TabItem value="Java">

```js
  private boolean micEnabled = false;

  btnMic.setOnClickListener(new View.OnClickListener() {
      @Override
      public void onClick(View v) {
          if (micEnabled) {
              // Muting Mic
              //highlight-next-line
              liveStream.muteMic();
              micEnabled = false;
          } else {
            // Unmuting Mic
            //highlight-next-line
              liveStream.unmuteMic();
              micEnabled = true;
          }
      }
  });
```

</TabItem>

</Tabs>

### Events associated with unmuteMic

- Every Participant—including all the hosts and audience members will receive a callback on [`onStreamEnabled()`](/android/api/sdk-reference/participant-class/participant-event-listener-class#onstreamenabled) of the [`Participant`](/android/api/sdk-reference/participant-class/introduction) with `Stream` object.


### Events associated with muteMic

- Every Participant—including all the hosts and audience members will receive a callback on [`onStreamDisabled()`](/android/api/sdk-reference/participant-class/participant-event-listener-class#onstreamdisabled) of the [`Participant`](/android/api/sdk-reference/participant-class/introduction) with `Stream` object.


<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
  meeting!!.localParticipant.addEventListener(object : ParticipantEventListener() {
    //Callback for when the participant starts a stream
    //highlight-start
    override fun onStreamEnabled(stream: Stream) {
        if(stream.getKind().equals("audio")){
          Log.d("VideoSDK","Audio Stream On: onStreamEnabled $stream");
        }
    }
    //highlight-end

    //Callback for when the participant stops a stream
    //highlight-start
    override fun onStreamDisabled(stream: Stream) {
        if(stream.getKind().equals("audio")){
          Log.d("VideoSDK","Audio Stream On: onStreamDisabled $stream");
        }
    }
    //highlight-end
  });
```

</TabItem>

<TabItem value="Java">

```js
  participant.addEventListener(new ParticipantEventListener() {
    //Callback for when the participant starts a stream
    //highlight-start
    @Override
    public void onStreamEnabled(Stream stream) {
        if(stream.getKind().equals("audio")){
          Log.d("VideoSDK","Audio Stream On: onStreamEnabled" + stream);
        }
    }
    //highlight-end

    //Callback for when the participant stops a stream
    //highlight-start
    @Override
    public void onStreamDisabled(Stream stream) {
        if(stream.getKind().equals("audio")){
          Log.d("VideoSDK","Audio Stream Off: onStreamDisabled" + stream);
        }
    }
    //highlight-end
  });
```

</TabItem>

</Tabs>

### Audio Permissions

- To use the microphone in a live stream, you need to add permission in `app/src/main/AndroidManifest.xml` after `</application>`.

```xml title="AndroidManifest.xml"
<uses-permission android:name="android.permission.RECORD_AUDIO" />
```

- You need to set up a permission request that provides this access.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
import android.Manifest
import android.content.pm.PackageManager
import android.os.Bundle
import android.widget.Toast
import androidx.appcompat.app.AppCompatActivity
import androidx.core.app.ActivityCompat
import androidx.core.content.ContextCompat

class LiveStreamActivity : AppCompatActivity() {
    private val PERMISSION_REQUEST_CODE: Int = 1;

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_live_stream);

        //highlight-start
        if (checkPermission()) {
            // . write your main code to execute, It will execute if the permission is already given.
        } else {
            requestPermission()
        }
        //highlight-end
    }
    private fun checkPermission(): Boolean {
        //highlight-next-line
        return ContextCompat.checkSelfPermission(this, Manifest.permission.RECORD_AUDIO) == PackageManager.PERMISSION_GRANTED
    }

    private fun requestPermission() {
      //highlight-start
        ActivityCompat.requestPermissions(
            this, arrayOf(Manifest.permission.RECORD_AUDIO),
            PERMISSION_REQUEST_CODE
        )
      //highlight-end
    }

    override
    fun onRequestPermissionsResult(
        requestCode: Int,
        permissions: Array<out String>,
        grantResults: IntArray
    ) {
        super.onRequestPermissionsResult(requestCode, permissions, grantResults)
        when (requestCode) {
            PERMISSION_REQUEST_CODE -> if (grantResults.isNotEmpty() && grantResults[0] == PackageManager.PERMISSION_GRANTED) {
                Toast.makeText(applicationContext, "Permission Granted", Toast.LENGTH_SHORT).show()
                // main logic
            } else {
                Toast.makeText(applicationContext, "Permission Denied", Toast.LENGTH_SHORT).show()
            }
        }
    }
}
```

</TabItem>

<TabItem value="Java">

```js
import androidx.annotation.NonNull;
import androidx.appcompat.app.AppCompatActivity;
import androidx.core.app.ActivityCompat;
import androidx.core.content.ContextCompat;

import android.Manifest;
import android.content.pm.PackageManager;
import android.os.Bundle;
import android.widget.Toast;

import java.util.ArrayList;
import java.util.List;

public class LiveStreamActivity extends AppCompatActivity {

    private static final int PERMISSION_REQUEST_CODE = 1;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_live_stream);

        //highlight-start
        if (checkPermission()) {
            // . write your main code to execute, It will execute if the permission is already given.
        } else {
            requestPermission();
        }
        //highlight-end
    }

    private boolean checkPermission() {
        //highlight-next-line
        return ContextCompat.checkSelfPermission(this, Manifest.permission.RECORD_AUDIO) == PackageManager.PERMISSION_GRANTED;
    }

    private void requestPermission() {
        List<String> permissionList = new ArrayList<String>();
        String[] permissions = {};
        permissionList.add(Manifest.permission.RECORD_AUDIO);
        //highlight-start
        ActivityCompat.requestPermissions(
                this, permissionList.toArray(permissions),
                PERMISSION_REQUEST_CODE
        );
        //highlight-end
    }

    @Override
    public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
        super.onRequestPermissionsResult(requestCode, permissions, grantResults);
        switch (requestCode) {
            case PERMISSION_REQUEST_CODE:
                if (grantResults.length > 0 && grantResults[0] == PackageManager.PERMISSION_GRANTED) {
                    Toast.makeText(MainActivity.this, "Permission Granted", Toast.LENGTH_SHORT).show();
                    // main logic
                } else {
                    Toast.makeText(MainActivity.this, "Permission Denied", Toast.LENGTH_SHORT).show();
                }
                break;
        }
    }
}
```

</TabItem>

</Tabs>

### API Reference

The API references for all the methods and events utilised in this guide are provided below.

- [unmuteMic()](/android/api/sdk-reference/meeting-class/methods#unmutemic)
- [muteMic()](/android/api/sdk-reference/meeting-class/methods#mutemic)
- [onStreamEnabled()](/android/api/sdk-reference/participant-class/participant-event-listener-class#onstreamenabled)
- [onStreamDisabled()](/android/api/sdk-reference/participant-class/participant-event-listener-class#onstreamdisabled)


---

---
title: On / Off Camera | Video SDK
hide_title: true
hide_table_of_contents: false
description: Camera Controls features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: On / Off Camera
pagination_label: On / Off Camera
keywords:
  - audio calling
  - video calling
  - real-time communication
  - collaboration
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: on-off-camera
--- 

# On / Off Camera - Android

This feature enables hosts to turn their cameras on or off to share their video stream with other hosts and audience members during the meeting. Only hosts (in `SEND_AND_RECV` mode) can broadcast their camera feed, while audience members (in `RECV_ONLY` mode) can view it in real time.

### `enableWebcam()`

- By using the `enableWebcam()` function of the `Meeting` class, the host can publish their video to to other hosts and audience members.

- You can also pass a customised video track in `enableWebcam()` by using [Custom Video Track](../custom-media-sources/custom-video-sources.md).


- Video stream of the participant can be accessed from the `onStreamEnabled` event of `ParticipantEventListener`.

### `disableWebcam()`

- By using `disableWebcam()` function of `Meeting` class, the host can stop publishing their video to to other hosts and audience members.

#### Example

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
  btnWebcam!!.setOnClickListener {
    if (webcamEnabled) {
      // Disabling camera
      //highlight-next-line
      meeting!!.disableWebcam()
    } else {
      // Enabling camera
      //highlight-next-line
      meeting!!.enableWebcam()
    }
    webcamEnabled=!webcamEnabled
  }
```

</TabItem>

<TabItem value="Java">

```js
  btnWebcam.setOnClickListener(new View.OnClickListener() {
      @Override
      public void onClick(View v) {
        if (webcamEnabled) {
          // Disabling camera
          //highlight-next-line
          liveStream.disableWebcam();
        } else {
          // Enabling camera
          //highlight-next-line
          liveStream.enableWebcam();
        }
        webcamEnabled=!webcamEnabled;
      }
  });
```

</TabItem>

</Tabs>

:::important
To learn, how to render video in the meeting, follow thisdetailed [guide](/android/guide/video-and-audio-calling-api-sdk/render-media/display-video/render-participant) .
:::

### Events associated with enableWebcam

- Every Participant—including all the hosts and audience members will receive a callback on [`onStreamEnabled()`](/android/api/sdk-reference/participant-class/participant-event-listener-class#onstreamenabled) event of the [`Participant`](/android/api/sdk-reference/participant-class/introduction) with `Stream` object.

### Events associated with disableWebcam

- Every Participant—including all the hosts and audience members will receive a callback on [`onStreamDisabled()`](/android/api/sdk-reference/participant-class/participant-event-listener-class#onstreamdisabled) event of the [`Participant`](/android/api/sdk-reference/participant-class/introduction) with `Stream` object.


<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
  liveStream!!.localParticipant.addEventListener(object : ParticipantEventListener() {
    //Callback for when the participant starts a stream
    //highlight-start
    override fun onStreamEnabled(stream: Stream) {
        if(stream.getKind().equals("video")){
          Log.d("VideoSDK","Video Stream On: onStreamEnabled $stream");
        }
    }
    //highlight-end

    //Callback for when the participant stops a stream
    //highlight-start
    override fun onStreamDisabled(stream: Stream) {
        if(stream.getKind().equals("video")){
          Log.d("VideoSDK","Video Stream On: onStreamDisabled $stream");
        }
    }
    //highlight-end
  });
```

</TabItem>

<TabItem value="Java">

```js
  participant.addEventListener(new ParticipantEventListener() {
    //Callback for when the participant starts a stream
    //highlight-start
    @Override
    public void onStreamEnabled(Stream stream) {
        if(stream.getKind().equals("video")){
          Log.d("VideoSDK","Video Stream On: onStreamEnabled" + stream);
        }
    }
    //highlight-end

    //Callback for when the participant stops a stream
    //highlight-start
    @Override
    public void onStreamDisabled(Stream stream) {
        if(stream.getKind().equals("video")){
          Log.d("VideoSDK","Video Stream Off: onStreamDisabled" + stream);
        }
    }
    //highlight-end
  });
```

</TabItem>

</Tabs>

### Video Permissions

- To use the camera in a live stream, you need to add permission in `app/src/main/AndroidManifest.xml` after `</application>`.

```xml title="AndroidManifest.xml"
<uses-permission android:name="android.permission.CAMERA" />
```

- You need to set up a permission request that provides this access.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
import android.Manifest
import android.content.pm.PackageManager
import android.os.Bundle
import android.widget.Toast
import androidx.appcompat.app.AppCompatActivity
import androidx.core.app.ActivityCompat
import androidx.core.content.ContextCompat

class LiveStreamActivity : AppCompatActivity() {
    private val PERMISSION_REQUEST_CODE: Int = 1;

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_live_stream);

        //highlight-start
        if (checkPermission()) {
            // . write your main code to execute, It will execute if the permission is already given.
        } else {
            requestPermission()
        }
        //highlight-end
    }
    private fun checkPermission(): Boolean {
        //highlight-next-line
        return ContextCompat.checkSelfPermission(this, Manifest.permission.CAMERA) == PackageManager.PERMISSION_GRANTED
    }

    private fun requestPermission() {
      //highlight-start
        ActivityCompat.requestPermissions(
            this, arrayOf(Manifest.permission.CAMERA),
            PERMISSION_REQUEST_CODE
        )
      //highlight-end
    }

    override
    fun onRequestPermissionsResult(
        requestCode: Int,
        permissions: Array<out String>,
        grantResults: IntArray
    ) {
        super.onRequestPermissionsResult(requestCode, permissions, grantResults)
        when (requestCode) {
            PERMISSION_REQUEST_CODE -> if (grantResults.isNotEmpty() && grantResults[0] == PackageManager.PERMISSION_GRANTED) {
                Toast.makeText(applicationContext, "Permission Granted", Toast.LENGTH_SHORT).show()
                // main logic
            } else {
                Toast.makeText(applicationContext, "Permission Denied", Toast.LENGTH_SHORT).show()
            }
        }
    }
}
```

</TabItem>

<TabItem value="Java">

```js
import androidx.annotation.NonNull;
import androidx.appcompat.app.AppCompatActivity;
import androidx.core.app.ActivityCompat;
import androidx.core.content.ContextCompat;

import android.Manifest;
import android.content.pm.PackageManager;
import android.os.Bundle;
import android.widget.Toast;

import java.util.ArrayList;
import java.util.List;

public class LiveStreamActivity extends AppCompatActivity {

    private static final int PERMISSION_REQUEST_CODE = 1;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_live_stream);

        //highlight-start
        if (checkPermission()) {
            // . write your main code to execute, It will execute if the permission is already given.
        } else {
            requestPermission();
        }
        //highlight-end
    }

    private boolean checkPermission() {
        //highlight-next-line
        return ContextCompat.checkSelfPermission(this, Manifest.permission.CAMERA) == PackageManager.PERMISSION_GRANTED;
    }

    private void requestPermission() {
        List<String> permissionList = new ArrayList<String>();
        String[] permissions = {};
        permissionList.add(Manifest.permission.CAMERA);
        //highlight-start
        ActivityCompat.requestPermissions(
                this, permissionList.toArray(permissions),
                PERMISSION_REQUEST_CODE
        );
        //highlight-end
    }

    @Override
    public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
        super.onRequestPermissionsResult(requestCode, permissions, grantResults);
        switch (requestCode) {
            case PERMISSION_REQUEST_CODE:
                if (grantResults.length > 0 && grantResults[0] == PackageManager.PERMISSION_GRANTED) {
                    Toast.makeText(MainActivity.this, "Permission Granted", Toast.LENGTH_SHORT).show();
                    // main logic
                } else {
                    Toast.makeText(MainActivity.this, "Permission Denied", Toast.LENGTH_SHORT).show();
                }
                break;
        }
    }
}
```

</TabItem>

</Tabs>

:::important
If the app goes to the background, VideoSDK detectes this event based on activity lifecycle and release the camera so that it can be used by other apps. In order to make sure this functionality works properly use  `VideoSDK.setActivityForLifeCycle(activity)` to specify which activity VideoSDK should monitor for lifecycle changes.
:::

### API Reference

The API references for all the methods and events utilised in this guide are provided below.

- [enableWebcam()](/android/api/sdk-reference/meeting-class/methods#enablewebcam)
- [disableWebcam()](/android/api/sdk-reference/meeting-class/methods#disablewebcam)
- [onStreamEnabled()](/android/api/sdk-reference/participant-class/participant-event-listener-class#onstreamenabled)
- [onStreamDisabled()](/android/api/sdk-reference/participant-class/participant-event-listener-class#onstreamdisabled)


---

---
title: Screen Share | Video SDK
hide_title: true
hide_table_of_contents: false
description: Share your Screen features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Screen Share
pagination_label: Screen Share
keywords:
  - audio calling
  - video calling
  - real-time communication
  - collaboration
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: screen-share
--- 

# Screen Share - Android

This feature enables hosts to start or stop sharing their screen with other hosts and audience members during the live stream. Only hosts (in `SEND_AND_RECV` mode) can broadcast their screen, while audience members (in `RECV_ONLY` mode) can view it in real time.

### How Screen share works?

- The following diagram shows flow of the screen sharing in android using VideoSDK :

<div style={{textAlign: 'center'}}>

![VideoSDK Android Screenshare Flow Diagram](/img/android/screenshare/flow_diagram.png)

</div>

### `enableScreenShare()`

- By using `enableScreenShare()` function of `Meeting` class,the host can share their mobile screen to other hosts and audience members.

- You can pass customised screenshare track in `enableScreenShare()` by using [Custom Screen Share Track](/android/guide/interactive-live-streaming/custom-media-sources/custom-screenshare-sources).

- Screen Share stream of the participant can be accessed from the `onStreamEnabled` event of `ParticipantEventListener`.

### Screenshare permission

- A participant’s Screen share stream is provided via the `MediaProjection` API. This API is only compatible with `Build.VERSION_CODES.LOLLIPOP` or higher.

- Get an instance of the `MediaProjectionManager` and Call the `createScreenCaptureIntent()` method in an activity. This initiates a prompt dialog for the user to confirm screen projection.

- One will get a prompt dialog like this:

<div style={{textAlign: 'center'}}>

<img
src={require('/img/android/screenshare/user_permission.jpg').default}
alt="user permission"
width="450"
/>

</div>

<br/>

- After permission is received from the user, you can call `enableScreenShare()` method.

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
private fun enableScreenShare() {
    val mediaProjectionManager = application.getSystemService(
        MEDIA_PROJECTION_SERVICE
    ) as MediaProjectionManager
    startActivityForResult(
        mediaProjectionManager.createScreenCaptureIntent(), CAPTURE_PERMISSION_REQUEST_CODE
    )
}

public override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) {
    super.onActivityResult(requestCode, resultCode, data)
    if (requestCode != CAPTURE_PERMISSION_REQUEST_CODE) return
    if (resultCode == RESULT_OK) {
        // Enabling screen share
        //highlight-next-line
        liveStream!!.enableScreenShare(data)
    }
}
```

</TabItem>

<TabItem value="Java">

```js
private void enableScreenShare() {
    MediaProjectionManager mediaProjectionManager =
        (MediaProjectionManager) getApplication().getSystemService(
            Context.MEDIA_PROJECTION_SERVICE);
    startActivityForResult(
        mediaProjectionManager.createScreenCaptureIntent(), CAPTURE_PERMISSION_REQUEST_CODE);
}

@Override
public void onActivityResult(int requestCode, int resultCode, Intent data) {
    super.onActivityResult(requestCode, resultCode, data);
    if (requestCode != CAPTURE_PERMISSION_REQUEST_CODE)
        return;
    if (resultCode == Activity.RESULT_OK) {
        // Enabling screen share
        //highlight-next-line
        liveStream.enableScreenShare(data);
    }
}
```

</TabItem>

</Tabs>

### Customise notification

- When a presenter starts screen share, presenter will receive a notification with a pre-defined title and message.

- Notification with pre-defined title and message will look like this:

<div style={{textAlign: 'center'}}>

<img
src={require('/img/android/screenshare/notification.jpg').default}
alt="notification"
width="450"
/>

</div>

- You can Customise those title, message and icon as per your requirements using `<meta-data>` specified in `app/src/main/AndroidManifest.xml`.

```js
<application>
  <meta-data
    android:name="notificationTitle"
    //highlight-next-line
    android:value="@string/notificationTitle"
  />
  <meta-data
    android:name="notificationContent"
    //highlight-next-line
    android:value="@string/notificationContent"
  />
  <meta-data
    android:name="notificationIcon"
    //highlight-next-line
    android:resource="@mipmap/ic_launcher_round"
  />
</application>
```

### `disableScreenShare()`

- By using `disableScreenShare()` function of `Meeting` class,the host can stop sharing their mobile screen to other hosts and audience members.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
private fun disableScreenShare() {
    // Disabling screen share
    //highlight-next-line
    liveStream!!.disableScreenShare()
}
```

</TabItem>

<TabItem value="Java">

```js
private void disableScreenShare(){
    // Disabling screen share
    //highlight-next-line
    liveStream.disableScreenShare();
}
```

</TabItem>

</Tabs>

### Events associated with enableScreenShare

- Participant who share their mobile screen will receive a callback on [`onStreamEnabled()`](/android/api/sdk-reference/participant-class/participant-event-listener-class#onstreamenabled) of the [`Participant`](/android/api/sdk-reference/participant-class/introduction) with `Stream` object.

- While other Participants will receive [`onPresenterChanged()`](/android/api/sdk-reference/meeting-class/meeting-event-listener-class#onpresenterchanged) callback of the [`Meeting`](/android/api/sdk-reference/meeting-class/introduction) class with the participantId as `presenterId` who started the screen share.

### Events associated with disableScreenShare

- Participant who shared their mobile screen will receive a callback on [`onStreamDisabled()`](/android/api/sdk-reference/participant-class/participant-event-listener-class#onstreamdisabled) of the [`Participant`](/android/api/sdk-reference/participant-class/introduction) with `Stream` object.

- While other Participants will receive [`onPresenterChanged()`](/android/api/sdk-reference/meeting-class/meeting-event-listener-class#onpresenterchanged) callback of the [`Meeting`](/android/api/sdk-reference/meeting-class/introduction) class with the `presenterId` as `null` indicating there is no presenter.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
private fun setLocalListeners() {
    liveStream!!.localParticipant.addEventListener(object : ParticipantEventListener() {
        //Callback for when the participant starts a stream
        //highlight-start
        override fun onStreamEnabled(stream: Stream) {
           if (stream.kind.equals("share", ignoreCase = true)) {
              Log.d("VideoSDK","Share Stream On: onStreamEnabled $stream");
            }
        }
        //highlight-end

        //Callback for when the participant stops a stream
        //highlight-start
        override fun onStreamDisabled(stream: Stream) {
            if (stream.kind.equals("share", ignoreCase = true)) {
               Log.d("VideoSDK","Share Stream On: onStreamDisabled $stream");
            }
        }
        //highlight-end
    });
}

private val meetingEventListener: MeetingEventListener = object : MeetingEventListener() {
    //Callback for when the presenter changes
    //highlight-start
    override fun onPresenterChanged(participantId: String) {
        if(!TextUtils.isEmpty(participantId))
        {
          Log.d("VideoSDK","$participantId started screen share");
        }else{
          Log.d("VideoSDK","some one stopped screen share");
        }
    }
    //highlight-end
}
```

</TabItem>

<TabItem value="Java">

```js
private void setLocalListeners() {
    liveStream.getLocalParticipant().addEventListener(new ParticipantEventListener() {
        //Callback for when the participant starts a stream
        //highlight-start
        @Override
        public void onStreamEnabled(Stream stream) {
            if (stream.getKind().equalsIgnoreCase("share")) {
                Log.d("VideoSDK","Share Stream On: onStreamEnabled" + stream);
            }
        }
        //highlight-end

        //Callback for when the participant stops a stream
        //highlight-start
        @Override
        public void onStreamDisabled(Stream stream) {
            if (stream.getKind().equalsIgnoreCase("share")) {
                Log.d("VideoSDK","Share Stream Off: onStreamDisabled" + stream);
            }
        }
        //highlight-end
    });
}

private final MeetingEventListener meetingEventListener = new MeetingEventListener() {
    //Callback for when the presenter changes
    //highlight-start
    @Override
    public void onPresenterChanged(String participantId) {
      if(participantId != null){
        Log.d("VideoSDK",participantId + "started screen share");
      }else{
        Log.d("VideoSDK","some one stopped screen share");
      }
    }
    //highlight-end
};
```

</TabItem>

</Tabs>

### Rendering Screen Share Stream

- When a host participant shares their screen, the `onStreamEnabled()` function of the `ParticipantEventListener` is triggered, allowing the `Stream` to be added to a `VideoView`.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
private fun setLocalListeners() {
    liveStream!!.localParticipant.addEventListener(object : ParticipantEventListener() {
        override fun onStreamEnabled(stream: Stream) {
           if (stream.kind.equals("share", ignoreCase = true)) {
                // display share video
                val videoTrack = stream.track as VideoTrack
                shareView!!.addTrack(videoTrack)
            }
        }
        override fun onStreamDisabled(stream: Stream) {
            if (stream.kind.equals("share", ignoreCase = true)) {
               shareView!!.removeTrack()
            }
        }
    });
}
```

</TabItem>

<TabItem value="Java">

```js
private void setLocalListeners() {
    liveStream.getLocalParticipant().addEventListener(new ParticipantEventListener() {
        @Override
        public void onStreamEnabled(Stream stream) {
            if (stream.getKind().equalsIgnoreCase("share")) {
                // display share video
                VideoTrack videoTrack = (VideoTrack) stream.getTrack();
                shareView.addTrack(videoTrack);
            }
        }
        @Override
        public void onStreamDisabled(Stream stream) {
            if (stream.getKind().equalsIgnoreCase("share")) {
                shareView.removeTrack();
            }
        }
    });
}
```

</TabItem>

</Tabs>


### API Reference

The API references for all the methods and events utilised in this guide are provided below.

- [enableScreenShare()](/android/api/sdk-reference/meeting-class/methods#enablescreenshare)
- [disableScreenShare()](/android/api/sdk-reference/meeting-class/methods#disablescreenshare)
- [onStreamEnabled()](/android/api/sdk-reference/participant-class/participant-event-listener-class#onstreamenabled)
- [onStreamDisabled()](/android/api/sdk-reference/participant-class/participant-event-listener-class#onstreamdisabled)
- [onPresenterChanged()](/android/api/sdk-reference/meeting-class/meeting-event-listener-class#onpresenterchanged)


---

---
title: Switch Live Stream | Video SDK
hide_title: true
hide_table_of_contents: false
sidebar_label: Switch Live Stream
pagination_label: Switch Live Stream
image: img/videosdklive-thumbnail.jpg
sidebar_position: 2
slug: switch-live-stream
---

# Switch Live Stream - Android

## Overview

The **Switch Live Stream** feature enables users to **seamlessly transition** between live streams without needing to manually disconnect and reconnect. This drastically improves user experience by reducing latency and preserving media and socket connections.

### Previously

1.  Users had to **disconnect** from the current liveStream.
2.  Then **manually connect** to a new liveStream:
    - New socket connection created.
    - New media transports initialized.
    - Delays due to re-connection and media setup.

This led to:

- **Higher latency**
- **Socket transport downtime**
- **Poor experience** for users switching frequently between rooms

### New Behavior with `switchTo`

- Keeps the existing **socket connection** alive
- Reuses or reconfigures existing **media**
- Switches the server-side context to the **new liveStream**

### `switchTo()`

#### **Parameters**

- **liveStreamId** (`string`, required): ID of the new liveStream to join
- **token** (`string`, optional): VideoSDK token for authentication

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
class LiveStreamActivity : AppCompatActivity() {
    //Initialize  meeting
    val liveStream = VideoSDK.initMeeting(... )
    //...
    val switchButton: Button = findViewById(R.id.switchLiveStreamButton)
    switchButton.setOnClickListener {
        liveStream?.switchTo("liveStream-xyz-456")
    }
}
```

</TabItem>

<TabItem value="Java">

```java
public class LiveStreamActivity extends AppCompatActivity {
    // Initialize meeting
  Meeting liveStream = VideoSDK.initMeeting( ...);
    //...
    Button switchButton = findViewById(R.id.switchLiveStreamButton);
    switchButton.setOnClickListener(new View.OnClickListener() {
        @Override
        public void onClick(View v) {
            if (liveStream != null) {
                liveStream.switchTo("liveStream-xyz-456");
            }
        }
    });
}
```

</TabItem>

</Tabs>

## Important Considerations

### Meeting Status

- **The destination liveStream must be active** before attempting to switch.
- If the destination liveStream is inactive or doesn't exist, the switch will fail.

### Token Management

- **Token Expiry**: Be careful with short-lived tokens when using the switch feature.
  - If you're using short-lived tokens for security reasons, always provide a new token in the `switchTo` method.
  - Tokens that expire during a liveStream can cause unexpected disconnections.
- **Best Practice**: For frequent switches, use tokens with reasonable expiry times or implement a token refresh mechanism.

## API Reference

- [switchTo](/android/api/sdk-reference/meeting-class/methods#switchto)


---

---
title: Geo Fencing | Location based Restrictions | Video SDK
hide_title: true
hide_table_of_contents: false
description: Implement geographic content restrictions with Video SDK's Geo Fencing feature. Essential for compliance and tailored content delivery based on user location.
sidebar_label: Geo Fencing
pagination_label: Geo Fencing
keywords:
- geo fencing
- geographic restrictions
- location based restrictions
- regional access
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: geo-fencing
---

# Geo Fencing - Android

import GeoFencing from '../../../../mdx/\_geo-fencing.mdx';

<GeoFencing/>



---

---
title: Host vs Audience Modes | Video SDK
hide_title: true
hide_table_of_contents: false
description: Understand the differences between Host and Audience modes in Video SDK's Interactive Live Stream (ILS), their capabilities, and how participants transition between them.
sidebar_label: Host vs Audience Modes
pagination_label: Host vs Audience Modes
keywords:
  - audio calling
  - video calling
  - real-time communication
  - collaboration
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: join-meeting
--- 

# Host vs Audience Modes - Android

Before diving into implementation, it's important to understand the two core modes of participation in an `Interactive Live Stream (ILS)` session powered by VideoSDK:

### `1. SEND_AND_RECV` – Host / Co-host Mode

This mode is designed for Hosts or Co-hosts who need to broadcast their audio and video to the audience and potentially interact with other hosts. Following is the list of everything a host is capable of:

- Publish and receive media (audio/video/screen share)
- Participate in conversations with other hosts
- Engage with the audience using chat, polls, reactions, and more
- Moderate the stage and manage participants
- Invite audience members on stage to become temporary broadcasters

🔢 Supports 100+ simultaneous hosts/co-hosts (Need more? Contact support@videosdk.live)

### `2. RECV_ONLY` – Audience Mode

This mode is optimized for audience members who are viewing the live stream and engaging via non-verbal interaction tools. Following is the list of everything audience is capable of:

- Receive media from all active hosts in real time (audio/video/screen share)
- No media publishing – cannot share their own audio/video unless promoted
- Engage via:
  - Live chat
  - Polls and quizzes
  - Reactions (emojis, claps, hearts, etc.)
  - Virtual gifts
  - Hand raise to request stage access

🔢 Scales to 2,000+ real-time viewers (Need more? Contact support@videosdk.live)

### Seamless Transition Between Modes

VideoSDK offers a dynamic role management system, making it easy to transition a participant from audience to stage. If a host invites an audience member on stage, they can seamlessly switch from `RECV_ONLY` mode to `SEND_AND_RECV` mode. This allows them to publish their audio/video and interact like a host or co-host. Once their role is revoked, they can return to the audience mode.

### Mode Architecture

Here’s a visual representation of how these modes function within an ILS session:

<div style={{textAlign: 'center'}}>
<img
  src="https://cdn.videosdk.live/website-resources/docs-resources/ils_mode_demonstration-compressed.jpg"
  alt="ILS Mode Demonstration"
  width="550"
  height="450"
/>
</div>

By clearly separating hosts from viewers, and offering seamless transitions between roles, VideoSDK ILS ensures high performance, low latency, and exceptional flexibility for all live streaming scenarios.

:::note

Throughout the rest of this documentation, whenever we mention "Host", we are specifically referring to a participant in the `SEND_AND_RECV` mode. Similarly, when we mention "Audience" or "Viewer", we are referring to participants in the `RECV_ONLY` mode. These distinctions are important, as each mode comes with its own set of capabilities and limitations.

:::


---

---
title: Overview | Video SDK
hide_title: true
hide_table_of_contents: false
description: Learn how Video SDK's Interactive Live Streaming (ILS) enables ultra-low-latency real-time engagement, supporting multiple hosts and thousands of viewers with interactive tools.
sidebar_label: Overview
pagination_label: Overview
keywords:
  - audio calling
  - video calling
  - real-time communication
  - collaboration
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: initialise-meeting
---

# Overview - Android

Interactive Live Streaming (ILS) is a low-latency streaming solution designed for real-time engagement at scale. Unlike traditional streaming protocols like HTTP Live Streaming (HLS), which typically have a delay of 15–30 seconds, ILS offers latency as low as 300 milliseconds—making it ideal for experiences that rely on immediate interaction.

While originally designed for meetings, VideoSDK seamlessly adapts to live streaming—supporting 100+ simultaneous hosts/co-hosts (Need more? Contact support@videosdk.live) and 2,000+ real-time viewers (scalable on request). This flexible architecture empowers dynamic events with multiple speakers, performers, or presenters.

ILS is not just about watching—it's about participating. While hosts and co-hosts can interact via audio/video and screen share, the audience consumes the content in real time and engages through interactive features like chat, polls and virtual gifting.

:::info

If you're already using VideoSDK for meetings, throughout this documentation you will learn how to extend its capabilities to support interactive live streaming.
Much of the core structure remains the same, but you'll discover how to adapt roles, scale the audience, and integrate interactive features to build engaging live stream experiences—all using the familiar tools and APIs you're used to.

:::

### Key Benefits:

- `Ultra-low latency`: Sub-second delivery for seamless interaction

- `Multiple host support`: Up to 100 simultaneous broadcasters

- `Scalable viewer capacity`: Handle up to 2,000 real-time audience members

- `Interactive tools`: Chat, polls, virtual gifts, hand raise, and more

- `Cross-platform compatibility`: Works across mobile, web, and desktop

<div style={{ textAlign: 'center' }}>
    <img
        src="https://cdn.videosdk.live/docs/images/android/ils/overview.png"
        alt="Waiting Screen"
         style={{height: '450px'}}
    />
</div>

### When to Use ILS?

Use Interactive Live Streaming when you need to:

- Run virtual events with multiple speakers
- Engage your audience actively during webinars
- Host fitness or coaching sessions with feedback
- Stream concerts, shows, or ceremonies with real-time reactions
- Organize town halls, investor calls, or product launches
- Facilitate audio rooms for casual or topic-based discussions
- Power social experiences like live meetups, talent shows, or community hangouts

:::info

If your requirement is strictly one-way broadcasting where interactivity is minimal and latency isn't critical (e.g., sports highlights, pre-recorded shows), http live streaming (HLS) may be more appropriate. To learn more about HLS, go through the [documentation](/android/guide/interactive-live-streaming/integrate-hls/overview).

:::


---

---
title: Display Attendees Count - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: Interactive Livestream features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Display Attendees Count
pagination_label: Display Attendees Count
keywords:
  - Start HLS meeting
  - Stop HLS meeting
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: display-attendees-count
---

# Display Attendees Count - Android

In this guide, we will see how you can display the number of attendees in realtime.

:::note
Before going forward in this guide, do make sure all the attendees join the meeting with mode as `SIGNALLING_ONLY`
:::

- We will get the all the `participants` except local participant using `getParticipants()` method of the the `Meeting` class. With all the participants, we will filter out participants who have joined as a `SIGNALLING_ONLY` and then display that count.

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
private fun showViewerCount() {
    var viewerCount = 1  // start with 1 to count local participant
    val participants = meeting!!.participants
    for (entry: Map.Entry<String, Participant> in participants.entries) {
        val participant = entry.value
        if (participant.mode == "SIGNALLING_ONLY") {
            viewerCount++
        }
    }
    this.viewerCount!!.text = viewerCount.toString()
}
```

</TabItem>

<TabItem value="Java">

```js
private void showViewerCount() {
    int viewerCount = 1; // start with 1 to count local participant
    Map<String, Participant> participants = meeting.getParticipants();
    for (Map.Entry<String, Participant> entry : participants.entrySet()) {
        Participant participant = entry.getValue();
        if (participant.getMode().equals("SIGNALLING_ONLY")) {
            viewerCount++;
        }
    }
    this.viewerCount.setText(String.valueOf(viewerCount));
}
```

</TabItem>

</Tabs>

## API Reference

The API references for all the methods utilized in this guide are provided below.

- [getparticipants()](/android/api/sdk-reference/meeting-class/properties#getparticipants)


---

---
title: Invite Guest on Stage - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: Interactive Livestream features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Invite Guest on Stage
pagination_label: Invite Guest on Stage
keywords:
  - Start HLS meeting
  - Stop HLS meeting
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: invite-guest-on-stage
---

# Invite Guest on Stage - Android

In this guide, we will see how you can request a viewer to join your livestream by using the `changeMode()`.

import CautionMessage from '@site/src/theme/CautionMessage';

<CautionMessage sdk="Android SDK" version="v0.2.0" />

Let's first have a look at how we will be using the `PubSub` mechanism to acheive the requesting and switching of the participant's mode.

![invite-guest-pubsub](https://cdn.videosdk.live/website-resources/docs-resources/invite_guest_pubsub.png)

:::note
Before going forward in this guide, do make sure all the attendees join the meeting with mode as `SIGNALLING_ONLY` and the host joins with mode as `SEND_AND_RECV`
:::

### Step 1: Loading Viewer List

The host will see a list of participants who have joined as `SIGNALLING_ONLY` along with a button that, when selected, will invite that user to join the livestream.

Here we are using `RecyclerView` to display viewer list with button.

```xml title="layout_viewers_list_view.xml"
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical"
    android:background="#2B3034"
    android:id="@+id/layout_participants">

    <TextView
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_gravity="center"
        android:paddingVertical="15sp"
        android:text="Viewer List"
        android:textSize="20sp"
        android:textColor="@color/white"/>

    <androidx.recyclerview.widget.RecyclerView
        android:id="@+id/rvViewersLinearView"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:paddingHorizontal="15sp" />

</LinearLayout>
```

```xml title="item_viewer_list_layout.xml"
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="wrap_content"
    android:layout_marginBottom="10dp"
    android:gravity="center"
    android:orientation="horizontal"
    android:padding="12dp">


    <TextView
        android:id="@+id/viewerName"
        android:layout_width="0dp"
        android:layout_height="wrap_content"
        android:layout_weight="1"
        android:textSize="20sp"
        android:textColor="@color/white"/>

    <Button
        android:id="@+id/btnRequest"
        android:layout_width="0dp"
        android:layout_height="wrap_content"
        android:layout_weight="1"
        android:text="Request to join Stage"
        android:textAllCaps="false" />


</LinearLayout>
```

- Create a recycler view adapter named `ViewerListAdapter` which will show the viewer list. Create `PeerViewHolder` in the adapter which will extend `RecyclerView.ViewHolder`.

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
class ViewerListAdapter(items: ArrayList<Participant?>?, private val meeting: Meeting) :
    RecyclerView.Adapter<ViewerListAdapter.ViewHolder?>() {
    private var viewers = ArrayList<Participant?>()

    init {
      viewers.addAll(items!!)

      //highlight-next-line
      // adding Meeting Event listener to get the participant join/leave and panticipant mode change event in the meeting.
      meeting.addEventListener(object : MeetingEventListener() {
        override fun onParticipantJoined(participant: Participant) {
            super.onParticipantJoined(participant)
            viewers = ArrayList()
            viewers.addAll(allViewers)
            notifyDataSetChanged()
        }

        override fun onParticipantLeft(participant: Participant) {
            super.onParticipantLeft(participant)
            viewers = ArrayList()
            viewers.addAll(allViewers)
            notifyDataSetChanged()
        }

        override fun onParticipantModeChanged(data: JSONObject) {
            viewers = ArrayList()
            viewers.addAll(allViewers)
            notifyDataSetChanged()
        }
      })
    }

    private val allViewers: ArrayList<Participant?>
        private get() {
            val viewerList: ArrayList<Participant?> = ArrayList()
            val participants: Iterator<Participant> = meeting.participants.values.iterator()
            for (i in 0 until meeting.participants.size) {
                val participant = participants.next()
                //highlight-start
                if (participant.mode == "SIGNALLING_ONLY") {
                    viewerList.add(participant)
                }
                //highlight-end
            }
            return viewerList
        }

    override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): ViewHolder {
        return ViewHolder(
            LayoutInflater.from(parent.context)
                .inflate(R.layout.item_viewer_list_layout, parent, false)
        )
    }

    override fun onBindViewHolder(holder: ViewHolder, position: Int) {
        val participant = viewers[position]
        holder.viewerName.text = viewers[position]!!.displayName
    }

    override fun getItemCount(): Int {
        return viewers.size
    }

    class ViewHolder(itemView: View) : RecyclerView.ViewHolder(itemView) {
        var viewerName: TextView
        var btnRequest: Button

        init {
            viewerName = itemView.findViewById(R.id.viewerName)
            btnRequest = itemView.findViewById(R.id.btnRequest)
        }
    }
}
```

</TabItem>

<TabItem value="Java">

```js
public class ViewerListAdapter extends RecyclerView.Adapter<ViewerListAdapter.ViewHolder> {
    private ArrayList<Participant> viewers = new ArrayList<>();
    private Meeting meeting;

    public ViewerListAdapter(ArrayList<Participant> items, Meeting meeting) {
      this.meeting = meeting;
      viewers.addAll(items);

      //highlight-next-line
      // adding Meeting Event listener to get the participant join/leave and panticipant mode change event in the meeting.
      meeting.addEventListener(new MeetingEventListener() {
        @Override
        public void onParticipantJoined(Participant participant) {
            super.onParticipantJoined(participant);
            viewers = new ArrayList<>();
            viewers.addAll(getAllViewers());
            notifyDataSetChanged();
        }

        @Override
        public void onParticipantLeft(Participant participant) {
            super.onParticipantLeft(participant);
            viewers = new ArrayList<>();
            viewers.addAll(getAllViewers());
            notifyDataSetChanged();
        }

        @Override
        public void onParticipantModeChanged(JSONObject data) {
            viewers = new ArrayList<>();
            viewers.addAll(getAllViewers());
            notifyDataSetChanged();
        }
      });

    }

    private ArrayList<Participant> getAllViewers() {
        ArrayList<Participant> viewerList = new ArrayList();
        Iterator<Participant> participants = meeting.getParticipants().values().iterator();

        for (int i = 0; i < meeting.getParticipants().size(); i++) {
            //highlight-start
            final Participant participant = participants.next();
            if (participant.getMode().equals("SIGNALLING_ONLY")) {
                viewerList.add(participant);
            }
            //highlight-end
        }
        return viewerList;
    }

    @NonNull
    @Override
    public ViewHolder onCreateViewHolder(@NonNull ViewGroup parent, int viewType) {
        return new ViewHolder(LayoutInflater.from(parent.getContext()).inflate(R.layout.item_viewer_list_layout, parent, false));
    }

    @Override
    public void onBindViewHolder(@NonNull ViewHolder holder, int position) {
        final Participant participant = viewers.get(position);
        holder.viewerName.setText(viewers.get(position).getDisplayName());
    }

    @Override
    public int getItemCount() {
        return viewers.size();
    }

    static class ViewHolder extends RecyclerView.ViewHolder {
        TextView viewerName;
        Button btnRequest;

        public ViewHolder(@NonNull View itemView) {
            super(itemView);
            viewerName = itemView.findViewById(R.id.viewerName);
            btnRequest = itemView.findViewById(R.id.btnRequest);
        }
    }

}
```

</TabItem>

</Tabs>

- Set this adapter to `RecyclerView`

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
btnViewerList.setOnClickListener { openViewerList() }

fun openViewerList() {
  val viewerListView: RecyclerView
  val bottomSheetDialog = BottomSheetDialog(mContext!!)
  val layout_participants = findViewById(R.id.layout_participants)
  val v3 = LayoutInflater.from(mContext)
      .inflate(R.layout.layout_viewers_list_view, layout_participants)
  bottomSheetDialog.setContentView(v3)
  viewerListView = v3.findViewById(R.id.rvViewersLinearView)
  viewerListView.minimumHeight = 400
  bottomSheetDialog.show()
  val viewerList: ArrayList<*> = ArrayList<Any?>()
  val participants: Iterator<Participant> = meeting!!.participants.values.iterator()
  for (i in 0 until meeting!!.participants.size) {
      val participant = participants.next()
      //highlight-start
      if (participant.mode == "SIGNALLING_ONLY")
        viewerList.add(participant)
      //highlight-end
  }
  viewerListView.layoutManager = LinearLayoutManager(mContext)
  //highlight-next-line
  viewerListView.adapter = ViewerListAdapter(viewerList, meeting!!)
  viewerListView.setHasFixedSize(true)
}
```

</TabItem>

<TabItem value="Java">

```js
btnViewerList.setOnClickListener(v -> openParticipantList());

public void openViewerList() {
  RecyclerView viewerListView;
  BottomSheetDialog bottomSheetDialog = new BottomSheetDialog(mContext);
  LinearLayout layout_participants = findViewById(R.id.layout_participants);
  View v3 = LayoutInflater.from(mContext).inflate(R.layout.layout_viewers_list_view, layout_participants);
  bottomSheetDialog.setContentView(v3);
  viewerListView = v3.findViewById(R.id.rvViewersLinearView);
  viewerListView.setMinimumHeight(400);
  bottomSheetDialog.show();

  ArrayList viewerList = new ArrayList();
  final Iterator<Participant> participants = meeting.getParticipants().values().iterator();
  for (int i = 0; i < meeting.getParticipants().size(); i++) {
      final Participant participant = participants.next();
      //highlight-start
      if (participant.getMode().equals("SIGNALLING_ONLY"))
          viewerList.add(participant);
      //highlight-end
  }
  viewerListView.setLayoutManager(new LinearLayoutManager(mContext));
  //highlight-next-line
  viewerListView.setAdapter(new ViewerListAdapter(viewerList, meeting));
  viewerListView.setHasFixedSize(true);
}

```

</TabItem>

</Tabs>

<center>

<img style={{height: '450px'}} src="https://cdn.videosdk.live/website-resources/docs-resources/android_stage_request.jpg" />

</center>

### Step 2: Requesting a Viewer to Join Livestream

We have a Viewer list ready. Now, let us handle the click event for the `btnRequest`.

We will be using `CHANGE_MODE_ + participantId` as the topic for PubSub.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
override fun onBindViewHolder(holder: ViewHolder, position: Int) {
  //...

  holder.btnRequest.setOnClickListener { v: View? ->
    val pubSubPublishOptions = PubSubPublishOptions()
    pubSubPublishOptions.isPersist = false
    //highlight-start
    meeting.pubSub.publish(
        "CHANGE_MODE_" + participant!!.id,
        participant.id,
        pubSubPublishOptions
    )
    //highlight-end
  }
}
```

</TabItem>

<TabItem value="Java">

```js
@Override
public void onBindViewHolder(@NonNull ViewHolder holder, int position) {
  //...

  holder.btnRequest.setOnClickListener(v -> {
    PubSubPublishOptions pubSubPublishOptions = new PubSubPublishOptions();
    pubSubPublishOptions.setPersist(false);
    //highloght-next-line
    meeting.pubSub.publish("CHANGE_MODE_"+ participant.getId(), participant.getId(), pubSubPublishOptions);
  });
}
```

</TabItem>

</Tabs>

### Step 3: Showing Viewer Request Dialog

After implementing the Host requesting viewer to join the livestream, let's display the viewer's request dialogue and switch the `SIGNALLING_ONLY` mode to `SEND_AND_RECV`.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
meeting!!.addEventListener(object : MeetingEventListener() {
  override fun onMeetingJoined() {
    val changeModeListener =
      PubSubMessageListener { pubSubMessage: PubSubMessage ->
          if (pubSubMessage.message == meeting!!.localParticipant.id) {
              showRequestDialog(pubSubMessage.senderName)
          }
      }
    //highlight-next-line
    meeting!!.pubSub.subscribe("CHANGE_MODE_" + meeting!!.localParticipant.id, changeModeListener)
  }
})

private fun showRequestDialog(name: String) {
    val builder = AlertDialog.Builder(
        mContext!!
    )
    builder.setMessage("$name has request you to go on stage")
    builder.setTitle("Change mode Request")
    builder.setCancelable(false)
    builder.setPositiveButton("Yes") { dialog: DialogInterface, _: Int ->
        //highlight-next-line
        meeting!!.changeMode("SEND_AND_RECV")
        //...
        dialog.dismiss()
    }
    builder.setNegativeButton(
        "No"
    ) { dialog: DialogInterface, which: Int -> dialog.dismiss() }
    val alertDialog = builder.create()
    alertDialog.show()
}

```

</TabItem>

<TabItem value="Java">

```js
meeting.addEventListener(new MeetingEventListener() {
  @Override
  public void onMeetingJoined() {
    PubSubMessageListener changeModeListener = pubSubMessage -> {
        if (pubSubMessage.getMessage().equals(meeting.getLocalParticipant().getId())) {
            showRequestDialog(pubSubMessage.getSenderName());
        }
    };
    //highlight-next-line
    meeting.pubSub.subscribe("CHANGE_MODE_"+ meeting.getLocalParticipant().getId(), changeModeListener);
  }
}

private void showRequestDialog(String name) {
  AlertDialog.Builder builder = new AlertDialog.Builder(mContext);
  builder.setMessage(name + " has request you to go on stage");
  builder.setTitle("Change mode Request");
  builder.setCancelable(false);

  builder.setPositiveButton("Yes", (dialog, which) -> {
      //highlight-next-line
      meeting.changeMode("SEND_AND_RECV");
      //...
      dialog.dismiss();
  });

  builder.setNegativeButton("No", (dialog, which) -> {
      dialog.dismiss();
  });

  AlertDialog alertDialog = builder.create();
  alertDialog.show();
}
```

</TabItem>

</Tabs>

<center>

<img style={{height: '450px'}} src="https://cdn.videosdk.live/website-resources/docs-resources/android_stage_request_dialog.jpg" />

</center>

### Step 4: Pin the participant

We need to pin the participant so that he/she can appears on the livestream. To achieve this, we will listen to the callback on the `onParticipantModeChanged` of `Meeting` class.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
class ParticipantListAdapter(
    items: ArrayList<Participant?>?,
    private val meeting: Meeting,
    private val context: Context
) : RecyclerView.Adapter<ParticipantListAdapter.ViewHolder>() {
  // ...

 init {
    //...
    meeting.addEventListener(object : MeetingEventListener() {
      override fun onParticipantJoined(participant: Participant) {
          //...
      }

      override fun onParticipantLeft(participant: Participant) {
         // ...
      }

      //highlight-start
      override fun onParticipantModeChanged(data: JSONObject) {
        //...
         val participant = meeting.participants[data.getString("participantId")]
          if (data.getString("mode") == "SEND_AND_RECV") {
              participant!!.pin("SHARE_AND_CAM")
          } else {
              participant!!.unpin("SHARE_AND_CAM")
          }
      }
      //highlight-end
    })
  }

  //...
  class ViewHolder(itemView: View) : RecyclerView.ViewHolder(itemView) {
      //...
  }
}
```

</TabItem>

<TabItem value="Java">

```js
public class ParticipantListAdapter extends RecyclerView.Adapter<ParticipantListAdapter.ViewHolder> {
    // ...

  public ParticipantListAdapter(ArrayList<Participant> items, Meeting meeting, Context context) {
    //...
    meeting.addEventListener(new MeetingEventListener() {
      @Override
      public void onParticipantJoined(Participant participant) {
        //...
      }

      @Override
      public void onParticipantLeft(Participant participant) {
        //...
      }

      //highlight-start
      @Override
      public void onParticipantModeChanged(JSONObject data) {
        //...
        Participant participant = meeting.getParticipants().get(data.getString("participantId"));
        if (data.getString("mode").equals("SEND_AND_RECV"))
        {
          participant.pin("SHARE_AND_CAM");
        }else
        {
          participant.unpin("SHARE_AND_CAM");
        }
      }
      //highlight-end
    });

  }

  //...
  static class ViewHolder extends RecyclerView.ViewHolder {
      //...
  }
}
```

</TabItem>

</Tabs>

import ReactPlayer from 'react-player'

<div style={{textAlign: 'center'}}>

<ReactPlayer muted controls url="https://cdn.videosdk.live/website-resources/docs-resources/android_stage_request_demo.mp4" height="500px" width={"100%"} />

</div>

<br/>

## API Reference

The API references for all the methods utilized in this guide are provided below.

- [Meeting](/android/api/sdk-reference/meeting-class/introduction)
- [pubSub](/android/guide/video-and-audio-calling-api-sdk/collaboration-in-meeting/pubsub)
- [onParticipantModeChanged()](/android/api/sdk-reference/meeting-class/meeting-event-listener-class#onparticipantmodechanged)


---

---
title: Manage On-Screen Participants - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: Interactive Livestream features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Manage On-Screen Participants
pagination_label: Manage On-Screen Participants
keywords:
  - Start HLS meeting
  - Stop HLS meeting
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: manage-on-screen-participants
---

# Manage On-Screen Participants - Android

It is important that only the necessary person are present on the screen when livestream is on. To handle this, we will be using the `pin` and `unpin` methods of the `Participant` class.

:::note
To ensure only the hosts/speakers are shown in the grid, you should use the `SPOTLIGHT` layout and `pin` as the priority when starting the interactive livestream.
:::

Let us first explore two methods that we will be using to manage on-screen participants.

### `pin()`

With these method you can pin any participant's Camera, Screen Share or both. This can be useful to identify the participants based on which you can perform rendering participant grid.

### `unpin()`

With these methods you can unpin any participant's Camera, Screen Share or both. This can be useful to reset pin state of the participant.

import CautionMessage from '@site/src/theme/CautionMessage';


<CautionMessage sdk="Android SDK" version="v0.2.0" />

### Managing On-Screen Participants

1. If you want to pin all the hosts/speakers automatically, you can do it by listenting to the `onMeetingJoined` callback and `onParticipantModeChanged`, where you can `pin` and `unpin` based on the mode.

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
private val meetingEventListener: MeetingEventListener = object : MeetingEventListener() {
  override fun onMeetingJoined() {
        //highlight-start
        val localParticipant = meeting!!.localParticipant
        //We will pin the participant if mode is SEND_AND_RECV
        if (localParticipant.mode == "SEND_AND_RECV") {
            localParticipant.pin()
        } else {
            localParticipant.unpin()
        }
        //highlight-end
   }

  override fun onParticipantModeChanged(data: JSONObject) {
    //highlight-start
    val localParticipant = meeting!!.localParticipant
    //We will pin the participant if mode is SEND_AND_RECV else unpin him
    if(localParticipant.id.equals(data.getString("peerId"))
    {
        if(localParticipant.mode == "SEND_AND_RECV")
        {
            localParticipant.pin()
        }else{
            localParticipant.unpin()
        }
    }
    //highlight-end
  }
}

override fun onCreate(savedInstanceState: Bundle?) {
  //...

  // add listener to meeting
  //highlight-next-line
  meeting!!.addEventListener(meetingEventListener)
}
```

</TabItem>

<TabItem value="Java">

```js
private final MeetingEventListener meetingEventListener = new MeetingEventListener() {
  @Override
  public void onMeetingJoined() {
    //highlight-start
    Participant localParticipant = meeting.getLocalParticipant();
    //We will pin the participant if mode is SEND_AND_RECV
    if (localParticipant.getMode() == "SEND_AND_RECV") {
        localParticipant.pin();
    } else {
        localParticipant.unpin();
    }
    //highlight-end
  }

  @Override
  public void onParticipantModeChanged(JSONObject data) {
    //highlight-start
    Participant localParticipant = meeting.getLocalParticipant();
    //We will pin the participant if mode is SEND_AND_RECV else unpin him
    if(localParticipant.getId().equals(data.getString("peerId"))
    {
        if(localParticipant.getMode() == "SEND_AND_RECV")
        {
            localParticipant.pin();
        }else{
            localParticipant.unpin();
        }
    }
    //highlight-end
  }
};

@Override
protected void onCreate(Bundle savedInstanceState) {
  //...

  // add listener to meeting
  //highlight-next-line
  meeting.addEventListener(meetingEventListener);
}
```

</TabItem>

</Tabs>

2. When rendering the participant grid on the Speaker side, make sure to show only the participants who are in `SEND_AND_RECV` mode. You can filter the participants as shown in below example.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
 private fun getSpeakerList(): List<Participant?>? {
    val speakerList: MutableList<Participant?> = ArrayList()
    val participants = meeting!!.participants
    for (entry: Map.Entry<String, Participant> in participants.entries) {
        val participant = entry.value
        if (participant.mode == "SEND_AND_RECV") {
            speakerList.add(participant)
        }
    }
    return speakerList
}
```

</TabItem>

<TabItem value="Java">

```js
private List<Participant> getSpeakerList() {
    List<Participant> speakerList = new ArrayList();
    Map<String, Participant> participants = meeting.getParticipants();
    for (Map.Entry<String, Participant> entry : participants.entrySet()) {
        Participant participant = entry.getValue();
        if (participant.getMode().equals("SEND_AND_RECV")) {
            speakerList.add(participant);
        }
    }
    return speakerList;
}
```

</TabItem>

</Tabs>

## API Reference

The API references for all the methods utilized in this guide are provided below.

- [pin](/android/api/sdk-reference/participant-class/methods#pin)
- [unpin](/android/api/sdk-reference/participant-class/methods#unpin)


---

---
title: Manage Roles - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: Interactive Livestream features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Manage Roles
pagination_label: Manage Roles
keywords:
  - Start HLS meeting
  - Stop HLS meeting
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: manage-roles
---

# Manage Roles - Android

## Roles with VideoSDK

When doing interactive live streaming maintaining the role of users is quite important. To help manage these roles better, VideoSDK allows a participant with two types of modes:

**`1. SEND_AND_RECV`** When a participant is joining with mode set to `SEND_AND_RECV`, we will be able to **publish and consume the media** of other participants and also interact with them using the features like chat, poll etc.

**`2. SIGNALLING_ONLY`** When a participant is joining with mode set to `SIGNALLING_ONLY`, that participant is **not allowed to publish or consume any media** from other participants. Although they can interact with other participants using chat, polls etc.

import CautionMessage from '@site/src/theme/CautionMessage';


<CautionMessage sdk="Android SDK" version="v0.2.0" />

**_This image is for education purpose_**

![manage-roles](https://cdn.videosdk.live/website-resources/docs-resources/meeting_modes.jpg)

## When to use the Roles?

##### 1. Simple Adaptive Streaming

- Simple Adaptive Streaming (SAS) is a type of livestreaming that requires minimal interaction between the host and viewers.

- It is particularly useful for events with a large number of viewers who prefer not to engage with the host.

- In SAS, each speaker attends a VideoSDK meeting in `SEND_AND_RECV` mode, while viewers can simply watch the livestream using the `playbackHlsUrl` or `livestreamUrl`. Unlike the speakers, viewers do not need to join the meeting in `SEND_AND_RECV` or `SIGNALLING_ONLY` mode. This allows for a seamless streaming experience without any unnecessary interruptions or distractions.
  - `playbackHlsUrl` - Live HLS with playback support
  - `livestreamUrl` - Live HLS without playback support

:::note
`downstreamUrl` is now depecated. Use `playbackHlsUrl` or `livestreamUrl` in place of `downstreamUrl`
:::

**_This video is for education purpose_**

import ReactPlayer from 'react-player'

<div style={{textAlign: 'center'}}>

<ReactPlayer autoplay muted loop playing controls url="https://cdn.videosdk.live/website-resources/docs-resources/react_simple_ils.mp4" height="500px" width={"100%"} />

</div>

##### 2. Adaptive Streaming with increased engagement

- If you're looking to increase engagement with your audience during a live streaming event, consider using Adaptive Streaming technology. With this approach, you can incorporate interactive features such as polls and conversations, and give viewers the ability to join and leave the livestream as the host decides.

- To set this up, have all speakers join as `SEND_AND_RECV` mode participants, while the audience joins as `SIGNALLING_ONLY` mode participants. This way, everyone can participate in the interactive elements of the live stream and create a more dynamic and engaging experience for all.

**_This video is for education purpose_**

<div style={{textAlign: 'center'}}>

<ReactPlayer autoplay muted loop playing controls url="https://cdn.videosdk.live/website-resources/docs-resources/react_livestream_interaction_1.mp4" height="500px" width={"100%"} />

</div>

## Using roles

When you initialize the meeting, you can set the mode of Participant.

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
class MainActivity : AppCompatActivity() {

  fun getToken(): String? {
    //highlight-next-line
    ...
  }

  fun getMeetingId(token: String?): String? {
    //highlight-next-line
    ...
  }

 override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    setContentView(R.layout.activity_main)

    //We will fetch token and meetingId and store it in local variables
    val token: String = getToken()
    val meetingId = getMeetingId(token)

    // initialize the VideoSDK
    VideoSDK.initialize(this@MainActivity)

    // set token property of VideoSDK
    VideoSDK.config(token)

    // highlight-start
    // create a new meeting instance
    val meeting: Meeting = VideoSDK.initMeeting(
        this@MainActivity, meetingId, "NAME HERE",
        true, true, null,
        //highlight-next-line
        "SEND_AND_RECV", // allowed: SEND_AND_RECV | SIGNALLING_ONLY | RECV_ONLY
        false,
        null,
        null
    )
    // highlight-end

    Log.d("VideoSDK", "onCreate: $meetingId")
  }
}
```

</TabItem>

<TabItem value="Java">

```java
public class MainActivity extends AppCompatActivity {

  public String getToken()
  {
    //highlight-next-line
    ...
  }

  public String getMeetingId(String token) {
    //highlight-next-line
    ...
  }

  @Override
  protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);

    //We will fetch token and meetingId and store it in local variables
    String token = getToken();
    String meetingId = getMeetingId(token);

    // initialize the VideoSDK
    VideoSDK.initialize(MainActivity.this);

    // set token property of VideoSDK
    VideoSDK.config(token);

    // highlight-start
    // create a new meeting instance
    Meeting meeting = VideoSDK.initMeeting(
            MainActivity.this, meetingId, "NAME HERE",
            true, true, null,
            //highlight-next-line
            "SEND_AND_RECV", // allowed: SEND_AND_RECV | SIGNALLING_ONLY | RECV_ONLY
            false,
            null,
            null,
    );
    // highlight-end

    Log.d("VideoSDK", "onCreate: " + meetingId);
  }
}
```

</TabItem>

</Tabs>

## Getting Participant Mode

You can identify the participants role by using `mode` property from `Participant` class.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
override fun onCreate(savedInstanceState: Bundle?) {
  //...

  val localParticipant = meeting!!.localParticipant
  //highlight-next-line
  Log.d("VideoSDK", "Participant mode : " + localParticipant.mode)
}
```

</TabItem>

<TabItem value="Java">

```js
@Override
protected void onCreate(Bundle savedInstanceState) {
  //...

  Participant localParticipant = meeting.getLocalParticipant();
  //highlight-next-line
  Log.d("VideoSDK", "Participant mode : " + participant.getMode());
}
```

</TabItem>

</Tabs>

## Changing Participant's Mode

Let's say you are hosting a livestream and you want one of your viewer to join the livestream with you. In this case you can change the mode of the participant using the `changeMode()` of the `Meeting` class.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
findViewById<View>(R.id.btnConferenceMode).setOnClickListener { view: View? ->
    // change mode to SEND_AND_RECV
    //highlight-next-line
    meeting!!.changeMode("SEND_AND_RECV")
}

findViewById<View>(R.id.btnViewerMode).setOnClickListener { view: View? ->
    // change mode to SIGNALLING_ONLY
    //highlight-next-line
    meeting!!.changeMode("SIGNALLING_ONLY")
}
```

</TabItem>

<TabItem value="Java">

```js
findViewById(R.id.btnConferenceMode).setOnClickListener(view -> {
    // change mode to SEND_AND_RECV
    //highlight-next-line
    meeting.changeMode("SEND_AND_RECV");
});

findViewById(R.id.btnViewerMode).setOnClickListener(view -> {
    // change mode to SIGNALLING_ONLY
    //highlight-next-line
   meeting.changeMode("SIGNALLING_ONLY");
});
```

</TabItem>

</Tabs>

## API Reference

The API references for all the methods utilized in this guide are provided below.

- [Meeting](/android/api/sdk-reference/meeting-class/introduction)
- [Participant](/android/api/sdk-reference/participant-class/introduction)
- [changeMode()](/android/api/sdk-reference/meeting-class/methods#changemode)


---

---
title: Interactive Livestream - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: Interactive Livestream features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Overview
pagination_label: Overview
keywords:
  - Start HLS meeting
  - Stop HLS meeting
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: overview
---

# Interactive Livestream (HLS) - Android

### What is Interactive Livestream (HLS)?

Interactive live streaming (HLS) refers to a type of live streaming where viewers can actively engage with the content being streamed and with other viewers in real-time.

In an interactive live stream (HLS), viewers can take part in a variety of activities like live polling, Q&A sessions, and even sending virtual gifts to the content creator or each other.

### What is Adaptive Live Streaming?

Livestream experience is important while undertaking interactive live streaming in order to increase audience. To do this, the livestream should be able to respond to the viewer's network bandwidth, and change the stream's resolution as necessary. Therefore, adaptive live streaming refers to a feed that automatically adjusts to a lower or higher resolution dependent on the user's preferences.

### What is Latency?

Latency is the delay between capturing video content and its playback. Key factors that affecting latency :

- **Buffering**: Balance buffer size for smoother playback against latency.
- **Network Conditions**: Efficient servers and network health contribute to lower latency.

Standard HLS has a latency around 5-6 seconds.

### HLS Architecture of VideoSDK

<center>

<img src='https://cdn.videosdk.live/website-resources/docs-resources/mobile_hls.png' />

</center>

When a host starts the interactive live stream, VideoSDK will use a default theme or user specified template to compose and encode a live stream which will be delivered to the viewers through a `M3U8` video file which can be played directly on the viewer end which will adapt to the viewer's network bandwidth.

When using VideoSDK for interactive live stream, you get multiple types of URLs which you can use based on your requirements.

**`1. Standard Streaming:`** This type of streaming is where the user is not allowed to go back in the live and can just stream it.

**`2. Rolling Playback:`** This type of streaming is where the user is allowed to do rewind and do a playback of the complete stream.

**`3. VoD Playback`** With this, users can playback the complete live stream on demand whenever needed.

### Using HLS with VideoSDK

You can use HLS with VideoSDK in two different ways.

#### 1. Simple Adaptive Streaming

When we talk about simple adaptive streaming, we imply that there is hardly any interaction between the hosts and the viewers.

These livestreams are helpful when there are a lot of viewers, and they don't want to engage with the host. In this scenario, every presenter attends a VideoSDK meeting, while every viewer only watches the livestream.

**_This video is for education purpose_**

import ReactPlayer from 'react-player'

<div style={{textAlign: 'center'}}>

<ReactPlayer autoplay muted loop playing controls url="https://cdn.videosdk.live/website-resources/docs-resources/react_simple_ils.mp4" height="500px" width={"100%"} />

</div>

#### 2. Adaptive Streaming with increased engagement

When you want to communicate with your audience by enabling polls, conversations, and the ability for viewers to join and leave the livestream based on the host's decision, adaptive streaming with enhanced engagement will be the best fit for you.

In this scenario, both the host and the viewer will have to join a VideoSDK meeting with different roles. To learn more about the roles [follow these guide.](../handling-participants/manage-roles)

**_This video is for education purpose_**

<div style={{textAlign: 'center'}}>

<ReactPlayer autoplay muted loop playing controls url="https://cdn.videosdk.live/website-resources/docs-resources/react_livestream_interaction_2.mp4" height="500px" width={"100%"} />

</div>


---

---
title: Setup HLS Player | Video SDK
hide_title: true
hide_table_of_contents: false
description: Using VideoSDK to do the interactive livestreaming.
sidebar_label: Setup HLS Player
pagination_label: Setup HLS Player
keywords:
  - audio calling
  - video calling
  - real-time communication
  - interactive live streaming
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: setup-hls-player
---

# Setup HLS Player - Android

In this guide, we will add player which will be responsible for playing the HLS stream.
Before starting this guide, make sure you have a VideoSDK meetings setup allowing you to join the room. To learn more about setting up a VideoSDK meeting, follow this [quick start guide](/android/guide/video-and-audio-calling-api-sdk/quick-start).

To play the HLS stream we will be using the [Exoplayer](https://github.com/google/ExoPlayer) library.

### `1. Setup player into your project`

**`Step 1:`** Let's first add ExoPlayer module dependency into the project.

```js title="app/build.gradle"
dependencies {
  implementation 'com.google.android.exoplayer:exoplayer:2.18.5'
  // other app dependencies
  }
```

**`Step 2:`** Now let's add the `StyledPlayerView` which will display livestreaming. And also add the `TextView` which will be shown when there is no active HLS. For these, we will use the `onHlsStateChanged` event from the `MeetingEventListener` abstract class to identify if there is an active HLS.

```xml title="activity_viewer.xml"
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent">

    <TextView
        android:id="@+id/waitingLayout"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:text="Waiting for host \n to start the live streaming"
        android:textFontWeight="700"
        android:textSize="20sp"
        android:gravity="center"/>

    <com.google.android.exoplayer2.ui.StyledPlayerView
        android:id="@+id/player_view"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:visibility="gone"
        app:resize_mode="fixed_width"
        app:show_buffering="when_playing"
        app:show_subtitle_button="false"
        app:use_artwork="false"
        app:show_next_button="false"
        app:show_previous_button="false"
        app:use_controller="true"/>

</LinearLayout>
```

### `2. Initialize player and Playing HLS stream`

**`Step 1:`** Now that player is setup, let's initialize player and play the HLS once it becomes playable. For these, we will get the `playbackHlsUrl` and `livestreamUrl` when the `onHlsStateChanged` event of `MeetingEventListener` state changes to `HLS_PLAYABLE`.

- when you receive `HLS_PLAYABLE` status you will receive 2 urls
  - `playbackHlsUrl` - Live HLS with playback support
  - `livestreamUrl` - Live HLS without playback support

:::note
`downstreamUrl` is now depecated. Use `playbackHlsUrl` or `livestreamUrl` in place of `downstreamUrl`
:::

**`Step 2:`** We also need to release player and show `TextView` which shows there is no active HLS. We will release player when the `onHlsStateChanged` event of `MeetingEventListener` state changes to `HLS_STOPPED`.

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js title="ViewerActivity.kt"
class ViewerActivity : AppCompatActivity() {
    private val meeting: Meeting? = null
    private var playerView: StyledPlayerView? = null
    private var waitingLayout: TextView? = null
    private var player: ExoPlayer? = null
    private var dataSourceFactory: DefaultHttpDataSource.Factory? = null
    private val startAutoPlay = true
    private var playbackHlsUrl: String? = ""


    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_meeting)
        playerView = findViewById(R.id.player_view)
        waitingLayout = findViewById(R.id.waitingLayout)

        // setup meeting
        //...

        //highlight-next-line
        // add listener to the meeting
        meeting!!.addEventListener(meetingEventListener)
    }

    private val meetingEventListener: MeetingEventListener = object : MeetingEventListener() {
        override fun onMeetingJoined() {
            Log.d("VideoSDK", "onMeetingJoined: ")
        }

        override fun onMeetingLeft() {
            Log.d("VideoSDK", "onMeetingLeft: ")
        }

        //highlight-start
        @RequiresApi(api = Build.VERSION_CODES.P)
        override fun onHlsStateChanged(HlsState: JSONObject) {
            if (HlsState.has("status")) {
                try {
                    if (HlsState.getString("status") == "HLS_PLAYABLE" && HlsState.has("playbackHlsUrl")) {
                        playbackHlsUrl = HlsState.getString("playbackHlsUrl")
                        waitingLayout!!.visibility = View.GONE
                        playerView!!.visibility = View.VISIBLE
                        // initialize player
                        initializePlayer()
                    }
                    if (HlsState.getString("status") == "HLS_STOPPED") {
                        // release the player
                        releasePlayer()
                        playbackHlsUrl = null
                        waitingLayout!!.text = "Host has stopped \n the live streaming"
                        waitingLayout!!.visibility = View.VISIBLE
                        playerView!!.visibility = View.GONE
                    }
                } catch (e: JSONException) {
                    e.printStackTrace()
                }
            }
            //highlight-end
        }
    }

    private fun initializePlayer() {
        if (player == null) {
            dataSourceFactory = DefaultHttpDataSource.Factory()
            val mediaSource = HlsMediaSource.Factory(dataSourceFactory!!).createMediaSource(
                MediaItem.fromUri(Uri.parse(playbackHlsUrl))
            )
            val playerBuilder = ExoPlayer.Builder( /* context= */this@ViewerActivity)
            player = playerBuilder.build()
            // auto play when player is ready
            player!!.playWhenReady = startAutoPlay
            player!!.setMediaSource(mediaSource)
            // if you want display setting for player then remove this line
            playerView!!.findViewById<View>(com.google.android.exoplayer2.ui.R.id.exo_settings).visibility =
                View.GONE
            playerView!!.player = player
        }
        player!!.prepare()
    }

    private fun releasePlayer() {
        if (player != null) {
            player!!.release()
            player = null
            dataSourceFactory = null
            playerView!!.player = null
        }
    }
}
```

</TabItem>

<TabItem value="Java">

```java title="ViewerFragment.java"
public class ViewerActivity extends AppCompatActivity {
    private Meeting meeting;
    protected StyledPlayerView playerView;
    private TextView waitingLayout;
    protected @Nullable
    ExoPlayer player;

    private DefaultHttpDataSource.Factory dataSourceFactory;
    private boolean startAutoPlay = true;
    private String playbackHlsUrl = "";

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_meeting);
        playerView = findViewById(R.id.player_view);
        waitingLayout = findViewById(R.id.waitingLayout);

        // setup meeting
        //...

        //highlight-next-line
        // add listener to the meeting
        meeting.addEventListener(meetingEventListener);
    }

    private final MeetingEventListener meetingEventListener = new MeetingEventListener() {
        @Override
        public void onMeetingJoined() {
            Log.d("VideoSDK", "onMeetingJoined: ");
        }

        @Override
        public void onMeetingLeft() {
            Log.d("VideoSDK", "onMeetingLeft: ");
        }

        //highlight-start
        @RequiresApi(api = Build.VERSION_CODES.P)
        @Override
        public void onHlsStateChanged(JSONObject HlsState) {
            if (HlsState.has("status")) {
                try {
                    if (HlsState.getString("status").equals("HLS_PLAYABLE") && HlsState.has("playbackHlsUrl")) {
                        playbackHlsUrl = HlsState.getString("playbackHlsUrl");
                        waitingLayout.setVisibility(View.GONE);
                        playerView.setVisibility(View.VISIBLE);
                        // initialize player
                        initializePlayer();
                    }
                    if (HlsState.getString("status").equals("HLS_STOPPED")) {
                        // release the player
                        releasePlayer();
                        playbackHlsUrl = null;
                        waitingLayout.setText("Host has stopped \n the live streaming");
                        waitingLayout.setVisibility(View.VISIBLE);
                        playerView.setVisibility(View.GONE);
                    }
                } catch (JSONException e) {
                    e.printStackTrace();
                }
            }
            //highlight-end
        }
    };

    protected void initializePlayer() {
        if (player == null) {
            dataSourceFactory = new DefaultHttpDataSource.Factory();
            HlsMediaSource mediaSource = new HlsMediaSource.Factory(dataSourceFactory).createMediaSource(
                    MediaItem.fromUri(Uri.parse(this.playbackHlsUrl)));

            ExoPlayer.Builder playerBuilder =
                    new ExoPlayer.Builder(/* context= */ ViewerActivity.this);
            player = playerBuilder.build();
            // auto play when player is ready
            player.setPlayWhenReady(startAutoPlay);
            player.setMediaSource(mediaSource);
            // if you want display setting for player then remove this line
            playerView.findViewById(com.google.android.exoplayer2.ui.R.id.exo_settings).setVisibility(View.GONE);
            playerView.setPlayer(player);
        }
        player.prepare();
    }

    protected void releasePlayer() {
        if (player != null) {
            player.release();
            player = null;
            dataSourceFactory = null;
            playerView.setPlayer(/* player= */ null);
        }
    }
}
```

</TabItem>

</Tabs>

With this, the player is setup to play the HLS.

<center>

<img style={{height: '450px',marginRight:'15px'}} src="https://cdn.videosdk.live/website-resources/docs-resources/android_ils_quickstart_viewer_screen_waiting.jpg" />

<img style={{height: '450px'}} src="https://cdn.videosdk.live/website-resources/docs-resources/android_ils_quickstart_viewer_screen.jpg" />

</center>

## API Reference

The API references for all the methods utilized in this guide are provided below.

- [onHlsStateChanged](/android/api/sdk-reference/meeting-class/meeting-event-listener-class#onhlsstatechanged)


---

---
title: Start HLS | Video SDK
hide_title: true
hide_table_of_contents: false
description: Using VideoSDK to do the interactive livestreaming.
sidebar_label: Start HLS
pagination_label: Start HLS
keywords:
  - audio calling
  - video calling
  - real-time communication
  - interactive live streaming
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: start-hls
---

# Start HLS - Android

Before starting the HLS, the prequisite steps require you to have a VideoSDK Meeting running which you want to use for interactive livestream. To learn more about setting up a interactive live streaming, you can follow the steps [here in the quick start guide.](/android/guide/video-and-audio-calling-api-sdk/quick-start-ILS)

## Starting HLS

Once the user has joined the meeting, `startHls()` can be used to start a interactive livestream of the meeting which can be accessed from the `Meeting` class. This method accepts one parameter:

- `config`: This parameter will define how the interactive livestream layout should look like.

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
val config = JSONObject()

//highlight-next-line
// Layout Configuration
val layout = JSONObject()
JsonUtils.jsonPut(layout, "type", "GRID") // "SPOTLIGHT" | "SIDEBAR",  Default : "GRID"
JsonUtils.jsonPut(layout, "priority", "SPEAKER") // "PIN", Default : "SPEAKER"
JsonUtils.jsonPut(layout, "gridSize", 4) // MAX : 25
JsonUtils.jsonPut(config, "layout", layout)

//highlight-next-line
// Theme of interactive livestream layout
JsonUtils.jsonPut(config, "theme", "DARK") //  "LIGHT" | "DEFAULT"

//highlight-next-line
// `mode` is used to either interactive livestream video & audio both or only audio.
JsonUtils.jsonPut(config, "mode", "video-and-audio") // "audio", Default : "video-and-audio"

//highlight-next-line
// Quality of interactive livestream and is only applicable to `video-and-audio` type mode.
JsonUtils.jsonPut(config, "quality", "high") // "low" | "med",  Default : "med"

//highlight-start
// This mode refers to orientation of interactive livestream.
// landscape : Start interactive livestream of the meeting in horizontally
// portrait : Start interactive livestream of the meeting in vertically (Best for mobile view)
//highlight-end
JsonUtils.jsonPut(config, "orientation", "portrait") // "landscape",  Default : "landscape"

meeting!!.startHls(config)
```

</TabItem>

<TabItem value="Java">

```js
JSONObject config = new JSONObject();

//highlight-next-line
// Layout Configuration
JSONObject layout = new JSONObject();
JsonUtils.jsonPut(layout, "type", "GRID"); // "SPOTLIGHT" | "SIDEBAR",  Default : "GRID"
JsonUtils.jsonPut(layout, "priority", "SPEAKER");  // "PIN", Default : "SPEAKER"
JsonUtils.jsonPut(layout, "gridSize", 4); // MAX : 25
JsonUtils.jsonPut(config, "layout", layout);

//highlight-next-line
// Theme of interactive livestream layout
JsonUtils.jsonPut(config, "theme", "DARK"); //  "LIGHT" | "DEFAULT"

//highlight-next-line
// `mode` is used to either interactive livestream video & audio both or only audio.
JsonUtils.jsonPut(config, "mode", "video-and-audio"); // "audio", Default : "video-and-audio"

//highlight-next-line
// Quality of interactive livestream and is only applicable to `video-and-audio` type mode.
JsonUtils.jsonPut(config, "quality", "high"); // "low" | "med",  Default : "med"

//highlight-start
// This mode refers to orientation of interactive livestream.
// landscape : Start interactive livestream of the meeting in horizontally
// portrait : Start interactive livestream of the meeting in vertically (Best for mobile view)
//highlight-end
JsonUtils.jsonPut(config, "orientation", "portrait"); // "landscape",  Default : "landscape"

meeting.startHls(config);
```

</TabItem>

</Tabs>

:::note
If you want only the SEND_AND_RECV participants to be seen in the livestream, you can `pin` all the participants in the SEND_AND_RECV mode and start the livestream with the `SPOTLIGHT` layout and `pin` as the `PRIORITY`.

Deprecated: Use SEND_AND_RECV instead of CONFERENCE
:::

### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
// keep track of hls
findViewById<View>(R.id.btnStartHls).setOnClickListener { view: View? ->
    //highlight-start
    val config = JSONObject()
    val layout = JSONObject()
    JsonUtils.jsonPut(layout, "type", "SPOTLIGHT")
    JsonUtils.jsonPut(layout, "priority", "PRIORITY")
    JsonUtils.jsonPut(layout, "gridSize", 4)
    JsonUtils.jsonPut(config, "layout", layout)
    JsonUtils.jsonPut(config, "theme", "DARK")
    JsonUtils.jsonPut(config, "mode", "video-and-audio")
    JsonUtils.jsonPut(config, "quality", "high")
    JsonUtils.jsonPut(config, "orientation", "portrait")
    //highlight-end

    // Start Hls
    //highlight-next-line
    meeting!!.startHls(config)
}
```

</TabItem>

<TabItem value="Java">

```js
findViewById(R.id.btnStartHls).setOnClickListener(view -> {
    //highlight-start
    JSONObject config = new JSONObject();
    JSONObject layout = new JSONObject();
    JsonUtils.jsonPut(layout, "type", "SPOTLIGHT");
    JsonUtils.jsonPut(layout, "priority", "PRIORITY");
    JsonUtils.jsonPut(layout, "gridSize", 4);
    JsonUtils.jsonPut(config, "layout", layout);
    JsonUtils.jsonPut(config, "theme", "DARK");
    JsonUtils.jsonPut(config, "mode", "video-and-audio");
    JsonUtils.jsonPut(config, "quality", "high");
    JsonUtils.jsonPut(config, "orientation", "portrait");
    //highlight-end

    // Start Hls
    //highlight-next-line
    meeting.startHls(config);
});
```

</TabItem>

</Tabs>

## Understanding Layouts

##### 1. GRID Layout

This layout is default layout if no participants are pinned, it will look same as a normal meeting grid layout, when any participant is pinned that participant will be moved on top of the main screen grid above all non pinned participants

While screenshare as well the main view will contain only screenshare media but the side panel view of participant grid will maintain same order of pinned and unpinned participants.

|                       Grid                        |                     Grid with Screenshare                     |
| :-----------------------------------------------: | :-----------------------------------------------------------: |
| ![prebuilt-grid](/img/prebuilt/prebuilt-grid.png) | ![prebuilt-grid-share](/img/prebuilt/prebuilt-grid-share.png) |

##### 2. SIDEBAR Layout

This layout will have one main screen view and other sidebar grid layout. Only pinned participant will be visible in this layout, all unpinned participants will not be visible in this layout. If more than one participant is pinned then the first participant who was pinned will appear in main screen layout and all other remaining pinned particiapants will be visible in sidebar.

If any pinned participant started screenshare then the screenshare media will be visible in main screen layout and all other pinned participants webcam view will be visible in sidebar

|                         Sidebar                         |                      Sidebar with Screenshare                       |
| :-----------------------------------------------------: | :-----------------------------------------------------------------: |
| ![prebuilt-sidebar](/img/prebuilt/prebuilt-sidebar.png) | ![prebuilt-sidebar-share](/img/prebuilt/prebuilt-sidebar-share.png) |

##### 3. SPOTLIGHT Layout

This layout will only contain main screen layout, multiple pinned participants will be visible in main screen view. Same as `SIDEBAR` layout only pinned participants will be visible in main screen.

If any pinned participant started screenshare then only screenshare view will be visible in main screen, no webcam view will be visible when any pinned participant started screenshare.

|                          Spotlight                          |                       Spotlight with Screenshare                        |
| :---------------------------------------------------------: | :---------------------------------------------------------------------: |
| ![prebuilt-spotlight](/img/prebuilt/prebuilt-spotlight.png) | ![prebuilt-spotlight-share](/img/prebuilt/prebuilt-spotlight-share.png) |

## Event associated with HLS

- **onHlsStateChanged** - Whenever meeting HLS state changes, then `onHlsStateChanged` event will trigger.

- You can get the `livestreamUrl` and `playbackHlsUrl` of the HLS to play it on the Viewer side when the state changes to `HLS_PLAYABLE`.
  - `playbackHlsUrl` - Live HLS with playback support
  - `livestreamUrl` - Live HLS without playback support

:::note
`downstreamUrl` is now depecated. Use `playbackHlsUrl` or `livestreamUrl` in place of `downstreamUrl`
:::

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
private val meetingEventListener: MeetingEventListener = object : MeetingEventListener() {
  override fun onHlsStateChanged(HlsState: JSONObject) {
    when (HlsState.getString("status")) {
        "HLS_STARTING" -> Log.d("onHlsStateChanged", "Meeting hls is starting")
        "HLS_STARTED" -> Log.d("onHlsStateChanged", "Meeting hls is started")
        "HLS_PLAYABLE" -> {
            Log.d("onHlsStateChanged", "Meeting hls is playable now")
            //highlight-start
            // on hls playable you will receive playbackHlsUrl and livestreamUrl
            val playbackHlsUrl = HlsState.getString("playbackHlsUrl")
            val livestreamUrl = HlsState.getString("livestreamUrl")
            //highlight-end
        }
        "HLS_STOPPING" -> Log.d("onHlsStateChanged", "Meeting hls is stopping")
        "HLS_STOPPED" -> Log.d("onHlsStateChanged", "Meeting hls is stopped")
    }
  }
}

override fun onCreate(savedInstanceState: Bundle?) {
  //...

  // add listener to meeting
  //highlight-next-line
  meeting!!.addEventListener(meetingEventListener)
}
```

</TabItem>

<TabItem value="Java">

```js
private final MeetingEventListener meetingEventListener = new MeetingEventListener() {
  @Override
  public void onHlsStateChanged(JSONObject HlsState) {
      switch (HlsState.getString("status")) {
          case "HLS_STARTING":
              Log.d("onHlsStateChanged", "Meeting hls is starting");
              break;
          case "HLS_STARTED":
              Log.d("onHlsStateChanged", "Meeting hls is started");
              break;
          case "HLS_PLAYABLE":
              Log.d("onHlsStateChanged", "Meeting hls is playable now");
              //highlight-start
              // on hls started you will receive playbackHlsUrl and livestreamUrl
              String playbackHlsUrl = HlsState.getString("playbackHlsUrl");
              String livestreamUrl = HlsState.getString("livestreamUrl");
              //highlight-end
              break;
          case "HLS_STOPPING":
              Log.d("onHlsStateChanged", "Meeting hls is stopping");
              break;
          case "HLS_STOPPED":
              Log.d("onHlsStateChanged", "Meeting hls is stopped");
              break;
      }
  }
}

@Override
protected void onCreate(Bundle savedInstanceState) {
  //...

  // add listener to meeting
  //highlight-next-line
  meeting.addEventListener(meetingEventListener);
}
```

</TabItem>

</Tabs>

## Custom Template

With VideoSDK, you can also use your own custom designed layout template to livestream the meetings. In order to use the custom template, you need to create a template for which you can [follow this guide](/react/guide/interactive-live-streaming/custom-template). Once you have setup the template, you can use the [REST API to start](/api-reference/realtime-communication/start-livestream) the livestream with the `templateURL` parameter.

## API Reference

The API references for all the methods utilized in this guide are provided below.

- [startHls()](/android/api/sdk-reference/meeting-class/methods#starthls)
- [stopHls()](/android/api/sdk-reference/meeting-class/methods#stophls)
- [onHlsStateChanged](/android/api/sdk-reference/meeting-class/meeting-event-listener-class#onhlsstatechanged)


---

---
title: Stop HLS | Video SDK
hide_title: true
hide_table_of_contents: false
description: Using VideoSDK to do the interactive livestreaming.
sidebar_label: Stop HLS
pagination_label: Stop HLS
keywords:
  - audio calling
  - video calling
  - real-time communication
  - interactive live streaming
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: stop-hls
---

# Stop HLS - Android

This could refer to stopping the transmission of an ongoing HLS stream, which would mean the stream is no longer available to viewers.

## Stopping HLS

- `stopHls()` is used to stop interactive livestream of the meeting which can be accessed from the `Meeting` class.

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
findViewById<View>(R.id.btnStopHls).setOnClickListener { view: View? ->
    // Stop Hls
    //highlight-next-line
    meeting!!.stopHls()
}
```

</TabItem>

<TabItem value="Java">

```js
findViewById(R.id.btnStopHls).setOnClickListener(view -> {
    // Stop Hls
    //highlight-next-line
    meeting.stopHls();
});
```

</TabItem>

</Tabs>

## Event associated with HLS

- **onHlsStateChanged** - Whenever meeting HLS state changes, then `onHlsStateChanged` event will trigger.

- You will get `HLS_STOPPING` and `HLS_STOPPED` status on calling `stopHls()`.

:::note
`downstreamUrl` is now depecated. Use `playbackHlsUrl` or `livestreamUrl` in place of `downstreamUrl`
:::

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
private val meetingEventListener: MeetingEventListener = object : MeetingEventListener() {
  override fun onHlsStateChanged(HlsState: JSONObject) {
    when (HlsState.getString("status")) {
        "HLS_STARTING" -> Log.d("onHlsStateChanged", "Meeting hls is starting")
        "HLS_STARTED" -> Log.d("onHlsStateChanged", "Meeting hls is started")
        "HLS_PLAYABLE" -> {
            Log.d("onHlsStateChanged", "Meeting hls is playable now")
             // on hls playable you will receive playbackHlsUrl and livestreamUrl
            val playbackHlsUrl = HlsState.getString("playbackHlsUrl")
            val livestreamUrl = HlsState.getString("livestreamUrl")
        }
            //highlight-start
        "HLS_STOPPING" -> Log.d("onHlsStateChanged", "Meeting hls is stopping")
        "HLS_STOPPED" -> Log.d("onHlsStateChanged", "Meeting hls is stopped")
            //highlight-end

    }
  }
}

override fun onCreate(savedInstanceState: Bundle?) {
  //...

  // add listener to meeting
  //highlight-next-line
  meeting!!.addEventListener(meetingEventListener)
}
```

</TabItem>

<TabItem value="Java">

```js
private final MeetingEventListener meetingEventListener = new MeetingEventListener() {
  @Override
  public void onHlsStateChanged(JSONObject HlsState) {
      switch (HlsState.getString("status")) {
          case "HLS_STARTING":
              Log.d("onHlsStateChanged", "Meeting hls is starting");
              break;
          case "HLS_STARTED":
              Log.d("onHlsStateChanged", "Meeting hls is started");
              break;
          case "HLS_PLAYABLE":
              Log.d("onHlsStateChanged", "Meeting hls is playable now");
              // on hls started you will receive playbackHlsUrl and livestreamUrl
              String playbackHlsUrl = HlsState.getString("playbackHlsUrl");
              String livestreamUrl = HlsState.getString("livestreamUrl");
              break;
              //highlight-start
          case "HLS_STOPPING":
              Log.d("onHlsStateChanged", "Meeting hls is stopping");
              break;
          case "HLS_STOPPED":
              Log.d("onHlsStateChanged", "Meeting hls is stopped");
              break;
              //highlight-end

      }
  }
}

@Override
protected void onCreate(Bundle savedInstanceState) {
  //...

  // add listener to meeting
  //highlight-next-line
  meeting.addEventListener(meetingEventListener);
}
```

</TabItem>

</Tabs>

## API Reference

The API references for all the methods utilized in this guide are provided below.

- [startHls()](/android/api/sdk-reference/meeting-class/methods#starthls)
- [stopHls()](/android/api/sdk-reference/meeting-class/methods#stophls)
- [onHlsStateChanged](/android/api/sdk-reference/meeting-class/meeting-event-listener-class#onhlsstatechanged)


---

---
title: Chat messages with PubSub - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: PubSub features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Chat using PubSub
pagination_label: Chat using PubSub
keywords:
  - Chat in meeting
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: chat-using-pubsub
---

# Chat using PubSub - Android

For the communication or any kind of messaging in between the participants, VideoSDK provides `pubSub` class which use Publish-Subscribe mechanism and can be used to develope wide varitey of functionalities. For example, participants could use it to send chat messages to each other, share files or other media, or even trigger actions like muting or unmuting audio or video.

Now we will see, how we can use PubSub to implement Chat functionality. If you are not familiar with the PubSub mechanism and `pubSub` class, you can [follow this guide](/android/guide/video-and-audio-calling-api-sdk/collaboration-in-meeting/pubsub).

## Implementing Chat

### `Group Chat`

1. First step in creating a group chat is choosing the topic which all the participants will publish and subscribe to send and receive the messages. We will be using `CHAT` as the topic for this one.
2. On the send button, publish the message that the sender typed in the `EditText` field.

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle
import android.view.View
import android.widget.EditText
import android.widget.Toast
import androidx.appcompat.widget.Toolbar
import live.videosdk.rtc.android.Meeting
import live.videosdk.rtc.android.listeners.PubSubMessageListener
import live.videosdk.rtc.android.model.PubSubPublishOptions

class ChatActivity : AppCompatActivity() {
  // Meeting
  var meeting: Meeting? = null

  override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    setContentView(R.layout.activity_chat)

    /**
     * Here, we have created 'MainApplication' class, which extends android.app.Application class.
     * It has Meeting property and getter and setter methods of Meeting property.
     * In your android manifest, you must declare the class implementing android.app.Application
     * (add the android:name=".MainApplication" attribute to the existing application tag):
     * In MainActivity.kt, we have set Meeting property.
     *
     * For Example: (MainActivity.kt)
     * var meeting = VideoSDK.initMeeting(context, meetingId, ParticipantName, micEnabled, webcamEnabled, paricipantId, mode, multiStream, customTrack, metaData, signalingBaseUrl)
     * (this.application as MainApplication).meeting = meeting
    */

    // Get Meeting
    meeting = (this.application as MainApplication).meeting

    findViewById(R.id.btnSend).setOnClickListener(view -> sendMessage());
  }

  private fun sendMessage() {
    // get message from EditText
    val message: String = etmessage.getText().toString()
    if (!TextUtils.isEmpty(message)) {
        val publishOptions = PubSubPublishOptions()
        publishOptions.setPersist(true)

        // Sending the Message using the publish method
        //highlight-next-line
        meeting!!.pubSub.publish("CHAT", message, publishOptions)

        // Clearing the message input
        etmessage.setText("")
    } else {
        Toast.makeText(
            this@ChatActivity, "Please Enter Message",
            Toast.LENGTH_SHORT
        ).show()
    }
  }
}
```

</TabItem>

<TabItem value="Java">

```js
import androidx.appcompat.app.AppCompatActivity;
import android.os.Bundle;
import java.util.List;
import live.videosdk.rtc.android.Meeting;
import live.videosdk.rtc.android.lib.PubSubMessage;
import live.videosdk.rtc.android.listeners.PubSubMessageListener;
import live.videosdk.rtc.android.model.PubSubPublishOptions;

public class ChatActivity extends AppCompatActivity {
  // Meeting
  Meeting meeting;

  @Override
  protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_chat);

    /**
     * Here, we have created 'MainApplication' class, which extends android.app.Application class.
     * It has Meeting property and getter and setter methods of Meeting property.
     * In your android manifest, you must declare the class implementing android.app.Application
     * (add the android:name=".MainApplication" attribute to the existing application tag):
     * In MainActivity.java, we have set Meeting property.
     *
     * For Example: (MainActivity.java)
     * Meeting meeting = VideoSDK.initMeeting(context, meetingId, ParticipantName, micEnabled, webcamEnabled, participantId, mode, mutliStream, customTrack,metaData, signalingBaseUrl, preferredProtocol);
     * ((MainApplication) this.getApplication()).setMeeting(meeting);
    */

    // Get Meeting
    meeting = ((MainApplication) this.getApplication()).getMeeting();

    findViewById(R.id.btnSend).setOnClickListener(view -> sendMessage());
  }

  private void sendMessage()
  {
    // get message from EditText
    String message = etmessage.getText().toString();
    if (!message.equals("")) {
        PubSubPublishOptions publishOptions = new PubSubPublishOptions();
        publishOptions.setPersist(true);

        // Sending the Message using the publish method
        //highlight-next-line
        meeting.pubSub.publish("CHAT", message, publishOptions);

        // Clearing the message input
        etmessage.setText("");
    } else {
        Toast.makeText(ChatActivity.this, "Please Enter Message",
                Toast.LENGTH_SHORT).show();
    }
  }
}
```

</TabItem>

</Tabs>

3. Next step would be to display the messages others send. For this we have to `subscribe` to that topic i.e `CHAT` and display all the messages.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
class ChatActivity : AppCompatActivity() {

  // PubSubMessageListener
  //highlight-start
  var pubSubMessageListener =
    PubSubMessageListener { message ->
      // New message
      Toast.makeText(
            this@ChatActivity, message.senderName + " says : " + message.message,
            Toast.LENGTH_SHORT
        ).show()
  }
  //highlight-end

  override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    setContentView(R.layout.activity_chat)

    //...

    // Subscribe for 'CHAT' topic
    //highlight-next-line
    val pubSubMessageList = meeting!!.pubSub.subscribe("CHAT", pubSubMessageListener)

    for (message in pubSubMessageList) {
      // Persisted messages
      Toast.makeText(
            this@ChatActivity, message.senderName + " says : " + message.message,
            Toast.LENGTH_SHORT
        ).show()
    }
  }
}
```

</TabItem>

<TabItem value="Java">

```js
public class ChatActivity extends AppCompatActivity {

  // PubSubMessageListener
  //highlight-start
  private PubSubMessageListener pubSubMessageListener = new PubSubMessageListener() {
    @Override
    public void onMessageReceived(PubSubMessage message) {
        // New message
        Toast.makeText(
          ChatActivity.this, message.senderName + " says : "+ message.getMessag(),
          Toast.LENGTH_SHORT
        ).show();
    }
  };
  //highlight-end

  @Override
  protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_chat);

    //..

    // Subscribe for 'CHAT' topic
    //highlight-next-line
    List<PubSubMessage> pubSubMessageList = meeting.pubSub.subscribe("CHAT", pubSubMessageListener);

    for(PubSubMessage message : pubSubMessageList){
        // Persisted messages
        Toast.makeText(
          ChatActivity.this, message.senderName + " says : "+ message.getMessag(),
          Toast.LENGTH_SHORT
        ).show();
    }
  }
}
```

</TabItem>

</Tabs>

4. Final step in the group chat would be `unsubscribe` to that topic, which you had previously subscribed but no longer needed. Here we are `unsubscribe` to `CHAT` topic on activity destroy.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
class ChatActivity : AppCompatActivity() {
  override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    setContentView(R.layout.activity_chat)

    //...
  }

  override fun onDestroy() {
    // Unsubscribe for 'CHAT' topic
    //highlight-next-line
    meeting!!.pubSub.unsubscribe("CHAT", pubSubMessageListener)
    super.onDestroy()
  }
}
```

</TabItem>

<TabItem value="Java">

```js
public class ChatActivity extends AppCompatActivity {
  @Override
  protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_chat);

    //..
  }

  @Override
  protected void onDestroy() {
    // Unsubscribe for 'CHAT' topic
    //highlight-next-line
    meeting.pubSub.unsubscribe("CHAT", pubSubMessageListener);
    super.onDestroy();
  }
}
```

</TabItem>

</Tabs>

### `Private Chat`

In the above example, if you want to convert into the private chat between two participants, then all you have to do is pass `sendOnly` parameter in `PubSubPublishOptions`.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
class ChatActivity : AppCompatActivity() {

  //..
  
  private fun sendMessage() {
    // get message from EditText
    val message: String = etmessage.getText().toString()
    if (!TextUtils.isEmpty(message)) {
        val publishOptions = PubSubPublishOptions()
        publishOptions.setPersist(true)
        //highlight-start
        // Pass the participantId of the participant to whom you want to send the message.
        var sendOnly: Array<String> = arrayOf("xyz")
        publishOptions.setSendOnly(sendOnly);
        //highlight-end

        // Sending the Message using the publish method
        //highlight-next-line
        meeting!!.pubSub.publish("CHAT", message, publishOptions)

        // Clearing the message input
        etmessage.setText("")
    } else {
        Toast.makeText(
            this@ChatActivity, "Please Enter Message",
            Toast.LENGTH_SHORT
        ).show()
    }
  }
}
```

</TabItem>

<TabItem value="Java">

```js
public class ChatActivity extends AppCompatActivity {
 
  //...

  private void sendMessage()
  {
    // get message from EditText
    String message = etmessage.getText().toString();
    if (!message.equals("")) {
        PubSubPublishOptions publishOptions = new PubSubPublishOptions();
        publishOptions.setPersist(true);
        //highlight-start
        // Pass the participantId of the participant to whom you want to send the message.
        String[] sendOnly = {
          "xyz" 
        };
        publishOptions.setSendOnly(sendOnly);
        //highlight-end

        // Sending the Message using the publish method
        //highlight-next-line
        meeting.pubSub.publish("CHAT", message, publishOptions);

        // Clearing the message input
        etmessage.setText("");
    } else {
        Toast.makeText(ChatActivity.this, "Please Enter Message",
                Toast.LENGTH_SHORT).show();
    }
  }
}
```

</TabItem>

</Tabs>

### Downloading Chat Messages

All the messages from the PubSub which where published with `persist : true` and can be downloaded as an `.csv` file. This file will be available in the VideoSDK dashboard as well as throught the [Sessions API](/api-reference/realtime-communication/fetch-session-using-sessionid).

### API Reference

The API references for all the methods and events utilised in this guide are provided below.

- [pubSub()](/android/api/sdk-reference/pubsub-class/introduction)


---

---
title: Notify Attendees with PubSub - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: PubSub features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Notify Attendees in Realtime
pagination_label: Notify Attendees in Realtime
keywords:
  - Start Livestream meeting
  - Stop Livestream meeting
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: notify-attendees
---

# Notify Attendees in Realtime - Android

When doing livestream, you may want to broadcast message to all the viewers at once.

Let us see, how we can use PubSub to implement this functionality. If you are not familiar with the PubSub mechanism, you can [follow this guide](/android/guide/video-and-audio-calling-api-sdk/collaboration-in-meeting/pubsub).

### Notifying Attendees

1. We will be publish the message that the sender typed in the `EditText` field to the topic `NOTIFY_ATTENDEES`.

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js

class SpeakerActivity : AppCompatActivity() {
  override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    //...
    findViewById(R.id.btnSend).setOnClickListener(view -> sendMessage());
  }

  private fun sendMessage() {
    // get message from EditText
    val message: String = etmessage.getText().toString()
    if (!TextUtils.isEmpty(message)) {
        val publishOptions = PubSubPublishOptions()
        publishOptions.setPersist(true)

        // Sending the Message using the publish method
        //highlight-next-line
        meeting!!.pubSub.publish("NOTIFY_ATTENDEES", message, publishOptions)

        // Clearing the message input
        etmessage.setText("")
    } else {
        Toast.makeText(
            this@SpeakerActivity, "Please Enter Message",
            Toast.LENGTH_SHORT
        ).show()
    }
  }
}
```

</TabItem>

<TabItem value="Java">

```js
public class SpeakerActivity extends AppCompatActivity {
  @Override
  protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    //...
    findViewById(R.id.btnSend).setOnClickListener(view -> sendMessage());
  }

  private void sendMessage()
  {
    // get message from EditText
    String message = etmessage.getText().toString();
    if (!message.equals("")) {
        PubSubPublishOptions publishOptions = new PubSubPublishOptions();
        publishOptions.setPersist(true);

        // Sending the Message using the publish method
        //highlight-next-line
        meeting.pubSub.publish("NOTIFY_ATTENDEES", message, publishOptions);

        // Clearing the message input
        etmessage.setText("");
    } else {
        Toast.makeText(SpeakerActivity.this, "Please Enter Message",
                Toast.LENGTH_SHORT).show();
    }
  }
}
```

</TabItem>

</Tabs>

2. Now let us show an alert to all the viewers displaying the message posted by the speaker.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
class ViewerActivity : AppCompatActivity() {

  // PubSubMessageListener
  //highlight-start
  var pubSubMessageListener =
    PubSubMessageListener { message ->
      if(meeting!!.localparticipant.mode == "SIGNALLING_ONLY"){
        Toast.makeText(
                this@ViewerActivity, message.message,
                Toast.LENGTH_SHORT
            ).show()
      }
  }
  //highlight-end

  override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    setContentView(R.layout.activity_chat)

    //...

    // Subscribe for 'NOTIFY_ATTENDEES' topic
    //highlight-next-line
    val pubSubMessageList = meeting!!.pubSub.subscribe("NOTIFY_ATTENDEES", pubSubMessageListener)

    for (message in pubSubMessageList) {
      // Persisted messages
      if(meeting!!.localparticipant.mode == "SIGNALLING_ONLY"){
        Toast.makeText(
                this@ViewerActivity, message.message,
                Toast.LENGTH_SHORT
            ).show()
      }
    }
  }
}
```

</TabItem>

<TabItem value="Java">

```js
public class ViewerActivity extends AppCompatActivity {

  // PubSubMessageListener
  //highlight-start
  private PubSubMessageListener pubSubMessageListener = new PubSubMessageListener() {
    @Override
    public void onMessageReceived(PubSubMessage message) {
        if(meeting.getLocalParticipant().getMode() == "SIGNALLING_ONLY"){
            Toast.makeText(
                ViewerActivity.this, message.getMessage(),
                Toast.LENGTH_SHORT
                ).show();
        }
    }
  };
  //highlight-end

  @Override
  protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);

    //..

    // Subscribe for 'NOTIFY_ATTENDEES' topic
    //highlight-next-line
    List<PubSubMessage> pubSubMessageList = meeting.pubSub.subscribe("NOTIFY_ATTENDEES", pubSubMessageListener);

    for(PubSubMessage message : pubSubMessageList){
        // Persisted messages
        if(meeting.getLocalParticipant().getMode() == "SIGNALLING_ONLY"){
            Toast.makeText(
            ViewerActivity.this, message.getMessage(),
            Toast.LENGTH_SHORT
            ).show();
        }
    }
  }
}
```

</TabItem>

</Tabs>

### API Reference

The API references for all the methods and events utilised in this guide are provided below.

- [pubSub()](/android/api/sdk-reference/pubsub-class/introduction)


---

---
title: Raise Hand with PubSub - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: PubSub features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Raise Hand using PubSub
pagination_label: Raise Hand using PubSub
keywords:
  - Raise Hand
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: raise-hand-using-pubsub
---

# Raise Hand using PubSub - Android

Let us see, how we can use PubSub to implement Raise Hand functionality. If you are not familiar with the PubSub mechanism and `pubSub` class, you can [follow this guide](/android/guide/video-and-audio-calling-api-sdk/collaboration-in-meeting/pubsub).

## Implementing Raise Hand

1. First step in raise hand is choosing the topic which all the participants will publish and subscribe to know some participant raise their hand. We will be using `RAISE_HAND` as the topic for this one.
2. On the raiseHand button, publish any message to that specific topic.

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
class MainActivity : AppCompatActivity() {

  override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    setContentView(R.layout.activity_main)

    //...

    findViewById(R.id.btnRaiseHand).setOnClickListener(view -> sendRaiseHandMessage());
  }

  private fun sendRaiseHandMessage() {
    val publishOptions = PubSubPublishOptions()
    publishOptions.setPersist(false)

    // Sending the Message using the publish method
    //highlight-next-line
    meeting!!.pubSub.publish("RAISE_HAND", "Raise Hand", publishOptions)
  }
}
```

</TabItem>

<TabItem value="Java">

```js
public class MainActivity extends AppCompatActivity {
  @Override
  protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_chat);

    //...

    findViewById(R.id.btnRaiseHand).setOnClickListener(view -> sendRaiseHandMessage());
  }

  private void sendRaiseHandMessage()
  {
    PubSubPublishOptions publishOptions = new PubSubPublishOptions();
    publishOptions.setPersist(false);

    // Sending the Message using the publish method
    //highlight-next-line
    meeting.pubSub.publish("RAISE_HAND", "Raise Hand", publishOptions);
  }
}
```

</TabItem>

</Tabs>

3. Now let us show an alert to all the participants showing who raised the hand.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
class MainActivity : AppCompatActivity() {

  // PubSubMessageListener
  //highlight-start
  var pubSubMessageListener =
    PubSubMessageListener { message ->
      // Participant raise hand
      Toast.makeText(
            this@MainActivity, message.senderName + " raise hand",
            Toast.LENGTH_SHORT
        ).show()
  }
  //highlight-end

  override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    setContentView(R.layout.activity_chat)

    //...

    // Subscribe for 'RAISE_HAND' topic
    //highlight-next-line
    val pubSubMessageList = meeting!!.pubSub.subscribe("RAISE_HAND", pubSubMessageListener)
  }
}
```

</TabItem>

<TabItem value="Java">

```js
public class MainActivity extends AppCompatActivity {

  // PubSubMessageListener
  //highlight-start
  private PubSubMessageListener pubSubMessageListener = new PubSubMessageListener() {
    @Override
    public void onMessageReceived(PubSubMessage message) {
        // Participant raise hand
        Toast.makeText(
          MainActivity.this, message.senderName + " raise hand",
          Toast.LENGTH_SHORT
        ).show();
    }
  };
  //highlight-end

  @Override
  protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);

    //..

    // Subscribe for 'RAISE_HAND' topic
    //highlight-next-line
    List<PubSubMessage> pubSubMessageList = meeting.pubSub.subscribe("RAISE_HAND", pubSubMessageListener);
  }
}
```

</TabItem>

</Tabs>

### API Reference

The API references for all the methods and events utilised in this guide are provided below.

- [pubSub()](/android/api/sdk-reference/pubsub-class/introduction)


---

---
title: Reactions with PubSub - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: PubSub features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Reactions
pagination_label: Reactions
keywords:
  - Start Livestream meeting
  - Stop Livestream meeting
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: reactions
---

# Reactions - Android

When doing a livestream, one of the way to increase the interaction in between the viewer and speaker is by showing the viewers reaction to all. You might have seen emojis flying around during the livestream happening on instagram.

Lets create a similar flying emoji by using the VideoSDK PubSub mechanism.

### Step 1: Creating a button to send reaction

When `btnReaction` is clicked we will send the emoji name to all the participants using the VideoSDK PubSub mechanism and also shows emoji to localParticipant.

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
class ILSViewActivity : AppCompatActivity() {

  override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    //...
    findViewById(R.id.btnReaction).setOnClickListener { v: View? ->
        showEmoji(resources.getDrawable(R.drawable.love_eyes_emoji))
        meeting!!.pubSub.publish("REACTION", "love_eyes", pubSubPublishOptions)
    }
  }

  private fun showEmoji(drawable: Drawable?) {
    // we will implement this method in step 2
  }
}
```

</TabItem>

<TabItem value="Java">

```js
public class ILSViewActivity extends AppCompatActivity {
  @Override
  protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    //...
    findViewById(R.id.loveEyes).setOnClickListener(v -> {
        showEmoji(getResources().getDrawable(R.drawable.love_eyes_emoji));
        meeting.pubSub.publish("REACTION", "love_eyes", pubSubPublishOptions);
    });
  }

  public void showEmoji(Drawable drawable) {
    // we will implement this method in step 2
  }
}
```

</TabItem>

</Tabs>

### Step 2: Displaying the Reactions to all the users

Here we will listen to the `onMessageReceived` event of `PubSubMessageListener` to know someone send the reactions, and show the flying emoji whenever it triggered.

To Display flyingEmoji, we are using `DirectionGenerator` class to specify direction and `ZeroGravityAnimation` class to give animation to the flyingEmoji.

Copy `DirectionGenerator` and `ZeroGravityAnimation` classes from our [code sample](https://github.com/videosdk-live/videosdk-hls-android-kotlin-example/tree/main/app/src/main/java/live/videosdk/android/hlsdemo/common/reactions).

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
class ILSViewActivity : AppCompatActivity() {

  override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    //...
    var emojiListener =
    PubSubMessageListener { pubSubMessage ->
        when (pubSubMessage.message) {
            //Showing other participants reactions
            "loveEyes" -> showEmoji(resources.getDrawable(R.drawable.love_eyes_emoji))
        }
    }
    //Subscribing to the PubSub topic REACTION to recive other participants reactions.
    //highlight-start
    meeting!!.pubSub.subscribe("REACTION", emojiListener)
  }
}
```

</TabItem>

<TabItem value="Java">

```js
public class ILSViewActivity extends AppCompatActivity {
  @Override
  protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    //...
    private PubSubMessageListener pubSubMessageListener = new PubSubMessageListener() {
    @Override
    public void onMessageReceived(PubSubMessage pubSubMessage) {
            switch (pubSubMessage.getMessage()) {
                case "loveEyes":
                    //Showing other participants reactions
                    showEmoji(getResources().getDrawable(R.drawable.love_eyes_emoji));
                    break;
            }

        }
    };
    //Subscribing to the PubSub topic REACTION to recive other participants reactions.
    //highlight-start
    meeting.pubSub.subscribe("REACTION", emojiListener);
  }
}
```

</TabItem>

</Tabs>

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
private fun showEmoji(drawable: Drawable?) {
    // You can change the number of emojis that will be flying on screen
    for (i in 0..4) {
        flyObject(
            drawable,
            3000,
            DirectionGenerator.Direction.BOTTOM,
            DirectionGenerator.Direction.TOP,
            1f
        )
    }
}

private fun flyObject(
    drawable: Drawable?,
    duration: Int,
    from: DirectionGenerator.Direction?,
    to: DirectionGenerator.Direction?,
    scale: Float
) {
    val animation = ZeroGravityAnimation()
    animation.setCount(1)
    animation.setScalingFactor(scale)
    animation.setOriginationDirection((from)!!)
    animation.setDestinationDirection((to)!!)
    animation.setImage(drawable)
    animation.setDuration(duration)
    animation.setAnimationListener(object : Animation.AnimationListener {
        override fun onAnimationStart(animation: Animation) {}
        override fun onAnimationEnd(animation: Animation) {}
        override fun onAnimationRepeat(animation: Animation) {}
    })
    viewerEmojiHolder!!.bringToFront()
    animation.play(mActivity, viewerEmojiHolder)
}
```

</TabItem>

<TabItem value="Java">

```js
public void showEmoji(Drawable drawable) {
    // You can change the number of emojis that will be flying on screen
    for (int i = 0; i < 5; i++) {
        flyObject(drawable, 3000, DirectionGenerator.Direction.BOTTOM, DirectionGenerator.Direction.TOP, 1);
    }
}

public void flyObject(final Drawable drawable, final int duration, final DirectionGenerator.Direction from, final DirectionGenerator.Direction to, final float scale) {
    ZeroGravityAnimation animation = new ZeroGravityAnimation();
    animation.setCount(1);
    animation.setScalingFactor(scale);
    animation.setOriginationDirection(from);
    animation.setDestinationDirection(to);
    animation.setImage(drawable);
    animation.setDuration(duration);
    animation.setAnimationListener(new Animation.AnimationListener() {
        @Override
        public void onAnimationStart(Animation animation) {

        }

        @Override
        public void onAnimationEnd(Animation animation) {
        }

        @Override
        public void onAnimationRepeat(Animation animation) {

        }
    });
    viewerEmojiHolder.bringToFront();
    animation.play(mActivity, viewerEmojiHolder);
}

```

</TabItem>

</Tabs>

:::note
Here `viewerEmojiHolder` is FrameLayout, you can change recording to your requirement.
:::

<center>

<img style={{height: '450px',marginRight:'15px'}} src="https://cdn.videosdk.live/website-resources/docs-resources/android_emoji_viewer.gif" />

<img style={{height: '450px'}} src="https://cdn.videosdk.live/website-resources/docs-resources/android_emoji_speaker.gif"/>

</center>

### API Reference

The API references for all the methods and events utilised in this guide are provided below.

- [pubSub()](/android/api/sdk-reference/pubsub-class/introduction)


---

---
title: Pin/Unpin participant from the meeting - React JS SDK
hide_title: false
hide_table_of_contents: false
description: Pin/Unpin a participant or a peer from the meeting while it is still in progress. It helps in meeting moderation.
sidebar_label: Pin/Unpin Participant
pagination_label: Pin/Unpin Participant
keywords:
  - pin/unpin participant
  - react js
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: pin-unpin-participant
---

# Pin/Unpin Participants - Android

In a live stream setup, you often want to control which participant is actively visible on screen — whether it’s the host, a special guest, or someone screen sharing. To manage this dynamically, the `Participant` class provides two key methods:

- `pin()` – Focus on a specific participant’s camera or screen share

- `unpin()` – Remove that focus and return to the default layout

This allows you to programmatically decide who gets the spotlight in your live stream layout.

### `pin()`

The pin() method makes it easy to bring a host camera or screen share front and center in the broadcast layout. Once pinned, you can write the layout logic to place this host in the primary frame, e.g. fullscreen or in a highlighted position.

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
private fun pinParticipant(participant: Participant) {
    participant.pin(null)
    Toast.makeText(context, "Participant pinned", Toast.LENGTH_SHORT).show()
}
```

</TabItem>

<TabItem value="Java">

```java
private void pinParticipant(Participant participant) {
    participant.pin(null);
    Toast.makeText(context, "Participant pinned", Toast.LENGTH_SHORT).show();
}
```

</TabItem>

</Tabs>

### `unpin()`

When a host is no longer the focus (e.g. their segment is over), you can reset their pinned state using unpin(). This allows your live stream UI to revert to a default grid view or automatically promote the next speaker.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
private fun unpinParticipant(participant: Participant) {
    participant.unpin(null)
    Toast.makeText(context, "Participant unpinned", Toast.LENGTH_SHORT).show()
}
```

</TabItem>

<TabItem value="Java">

```java
private void unpinParticipant(Participant participant) {
    participant.unpin(null);
    Toast.makeText(context, "Participant unpinned", Toast.LENGTH_SHORT).show();
}
```

</TabItem>

</Tabs>

### Events associated with pin/unpin

Following callbacks are received when a host is pinned or unpinned in the livestream.

- All participants-including all the hosts and audience members will receive a callback on the [`onPinStateChanged`](/android/api/sdk-reference/meeting-class/meeting-event-listener-class#onparticipantmodechanged) event with the data object containg the peerid of the participant who was pinned, the state and pinnedBy values.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
private val meetingEventListener = object : MeetingEventListener() {
    override fun onPinStateChanged(pinStateData: JSONObject) {
        try {
            Log.d("VideoSDK", "onPinStateChanged: $pinStateData")

            meeting?.let {
                val peerId = pinStateData.getString("peerId")
                var participant = it.participants[peerId]
                
                if (participant == null) {
                    participant = it.localParticipant
                }

                val name = participant?.displayName ?: "Unknown"
                Toast.makeText(this@MainActivity, "Pinned $name", Toast.LENGTH_SHORT).show()
            }
        } catch (e: JSONException) {
            e.printStackTrace()
        }
    }
}

```

</TabItem>

<TabItem value="Java">

```java
private final MeetingEventListener meetingEventListener = new MeetingEventListener() {
    @Override
    public void onPinStateChanged(JSONObject pinStateData) {
        try {
            Log.d("VideoSDK", "onPinStateChanged: " + pinStateData);
            if (meeting != null) {
                String peerId = pinStateData.getString("peerId");
                Participant participant = meeting.getParticipants().get(peerId);

                if (participant == null) {
                    participant = meeting.getLocalParticipant();
                }

                String displayName = participant.getDisplayName();
                Toast.makeText(MainActivity.this, "Pinned " + displayName, Toast.LENGTH_SHORT).show();
            }
        } catch (JSONException e) {
            e.printStackTrace();
        }
    }
};
```

</TabItem>

</Tabs>

:::info

- Based on the `onPinStateChanged` event, you should update your live stream layout for all participants (including the audience) to reflect the current pinned participant.
This means conditionally rendering the pinned participant in the main view or spotlight area across all clients.

:::


## API Reference

The API references for all the methods and events utilized in this guide are provided below.

- [pin()](/android/api/sdk-reference/participant-class/methods#pin)
- [unpin()](/android/api/sdk-reference/participant-class/methods#unpin)



---

---
title: Rendering Host and Audience Views | Video SDK
hide_title: true
hide_table_of_contents: false
description: Learn how to render host and audience views during a live stream using Video SDK's React API, manage participant media, and track participant counts in real time.
sidebar_label: Rendering Host and Audience Views
pagination_label: Rendering Host and Audience Views
keywords:
  - audio calling
  - video calling
  - real-time communication
  - collaboration
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: rendering-host-audience-views
---

# Rendering Host and Audience Views - Android 

In a live stream setup, only hosts (participants in `SEND_AND_RECV` mode) can broadcast their audio and video. Audience members (in `RECV_ONLY` mode) are passive viewers who do not share their audio/video.

To ensure optimal performance and a clean user experience, your app should:

- **Render audio and video elements only for hosts** (i.e., participants in `SEND_AND_RECV` mode).
- **Display the total audience count** to give context on viewership without rendering individual audience tiles.

## Filtering and Rendering Hosts

The steps involved in rendering the audio and video of hosts are as follows.

1. [Filtering Hosts and Checking their Mic/Webcam Status](#1-filtering-hosts-and-checking-their-micwebcam-status)
2. [Rendering Video Streams of Hosts](#2-rendering-video-streams-of-hosts)
3. [Rendering Audio Streams of Hosts](#3-rendering-audio)

### `1. Filtering Hosts and Checking their Mic/Webcam Status `

In a live stream, only participants in `SEND_AND_RECV` mode (i.e., hosts) actively share their audio and video. To render their streams, begin by accessing all participants using the `Meeting` class. Then, filter out only those in `SEND_AND_RECV` mode.


import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
private fun showParticipants() {
    // Clear existing lists
    speakerList?.clear()
    
    // Filter for host participants (SEND_AND_RECV mode)
    liveStream?.participants?.values?.forEach { participant ->
        if (participant.mode == "SEND_AND_RECV" && speakerList!!.size < 4) {
            speakerList?.add(participant)
        }
    }
    
    // Add local participant if they're a host
    if (liveStream?.localParticipant?.mode == "SEND_AND_RECV" && !speakerList!!.contains(liveStream?.localParticipant)) {
        speakerList?.add(0, liveStream?.localParticipant!!)
    }
    
    // Update the UI with filtered participants
    updateSpeakerGrid()
}

private fun updateSpeakerGrid() {
    // Update UI based on number of speakers
    when (speakerList?.size) {
        1 -> {
            speakerOneContainer?.visibility = View.VISIBLE
            speakerTwoContainer?.visibility = View.GONE
            speakerThreeContainer?.visibility = View.GONE
            speakerFourContainer?.visibility = View.GONE
            
            // Show first speaker
            showInGUI(speakerList!![0], speakerOneView, speakerOneNameText)
        }
        2 -> {
            speakerOneContainer?.visibility = View.VISIBLE
            speakerTwoContainer?.visibility = View.VISIBLE
            speakerThreeContainer?.visibility = View.GONE
            speakerFourContainer?.visibility = View.GONE
            
            // Show first and second speakers
            showInGUI(speakerList!![0], speakerOneView, speakerOneNameText)
            showInGUI(speakerList!![1], speakerTwoView, speakerTwoNameText)
        }
    }
}
```

</TabItem>

<TabItem value="Java">

```java
private void showParticipants() {
    // Clear existing lists
    if (speakerList != null) {
        speakerList.clear();
    }

    // Filter for host participants (SEND_AND_RECV mode)
    if (liveStream != null && liveStream.getParticipants() != null) {
        for (Participant participant : liveStream.getParticipants().values()) {
            if ("SEND_AND_RECV".equals(participant.getMode()) && speakerList.size() < 4) {
                speakerList.add(participant);
            }
        }
    }

    // Add local participant if they're a host
    if (liveStream != null && "SEND_AND_RECV".equals(liveStream.getLocalParticipant().getMode())
            && !speakerList.contains(liveStream.getLocalParticipant())) {
        speakerList.add(0, liveStream.getLocalParticipant());
    }

    // Update the UI with filtered participants
    updateSpeakerGrid();
}

private void updateSpeakerGrid() {
    // Update UI based on number of speakers
    if (speakerList == null) return;

    switch (speakerList.size()) {
        case 1:
            speakerOneContainer.setVisibility(View.VISIBLE);
            speakerTwoContainer.setVisibility(View.GONE);
            speakerThreeContainer.setVisibility(View.GONE);
            speakerFourContainer.setVisibility(View.GONE);

            // Show first speaker
            showInGUI(speakerList.get(0), speakerOneView, speakerOneNameText);
            break;

        case 2:
            speakerOneContainer.setVisibility(View.VISIBLE);
            speakerTwoContainer.setVisibility(View.VISIBLE);
            speakerThreeContainer.setVisibility(View.GONE);
            speakerFourContainer.setVisibility(View.GONE);

            // Show first and second speakers
            showInGUI(speakerList.get(0), speakerOneView, speakerOneNameText);
            showInGUI(speakerList.get(1), speakerTwoView, speakerTwoNameText);
            break;
    }
}
```

</TabItem>

</Tabs>

### `2. Rendering Video Streams of Hosts`

Once you've filtered for participants in `SEND_AND_RECV` mode (i.e., hosts), you can use the `Participant` class to access their real-time data, including their webcamStream, webcamOn, and whether they are the local participant.

For each of these participants, use the `Participant` , which provides real-time information like displayName, micOn, and webcamOn. Display their name along with the current status of their microphone and webcam. If the webcam is off, show a simple placeholder with their name. If it's on, render their video feed. This ensures only hosts are visible to the audience, keeping the experience clean and intentional.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
private fun showInGUI(participant: Participant, videoView: VideoView, nameText: TextView) {
    // Set participant name
    nameText.text = if (participant.id == liveStream?.localParticipant?.id) "You" else participant.displayName
    
    // Get references to status indicators
    val micStatusIcon = videoView.findViewById<ImageView>(R.id.ivMicStatus)
    val micStatusText = videoView.findViewById<TextView>(R.id.tvMicStatus)
    val webcamStatusIcon = videoView.findViewById<ImageView>(R.id.ivWebcamStatus)
    val webcamStatusText = videoView.findViewById<TextView>(R.id.tvWebcamStatus)
    
    // Set initial status
    updateMicStatus(participant.isMicOn, micStatusIcon, micStatusText)
    updateWebcamStatus(participant.isWebcamOn, webcamStatusIcon, webcamStatusText, videoView)
    
    // Add participant listener for status changes
    participant.addEventListener(object : ParticipantEventListener() {
        override fun onStreamEnabled(stream: Stream) {
            activity?.runOnUiThread {
                if (stream.kind.equals("video", ignoreCase = true)) {
                    // Update webcam status
                    updateWebcamStatus(true, webcamStatusIcon, webcamStatusText, videoView)
                    
                    // Set up video stream
                    videoView.visibility = View.VISIBLE
                    videoView.setScalingType(RendererCommon.ScalingType.SCALE_ASPECT_FILL)
                    
                    // Mirror video for local participant
                    if (participant.id == liveStream?.localParticipant?.id) {
                        videoView.setMirror(true)
                    }
                    
                    videoView.addTrack(stream.mediaStream, stream.trackId)
                } else if (stream.kind.equals("audio", ignoreCase = true)) {
                    // Update mic status
                    updateMicStatus(true, micStatusIcon, micStatusText)
                }
            }
        }

        override fun onStreamDisabled(stream: Stream) {
            activity?.runOnUiThread {
                if (stream.kind.equals("video", ignoreCase = true)) {
                    // Update webcam status
                    updateWebcamStatus(false, webcamStatusIcon, webcamStatusText, videoView)
                    
                    // Hide video view
                    videoView.visibility = View.GONE
                } else if (stream.kind.equals("audio", ignoreCase = true)) {
                    // Update mic status
                    updateMicStatus(false, micStatusIcon, micStatusText)
                }
            }
        }
    })
    
    // Set up initial streams
    participant.streams.values.forEach { stream ->
        if (stream.kind.equals("video", ignoreCase = true)) {
            // Set up video stream
            videoView.visibility = View.VISIBLE
            videoView.setScalingType(RendererCommon.ScalingType.SCALE_ASPECT_FILL)
            
            // Mirror video for local participant
            if (participant.id == liveStream?.localParticipant?.id) {
                videoView.setMirror(true)
            }
            
            videoView.addTrack(stream.mediaStream, stream.trackId)
        }
    }
}

private fun updateMicStatus(isMicOn: Boolean, micStatusIcon: ImageView, micStatusText: TextView) {
    micStatusIcon.setImageResource(if (isMicOn) R.drawable.ic_audio_on else R.drawable.ic_audio_off)
    micStatusText.text = if (isMicOn) "On" else "Off"
}

private fun updateWebcamStatus(isWebcamOn: Boolean, webcamStatusIcon: ImageView, webcamStatusText: TextView, videoView: VideoView) {
    webcamStatusIcon.setImageResource(if (isWebcamOn) R.drawable.ic_video_camera else R.drawable.ic_video_camera_off)
    webcamStatusText.text = if (isWebcamOn) "On" else "Off"
    
    // Show/hide video view based on webcam status
    if (isWebcamOn) {
        videoView.visibility = View.VISIBLE
    } else {
        videoView.removeTrack()
        videoView.visibility = View.GONE
    }
}
```

</TabItem>

<TabItem value="Java">

```java
private void showInGUI(Participant participant, VideoView videoView, TextView nameText) {
    // Set participant name
    if (participant.getId().equals(liveStream.getLocalParticipant().getId())) {
        nameText.setText("You");
    } else {
        nameText.setText(participant.getDisplayName());
    }

    // Get references to status indicators
    ImageView micStatusIcon = videoView.findViewById(R.id.ivMicStatus);
    TextView micStatusText = videoView.findViewById(R.id.tvMicStatus);
    ImageView webcamStatusIcon = videoView.findViewById(R.id.ivWebcamStatus);
    TextView webcamStatusText = videoView.findViewById(R.id.tvWebcamStatus);

    // Set initial status
    updateMicStatus(participant.isMicOn(), micStatusIcon, micStatusText);
    updateWebcamStatus(participant.isWebcamOn(), webcamStatusIcon, webcamStatusText, videoView);

    // Add participant listener for status changes
    participant.addEventListener(new ParticipantEventListener() {
        @Override
        public void onStreamEnabled(Stream stream) {
            if (activity != null) {
                activity.runOnUiThread(() -> {
                    if ("video".equalsIgnoreCase(stream.getKind())) {
                        // Update webcam status
                        updateWebcamStatus(true, webcamStatusIcon, webcamStatusText, videoView);

                        // Set up video stream
                        videoView.setVisibility(View.VISIBLE);
                        videoView.setScalingType(RendererCommon.ScalingType.SCALE_ASPECT_FILL);

                        // Mirror video for local participant
                        if (participant.getId().equals(liveStream.getLocalParticipant().getId())) {
                            videoView.setMirror(true);
                        }

                        videoView.addTrack(stream.getMediaStream(), stream.getTrackId());

                    } else if ("audio".equalsIgnoreCase(stream.getKind())) {
                        // Update mic status
                        updateMicStatus(true, micStatusIcon, micStatusText);
                    }
                });
            }
        }

        @Override
        public void onStreamDisabled(Stream stream) {
            if (activity != null) {
                activity.runOnUiThread(() -> {
                    if ("video".equalsIgnoreCase(stream.getKind())) {
                        // Update webcam status
                        updateWebcamStatus(false, webcamStatusIcon, webcamStatusText, videoView);

                        // Hide video view
                        videoView.setVisibility(View.GONE);
                    } else if ("audio".equalsIgnoreCase(stream.getKind())) {
                        // Update mic status
                        updateMicStatus(false, micStatusIcon, micStatusText);
                    }
                });
            }
        }
    });

    // Set up initial streams
    for (Stream stream : participant.getStreams().values()) {
        if ("video".equalsIgnoreCase(stream.getKind())) {
            // Set up video stream
            videoView.setVisibility(View.VISIBLE);
            videoView.setScalingType(RendererCommon.ScalingType.SCALE_ASPECT_FILL);

            // Mirror video for local participant
            if (participant.getId().equals(liveStream.getLocalParticipant().getId())) {
                videoView.setMirror(true);
            }

            videoView.addTrack(stream.getMediaStream(), stream.getTrackId());
        }
    }
}

private void updateMicStatus(boolean isMicOn, ImageView micStatusIcon, TextView micStatusText) {
    micStatusIcon.setImageResource(isMicOn ? R.drawable.ic_audio_on : R.drawable.ic_audio_off);
    micStatusText.setText(isMicOn ? "On" : "Off");
}

private void updateWebcamStatus(boolean isWebcamOn, ImageView webcamStatusIcon, TextView webcamStatusText, VideoView videoView) {
    webcamStatusIcon.setImageResource(isWebcamOn ? R.drawable.ic_video_camera : R.drawable.ic_video_camera_off);
    webcamStatusText.setText(isWebcamOn ? "On" : "Off");

    // Show/hide video view based on webcam status
    if (isWebcamOn) {
        videoView.setVisibility(View.VISIBLE);
    } else {
        videoView.removeTrack();
        videoView.setVisibility(View.GONE);
    }
}
```

</TabItem>

</Tabs>


### `3. Rendering Audio Streams of Hosts`

Alongside video rendering, you can also play a participant’s audio whenever their mic is turned on. 

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
private fun setupAudioControls() {
    micButton?.setOnClickListener {
        if (liveStream?.localParticipant?.isMicOn == true) {
            // Turn off microphone
            liveStream?.localParticipant?.disableMic()
            micButton?.setImageResource(R.drawable.ic_audio_off)
        } else {
            // Turn on microphone
            liveStream?.localParticipant?.enableMic()
            micButton?.setImageResource(R.drawable.ic_audio_on)
        }
    }
}

liveStream?.addEventListener(object : MeetingEventListener() {
    override fun onAudioDeviceChanged(audioDevice: String, availableAudioDevices: Set<String>) {
        // Handle audio device changes (e.g., switching between speaker, earpiece, headphones)
        activity?.runOnUiThread {
            // Update UI based on current audio device
            when (audioDevice) {
                "SPEAKER_PHONE" -> audioOutputButton?.setImageResource(R.drawable.ic_speaker)
                "EARPIECE" -> audioOutputButton?.setImageResource(R.drawable.ic_earpiece)
                "WIRED_HEADSET" -> audioOutputButton?.setImageResource(R.drawable.ic_headset)
                "BLUETOOTH" -> audioOutputButton?.setImageResource(R.drawable.ic_bluetooth)
            }
        }
    }
})
```

</TabItem>

<TabItem value="Java">

```java
private void setupAudioControls() {
    if (micButton != null) {
        micButton.setOnClickListener(v -> {
            if (liveStream != null && liveStream.getLocalParticipant() != null) {
                if (liveStream.getLocalParticipant().isMicOn()) {
                    // Turn off microphone
                    liveStream.getLocalParticipant().disableMic();
                    micButton.setImageResource(R.drawable.ic_audio_off);
                } else {
                    // Turn on microphone
                    liveStream.getLocalParticipant().enableMic();
                    micButton.setImageResource(R.drawable.ic_audio_on);
                }
            }
        });
    }
}

private void setupAudioDeviceListener() {
    if (liveStream != null) {
    liveStream.addEventListener(new MeetingEventListener() {
        @Override
        public void onAudioDeviceChanged(String audioDevice, Set<String> availableAudioDevices) {
            // Handle audio device changes (e.g., switching between speaker, earpiece, headphones)
          activity.runOnUiThread(() -> {
              // Update UI based on current audio device
            switch (audioDevice) {
                case "SPEAKER_PHONE":
                    if (audioOutputButton != null)
                        audioOutputButton.setImageResource(R.drawable.ic_speaker);
                    break;
                case "EARPIECE":
                    if (audioOutputButton != null)
                        audioOutputButton.setImageResource(R.drawable.ic_earpiece);
                    break;
                case "WIRED_HEADSET":
                    if (audioOutputButton != null)
                        audioOutputButton.setImageResource(R.drawable.ic_headset);
                    break;
                case "BLUETOOTH":
                    if (audioOutputButton != null)
                        audioOutputButton.setImageResource(R.drawable.ic_bluetooth);
                    break;
            }
          });
        }
    });
    }
}
```

</TabItem>

</Tabs>


## API Reference

The API references for all the methods and events utilized in this guide are provided below.

- [Participant](/android/api/sdk-reference/participant-class/introduction)


---

---
title: Live Captioning - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: Live Captioning features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add support for Live Captioning or captioning to your applications.
sidebar_label: Live Captioning
pagination_label: Live Captioning
keywords:
  - Start Live Captioning meeting
  - Stop Live Captioning meeting
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: live-captioning
---

# Live Captioning for Livestreams - Android

Live captioning enhances your livestreams by converting hosts' speech into text in real-time, boosting accessibility and engagement. Using the `startTranscription()` and `stopTranscription()` methods, you can enable or disable captions on the fly, and display captions dynamically in your UI for all viewers.

Video SDK offers flexible configuration and event-driven updates to help you integrate captions seamlessly into your broadcast layout.

### `startTranscription()`

The `startTranscription()` method, accesible from the `Meeting` class, is used to initiate live captions in a live stream. 

### `stopTranscription()`

The `stopTranscription()` method, accesible from the `Meeting` class, is used to stop the live captions in a live stream.

#### Example

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
import android.os.Bundle
import android.widget.Button
import androidx.appcompat.app.AppCompatActivity
import live.videosdk.rtc.android.Meeting
import live.videosdk.rtc.android.VideoSDK
import live.videosdk.rtc.android.meeting.SummaryConfig
import live.videosdk.rtc.android.meeting.TranscriptionConfig

class LiveStreamActivity : AppCompatActivity() {

    private lateinit var liveStream: Meeting

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_live_stream)

        // Initialize the meeting (replace with actual meeting ID and token)
        liveStream = VideoSDK.initMeeting(... )

        val startCaptionsButton: Button = findViewById(R.id.btn_start_captions)
        val stopCaptionsButton: Button = findViewById(R.id.btn_stop_captions)

        startCaptionsButton.setOnClickListener {
            startRealtimeTranscription()
        }

        stopCaptionsButton.setOnClickListener {
            stopRealtimeTranscription()
        }
    }

    private fun startRealtimeTranscription() {
        val webhookUrl = "https://www.example.com"

        val summaryConfig = SummaryConfig(
            true,
            "Write summary in sections like Title, Agenda, Speakers, Action Items, Outlines, Notes and Summary"
        )

        val transcriptionConfig = TranscriptionConfig(
            webhookUrl,
            summaryConfig
        )

        liveStream.startTranscription(transcriptionConfig)
    }

    private fun stopRealtimeTranscription() {
        liveStream.stopTranscription()
    }
}
```

</TabItem>

<TabItem value="Java">

```java
public class LiveStreamActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_live_stream);

        // Initialize the meeting
        Meeting liveStream = VideoSDK.initMeeting( ...);

        Button startCaptionsButton = findViewById(R.id.btn_start_captions);
        Button stopCaptionsButton = findViewById(R.id.btn_stop_captions);

        startCaptionsButton.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                startRealtimeTranscription();
            }
        });

        stopCaptionsButton.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                stopRealtimeTranscription();
            }
        });
    }

    private void startRealtimeTranscription() {
        String webhookUrl = "https://www.example.com";

        SummaryConfig summaryConfig = new SummaryConfig(
                true,
                "Write summary in sections like Title, Agenda, Speakers, Action Items, Outlines, Notes and Summary"
        );

        TranscriptionConfig transcriptionConfig = new TranscriptionConfig(
                webhookUrl,
                summaryConfig
        );

        liveStream.startTranscription(transcriptionConfig);
    }

    private void stopRealtimeTranscription() {
        liveStream.stopTranscription();
    }
}
```

</TabItem>

</Tabs>


### Events associated with live captioning

- All [participants-including all the hosts and audience members](/android/guide/video-and-audio-calling-api-sdk/concept-and-architecture#2-participant) will receive a callback on the [`onTranscriptionStateChanged`](/android/api/sdk-reference/meeting-class/meeting-event-listener-class#ontranscriptionstatechanged) event with the current state of the captioning.
- All [participants-including all the hosts and audience members](/android/guide/video-and-audio-calling-api-sdk/concept-and-architecture#2-participant) will receive a callback on the [`onTranscriptionText`](/android/api/sdk-reference/meeting-class/meeting-event-listener-class#ontranscriptiontext) event with the latest captions whenever a host speaks.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
private val meetingEventListener: MeetingEventListener = object : MeetingEventListener() {
  override fun onTranscriptionStateChanged(data: JSONObject) {
    try {
        val status = data.getString("status")
        val id = data.getString("id")
        when (status) {
            TranscriptionState.TRANSCRIPTION_STARTING.name -> Log.d("onTranscriptionStateChanged", "Realtime Transcription is starting, ID: $id")
            TranscriptionState.TRANSCRIPTION_STARTED.name -> Log.d("onTranscriptionStateChanged", "Realtime Transcription is started, ID: $id")
            TranscriptionState.TRANSCRIPTION_STOPPING.name -> Log.d("onTranscriptionStateChanged", "Realtime Transcription is stopping, ID: $id")
            TranscriptionState.TRANSCRIPTION_STOPPED.name -> Log.d("onTranscriptionStateChanged", "Realtime Transcription is stopped, ID: $id")
            else -> Log.d("onTranscriptionStateChanged", "Unknown transcription state: $status, ID: $id")
        }
    } catch (e: JSONException) {
        Log.e("onTranscriptionStateChanged", "Error parsing transcription state", e)
    }
  }

  override fun onTranscriptionText(data: TranscriptionText) {
    val participantId: String = data.participantId
    val participantName: String = data.participantName
    val text: String = data.text
    val timestamp: Int = data.timestamp
    val type: String = data.type

    Log.d("onTranscriptionText", "$participantName: $text $timestamp")
  }
}

override fun onCreate(savedInstanceState: Bundle?) {
  //...

  // add listener to meeting
  liveStream!!.addEventListener(meetingEventListener)
}
```

</TabItem>

<TabItem value="Java">

```java
private final MeetingEventListener meetingEventListener = new MeetingEventListener() {
  @Override
    public void onTranscriptionStateChanged(JSONObject data) {
        try {
            String status = data.getString("status");
            String id = data.getString("id");

            if (TranscriptionState.TRANSCRIPTION_STARTING.name().equals(status)) {
                Log.d("onTranscriptionStateChanged", "Realtime Transcription is starting, ID: " + id);
            }
            else if (TranscriptionState.TRANSCRIPTION_STARTED.name().equals(status)) {
                Log.d("onTranscriptionStateChanged", "Realtime Transcription is started, ID: " + id);
            }
            else if (TranscriptionState.TRANSCRIPTION_STOPPING.name().equals(status)) {
                Log.d("onTranscriptionStateChanged", "Realtime Transcription is stopping, ID: " + id);
            }
            else if (TranscriptionState.TRANSCRIPTION_STOPPED.name().equals(status)) {
                Log.d("onTranscriptionStateChanged", "Realtime Transcription is stopped, ID: " + id);
            }
            else {
                Log.d("onTranscriptionStateChanged", "Unknown transcription state: " + status + ", ID: " + id);
            }
        } catch (JSONException e) {
            Log.e("onTranscriptionStateChanged", "Error parsing transcription state", e.getMessage());
        }
    }

    @Override
    public void onTranscriptionText(TranscriptionText data) {
        String participantId = data.getParticipantId();
        String participantName = data.getParticipantName();
        String text = data.getText();
        int timestamp = data.getTimestamp();
        String type = data.getType();

        Log.d("onTranscriptionText", participantName + ": " + text + " " + timestamp);
    }
}

@Override
protected void onCreate(Bundle savedInstanceState) {
  //...

  // add listener to meeting
  liveStream.addEventListener(meetingEventListener);
}
```

</TabItem>

</Tabs>


### API Reference

The API references for all the methods utilized in this guide are provided below.

- [startTranscription()](/android/api/sdk-reference/meeting-class/methods#starttranscription)
- [stopTranscription()](/android/api/sdk-reference/meeting-class/methods#stoptranscription)
- [onTranscriptionStateChanged](/android/api/sdk-reference/meeting-class/meeting-event-listener-class#ontranscriptionstatechanged)
- [onTranscriptionText](/android/api/sdk-reference/meeting-class/meeting-event-listener-class#ontranscriptiontext)


---

---
title: Reactions during Live Stream - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: PubSub features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Reactions
pagination_label: Reactions
keywords:
  - Reactions during Live Stream
  - Livestream
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: reactions-during-livestream
---

# Reactions during Live Stream - Android

To enhance interaction between viewers and speakers during a livestream, a creative approach is to display viewers' reactions to everyone. This can be achieved by creating a lively atmosphere with flying emojis, similar to the experience seen in livestreams on platforms like Instagram.

This guide explains how to implement this engaging feature using the VideoSDK PubSub mechanism.

### Step 1: Creating a button to send reaction

To implement this functionality, start by creating a button that sends reactions to all users. When `Button` is clicked we will send the emoji name to all the participants using the VideoSDK PubSub mechanism and also shows emoji to host.

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
class LiveStreamActivity : AppCompatActivity() {

  override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    //...
    findViewById(R.id.btnReaction).setOnClickListener { v: View? ->
        showEmoji(resources.getDrawable(R.drawable.love_eyes_emoji))
        liveStream!!.pubSub.publish("REACTION", "love_eyes", pubSubPublishOptions)
    }
  }

  private fun showEmoji(drawable: Drawable?) {
    // we will implement this method in step 2
  }
}
```

</TabItem>

<TabItem value="Java">

```js
public class LiveStreamActivity extends AppCompatActivity {
  @Override
  protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    //...
    findViewById(R.id.loveEyes).setOnClickListener(v -> {
        showEmoji(getResources().getDrawable(R.drawable.love_eyes_emoji));
        liveStream.pubSub.publish("REACTION", "love_eyes", pubSubPublishOptions);
    });
  }

  public void showEmoji(Drawable drawable) {
    // we will implement this method in step 2
  }
}
```

</TabItem>

</Tabs>

### Step 2: Displaying the Reactions to all the users

Here we will listen to the `onMessageReceived` event of `PubSubMessageListener` to know someone send the reactions, and show the flying emoji whenever it triggered.

To Display flyingEmoji, we are using `DirectionGenerator` class to specify direction and `ZeroGravityAnimation` class to give animation to the flyingEmoji.

Copy `DirectionGenerator` and `ZeroGravityAnimation` classes from our [code sample](https://github.com/videosdk-live/videosdk-hls-android-kotlin-example/tree/main/app/src/main/java/live/videosdk/android/hlsdemo/common/reactions).

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
class LiveStreamActivity : AppCompatActivity() {

  override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    //...
    var emojiListener =
    PubSubMessageListener { pubSubMessage ->
        when (pubSubMessage.message) {
            //Showing other participants reactions
            "loveEyes" -> showEmoji(resources.getDrawable(R.drawable.love_eyes_emoji))
        }
    }
    //Subscribing to the PubSub topic REACTION to recive other participants reactions.
    //highlight-start
    liveStream!!.pubSub.subscribe("REACTION", emojiListener)
  }
}
```

</TabItem>

<TabItem value="Java">

```js
public class LiveStreamActivity extends AppCompatActivity {
  @Override
  protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    //...
    private PubSubMessageListener pubSubMessageListener = new PubSubMessageListener() {
    @Override
    public void onMessageReceived(PubSubMessage pubSubMessage) {
            switch (pubSubMessage.getMessage()) {
                case "loveEyes":
                    //Showing other participants reactions
                    showEmoji(getResources().getDrawable(R.drawable.love_eyes_emoji));
                    break;
            }

        }
    };
    //Subscribing to the PubSub topic REACTION to recive other participants reactions.
    //highlight-start
    liveStream.pubSub.subscribe("REACTION", emojiListener);
  }
}
```

</TabItem>

</Tabs>

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
private fun showEmoji(drawable: Drawable?) {
    // You can change the number of emojis that will be flying on screen
    for (i in 0..4) {
        flyObject(
            drawable,
            3000,
            DirectionGenerator.Direction.BOTTOM,
            DirectionGenerator.Direction.TOP,
            1f
        )
    }
}

private fun flyObject(
    drawable: Drawable?,
    duration: Int,
    from: DirectionGenerator.Direction?,
    to: DirectionGenerator.Direction?,
    scale: Float
) {
    val animation = ZeroGravityAnimation()
    animation.setCount(1)
    animation.setScalingFactor(scale)
    animation.setOriginationDirection((from)!!)
    animation.setDestinationDirection((to)!!)
    animation.setImage(drawable)
    animation.setDuration(duration)
    animation.setAnimationListener(object : Animation.AnimationListener {
        override fun onAnimationStart(animation: Animation) {}
        override fun onAnimationEnd(animation: Animation) {}
        override fun onAnimationRepeat(animation: Animation) {}
    })
    viewerEmojiHolder!!.bringToFront()
    animation.play(mActivity, viewerEmojiHolder)
}
```

</TabItem>

<TabItem value="Java">

```js
public void showEmoji(Drawable drawable) {
    // You can change the number of emojis that will be flying on screen
    for (int i = 0; i < 5; i++) {
        flyObject(drawable, 3000, DirectionGenerator.Direction.BOTTOM, DirectionGenerator.Direction.TOP, 1);
    }
}

public void flyObject(final Drawable drawable, final int duration, final DirectionGenerator.Direction from, final DirectionGenerator.Direction to, final float scale) {
    ZeroGravityAnimation animation = new ZeroGravityAnimation();
    animation.setCount(1);
    animation.setScalingFactor(scale);
    animation.setOriginationDirection(from);
    animation.setDestinationDirection(to);
    animation.setImage(drawable);
    animation.setDuration(duration);
    animation.setAnimationListener(new Animation.AnimationListener() {
        @Override
        public void onAnimationStart(Animation animation) {

        }

        @Override
        public void onAnimationEnd(Animation animation) {
        }

        @Override
        public void onAnimationRepeat(Animation animation) {

        }
    });
    viewerEmojiHolder.bringToFront();
    animation.play(mActivity, viewerEmojiHolder);
}

```

</TabItem>

</Tabs>

:::note
Here `viewerEmojiHolder` is FrameLayout, you can change recording to your requirement.
:::

<center>

<img style={{height: '450px',marginRight:'15px'}} src="https://cdn.videosdk.live/website-resources/docs-resources/android_emoji_viewer.gif" />

<img style={{height: '450px'}} src="https://cdn.videosdk.live/website-resources/docs-resources/android_emoji_speaker.gif"/>

</center>

### API Reference

The API references for all the methods and events utilised in this guide are provided below.

- [pubSub()](/android/api/sdk-reference/pubsub-class/introduction)


---

---
title: Geo Tag Meeting recordings - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: Geo Tag meeting recordings feature quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Geo Tag Recording
pagination_label: Geo Tag Recording
keywords:
  - Start Recording meeting
  - Stop Recording meeting
  - audio calling
  - video calling
  - geo tag
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: geo-tag-recording
---

# Geo Tag Meeting Recordings - Android

To ensure compliance for BFSIs doing vKYC, it very important to include the co-ordinates(location) of the customer in the recordings. VideoSDK provides a very customizable solution to implement this feature. You will be using custom templates for this purpose.

We have created a ready to use template for this use case which can be found [here](https://github.com/videosdk-live/videosdk-rtc-react-prebuilt-ui/tree/template/geo-tag-watermark). To integrate this template with your recordings follow the below mentiond instructions.

### Host the template

1. Clone the template repository and switch to the branch `template/geo-tag-watermark`.

```bash
git clone https://github.com/videosdk-live/videosdk-rtc-react-prebuilt-ui.git
cd videosdk-rtc-react-prebuilt-ui
git checkout template/geo-tag-watermark
```

2. Install the dependencies and create a build of the project using below mentioned commands.

```bash
npm install
npm run build
```

3. Host the contents of the build folder on your server and check if the template is up and running.

:::note

If you want to create the complete template from scratch you can [follow this guide.](/android/guide/video-and-audio-calling-api-sdk/live-streaming/custom-template)

:::

### Using the template for recording

1. To use the template that we deployed earlier, we will be using the `templateUrl` feature in the `startRecording` API.
   To generate the template URL, you will have to append the `meetingId`, and `token` has to be added in the query parameters. Also if you are using the template provided above you need to added a few extra paramters mentioned below. Here is the code snippet to generate the URL.

```js
async function main() {
  let meetingId = "Your MeetingID";
  let token = "Your Token";
  const templateUrl = `https://${YOUR Template URL}/?meetingId=${meetingId}&token=${token}&name=recorder&isRecorder=true&joinWithoutUserInteraction=true`;

  console.log(templateUrl);
}

main();
```

2. Now that we have the template URL, we will use this URL to start the recording using the below provided API call.

```js
async function main() {
  let meetingId = "Your MeetingID";
  let token = "Your Token";
  const templateUrl = `https://${YOUR Template URL}/?meetingId=${meetingId}&token=${token}&name=recorder&isRecorder=true&joinWithoutUserInteraction=true`;

  console.log(templateUrl);

  //Using the previouly created template URL and starting the recording using the API.
  const options = {
    method: "POST",
    headers: {
      Authorization: "$YOUR_TOKEN",
      "Content-Type": "application/json",
    },
    body: JSON.stringify({
      roomId: "Your MeetingId",
      templateUrl: templateUrl,
    }),
  };
  const url = `https://api.videosdk.live/v2/recordings/start`;
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
}

main();
```

### Updating the Geo Tagging Coordinates

We will be using the PubSub feature of VideoSDK to update the data of latitude and longitude. For the predefined template provided by us we are using `GEO_TAG` as topic name. We will be publishing the `participantName`, `latitude` and `longitude` of the participant for whom we want to show in the recording.

:::note

You will have to fetch the longitude and latitude of the participant before sending it using the pubsub.

:::

Here is the code how you will have to publish the message:

```js
function Watermark() {
  const { messages, publish } = usePubSub("GEO_TAG");

  const sendCoordinates = () => {
    publish(
      "GEO TAG DATA",
      { persist: true },
      {
        latitude: "LATITUDE OF PARTICIPANT",
        longitude: "LONGITUDE OF PARTICIPANT",
        participantName: "NAME OF PARTICIPANT",
      }
    );
  };

  return <></>;
}
```

After implementing this, you should get the recording in the following format:

![Geo Tagging Recoridng](https://cdn.videosdk.live/website-resources/docs-resources/geo-tag-recording-template.png)

If you wish to change how UI looks on recording, you can change it by updating the layout in the template itself.

### API Reference

The API references for all the methods utilized in this guide are provided below.

- [Start Recording API](/api-reference/realtime-communication/start-recording)
- [Learn more about Custom Templates](/android/guide/video-and-audio-calling-api-sdk/live-streaming/custom-template)


---

---
title: Recording Overview - Android
hide_title: false
hide_table_of_contents: false
description: Record Meeting features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Overview
pagination_label: Overview
keywords:
  - Overview
  - Start Recording meeting
  - Stop Recording meeting
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: Overview
---

import Overview from '../../../../../mdx/\_recording-overview.mdx';

<Overview title="Recording Overview"/>


---

---
title: Generate presigned URL - Android
hide_title: false
hide_table_of_contents: false
description: presigned URL features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Generate presigned URL
pagination_label: Generate presigned URL
keywords:
  - Start Recording meeting
  - Stop Recording meeting
  - audio calling
  - video calling
  - real-time communication
  - presigned URL
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: presigned-URL
---

import PreSignedUrl from '../../../../../mdx/\_presigned-url.mdx';

<PreSignedUrl title="Generate presigned URL - React"/>


---

---
title: Record Live Stream - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: Record Live Stream features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Record Live Stream
pagination_label: Record Live Stream
keywords:
  - Start Recording Live Stream
  - Stop Recording Live Stream
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: recording
---

# Recording in Live Stream - Android

This guide will provide an overview of how to implement start and stop Recording during a live stream.

### `startRecording()`

`startRecording()` can be used to start a recording of the meeting which can be accessed from the `Meeting` class. This method accepts four parameters:

- `1. webhookUrl`: This would the webhook URL where you would like to listen to event happening for the recording like starting and stopping of recording. It will be triggered when the recording is completed and stored into server. Read more about webhooks [here](https://en.wikipedia.org/wiki/Webhook)

- `2. awsDirPath`: This parameter accepts the path for the your S3 bucket where you want to store recordings to. To allow us to store recording in your S3 bucket, you will need to fill this form by providing the required values. ([VideoSDK Cloud (AWS S3, Azure Blob or GCP ) Integration](/android/guide/video-and-audio-calling-api-sdk/recording/recording-storage-config))

- `3. config`: This parameter will define how the meeting should be recorded.

- `4. transcription`: This parameter lets you start post transcription for the recording.

:::note

If you don't have a value for `webhookUrl`,`awsDirPath` or `config`, you should pass `null` in place of the missing value. If you pass `null` in `awsDirPath` parameter then by default recordings will be store on the VideoSDK's storage.
:::

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
val config = JSONObject()

//highlight-next-line
// Layout Configuration
val layout = JSONObject()
JsonUtils.jsonPut(layout, "type", "GRID") // "SPOTLIGHT" | "SIDEBAR",  Default : "GRID"
JsonUtils.jsonPut(layout, "priority", "SPEAKER") // "PIN", Default : "SPEAKER"
JsonUtils.jsonPut(layout, "gridSize", 4) // MAX : 4
JsonUtils.jsonPut(config, "layout", layout)

//highlight-next-line
// Theme of recording
JsonUtils.jsonPut(config, "theme", "DARK") //  "LIGHT" | "DEFAULT"

//highlight-next-line
// `mode` is used to either record video & audio both or only audio.
JsonUtils.jsonPut(config, "mode", "video-and-audio") // "audio", Default : "video-and-audio"

//highlight-next-line
// Quality of recording and is only applicable to `video-and-audio` type mode.
JsonUtils.jsonPut(config, "quality", "high") // "low" | "med",  Default : "med"

//highlight-start
// This mode refers to orientation of recording.
// landscape : Record the meeting in horizontally
// portrait : Record the meeting in vertically (Best for mobile view)
//highlight-end
JsonUtils.jsonPut(config, "orientation", "portrait") // "landscape",  Default : "landscape"

//highlight-next-line
// Post Transcription Configuration
val prompt = "Write summary in sections like Title, Agenda, Speakers, Action Items, Outlines, Notes and Summary"
val summaryConfig = SummaryConfig(true, prompt)
val modelId = "raman_v1"
val transcription = PostTranscriptionConfig(true, summaryConfig, modelId)

meeting.startRecording(null, null, config, transcription)
```

</TabItem>

<TabItem value="Java">

```js
JSONObject config = new JSONObject();

//highlight-next-line
// Layout Configuration
JSONObject layout = new JSONObject();
JsonUtils.jsonPut(layout, "type", "GRID"); // "SPOTLIGHT" | "SIDEBAR",  Default : "GRID"
JsonUtils.jsonPut(layout, "priority", "SPEAKER");  // "PIN", Default : "SPEAKER"
JsonUtils.jsonPut(layout, "gridSize", 4); // MAX : 4
JsonUtils.jsonPut(config, "layout", layout);

//highlight-next-line
// Theme of recording
JsonUtils.jsonPut(config, "theme", "DARK"); //  "LIGHT" | "DEFAULT"

//highlight-next-line
// `mode` is used to either record video & audio both or only audio.
JsonUtils.jsonPut(config, "mode", "video-and-audio"); // "audio", Default : "video-and-audio"

//highlight-next-line
// Quality of recording and is only applicable to `video-and-audio` type mode.
JsonUtils.jsonPut(config, "quality", "high"); // "low" | "med",  Default : "med"

//highlight-start
// This mode refers to orientation of recording.
// landscape : Record the meeting in horizontally
// portrait : Record the meeting in vertically (Best for mobile view)
//highlight-end
JsonUtils.jsonPut(config, "orientation", "portrait"); // "landscape",  Default : "landscape"

//highlight-next-line
// Post Transcription Configuration
String prompt = "Write summary in sections like Title, Agenda, Speakers, Action Items, Outlines, Notes and Summary";
SummaryConfig summaryConfig = new SummaryConfig(true, prompt);
String modelId = "raman_v1";
PostTranscriptionConfig transcription = new PostTranscriptionConfig(true, summaryConfig, modelId);

meeting.startRecording(null, null, config, transcription);
```

</TabItem>

</Tabs>

### `stopRecording()`

- `stopRecording()` is used to stop the meeting recording which can be accessed from the `Meeting` class.

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
// keep track of recording
val recording = false

findViewById<View>(R.id.btnRecording).setOnClickListener { view: View? ->
    if (!recording) {
      //highlight-start
      val config = JSONObject()
      val layout = JSONObject()
      JsonUtils.jsonPut(layout, "type", "GRID")
      JsonUtils.jsonPut(layout, "priority", "SPEAKER")
      JsonUtils.jsonPut(layout, "gridSize", 4)
      JsonUtils.jsonPut(config, "layout", layout)
      JsonUtils.jsonPut(config, "theme", "DARK")
      JsonUtils.jsonPut(config, "mode", "video-and-audio")
      JsonUtils.jsonPut(config, "quality", "high")
      JsonUtils.jsonPut(config, "orientation", "portrait")
      //highlight-end

      //highlight-next-line
      // Post Transcription Configuration
      val prompt = "Write summary in sections like Title, Agenda, Speakers, Action Items, Outlines, Notes and Summary"
      val summaryConfig = SummaryConfig(true, prompt)
      val modelId = "raman_v1"
      val transcription = PostTranscriptionConfig(true, summaryConfig, modelId)

      // Start Recording
      // If you don't have a `webhookUrl` or `awsDirPath`, you should pass null.
      // If you don't want to enable transcription, you can pass null as parameter.
      //highlight-next-line
      meeting!!.startRecording("YOUR WEB HOOK URL", "AWS Directory Path", config, transcription)
    } else {
      // Stop Recording
      //highlight-next-line
      meeting!!.stopRecording()
    }
}
```

</TabItem>

<TabItem value="Java">

```js
// keep track of recording
boolean recording = false;

findViewById(R.id.btnRecording).setOnClickListener(view -> {
    if (!recording) {
      //highlight-start
      JSONObject config = new JSONObject();
      JSONObject layout = new JSONObject();
      JsonUtils.jsonPut(layout, "type", "GRID");
      JsonUtils.jsonPut(layout, "priority", "SPEAKER");
      JsonUtils.jsonPut(layout, "gridSize", 4);
      JsonUtils.jsonPut(config, "layout", layout);
      JsonUtils.jsonPut(config, "theme", "DARK");
      JsonUtils.jsonPut(config, "mode", "video-and-audio");
      JsonUtils.jsonPut(config, "quality", "high");
      JsonUtils.jsonPut(config, "orientation", "portrait");
      //highlight-end

      //highlight-next-line
      // Post Transcription Configuration
      String prompt = "Write summary in sections like Title, Agenda, Speakers, Action Items, Outlines, Notes and Summary";
      SummaryConfig summaryConfig = new SummaryConfig(true, prompt);
      String modelId = "raman_v1";
      PostTranscriptionConfig transcription = new PostTranscriptionConfig(true, summaryConfig, modelId);

      // Start Recording
      // If you don't have a `webhookUrl` or `awsDirPath`, you should pass null.
      // If you don't want to enable transcription, you can pass null as parameter.
      //highlight-next-line
      meeting.startRecording("YOUR WEB HOOK URL", "AWS Directory Path", config, transcription);
    } else {
      // Stop Recording
      //highlight-next-line
      meeting.stopRecording();
    }
});
```

</TabItem>

</Tabs>

:::important

To initiate automatic recording at the beginning of a `session`, simply provide the `autoStartConfig` feature `recording` during `room` creation. For more information on configuring the `autoStartConfig`, please refer to the provided documentation **[<u>here</u>](/api-reference/realtime-communication/create-room#autoStartConfig)**.

:::

### API Reference

The API references for all the methods utilised in this guide are provided below.

- [startRecording()](/android/api/sdk-reference/meeting-class/methods#startrecording)
- [stopRecording()](/android/api/sdk-reference/meeting-class/methods#stoprecording)
- [onRecordingStateChanged](/android/api/sdk-reference/meeting-class/meeting-event-listener-class#onrecordingstatechanged)
- [autoStartConfig](/api-reference/realtime-communication/create-room#autoStartConfig)


---

---
title: Participant Recording (Individual) - Android
hide_title: false
hide_table_of_contents: false
description: Individual participant recording features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Participant Recording (Individual)
pagination_label: Participant Recording
keywords:
  - Start Participant Recording
  - Stop Participant Recording
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: record-participant
---

import RecordParticipant from '../../../../../mdx/\_intro-participant-recording.mdx';
import WebhookParticipantRecording from '../../../../../mdx/\_webhook-participant-recording.mdx';

<RecordParticipant title="Record Participant"/>

## Start Individual Participant Recording

To start a participant recording, you will have to call `/v2/recordings/participant/start` API with following body parameters.

- `roomId`: RoomId for which the participant recording is to be started
- `participantId`: participantId of the participant to be recorder.
- `fileFormat`: Currently only `webm` is supported as file format. We will add the support for other formats in future.
- `webhookUrl`: The webhook URL where you would like to get the status updates of the recording. To learn more about webhooks refer [here](#participant-track-recording-starting).
- `bucketDirPath`: If you are using your own storage, you can provide the directory path where you want to store the recording. To configure the storage please [refere this quide](/javascript/guide/video-and-audio-calling-api-sdk/recording/recording-storage-config).

The usual recording path would look like `${sessionId}/${participantId}/${filename}`.

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'}]}>

<TabItem value="Kotlin">

```kotlin
import org.json.JSONObject
import java.io.OutputStream
import java.net.HttpURLConnection
import java.net.URL
import java.io.IOException

fun StartParticipantRecording() {
    val roomId = "<YOUR ROOM ID>"
    val participantId = "<PARTICIPANT ID>"
    val fileFormat = "<YOUR FILE FORMAT>" // (Optional) default: webm
    val bucketDirPath = "<YOUR CLOUD STORAGE BUCKET PATH>" // (Optional) test/abc
    val webhookUrl = "<YOUR WEBHOOK URL>" // (Optional)

    try {
        val url = URL("https://api.videosdk.live/v2/recordings/participant/start")
        val conn = url.openConnection() as HttpURLConnection
        conn.requestMethod = "POST"
        conn.setRequestProperty("Authorization", "$YOUR_TOKEN")
        conn.setRequestProperty("Content-Type", "application/json")
        conn.doOutput = true

        val json = JSONObject()
        json.put("roomId", roomId)
        json.put("participantId", participantId)
        json.put("fileFormat", fileFormat)
        json.put("bucketDirPath", bucketDirPath)
        json.put("webhookUrl", webhookUrl)

        conn.outputStream.use { os: OutputStream ->
            val input = json.toString().toByteArray(Charsets.UTF_8)
            os.write(input, 0, input.size)
        }

        val responseCode = conn.responseCode
        if (responseCode == HttpURLConnection.HTTP_OK) {
            println("Participant Recording started successfully.")
        } else {
            println("Failed to start participant recording.")
        }
    } catch (e: Exception) {
        e.printStackTrace()
    }
}

```

</TabItem>

<TabItem value="Java">

```java
import java.io.OutputStream;
import java.net.HttpURLConnection;
import java.net.URL;
import org.json.JSONObject;

private void StartParticipantRecording() {
    String roomId = "<YOUR ROOM ID>";
    String participantId = "<PARTICIPANT ID>";
    String fileFormat = "<YOUR FILE FORMAT>"; // (Optional) default: webm
    String bucketDirPath = "<YOUR CLOUD STORAGE BUCKET PATH>"; // (Optional) test/abc
    String webhookUrl = "<YOUR WEBHOOK URL>"; // (Optional)

    try {
        URL url = new URL("https://api.videosdk.live/v2/recordings/participant/start");
        HttpURLConnection conn = (HttpURLConnection) url.openConnection();
        conn.setRequestMethod("POST");
        conn.setRequestProperty("Authorization", "$YOUR_TOKEN");
        conn.setRequestProperty("Content-Type", "application/json");
        conn.setDoOutput(true);

        JSONObject json = new JSONObject();
        json.put("roomId", roomId);
        json.put("participantId", participantId);
        json.put("fileFormat", fileFormat);
        json.put("bucketDirPath", bucketDirPath);
        json.put("webhookUrl", webhookUrl);

        try (OutputStream os = conn.getOutputStream()) {
            byte[] input = json.toString().getBytes("utf-8");
            os.write(input, 0, input.length);
        }

        int responseCode = conn.getResponseCode();
        if (responseCode == HttpURLConnection.HTTP_OK) {
            System.out.println("Participant Recording started successfully.");
        } else {
            System.out.println("Failed to start participant recording.");
        }
    } catch (Exception e) {
        e.printStackTrace();
    }
}

```

</TabItem>

</Tabs>

## Stop Individual Participant Recording

To stop a participant recording, you will have to call `/v2/recordings/participant/stop` API with following body parameters.

- `roomId`: RoomId for which the participant recording is to be stopped
- `participantId`: participantId for which the recording is to be stopped.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```kotlin
import org.json.JSONObject
import java.io.OutputStream
import java.net.HttpURLConnection
import java.net.URL

fun StopParticipantRecording() {
val roomId = "<YOUR ROOM ID>"
val participantId = "<PARTICIPANT ID>"

    try {
        val url = URL("https://api.videosdk.live/v2/recordings/participant/stop")
        val conn = url.openConnection() as HttpURLConnection
        conn.requestMethod = "POST"
        conn.setRequestProperty("Authorization", "$YOUR_TOKEN")
        conn.setRequestProperty("Content-Type", "application/json")
        conn.doOutput = true

        val json = JSONObject()
        json.put("roomId", roomId)
        json.put("participantId", participantId)

        conn.outputStream.use { os: OutputStream ->
            val input = json.toString().toByteArray(Charsets.UTF_8)
            os.write(input, 0, input.size)
        }

        val responseCode = conn.responseCode
        if (responseCode == HttpURLConnection.HTTP_OK) {
            println("Participant Recording stopped successfully.")
        } else {
            println("Failed to stop participant recording.")
        }
    } catch (e: Exception) {
        e.printStackTrace()
    }

}

```

</TabItem>

<TabItem value="Java">

```java
import java.io.OutputStream;
import java.net.HttpURLConnection;
import java.net.URL;
import org.json.JSONObject;

private void StopParticipantRecording() {
    String roomId = "<YOUR ROOM ID>";
    String participantId = "<PARTICIPANT ID>";

    try {
        URL url = new URL("https://api.videosdk.live/v2/recordings/participant/stop");
        HttpURLConnection conn = (HttpURLConnection) url.openConnection();
        conn.setRequestMethod("POST");
        conn.setRequestProperty("Authorization", "$YOUR_TOKEN");
        conn.setRequestProperty("Content-Type", "application/json");
        conn.setDoOutput(true);

        JSONObject json = new JSONObject();
        json.put("roomId", roomId);
        json.put("participantId", participantId);

        try (OutputStream os = conn.getOutputStream()) {
            byte[] input = json.toString().getBytes("utf-8");
            os.write(input, 0, input.length);
        }

        int responseCode = conn.getResponseCode();
        if (responseCode == HttpURLConnection.HTTP_OK) {
            System.out.println("Participant Recording stopped successfully.");
        } else {
            System.out.println("Failed to stop participant recording.");
        }
    } catch (Exception e) {
        e.printStackTrace();
    }
}


```

</TabItem>

</Tabs>

<WebhookParticipantRecording title="Webhooks"/>


---

---
title: Participant Track Recording - Android
hide_title: false
hide_table_of_contents: false
description: Participant track recording features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Participant Track Recording
pagination_label: Participant Track Recording
keywords:
  - Start Track Recording
  - Start Track Recording
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: record-track
---
import RecordTrack from '../../../../../mdx/\_intro-track-recording.mdx';
import WebhookTrackRecording from '../../../../../mdx/\_webhook-track-recording.mdx';

<RecordTrack title="Record Track"/>

## Start Participant Track Recording

To start a participant track recording, you will have to call `/v2/recordings/participant/track/start` API with following body parameters.

- `roomId`: RoomId for which the participant track recording is to be started
- `participantId`: participantId of the participant to be recorder.
- `kind`: The kind of tracks you want to record.
  - You can pass following values: _`audio`_ | _`video`_ | _`screen_audio`_ | _`screen_video`_
- `fileFormat`: Currently only `webm` is supported as file format. We will add the support for other formats in future.
- `webhookUrl`: The webhook URL where you would like to get the status updates of the recording. To learn more about webhooks refer [here](#participant-track-recording-starting).
- `bucketDirPath`: If you are using your own storage, you can provide the directory path where you want to store the recording. To configure the storage please [refere this quide](/javascript/guide/video-and-audio-calling-api-sdk/recording/recording-storage-config).

The usual recording path would look like `${sessionId}/${participantId}/${kind}/${filename}`.

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'}]}>

<TabItem value="Kotlin">

```kotlin
import org.json.JSONObject
import java.io.OutputStream
import java.net.HttpURLConnection
import java.net.URL
import java.io.IOException

fun StartTrackRecording() {
    val roomId = "<YOUR ROOM ID>"
    val participantId = "<PARTICIPANT ID>"
    val kind = "<YOUR STREAM KIND>"
    val fileFormat = "<YOUR FILE FORMAT>"
    val bucketDirPath = "<YOUR CLOUD STORAGE BUCKET PATH>"
    val webhookUrl = "<YOUR WEBHOOK URL>"

    try {
        val url = URL("https://api.videosdk.live/v2/recordings/participant/track/start")
        val conn = url.openConnection() as HttpURLConnection
        conn.requestMethod = "POST"
        conn.setRequestProperty("Authorization", "$YOUR_TOKEN")
        conn.setRequestProperty("Content-Type", "application/json")
        conn.doOutput = true

        val jsonBody = JSONObject()
        jsonBody.put("roomId", roomId)
        jsonBody.put("participantId", participantId)
        jsonBody.put("kind", kind)
        jsonBody.put("fileFormat", fileFormat)
        jsonBody.put("bucketDirPath", bucketDirPath)
        jsonBody.put("webhookUrl", webhookUrl)

        conn.outputStream.use { os: OutputStream ->
            val input = json.toString().toByteArray(Charsets.UTF_8)
            os.write(input, 0, input.size)
        }

        val responseCode = conn.responseCode
        if (responseCode == HttpURLConnection.HTTP_OK) {
            println("Track Recording started successfully.")
        } else {
            println("Failed to start track recording.")
        }
    } catch (e: Exception) {
        e.printStackTrace()
    }
}



```

</TabItem>

<TabItem value="Java">

```java
import java.io.OutputStream;
import java.net.HttpURLConnection;
import java.net.URL;
import org.json.JSONObject;

public void StartTrackRecording() {
    String roomId = "<YOUR ROOM ID>";
    String participantId = "<PARTICIPANT ID>";
    String kind = "<YOUR STREAM KIND>";
    String fileFormat = "<YOUR FILE FORMAT>";
    String bucketDirPath = "<YOUR CLOUD STORAGE BUCKET PATH>";
    String webhookUrl = "<YOUR WEBHOOK URL>";

    try {
        URL url = new URL("https://api.videosdk.live/v2/recordings/participant/track/start");
        HttpURLConnection conn = (HttpURLConnection) url.openConnection();
        conn.setRequestMethod("POST");
        conn.setRequestProperty("Authorization", "$YOUR_TOKEN");
        conn.setRequestProperty("Content-Type", "application/json");
        conn.setDoOutput(true);

        JSONObject jsonBody = new JSONObject();
        jsonBody.put("roomId", roomId);
        jsonBody.put("participantId", participantId);
        jsonBody.put("kind", kind);
        jsonBody.put("fileFormat", fileFormat);
        jsonBody.put("bucketDirPath", bucketDirPath);
        jsonBody.put("webhookUrl", webhookUrl);

        try (OutputStream os = conn.getOutputStream()) {
        byte[] input = json.toString().getBytes("utf-8");
        os.write(input, 0, input.length);
        }

        int responseCode = conn.getResponseCode();
        if (responseCode == HttpURLConnection.HTTP_OK) {
            System.out.println("Track Recording started successfully.");
        } else {
            System.out.println("Failed to start track recording.");
        }
    } catch (Exception e) {
        e.printStackTrace();
    }
}

```

</TabItem>

</Tabs>

## Stop Participant Track Recording

To stop a participant track recording, you will have to call `/v2/recordings/participant/track/stop` API with following body parameters.

- `roomId`: RoomId for which the participant track recording is to be stopped
- `participantId`: participantId for which the recording is to be stopped.
- `kind`: The kind of track recording you want to stop for the given participant.
  - You can pass following values: _`audio`_ | _`video`_ | _`screen_audio`_ | _`screen_video`_

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```kotlin
import org.json.JSONObject
import java.io.OutputStream
import java.net.HttpURLConnection
import java.net.URL

fun StopTrackRecording() {
    val roomId = "<YOUR ROOM ID>"
    val participantId = "<PARTICIPANT ID>"
    val kind = "<YOUR STREAM KIND>"

    try {
        val url = URL("https://api.videosdk.live/v2/recordings/participant/track/stop")
        val conn = url.openConnection() as HttpURLConnection
        conn.requestMethod = "POST"
        conn.setRequestProperty("Authorization", "$YOUR_TOKEN")
        conn.setRequestProperty("Content-Type", "application/json")
        conn.doOutput = true

        val jsonBody = JSONObject()
        jsonBody.put("roomId", roomId)
        jsonBody.put("participantId", participantId)
        jsonBody.put("kind", kind)

        conn.outputStream.use { os: OutputStream ->
            val input = json.toString().toByteArray(Charsets.UTF_8)
            os.write(input, 0, input.size)
        }

        val responseCode = conn.responseCode
        if (responseCode == HttpURLConnection.HTTP_OK) {
            println("Track Recording stopped successfully.")
        } else {
            println("Failed to stop track recording.")
        }
    } catch (e: Exception) {
        e.printStackTrace()
    }
}

```

</TabItem>

<TabItem value="Java">

```java
import java.io.OutputStream;
import java.net.HttpURLConnection;
import java.net.URL;
import org.json.JSONObject;

public void StopTrackRecording() {
    String roomId = "<YOUR ROOM ID>";
    String participantId = "<PARTICIPANT ID>";
    String kind = "<YOUR STREAM KIND>";


    try {
        URL url = new URL("https://api.videosdk.live/v2/recordings/participant/track/stop");
        HttpURLConnection conn = (HttpURLConnection) url.openConnection();
        conn.setRequestMethod("POST");
        conn.setRequestProperty("Authorization", "$YOUR_TOKEN");
        conn.setRequestProperty("Content-Type", "application/json");
        conn.setDoOutput(true);

        JSONObject jsonBody = new JSONObject();
        jsonBody.put("roomId", roomId);
        jsonBody.put("participantId", participantId);
        jsonBody.put("kind", kind);

        try (OutputStream os = conn.getOutputStream()) {
        byte[] input = json.toString().getBytes("utf-8");
        os.write(input, 0, input.length);
        }

        int responseCode = conn.getResponseCode();
        if (responseCode == HttpURLConnection.HTTP_OK) {
            System.out.println("Track Recording stopped successfully.");
        } else {
            System.out.println("Failed to stop track recording.");
        }
    } catch (Exception e) {
        e.printStackTrace();
    }
}

```

</TabItem>

</Tabs>

<WebhookTrackRecording title="Webhooks" />


---

---
title: Configure Recording Storage - Android
hide_title: false
hide_table_of_contents: false
sidebar_label: Configure Recording Storage
sidebar_position: 1
pagination_label: Configure Recording Storage
keywords:
  - configure recording storage
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
slug: recording-storage-config
---

### Storage Configuration

While recording your meetings, you have the flexibility to store them either on VideoSDK's storage or configure your own storage solution such as **`AWS S3 Storage, Azure Blob or GCP Cloud Storage`**. To set up your own storage, you can navigate to the [API section](https://app.videosdk.live/api-keys) in the VideoSDK Dashboard.

- This feature allows you to configure storage provider for your meeting recordings.

- You can configure multiple storage provider with multiple API Keys.

- Currently, we support `AWS S3`, `Azure Blob` and `GCP Cloud Storage`. We will add support for other storage provider soon !!

## Prerequisites

- An active [VideoSDK Developer Account](https://app.videosdk.live)
- `Aws S3`, `Azure Blob Storage` or `GCP Cloud Storage` Credentials

## How to setup ?

### Step 1 : Select Api Key

<div style={{textAlign: 'center'}}>

![Dashboard](/img/tutorial/dashboard/api-key-dashboard.png)

</div>

- Go to [VideoSDK Dashboard](https://app.videosdk.live/api-keys).
- Select API Key for which, you want to set storage configuration.
- Then click on `Storage Config` Icon in Actions.

### Step 2 : Choose Cloud Storage Provider

![Dashboard](/img/tutorial/dashboard/storage-config.png)

- As you can see in the image, there are 3 Cloud Storage Provider (`Aws`, `Azure`, `GCP`).
- You can select a Cloud Storage Provider as per your requirements.

### Step 3 : Configure Bucket or Container

<h4> For Aws S3 Storage </h4>

![Aws S3](/img/tutorial/dashboard/s3.png)

- You will need AWS S3 Bucket. [Learn to create S3 Bucket](https://docs.aws.amazon.com/AmazonS3/latest/userguide/creating-bucket.html).

- As you can see in the image, you will need enter `accessKeyId`, `secretAccessKey`, `region`, `bucket`, and `ACL` to setup for Aws S3 Storage.

- Click on `Save` button.

<hr />

<h4> For Azure Blob Storage: </h4>

![Azure Blob](/img/tutorial/dashboard/blob.png)

- You will need Azure Blob Container. [Learn to create Blob Container](https://docs.microsoft.com/en-us/azure/storage/blobs/storage-quickstart-blobs-portal#create-a-container).

- As you can see in the image, you will need to enter `connectionString` and `containerName` to setup for Azure Blob.

- Click on `Save` button.

<hr />

<h4> For Google Cloud Storage: </h4>

<img src="/img/tutorial/dashboard/gcp.png" alt="GCP Cloud Storage" width="436" height="632"/>

1. You will need Google Cloud Storage Bucket. [Learn to create Google Cloud Storage Bucket](https://cloud.google.com/storage/docs/creating-buckets).

2. After creation, click on the <b> &#xFE19; </b>button in the upper right corner and select **`Project settings`**.

3. Under **`IAM and Admin`**, select **`Service Accounts`**. In the service account list, click on the <b> &#xFE19; </b> button for the account just added or created before, and select **`Manage keys`**.

4. Click **`ADD KEY > Create new key`**. Select **`JSON`** in the pop-up box and click **`CREATE`**. A json file is downloaded with the name format `projectId-xxxxxxxx.json`.

5. Open the downloaded json file, which looks like the following example:

```
{
  "type": "service_account",
  "project_id": "videosdk-12345",
  "private_key_id": "yourprivateidkeyyourprivateidkeyyourprivateidkey",
  "private_key": "-----BEGIN PRIVATE KEY-----\nThisisYourPrivateKeyThisisYourPrivateKeyThisisYourPrivateKey\nThisisYourPrivateKey\nThisisYourPrivateKey\nThisisYourPrivateKey\n-----END PRIVATE KEY-----\n",
  "client_email": "xxxx-xxxx@videosdk-12345.iam.gserviceaccount.com",
  "client_id": "123456789012345678901",
  "auth_uri": "https://accounts.google.com/o/oauth2/auth",
  "token_uri": "https://oauth2.googleapis.com/token",
  "auth_provider_x509_cert_url": "https://www.googleapis.com/oauth2/v1/certs",
  "client_x509_cert_url": "https://www.googleapis.com/robot/v1/metadata/x509/videosdk%40videosdk-404307.iam.gserviceaccount.com",
  "universe_domain": "googleapis.com"
}
```

- As you can see in the image, you will need to enter `Project Id`, `Client Email`, `Bucket`, `Private Key` to setup for Google Cloud Storage Bucket. You can retrieve these details from the json file.

- Click on `Save` button.

### Step 4 : Test

- It's time to test !!
- [Create Room](https://docs.videosdk.live/api-reference/realtime-communication/create-room) with token generated with the API Key, you have configured for.
- Start meeting with the roomId created and Start Recording !!
- Then, you can see that recording will be available in your Bucket or Container.

:::note

- Only a single Recording Storage Config can be possible for a particular Api Key at a time.
- In order to add new Recording Configuration, first you need to delete current configuration.

:::


---

---
title: Record Meeting Video & Audio Call - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: Record Meeting features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Webhook and Events
pagination_label: Webhook and Events
keywords:
  - Start Recording meeting
  - Stop Recording meeting
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: webhook-and-events
---

# Webhooks and Events - Android

### Event associated with Recording

- **onRecordingStateChanged** - Whenever recording state changes, then `onRecordingStateChanged` event will trigger.

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
private val meetingEventListener: MeetingEventListener = object : MeetingEventListener() {
  override fun onRecordingStateChanged(recordingState: String) {
    when (recordingState) {
        "RECORDING_STARTING" -> {
            Log.d("onRecordingStateChanged", "Meeting recording is starting")
        }
        "RECORDING_STARTED" -> {
            Log.d("onRecordingStateChanged", "Meeting recording is started")
        }
        "RECORDING_STOPPING" -> {
            Log.d("onRecordingStateChanged", "Meeting recording is stopping")
        }
        "RECORDING_STOPPED" -> {
            Log.d("onRecordingStateChanged", "Meeting recording is stopped")
        }
    }
  }
}

override fun onCreate(savedInstanceState: Bundle?) {
  //...

  // add listener to meeting
  //highlight-next-line
  liveStream!!.addEventListener(meetingEventListener)
}
```

</TabItem>

<TabItem value="Java">

```js
private final MeetingEventListener meetingEventListener = new MeetingEventListener() {
  @Override
  public void onRecordingStateChanged(String recordingState) {
      switch (recordingState) {
          case "RECORDING_STARTING":
              Log.d("onRecordingStateChanged", "Meeting recording is starting");
              break;
          case "RECORDING_STARTED":
              Log.d("onRecordingStateChanged", "Meeting recording is started");
              break;
          case "RECORDING_STOPPING":
              Log.d("onRecordingStateChanged", "Meeting recording is stopping");
              break;
          case "RECORDING_STOPPED":
              Log.d("onRecordingStateChanged", "Meeting recording is stopped");
              break;
      }
  }
}

@Override
protected void onCreate(Bundle savedInstanceState) {
  //...

  // add listener to meeting
  //highlight-next-line
  liveStream.addEventListener(meetingEventListener);
}
```

</TabItem>

</Tabs>

## Webhook associated with Recording

### recording-starting

- A "Recording Starting" webhook is triggered when the recording process for a meeting is initiated.

###### Example

```javascript
{
    "webhookType": "recording-starting",
    "data": {
        "meetingId": "jvsg-8rjn-j304",
        "sessionId": "613731342f27f56e4fc4b6d0",
    },
}
```

---

### recording-started

- Recording started webhook will be received when successfully recording is started in meeting

###### Example

```javascript
{
    "webhookType": "recording-started",
    "data": {
        "meetingId": "jvsg-8rjn-j304",
        "sessionId": "613731342f27f56e4fc4b6d0",
    },
}
```

---

### recording-stopping

- A "Recording Stopping" webhook is triggered when the recording end process for a meeting is initiated.

###### Example

```javascript
{
    "webhookType": "recording-stopping",
    "data": {
        "meetingId": "jvsg-8rjn-j304",
        "sessionId": "613731342f27f56e4fc4b6d0",
    },
}
```

---

### recording-stopped

- Recording stopped webhook will be received when recording is successfully stopped in meeting.

###### Example

```javascript
{
    "webhookType": "recording-stopped",
    "data": {
        "meetingId": "jvsg-8rjn-j304",
        "sessionId": "613731342f27f56e4fc4b6d0",
        "filePath" : "/encoded/videos/62d148951a1eb20029fc9b05.mp4",
        "fileUrl" : "https://cdn.videosdk.live/encoded/videos/62d148951a1eb20029fc9b05.mp4",

    },
}
```

---

### recording-failed

- A "Recording Failed" webhook is generated when the recording process encounters an interruption or issue during either the starting or stopping phases.

###### Example

```javascript
{
    "webhookType": "recording-failed",
    "data": {
        "meetingId": "jvsg-8rjn-j304",
        "sessionId": "613731342f27f56e4fc4b6d0",
    },
}
```


---

---
title: Relay Media | Video SDK
hide_title: true
hide_table_of_contents: false
sidebar_label: Relay Media(PK Host)
pagination_label: Relay Media(PK Host)
image: img/videosdklive-thumbnail.jpg
sidebar_position: 2
slug: relay-media
---

import Mermaid from '@theme/Mermaid';

# Relay Media(PK Host) - Android

## Overview

The Relay Media feature enables hosts to relay their media (audio, video, screen share) to one or multiple other live streams. This creates cross-stream interactions similar to "PK battles" or collaborative broadcasts.

This feature allows audiences in one live stream to view and hear hosts from another live stream without changing rooms, creating powerful interactive experiences.

## Key Concepts

- **Media Relay**: The process of transmitting a host's audio/video from one live stream to another
- **Source Meeting**: The original live stream where the host is broadcasting
- **Destination Meeting**: The target live stream(s) where the host's media will be relayed
- **Relay Kinds**: The types of media that can be relayed (video, audio, screen share, etc.)

## Sequence Diagram

<Mermaid chart={`sequenceDiagram
participant  HostA  as  Host  A
participant  HostB  as  Host  B
participant  AudienceB  as  Audience  B
HostA->>HostB: requestMediaRelay(meetingB_Id, token, kinds)
HostB-->>HostB: mediaRelayRequestReceived  event
alt  Accept
HostB->>HostA: accept()
HostA-->>HostA: mediaRelayRequestResponse("accepted")
HostA-->>HostA: mediaRelayStarted(meetingB_Id)
HostA->>AudienceB: Media  streaming
else  Reject
HostB->>HostA: reject()
HostA-->>HostA: mediaRelayRequestResponse("rejected")
end
HostA->>HostB: stopMediaRelay(meetingB_Id)
HostA-->>HostA: mediaRelayStopped(meetingB_Id, reason);`}/>

## Implementation Guide

### 1. Requesting Media Relay

### `requestMediaRelay()`

**Parameters:**

- `destinationMeetingId` (`String`, **required**) – ID of the target meeting 
- `token` (`String`) – Authentication token for the destination meeting.  
  If you pass `null`, the SDK will use the existing authentication token.
- `kinds` (`Array<String>`) – Media types to relay. If `null`, all media types will be relayed. Options:
  - `"video"` – Camera video
  - `"audio"` – Microphone audio
  - `"share"` – Screen share video

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
import android.os.Bundle
import android.widget.Button
import androidx.appcompat.app.AppCompatActivity
import live.videosdk.rtc.android.Meeting

class LiveStreamActivity : AppCompatActivity() {
    //Initialize  meeting
    liveStream = VideoSDK.initMeeting(... )
    //...
    val switchButton: Button = findViewById(R.id.switchLiveStreamButton)
    switchButton.setOnClickListener {
       requestMediaRelayToAnotherMeeting()
    }

    fun requestMediaRelayToAnotherMeeting() {
    val liveStreamId = "liveStream-B"
    // Secure token to authenticate the relay meeting
    val relayToken = "secureToken123"
    // Specify the media types to relay
    val mediaTypes = listOf("video", "audio")
    // Request media relay
    liveStream.requestMediaRelay(liveStreamId, relayToken, mediaTypes)
    }
}
```

</TabItem>

<TabItem value="Java">

```js

import android.os.Bundle;
import android.view.View;
import android.widget.Button;
import androidx.appcompat.app.AppCompatActivity;
import live.videosdk.rtc.android.Meeting;

public class LiveStreamActivity extends AppCompatActivity {
    // Initialize meeting
    Meeting liveStream = VideoSDK.initMeeting( ...);
    //...
    Button switchButton = findViewById(R.id.switchLiveStreamButton);
    switchButton.setOnClickListener(new View.OnClickListener() {
        @Override
        public void onClick(View v) {
            if (liveStream != null) {
                requestMediaRelayToAnotherMeeting()
            }
        }
    });

    public void requestMediaRelayToAnotherMeeting() {
    // Meeting ID to which you want to relay
    String liveStreamId = "liveStream-B";
    // Secure token to authenticate the relay meeting
    String relayToken = "secureToken123";
    // Specify the media types to relay
    String[] mediaTypes = new String[]{"video", "audio"};
    // Request media relay
    liveStream.requestMediaRelay(liveStreamId, relayToken, Arrays.asList(mediaTypes));
    }
}
```

</TabItem>

</Tabs>

### 2. Handling Relay Requests (Destination Meeting)

In the destination liveStream, hosts (participants with `SEND_AND_RECV` mode) will receive relay requests:

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
import com.google.android.material.dialog.MaterialAlertDialogBuilder
import live.videosdk.rtc.android.Meeting
import live.videosdk.rtc.android.listeners.MeetingEventListener

class LiveStreamView() {
    init {
        // initialize initialize
        liveStream = VideoSDK.initMeeting(... )
        // ...
        // Set up media relay request listener
        liveStream.addEventListener(object : MeetingEventListener() {
        override fun onMediaRelayRequestReceived(participantId: String, liveStreamId: String, listener:RelayRequestListener) {
            showRelayRequest(participantId, liveStreamId, listener)
        }
        })
    }

    private fun showRelayRequest(participantId: String,liveStreamId: String,listener: RelayRequestListener) {
        MaterialAlertDialogBuilder(this@MainActivity)
            .setTitle("Entry Request : $participantId")
            .setMessage("$liveStreamId is requesting to join")
            .setPositiveButton("Approve") { dialog, _ -> listener.accept() }
            .setNegativeButton("Deny") { dialog, _ -> listener.reject() }
            .setCancelable(false)
            .show()
    }

}
```

</TabItem>

<TabItem value="Java">

```js
import android.app.AlertDialog;

import live.videosdk.rtc.android.Meeting;
import live.videosdk.rtc.android.listeners.MeetingEventListener;

public class LiveStreamView {
    //initialize initialize
    Meeting liveStream = VideoSDK.initMeeting( ...);
    //...

      // Set up media relay request listener
      liveStream.addEventListener(new MeetingEventListener() {
        @Override
        public void onMediaRelayRequestReceived(String participantId, String liveStreamId, RelayRequestListener listener) {
            showRelayRequest(participantId, liveStreamId, listener);
        }
      });
    
    private void showRelayRequest(String participantId, String liveStreamId, RelayRequestListener listener) {
        new MaterialAlertDialogBuilder(MainActivity.this)
                .setTitle("Entry Request :"+ participantId)
                .setMessage(liveStreamId + " is requesting to join")
                .setPositiveButton("Approve", (dialog, which) -> listener.accept())
                .setNegativeButton("Deny", (dialog, which) -> listener.reject())
                .setCancelable(false)
                .show();
    }
}
```

</TabItem>

</Tabs>

### 3. Handling Request Responses (Source Meeting)

In the source liveStream, track the response to your relay requests:

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
import android.content.Context
import android.widget.Toast
import live.videosdk.rtc.android.Meeting
import live.videosdk.rtc.android.listeners.MeetingEventListener

class LiveStreamView() {
    //initialize initialize
    liveStream = VideoSDK.initMeeting(... )

    init {
        // Set up media relay request response listener
        liveStream.addEventListener(object : MeetingEventListener() {
            override fun onMediaRelayRequestResponse(participantId: String, decision: String) {
                handleMediaRelayResponse(participantId, decision)
            }
        })
    }

    // Handling the media relay request response
    private fun handleMediaRelayResponse(participantId: String, decision: String) {
        if (decision == "accepted") {
            // Relay request accepted by participant
            println("Relay request accepted by $participantId")
        } else {
            // Relay request rejected by participant
            println("Relay request rejected by $participantId")
        }
    }
}
```

</TabItem>

<TabItem value="Java">

```js
import android.content.Context;
import android.widget.Toast;
import live.videosdk.rtc.android.Meeting;
import live.videosdk.rtc.android.listeners.MeetingEventListener;

public class LiveStreamView {

    // initialize meeting
    Meeting liveStream = VideoSDK.initMeeting( ...);
    // ...
    // Set up media relay request response listener
    liveStream.addEventListener(new MeetingEventListener() {
        @Override
        public void onMediaRelayRequestResponse(String participantId, String decision) {
            handleMediaRelayResponse(participantId, decision);
        }
    });
    // Handling the media relay request response
    private void handleMediaRelayResponse(String participantId, String decision) {
        if ("accepted".equals(decision)) {
            // Relay request accepted by participant
            System.out.println("Relay request accepted by " + participantId);
        } else {
            // Relay request rejected by participant
            System.out.println("Relay request rejected by " + participantId);
        }
    }
}
```

</TabItem>

</Tabs>

### 4. Tracking Active Relays

When a relay successfully starts:

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
import android.util.Log
import live.videosdk.rtc.android.Meeting
import live.videosdk.rtc.android.listeners.MeetingEventListener

class LiveStreamView() {
    // initialize meeting
    liveStream = VideoSDK.initMeeting(... )
    // ...
    companion object {
        private const val TAG = "LiveStreamView"
    }
    init {
        // Set up media relay started listener
        liveStream.addEventListener(object : MeetingEventListener() {
            override fun onMediaRelayStarted(liveStreamId: String) {
                handleMediaRelayStarted(liveStreamId)
            }
        })
    }
    // Called when media relay starts
    private fun handleMediaRelayStarted(liveStreamId: String) {
        Log.d(TAG, "Media relay started to $liveStreamId")
        // You can update UI or handle logic here
    }
}
```

</TabItem>

<TabItem value="Java">

```js
import android.util.Log;
import live.videosdk.rtc.android.Meeting;
import live.videosdk.rtc.android.listeners.MeetingEventListener;

public class LiveStreamView {
    // initialize meeting
   Meeting liveStream = VideoSDK.initMeeting( ...);
    // ...
    // Set up media relay started listener
    liveStream.addEventListener(new MeetingEventListener() {
        @Override
        public void onMediaRelayStarted(String liveStreamId) {
            handleMediaRelayStarted(liveStreamId);
        }
    });
    // Called when media relay starts
    private void handleMediaRelayStarted(String liveStreamId) {
        Log.d(TAG, "Media relay started to " + liveStreamId);
        //...
    }
}
```

</TabItem>

</Tabs>

### 5. Stopping Media Relay

To stop an ongoing relay:

### `stopMediaRelay()`

**Parameters:**

- `liveStreamId` (string): ID of the liveStream where the relay should stop

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
import android.os.Bundle
import android.widget.Button
import androidx.appcompat.app.AppCompatActivity
import live.videosdk.rtc.android.Meeting

class LiveStreamActivity : AppCompatActivity() {
    // Initialize meeting 
    liveStream = VideoSDK.initMeeting(... )
    //..
    val stopRelayButton = findViewById<Button>(R.id.btnStopRelay)

    stopRelayButton.setOnClickListener {
        handleStopMediaRelay()
    }

    // Called to stop media relay
    private fun handleStopMediaRelay() {
        val liveStreamId = "liveStream-B"
        liveStream.stopMediaRelay(liveStreamId)
    }
}
```

</TabItem>

<TabItem value="Java">

```js
import android.view.View;
import android.widget.Button;
import live.videosdk.rtc.android.Meeting;

public class LiveStreamView {

    private Meeting meeting;
    // initialize meeting
    Meeting liveStream = VideoSDK.initMeeting( ...);
    // ...
    
    // Set click listener for the Stop Media Relay button
    stopRelayButton.setOnClickListener(new View.OnClickListener() {
        @Override
        public void onClick(View v) {
            handleStopMediaRelay();
        }
    });

    // Called to stop media relay
    private void handleStopMediaRelay() {
        String liveStreamId = "liveStream-B";
        liveStream.stopMediaRelay(liveStreamId);
    }
}
```

</TabItem>

</Tabs>

### 6. Handling Relay Stop Events

When a relay stops for any reason:

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
import android.util.Log
import live.videosdk.rtc.android.Meeting
import live.videosdk.rtc.android.listeners.MeetingEventListener

class LiveStreamView() {
    // initialize meeting
    val liveStream = VideoSDK.initMeeting(... )
    // ...
    companion object {
        private const val TAG = "LiveStreamView"
    }

    fun setupListeners() {
        liveStream.addEventListener(object : MeetingEventListener() {
            override fun onMediaRelayStopped(liveStreamId: String, reason: String) {
                handleMediaRelayStopped(liveStreamId, reason)
            }
        })
    }

    private fun handleMediaRelayStopped(liveStreamId: String, reason: String) {
        Log.d(TAG, "Relay to $liveStreamId stopped. Reason: $reason")
        // Update UI based on stop reason
        when (reason) {
            "user_stopped" -> showMessage("You stopped relaying to $liveStreamId")
            "connection_lost" -> showMessage("Relay to $liveStreamId ended due to connection issues")
            else -> showMessage("Relay to $liveStreamId ended: $reason")
        }
    }

    private fun showMessage(message: String) {
        Log.i(TAG, message)
    }
}
```

</TabItem>

<TabItem value="Java">

```js
import android.util.Log;
import live.videosdk.rtc.android.Meeting;
import live.videosdk.rtc.android.listeners.MeetingEventListener;

public class LiveStreamView {

    private static final String TAG = "LiveStreamView";
    // initialize meeting
   Meeting liveStream = VideoSDK.initMeeting( ...);
    // ...
    public void setupListeners() {
        liveStream.addEventListener(new MeetingEventListener() {
            @Override
            public void onMediaRelayStopped(String liveStreamId, String reason) {
                handleMediaRelayStopped(liveStreamId, reason);
            }
        });
    }

    private void handleMediaRelayStopped(String liveStreamId, String reason) {
        Log.d(TAG, "Relay to " + liveStreamId + " stopped. Reason: " + reason);
        // Update UI based on stop reason
        switch (reason) {
            case "user_stopped":
                showMessage("You stopped relaying to " + liveStreamId);
                break;
            case "connection_lost":
                showMessage("Relay to " + liveStreamId + " ended due to connection issues");
                break;
            default:
                showMessage("Relay to " + liveStreamId + " ended: " + reason);
        }
    }

    private void showMessage(String message) {
        Log.i(TAG, message);
    }
}
```

</TabItem>

</Tabs>

### 7. Handling Relay Errors

To handle errors that may occur during relay:

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
import android.util.Log
import live.videosdk.rtc.android.Meeting
import live.videosdk.rtc.android.listeners.MeetingEventListener

class LiveStreamView() {
    // initialize meeting
    val liveStream = VideoSDK.initMeeting(... )
    // ...
    companion object {
        private const val TAG = "LiveStreamView"
    }

    private fun setupListeners() {
        liveStream.addEventListener(object : MeetingEventListener() {
            override fun onMediaRelayError(liveStreamId: String, error: String) {
                handleMediaRelayError(liveStreamId, error)
            }
        })
    }

    private fun handleMediaRelayError(liveStreamId: String, error: String) {
        Log.e(TAG, "Relay error to $liveStreamId: $error")
    }
}
```

</TabItem>

<TabItem value="Java">

```js
import android.util.Log;
import live.videosdk.rtc.android.Meeting;
import live.videosdk.rtc.android.listeners.MeetingEventListener;

public class LiveStreamView {

    // initialize meeting
  Meeting liveStream = VideoSDK.initMeeting( ...);

    private static final String TAG = "LiveStreamView";

    private void setupListeners() {
        liveStream.addEventListener(new MeetingEventListener() {
            @Override
            public void onMediaRelayError(String liveStreamId, String error) {
                handleMediaRelayError(liveStreamId, error);
            }
        });
    }

    private void handleMediaRelayError(String liveStreamId, String error) {
        Log.e(TAG, "Relay error to " + liveStreamId + ": " + error);
    }
}
```

</TabItem>

</Tabs>

## Use Cases

1.  **Guest Appearances:** Allow popular hosts to make guest appearances in other streams without leaving their audience
2.  **Cross-Stream Competitions:** Create "battles" or competitions between hosts in different streams
3.  **Multi-Location Broadcasting:** Connect hosts from different physical locations into a shared experience
4.  **Expert Commentary:** Bring in subject matter experts to comment on events in another stream

## Troubleshooting

### Common Issues

1.  **Relay Request Not Received**

    - Verify both meetings are active
    - Check that destination liveStream ID is correct
    - Ensure the token has proper permissions

2.  **Media Not Visible After Acceptance**

    - Verify network connectivity
    - Check that appropriate media kinds were specified
    - Ensure the host has enabled their camera/microphone

3.  **Unexpected Relay Termination**

    - Check for network connectivity issues
    - Verify that both meetings remain active
    - Look for error events with specific reasons

## API Reference

- [requestMediaRelay](/android/api/sdk-reference/meeting-class/methods#requestmediarelay)
- [stopMediaRelay](/android/api/sdk-reference/meeting-class/methods#stopmediarelay)
- [onMediaRelayRequestReceived](/android/api/sdk-reference/meeting-class/meeting-event-listener-class#onmediarelayrequestreceived)
- [onMediaRelayRequestResponse](/android/api/sdk-reference/meeting-class/meeting-event-listener-class#onmediarelayrequestreceived)
- [onMediaRelayStarted](/android/api/sdk-reference/meeting-class/meeting-event-listener-class#onmediarelaystarted)
- [onMediaRelayStopped](/android/api/sdk-reference/meeting-class/meeting-event-listener-class#onmediarelaystopped)
- [onMediaRelayError](/android/api/sdk-reference/meeting-class/meeting-event-listener-class#onmediarelayerror)



---

---
title: RTMP Livestream - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: RTMP Livestream features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: RTMP Livestream
pagination_label: RTMP Livestream
keywords:
  - Start Livestream meeting
  - Stop Livestream meeting
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: rtmp-livestream
--- 

# RTMP Livestream - Android

RTMP is a popular protocol for live streaming video content from a VideoSDK to platforms such as YouTube, Twitch, Facebook, and others.

By providing the platform-specific stream key and stream URL, the VideoSDK can connect to the platform's RTMP server and transmit the live video stream.

VideoSDK allows you to livestream your meeting to platform which support RTMP ingestion just by providing the platform-specific stream key and stream URL, we can connect to the platform's RTMP server and transmit the live video stream.

VideoSDK also allows you to configure the livestream layouts in numerous ways like by simply setting different prebuilt layouts in the configuration or by providing your own custom template to do the livestream according to your layout choice.

This guide will provide an overview of how to implement start and stop RTMP Livestreaming.

### `startLivestream()`

`startLivestream()` method, accesible from the Meeting class, is used to initiate the RTMP livestream. This method accepts the following two parameters:

- `1. outputs`: This parameter accepts a list of `LivestreamOutput` objects which contains the RTMP `url` and `streamKey` of the platforms you want to start the livestream.

- `2. config`: This parameter will define how the livestream layout should look like. You can pass `null` for default layout.

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
val config = JSONObject()

//highlight-next-line
// Layout Configuration
val layout = JSONObject()
JsonUtils.jsonPut(layout, "type", "GRID") // "SPOTLIGHT" | "SIDEBAR",  Default : "GRID"
JsonUtils.jsonPut(layout, "priority", "SPEAKER") // "PIN", Default : "SPEAKER"
JsonUtils.jsonPut(layout, "gridSize", 4) // MAX : 4
JsonUtils.jsonPut(config, "layout", layout)

//highlight-next-line
// Theme of livestream layout
JsonUtils.jsonPut(config, "theme", "DARK") //  "LIGHT" | "DEFAULT"

val outputs: MutableList<LivestreamOutput> = ArrayList()
outputs.add(LivestreamOutput(RTMP_URL, RTMP_STREAM_KEY))

liveStream!!.startLivestream(outputs,config)
```

</TabItem>

<TabItem value="Java">

```js
JSONObject config = new JSONObject();

//highlight-next-line
// Layout Configuration
JSONObject layout = new JSONObject();
JsonUtils.jsonPut(layout, "type", "GRID"); // "SPOTLIGHT" | "SIDEBAR",  Default : "GRID"
JsonUtils.jsonPut(layout, "priority", "SPEAKER");  // "PIN", Default : "SPEAKER"
JsonUtils.jsonPut(layout, "gridSize", 4); // MAX : 4
JsonUtils.jsonPut(config, "layout", layout);

//highlight-next-line
// Theme of livestream layout
JsonUtils.jsonPut(config, "theme", "DARK"); //  "LIGHT" | "DEFAULT"

List<LivestreamOutput> outputs = new ArrayList<>();
outputs.add(new LivestreamOutput(RTMP_URL, RTMP_STREAM_KEY));

liveStream.startLivestream(outputs,config);
```

</TabItem>

</Tabs>

### `stopLivestream()`

- `stopLivestream()` is used to stop the meeting livestream which can be accessed from the `Meeting` class.

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
// keep track of livestream status
val liveStream = false

findViewById<View>(R.id.btnLiveStream).setOnClickListener { view: View? ->
  if (!liveStream) {
    //highlight-start
    val config = JSONObject()
    val layout = JSONObject()
    JsonUtils.jsonPut(layout, "type", "GRID")
    JsonUtils.jsonPut(layout, "priority", "SPEAKER")
    JsonUtils.jsonPut(layout, "gridSize", 4)
    JsonUtils.jsonPut(config, "layout", layout)
    JsonUtils.jsonPut(config, "theme", "DARK")
    //highlight-end

    val outputs: MutableList<LivestreamOutput> = ArrayList()
    //highlight-next-line
    outputs.add(LivestreamOutput(RTMP_URL, RTMP_STREAM_KEY))

    // Start LiveStream
    //highlight-next-line
    liveStream!!.startLivestream(outputs,config)
  } else {
    // Stop LiveStream
    //highlight-next-line
    liveStream!!.stopLivestream()
  }
}
```

</TabItem>

<TabItem value="Java">

```js
// keep track of livestream status
boolean liveStream = false;

findViewById(R.id.btnLiveStream).setOnClickListener(view -> {
  if (!liveStream) {
    //highlight-start
    JSONObject config = new JSONObject();
    JSONObject layout = new JSONObject();
    JsonUtils.jsonPut(layout, "type", "GRID");
    JsonUtils.jsonPut(layout, "priority", "SPEAKER");
    JsonUtils.jsonPut(layout, "gridSize", 4);
    JsonUtils.jsonPut(config, "layout", layout);
    JsonUtils.jsonPut(config, "theme", "DARK");
    //highlight-end

    List<LivestreamOutput> outputs = new ArrayList<>();
    //highlight-next-line
    outputs.add(new LivestreamOutput(RTMP_URL, RTMP_STREAM_KEY));

    // Start LiveStream
    //highlight-next-line
    liveStream.startLivestream(outputs,config);
  } else {
    // Stop LiveStream
    //highlight-next-line
    liveStream.stopLivestream();
  }
});
```

</TabItem>

</Tabs>

### Event associated with Livestream

- **onLivestreamStateChanged** - Whenever meeting livestream state changes, then `onLivestreamStateChanged` event will trigger.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
private val meetingEventListener: MeetingEventListener = object : MeetingEventListener() {
  override fun onLivestreamStateChanged(livestreamState: String?) {
    when (livestreamState) {
      "LIVESTREAM_STARTING" -> Log.d( "LivestreamStateChanged",
          "Meeting livestream is starting"
      )
      "LIVESTREAM_STARTED" -> Log.d( "LivestreamStateChanged",
          "Meeting livestream is started"
      )
      "LIVESTREAM_STOPPING" -> Log.d("LivestreamStateChanged",
          "Meeting livestream is stopping"
      )
      "LIVESTREAM_STOPPED" -> Log.d("LivestreamStateChanged",
          "Meeting livestream is stopped"
      )
    }
  }
}

override fun onCreate(savedInstanceState: Bundle?) {
  //...

  // add listener to meeting
  //highlight-next-line
  liveStream!!.addEventListener(meetingEventListener)
}
```

</TabItem>

<TabItem value="Java">

```js
private final MeetingEventListener meetingEventListener = new MeetingEventListener() {
  @Override
  public void onLivestreamStateChanged(String livestreamState) {
    switch (livestreamState) {
      case "LIVESTREAM_STARTING":
          Log.d("LivestreamStateChanged", "Meeting livestream is starting");
          break;
      case "LIVESTREAM_STARTED":
          Log.d("LivestreamStateChanged", "Meeting livestream is started");
          break;
      case "LIVESTREAM_STOPPING":
          Log.d("LivestreamStateChanged", "Meeting livestream is stopping");
          break;
      case "LIVESTREAM_STOPPED":
          Log.d("LivestreamStateChanged", "Meeting livestream is stopped");
          break;
    }
  }
}

@Override
protected void onCreate(Bundle savedInstanceState) {
  //...

  // add listener to meeting
  //highlight-next-line
  liveStream.addEventListener(meetingEventListener);
}
```

</TabItem>

</Tabs>

### API Reference

The API references for all the methods utilised in this guide are provided below.

- [startLivestream()](/android/api/sdk-reference/meeting-class/methods#startlivestream)
- [stopLivestream()](/android/api/sdk-reference/meeting-class/methods#stoplivestream)
- [onLivestreamStateChanged](/android/api/sdk-reference/meeting-class/meeting-event-listener-class#onlivestreamstatechanged)


---

---
title: Sending Virtual Gifts - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: Learn how to implement a complete virtual gifting system in your live streaming app using PubSub and your backend server for balance verification and event broadcasting.
sidebar_label: Virtual Gifts
pagination_label: Virtual Gifts
keywords:
  - Virtual Gifts
  - Livestream monetization
  - Audience interaction
  - Gifting host
  - PubSub
  - Wallet system
image: img/videosdklive-thumbnail.jpg
sidebar_position: 2
slug: sending-virtual-gifts
---

# Sending Virtual Gifts - Android

Virtual gifting is a powerful monetization and engagement feature that allows viewers to support hosts or speakers during a livestream by sending them digital tokens or "gifts." These gifts can be visually animated and even linked to leaderboards or reward systems.

This guide explains how to implement a secure and real-time virtual gifting experience using your backend server in combination with VideoSDK PubSub.

### How It Works
1. User Action: A viewer taps on a gift button to send a virtual gift to the host.

2. Server Verification:
   - A request is made to your business backend to process the gift.
    - The server authenticates the user, checks their wallet balance, deducts the gift value, and returns a success response.

3. Event Broadcast: Upon success, the client publishes a PubSub message to inform everyone in the meeting (host + other viewers) that a gift has been sent. Clients can then visually show an animation or notification.

### Backend Responsibility

Your backend plays a central role in verifying, validating, and processing gift transactions. It should:
  - Authenticate the request (token/session)
  - Verify if the user has sufficient balance
  - Deduct the gift cost
  - Store the transaction in a database (optional but recommended)
  - Respond with success or failure

### Frontend Implementation

- Sending a Gift (Client to Backend + PubSub)

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
// Data class for request body
data class GiftRequest(val senderId: String, val hostId: String, val giftType: String)

// Retrofit API interface
interface ApiService {
    @POST("send-gift")
    suspend fun sendGift(@Body request: GiftRequest): Response<GiftResponse>
}

// Gift sending logic with PubSub
fun sendGift(giftType: String, senderId: String, hostId: String, pubSub: PubSub) {
    CoroutineScope(Dispatchers.IO).launch {
        try {
            val response = api.sendGift(GiftRequest(senderId, hostId, giftType))
            if (response.isSuccessful && response.body()?.success == true) {
                pubSub.publish(mapOf("giftType" to giftType, "from" to senderId, "to" to hostId))
            } else {
                Log.e("Gift", "Failed: ${response.body()?.message}")
            }
        } catch (e: Exception) {
            Log.e("Gift", "Error: ${e.message}")
        }
    }
}
```

</TabItem>

<TabItem value="Java">

```java
// Request model
public class GiftRequest {
    public String senderId;
    public String hostId;
    public String giftType;

    public GiftRequest(String senderId, String hostId, String giftType) {
        this.senderId = senderId;
        this.hostId = hostId;
        this.giftType = giftType;
    }
}

// Response model
public class GiftResponse {
    public boolean success;
    public String message;
}

// Retrofit interface
public interface ApiService {
    @POST("send-gift")
    Call<GiftResponse> sendGift(@Body GiftRequest request);
}

// Gift sending method
public void sendGift(String giftType, String senderId, String hostId, PubSub pubSub) {
    GiftRequest request = new GiftRequest(senderId, hostId, giftType);

    Retrofit retrofit = new Retrofit.Builder()
        .baseUrl("https://your-api.com/")
        .addConverterFactory(GsonConverterFactory.create())
        .build();

    ApiService api = retrofit.create(ApiService.class);

    api.sendGift(request).enqueue(new Callback<GiftResponse>() {
        @Override
        public void onResponse(Call<GiftResponse> call, Response<GiftResponse> response) {
            if (response.isSuccessful() && response.body().success) {
                Map<String, String> payload = new HashMap<>();
                payload.put("giftType", giftType);
                payload.put("from", senderId);
                payload.put("to", hostId);
                pubSub.publish(payload);
            } else {
                Log.e("Gift", "Failed: " + (response.body() != null ? response.body().message : "Unknown error"));
            }
        }

        @Override
        public void onFailure(Call<GiftResponse> call, Throwable t) {
            Log.e("Gift", "Error sending gift", t);
        }
    });
}
```

</TabItem>

</Tabs>

- Displaying the Gift (All Clients)

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
// In your Activity or Fragment
val gifts = mutableListOf<Gift>()

pubSub.onMessage("GIFT") { message ->
    val from = message["from"] ?: "Unknown"
    val to = message["to"] ?: "Unknown"
    val type = message["giftType"] ?: "gift"

    val gift = Gift(from = from, to = to, type = type)
    gifts.add(gift)

    runOnUiThread {
        Toast.makeText(
            this,
            "🎁 $from sent a $type to $to",
            Toast.LENGTH_SHORT
        ).show()
    }
}
```

</TabItem>

<TabItem value="Java">

```java
// In your Activity or Fragment
List<Gift> gifts = new ArrayList<>();

pubSub.onMessage("GIFT", message -> {
    String from = message.get("from");
    String to = message.get("to");
    String type = message.get("giftType");

    Gift gift = new Gift(from, to, type);
    gifts.add(gift);

    runOnUiThread(() -> {
        Toast.makeText(
            context,
            "🎁 " + from + " sent a " + type + " to " + to,
            Toast.LENGTH_SHORT
        ).show();
    });
});
```

</TabItem>

</Tabs>

## API Reference

The API references for all the methods and events utilized in this guide are provided below.

- [pubSub()](/android/api/sdk-reference/pubsub-class/introduction)


---

---
title: Initialize Live Stream | Video SDK
hide_title: true
hide_table_of_contents: false
description: Learn how to initialize a live stream using VideoSDK in React. This guide covers generating tokens, creating stream IDs, and setting up a live stream session with VideoSDK.
sidebar_label: Initialize Live Stream
pagination_label: Initialize Live Stream
keywords:
  - audio calling
  - video calling
  - real-time communication
  - collaboration
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: initialize-livestream
---

# Initialize Live Stream - Android

To configure livestreaming with VideoSDK you require two things, first the `token` which will be used for **Authentication** purpose and a `streamId` which will be used to specify where the hosts and audience will join.

### Generating Token

You can generate a `token` in two ways:

1. **`Temporary Token`** : You can visit [Dashboard's API Key section](https://app.videosdk.live/api-keys) and generate a temporary token from there.

2. **`Server`** : You can setup **JWT** in backend and make an API call to get the token from your server.

To learn more about **Authentication** and token in detail you can follow [this guide](/android/guide/video-and-audio-calling-api-sdk/authentication-and-token).

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
// With Temporary Token
fun getToken(): String {
  // Update the token here from the VideoSDK dashboard
  // highlight-next-line
  return "YOUR_TOKEN"
}

// Server
fun getToken(): String {
  val token = arrayOfNulls<String>(1)
  // highlight-start
  AndroidNetworking.get("http://localhost:3000/get-token")
      .build()
      .getAsJSONObject(object : JSONObjectRequestListener() {
          fun onResponse(response: JSONObject) {
              try {
                  token[0] = response.getString("token")
              } catch (e: JSONException) {
                  e.printStackTrace()
              }
          }

          fun onError(anError: ANError) {
              anError.printStackTrace()
          }
      })
  // highlight-end
  return token[0]
}
```

</TabItem>

<TabItem value="Java">

```java
// With Temporary Token
public String getToken()
{
  // Update the token here from the VideoSDK dashboard
  // highlight-next-line
  String token = "YOUR_TOKEN";
  return token;
}

// Server
public String getToken()
{
  final String[] token = new String[1];
  // highlight-start
  AndroidNetworking.get("http://localhost:3000/get-token")
      .build()
      .getAsJSONObject(new JSONObjectRequestListener() {
          @Override
          public void onResponse(JSONObject response) {
              try {
                  token[0] = response.getString("token");
              } catch (JSONException e) {
                  e.printStackTrace();
              }
          }
          @Override
          public void onError(ANError anError) {
              anError.printStackTrace();
          }
      });
  // highlight-end
  return token[0];
}
```

</TabItem>

</Tabs>

### Generating Stream Id

With the token ready, you can now get the `streamId` from the [VideoSDK's rooms API](/api-reference/realtime-communication/create-room).

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
fun getStreamId(token: String): String {
  var streamId: String =null;
  // We will use VideoSDK rooms API endpoint to create a streamId
  // highlight-start
  AndroidNetworking.post("https://api.videosdk.live/v2/rooms")
      .addHeaders("Authorization", token) // We will pass the token in the headers
      .build()
      .getAsJSONObject(object : JSONObjectRequestListener() {
          fun onResponse(response: JSONObject) {
              try {
                  streamId = response.getString("roomId")
              } catch (e: Exception) {
                  e.printStackTrace()
              }
          }

          fun onError(anError: ANError) {
              anError.printStackTrace()
          }
      })
  // highlight-end
  //we will return the streamId which we got from the response of the api
  return streamId
}
```

</TabItem>

<TabItem value="Java">

```java
public String getStreamId(String token) {
  final String[] streamId = new String[1];
  // We will use VideoSDK rooms API endpoint to create a streamId
  // highlight-start
  AndroidNetworking.post("https://api.videosdk.live/v2/rooms")
      .addHeaders("Authorization", token) // We will pass the token in the headers
      .build()
      .getAsJSONObject(new JSONObjectRequestListener() {
          @Override
          public void onResponse(JSONObject response) {
              try {
                  streamId[0] = response.getString("roomId");
              } catch (Exception e) {
                  e.printStackTrace();
              }
          }
          @Override
          public void onError(ANError anError) {
              anError.printStackTrace();
          }
      });
  // highlight-end
  //we will return the streamId which we got from the response of the api
  return streamId[0];
}
```

</TabItem>

</Tabs>

### Initialization of Live Stream

1. To initialize the live stream , first we have to initialize the VideoSDK.
   We can initialize the VideoSDK using `initialize()` method provided by the SDK.

```js title="initialize"
  VideoSDK.initialize(Context context)
```

2. Next, we have to set token property of VideoSDK class.
   By using `config()` method, you can set the token property of VideoSDK class.

```js title="config"
 VideoSDK.config(String token)
```

3. Now, we can initialize the live stream  using a factory method provided by the SDK called `initMeeting()`.

`initMeeting()` is responsible for initializing the live stream  with the provided configuration, which includes the `streamId`, `name`, `participantId` and many more.

Let's take a deeper look at the available configuration options first.

```js title="initMeeting"
  VideoSDK.initMeeting(
      Context context,  // context of activity
      String MeetingId,  
      String name, // name of participant
      boolean micEnabled, // flag to enable-mic
      boolean webcamEnabled, // flag to enable-webcam
      String participantId,  // id of participant
      String mode, // mode of participant
      boolean multiStream, // multiStream
      Map<String, CustomStreamTrack> customTracks, // map of customTracks
      JSONObject metaData, // metaData
      String signalingBaseUrl // signalingBaseUrl
      PreferredProtocol preferredProtocol //preferredProtocol
  )
```


- **`MeetingId`** :

  - This is a unique identifier that allows participants to join a specific live stream.
  - It will be in the format of `xxx-yyy-zzz` and will be generated using the [VideoSDK's Room API](/api-reference/realtime-communication/create-room).

- **`mode`** :

  - This paramter defines the mode the participant will enter the live stream with.
  - `SEND_AND_RECV`: For hosts/co-hosts who can send and receive media.
  - `RECV_ONLY`: For audience members who can only receive media.​


- **`name`**:

  - This represents the name of the participant in the live streams.
  - It will accept `String` type value.

- **`micEnabled`**:

  - This is a `boolean` flag, indicating whether a participant's microphone will be automatically enabled when they join the live stream. This property will be completely ignored for Audience participants, as they are not allowed to publish their audio.

- **`webcamEnabled`**:

  - This is a `boolean` flag, indicating whether a participant's webcam will be automatically enabled when they join the live stream. This property will be completely ignored for Audience participants, as they are not allowed to publish their video.

- **`metaData`**:

  - If you want to provide additional details about the participants joining the live stream, such as their profile image, you can pass that information in this parameter.
  - It has to be of `Object` type.
  - This is an `OPTIONAL` parameter.

- **`participantId`**:

  - This is a unique identifier for the participant's inside the live stream.

    - It can be used to specify the **unique identifier** which can be linked with **your own database** service.
    - It has to be of `String` type.
    - This is an `OPTIONAL` parameter. By default VideoSDK will generate unique id for each participant.

- **`multistream`**:

  - This is a `boolean` flag, indicating whether the host's media stream should send multiple resolution layers or a single resolution layer.

:::caution
You must ensure that the `participantId` is not repeated in the same livestream. This will enable VideoSDK to eliminate any participant associated with that `participantId`.
:::

With all the configuration options explained, here is how you can initialize the live stream.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
class LiveStreamActivity : AppCompatActivity() {

  fun getToken(): String {
    //highlight-next-line
    ...
  }

  fun getStreamId(token: String): String {
    //highlight-next-line
    ...
  }

 override fun onCreate(savedInstanceState: Bundle) {
    super.onCreate(savedInstanceState)
    setContentView(R.layout.activity_main)

    // initialize AndroidNetworking to perform Network call
    AndroidNetworking.initialize(applicationContext)

    //We will fetch token and streamId and store it in local variables
    val token: String = getToken()
    val streamId = getStreamId(token)

    // highlight-start
    // initialize the VideoSDK
    VideoSDK.initialize(this@MainActivity)

    // set token property of VideoSDK
    VideoSDK.config(token)

    // create a new meeting instance
    val liveStream: Meeting = VideoSDK.initMeeting(
        this@MainActivity, streamId, "NAME HERE",
        true, true, null, null, false, null, null
    )
    // highlight-end

    Log.d("VideoSDK", "onCreate: $streamId")
  }
}
```

</TabItem>

<TabItem value="Java">

```java
public class LiveStreamActivity extends AppCompatActivity {

  public String getToken()
  {
    //highlight-next-line
    ...
  }

  public String getStreamId(String token) {
    //highlight-next-line
    ...
  }

  @Override
  protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);

    // initialize AndroidNetworking to perform Network call
    AndroidNetworking.initialize(getApplicationContext());

    //We will fetch token and streamId and store it in local variables
    String token = getToken();
    String streamId = getStreamId(token);

    // highlight-start
    // initialize the VideoSDK
    VideoSDK.initialize(MainActivity.this);

    // set token property of VideoSDK
    VideoSDK.config(token);

    // create a new meeting instance
    Meeting liveStream = VideoSDK.initMeeting(
            MainActivity.this, streamId, "NAME HERE",
            true, true, null, null, false, null, null
    // highlight-end

    Log.d("VideoSDK", "onCreate: " + streamId
    );
  }
}
```

</TabItem>

</Tabs>

### API Reference

The API references for all the methods utilised in this guide are provided below.

- [initMeeting](/android/api/sdk-reference/initMeeting)



---

---
title: Join/Leave Live Stream | Video SDK
hide_title: true
hide_table_of_contents: false
description: Easily integrate join and leave functionalities for interactive live streams using Video SDK’s ReactSDK with event handling for participant management.
sidebar_label: Join/Leave Live Stream
pagination_label: Join/Leave Live Stream
keywords:
  - audio calling
  - video calling
  - real-time communication
  - collaboration
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: join-leave-livestream
--- 

# Join Live Stream - Android

Once, the live stream is configured, the next step is to join it. If you have not initialized the live stream yet, you can [follow the guide here.](/android/guide/interactive-live-streaming/setup-livestream/initialize-livestream)

### `join()`

- To join the live stream you can call the `join()` method which is the part of the `Meeting` class of Android SDK.
- This method can be called after the live stream is initialized from the `VideoSdk class`.

### Events associated with Join

Following callbacks are received when a participant is successfully joined.

- [Local Participant](/android/guide/video-and-audio-calling-api-sdk/concept-and-architecture#2-participant) will receive a [`onMeetingJoined`](/android/api/sdk-reference/meeting-class/meeting-event-listener-class#onmeetingjoined) event, when successfully joined.
- [Remote Participant](/android/guide/video-and-audio-calling-api-sdk/concept-and-architecture#2-participant) will receive a [`onParticipantJoined`](/android/api/sdk-reference/meeting-class/meeting-event-listener-class#onparticipantjoined) event with the newly joined `Participant` object from the event callback.

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
class LiveStreamActivity : AppCompatActivity() {
 override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    setContentView(R.layout.activity_live_stream);
    // initialize the meeting
     liveStream = VideoSDK.initMeeting(... )
    ...

    // join meeting
    meeting!!.join()

    // Add event listener for listening upcoming events of live stream
    // highlight-next-line
    meeting!!.addEventListener(meetingEventListener)
  }

  private val meetingEventListener: MeetingEventListener = object : MeetingEventListener(){
    //Event to determine if the live stream has been joined
    //highlight-start
    fun onMeetingJoined() {
        Log.d("VideoSDK", "onMeetingJoined")
    }
    //highlight-end
    / //Event to determine some other participant has joined
    //highlight-start
    fun onParticipantJoined(participant: Participant) {
        Log.d("#VideoSDK", participant.displayName + " joined");
    }
    //highlight-end
  }
}
```

</TabItem>

<TabItem value="Java">

```java
public class LiveStreamActivity extends AppCompatActivity {
  @Override
  protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_live_stream);
    // initialize the meeting
    Meeting liveStream = VideoSDK.initMeeting( ...);
    ...

    // join meeting
    meeting.join();

    // Add event listener for listening upcoming events of live stream
    //highlight-next-line
    meeting.addEventListener(meetingEventListener);
  }

  private final MeetingEventListener meetingEventListener=new MeetingEventListener() {
   //Event to determine if the live stream has been joined
    @Override
    public void onMeetingJoined() {
        Log.d("VideoSDK", "onMeetingJoined");
    }
    //highlight-end

    / //Event to determine some other participant has joined
    //highlight-start
    @Override
    public void onParticipantJoined(Participant participant) {
        Log.d("#VideoSDK", participant.getDisplayName() + " joined");
    }
    //highlight-end
  };
}
```

</TabItem>

</Tabs>

### `leave()`

- To leave the live stream you can call the `leave()` method which is the part of the `Meeting` class of Flutter SDK.


:::note
This method can be called only after the live stream is joined successfully.
:::

### Events associated with the leave() method

Following callbacks are received when a participant leaves the live stream.

- The [Local Participant](/android/guide/video-and-audio-calling-api-sdk/concept-and-architecture#2-participant) will receive the [`onMeetingLeft`](/react/api/sdk-reference/use-meeting/events#onmeetingleft) event, once they have successfully left the livestream.
- All the [Remote Participants](/android/guide/video-and-audio-calling-api-sdk/concept-and-architecture#2-participant)—including all the hosts and audience members—will receive the [`onParticipantLeft`](/react/api/sdk-reference/use-meeting/events#onparticipantjoined) event with the `Participant` object of the user who left the livestream.


<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
private final MeetingEventListener meetingEventListener = new MeetingEventListener() {
  //Event to determine if the live stream has been left
  //highlight-start
  override fun onMeetingLeft() {
    Log.d("#VideoSDK", "onMeetingleft()")
  }
  //highlight-end

  //Event to determine some other participant has left
  //highlight-start
  override fun onParticipantLeft(participant: Participant) {
    Log.d("#VideoSDK", participant.displayName + " left");
  }
  //highlight-end
}
```

</TabItem>

<TabItem value="Java">

```javascript
private final MeetingEventListener meetingEventListener = new MeetingEventListener() {
  //Event to determine if the live stream has been left
  //highlight-start
  @Override
  public void onMeetingLeft() {
    Log.d("#VideoSDK", "onMeetingleft()")
  }
  //highlight-end

  //Event to determine some other participant has left
  //highlight-start
  @Override
  public void onParticipantLeft(Participant participant) {
    Log.d("#VideoSDK", participant.getDisplayName() + " left");
  }
  //highlight-end
}
```

</TabItem>

</Tabs>
:::tip
You should call the `leave()` method on the unmount of your main live stream component so that live stream is left once the view is unmounted.
:::

### API Reference

The API references for all the methods and events utilized in this guide are provided below.

- [initMeeting](/android/api/sdk-reference/initMeeting)
- [join()](/android/api/sdk-reference/meeting-class/methods#join)
- [onMeetingJoined()](/android/api/sdk-reference/meeting-class/meeting-event-listener-class#onmeetingjoined)
- [onParticipantJoined()](/android/api/sdk-reference/meeting-class/meeting-event-listener-class#onparticipantjoined)
- [leave()](/android/api/sdk-reference/meeting-class/methods#leave)
- [onMeetingLeft()](/android/api/sdk-reference/meeting-class/meeting-event-listener-class#onmeetingleft)
- [onParticipantLeft()](/android/api/sdk-reference/meeting-class/meeting-event-listener-class#onparticipantleft)


---

---
title: Waiting Screen | Video SDK
hide_title: true
hide_table_of_contents: false
description: Learn how to implement a waiting screen in React with Video SDK to ensure audience members only enter a live stream after a host joins, enhancing the meeting experience.
sidebar_label: Waiting Screen
pagination_label: Waiting Screen
keywords:
  - audio calling
  - video calling
  - real-time communication
  - collaboration
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: waiting-screen
---

# Waiting Screen - Android

To create a smoother and more polished entry experience for audience members, it's important not to immediately render the meeting room when they join. Instead, show a waiting screen until at least one host is present in the room.

### Why This Matters?

- Hosts are typically responsible for driving the meeting, and their presence is essential before audience members should be able to view or interact in the room.

- Allowing audience members (in RECV_ONLY mode) to enter a meeting with no active hosts (in SEND_AND_RECV mode) can result in confusion and a poor user experience.

### Participant Modes

- Hosts must join the meeting with the SEND_AND_RECV mode.
- Audience members should join with the RECV_ONLY mode.

### Implementation Guide

You can achieve this behavior by using the participants list and onParticipantJoined event from the Meeting class.

1. Check if a Host is Present
   On initial render, use the participants object to determine if there's already a host in the room:

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
val hasHost = meeting.getParticipants().values.any { it.mode == "SEND_AND_RECV" }

Log.d("Tag", "Has Host: $hasHost")
```

</TabItem>

<TabItem value="Java">

```javascript
boolean hasHost = meeting.getParticipants().values().stream()
    .anyMatch(p -> "SEND_AND_RECV".equals(p.getMode()));

Log.d("Tag", "Has Host: " + hasHost);

```

</TabItem>

</Tabs>

If hasHost is true, render the meeting view. Otherwise, show the waiting screen.

2. Listen for Host Join
   Always listen for the onParticipantJoined event in case a host joins after the audience participant:

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
override fun onParticipantJoined(participant: Participant) {
    if (participant.mode == "SEND_AND_RECV") {
        // Show meeting UI
       Log.d("Tag", "Host joined. Show meeting view.")
    }
}
```

</TabItem>

<TabItem value="Java">

```javascript
@Override
public void onParticipantJoined(Participant participant) {
    if ("SEND_AND_RECV".equals(participant.getMode())) {
        // Show meeting UI
        System.out.println("Host joined. Show meeting view.");
    }
}
```

</TabItem>

</Tabs>

This ensures that as soon as a host joins, the waiting audience members are transitioned smoothly into the meeting view.

<div style={{ textAlign: 'center' }}>
    <img 
        src="https://cdn.videosdk.live/docs/images/flutter/ils/waiting_screen_flutter.jpg" 
        alt="Waiting Screen" 
         style={{height: '450px'}}
    />
</div>


---

---
title: Virtual Background 
hide_title: true
hide_table_of_contents: false
sidebar_label: Virtual Background 
pagination_label: Virtual Background 
keywords:
  - Virtual Background 
  - Live Stream
image: img/videosdklive-thumbnail.jpg
sidebar_position: 2
slug: virtual-background
---


# Virtual Background - Android

Virtual backgrounds enhance your **live stream experience** by allowing you to replace your physical background with a digital image or apply a blur effect. This is ideal for creators and streamers who want to maintain privacy, reduce distractions, or add a personal touch to their broadcast. You can use a preloaded background image or supply your own via a CDN.

import ReactPlayer from 'react-player'

<ReactPlayer controls autoplay muted loop playing url='https://assets.videosdk.live/images/android-video-processor.mp4' width={"100%"} />


## Virtual Background using `MediaEffects` library

The `MediaEffects` library enables the integration of sophisticated virtual background effects within your video applications. By leveraging this library, users can replace their physical backgrounds with custom images or static backdrops, creating a more immersive and engaging experience. 

### Install the library 
You can install our Android library by using Maven Central package repositories.

- Add the dependency in your `app/build.gradle` file.

```js title="app/build.gradle"
dependencies {
	implementation 'live.videosdk:videosdk-media-effects:0.0.2'
	// other app dependencies
}
```
### Apply Virtual Background

- The `applyVideoProcessor()` method of the `VideoSDK` class enables dynamic changes to the video background during a live session.
- This method accepts an instance of the `VideoFrameProcessor` class as its parameter.
- The following classes implement the `VideoFrameProcessor` interface. Depending on your requirements, you can create an instance of the appropriate class and pass it to the `applyVideoProcessor()` method:

    1. `BackgroundImageProcessor` : The `BackgroundImageProcessor` class takes a `Uri` as a parameter and uses it as the video stream background.
    2. `BackgroundBlurProcessor`: The `BackgroundBlurProcessor` class takes a `float` value for the blur radius and a `Context` to apply a blur effect to the video stream background. It supports range between 0 to 25.
    3. `BackgroundColorProcessor`: The `BackgroundColorProcessor` class takes an `int` value for the color and sets it as the background for the video stream.

### Change Virtual Background

- To change the virtual background, users can utilize a set of setters that allow easy switching between a new image, a blur effect, or a solid color. This functionality supports dynamic customization, enhancing the user's video experience by enabling seamless background updates in real-time.

- You can use following setters to change Virtual Background:

    1. `setBackgroundSource(Uri uri)`: This method of the `BackgroundImageProcessor` class takes a `Uri` as a parameter to update the current background image for the video stream.
    2. `setBlurRadius(float opacity)`: This method of the `BackgroundBlurProcessor` class takes a `float` value for the blur radius to adjust the blur effect of the current background.
    3. `setBackgroundColor(int color)`: This method of the `BackgroundColorProcessor` class takes an `int` value as a parameter to update the current background color for the video stream.
### Remove Virtual Background

- The `removeVideoProcessor()` method from the `VideoSDK` class provides users with a convenient way to revert their video background to its original state, removing any previously applied virtual background. This functionality ensures flexibility for users to switch between virtual and real backgrounds as needed.

#### Example

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
Class LiveStreamActivity : AppCompatActivity() {
    private var backgroundImageProcessor: BackgroundImageProcessor? = null
    private var backgroundBlurProcessor: BackgroundBlurProcessor? = null
    private var backgroundColorProcessor: BackgroundColorProcessor? = null

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)

        //...

        //To Apply Virtual Background
        findViewById<View>(R.id.applyBackground).setOnClickListener { view: View? ->
            val uri =
                Uri.parse("https://st.depositphotos.com/2605379/52364/i/450/depositphotos_523648932-stock-photo-concrete-rooftop-night-city-view.jpg")
            backgroundImageProcessor = BackgroundImageProcessor(uri)
      //    backgroundBlurProcessor = BackgroundBlurProcessor(25f, this)
      //    backgroundColorProcessor = BackgroundColorProcessor(Color.BLUE)
            VideoSDK.applyVideoProcessor(backgroundColorProcessor)
        }

        //To Change Virtual Background
        findViewById<View>(R.id.changeBackground).setOnClickListener { view: View? ->
            val newUri =
                Uri.parse("https://images.pexels.com/photos/531880/pexels-photo-531880.jpeg?cs=srgb&dl=pexels-pixabay-531880.jpg&fm=jpg")
            backgroundImageProcessor!!.setBackgroundSource(newUri)
      //    backgroundColorProcessor!!.setBackgroundColor(Color.CYAN)
      //    backgroundBlurProcessor!!.setBlurRadius(17f)
        }
        
        //To Remove Virtual Background
        findViewById<View>(R.id.changeBackground).setOnClickListener { view: View? ->
            VideoSDK.removeVideoProcessor()
        }
    }
}
```

</TabItem>

<TabItem value="Java">

```java
public class LiveStreamActivity extends AppCompatActivity {

    private BackgroundImageProcessor backgroundImageProcessor;
    private BackgroundBlurProcessor backgroundBlurProcessor;
    private BackgroundColorProcessor backgroundColorProcessor;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        //...

        //To Apply Virtual Background
        findViewById(R.id.applyBackground).setOnClickListener(view -> {
            Uri uri = Uri.parse("https://st.depositphotos.com/2605379/52364/i/450/depositphotos_523648932-stock-photo-concrete-rooftop-night-city-view.jpg");
            backgroundImageProcessor = new BackgroundImageProcessor(uri);
        //   backgroundBlurProcessor = new BackgroundBlurProcessor(25,this);
        //   backgroundColorProcessor = new BackgroundColorProcessor(Color.BLUE);
            VideoSDK.applyVideoProcessor(backgroundColorProcessor);
        });

        //To Change Virtual Background
        findViewById(R.id.changeBackground).setOnClickListener(view -> {
            Uri newUri = Uri.parse("https://images.pexels.com/photos/531880/pexels-photo-531880.jpeg?cs=srgb&dl=pexels-pixabay-531880.jpg&fm=jpg");
            backgroundImageProcessor.setBackgroundSource(newUri);
        //    backgroundColorProcessor.setBackgroundColor(Color.CYAN);
        //    backgroundBlurProcessor.setBlurRadius(17);    
        });
        
        //To Remove Virtual Background
        findViewById(R.id.removeBackground).setOnClickListener(view -> {
            VideoSDK.removeVideoProcessor();
        });
    }
}
```

</TabItem>

</Tabs>

## API Reference

The API references for all the methods utilized in this guide are provided below.

- [applyVideoProcessor()](/android/api/sdk-reference/videosdk-class/methods#applyvideoprocessor)
- [removeVideoProcessor()](/android/api/sdk-reference/videosdk-class/methods#removevideoprocessor)



---

---
sidebar_label: Overview
pagination_label: Overview
---

# Overview of SIP with VideoSDK - Android

import SipConnect from '../../../../mdx/\_sip-connect.mdx';
import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>

<SipConnect title="SIP Connect with VideoSDK - Android"/>


---

---
sidebar_label: Quick Start
pagination_label: Quick Start
---

# Build a SIP Integration: VideoSDK & Twilio for Inbound Outbound Calls! Step-by-Step

import SipQuickStart from '../../../../mdx/\_sip-connect-quick-start.mdx';

<SipQuickStart/>


---

---
title: SIP Connect
hide_title: false
hide_table_of_contents: false
description: Interactive Livestream features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: SIP Connect
pagination_label: SIP Connect
keywords:
  - SIP connect
  - PSTN connect
  - sip videosdk
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: sip-connect
---

# SIP Connect - Android

import SipConnect from '../../../mdx/\_sip-connect.mdx';
import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>

<SipConnect title="SIP Connect with VideoSDK - Android"/>


---

---
title: Start a Video & Audio Call in Android SDK - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: Build customizable real-time video & audio calling applications in Android SDK using Video SDK add live Video & Audio conferencing to your applications.
sidebar_label: "Client Setup for Android"
pagination_label: "Client Setup for Android"
keywords:
  - android sdk
  - java sdk
  - kotlin sdk
  - chromebook sdk
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: android-sdk
---

import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>

# Getting Started - Android SDK

Android SDK is natively written SDK using Java. It is compatible with both Java and Kotlin.

## Install an Android SDK

The easiest way to get started is by installing the sdk in your app.

### Step 1: Add the repositories into your project.

- If your Android Studio Version is older than Android Studio Bumblebees, add the repository to project's `build.gradle` file.
- If your are using Android Studio Bumblebees or newer Version, add the repository to `settings.gradle` file.

:::note

You can use imports with Maven Central after rtc-android-sdk version `0.1.12`.

Whether on Maven or Jitpack, the same version numbers always refer to the same SDK.

:::

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Maven Central"
groupId={"android-repositories"}
values={[{label: 'Maven Central', value: 'Maven Central'},{label: 'Jitpack', value: 'Jitpack'},]}>

<TabItem value="Maven Central">

```js title="build.gradle"
allprojects {
  repositories {
    // ...
    google()
    mavenCentral()
    maven { url "https://maven.aliyun.com/repository/jcenter" }
  }
}
```

```js title="settings.gradle"
dependencyResolutionManagement{
  repositories {
    // ...
    google()
    mavenCentral()
    maven { url "https://maven.aliyun.com/repository/jcenter" }
  }
}

```

</TabItem>

<TabItem value="Jitpack">

```js title="build.gradle"
allprojects {
  repositories {
    // ...
    google()
    maven { url 'https://jitpack.io' }
    mavenCentral()
    maven { url "https://maven.aliyun.com/repository/jcenter" }
  }
}
```

```js title="settings.gradle"
dependencyResolutionManagement{
  repositories {
    // ...
    google()
    maven { url 'https://jitpack.io' }
    mavenCentral()
    maven { url "https://maven.aliyun.com/repository/jcenter" }
  }
}

```

</TabItem>

</Tabs>

### Step 2: Add the dependency in `app/build.gradle`:

```js title="app/build.gradle"
dependencies {
		implementation 'live.videosdk:rtc-android-sdk:0.3.0'

		// other app dependencies
}
```

:::important

Android SDK compatible with armeabi-v7a, arm64-v8a, x86_64 architectures. If you want to run the application in an emulator, choose ABI x86_64 when creating a device.

:::

### Step 3: Add all the following permissions to AndroidManifest.xml

```js title="AndroidManifest.xml"
<uses-permission android:name="android.permission.RECORD_AUDIO" />
<uses-permission android:name="android.permission.MODIFY_AUDIO_SETTINGS" />
<uses-permission android:name="android.permission.INTERNET" />
<uses-permission android:name="android.permission.READ_PHONE_STATE" />
<uses-permission android:name="android.permission.CAMERA" />

<uses-permission android:name="android.permission.BLUETOOTH" />
<uses-permission android:name="android.permission.BLUETOOTH_ADMIN" />
<uses-permission android:name="android.permission.BLUETOOTH_CONNECT" />

```

### Step 4: Create MainApplication class with the following code

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js title="MainApplication.kt"
package live.videosdk.demo;

import live.videosdk.rtc.android.VideoSDK;

class MainApplication : Application() {
  override fun onCreate() {
    super.onCreate()
    
    VideoSDK.initialize(applicationContext)
  }
}
```

</TabItem>

<TabItem value="Java">

```js title="MainApplication.java"
package live.videosdk.demo;

import android.app.Application;

import live.videosdk.rtc.android.VideoSDK;

public class MainApplication extends Application {
    @Override
    public void onCreate() {
        super.onCreate();

        VideoSDK.initialize(getApplicationContext());
    }
}
```

</TabItem>

</Tabs>

### Step 5: Add MainApplication to AndroidManifest.xml

```js title="AndroidManifest.xml"
<application
    android:name=".MainApplication"
>
  <!-- ... -->
</application>
```

:::note

Check out official example of Android SDK implementation for Java and Kotlin as mentioned below: 

- For **Java** Code Sample [Click here](https://github.com/videosdk-live/videosdk-rtc-android-java-sdk-example)<br />
- For **Kotlin** Code Sample [Click here](https://github.com/videosdk-live/videosdk-rtc-android-kotlin-sdk-example)

:::


---

---
title: Authentication and Token | Video SDK
hide_title: true
hide_table_of_contents: false
description: Video SDK and Audio SDK, developers need to implement a token server. This requires efforts on both the front-end and backend.
sidebar_label: Authentication and Tokens
pagination_label: Authentication and Tokens
keywords:
  - audio calling
  - video calling
  - real-time communication
  - collaboration
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: authentication-and-token
---

import ServerSetup from '../../../../mdx/introduction/\_server-setup.mdx';

<ServerSetup title="Authentication and Tokens for VideoSDK - Android" />


---

---
title: Authentication in Video & Audio Calling SDK
hide_title: false
hide_table_of_contents: false
description: This guide will explain authentication and token flow for video & audio calling SDK.
sidebar_label: Authentication and Tokens
pagination_label: Authentication and Tokens
keywords:
  - authentication audio calling
  - authentication video calling
  - authentication real-time communication
  - tokens
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: authentication-and-tokens
---

import Mermaid from '@theme/Mermaid';
import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>

# Authentication and Token

VideoSDK uses access tokens for authentication. Using our dashboard ([app.videosdk.live](https://app.videosdk.live/)), anyone can generate access tokens tokens with an API key and secret pair.

- Your backend server will generate access tokens using API Key and secret.
- Your client obtains token from your backend server.
- Your client will pass the token to VideoSDK server.
- VideoSDK client sdk will conncts to the VideoSDK server with available token.
- VideoSDK server will validate the token and accpets your incoming connection.

Here is the simple sequence diagram represents the authentication.
<Mermaid chart={`sequenceDiagram Your App Client->>Your App Server: Request for token; activate Your App Server; Note left of Your App Server: Generate token; Your App Server-->>Your App Client: Received token; deactivate Your App Server; Your App Client->>VideoSDK Server: Request to establish connection; activate VideoSDK Server; Note left of VideoSDK Server: Validates Token; VideoSDK Server-->>Your App Client: Connection established; deactivate VideoSDK Server;`}/>

## Generate API Key and Secret

Visit, [app.videosdk.live](https://app.videosdk.live/) to gererate API Key and secret.

![Generate API Key from Dashboard](/img/tutorial/generate-api-key.jpg)

## Generate Access Token

For security, every participant that connects to meeting needs a access token. By substituting `apikey` and `permissions` in it.

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="node"
groupId={"server-group-id"}
values={[
{label: 'Node.js', value: 'node'},
{label: 'Python', value: 'python'},
{label: 'Java', value: 'java'},
{label: 'Ruby', value: 'ruby'},
{label: 'PHP', value: 'php'},
]}>
<TabItem value="node">

```js
var jwt = require("jsonwebtoken");
var uuid4 = require("uuid4");

// Need to generate from app.videosdk.live
const API_KEY = "API_KEY_GENERATED";
const SECRET_KEY = "API_SECRET_KEY_GENERATED";

jwt.sign(
  {
    apikey: API_KEY,
    permissions: ["allow_join"], // Permission to join the meeting
  },
  SECRET_KEY,
  {
    algorithm: "HS256",
    expiresIn: "24h",
    jwtid: uuid4(),
  },
  function (err, token) {
    console.log(token);
  }
);
```

</TabItem>
<TabItem value="python">

```python
#!/usr/bin/env python3
import jwt
import uuid
import datetime

api_key = 'api_key_generated'
secret_key = 'secret_key_generated'


def generateToken():
    expires = 24 * 3600
    now = datetime.datetime.utcnow()
    exp = now + datetime.timedelta(seconds=expires)
    return jwt.encode(payload={
          'apikey': api_key,
          permissions: ["allow_join"]
        }, key=secret_key).decode('utf-8')

if __name__ == '__main__':
    print(generateToken())
```

</TabItem>
<TabItem value="java">

```js
import java.time.Instant;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;
import java.util.UUID;
import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.SignatureAlgorithm;

private void generateManagementToken() {
    Map<String, Object> payload = new HashMap<>();
    payload.put("apikey", "<api_key_generated>");
    payload.put("permissions", ["allow_join"]);
    String token = Jwts.builder().setClaims(payload).setId(UUID.randomUUID().toString())
        .setExpiration(new Date(System.currentTimeMillis() + 86400 * 1000))
        .setIssuedAt(Date.from(Instant.ofEpochMilli(System.currentTimeMillis() - 60000)))
        .setNotBefore(new Date(System.currentTimeMillis()))
        .signWith(SignatureAlgorithm.HS256, "<secret_key_generated>".getBytes()).compact();
  }
```

</TabItem>
<TabItem value="ruby">

```js
require 'jwt'
require 'securerandom'

$api_key = "api_key_generated"
$secret_key = "secret_key_generated"

def generateToken()
    payload = {
      apikey: $api_key,
      permissions: ["allow_join"]
    }
token = JWT.encode(payload, $secret_key, 'HS256')
return token
end

puts generateToken
```

</TabItem>
<TabItem value="php">

```js
<?php

use Firebase\JWT\JWT;
use Ramsey\Uuid\Uuid;

$api_key = "api_key_generated";
$secret_key = "secret_key_generated"

$payload = [
    'apikey' => api_key,
    'permissions': ["allow_join"],
];

$token = JWT::encode($payload, $secret_key, 'HS256');
?>
```

</TabItem>
</Tabs>

Available permissions are:

- **allow_join**: The participant will be permitted entry without request.
- **ask_join**: The participant will not be permitted entry without request.
- **allow_mod**: Allow participant to enable/disable other participant's mic/webcam.


---

---
title: Chat messages with PubSub - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: PubSub features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Chat using PubSub
pagination_label: Chat using PubSub
keywords:
  - Chat in meeting
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: chat-using-pubsub
---

# Chat using PubSub - Android

For the communication or any kind of messaging in between the participants, VideoSDK provides `pubSub` class which use Publish-Subscribe mechanism and can be used to develope wide varitey of functionalities. For example, participants could use it to send chat messages to each other, share files or other media, or even trigger actions like muting or unmuting audio or video.

Now we will see, how we can use PubSub to implement Chat functionality. If you are not familiar with the PubSub mechanism and `pubSub` class, you can [follow this guide](./pubsub).

## Implementing Chat

### `Group Chat`

1. First step in creating a group chat is choosing the topic which all the participants will publish and subscribe to send and receive the messages. We will be using `CHAT` as the topic for this one.
2. On the send button, publish the message that the sender typed in the `EditText` field.

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle
import android.view.View
import android.widget.EditText
import android.widget.Toast
import androidx.appcompat.widget.Toolbar
import live.videosdk.rtc.android.Meeting
import live.videosdk.rtc.android.listeners.PubSubMessageListener
import live.videosdk.rtc.android.model.PubSubPublishOptions

class ChatActivity : AppCompatActivity() {
  // Meeting
  var meeting: Meeting? = null

  override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    setContentView(R.layout.activity_chat)

    /**
     * Here, we have created 'MainApplication' class, which extends android.app.Application class.
     * It has Meeting property and getter and setter methods of Meeting property.
     * In your android manifest, you must declare the class implementing android.app.Application
     * (add the android:name=".MainApplication" attribute to the existing application tag):
     * In MainActivity.kt, we have set Meeting property.
     *
     * For Example: (MainActivity.kt)
     * var meeting = VideoSDK.initMeeting(context, meetingId, ParticipantName, micEnabled, webcamEnabled, paricipantId, mode, multiStream, customTrack, metaData, signalingBaseUrl,preferredProtocol)
     * (this.application as MainApplication).meeting = meeting
    */

    // Get Meeting
    meeting = (this.application as MainApplication).meeting

    findViewById(R.id.btnSend).setOnClickListener(view -> sendMessage());
  }

  private fun sendMessage() {
    // get message from EditText
    val message: String = etmessage.getText().toString()
    if (!TextUtils.isEmpty(message)) {
        val publishOptions = PubSubPublishOptions()
        publishOptions.setPersist(true)

        // Sending the Message using the publish method
        //highlight-next-line
        meeting!!.pubSub.publish("CHAT", message, publishOptions)

        // Clearing the message input
        etmessage.setText("")
    } else {
        Toast.makeText(
            this@ChatActivity, "Please Enter Message",
            Toast.LENGTH_SHORT
        ).show()
    }
  }
}
```

</TabItem>

<TabItem value="Java">

```js
import androidx.appcompat.app.AppCompatActivity;
import android.os.Bundle;
import java.util.List;
import live.videosdk.rtc.android.Meeting;
import live.videosdk.rtc.android.lib.PubSubMessage;
import live.videosdk.rtc.android.listeners.PubSubMessageListener;
import live.videosdk.rtc.android.model.PubSubPublishOptions;

public class ChatActivity extends AppCompatActivity {
  // Meeting
  Meeting meeting;

  @Override
  protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_chat);

    /**
     * Here, we have created 'MainApplication' class, which extends android.app.Application class.
     * It has Meeting property and getter and setter methods of Meeting property.
     * In your android manifest, you must declare the class implementing android.app.Application
     * (add the android:name=".MainApplication" attribute to the existing application tag):
     * In MainActivity.java, we have set Meeting property.
     *
     * For Example: (MainActivity.java)
     * Meeting meeting = VideoSDK.initMeeting(context, meetingId, ParticipantName, micEnabled, webcamEnabled, participantId, mode, multiStream, customTrack,metaData, signalingBaseUrl,preferredProtocol);
     * ((MainApplication) this.getApplication()).setMeeting(meeting);
    */

    // Get Meeting
    meeting = ((MainApplication) this.getApplication()).getMeeting();

    findViewById(R.id.btnSend).setOnClickListener(view -> sendMessage());
  }

  private void sendMessage()
  {
    // get message from EditText
    String message = etmessage.getText().toString();
    if (!message.equals("")) {
        PubSubPublishOptions publishOptions = new PubSubPublishOptions();
        publishOptions.setPersist(true);

        // Sending the Message using the publish method
        //highlight-next-line
        meeting.pubSub.publish("CHAT", message, publishOptions);

        // Clearing the message input
        etmessage.setText("");
    } else {
        Toast.makeText(ChatActivity.this, "Please Enter Message",
                Toast.LENGTH_SHORT).show();
    }
  }
}
```

</TabItem>

</Tabs>

3. Next step would be to display the messages others send. For this we have to `subscribe` to that topic i.e `CHAT` and display all the messages.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
class ChatActivity : AppCompatActivity() {

  // PubSubMessageListener
  //highlight-start
  var pubSubMessageListener =
    PubSubMessageListener { message ->
      // New message
      Toast.makeText(
            this@ChatActivity, message.senderName + " says : " + message.message,
            Toast.LENGTH_SHORT
        ).show()
  }
  //highlight-end

  override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    setContentView(R.layout.activity_chat)

    //...

    // Subscribe for 'CHAT' topic
    //highlight-next-line
    val pubSubMessageList = meeting!!.pubSub.subscribe("CHAT", pubSubMessageListener)

    for (message in pubSubMessageList) {
      // Persisted messages
      Toast.makeText(
            this@ChatActivity, message.senderName + " says : " + message.message,
            Toast.LENGTH_SHORT
        ).show()
    }
  }
}
```

</TabItem>

<TabItem value="Java">

```js
public class ChatActivity extends AppCompatActivity {

  // PubSubMessageListener
  //highlight-start
  private PubSubMessageListener pubSubMessageListener = new PubSubMessageListener() {
    @Override
    public void onMessageReceived(PubSubMessage message) {
        // New message
        Toast.makeText(
          ChatActivity.this, message.senderName + " says : "+ message.getMessage(),
          Toast.LENGTH_SHORT
        ).show();
    }
  };
  //highlight-end

  @Override
  protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_chat);

    //..

    // Subscribe for 'CHAT' topic
    //highlight-next-line
    List<PubSubMessage> pubSubMessageList = meeting.pubSub.subscribe("CHAT", pubSubMessageListener);

    for(PubSubMessage message : pubSubMessageList){
        // Persisted messages
        Toast.makeText(
          ChatActivity.this, message.senderName + " says : "+ message.getMessage(),
          Toast.LENGTH_SHORT
        ).show();
    }
  }
}
```

</TabItem>

</Tabs>

4. Final step in the group chat would be `unsubscribe` to that topic, which you had previously subscribed but no longer needed. Here we are `unsubscribe` to `CHAT` topic on activity destroy.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
class ChatActivity : AppCompatActivity() {
  override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    setContentView(R.layout.activity_chat)

    //...
  }

  override fun onDestroy() {
    // Unsubscribe for 'CHAT' topic
    //highlight-next-line
    meeting!!.pubSub.unsubscribe("CHAT", pubSubMessageListener)
    super.onDestroy()
  }
}
```

</TabItem>

<TabItem value="Java">

```js
public class ChatActivity extends AppCompatActivity {
  @Override
  protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_chat);

    //..
  }

  @Override
  protected void onDestroy() {
    // Unsubscribe for 'CHAT' topic
    //highlight-next-line
    meeting.pubSub.unsubscribe("CHAT", pubSubMessageListener);
    super.onDestroy();
  }
}
```

</TabItem>

</Tabs>

### `Private Chat`

In the above example, if you want to convert into the private chat between two participants, then all you have to do is pass `sendOnly` parameter in `PubSubPublishOptions`.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
class ChatActivity : AppCompatActivity() {

  //..
  
  private fun sendMessage() {
    // get message from EditText
    val message: String = etmessage.getText().toString()
    if (!TextUtils.isEmpty(message)) {
        val publishOptions = PubSubPublishOptions()
        publishOptions.setPersist(true)
        //highlight-start
        // Pass the participantId of the participant to whom you want to send the message.
        var sendOnly: Array<String> = arrayOf("xyz")
        publishOptions.setSendOnly(sendOnly);
        //highlight-end

        // Sending the Message using the publish method
        //highlight-next-line
        meeting!!.pubSub.publish("CHAT", message, publishOptions)

        // Clearing the message input
        etmessage.setText("")
    } else {
        Toast.makeText(
            this@ChatActivity, "Please Enter Message",
            Toast.LENGTH_SHORT
        ).show()
    }
  }
}
```

</TabItem>

<TabItem value="Java">

```js
public class ChatActivity extends AppCompatActivity {
 
  //...

  private void sendMessage()
  {
    // get message from EditText
    String message = etmessage.getText().toString();
    if (!message.equals("")) {
        PubSubPublishOptions publishOptions = new PubSubPublishOptions();
        publishOptions.setPersist(true);
        //highlight-start
        // Pass the participantId of the participant to whom you want to send the message.
        String[] sendOnly = {
          "xyz" 
        };
        publishOptions.setSendOnly(sendOnly);
        //highlight-end

        // Sending the Message using the publish method
        //highlight-next-line
        meeting.pubSub.publish("CHAT", message, publishOptions);

        // Clearing the message input
        etmessage.setText("");
    } else {
        Toast.makeText(ChatActivity.this, "Please Enter Message",
                Toast.LENGTH_SHORT).show();
    }
  }
}
```

</TabItem>

</Tabs>

### Downloading Chat Messages

All the messages from the PubSub which where published with `persist : true` and can be downloaded as an `.csv` file. This file will be available in the VideoSDK dashboard as well as throught the [Sessions API](/api-reference/realtime-communication/fetch-session-using-sessionid).

### API Reference

The API references for all the methods and events utilised in this guide are provided below.

- [pubSub()](/android/api/sdk-reference/pubsub-class/introduction)


---

---
title: PubSub - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: PubSub features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: PubSub
pagination_label: PubSub
keywords:
  - Start Livestream meeting
  - Stop Livestream meeting
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: pubsub
---

# PubSub - Android

PubSub is a short acronym for Publish-Subscribe mechanism. This mechanism is used to send and recieve messages from a particular topic. As the name suggests, for someone to send a message, they have to specify the topic and the message which should be published and for someone to receive a message, they should be subscribed to that topic.

Here is a visual to better understand publish-subscribe mechanism.

![pubsub](/img/pubsub.png)

## pubSub

In order to use PubSub in meeting, VideoSDK provides a class `pubSub` which allows you to subscribe to any topic and publish to any topic allowing to pass on messages and instructions during the meeting easily.

### `publish()`

- This method is used for publishing message of specific topic.
- This method can be accessed from the `pubSub` class, which is subclass of `Meeting` class.
- This method will accept following parameters as input:
  - `topic`: This will be the topic for which you are publishing a message.
  - `message`: This will be the actual message to be published. It has to be in `String` format.
  - `options`: This is an object of `PubSubPublishOptions` which specifies the options for publish. `PubSubPublishOptions` has 2 properties.
    - `persist` : `persist` offered the option of keeping the message around for the duration of the session. When `persist` is set to `true`, that message will be retained for upcoming participants and will be available in [VideoSDK Session Dashboard](https://app.videosdk.live/meetings/sessions) with `.CSV` format after completion of session.
    - `sendOnly`: If you want to send a message to specific participants, you can pass their respective `participantId` in form of `String[]`. If you don't provide any IDs or pass a `null` value, the message will be sent to all participants by default. This is optional parameter.
  - `payload`: If you need to include additional information along with a message, you can pass here as `JSONObject`. This is optional parameter.

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
private fun sendMessage() {
  // publish message
  val options = PubSubPublishOptions()
  options.isPersist = true
  //highlight-next-line
  meeting!!.pubSub.publish("CHAT", "Hello Everyone!", options)
}
```

</TabItem>

<TabItem value="Java">

```js
protected void sendMessage() {
  // publish message
  PubSubPublishOptions options = new PubSubPublishOptions();
  options.setPersist(true);
  //highlight-next-line
  meeting.pubSub.publish("CHAT", "Hello Everyone!", options);
}
```

</TabItem>

</Tabs>

### `subscribe()`

- This method is used to subscribe for particular topic.
- This method will accept two parameters as input:

  - `topic`: This will be the topic to be subscribed.
  - `listener`: This is an object of `PubSubMessageListener`, which listens for upcoming messages and calls `onMessageReceived` function, when new message received.

- This method will return `List<PubSubMessage>` which is a list of messages which were sent earlier.

The object of `PubSubMessage` contains following properties:

- `senderId`: This represents the `participantId` of the participant who send the message.
- `senderName`: This represents the `displayName` of the participant who send the message.
- `message`: This will be the actual message that was send.
- `timestamp`: This wil the timestamp for when the message was published.
- `topic`: This will be the name of the topic message was published to.
- `payload`: This will be the data that you have send with message.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
//highlight-start
var pubSubMessageListener =
  PubSubMessageListener { message ->
    // New message
    Log.v("New Message Received", message.senderName + " says : " + message.message)
  }
//highlight-end

@Override
protected void onCreate(Bundle savedInstanceState) {
  //...

  // Subscribe for 'CHAT' topic
  //highlight-next-line
  val pubSubMessageList = meeting!!.pubSub.subscribe("CHAT", pubSubMessageListener)

  // Persisted message list
  for (message in pubSubMessageList) {
    Log.v("Message List: ", message.senderName + " says : " + message.message)
  }
}
```

</TabItem>

<TabItem value="Java">

```js
//highlight-start
PubSubMessageListener pubSubMessageListener = new PubSubMessageListener() {
  @Override
  public void onMessageReceived(PubSubMessage message) {
    // New message
    Log.v("New Message Received", message.senderName + " says : " + message.getMessage());
  }
};
//highlight-end

@Override
protected void onCreate(Bundle savedInstanceState) {
  //...

  // Subscribe for 'CHAT' topic
  //highlight-next-line
  List<PubSubMessage> pubSubMessageList = meeting.pubSub.subscribe("CHAT",pubSubMessageListener);

  // Persisted message list
  for(PubSubMessage message : pubSubMessageList){
    Log.v("Message List: ", message.senderName + " says : " + message.getMessage());
  }
}
```

</TabItem>

</Tabs>

### `unsubscribe()`

- This method is used to unsubscribe for particular topic.
- This method will accept two parameters as input:

  - `topic`: This will be the topic to be unsubscribed.
  - `listener`: This is an object of `PubSubMessageListener`, which was passed in `subscribe()`.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
fun unsubscribe() {
  // Unsubscribe 'CHAT' topic
  meeting!!.pubSub.unsubscribe("CHAT", pubSubMessageListener)
}
```

</TabItem>

<TabItem value="Java">

```js
public void unsubscribe(){
  // Unsubscribe 'CHAT' topic
  meeting.pubSub.unsubscribe("CHAT", pubSubMessageListener);
}
```

</TabItem>

</Tabs>

## Applications of usePubSub

PubSub is a very powerful mechanism which can be used to do alot of things which can make your meeting experience much more interactive. Some of the most common usecase that we have come across for the PubSub during a meeting are listed below:

1. [`Chat`](./chat-using-pubsub): You can utilise this to develop various Chat features, such as Private Chat and Group Chat. You can follow our chat [integration guide here](./chat-using-pubsub).
2. `Raise Hand`: You can allow attendees to raise their hands at any time during the meeting, informing everyone else that someone has done so.
3. `Poll`: You may make polls, let users respond to them, and display the results at the end of a poll.
4. `Question Answer Session`: You can also design interactive functionality that is question-and-answer based.

### Downloading PubSub Messages

All the messages from the PubSub which were published with `persist : true` and can be downloaded as an `.csv` file. This file will be available in the VideoSDK dashboard as well as throught the [Sessions API](/api-reference/realtime-communication/fetch-session-using-sessionid).

### API Reference

The API references for all the methods and events utilised in this guide are provided below.

- [pubSub()](/android/api/sdk-reference/pubsub-class/introduction)


---

---
title: Raise Hand with PubSub - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: PubSub features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Raise Hand using PubSub
pagination_label: Raise Hand using PubSub
keywords:
  - Raise Hand
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: raise-hand-using-pubsub
---

# Raise Hand using PubSub - Android

Let us see, how we can use PubSub to implement Raise Hand functionality. If you are not familiar with the PubSub mechanism and `pubSub` class, you can [follow this guide](./pubsub).

## Implementing Raise Hand

1. First step in raise hand is choosing the topic which all the participants will publish and subscribe to know some participant raise their hand. We will be using `RAISE_HAND` as the topic for this one.
2. On the raiseHand button, publish any message to that specific topic.

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
class MainActivity : AppCompatActivity() {

  override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    setContentView(R.layout.activity_main)

    //...

    findViewById(R.id.btnRaiseHand).setOnClickListener(view -> sendRaiseHandMessage());
  }

  private fun sendRaiseHandMessage() {
    val publishOptions = PubSubPublishOptions()
    publishOptions.setPersist(false)

    // Sending the Message using the publish method
    //highlight-next-line
    meeting!!.pubSub.publish("RAISE_HAND", "Raise Hand", publishOptions)
  }
}
```

</TabItem>

<TabItem value="Java">

```js
public class MainActivity extends AppCompatActivity {
  @Override
  protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_chat);

    //...

    findViewById(R.id.btnRaiseHand).setOnClickListener(view -> sendRaiseHandMessage());
  }

  private void sendRaiseHandMessage()
  {
    PubSubPublishOptions publishOptions = new PubSubPublishOptions();
    publishOptions.setPersist(false);

    // Sending the Message using the publish method
    //highlight-next-line
    meeting.pubSub.publish("RAISE_HAND", "Raise Hand", publishOptions);
  }
}
```

</TabItem>

</Tabs>

3. Now let us show an alert to all the participants showing who raised the hand.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
class MainActivity : AppCompatActivity() {

  // PubSubMessageListener
  //highlight-start
  var pubSubMessageListener =
    PubSubMessageListener { message ->
      // Participant raise hand
      Toast.makeText(
            this@MainActivity, message.senderName + " raise hand",
            Toast.LENGTH_SHORT
        ).show()
  }
  //highlight-end

  override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    setContentView(R.layout.activity_chat)

    //...

    // Subscribe for 'RAISE_HAND' topic
    //highlight-next-line
    val pubSubMessageList = meeting!!.pubSub.subscribe("RAISE_HAND", pubSubMessageListener)
  }
}
```

</TabItem>

<TabItem value="Java">

```js
public class MainActivity extends AppCompatActivity {

  // PubSubMessageListener
  //highlight-start
  private PubSubMessageListener pubSubMessageListener = new PubSubMessageListener() {
    @Override
    public void onMessageReceived(PubSubMessage message) {
        // Participant raise hand
        Toast.makeText(
          MainActivity.this, message.senderName + " raise hand",
          Toast.LENGTH_SHORT
        ).show();
    }
  };
  //highlight-end

  @Override
  protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);

    //..

    // Subscribe for 'RAISE_HAND' topic
    //highlight-next-line
    List<PubSubMessage> pubSubMessageList = meeting.pubSub.subscribe("RAISE_HAND", pubSubMessageListener);
  }
}
```

</TabItem>

</Tabs>

### API Reference

The API references for all the methods and events utilised in this guide are provided below.

- [pubSub()](/android/api/sdk-reference/pubsub-class/introduction)


---

---
title: Render Whiteboard - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: Whiteboard is a digital canvas that allows users to collaborate in real-time by drawing, writing, and sharing ideas visually, making it ideal for brainstorming, presentations, and teamwork.
sidebar_label: Render Whiteboard
pagination_label: Render Whiteboard
keywords:
  - Start Livestream meeting
  - Stop Livestream meeting
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg2
sidebar_position: 1
slug: render-whiteboard
---

# Render Whiteboard - Android

This guide explains how to dynamically render a whiteboard in your Android application.

## Setup WebView

- The whiteboard is rendered using a `WebView` component.
- You can configure the required XML style using the following code

```js
<WebView
    android:id="@+id/webView"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    />
```

## Render the Whiteboard

You can start the whiteboard with `meeting.startWhiteboard()` method, which triggers the `onWhiteboardStarted()` event. The event provides the URL to load in the WebView for rendering. To stop it, call `meeting.stopWhiteboard()`, which triggers the `onWhiteboardStopped()` event.

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
class MeetingActivity : AppCompatActivity() {

    private lateinit var meeting: Meeting
    private lateinit var webView: WebView

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_meeting)

        webView = findViewById(R.id.webView)

        // Init and config meeting
        // meeting = ...

        meeting.addEventListener(meetingEventListener);

        val meetingEventListener = object : MeetingEventListener() {
            override fun onWhiteboardStarted(url: String) {
                super.onWhiteboardStarted(url)
                webView.loadUrl(url)
                webView.settings.javaScriptEnabled = true
                webView.webViewClient = WebViewClient()
            }

            override fun onWhiteboardStopped() {
                super.onWhiteboardStopped()
                //...
            }
        }

        findViewById<View>(R.id.btnStartWhiteboard).setOnClickListener {
            meeting.startWhiteboard()
        }

        findViewById<View>(R.id.btnStopWhiteboard).setOnClickListener {
            meeting.stopWhiteboard()
        }
    }
}
```

</TabItem>

<TabItem value="Java">

```js
public class MeetingActivity extends AppCompatActivity {
    
    private Meeting meeting;
    private WebView webView ;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        //...

        webView = findViewById(R.id.webView);
        /* 
        init and config meeting ...
        meeting = //...
        */
        meeting.addEventListener(meetingEventListener);
        
        final MeetingEventListener meetingEventListener = new MeetingEventListener() {
            //...
            @Override
            public void onWhiteboardStarted(String url) {
                super.onWhiteboardStarted(url);
                webView.loadUrl(url);
                webView.getSettings().setJavaScriptEnabled(true);
                webView.setWebViewClient(new WebViewClient());
            }

            @Override
            public void onWhiteboardStopped() {
                super.onWhiteboardStopped();
                //...
            }
        };

        findViewById(R.id.btnStartWhiteboard).setOnClickListener(v -> {
            meeting.startWhiteboard();
        });

        findViewById(R.id.btnStopWhiteboard).setOnClickListener(v -> {
            meeting.stopWhiteboard();
        });
    }
}
```

</TabItem>

</Tabs>


## API Reference

- [startWhiteboard()](/android/api/sdk-reference/meeting-class/methods#startwhiteboard)
- [stopWhiteboard()](/android/api/sdk-reference/meeting-class/methods#stopwhiteboard)
- [onWhiteboardStarted()](/android/api/sdk-reference/meeting-class/meeting-event-listener-class#onwhiteboardstarted)
- [onWhiteboardStopped()](/android/api/sdk-reference/meeting-class/meeting-event-listener-class#onwhiteboardstopped)




---

---
title: Upload & Fetch Temporary File | Video SDK
hide_title: true
hide_table_of_contents: false
description: Upload & Fetch Temporary File.
sidebar_label: Upload-Fetch Temporary File
pagination_label: Upload-Fetch Temporary File
keywords:
  - upload temporary file
  - fetch temporary file
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: upload-fetch-temporary-file
--- 

# Upload and Retrieve the Temporary File - Android

This guide demonstrates how to upload and retrieve files from VideoSDK's temporary file storage system.

### `uploadBase64File()`

- By using the `uploadBase64File()` method of the [`Meeting`](/android/api/sdk-reference/meeting-class/introduction) class, you can upload your file to Videosdk's Temporary storage.

- The `uploadBase64File()` method only works with `base64`. Therefore, it is necessary to convert your file into `base64` format.

- You have to pass `base64Data`,`token`,`fileName` and implementation of `TaskCompletionListener` as parameter in `uploadBase64File()` method.

- When the upload is complete, the `onComplete()` method of `TaskCompletionListener` will provide the corresponding `fileUrl`, which can be used to retrieve the uploaded file.

- If an error occurs during the upload process, the `onError()` method of `TaskCompletionListener` will provide the error details.

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
private fun uploadFile() {
  val base64Data = "<Your File's base64>" // Convert your file to base64 and pass here
  val token = "<VIDEOSDK_TOKEN>"
  val fileName = "myImage.jpeg" // Provide name with extension here
  meeting!!.uploadBase64File(
    base64Data,
    token,
    fileName,
    object : TaskCompletionListener<String?, String?> {
      override fun onComplete(data: String?) {
          Log.d("VideoSDK", "Uploaded file url: $data")
      }

      override fun onError(error: String?) {
          Log.d("VideoSDK", "Error in upload file: $error")
      }
    }
  )
}
```

</TabItem>

<TabItem value="Java">

```js
private void uploadFile() {
  String base64Data = "<Your File's base64>"; // Convert your file to base64 and pass here
  String token = "<VIDEOSDK_TOKEN>";
  String fileName = "myImage.jpeg"; // Provide name with extension here
  meeting.uploadBase64File(base64Data, token, fileName, new TaskCompletionListener<String, String>() {
    @Override
    public void onComplete(@Nullable String data) {
        Log.d("VideoSDK", "Uploaded file url: " + data);
    }

    @Override
    public void onError(@Nullable String error) {
        Log.d("VideoSDK", "Error in upload file: " + error);
    }
  });
}
```

</TabItem>

</Tabs>


### `fetchBase64File()`

- By using the `fetchBase64File()` method of the [`Meeting`](/android/api/sdk-reference/meeting-class/introduction) class, you can retrieve your file from Videosdk's Temporary storage.

- To retrieve a file, you need to pass the `fileUrl` (which is returned by the `uploadBase64File()` method), the `token`, and an implementation of the `TaskCompletionListener` as parameters.

- When the fetch operation is complete, the `onComplete()` method of `TaskCompletionListener` will provide the file in `base64` format.

- If an error occurs during the fetch operation, the `onError()` method of `TaskCompletionListener` will provide the error details.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
private fun fetchFile() {
  val url = "<Your FileUrl>"  // Provide fileUrl which is returned by uploadBase64File()
  val token = "<VIDEOSDK_TOKEN>"
  meeting.fetchBase64File(url, token, object : TaskCompletionListener<String?, String?> {
      override fun onComplete(data: String?) {
          Log.d("VideoSDK", "Fetched file in base64:$data")
      }

      override fun onError(error: String?) {
          Log.d("VideoSDK", "Error in fetch file: $error")
      }
  })
}
```

</TabItem>

<TabItem value="Java">

```js
private void fetchFile() {
  String url = "<Your FileUrl>";  // Provide fileUrl which is returned by uploadBase64File()
  String token = "<VIDEOSDK_TOKEN>";
  meeting.fetchBase64File(url, token, new TaskCompletionListener<String, String>() {
      @Override
      public void onComplete(@Nullable String data) {
          Log.d("VideoSDK", "Fetched file in base64:" + data);
      }

      @Override
      public void onError(@Nullable String error) {
          Log.d("VideoSDK", "Error in fetch file: " + error);
      }
  });
}
```

</TabItem>

</Tabs>


:::note

The file stored in the system will be automatically deleted once the current room/meeting comes to an end.

:::

### API Reference

The API references for all the methods and events utilised in this guide are provided below.

- [uploadBase64File()](/android/api/sdk-reference/meeting-class/methods#uploadbase64file)
- [fetchBase64File()](/android/api/sdk-reference/meeting-class/methods#fetchbase64file)

---

---
title: Whiteboard - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: Whiteboard is a digital canvas that allows users to collaborate in real-time by drawing, writing, and sharing ideas visually, making it ideal for brainstorming, presentations, and teamwork.
sidebar_label: Start/Stop Whiteboard
pagination_label: Start/Stop Whiteboard
keywords:
  - Start Livestream meeting
  - Stop Livestream meeting
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg2
sidebar_position: 1
slug: whiteboard
---

# Whiteboard - Android

The Whiteboard is an interactive, shared canvas that enables users to collaborate in real-time within your Android application. It allows multiple participants to draw, write, and add annotations simultaneously, making it ideal for meetings, presentations, brainstorming sessions, and other collaborative activities.

This documentation will guide you on how to start and stop the whiteboard, and handle the necessary events to ensure a smooth user experience.

## `startWhiteboard()`

- To start the whiteboard session, you can call the `startWhiteboard()` method of the `meeting` class, which initializes the whiteboard and makes it available for user interaction.

### Events associated with startWhiteboard

- All participants will receive the `onWhiteboardStarted` event from the `MeetingEventListener` when the whiteboard starts successfully. This event provides a URL that can be used to render and interact with the whiteboard within the app.

- The whiteboard URL can be displayed using a `WebView` component, allowing participants to interact seamlessly within the app. For detailed instructions on rendering the whiteboard, refer to this [guide](/android/guide/video-and-audio-calling-api-sdk/collaboration-in-meeting/render-whiteboard).


import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
val meetingEventListener = object : MeetingEventListener() {
    override fun onWhiteboardStarted(url: String) {
        super.onWhiteboardStarted(url)
        //...
    }
    //...
    meeting!!.addEventListener(meetingEventListener)
}
```

</TabItem>

<TabItem value="Java">

```js
final MeetingEventListener meetingEventListener = new MeetingEventListener() {
    @Override
    public void onWhiteboardStarted(String url) {
        super.onWhiteboardStarted(url);
        //...
    }
    //...
    meeting!!.addEventListener(meetingEventListener)
};
```

</TabItem>

</Tabs>

## `stopWhiteboard()`

- To end the whiteboard session, you can call the `stopWhiteboard()` method of the `meeting` class, which terminates the active whiteboard and cleans up any resources associated with it.

### Events associated with stopWhiteboard

- All participants will receive the `onWhiteboardStopped` event from the `MeetingEventListener` when the whiteboard session is successfully terminated. This event signals that the whiteboard is no longer available for interaction within the app.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
val meetingEventListener = object : MeetingEventListener() {
    override fun onWhiteboardStopped() {
        super.onWhiteboardStopped()
        //...
    }
    //...
    meeting!!.addEventListener(meetingEventListener)
}
```

</TabItem>

<TabItem value="Java">

```js
final MeetingEventListener meetingEventListener = new MeetingEventListener() {
    @Override
    public void onWhiteboardStopped() {
        super.onWhiteboardStopped();
        //...
    }
    //...
    meeting!!.addEventListener(meetingEventListener)
};
```

</TabItem>

</Tabs>


## API Reference

- [startWhiteboard()](/android/api/sdk-reference/meeting-class/methods#startwhiteboard)
- [stopWhiteboard()](/android/api/sdk-reference/meeting-class/methods#stopwhiteboard)
- [onWhiteboardStarted()](/android/api/sdk-reference/meeting-class/meeting-event-listener-class#onwhiteboardstarted)
- [onWhiteboardStopped()](/android/api/sdk-reference/meeting-class/meeting-event-listener-class#onwhiteboardstopped)




---

---
title: VideoView Video & Audio Call - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: VideoView component quick integrate in Android with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: VideoView
pagination_label: VideoView
keywords:
  - SurfaceViewRender
  - VideoView
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: videoView
---

import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>

# What is SurfaceViewRender ?

`SurfaceViewRender` is a very powerful component of `WebRTC` since it is used to display the video stream on a SurfaceView. You can use `SurfaceViewRender` to show video of participant in your screen.

Here's the lifecycle of a SurfaceViewRenderer:

<div style={{textAlign: 'center'}}>

<img style={{height: '200px'}} src="/img/android/VideoView/life-cycle.png" />

</div>

Which means:

1. The SurfaceViewRenderer must be first initialised after being created and before it can be use at all. It starts a render thread.

2. `addSink()` needs to be called when you are having VideoTrack to render. addSink is method of `VideoTrack` that you want to add to it. You have to pass `surfaceViewRender` as parameter.

3. `removeSink()` should only be called when you're done showing the video. Another method of `VideoTrack`, and it takes the `surfaceViewRenderer` as a parameter.

4. Release at last to allow the render thread to terminate. This function should be called before the activity is destroyed and/or before init it again.

#### Mistakes you might make and stuck :

###### 1. Not initialised surfaceViewRender

The video never appears since a render thread was never start and you will see black view.

###### 2. Init it again before releasing it.

If you are not releasing surfaceViewRender before calling `init()` again, you will get this error.

```js
java.lang.IllegalStateException: svrParticipant Already initialized
        at org.webrtc.EglRenderer.init(EglRenderer.java:212)
```

###### 3. Two videos render on same SurfaceViewRender

If you called `addSink()` on the same `SurfaceViewRenderer` for two different tracks and did not call `removeSink` before that, then you will see two different videos on same SurfaceViewRenderer with flickers which would look like this :

import ReactPlayer from 'react-player'

<div style={{textAlign: 'center'}}>

<ReactPlayer controls url="/img/android/VideoView/android-flicker.mp4" height="500px" width={"100%"} />

</div>

<br/>

Too complicated right? However, VideoSDK makes it simple for you. You can use `VideoView` instead of `SurfaceViewRenderer`.

:::info

- If you want to use `VideoView`, please update SDK version to `0.1.13` or higher.

:::

### VideoView

`VideoView` provides a better abstraction to render live video and handles edge cases like managing init state, render more than one videos on same surfaceViewRender.

### Methods

1. **addTrack(VideoTrack videoTrack)** - `addTrack` will initialised SurfaceViewRender for you and render videoTrack that you provided.

2. **removeTrack()** - `removeTrack` should only be called when you're done showing the video.

3. **releaseSurfaceViewRenderer()** - `releaseSurfaceViewRenderer` should be called before the activity is destroyed.

#### How to use VideoView ?

##### Layout

```js
// <org.webrtc.SurfaceViewRenderer
//        android:id="@+id/svrParticipant"
//        android:layout_width="match_parent"
//        android:layout_height="match_parent" />

<live.videosdk.rtc.android.VideoView
  android:id="@+id/participantView"
  android:layout_width="match_parent"
  android:layout_height="match_parent"
/>
```

##### Initalising and adding video track

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
// svrParticipant.init(PeerConnectionUtils.getEglContext(), null)
// var track = stream.getTrack() as VideoTrack
// track!!.addSink(svrParticipant)

val track = stream.track as VideoTrack
participantView!!.addTrack(track);
```

</TabItem>

<TabItem value="Java">

```js
// svrParticipant.init(PeerConnectionUtils.getEglContext(), null);
// VideoTrack track = (VideoTrack) stream.getTrack();
// track.addSink(svrParticipant);

VideoTrack track = (VideoTrack) stream.getTrack();
participantView.addTrack(track);
```

</TabItem>

</Tabs>

##### removeTrack

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
// var track = stream.track as VideoTrack
// track!!.removeSink(svrParticipant);

participantView.removeTrack();
```

</TabItem>

<TabItem value="Java">

```js
// VideoTrack track = (VideoTrack) stream.getTrack();
// if (track != null) track.removeSink(svrParticipant);

participantView.removeTrack();
```

</TabItem>

</Tabs>

#### release

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
override fun onDestroy() {
        participantView.releaseSurfaceViewRenderer()
        super.onDestroy()
}
```

</TabItem>

<TabItem value="Java">

```js
@Override
protected void onDestroy() {
    participantView.releaseSurfaceViewRenderer();
    super.onDestroy();
}
```

</TabItem>

</Tabs>


---

---
sidebar_label: Concept And Architecture
pagination_label: Concept And Architecture
---

# Concept and Architecture - Android

Before diving into the concept, let's understand the VideoSDK, VideoSDK is a software development kit that offers tools and APIs for creating apps that are based on video and audio. It typically includes features such as video and audio calls, chat, cloud recording, simulcasting (RTMP), interactive live streaming (HLS), and many more across a wide range of platforms and devices.

## Concepts

![img.png](../../../../static/img/room-concept.png)

### `1. Meeting / Room`

- Meeting or Room object in the VideoSDK provide a virtual place for participants to interact and engage in real-time voice, video, and screen-sharing sessions. The object is in charge of handling media streams and participant communication.

- Meeting or Room can be uniquely identified by `meetingId` or `roomId`.

### `2. Participant`

- Participant is a VideoSDK object that represents each user/client in the meeting or room and allows them to share audio/video assets.

- `2.1 Local Participant` :
  The local participant is the one that runs on the user's device. The local participant has control over their own media streams, including the ability to start and stop audio and video.

  - The local participant in a meeting/room can also connect with other participants by transmitting and receiving audio and video streams, exchanging chat messages, and more.

- `2.2 Remote Participant` :
  The remote participant receives audio and video streams from the local participant and other remote participants and also has the ability to exchange audio, video, and chat messages with the local participant.

- Each participant in VideoSDK can be uniquely identified by `participantId`.

### `3. MediaStream & Track`

- A mediastream is a collection of audio & video tracks that can be transmitted between participants in real-time.

- A track is a continuous flow of audio or video data and can be thought of as a stream of media frames.

- A mediastream can contain multiple tracks. One video track for the video feed from the camera and one audio track for the audio feed from the microphone. These tracks can be transmitted between participants in VideoSDK Meeting / Room.

### `4. Events / Notifications`

- Events / Notifications can be used to inform users about various activities happening in a Meeting / Room, including participant join/leave and new messages. They can also be used to alert users about any SDK-level errors that occur during a call.

### `5. Session`

- A Session is the instance of an ongoing meeting/room which has one or more participants in it. A single room or meeting can have multiple sessions.
- Each session can be uniquely identified by `sessionId`.

![img.png](../../../../static/img/meeting-session.jpg)

---

![img.png](../../../../static/img/recording-hls-rtmp.png)

### `6. Cloud Recording`

- Cloud recording in VideoSDK refers to the process of recording audio or video content and storing it on a remote server or VideoSDK server.

### `7. Simulcasting (RTMP)`

- RTMP is a popular protocol for live streaming video content from a VideoSDK to platforms such as YouTube, Twitch, Facebook, and others.
- By providing the platform-specific `stream key` and `stream URL`, the VideoSDK can connect to the platform's RTMP server and transmit the live video stream.

### `8. Http Live Streaming (HLS)`

- Interactive live streaming (HLS) refers to a type of live streaming where viewers can actively engage with the content being streamed and with other viewers in real-time.

- In an interactive live stream (HLS), viewers can take part in a variety of activities like live polling, Q&A sessions, and even sending virtual gifts to the content creator or each other.

## Architecture

This diagram demonstrates end-to-end flow to implement video & audio calls, record calls, and go live on social media.

![Video-sdk-architecture!](/img/video-sdk-archietecture.svg)


---

---
title: Mute All Participants | Video SDK
hide_title: true
hide_table_of_contents: false
description: Video SDK and Audio SDK, developers need to implement a token server. This requires efforts on both the front-end and backend.
sidebar_label: Mute All Participants
pagination_label: Mute All Participants
keywords:
  - audio calling
  - video calling
  - real-time communication
  - collaboration
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: mute-all-participants
---

# Mute All Participants - Android

If you are the host or moderator of a video conference, you may want to mute all the participants at once. This can be useful in various scenarios, such as when you want to deliver a presentation or when there is background noise that is causing distractions.

- To achieve this, you have to iterate over the list of participants from the `Meeting` class and call `disableMic` method from `Participant` class.

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
btnMuteAllParticipant!!.setOnClickListener { _: View? ->
  var participants: Iterator<Participant> = meeting.participants.values.iterator()
  for (i in 0 until meeting.participants.size) {
      val participant = participants.next()
      participant.disableMic()
  }
}
```

</TabItem>

<TabItem value="Java">

```js
btnMuteAllParticipant.setOnClickListener(new View.OnClickListener() {
  @Override
  public void onClick(View v) {
    final Iterator<Participant> participants = meeting.getParticipants().values().iterator();
    for (int i = 0; i < meeting.getParticipants().size(); i++) {
      final Participant participant = participants.next();
      participant.disableMic();
    }
  }
});
```

</TabItem>

</Tabs>

:::note
Participant who will be muting other participants should have permission **`allow_mod`** passed in the token. To know more about permissions [**visit here**](/android/guide/video-and-audio-calling-api-sdk/authentication-and-token).
:::

### API Reference

The API references for all the methods and events utilised in this guide are provided below.

- [disableMic()](/android/api/sdk-reference/participant-class/methods#disablemic)


---

---
title: Toggle Remote Participant Media | Video SDK
hide_title: true
hide_table_of_contents: false
description: Video SDK and Audio SDK, developers need to implement a token server. This requires efforts on both the front-end and backend.
sidebar_label: Toggle Remote Participant Media
pagination_label: Toggle Remote Participant Media
keywords:
  - audio calling
  - video calling
  - real-time communication
  - collaboration
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: remote-participant-media
---

# Toggle Remote Participant Media - Android

When hosting a meeting, it's important that the host of the meeting should be able to request someone's Mic or Camera to be turned on or should be able to turn them off.

:::note
Participant who will be controlling other participant's mic and camera should have permission **`allow_mod`** passed in the token. To know more about permissions [**visit here**](/android/guide/video-and-audio-calling-api-sdk/authentication-and-token).
:::

Before we discuss the methods and events associated with this functionality, here is how the flow would look like.

![img1](../../../../../static/img/toggle-remote-media.png)

## Methods

### `enableMic()`

- If you wish to turn **on** the microphone of a participant, you will be calling the `enableMic()` from the `Participant` class.

- When this method is called, the participant whose microphone is requested will receive the `onMicRequested` event with the `participantId` of the participant who requested it and two callback functions `accept` and `reject` which should be called based on decision made by the user.

- **Example:** Meeting is running with **Participant A** and **Participant B**. Now **Participant A** wants to Enable Mic of **Participant B**, so **Participant A** will use `enableMic()` function to request **Participant B**, after that **Participant B** recieve the `onMicRequested` event, from there user can either accept or reject the incoming request.

### `enableWebcam()`

- If you wish to turn **on** the camera of a participant, you will be calling the `enableWebcam()` from the `Participant` class.

- When this method is called, the participant whose camera is requested will receive the `onWebcamRequested` event with the `participantId` of the participant who requested it and two callback functions `accept` and `reject` which should be called based on decision made by the user.

- **Example:** Meeting is running with **Participant A** and **Participant B**. Now **Participant A** wants to Enable Webcam of **Participant B**, so **Participant A** will use `enableWebcam()` function to request **Participant B**, after that **Participant B** recieve the `onWebcamRequested` event, from there user can either accept or reject the incoming request.

### `disableMic()`

- If you wish to turn **off** the microphone of a participant, you will be calling the `disableMic()` from the `Participant` class.
- This will disable the microphone of the participant.

### `disableWebcam()`

- If you wish to turn **off** the camera of a participant, you will be calling the `disableWebcam()` from the `Participant` class.
- This will disable the camera of the participant.

#### Example

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
btnEnableWebcam!!.setOnClickListener { _: View? ->
  // This will emit an event called "onWebcamRequested" to that particular participant
  participant!!.enableWebcam()
}

btnEnableMic!!.setOnClickListener { _: View? ->
  // This will emit an event called "onMicRequested" to that particular participant
  participant!!.enableMic()
}

btnDisableWebcam!!.setOnClickListener { _: View? ->
  // This will disable the webcam of that particular participant
  participant.disableWebcam()
}

btnDisableWebcam!!.setOnClickListener { _: View? ->
  // This will disable the mic of that particular participant
  participant.disableMic()
}
```

</TabItem>

<TabItem value="Java">

```js
btnEnableWebcam.setOnClickListener(new View.OnClickListener() {
    @Override
    public void onClick(View v) {
      // This will emit an event called "onWebcamRequested" to that particular participant
      participant.enableWebcam();
    }
});

btnEnableMic.setOnClickListener(new View.OnClickListener() {
    @Override
    public void onClick(View v) {
      // This will emit an event called "onMicRequested" to that particular participant
      participant.enableMic();
    }
});

btnDisableWebcam.setOnClickListener(new View.OnClickListener() {
    @Override
    public void onClick(View v) {
      // This will disable the webcam of that particular participant
      participant.disableWebcam();
    }
});

btnDisableMic.setOnClickListener(new View.OnClickListener() {
    @Override
    public void onClick(View v) {
      // This will disable the mic of that particular participant
      participant.disableMic();
    }
});
```

</TabItem>

</Tabs>

## Events

### `onWebcamRequested`

This event will be emitted to the `Participant B` when any other `Participant A` requests to enable webcam of that participant (`Participant B`). This event handler will receieve following two arguments:

- `participantId` - ParticipantId of the requesting participant
- `listener`: MicRequestListener \{ accept: Method; reject: Method }

### `onMicRequested`

This event will be emitted to the `Participant B` when any other `Participant A` requests to enable mic of that participant (`Participant B`). This event handler will receieve following two arguments:

- `participantId` - ParticipantId of the requesting participant
- `listener`: MicRequestListener \{ accept: Method; reject: Method }

###### Usage

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
override fun onMicRequested(participantId: String, listener: MicRequestListener) {
  // callback function to accept the request
  listener.accept()

  // callback function to reject the request
  listener.reject()
}

override fun onWebcamRequested(participantId: String, listener: WebcamRequestListener) {
  // callback function to accept the request
  listener.accept()

  // callback function to reject the request
  listener.reject()
}
```

</TabItem>

<TabItem value="Java">

```javascript
@Override
public void onMicRequested(String participantId, MicRequestListener listener) {
  // callback function to accept the request
  listener.accept();

  // callback function to reject the request
  listener.reject();
}

@Override
public void onWebcamRequested(String participantId, WebcamRequestListener listener) {
  // callback function to accept the request
  listener.accept();

  // callback function to reject the request
  listener.reject();
}
```

</TabItem>

</Tabs>

## API Reference

The API references for all the methods and events utilised in this guide are provided below.

- [enableMic()](/android/api/sdk-reference/participant-class/methods#enablemic)
- [disableMic()](/android/api/sdk-reference/participant-class/methods#disablemic)
- [enableWebcam()](/android/api/sdk-reference/participant-class/methods#enablewebcam)
- [disableWebcam()](/android/api/sdk-reference/participant-class/methods#disablewebcam)
- [onMicRequested()](/android/api/sdk-reference/meeting-class/meeting-event-listener-class#onmicrequested)
- [onWebcamRequested()](/android/api/sdk-reference/meeting-class/meeting-event-listener-class#onwebcamrequested)


---

---
title: Remove participant from the meeting - React JS SDK
hide_title: false
hide_table_of_contents: false
description: Remove a participant or a peer from the meeting while it is still in progress. It helps in meeting moderation.
sidebar_label: Remove Participant
pagination_label: Remove Participant
keywords:
  - remove participant
  - block participant
  - react js
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: remove-participant
---

# Remove Participant - Android

This feature in a meeting allows the meeting host or organizer to remove a participant from the meeting. This can be helpful in situations where a participant is causing a disturbance, is behaving inappropriately, or is not following meeting guidelines.

VideoSDK provide three ways to remove participant from meeting.

1. [Using SDK](#1-using-sdk)
2. [Using VideoSDK Dashboard](#2-using-videosdk-dashboard)
3. [Using Rest API](#3-using-rest-api)

## 1. Using SDK

### `remove()`

Remove participant allows removing participant while session is on-going. This can be helpful when moderation in particular meeting is required.

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
btnRemoveParticipant!!.setOnClickListener { _: View? ->
  val remoteParticipantId = "<participant-id>"
  // Get specific participant instance
  val participant = meeting!!.participants[remoteParticipantId]
  // Remove participant from active session
  // This will emit an event called "onParticipantLeft" for that particular participant
  participant!!.remove()
}
```

</TabItem>

<TabItem value="Java">

```js
btnRemoveParticipant.setOnClickListener(new View.OnClickListener() {
  @Override
  public void onClick(View v) {
    String remoteParticipantId = "<participant-id>";
    // Get specific participant instance
    Participant participant = meeting.getParticipants().get(remoteParticipantId);
    // Remove participant from active session
    // This will emit an event called "onParticipantLeft" for that particular participant
    participant.remove();
  }
});
```

</TabItem>

</Tabs>

### Events associated with remove

Following callbacks are received when a participant is removed from the meeting.

- Participant who was removed from the meeting will receive a callback on the [`onMeetingLeft`](/android/api/sdk-reference/meeting-class/meeting-event-listener-class#onmeetingleft).
- All other [remote participants](../concept-and-architecture#2-participant) will receive a callback [`onParticipantLeft`](/android/api/sdk-reference/meeting-class/meeting-event-listener-class#onparticipantleft) with Participant object.

## 2. Using VideoSDK Dashboard

- You can go the session page on [VideoSDK Dashboard](https://app.videosdk.live/meetings/sessions) and select the meeting you can to remove a participant from.
- And then from the participants list you can remove any participant you want.

import ReactPlayer from 'react-player'

<div style={{textAlign: 'center'}}>

<ReactPlayer autoplay muted loop playing url='/video/kickout-user.mp4' width={"100%"}/>

</div>

## 3. Using Rest API

- You can also remove the particular participant from the meeting [using the REST API](/api-reference/realtime-communication/remove-participant).
- To use this method, you should have the `sessionId` of the meeting and `participantId` of the participant who is supposed to be removed.

## API Reference

The API references for all the methods and events utilised in this guide are provided below.

- [remove()](/android/api/sdk-reference/participant-class/methods#remove)
- [onMeetingLeft()](/android/api/sdk-reference/meeting-class/meeting-event-listener-class#onmeetingleft)
- [onParticipantLeft()](/android/api/sdk-reference/meeting-class/meeting-event-listener-class#onparticipantleft)


---

---
title: Integrate Banuba SDK with Android SDK - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: Describes how to integrate Banuba SDK with videosdk.live using Android SDK to enhance video calls with real-time face filters and virtual backgrounds.
sidebar_label: "Banuba Integration"
pagination_label: "Banuba Integration"
keywords:
  - android sdk
  - java sdk
  - kotlin sdk
  - banuba
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: banuba-integration
---

import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>

# How to intergrate Banuba SDK with Android Video SDK?

Use Banuba SDK with Android SDK to enhance video calls with real-time face filters and virtual backgrounds.

### Step 1: Banuba Token

- To start working with the Banuba SDK into your project, you need to have the client token. To receive the client token please fill form on [banuba.com](https://www.banuba.com/)

### Step 2: Add Banuba SDK dependencies

- With the client token, you will also receive the Banuba SDK archive for Android which contains Banuba Effect Player (compiled Android library project with .aar extension), Banuba SDK (compiled Android library project with .aar extension) and example filters located under effects folder.

- Create `libs` directory in your project and add `banuba_effect_player.aar`, `banuba_sdk.aar` files.

<div style={{textAlign: 'center'}}>

![Banuba SDK dependency .aar files](/img/android/banuba/banuba_dependency.png)

</div>

- Open build.gradle (Module: app) and add Banuba SDK dependencies.

```js title="app/build.gradle"
dependencies {
  // Banuba SDK dependencies
   implementation fileTree(dir: 'libs', include: ['*.aar'])

  // other app dependencies
  }
```

### Step 3: Add effects into your project

- Create `effects` folder under `assets` directory in your project and add filters that you want to use in the `effects` folder.You can download test effects here: [Effects](https://docs.banuba.com/face-ar-sdk-v1/overview/demo_face_filters)

<div style={{textAlign: 'center'}}>

![Banuba SDK effects folder](/img/android/banuba/banuba_effects.png)

</div>

### Step 4: Integrate Banuba

1. Create one interface named `IVideoFrameProcessor` and a class named `BanubaProcessor` in your project and copy paste code from the [example](https://github.com/videosdk-live/videosdk-rtc-android-sdk-banuba-example).

2. Update your Banuba client token into `BanubaProcessor.java` file.

```js title="BanubaProcessor.java"
public class BanubaProcessor implements IVideoFrameProcessor {
    //...
    public static final String KEY = "place_your_token_here";
    //...
}
```

3. Create instance of `CapturerObserver` class and pass into VideoSDK.createCameraVideoTrack() method. To know more about createCameraVideoTrack() method please visit [CustomVideoTrack](../features/custom-track/custom-video-track.md).

4. Copy paste method named `initVideoFrameProcessor(VideoSource videosource,CustomStreamTrack videoCustomTrack)` from the [example](https://github.com/videosdk-live/videosdk-rtc-android-sdk-banuba-example). into your Activity and call it after creating `CustomStreamTrack` for video.

### Step 5: Use filters in Meeting

- If you want to use video filters from start of the meeting, you can pass `CustomStreamTrack` in the `initMeeting`.

- Also you can use video filters during the meeting by passing the `CustomStreamTrack` in the `enableWebcam()` method of Meeting.

:::tip

Stuck anywhere? Check out this [Code Sample of Banuba Intergation with Android-SDK](https://github.com/videosdk-live/videosdk-rtc-android-sdk-banuba-example.git) on GitHub

:::


---

---
title: Camera Controls Video & Audio Call - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: Camera Controls features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Camera Controls
pagination_label: Camera Controls
keywords:
  - Camera on
  - Camera off
  - Webcam on
  - Webcam off
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: camera-controls
---

import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>

# Camera Controls - Android

Whenever any participant wants to start/stop broadcasting their video to other participant in a meeting, they can simply do it with VideoSDK Meeting.

This guide will provide an overview of how to implement enable, disable and switch webcam features in a meeting.

1. **Enable Camera** - By using `enableWebcam()` function, a participant can publish camera stream to other participants.
2. **Disable Camera** - By using `disableWebcam()` function, a participant can stop publishing camera stream to other participants.
3. **Switch Camera** - By using `changeWebcam()` function, a participant can stream from front / rear camera during the meeting.This function is only applicable for Mobile devices.

### Enable, Disable And Switch Webcam

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
  btnWebcam!!.setOnClickListener {

    // Toggle participant webcam in meeting
    if (webcamEnabled) {
      meeting!!.disableWebcam()
    } else {
      meeting!!.enableWebcam()
    }

    // Change Webcam in Meeting
    meeting!!.changeWebcam()
  }
```

</TabItem>

<TabItem value="Java">

```js
  btnWebcam.setOnClickListener(new View.OnClickListener() {
      @Override
      public void onClick(View v) {

        // Toggle participant webcam in meeting
        if (webcamEnabled) {
          meeting.disableWebcam();
        } else {
          meeting.enableWebcam();
        }

         // Change Webcam in Meeting
        meeting.changeWebcam();
      }
  });
```

</TabItem>

</Tabs>

### Events

**Event associated with `enableWebcam()`:**

- Every Participant will receive a callback on [`onStreamEnabled()`](../../../api/sdk-reference/participant-class/participant-event-listener-class.md#onstreamenabled) of the [`Participant`](../../../api/sdk-reference/participant-class//introduction.md) with `Stream` object.

**Event associated with `disableWebcam()`:**

- Every Participant will receive a callback on [`onStreamDisabled()`](../../../api/sdk-reference/participant-class/participant-event-listener-class.md#onstreamenabled) of the [`Participant`](../../../api/sdk-reference/participant-class//introduction.md) with `Stream` object.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
  meeting!!.localParticipant.addEventListener(object : ParticipantEventListener() {
    override fun onStreamEnabled(stream: Stream) {
        //

        if(stream.getKind().equals("video")){
          //participant turned on video
          //Render participant video
        }
    }

    override fun onStreamDisabled(stream: Stream) {
        //

        if(stream.getKind().equals("video")){
          //participant turned off video
          //remove participant video
        }
    }
  });
```

</TabItem>

<TabItem value="Java">

```js
  participant.addEventListener(new ParticipantEventListener() {
    @Override
    public void onStreamEnabled(Stream stream) {
        //
        if(stream.getKind().equals("video")){
          //participant turned on video
          //Render participant video
        }
    }

    @Override
    public void onStreamDisabled(Stream stream) {
        //
        if(stream.getKind().equals("video")){
          //participant turned off video
          //remove participant video
        }
    }
  });
```

</TabItem>

</Tabs>


---

---
title: Custom Audio Track
hide_title: false
hide_table_of_contents: false
description: Custom Audio Track features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Custom Audio Track
pagination_label: Custom Audio Track
keywords:
  - Camera on
  - Camera off
  - Webcam on
  - Webcam off
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
---

import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>

# Custom Audio Track - React Native

We have introduced the ability to pass a custom Audio track for the Audio of the participants with different encoder configuration.

## Creating a Custom Audio Track

- You can create a Audio Track using `createAudioTrack()` method of `VideoSDK`.
- This method can be used to create audio track using different encoding parameters.

### Parameters

- **encoderConfig**:

  - type: `String`
  - required: `true`
  - default: `speech_standard`
  - Allowed values : `speech_low_quality` | `speech_standard` | `music_standard` | `standard_stereo` | `high_quality` | `high_quality_stereo`
  - It will be the encoder configuration you want to use for Audio Track.

- **context**

  - type: `Context`
  - required: `true`
  - Pass the Android Context for this parameter.

#### Returns

- `CustomStreamTrack`

### Example

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
try {
  val audioCustomTrack: CustomStreamTrack = VideoSDK.createAudioTrack("high_quality",this)
} catch (e: JSONException) {
   e.printStackTrace()
}
```

</TabItem>

<TabItem value="Java">

```js
try {
  CustomStreamTrack audioCustomTrack=VideoSDK.createAudioTrack("high_quality", this);
}catch (JSONException e) {
  e.printStackTrace();
}
```

</TabItem>

</Tabs>

## Using Custom Audio Track

### Custom Track while initializing the meeting

If you are passing `micEnabled: true` in the `initMeeting` of `VideoSDK` and want to use custom tracks from start of the meeting, you can pass custom track in the `initMeeting` as shown below.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
override fun onCreate(savedInstanceState: Bundle?) {
    //..

    val customTracks: MutableMap<String, CustomStreamTrack> = HashMap()

    val audioCustomTrack: CustomStreamTrack = VideoSDK.createAudioTrack("high_quality", this)
    customTracks["mic"] = audioCustomTrack  //Key must be "mic"

    // create a new meeting instance
    val meeting = VideoSDK.initMeeting(
      this@MainActivity,meetingId,participantName,
      //MicEnabled , If true, it will use the passed custom track to turn mic on
      true,
      //WebcamEnabled
      true,
      //ParticipantId
      null,
      //Mode
      null,
      //Pass the custom tracks here
      customTracks
    )
}
```

</TabItem>

<TabItem value="Java">

```js
@Override
protected void onCreate(Bundle savedInstanceState) {
    //..

    Map<String, CustomStreamTrack> customTracks = new HashMap<>();

    CustomStreamTrack audioCustomTrack = VideoSDK.createAudioTrack("high_quality", this);
    customTracks.put("mic", audioCustomTrack);  //Key must be "mic"

    // create a new meeting instance
    Meeting meeting = VideoSDK.initMeeting(
        MainActivity.this, meetingId, participantName,
       //MicEnabled , If true, it will use the passed custom track to turn mic on
        true,
        //WebcamEnabled
        true,
        //ParticipantId
        null,
        //Mode
        null,
        //Pass the custom tracks here
        customTracks
    );

}
```

</TabItem>

</Tabs>

### Custom Track with `unmuteMic()`

In order to switch tracks during the meeting, you have to pass the `CustomStreamTrack` in the `unmuteMic()` method of `Meeting`.

You can also pass custom track in `changeMic()` method of `Meeting`.

:::note

Make sure to call `muteMic()` before you create a new track as it may lead to unexpected behavior.

:::

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
try {
  val audioCustomTrack: CustomStreamTrack = VideoSDK.createAudioTrack("high_quality", this)
  meeting!!.unmuteMic(audioCustomTrack)

  //or
  meeting!!.changeMic(AppRTCAudioManager.AudioDevice.BLUETOOTH, audioCustomTrack)
} catch (e: JSONException) {
  e.printStackTrace()
}

```

</TabItem>

<TabItem value="Java">

```js
try {
  CustomStreamTrack audioCustomTrack = VideoSDK.createAudioTrack("high_quality", this);
  meeting.unmuteMic(audioCustomTrack);

  //or
  meeting.changeMic(AppRTCAudioManager.AudioDevice.BLUETOOTH,audioCustomTrack);
}catch (JSONException e) {
  e.printStackTrace();
}

```

</TabItem>

</Tabs>


---

---
title: Custom Screen Share Track
hide_title: false
hide_table_of_contents: false
description: Custom Screen Share Track features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Custom Screen Share Track
pagination_label: Custom Screen Share Track
keywords:
  - Camera on
  - Camera off
  - Webcam on
  - Webcam off
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
---

import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>

# Custom Screen Share Track - React Native

We have introduced the ability to pass a custom Screen Share track while sharing the screen of participants. This feature can be used to add custom video encoder config,background removal & video filter from external SDK(e.g., [Banuba](https://www.banuba.com/)) and send it to other participants.

## Creating a Custom Screen Share Track

- You can create a Screen Share track using `createScreenShareVideoTrack()` method of `VideoSDK`.
- This method can be used to create screen share track using different encoding parameters.

### Parameters

- **encoderConfig**:

  - type: `String`
  - required: `true`
  - default: `h720p_15fps`
  - Allowed values : `h360p_30fps` | `h720p_5fps` | `h720p_15fps` | `h1080p_15fps` | `h1080p_30fps`
  - It will be the encoderConfigs you can want to use for the Screen Share Track.

:::note

Above mentioned encoder configurations are valid for both, landscape as well as portrait mode.

:::

- **data**

  - type: `Intent`
  - required: `true`
  - It is Intent received from onActivityResult when user provide permission for ScreenShare.

- **context**

  - type: `Context`
  - required: `true`
  - Pass the Android Context for this parameter.

- **listener**
  - type: `CustomTrackListener`
  - required: `true`
  - Callback to this listener will be made when track is ready with CustomTrack as parameter.

### Example

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
// data is received from onActivityResult method.
VideoSDK.createScreenShareVideoTrack("h720p_5fps", data, this) { track ->
    meeting!!.enableScreenShare(track)
}
```

</TabItem>

<TabItem value="Java">

```javascript
// data is received from onActivityResult method.
VideoSDK.createScreenShareVideoTrack("h720p_5fps", data, this, (track)->{
    meeting.enableScreenShare(track);
});
```

</TabItem>

</Tabs>

## Using Custom Screen Share Track

### Custom Track with `enableScreenShare()`

In order to switch tracks during the meeting, you have to pass the `CustomStreamTrack` in the `enableScreenShare()` method of `Meeting`.

:::note

Make sure to call `disableScreenShare()` before you create a new track as it may lead to unexpected behavior.

:::

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
@TargetApi(21)
private fun askPermissionForScreenShare() {
    val mediaProjectionManager = application.getSystemService<Any>(
        Context.MEDIA_PROJECTION_SERVICE
    ) as MediaProjectionManager
    startActivityForResult(
        mediaProjectionManager.createScreenCaptureIntent(), CAPTURE_PERMISSION_REQUEST_CODE
    )
}

@RequiresApi(api = Build.VERSION_CODES.LOLLIPOP)
override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) {
    super.onActivityResult(requestCode, resultCode, data)
    if (requestCode != CAPTURE_PERMISSION_REQUEST_CODE) return
    if (resultCode == RESULT_OK) {
        VideoSDK.createScreenShareVideoTrack("h720p_5fps", data, this) { track ->
            meeting!!.enableScreenShare(track)
        }
    }
}

```

</TabItem>

<TabItem value="Java">

```javascript
@TargetApi(21)
private void askPermissionForScreenShare() {
    MediaProjectionManager mediaProjectionManager =
        (MediaProjectionManager) getApplication().getSystemService(
            Context.MEDIA_PROJECTION_SERVICE);
    startActivityForResult(
        mediaProjectionManager.createScreenCaptureIntent(), CAPTURE_PERMISSION_REQUEST_CODE);
}

@RequiresApi(api = Build.VERSION_CODES.LOLLIPOP)
@Override
public void onActivityResult(int requestCode, int resultCode, Intent data) {
    super.onActivityResult(requestCode, resultCode, data);
    if (requestCode != CAPTURE_PERMISSION_REQUEST_CODE)
        return;
    if (resultCode == Activity.RESULT_OK) {
        VideoSDK.createScreenShareVideoTrack("h720p_5fps", data, this, (track)->{
            meeting.enableScreenShare(track);
        });
    }
}

```

</TabItem>

</Tabs>


---

---
title: Custom Video Track
hide_title: false
hide_table_of_contents: false
description: Custom Video Track features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Custom Video Track
pagination_label: Custom Video Track
keywords:
  - Camera on
  - Camera off
  - Webcam on
  - Webcam off
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
---

import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>

# Custom Video Track - React Native

We have introduced the ability to pass a custom video track for the video of the participants. This feature can be used to add custom video encoder config, optimization mode (whether you want to focus on **motion**, **text** or **detail** of the video) and background removal & video filter from external SDK(e.g., [Banuba](https://www.banuba.com/))and send it to other participants.

## Creating a Custom Video Track

- You can create a Video Track using `createCameraVideoTrack()` method of `VideoSDK`.
- This method can be used to create video track using different encoding parameters & camera facing mode.

### Parameters

- **encoderConfig**:

  - type: `String`
  - required: `true`
  - default: `h480p_w640p`
  - Allowed values : `h144p_w176p` | `h240p_w320p` | `h480p_w640p` | `h480p_w720p` | `h720p_w960p` | `h1080p_w1440p` | `h720p_w1280p`
  - It will be the encoderConfigs you can want to use for the Video Track.

:::note

Above mentioned encoder configurations are valid for both, landscape as well as portrait mode.

:::

- **facingMode**:

  - type: `String`
  - required: `true`
  - Allowed values : `front` | `back`
  - It will specify wheater to use front or back camera for the video track.

- **optimizationMode**

  - type: `CustomStreamTrack.VideoMode`
  - required: `true`
  - Allowed values: `motion` | `text` | `detail`
  - It will specify the optimization mode for the video track being generated.

- **context**:

  - type: `Context`
  - required: `true`
  - Pass the Android Context for this parameter.

- **observer**:

  - type: `CapturerObserver`
  - required: `false`
  - If you want to use video filter from external SDK(e.g., [Banuba](https://www.banuba.com/)) then pass instance of `CapturerObserver` in this parameter.

:::note

For Banuba integraion with VideoSDK, please visit [Banuba Intergation with VideoSDK](../../video-processor/banuba-integration.md)

:::

#### Returns

- `CustomStreamTrack`

### Example

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
val videoCustomTrack: CustomStreamTrack = VideoSDK.createCameraVideoTrack("h240p_w320p", "front", CustomStreamTrack.VideoMode.MOTION, this)
```

</TabItem>

<TabItem value="Java">

```javascript
CustomStreamTrack customStreamTrack = VideoSDK.createCameraVideoTrack("h240p_w320p", "front", CustomStreamTrack.VideoMode.MOTION, this);
```

</TabItem>

</Tabs>

## Using Custom Video Track

### Custom Track while initializing the meeting

If you are passing `webcamEnabled: true` in the `initMeeting` of `VideoSDK` and want to use custom tracks from start of the meeting, you can pass custom track in the `initMeeting` as shown below.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
override fun onCreate(savedInstanceState: Bundle?) {
    //..

    val customTracks: MutableMap<String, CustomStreamTrack> = HashMap()
    val videoCustomTrack: CustomStreamTrack =
    VideoSDK.createCameraVideoTrack("h240p_w320p", "back", false, CustomStreamTrack.VideoMode.MOTION, this)
    customTracks["video"] = videoCustomTrack  //Key must be "video"

     // create a new meeting instance
    val meeting = VideoSDK.initMeeting(
      this@MainActivity, meetingId, participantName,
      //MicEnabled
      true,
      //WebcamEnabled , If true, it will use the passed custom track to turn webcam on
      true,
      // ParticipantId
      null,
      // Mode
      null,
      //Pass the custom tracks here
      customTracks
    )
}
```

</TabItem>

<TabItem value="Java">

```js
@Override
protected void onCreate(Bundle savedInstanceState) {
    //..

    Map<String, CustomStreamTrack> customTracks = new HashMap<>();

    CustomStreamTrack videoCustomTrack = VideoSDK.createCameraVideoTrack("h240p_w320p", "back", CustomStreamTrack.VideoMode.MOTION, this);
    customTracks.put("video", videoCustomTrack);  //Key must be "video"

    // create a new meeting instance
    Meeting meeting = VideoSDK.initMeeting(
        MainActivity.this, meetingId, participantName,
       //MicEnabled
        true,
        //WebcamEnabled , If true, it will use the passed custom track to turn webcam on
        true,
        // ParticipantId
        null,
        // Mode
        null,
        //Pass the custom tracks here
        customTracks
        );
}
```

</TabItem>

</Tabs>

### Custom Track with `enableWebcam()`

In order to switch tracks during the meeting, you have to pass the `CustomStreamTrack` in the `enableWebcam()` method of `Meeting`.

:::note

Make sure to call `disableWebcam()` before you create a new track as it may lead to unexpected behavior.

:::

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
val customStreamTrack: CustomStreamTrack = VideoSDK.createCameraVideoTrack("h240p_w320p", "back", CustomStreamTrack.VideoMode.MOTION, this)
meeting!!.enableWebcam(customStreamTrack)
```

</TabItem>

<TabItem value="Java">

```javascript
CustomStreamTrack customStreamTrack=VideoSDK.createCameraVideoTrack("h240p_w320p", "back", CustomStreamTrack.VideoMode.MOTION, this);
meeting.enableWebcam(customStreamTrack);
```

</TabItem>

</Tabs>


---

---
sidebar_label: Error Event
pagination_label: Error Event
---

import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>

# Error Event - Android

This event is helpful for development level troubleshooting while integrating SDK.

Whenever any invalid configuration provided or server/network errors arise, this event will trigger with a specific error code and message.

This event can ease your development process.

We have depicted a specific constant with code and message in the below table.

| Constant                              | Code | Message                                                                                                                     |
| ------------------------------------- | ---- | --------------------------------------------------------------------------------------------------------------------------- |
| **INVALID_API_KEY**                   | 4001 | `apikey` provided in the token is empty or invalid, please verify it on the dashboard.                                      |
| **INVALID_TOKEN**                     | 4002 | `token` is empty or invalid or might have expired.                                                                          |
| **INVALID_MEETING_ID**                | 4003 | `meetingId` is empty or invalid, please verify it or generate new meetingId using the API.                                  |
| **INVALID_PARTICIPANT_ID**            | 4004 | `participantId` is empty or invalid, it shouldn't contain any whitespaces.                                                  |
| **DUPLICATE_PARTICIPANT**             | 4005 | Leaving meeting, since this `participantId` joined from another device.                                                     |
| **ACCOUNT_DEACTIVATED**               | 4006 | It seems your account is deactivated by VideoSDK for some reason, you can reach out to us at `support@videosdk.live`.       |
| **ACCOUNT_DISCONTINUED**              | 4007 | Server will respond you with specific message.\_                                                                            |
| **INVALID_PERMISSIONS**               | 4008 | `permissions` provided in the token are invalid, please don't use `allow_join` or `allow_mod` with `ask_join`.              |
| **START_RECORDING_FAILED**            | 4011 | Recording start request failed due to an unknown error.                                                                     |
| **STOP_RECORDING_FAILED**             | 4012 | Recording stop request failed due to an unknown error.                                                                      |
| **START_LIVESTREAM_FAILED**           | 4013 | Livestream start request failed due to an unknown error.                                                                    |
| **STOP_LIVESTREAM_FAILED**            | 4014 | Livestream stop request failed due to an unknown error.                                                                     |
| **MAX_SPEAKER_LIMIT_REACHED_ON_ORGANIZATION**    | 4026 | You have reached max speaker limit on organization. To increase contact at support@videosdk.live".                                                               |
| **MAX_VIEWER_LIMIT_REACHED_ON_ORGANIZATION**    | 4027 | You have reached max viewer limit on organization. To increase contact at support@videosdk.live".                                                               |
| **MAX_RECORDING_LIMIT_REACHED_ON_ORGANIZATION**    | 4028 | You have reached max limit of recording on organization. To increase contact at support@videosdk.live.                                                               |
| **MAX_HLS_LIMIT_REACHED_ON_ORGANIZATION**    | 4029 | You have reached max limit of hls on organization. To increase contact at support@videosdk.live.                                                               |
| **MAX_LIVESTREAM_LIMIT_REACHED_ON_ORGANIZATION**    | 4030 | You have reached max limit of livestream on organization. To increase contact at support@videosdk.live.                                                               |
| **INVALID_LIVESTREAM_CONFIG**         | 4015 | Livestream 'outputs' configuration provided was invalid.                                                                    |
| **PREV_RECORDING_PROCESSING**         | 4018 | Previous recording session is being processed, please try again after few seconds.                                          |
| **RECORDING_FAILED**                  | 5001 | Recording stopped due to an unknown error.                                                                                  |
| **LIVESTREAM_FAILED**                 | 5002 | Livestream stopped due to an unknown error.                                                                                 |
| **RECORDING_DURATION_LIMIT_REACHED**  | 5004 | Recording has been automatically stopped by the system, due to max duration limit of 2 hours reached for a single Recording |
| **LIVESTREAM_DURATION_LIMIT_REACHED** | 5005 | Livestream has been automatically stopped by the system, due to max duration limit of 2 hours reached for a single RTMP     |
| **HLS_DURATION_LIMIT_REACHED**        | 5006 | Hls has been automatically stopped by the system, due to max duration limit of 2 hours reached for a single HLS             |

### Event Code

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
private val meetingEventListener: MeetingEventListener = object : MeetingEventListener() {
    //..
    override fun onError(error: JSONObject) {
    try {
        val errorCodes: JSONObject = VideoSDK.getErrorCodes()
        val code = error.getInt("code")
        if (code == errorCodes.getInt("START_LIVESTREAM_FAILED")) {
            Log.d("#error", "Error is: " + error["message"])
        } else if (code == errorCodes.getInt("START_RECORDING_FAILED")) {
            Log.d("#error", "Error is: " + error["message"])
        }
    } catch (e: Exception) {
            e.printStackTrace()
        }
    }
}
```

</TabItem>

<TabItem value="Java">

```js
private final MeetingEventListener meetingEventListener = new MeetingEventListener() {
    //..
    @Override
    public void onError(JSONObject error) {
        try {
            JSONObject errorCodes = VideoSDK.getErrorCodes();
            int code = error.getInt("code");
            if (code == errorCodes.getInt("START_LIVESTREAM_FAILED")) {
                Log.d("#error", "Error is: " + error.get("message"));
            }else if(code == errorCodes.getInt("START_RECORDING_FAILED"))
            {
                Log.d("#error", "Error is: " + error.get("message"));
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
};
```

</TabItem>

</Tabs>


---

---
title: External Call Detection Video & Audio Call - Video SDK Docs
hide_title: false
hide_table_of_contents: false
sidebar_label: External Call Detection
pagination_label: External Call Detection
keywords:
  - External Call Detection
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: external-call-detection
---

import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>

# External Call Detection - Android

External call detection feature in VideoSDK let you know, participant is on the call during meeting.

Whenever local participant accept the incoming call or place outgoing call, `externalcall-started` event will trigger.`externalcall-started` event only received by localParticipant.

For example, the meeting is running with **Alice** and **Bob**. Whenever **Alice** receives the call or she call someone, **Alice** will receive `externalcall-started` event.

We can access `externalcall-started` event through [meeting object](/android/guide/video-and-audio-calling-api-sdk/features/start-join-meeting).

### externalcall-started Event

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
private val meetingEventListener: MeetingEventListener = object : MeetingEventListener() {
     // ...
    override fun onExternalCallStarted() {
      Log.d("#meeting", "onExternalCallAnswered")
    }
};
```

</TabItem>

<TabItem value="Java">

```js
private final MeetingEventListener meetingEventListener = new MeetingEventListener() {
     // ...
    @Override
    public void onExternalCallStarted() {
        Log.d("#meeting", "onExternalCallStarted");
    }
};
```

</TabItem>

</Tabs>


---

---
title: RTMP Live Social Media Video & Audio Call - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: RTMP Live Social Media features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Go Live On Social Media
pagination_label: Go Live On Social Media
keywords:
  - Facebook Live
  - Youtube Live
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: go-live-social-media
---

import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>

# Go Live On Social Media - Android

This feature allows participant to broadcast meeting on various social media platforms such as Facebook or Youtube.
This guide will provide an overview of how participant can start and stop broadcasting meeting.

1. **Start LiveStream** - By using `startLivestream()` function, a participant can start broadcasting meeting on various platforms by provding url and stream keys as an argument.
2. **Stop LiveStream** - By using `stopLivestream()` function, a participant can stop broadcasting on all platforms.

### Start And Stop Live Stream

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
private val YOUTUBE_RTMP_URL: String? = null
private val YOUTUBE_RTMP_STREAM_KEY: String? = null

//
findViewById<View>(R.id.btnLivestream).setOnClickListener {
    if (!livestreaming) {
        if (YOUTUBE_RTMP_URL == null || YOUTUBE_RTMP_STREAM_KEY == null) {
            throw Error("RTMP url or stream key missing.")
        }
        val outputs: MutableList<LivestreamOutput> = ArrayList()
        outputs.add(LivestreamOutput(YOUTUBE_RTMP_URL, YOUTUBE_RTMP_STREAM_KEY))

        meeting!!.startLivestream(outputs)
    } else {
        meeting!!.stopLivestream()
    }
}
```

</TabItem>

<TabItem value="Java">

```js
private static final String YOUTUBE_RTMP_URL = null;
private static final String YOUTUBE_RTMP_STREAM_KEY = null;

//
findViewById(R.id.btnLivestream).setOnClickListener(view -> {
    if (!livestreaming) {
        if (YOUTUBE_RTMP_URL == null || YOUTUBE_RTMP_STREAM_KEY == null) {
            throw new Error("RTMP url or stream key missing.");
        }

        List<LivestreamOutput> outputs = new ArrayList<>();
        outputs.add(new LivestreamOutput(YOUTUBE_RTMP_URL, YOUTUBE_RTMP_STREAM_KEY));

        meeting.startLivestream(outputs);
    } else {
        meeting.stopLivestream();
    }
});
```

</TabItem>

</Tabs>

### Events

- **onLiveStreamStateChanged** - A `onLiveStreamStateChanged` event will be triggered any time the broadcasting state of a meeting changes.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
object : MeetingEventListener() {
  override fun onLivestreamStateChanged(livestreamState: String?) {
    when (livestreamState) {
        "LIVESTREAM_STARTING" -> Log.d( "LivestreamStateChanged",
            "Meeting livestream is starting"
        )
        "LIVESTREAM_STARTED" -> Log.d( "LivestreamStateChanged",
            "Meeting livestream is started"
        )
        "LIVESTREAM_STOPPING" -> Log.d("LivestreamStateChanged",
            "Meeting livestream is stopping"
        )
        "LIVESTREAM_STOPPED" -> Log.d("LivestreamStateChanged",
            "Meeting livestream is stopped"
        )
    }
  }

}
```

</TabItem>

<TabItem value="Java">

```js
new MeetingEventListener() {
  @Override
  public void onLivestreamStateChanged(String livestreamState) {
      switch (livestreamState) {
          case "LIVESTREAM_STARTING":
              Log.d("LivestreamStateChanged", "Meeting livestream is starting");
              break;
          case "LIVESTREAM_STARTED":
              Log.d("LivestreamStateChanged", "Meeting livestream is started");
              break;
          case "LIVESTREAM_STOPPING":
              Log.d("LivestreamStateChanged", "Meeting livestream is stopping");
              break;
          case "LIVESTREAM_STOPPED":
              Log.d("LivestreamStateChanged", "Meeting livestream is stopped");
              break;
      }
  }
}
```

</TabItem>

</Tabs>


---

---
title: Leave End Meeting Video & Audio Call - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: Leave or End Meeting features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Leave or End Meeting
pagination_label: Leave or End Meeting
keywords:
  - Exit Meeting
  - Leave Meeting
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: leave-end-meeting
---

import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>

# Leave or End Meeting - Android

Whenever participant wishes to end their communication in the meeting, they can simply leave the meeting.

This guide will provide an overview of how to implement leave or end feature in VideoSDK meetings.

1. **Leave** - By using `leave()` function, only a participant will leave/exit the meeting, the rest of the meeting will continue with other participants.
2. **End** - By using `end()` function, meeting will end for each and every participant. So, use this function according to your use cases.

### Leave And End Meeting

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
  btnLeave!!.setOnClickListener { _: View? ->
    meeting!!.leave()
  }

  btnEnd!!.setOnClickListener { _: View? ->
    meeting!!.end()
  }
```

</TabItem>

<TabItem value="Java">

```js
  btnLeave.setOnClickListener(new View.OnClickListener() {
      @Override
      public void onClick(View v) {
        meeting.leave();
      }
  });

  btnEnd.setOnClickListener(new View.OnClickListener() {
      @Override
      public void onClick(View v) {
        meeting.end();
      }
  });
```

</TabItem>

</Tabs>

### Events

**Events associated with `leave()`:**

- Local participant will receive a callback on[`onMeetingLeft`](../../../api/sdk-reference/meeting-class/meeting-event-listener-class.md#onmeetingleft) of `Meeting`.
- All remote participants will receive a callback [`onParticipantLeft`](../../../api/sdk-reference/meeting-class/meeting-event-listener-class.md#onparticipantleft) with Participant object.

**Event associated with `end()`:**

- All remote participants and local participant will receive a callback on [`onParticipantLeft`](../../../api/sdk-reference/meeting-class/meeting-event-listener-class.md#onparticipantleft) with Participant object.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
private final MeetingEventListener meetingEventListener = new MeetingEventListener() {
  override fun onMeetingLeft() {
    Log.d("#meeting", "onMeetingleft()")
  }

  override fun onParticipantLeft(participant: Participant) {
    Log.d("#meeting", participant.displayName + " left");
  }
}
```

</TabItem>

<TabItem value="Java">

```javascript
private final MeetingEventListener meetingEventListener = new MeetingEventListener() {
  @Override
  public void onMeetingLeft() {
    Log.d("#meeting", "onMeetingleft()")
  }

  @Override
  public void onParticipantLeft(Participant participant) {
    Log.d("#meeting", participant.getDisplayName() + " left");
  }
}
```

</TabItem>

</Tabs>


---

---
title: Manage Participants Video & Audio Call - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: Manage Participants features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Manage Participants
pagination_label: Manage Participants
keywords:
  - Exit Meeting
  - Leave Meeting
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: manage-participants
---

import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>

# Manage Participants - Android

## 1. Local Participant (self)

Local participant is used to consume your video & audio streams.
it contains information about local participant such as displayName, id, quality and streams Map.

You can acces localParticipant from the [meeting object](/android/guide/video-and-audio-calling-api-sdk/features/start-join-meeting#2-initialization).

### Participant object properties

| Property Name | Type          | Description                                            |
| ------------- | ------------- | ------------------------------------------------------ |
| id            | string        | Unique id of the participant.                          |
| displayName   | string        | The name you define during the meeting initialization. |
| local         | boolean       | Indicates the participant is local or not.             |
| quality       | string        | Indicates the participant streams quality.             |
| Streams       | Map of Stream | Returns Video & Audio Streams.                         |

### Stream Object properties

| Property Name | Type   | Description        |
| ------------- | ------ | ------------------ |
| id            | string | Unique id          |
| codec         | string | Video/Audio codec. |
| kind          | string | Stream Kind.       |
| track         | string | MediaStreamTrack   |

## 2. Other Participants (Except You)

Other participants Map is used to get all the participants (except you) in the meeting at any given time.

Other participants Map contains same properties as [LocalParticipant](/android/guide/video-and-audio-calling-api-sdk/features/manage-participants#participant-object-properties).

### Local And Other Participants

```xml title="activity_main.xml"
  <live.videosdk.rtc.android.VideoView
      android:id="@+id/localView"
      android:layout_width="80dp"
      android:layout_height="100dp"
      android:layout_gravity="end" />

  <androidx.recyclerview.widget.RecyclerView
      android:id="@+id/rvParticipants"
      android:layout_width="match_parent"
      android:layout_height="match_parent" />
```

:::info

- Here the participant's video is displayed using `VideoView`, but you may also use `SurfaceViewRender` for the same.
- For `VideoView`, SDK version should be `0.1.13` or higher.
- To know more about `VideoView`, please visit [here](/android/guide/video-and-audio-calling-api-sdk/components/videoView)

:::

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js title="MainActivity.kt"
  import live.videosdk.rtc.android.VideoView
  import org.webrtc.VideoTrack

  private fun displayLocalParticipant() {
    var localView: VideoView = findViewById(R.id.localView)

    // display local video when stream available
    meeting!!.localParticipant.addEventListener(
       object : ParticipantEventListener() {
         override fun onStreamEnabled(stream: Stream) {
           if (stream.kind.equals("video", ignoreCase = true)) {
             val videoTrack = stream.track as VideoTrack
             localView.addTrack(videoTrack)
            }
         }
      }
    )
  }

  private fun displayRemoteParticipants() {
    val rvParticipants = findViewById<RecyclerView>(R.id.rvParticipants)
    rvParticipants.layoutManager = GridLayoutManager(this, 2)
    rvParticipants.adapter = ParticipantAdapter(meeting!!)
  }

```

</TabItem>

<TabItem value="Java">

```js title="MainActivity.java"
  import live.videosdk.rtc.android.VideoView;
  import org.webrtc.VideoTrack;

  private void displayLocalParticipant() {
    final VideoView localView = findViewById(R.id.localView);

    // display local video when stream available
    meeting.getLocalParticipant().addEventListener(
        new ParticipantEventListener() {
          @Override
          public void onStreamEnabled(Stream stream) {
            if (stream.getKind().equalsIgnoreCase("video")) {
              VideoTrack track = (VideoTrack) stream.getTrack();
              localView.addTrack(track);
            }
          }
        }
      );
  }

  private void displayRemoteParticipants() {
    final RecyclerView rvParticipants = findViewById(R.id.rvParticipants);
    rvParticipants.setLayoutManager(new GridLayoutManager(this, 2));
    rvParticipants.setAdapter(new ParticipantAdapter(meeting));
  }

```

</TabItem>

</Tabs>

```xml title="item_remote_peer.xml"
<?xml version="1.0" encoding="utf-8"?>
<FrameLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="wrap_content">

    <live.videosdk.rtc.android.VideoView
        android:id="@+id/participantView"
        android:layout_width="match_parent"
        android:layout_height="match_parent" />

</FrameLayout>
```

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js title="ParticipantAdapter.kt"

class ParticipantAdapter(meeting: Meeting) : RecyclerView.Adapter<ParticipantAdapter.PeerViewHolder>() {
    private val participants: MutableList<Participant> = ArrayList()
    private var containerHeight = 0

    init {
        participants.add(meeting.localParticipant)
        meeting.addEventListener(object : MeetingEventListener() {
            override fun onParticipantJoined(participant: Participant) {
                participants.add(participant)
                notifyItemInserted(participants.size - 1)
            }

            override fun onParticipantLeft(participant: Participant) {
                // remove participant from grid
            }
        })
    }

    override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): PeerViewHolder {
        containerHeight = parent.height
        return PeerViewHolder(
            LayoutInflater.from(parent.context)
                .inflate(R.layout.item_remote_peer, parent, false)
        )
    }

    override fun onBindViewHolder(holder: PeerViewHolder, position: Int) {
        val participant = participants[position]

        val layoutParams = holder.itemView.layoutParams
        layoutParams.height = containerHeight / 3
        holder.itemView.layoutParams = layoutParams

        for ((_, stream) in participant.streams) {
            if (stream.kind.equals("video", ignoreCase = true)) {
                val videoTrack = stream.track as VideoTrack
                holder.participantView.addTrack(videoTrack)
                break
            }
        }

        participant.addEventListener(object : ParticipantEventListener() {
            override fun onStreamEnabled(stream: Stream) {
                if (stream.kind.equals("video", ignoreCase = true)) {
                    val videoTrack = stream.track as VideoTrack
                    holder.participantView.addTrack(videoTrack)
                }
            }
        })
    }

    override fun getItemCount(): Int {
        return participants.size
    }

    class PeerViewHolder(view: View) : RecyclerView.ViewHolder(view) {
        var participantView: VideoView = view.findViewById(R.id.participantView)
    }
}

```

Please refer the [example code](https://github.com/videosdk-live/videosdk-rtc-android-kotlin-sdk-example) on Github for more details.

</TabItem>

<TabItem value="Java">

```js title="ParticipantAdapter.java"

public class ParticipantAdapter extends RecyclerView.Adapter<ParticipantAdapter.PeerViewHolder> {

    private final List<Participant> participants = new ArrayList<>();
    private int containerHeight;

    public ParticipantAdapter(Meeting meeting) {
        Handler mHandler = new Handler(Looper.getMainLooper());

        meeting.addEventListener(new MeetingEventListener() {
            @Override
            public void onParticipantJoined(Participant participant) {
                participants.add(participant);
                mHandler.post(() -> notifyItemInserted(participants.size() - 1));
            }

            @Override
            public void onParticipantLeft(Participant participant) {
                // remove participant from grid
            }
        });
    }

    @NonNull
    @Override
    public PeerViewHolder onCreateViewHolder(@NonNull ViewGroup parent, int viewType) {
        containerHeight = parent.getHeight();

        return new PeerViewHolder(LayoutInflater.from(parent.getContext())
                .inflate(R.layout.item_remote_peer, parent, false));
    }

    @Override
    public void onBindViewHolder(@NonNull PeerViewHolder holder, int position) {
        final Participant participant = participants.get(position);

        ViewGroup.LayoutParams layoutParams = holder.itemView.getLayoutParams();
        layoutParams.height = containerHeight / 3;
        holder.itemView.setLayoutParams(layoutParams);

        for (Map.Entry<String, Stream> entry : participant.getStreams().entrySet()) {
            Stream stream = entry.getValue();
            if (stream.getKind().equalsIgnoreCase("video")) {
                VideoTrack videoTrack = (VideoTrack) stream.getTrack();
                holder.participantView.addTrack(videoTrack);
                break;
            }
        }

        participant.addEventListener(new ParticipantEventListener() {
            @Override
            public void onStreamEnabled(Stream stream) {
                if (stream.getKind().equalsIgnoreCase("video")) {
                    VideoTrack videoTrack = (VideoTrack) stream.getTrack();
                    holder.participantView.addTrack(videoTrack);
                }
            }
        });

    }

    @Override
    public int getItemCount() {
        return participants.size();
    }

    static class PeerViewHolder extends RecyclerView.ViewHolder {
        public VideoView participantView;
        public View itemView;

        PeerViewHolder(@NonNull View view) {
            super(view);

            itemView = view;

            participantView = view.findViewById(R.id.participantView);
        }
    }
}
```

Please refer the [example code](https://github.com/videosdk-live/videosdk-rtc-android-java-sdk-example/blob/master/app/src/main/java/live/videosdk/rtc/android/java) on Github for more details.

</TabItem>

</Tabs>

## 3. Participant Related Events

1. **onParticipantJoined** - Whenever any new participant join the meeting, `onParticipantJoined` event will trigger. For example, the meeting is running with **Alice** and **Bob**, then **Eve** join that meeting, after that `onParticipantJoined` event trigger and return the [participant object](/android/guide/video-and-audio-calling-api-sdk/features/manage-participants#participant-object-properties).

2. **onParticipantLeft** - Whenever any participant leave/exit the meeting, `onParticipantLeft` event will trigger.For example, the meeting is running with **Alice** and **Bob**, then **Bob** leave that meeting, after that `onParticipantLeft` event trigger and return the [participant object](/android/guide/video-and-audio-calling-api-sdk/features/manage-participants#participant-object-properties)

3. **onPresenterChanged** - Whenever any participant present/screenshare their screen/window in meeting, `onPresenterChanged` event will trigger and return the presenter `participantId`.

4. **onStreamEnabled** - Whenever any participant enabled mic/webcam in meeting, `onStreamEnabled` event will trigger and return [Stream](/android/guide/video-and-audio-calling-api-sdk/features/manage-participants#stream-object-properties).

5. **onStreamDisabled** - Whenever any participant disabled mic/webcam in meeting, `onStreamDisabled` event will trigger and return [Stream](/android/guide/video-and-audio-calling-api-sdk/features/manage-participants#stream-object-properties).

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
 meeting.addEventListener(object : MeetingEventListener() {
    override fun onParticipantJoined(participant: Participant) {
        participant.addEventListener(object : ParticipantEventListener() {
                override fun onStreamEnabled(stream: Stream) {
                    if (stream.kind.equals("video", ignoreCase = true)) {
                         // participant video enabled
                    } else if (stream.kind.equals("audio", ignoreCase = true)) {
                         // participant mic enabled
                    }
                }
                override fun onStreamDisabled(stream: Stream) {
                    if (stream.kind.equals("video", ignoreCase = true)) {
                         // participant video disabled
                    } else if (stream.kind.equals("audio", ignoreCase = true)) {
                        // participant mic disabled
                    }
                }
        })
    }

    override fun onParticipantLeft(participant: Participant) {
        Toast.makeText(this@MainActivity, participant.displayName + " left", Toast.LENGTH_SHORT).show()
    }

    override fun onPresenterChanged(presenterId: String) {
        Toast.makeText(this@MainActivity, presenterId + " started presenting", Toast.LENGTH_SHORT).show()
    }
 })
```

</TabItem>

<TabItem value="Java">

```js
 meeting.addEventListener(new MeetingEventListener() {
    @Override
    public void onParticipantJoined(Participant participant) {
      participant.addEventListener(new ParticipantEventListener() {
          @Override
          public void onStreamEnabled(Stream stream) {
              if (stream.getKind().equalsIgnoreCase("video")) {
                  // participant video enabled
              } else if (stream.getKind().equalsIgnoreCase("audio")) {
                  // participant mic enabled
              }
          }

          @Override
          public void onStreamDisabled(Stream stream) {
              if (stream.getKind().equalsIgnoreCase("video")) {
                  // participant video disabled
              } else if (stream.getKind().equalsIgnoreCase("audio")) {
                  // participant mic disabled
              }
          }
      });
    }

    @Override
    public void onParticipantLeft(Participant participant) {
      Toast
        .makeText(
          MainActivity.this,
          participant.getDisplayName() + " left",
          Toast.LENGTH_SHORT
        )
        .show();
    }
    @Override
    public void onPresenterChanged(String presenterId) {
      Toast
        .makeText(
          MainActivity.this,
          presenterId + " started presenting",
          Toast.LENGTH_SHORT
        )
        .show();
    }
 });
```

</TabItem>

</Tabs>


---

---
title: Mic Controls Video & Audio Call - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: Mic Controls features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Mic Controls
pagination_label: Mic Controls
keywords:
  - Mic on
  - Mic off
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: mic-controls
---

import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>

# Mic Controls - Android

Whenever any participant wants to start / stop broadcasting their audio to other participant in meeting, they can simply do it with VideoSDK Meeting.

This guide will provide an overview of how to use enable and disable Mic in a meeting.

1. **Enable Mic** - By using `unmuteMic()` function, a participant can publish audio to other participants.
2. **Disable Mic** - By using `muteMic()` function, a participant can stop publishing audio to other participants.

### 1. Enable, Disable Mic

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
  private var micEnabled = false

  btnMic!!.setOnClickListener { _: View? ->
    // Toggle participant mic in meeting
     if (micEnabled) {
       meeting!!.muteMic()
       micEnabled=false
     } else {
      meeting!!.unmuteMic()
      micEnabled=true
     }
  }
```

</TabItem>

<TabItem value="Java">

```js
  private boolean micEnabled = false;

  btnMic.setOnClickListener(new View.OnClickListener() {
      @Override
      public void onClick(View v) {
          // Toggle participant mic in meeting
          if (micEnabled) {
              meeting.muteMic();
              micEnabled = false;
          } else {
              meeting.unmuteMic();
              micEnabled = true;
          }
      }
  });
```

</TabItem>

</Tabs>

### Events

**Event associated with `unmuteMic()`:**

- Every Participant will receive a callback on [`onStreamEnabled()`](../../../api/sdk-reference/participant-class/participant-event-listener-class.md#onstreamenabled) of the [`Participant`](../../../api/sdk-reference/participant-class//introduction.md) with `Stream` object.

**Event associated with `muteMic()`:**

- Every Participant will receive a callback on [`onStreamDisabled()`](../../../api/sdk-reference/participant-class/participant-event-listener-class.md#onstreamenabled) of the [`Participant`](../../../api/sdk-reference/participant-class//introduction.md) with `Stream` object.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
  meeting!!.localParticipant.addEventListener(object : ParticipantEventListener() {
    override fun onStreamEnabled(stream: Stream) {
        //
        if(stream.getKind().equals("audio")){
          //participant turned on audio
        }
    }

    override fun onStreamDisabled(stream: Stream) {
        //
        if(stream.getKind().equals("audio")){
          //participant turned off audio
        }
    }
  });
```

</TabItem>

<TabItem value="Java">

```js
  participant.addEventListener(new ParticipantEventListener() {
    @Override
    public void onStreamEnabled(Stream stream) {
        //
        if(stream.getKind().equals("audio")){
          //participant turned on audio
        }
    }

    @Override
    public void onStreamDisabled(Stream stream) {
        //
        if(stream.getKind().equals("audio")){
          //participant turned off audio
        }
    }
  });
```

</TabItem>

</Tabs>

### 2. Change Audio Device

#### Get all audio Devices

- By using `meeting.getMics()` function, a participant can get all the connected mics.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
  private fun getMics(): MutableSet<AppRTCAudioManager.AudioDevice>? {
    val mics= meeting!!.mics
    return mics  // returns all mics
  }
```

</TabItem>

<TabItem value="Java">

```js
  private Set<AppRTCAudioManager.AudioDevice> getMics() {
    Set<AppRTCAudioManager.AudioDevice> mics = meeting.getMics();
    return mics; // returns all mics
  }
```

</TabItem>

</Tabs>

#### Select audio Device

- Local participant can change the audio device using `changeMic(AppRTCAudioManager.AudioDevice device)` method of meeting class.

- Parameters that can be passed to `changeMic` are

  | Audio Devices                                | Usage                        |
  | -------------------------------------------- | ---------------------------- |
  | AppRTCAudioManager.AudioDevice.BLUETOOTH     | For Bluetooth Device.        |
  | AppRTCAudioManager.AudioDevice.WIRED_HEADSET | For Wired Handset Device.    |
  | AppRTCAudioManager.AudioDevice.SPEAKER_PHONE | For Inbuilt - Speaker Device |
  | AppRTCAudioManager.AudioDevice.EARPIECE      | For Earpiece Device          |

- When a Local participant changes the Mic, `AppRTCAudioManager.AudioManagerEvents()` is triggered which can be set to `Meeting` class by using `meeting.setAudioDeviceChangeListener()`

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js

  btnChangeMic!!.setOnClickListener { _: View? ->
  // Change Mic in Meeting
    meeting!!.changeMic(AppRTCAudioManager.AudioDevice.BLUETOOTH)
  }

  private fun setAudioDeviceListeners() {
    meeting!!.setAudioDeviceChangeListener(object : AudioManagerEvents {
      override fun onAudioDeviceChanged(
        selectedAudioDevice: AppRTCAudioManager.AudioDevice,
        availableAudioDevices: Set<AppRTCAudioManager.AudioDevice>
      ) {
          when (selectedAudioDevice) {
            AppRTCAudioManager.AudioDevice.BLUETOOTH ->
              Toast.makeText(this@MainActivity, "Selected AudioDevice: BLUETOOTH", Toast.LENGTH_SHORT).show()

            AppRTCAudioManager.AudioDevice.WIRED_HEADSET ->
              Toast.makeText(this@MainActivity, "Selected AudioDevice: WIRED_HEADSET", Toast.LENGTH_SHORT).show()

            AppRTCAudioManager.AudioDevice.SPEAKER_PHONE ->
              Toast.makeText(this@MainActivity, "Selected AudioDevice: SPEAKER_PHONE", Toast.LENGTH_SHORT).show()

            AppRTCAudioManager.AudioDevice.EARPIECE ->
              Toast.makeText(this@MainActivity, "Selected AudioDevice: EARPIECE", Toast.LENGTH_SHORT).show()
          }
        }
    })
  }

  override fun onCreate(savedInstanceState: Bundle?) {
       // ...
       setAudioDeviceListeners()
  }
```

</TabItem>

<TabItem value="Java">

```js

  btnChangeMic.setOnClickListener(new View.OnClickListener() {
      @Override
      public void onClick(View v) {
        // Change Mic in Meeting
        meeting.changeMic(AppRTCAudioManager.AudioDevice.BLUETOOTH);
      }
  });

  private void setAudioDeviceListeners() {
    meeting.setAudioDeviceChangeListener(new AppRTCAudioManager.AudioManagerEvents() {
         @Override
        public void onAudioDeviceChanged(AppRTCAudioManager.AudioDevice selectedAudioDevice, Set<AppRTCAudioManager.AudioDevice> availableAudioDevices) {
            switch (selectedAudioDevice) {
                case BLUETOOTH:
                  Toast.makeText(MainActivity.this, "Selected AudioDevice: BLUETOOTH", Toast.LENGTH_SHORT).show();
                  break;
                case WIRED_HEADSET:
                  Toast.makeText(MainActivity.this, "Selected AudioDevice: WIRED_HEADSET", Toast.LENGTH_SHORT).show();
                  break;
                case SPEAKER_PHONE:
                  Toast.makeText(MainActivity.this, "Selected AudioDevice: SPEAKER_PHONE", Toast.LENGTH_SHORT).show();
                  break;
                case EARPIECE:
                  Toast.makeText(MainActivity.this, "Selected AudioDevice: EARPIECE", Toast.LENGTH_SHORT).show();
                  break;
               }
        }
    });
  }

  @Override
    protected void onCreate(Bundle savedInstanceState) {
       // ...
       setAudioDeviceListeners();
    }
```

</TabItem>

</Tabs>

- To use Bluetooth device, you must declare `BLUETOOTH` permission in `AndroidManifest.xml` file.

```js
<manifest ... >

<!-- Needed to communicate with already-paired Bluetooth devices. (Legacy up to Android 11) -->
<uses-permission android:name="android.permission.BLUETOOTH" />
<uses-permission android:name="android.permission.BLUETOOTH_ADMIN" />
<uses-permission android:name="android.permission.BLUETOOTH_CONNECT" />
//...
</manifest>
```


---

---
title: Pause/Resume Video Stream - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: Pause/Resume Video Stream features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Pause/Resume Video Stream
pagination_label: Pause/Resume Video Stream
keywords:
  - pause/resume video stream
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: pause-resume-video-stream
---

import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>

# Pause/Resume Video Stream - Android

Whenver you wish to stop/resume downlaod stream(webcam, screenShare and mic) of participant, you can simply do it by using `pause`, `resume` methods.

## Pause video stream

- `pause()` method is used for pause stream(webcam, screenShare and mic) of a particular participant.

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
  btnPause!!.setOnClickListener { _: View? ->
    for ((_, stream) in participant.streams) {
      stream.pause()
    }
  }
```

</TabItem>

<TabItem value="Java">

```js
  btnPause.setOnClickListener(new View.OnClickListener() {
      @Override
      public void onClick(View v) {
        for (Map.Entry<String, Stream> entry : participant.getStreams().entrySet()) {
                Stream stream = entry.getValue();
                stream.pause();
        }
      }
  });
```

</TabItem>

</Tabs>

## Resume video stream

- `resume()` method is used to resume stream(webcam, screenShare and mic) of a particular participant.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
  btnResume!!.setOnClickListener { _: View? ->
    for ((_, stream) in participant.streams) {
      stream.resume()
    }
  }
```

</TabItem>

<TabItem value="Java">

```js
  btnResume.setOnClickListener(new View.OnClickListener() {
      @Override
      public void onClick(View v) {
        for (Map.Entry<String, Stream> entry : participant.getStreams().entrySet()) {
            Stream stream = entry.getValue();
            stream.resume();
        }
      }
  });
```

</TabItem>

</Tabs>


---

---
title: Pin Participants Video & Audio Call - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: Pin Participant features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Pin Participants
pagination_label: Pin Participants
keywords:
  - pin
  - unpin
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: pin-participants
---

import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>

# Pin Participants - Android

In any meeting with large number of participants, if you want to show only one or two participant(s) on main screen then you can pin that perticipants so that viewers can only focus upon that participants only.

This guide will provide an overview of how to pin or unpin any participants in a meeting.

:::note
`pin()` and `unpin()` functions will take `string` or `null` as an argument. Pin will be effective for both webcam and screenshare of that participant.

Suppose you want to pin or unpin only webcam of that participant then you can pass `CAM`, else if you want to pin or unpin only screenshare of that participant then you can pass `SHARE`.

You can also pass `SHARE_AND_CAM` if you want to `pin` or `unpin` both webcam and screenshare media of that user, or passing `null` or nothing as an argument will also work in the same way.

If any participant's webcam is pinned but not screenshare, then calling `pin("SHARE")` the new pinState of that participant will be `{ cam: true, share: true }`.  
:::

### Pin And Unpin a Participant

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
  // Pin both webcam and screenshare of that participant
  meeting!!.participants[participantId].pin("SHARE_AND_CAM")

  // Pin webcam of that participant
  meeting!!.participants[participantId].pin("CAM")

  // Pin screenshare of that participant
  meeting!!.participants[participantId].pin("SHARE")

  //
  // Unpin both webcam and screenshare of that participant
  meeting!!.participants[participantId].unpin("SHARE_AND_CAM");

  // Unpin webcam of that participant
  meeting!!.participants[participantId].unpin("CAM");

  // Unpin screenshare of that participant
  meeting!!.participants[participantId].unpin("SHARE");
```

</TabItem>

<TabItem value="Java">

```js
// Pin both webcam and screenshare of that participant
meeting.getParticipants().get(participantId).pin("SHARE_AND_CAM");

// Pin webcam of that participant
meeting.getParticipants().get(participantId).pin("CAM");

// Pin screenshare of that participant
meeting.getParticipants().get(participantId).pin("SHARE");

//
// Unpin both webcam and screenshare of that participant
meeting.getParticipants().get(participantId).unpin(null);

// Unpin webcam of that participant
meeting.getParticipants().get(participantId).unpin("CAM");

// Unpin screenshare of that participant
meeting.getParticipants().get(participantId).unpin("SHARE");
```

</TabItem>

</Tabs>

### onPinStateChanged Event

Whenever any participant got pinned or unpinned by any participant, `onPinStateChanged` event will be triggered.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
 override fun onPinStateChanged(pinStateData: JSONObject?) {
   Log.d("onPinStateChanged: ", pinStateData.getString("peerId")) // id of participant who were pinned
   Log.d("onPinStateChanged: ", pinStateData.getJSONObject("state")) // { cam: true, share: true }
   Log.d("onPinStateChanged: ", pinStateData.getString("pinnedBy")) // id of participant who pinned that participant
  }
```

</TabItem>

<TabItem value="Java">

```javascript
@Override
  public void onPinStateChanged(JSONObject pinStateData) {
    Log.d("onPinStateChanged: ", pinStateData.getString("peerId")); // id of participant who were pinned
    Log.d("onPinStateChanged: ", pinStateData.getJSONObject("state")); // { cam: true, share: true }
    Log.d("onPinStateChanged: ", pinStateData.getString("pinnedBy")); // id of participant who pinned that participant
  }

```

</TabItem>

</Tabs>


---

---
sidebar_label: Send Message using PubSub
pagination_label: PubSub
---

import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>

# PubSub - Android

PubSub feature allows the participant to send and receive messages of the topics which he has subscribed.

## Methods

### publish()

This method is use for publishing message of specific topic.

#### Syntax

```js
public void publish(String topic, String message, PubSubPublishOptions options)
```

| Parameter Name | Type                 | Description                                                                                                                                       |
| -------------- | -------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------- |
| topic          | String               | This should be the topic for which you are publishing a message.                                                                                  |
| message        | String               | This is the actual message, which will be published to participants, who had subscribed to a particular topic.                                    |
| options        | PubSubPublishOptions | This is an object of PubSubPublishOptions, which provides an option, such as `persist`, which persists message history for upcoming participants. |

#### Example

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
private fun sendMessage() {
  val options = PubSubPublishOptions()
  options.isPersist = true
  meeting!!.pubSub.publish("CHAT", "Hello from Android", options)
}
```

</TabItem>

<TabItem value="Java">

```js
protected void sendMessage() {
  PubSubPublishOptions options = new PubSubPublishOptions();
  options.setPersist(true);
  meeting.pubSub.publish("CHAT", "Hello from Android", options);
}
```

</TabItem>

</Tabs>

### subscribe()

This method is used to subscribe for particular topic. This method returns a list of messages which were sent earlier.

#### Syntax

```js
public List<PubSubMessage> subscribe(String topic, PubSubMessageListener listener)
```

| Parameter Name | Type                  | Description                                                                                                                                      |
| -------------- | --------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------ |
| topic          | String                | This should be the topic to be subscribed.                                                                                                       |
| listener       | PubSubMessageListener | This is an object of PubSubMessageListener, which listens for upcoming messages and calls onMessageReceived function, when new message received. |

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
var pubSubMessageListener =
  PubSubMessageListener { message ->
    // Logs new message
    Log.v("New Message Received", "Message : " + message.message)
  }

@Override
protected void onCreate(Bundle savedInstanceState) {
  //...

  // Subscribe for 'CHAT' topic
  val pubSubMessageList = meeting!!.pubSub.subscribe("CHAT", pubSubMessageListener)

  // Logs persisted message list
  for (message in pubSubMessageList) {
    Log.v("Message List: ", "Message : " + message.message)
  }
}
```

</TabItem>

<TabItem value="Java">

```js
PubSubMessageListener pubSubMessageListener = new PubSubMessageListener() {
  @Override
  public void onMessageReceived(PubSubMessage message) {
    // Logs new message
    Log.v("New Message Received", "Message : " + message.getMessage());
  }
};

@Override
protected void onCreate(Bundle savedInstanceState) {
  //...

  // Subscribe for 'CHAT' topic
  List<PubSubMessage> pubSubMessageList = meeting.pubSub.subscribe("CHAT",pubSubMessageListener);

  // Logs persisted message list
  for(PubSubMessage message : pubSubMessageList){
    Log.v("Message List: ", "Message : " + message.getMessage());
  }
}
```

</TabItem>

</Tabs>

### unsubscribe()

This method is used to unsubscribe the message topic.

#### Syntax

```js
public void unsubscribe(String topic, PubSubMessageListener listener)
```

| Parameter Name | Type                  | Description                                                                    |
| -------------- | --------------------- | ------------------------------------------------------------------------------ |
| topic          | String                | This should be the topic to be unsubscribed.                                   |
| listener       | PubSubMessageListener | This is an object of PubSubMessageListener, which was passed in `subscribe()`. |

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
fun unsubscribe() {
  // Unsubscribe 'CHAT' topic
  meeting!!.pubSub.unsubscribe("CHAT", pubSubMessageListener)
}
```

</TabItem>

<TabItem value="Java">

```js
public void unsubscribe(){
  // Unsubscribe 'CHAT' topic
  meeting.pubSub.unsubscribe("CHAT", pubSubMessageListener);
}
```

</TabItem>

</Tabs>

## Sample Code

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
package live.videosdk.rtc.android.kotlin

import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle
import android.view.View
import android.widget.EditText
import android.widget.Toast
import androidx.appcompat.widget.Toolbar
import androidx.recyclerview.widget.LinearLayoutManager
import androidx.recyclerview.widget.RecyclerView
import live.videosdk.rtc.android.Meeting
import live.videosdk.rtc.android.listeners.PubSubMessageListener
import live.videosdk.rtc.android.model.PubSubPublishOptions

class ChatActivity : AppCompatActivity() {

    // Meeting
    var meeting: Meeting? = null

    // PubSubMessageListener
    var pubSubMessageListener =
      PubSubMessageListener { message ->
        // Logs new message
        Log.v("New Message Received", "Message : " + message.message)
    }

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_chat)

        /**
         * Here, we have created 'MainApplication' class, which extends android.app.Application class.
         * It has Meeting property and getter and setter methods of Meeting property.
         * In your android manifest, you must declare the class implementing android.app.Application (add the android:name=".MainApplication" attribute to the existing application tag):
         * In MainActivity.kt, we have set Meeting property.
         *
         * For Example: (MainActivity.kt)
         * var meeting = VideoSDK.initMeeting(context, meetingId, ParticipantName, micEnabled, webcamEnabled, paricipantId, mode, customTrack, metaData,signalingBaseUrl,preferredProtocol)
         * (this.application as MainApplication).meeting = meeting
        */

        // Get Meeting
        meeting = (this.application as MainApplication).meeting

        // Subscribe for 'CHAT' topic
        val pubSubMessageList = meeting!!.pubSub.subscribe("CHAT", pubSubMessageListener)

        for (message in pubSubMessageList) {
          // Logs persisted messages
           Log.v("Message List: ", "Message : " + message.message)
        }

        sendMessage()
    }

    private fun sendMessage() {
      val options = PubSubPublishOptions()
      options.isPersist = true
      meeting!!.pubSub.publish("CHAT", "Hello from Android", options)
    }

    override fun onDestroy() {
      // Unsubscribe for 'CHAT' topic
      meeting!!.pubSub.unsubscribe("CHAT", pubSubMessageListener)
      super.onDestroy()
    }
}
```

</TabItem>

<TabItem value="Java">

```js
package live.videosdk.rtc.android.java;

import androidx.appcompat.app.AppCompatActivity;
import android.os.Bundle;
import android.util.Log;
import java.util.List;
import live.videosdk.rtc.android.Meeting;
import live.videosdk.rtc.android.lib.PubSubMessage;
import live.videosdk.rtc.android.listeners.PubSubMessageListener;
import live.videosdk.rtc.android.model.PubSubPublishOptions;

public class ChatActivity extends AppCompatActivity {

    // Meeting
    Meeting meeting;

    // PubSubMessageListener
    private PubSubMessageListener pubSubMessageListener = new PubSubMessageListener() {
      @Override
      public void onMessageReceived(PubSubMessage message) {
          // Logs new message
          Log.v("New Message Received : ", "Message : " + message.getMessage());
      }
    };

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_chat);

        /**
         * Here, we have created 'MainApplication' class, which extends android.app.Application class.
         * It has Meeting property and getter and setter methods of Meeting property.
         * In your android manifest, you must declare the class implementing android.app.Application (add the android:name=".MainApplication" attribute to the existing application tag):
         * In MainActivity.java, we have set Meeting property.
         *
         * For Example: (MainActivity.java)
         * Meeting meeting = VideoSDK.initMeeting(context, meetingId, ParticipantName, micEnabled, webcamEnabled, participantId, mode, customTrack, metaData, signalingBaseUrl,preferredProtocol);
         * ((MainApplication) this.getApplication()).setMeeting(meeting);
        */

        // Get Meeting
        meeting = ((MainApplication) this.getApplication()).getMeeting();

        // Subscribe for 'CHAT' topic
        List<PubSubMessage> pubSubMessageList = meeting.pubSub.subscribe("CHAT", pubSubMessageListener);
        for(PubSubMessage message : pubSubMessageList){
            // Logs persisted messages
            Log.v("Message List : ", "Message : " + message.getMessage());
        }

        sendMessage();
    }

    protected void sendMessage() {
      PubSubPublishOptions publishOptions = new PubSubPublishOptions();
      publishOptions.setPersist(true);
      meeting.pubSub.publish("CHAT", "Hello from Android", publishOptions);
    }

    @Override
    protected void onDestroy() {
      // Unsubscribe for 'CHAT' topic
      meeting.pubSub.unsubscribe("CHAT", pubSubMessageListener);
      super.onDestroy();
    }
}
```

</TabItem>

</Tabs>


---

---
title: Record Meeting Video & Audio Call - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: Record Meeting features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Record Meeting
pagination_label: Record Meeting
keywords:
  - Start Recording meeting
  - Stop Recording meeting
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: recording-meeting
---

import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>

# Record Meeting - Android

Record meeting allows participants to record video & audio during the meeting. The recording files are available in developer dashboard.
Any participant can start / stop recording any time during the meeting.

This guide will provide an overview of how to implement start and stop Meeting Recording.

1. **Start Recording** - By using `startRecording()` function, a participant can start meeting recording.
2. **Stop Recording** - By using `stopRecording()` function, a participant can stop meeting recording.

### Start And Stop Recording

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
// TODO: change webhookUrl
val webhookUrl = "<webhook-url-here>"

// keep track of recording
val recording = false

findViewById<View>(R.id.btnRecording).setOnClickListener { view: View? ->
    if (!recording) {
        meeting!!.startRecording(webhookUrl)
    } else {
        meeting!!.stopRecording()
    }
}
```

</TabItem>

<TabItem value="Java">

```js
// TODO: change webhookUrl
String webhookUrl = "<webhook-url-here>";

// keep track of recording
boolean recording = false;

findViewById(R.id.btnRecording).setOnClickListener(view -> {
    if (!recording) {
        meeting.startRecording(webhookUrl);
    } else {
        meeting.stopRecording();
    }
});
```

</TabItem>

</Tabs>

### Events

- **onRecordingStateChanged** - A `onRecordingStateChanged` event will be triggered any time the recording state of a meeting changes.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
object : MeetingEventListener() {
  override fun onRecordingStateChanged(recordingState: String) {
    when (recordingState) {
        "RECORDING_STARTING" -> {
            Log.d("onRecordingStateChanged", "Meeting recording is starting")
        }
        "RECORDING_STARTED" -> {
            Log.d("onRecordingStateChanged", "Meeting recording is started")
        }
        "RECORDING_STOPPING" -> {
            Log.d("onRecordingStateChanged", "Meeting recording is stopping")
        }
        "RECORDING_STOPPED" -> {
            Log.d("onRecordingStateChanged", "Meeting recording is stopped")
        }
    }
  }
}
```

</TabItem>

<TabItem value="Java">

```js
new MeetingEventListener() {
  @Override
  public void onRecordingStateChanged(String recordingState) {
      switch (recordingState) {
          case "RECORDING_STARTING":
              Log.d("onRecordingStateChanged", "Meeting recording is starting");
              break;
          case "RECORDING_STARTED":
              Log.d("onRecordingStateChanged", "Meeting recording is started");
              break;
          case "RECORDING_STOPPING":
              Log.d("onRecordingStateChanged", "Meeting recording is stopping");
              break;
          case "RECORDING_STOPPED":
              Log.d("onRecordingStateChanged", "Meeting recording is stopped");
              break;
      }
  }
}
```

</TabItem>

</Tabs>


---

---
title: Remove participant from the meeting - Android SDK
hide_title: false
hide_table_of_contents: false
description: Remove a participant or a peer from the meeting while it is still in progress. It helps in meeting moderation.
sidebar_label: Remove Participant
pagination_label: Remove Participant
keywords:
  - remove participant
  - block participant
  - android
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: remove-participant
---

import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>

# Remove Participant - Android

Remove participant allows removing participant while session is on-going. This can be helpful when moderation in particular meeting is required.

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
val participant = meeting!!.participants.get("<participant-id>")

// This will emit an event called "onParticipantLeft" to that particular participant
participant.remove()
```

</TabItem>

<TabItem value="Java">

```js
Participant participant = meeting.getParticipants().get("<participant-id>");

// Remove participant from active session
// This will emit an event called "onParticipantLeft" to that particular participant
participant.remove();
```

</TabItem>

</Tabs>

### Events

**onParticipantLeft** - Removing participant will trigger `onParticipantLeft` event.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
private final MeetingEventListener meetingEventListener = new MeetingEventListener() {

  override fun onParticipantLeft(participant: Participant) {
    // Triggers when a participant is removed or leaves the meeting.
    Log.d("#meeting", participant.displayName + " left");
  }
}
```

</TabItem>

<TabItem value="Java">

```javascript
private final MeetingEventListener meetingEventListener = new MeetingEventListener() {
  @Override
  public void onParticipantLeft(Participant participant) {
    // Triggers when a participant is removed or leaves the meeting.
    Log.d("#meeting", participant.getDisplayName() + " left");
  }
}
```

</TabItem>

</Tabs>


---

---
title: Share your Screen Video & Audio Call - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: Share your Screen features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Share Your Screen
pagination_label: Share Your Screen
keywords:
  - Start Screen share
  - Stop Screen share
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: screenshare
---

import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>

# Share Your Screen - Android

- Whenever any participant wants to share a complete screen of mobile, they can simply do it with VideoSDK Meeting.

- This guide will provide an overview of how to enable or disable Screen Share in a meeting.

## How Screen share works?

- The following diagram shows flow of the screen sharing in android using VideoSDK:

<div style={{textAlign: 'center'}}>

![VideoSDK Android Screenshare Flow Diagram](/img/android/screenshare/flow_diagram.png)

</div>

## Enable Screen Share

- A participant’s Screen share stream is provided via the `MediaProjection` API. This API is only compatible with `Build.VERSION_CODES.LOLLIPOP` or higher.

- Get an instance of the `MediaProjectionManager` and Call the `createScreenCaptureIntent()` method in an activity. This initiates a prompt dialog for the user to confirm screen projection.

- One will get a prompt dialog like this:

<div style={{textAlign: 'center'}}>

<img
src={require('/img/android/screenshare/user_permission.jpg').default}
alt="user permission"
width="450"
/>

</div>

<br/>

- After permission is received from the user, call `meeting.enableScreenShare()` method.

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
private fun enableScreenShare() {
    val mediaProjectionManager = application.getSystemService(
        MEDIA_PROJECTION_SERVICE
    ) as MediaProjectionManager
    startActivityForResult(
        mediaProjectionManager.createScreenCaptureIntent(), CAPTURE_PERMISSION_REQUEST_CODE
    )
}

public override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) {
    super.onActivityResult(requestCode, resultCode, data)
    if (requestCode != CAPTURE_PERMISSION_REQUEST_CODE) return
    if (resultCode == RESULT_OK) {
        meeting!!.enableScreenShare(data)
    }
}
```

</TabItem>

<TabItem value="Java">

```js
private void enableScreenShare() {
    MediaProjectionManager mediaProjectionManager =
        (MediaProjectionManager) getApplication().getSystemService(
            Context.MEDIA_PROJECTION_SERVICE);
    startActivityForResult(
        mediaProjectionManager.createScreenCaptureIntent(), CAPTURE_PERMISSION_REQUEST_CODE);
}

@Override
public void onActivityResult(int requestCode, int resultCode, Intent data) {
    super.onActivityResult(requestCode, resultCode, data);
    if (requestCode != CAPTURE_PERMISSION_REQUEST_CODE)
        return;
    if (resultCode == Activity.RESULT_OK) {
        meeting.enableScreenShare(data);
    }
}
```

</TabItem>

</Tabs>

### Customise notification

- When a presenter starts screen share, presenter will receive a notification with a pre-defined title and message.

- Notification with pre-defined title and message will look like this:

<div style={{textAlign: 'center'}}>

<img
src={require('/img/android/screenshare/notification.jpg').default}
alt="notification"
width="450"
/>

</div>

- You can Customise those title, message and icon as per your requirements using `<meta-data>` specified in `app/src/main/AndroidManifest.xml`.

```js
<application>
  <meta-data
    android:name="notificationTitle"
    android:value="@string/notificationTitle"
  />
  <meta-data
    android:name="notificationContent"
    android:value="@string/notificationContent"
  />
  <meta-data
    android:name="notificationIcon"
    android:resource="@mipmap/ic_launcher_round"
  />
</application>
```

## Disable Screen Share

By using `meeting.disableScreenShare()` function, a participant can stop publishing screen stream to other participants.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
private fun disableScreenShare() {
    meeting!!.disableScreenShare()
}
```

</TabItem>

<TabItem value="Java">

```js
private void disableScreenShare(){
    meeting.disableScreenShare();
}
```

</TabItem>

</Tabs>

## Display Screen Share Stream

#### Local Participant

When a Local participant share the screen, `onStreamEnabled()` of `ParticipantEventListener` is triggered with the `Stream` which can be added to a `VideoView`.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
private fun setLocalListeners() {
    meeting!!.localParticipant.addEventListener(object : ParticipantEventListener() {
        override fun onStreamEnabled(stream: Stream) {
           if (stream.kind.equals("share", ignoreCase = true)) {
                // display share video
                val videoTrack = stream.track as VideoTrack
                shareView!!.addTrack(videoTrack)
            }
        }
        override fun onStreamDisabled(stream: Stream) {
            if (stream.kind.equals("share", ignoreCase = true)) {
               shareView!!.removeTrack()
            }
        }
    });
}
```

</TabItem>

<TabItem value="Java">

```js
private void setLocalListeners() {
    meeting.getLocalParticipant().addEventListener(new ParticipantEventListener() {
        @Override
        public void onStreamEnabled(Stream stream) {
            if (stream.getKind().equalsIgnoreCase("share")) {
                // display share video
                VideoTrack videoTrack = (VideoTrack) stream.getTrack();
                shareView.addTrack(videoTrack);
            }
        }
        @Override
        public void onStreamDisabled(Stream stream) {
            if (stream.getKind().equalsIgnoreCase("share")) {
                shareView.removeTrack();
            }
        }
    });
}
```

</TabItem>

</Tabs>

#### Other Participants

When other participant(Except you) share their screen, `onPresenterChanged()` in the `MeetingEventListener` is triggered with the `participantId` of the screen share.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
private val meetingEventListener: MeetingEventListener = object : MeetingEventListener() {
    override fun onPresenterChanged(participantId: String) {
        updatePresenter(participantId)
    }
}

//Getting the stream from the participantId
private fun updatePresenter(participantId: String?) {
    // find participant
    val participant = meeting!!.participants.get(participantId) ?: return

    // find share stream in participant
    var shareStream: Stream? = null
    for (stream: Stream in participant.streams.values) {
        if ((stream.kind == "share")) {
            shareStream = stream
            break
        }
    }
    if (shareStream == null) return

    // display share video
    val videoTrack = shareStream.track as VideoTrack
    shareView!!.addTrack(videoTrack)

    // listen for share stop event
    participant.addEventListener(object : ParticipantEventListener() {
        override fun onStreamDisabled(stream: Stream) {
            if ((stream.kind == "share")) {
                shareView!!.removeTrack()
            }
        }
    })
}
```

</TabItem>

<TabItem value="Java">

```js
private final MeetingEventListener meetingEventListener = new MeetingEventListener() {
    //Triggered when Presenter changes
    @Override
    public void onPresenterChanged(String participantId) {
        updatePresenter(participantId);
    }
};

//Getting the stream from the participantId
private void updatePresenter(String participantId) {
    // find participant
    Participant participant = meeting.getParticipants().get(participantId);
    if (participant == null) return;

    // find share stream in participant
    Stream shareStream = null;
    for (Stream stream: participant.getStreams().values()) {
        if (stream.getKind().equals("share")) {
            shareStream = stream;
            break;
        }
    }
    if (shareStream == null) return;

    // display share video
    VideoTrack videoTrack = (VideoTrack) shareStream.getTrack();
    shareView.addTrack(videoTrack)

    // listen for share stop event
    participant.addEventListener(new ParticipantEventListener() {
        @Override
        public void onStreamDisabled(Stream stream) {
            if (stream.getKind().equals("share")) {
                shareView.removeTrack();
            }
        }
    });
}
```

</TabItem>

</Tabs>

:::info

- Here screenShare stream is displayed using `VideoView`, but you may also use `SurfaceViewRender` for the same.
- For `VideoView`, SDK version should be `0.1.13` or higher.
- To know more about `VideoView`, please visit [here](/android/guide/video-and-audio-calling-api-sdk/components/videoView)

:::


---

---
title: Set Participant Video Quality - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: Set Participant Video Quality features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Set Participant Video Quality
pagination_label: Set Participant Video Quality
keywords:
  - set video quality
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: set-participant-video-quality
---

import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>

# Set Participant Video Quality - Android

This feature allows participants to set other participant's video quality during the meeting.

:::info

MultiStream is not supported by the Android SDK. Use `customTrack` instead of `setQuality()` if you want to change participant's quality who joined using our Android SDK.

To know more about customTrack visit [here](/android/guide/video-and-audio-calling-api-sdk/features/custom-track/custom-video-track)

:::

## Set Quality

- `setQuality` method will accept `low`, `med` or `high` as string parameter.

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
private fun setQuality()
{
  val participants: Iterator<Participant> = meeting!!.participants.values.iterator()
  for (i in 0 until meeting!!.participants.size) {
    val participant = participants.next()

    participant.quality = "low"
    //or
    participant.quality = "med"
    //or
    participant.quality = "high"
  }
}
```

</TabItem>

<TabItem value="Java">

```js
private void setQuality() {
  final Iterator<Participant> participants = meeting.getParticipants().values().iterator();

  for (int i = 0; i < meeting.getParticipants().size(); i++) {
    Participant participant = participants.next();

    participant.setQuality("low");
    //or
    participant.setQuality("med");
    //or
    participant.setQuality("high");
  }
}
```

</TabItem>

</Tabs>


---

---
title: Set Viewport
hide_title: false
hide_table_of_contents: false
sidebar_label: Set Viewport
pagination_label: Set Viewport
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: set-viewport
---

import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>

# Set Viewport - Android

When you are working with Video Calling, video quality is the most important part of communication. When a participant is shown on the screen, consuming multiple high quality although not required, will result in more memory and CPU usage of the device, eventually degrading quality.

The way to optimze around these situation is to consume the video quality which is required to fit the view of a particular participant, resulting in better quality, less usage of network bandwith and providing a better experience.

Viewport is the size of window or visible area in which video for the participant is shown. We can optimize the consuming video quality based on the viewport size of the participant. For example if the viewport size of a particular participant view is `480x360`, VideoSDK will download a `480x360` stream. If a participant on screen is present in bigger size, VideoSDK will provide a higher quality video for that particular participant only.

import ReactPlayer from 'react-player'

<div style={{textAlign: 'center'}}>

<ReactPlayer autoplay muted loop playing url='/img/viewport_illustration.mp4' width={"100%"}/>

</div>

<br/>

:::info

MultiStream is not supported by the Android SDK. Use `customTrack` instead of `setViewPort()` if you want to change participant's quality who joined using our Android SDK.

To know more about customTrack visit [here](/android/guide/video-and-audio-calling-api-sdk/features/custom-track/custom-video-track)

:::

### setViewPort()

`setViewPort()` can be used to achieve the best optimization of the video. This method is called with the `width` and `height` of the participant view on the `Participant` object and VideoSDK will handle the rest.

##### Parameters

- `width`

  - type: `int`
  - Width of the participant view for which the quliaty of video is to be adjusted.

- `height`
  - type: `int`
  - Height of the participant view for which the quliaty of video is to be adjusted.

### Example

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
class ParticipantAdapter(meeting: Meeting) : RecyclerView.Adapter<ParticipantAdapter.PeerViewHolder() {

  //Your variables here

  override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): PeerViewHolder {
    containerHeight = parent.height
    return PeerViewHolder(
      LayoutInflater.from(parent.context)
        .inflate(R.layout.item_remote_peer, parent, false)
    )
  }

  override fun onBindViewHolder(holder: PeerViewHolder, position: Int) {
    val participant = participants[position]

    //View updates here

    //Update Consuming quality using setViewPort
    participant.setViewPort(holder.itemView.getWidth(), holder.itemView.getHeight());
  }
}

```

</TabItem>

<TabItem value="Java">

```js

public class ParticipantAdapter extends RecyclerView.Adapter<ParticipantAdapter.PeerViewHolder> {

  //Your variables here

  @NonNull
  @Override
  public PeerViewHolder onCreateViewHolder(@NonNull ViewGroup parent, int viewType) {
    containerHeight = parent.getHeight();

    return new PeerViewHolder(LayoutInflater.from(parent.getContext())
            .inflate(R.layout.item_remote_peer, parent, false));
  }

  @Override
  public void onBindViewHolder(@NonNull PeerViewHolder holder, int position) {
    final Participant participant = participants.get(position);

    //View updates here

    //Update Consuming quality using setViewPort
    participant.setViewPort(holder.itemView.getWidth(), holder.itemView.getHeight());
  }
}

```

</TabItem>

</Tabs>

The complete usage of this method can be seen here in the [code sample](https://github.com/videosdk-live/videosdk-rtc-android-java-sdk-example/blob/master/app/src/main/java/live/videosdk/rtc/android/java/ParticipantAdapter.java#L134)


---

---
title: Speaker Indication Video & Audio Call - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: Speaker Indication features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Speaker Indication
pagination_label: Speaker Indication
keywords:
  - Active Speaker
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: speaker-indication
---

import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>

# Speaker Indication - Android

Speaker indication feature in VideoSDK let you know, which participant is active speaker in a meeting.

Whenever any participant speaks in meeting, `onSpeakerChanged` event will trigger.

For example, the meeting is running with **Alice** and **Bob**. Whenever any of them speaks, `onSpeakerChanged` event will trigger and return the speaker `participantId`.

We can access `onSpeakerChanged` event through [meeting object](../../../api/sdk-reference/meeting-class/introduction.md).

### onSpeakerChanged Event

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
private val meetingEventListener: MeetingEventListener = object : MeetingEventListener() {
     // ...
    override fun onSpeakerChanged(participantId: String?) {
        Toast.makeText(this@MainActivity, "active Speaker Id" + participantId, Toast.LENGTH_SHORT).show();
        super.onSpeakerChanged(participantId)
    }
};
```

</TabItem>

<TabItem value="Java">

```js
private final MeetingEventListener meetingEventListener = new MeetingEventListener() {
     // ...
    @Override
    public void onSpeakerChanged(String participantId) {
        Toast.makeText(MainActivity.this, "active Speaker Id" + participantId, Toast.LENGTH_SHORT).show();
        super.onSpeakerChanged(participantId);
    }
};
```

</TabItem>

</Tabs>


---

---
title: Start join Meeting Video & Audio Call - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: Start or join Meeting features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Start or Join Meeting
pagination_label: Start or Join Meeting
keywords:
  - Join audio calling
  - Join video calling
  - Join real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: start-join-meeting
---

import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>

# Start or Join Meeting - Android

<div style={{display:'flex',flexDirection:'row',alignItems:'stretch',}}>
<div style={{}}>
<p>After the successful installation of VideoSDK, the next step is to integrate VideoSDK features with your webApp/MobileApp.</p>

<p>To Communicate with other participant's audio or video call, you will need to join the meeting.</p>

<p>This guide will provide an overview of how to configure, initialize and join a VideoSDK meeting.</p>

</div>
<div>
<img src="/img/gif/new-meeting.gif"/>
</div>

</div>

## 1. Configuration

To configure a meeting, you will need [generated token](/android/guide/video-and-audio-calling-api-sdk/server-setup) and [meetingId](/api-reference/realtime-communication/create-room), we had discussed in [Server Setup](/android/guide/video-and-audio-calling-api-sdk/server-setup).
This code snippet calls API from local server

**Scenario 1** - Suppose you **don't have** any meetingId, you can simply generate meetingId by invoking `create-meeting` API.

**Scenario 2** - Suppose you **have** meetingId, now you don't have to call `create-meeting` API to generate meetingId, instead you can call `validate-meeting` API to validate meetingId.

**Token generation API is necessary for both scenario.**

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
package live.videosdk.rtc.android.java;

import com.androidnetworking.AndroidNetworking;
import com.androidnetworking.error.ANError;
import com.androidnetworking.interfaces.JSONObjectRequestListener;
import org.json.JSONException;
import org.json.JSONObject;

class JoinActivity : AppCompatActivity() {
  private val apiServerUrl = "http://localhost:9000"

  // ...
  // onCreate() and other methods
  private fun getToken(@Nullable meetingId: String?) {
    AndroidNetworking
      .get("$apiServerUrl/get-token")
      .build()
      .getAsJSONObject(
        object : JSONObjectRequestListener {
          override fun onResponse(response: JSONObject) {
            try
            {
              token = response.getString("token")
              if (meetingId == null) {
                createMeeting(token)
              } else {
                joinMeeting(token, meetingId)
              }
            } catch (e: JSONException) {
              e.printStackTrace()
            }
          }

          override fun onError(anError: ANError) {
            anError.printStackTrace()
          }
        }
      )
  }

  private fun createMeeting(token: String) {
    AndroidNetworking
      .post("$apiServerUrl/create-meeting")
      .addBodyParameter("token", token)
      .build()
      .getAsJSONObject(
        object : JSONObjectRequestListener {
          override fun onResponse(response: JSONObject) {
            try {
              // final String meetingId = response.getString("meetingId");

              // Intent intent = new Intent(JoinActivity.this, MainActivity.class);
              // intent.putExtra("token", token);
              // intent.putExtra("meetingId", meetingId);

              // startActivity(intent);
            } catch (e: JSONException) {
                e.printStackTrace()
            }
          }

          override fun onError(anError: ANError) {
            anError.printStackTrace()
          }
        }
      )
  }

  private fun joinMeeting(token: String, meetingId: String) {
    AndroidNetworking
      .post("$apiServerUrl/validate-meeting/{meetingId}")
      .addPathParameter("meetingId", meetingId)
      .addBodyParameter("token", token)
      .build()
      .getAsJSONObject(
        object : JSONObjectRequestListener {
          override fun onResponse(response: JSONObject) {
            // Intent intent = new Intent(JoinActivity.this, MainActivity.class);
            // intent.putExtra("token", token);
            // intent.putExtra("meetingId", meetingId);

            // startActivity(intent);
          }

          override fun onError(anError: ANError) {
            anError.printStackTrace()
          }
        }
      )
  }
}

```

</TabItem>

<TabItem value="Java">

```js
package live.videosdk.rtc.android.java;

import com.androidnetworking.AndroidNetworking;
import com.androidnetworking.error.ANError;
import com.androidnetworking.interfaces.JSONObjectRequestListener;
import org.json.JSONException;
import org.json.JSONObject;

public class JoinActivity extends AppCompatActivity {
  private String apiServerUrl = "http://localhost:9000";

  // ...
  // onCreate() and other methods

  private void getToken(@Nullable String meetingId) {
    AndroidNetworking
      .get(apiServerUrl + "/get-token")
      .build()
      .getAsJSONObject(
        new JSONObjectRequestListener() {
          @Override
          public void onResponse(JSONObject response) {
            try {
              String token = response.getString("token");

              if (meetingId == null) {
                createMeeting(token);
              } else {
                joinMeeting(token, meetingId);
              }
            } catch (JSONException e) {
              e.printStackTrace();
            }
          }

          @Override
          public void onError(ANError anError) {
            anError.printStackTrace();
          }
        }
      );
  }

  private void createMeeting(String token) {
    AndroidNetworking
      .post(apiServerUrl + "/create-meeting")
      .addBodyParameter("token", token)
      .build()
      .getAsJSONObject(
        new JSONObjectRequestListener() {
          @Override
          public void onResponse(JSONObject response) {
            try {
              // final String meetingId = response.getString("meetingId");

              // Intent intent = new Intent(JoinActivity.this, MainActivity.class);
              // intent.putExtra("token", token);
              // intent.putExtra("meetingId", meetingId);

              // startActivity(intent);
            } catch (JSONException e) {
              e.printStackTrace();
            }
          }

          @Override
          public void onError(ANError anError) {
            anError.printStackTrace();
          }
        }
      );
  }

  private void joinMeeting(String token, String meetingId) {
    AndroidNetworking
      .post(apiServerUrl + "/validate-meeting/{meetingId}")
      .addPathParameter("meetingId", meetingId)
      .addBodyParameter("token", token)
      .build()
      .getAsJSONObject(
        new JSONObjectRequestListener() {
          @Override
          public void onResponse(JSONObject response) {
            // Intent intent = new Intent(JoinActivity.this, MainActivity.class);
            // intent.putExtra("token", token);
            // intent.putExtra("meetingId", meetingId);

            // startActivity(intent);
          }

          @Override
          public void onError(ANError anError) {
            anError.printStackTrace();
          }
        }
      );
  }
}

```

</TabItem>

</Tabs>

## 2. Initialization

import CautionMessage from '@site/src/theme/CautionMessage';


<CautionMessage sdk="Android SDK" version="v0.2.0" />

<div style={{display:'flex',flexDirection:'row',alignItems:'stretch',}}>
<div style={{}}>
<p>
After configuration, you will have to Initialize 
<p>
meeting by providing name, meetingId, micEnabled, webcamEnabled & maxResolution.
</p>
</p>

<p>
NOTE : For React & React native developer, you have

<p>to be familiar with hooks concept. You can understand hooks concept on <a href={'https://reactjs.org/docs/hooks-intro.html'}>React Hooks</a>.</p>

</p>
</div>
<div>
<img src="/img/gif/add-participant.gif"/>
</div>

</div>

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
import live.videosdk.rtc.android.VideoSDK;
import live.videosdk.rtc.android.Meeting;

class MainActivity : AppCompatActivity() {
  private var meeting: Meeting? = null

  override fun onCreate(savedInstanceState: Bundle?) {
    // Configure parameters
    val token = intent.getStringExtra("token")
    val meetingId = intent.getStringExtra("meetingId")
    val participantName = "John Doe"
    val micEnabled = true
    val webcamEnabled = true
    val paticipantId="demo@123"  // If you passed `null` then SDK will create an Id by itself and will use that id.
    val mode="SEND_AND_RECV"

    // Configure authentication token
    VideoSDK.config(token)

    // create a new meeting instance
    meeting = VideoSDK.initMeeting(
      this@MainActivity,
      meetingId,
      participantName,
      micEnabled,
      webcamEnabled,
      paticipantId,
      mode,
      null
    )
  }
}

```

</TabItem>

<TabItem value="Java">

```js
import live.videosdk.rtc.android.VideoSDK;
import live.videosdk.rtc.android.Meeting;

public class MainActivity extends AppCompatActivity {
    private Meeting meeting;

    @Override
    protected void onCreate(Bundle savedInstanceState) {

        // Configure parameters
        final String token = getIntent().getStringExtra("token");
        final String meetingId = getIntent().getStringExtra("meetingId");
        final String participantName = "John Doe";
        final boolean micEnabled = true;
        final boolean webcamEnabled = true;
        final String participantId = "demo@123"; // If you passed `null` then SDK will create an Id by itself and will use that id.
        final String mode="SEND_AND_RECV";

        // Configure authentication token
        VideoSDK.config(token);

        // create a new meeting instance
        meeting = VideoSDK.initMeeting(
                MainActivity.this,
                meetingId,
                participantName,
                micEnabled,
                webcamEnabled,
                participantId,
                mode,
                null
        );
    }
}

```

</TabItem>

</Tabs>

## 3. Join

<div style={{display:'flex',flexDirection:'row',alignItems:'stretch',}}>
<div style={{}}>
<p>
After configuration & initialization, the third step is to call join() to join a meeting.
</p>

<p>
After joining, you will be able to Manage Participant in a meeting.
</p>

</div>
<div>
<img src="/img/gif/join-meeting.gif"/>
</div>

</div>

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
// After receiving mic and webcam access permissions
// join the meeting
meeting!!.join()
```

</TabItem>

<TabItem value="Java">

```js
// After receiving mic and webcam access permissions
// join the meeting
meeting.join();
```

</TabItem>

</Tabs>

## Events

Following events are emitted on the `meeting` when it is successfully joined.

- Local Participant will receive a [`onMeetingJoined`](../../../api/sdk-reference/meeting-class/meeting-event-listener-class.md#onmeetingjoined) event when successfully joined.
- Remote Participant will receive a [`onParticipantJoined`](../../../api/sdk-reference/meeting-class/meeting-event-listener-class.md#onparticipantjoined) event with the newly joined [`Participant`](../../../api/sdk-reference/participant-class/introduction.md) object from the event callback.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
private final MeetingEventListener meetingEventListener = new MeetingEventListener() {
  override fun onMeetingJoined() {
    Log.d("#meeting", "onMeetingJoined()")
  }

  override fun onParticipantJoined(participant: Participant) {
    Log.d("#meeting", participant.displayName + " left");
  }
}
```

</TabItem>

<TabItem value="Java">

```javascript
private final MeetingEventListener meetingEventListener = new MeetingEventListener() {

  @Override
  public void onMeetingJoined() {
    Log.d("#meeting", "onMeetingJoined()");
  }

  @Override
  public void onParticipantJoined(Participant participant) {
    Log.d("#meeting", participant.getDisplayName() + " left");
  }
}
```

</TabItem>

</Tabs>


---

---
title: Toggle Participant Media
hide_title: false
hide_table_of_contents: false
description: Camera Controls features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Toggle Participant Media
pagination_label: Toggle Participant Media
keywords:
  - Camera on
  - Camera off
  - Webcam on
  - Webcam off
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: toggle-participant-media
---

import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>

# Toggle Participant Media - Android

Control other participant's webcam and mic.
For better idea, let's understand this with a real case scenario

**Scenario 1 (Online Class)** - In this scenario, the lecturer(Local Participant) will control the student's(Other Participant) webcam and mic as per his/her needs.

**Scenario 2 (Online Events)** - In this scenario, the event hosts will control the audience webcam and mic when someone wants to speak.

This guide will provide an overview of how to control other participant webcam and mic in a meeting.

1. **Enable Webcam of Participant** - By using `enableWebcam()` function, a `onWebcamRequested` event will trigger on requested participant side.

   **Example** : Meeting is running with **User A** and **User B**. Now **User A** wants to Enable Webcam of **User B**, so **User A** will use `enableWebcam()` function to request **User B**, after that **User B** recieve the `onWebcamRequested` event, from there user can either accept or reject the incoming request.

2. **Disable Webcam of Participant** - By using `disableWebcam()` function, webcam of that participant will be turned off.

   **Example** : **User A** wants to Disable Webcam of **User B**, so **User A** will use `disableWebcam()` function to Disable it without any request.

3. **Enable Mic of Participant** - By using `enableMic()` function, a `onMicRequested` event will trigger on requested participant side.

   **Example** : Meeting is running with **User A** and **User B**. Now **User A** wants to Enable Mic of **User B**, so **User A** will use `enableMic()` function to request **User B**, after that **User B** will receive the `onMicRequested` event, from there user can either accept or reject the incoming request.

4. **Disable Mic of Participant** - By using `disableMic()` function, Mic of that participant will disable.

   **Example** : **User A** wants to Disable Mic of **User B**, so **User A** will use `disableMic()` function to Disable it without any request.

:::note

To achieve this feature, you need to pass `allow_join` persmission while genearting token for meeting initialization. After that you will be able to access participant media methods.

[How to apply permission while generating token?](/android/guide/video-and-audio-calling-api-sdk/server-setup)

:::

### Request Media Methods

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
val participant = meeting!!.participants.get("<participant-id>")

// This will emit an event called "onWebcamRequested" to that particular participant
participant.enableWebcam()

// This will directly disable webcam of particular participant
participant.disableWebcam()

// This will emit an event called "onMicRequested" to that particular participant
participant.enableMic()

// This will directly disable mic of particular participant
participant.disableMic()
```

</TabItem>

<TabItem value="Java">

```js
Participant participant = meeting.getParticipants().get("<participant-id>");

// This will emit an event called "onWebcamRequested" to that particular participant
participant.enableWebcam();

// This will directly disable webcam of particular participant
participant.disableWebcam();

// This will emit an event called "onMicRequested" to that particular participant
participant.enableMic();

// This will directly disable mic of particular participant
participant.disableMic();
```

</TabItem>

</Tabs>

### Manage Requested Media Events

1. **onWebcamRequested** - This event will be emitted to the participant `B` when any other participant `A` requests to enable webcam of that participant `B`. This event handler will receieve following three arguments:

   - `accept()` - Callback function to accept the request.
   - `reject()` - Callback function to reject the request.

<div style={{height: "10px"}}></div>

2. **onMicRequested** - This event will be emitted to the participant `B` when any other participant `A` requests to enable mic of that participant `B`. This event handler will receieve following three arguments:

   - `accept()` - Callback function to accept the request.
   - `reject()` - Callback function to reject the request.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
object : MeetingEventListener() {
  override fun onMicRequested(participantId: String, listener: MicRequestListener) {
      // TODO: show dialog before accepting request
      listener.accept()
  }

  override fun onWebcamRequested(participantId: String, listener: WebcamRequestListener) {
      // TODO: show dialog before accepting request
      listener.accept()
  }
}
```

</TabItem>

<TabItem value="Java">

```js
new MeetingEventListener() {
  @Override
  public void onMicRequested(String participantId, MicRequestListener listener) {
      // TODO: show dialog before accepting request
      listener.accept();
  }

  @Override
  public void onWebcamRequested(String participantId, WebcamRequestListener listener) {
      // TODO: show dialog before accepting request
      listener.accept();
  }
}
```

</TabItem>

</Tabs>


---

---
title: Cloud Proxy | Secure and Manage Streaming Traffic | Video SDK
hide_title: true
hide_table_of_contents: false
description: Leverage Video SDK's Cloud Proxy to securely manage and optimize your video streaming traffic. Ideal for enhancing performance and securing data.
sidebar_label: Cloud Proxy
pagination_label: Cloud Proxy
keywords:
  - cloud proxy
  - secure streaming
  - video SDK security
  - traffic management
image: img/videosdklive-thumbnail.jpg
sidebar_position: 2
slug: cloud-proxy
---

# Cloud Proxy - Android

import CloudProxy from '../../../../../mdx/\_cloud-proxy.mdx';

<CloudProxy/>

## Implementation

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
val meeting: Meeting = VideoSDK.initMeeting(
      this@MainActivity, "meetingId", "John Due", true,
      true, null, null, false, null, null,"proxy.yourwebsite.com", VideoSDK.PreferredProtocol.UDP_ONLY
);
```

</TabItem>

<TabItem value="Java">

```java
Meeting meeting = VideoSDK.initMeeting(
      MainActivity.this, "meetingId", "John Due",true,
      true, null, null, false, null,null,"proxy.yourwebsite.com", VideoSDK.PreferredProtocol.UDP_ONLY
);
```

</TabItem>

</Tabs>
### Parameters
- preferredProtocol:
    - UDP_OVER_TCP (default): Initially the server attempts to establish a connection using UDP, if that fails it automatically switches to TCP protocol.
    - UDP_ONLY: Force UDP protocol
    - TCP_ONLY: Force TCP protocol
- signalingBaseUrl: Proxy URL to origin signaling and media.

## API Reference

The API references for all the methods and events utilized in this guide are provided below.

- [initMeeting()](/android/api/sdk-reference/initMeeting)


---

---
title: Geo Fencing | Location based Restrictions | Video SDK
hide_title: true
hide_table_of_contents: false
description: Implement geographic content restrictions with Video SDK's Geo Fencing feature. Essential for compliance and tailored content delivery based on user location.
sidebar_label: Geo Fencing
pagination_label: Geo Fencing
keywords:
- geo fencing
- geographic restrictions
- location based restrictions
- regional access
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: geo-fencing
---

# Geo Fencing - Android

import GeoFencing from '../../../../../mdx/\_geo-fencing.mdx';

<GeoFencing/>



---

---
title: Geo IP Restriction | Location Based Access Control | Video SDK
hide_title: true
hide_table_of_contents: false
description: Utilize Video SDK’s Geo IP Restriction to enforce access based on user geography. This feature is crucial for adhering to location-specific regulations and ensuring content is appropriately localized.
sidebar_label: Geo IP Restriction
pagination_label: Geo IP Restriction
keywords:
- geo ip restriction
- geographic access control
- location based security
- regional compliance
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: geo-ip-restriction
---

# Geo IP Restrictions  - Android

import GeoIpRestriction from '../../../../../mdx/\_geo-ip-restriction.mdx';

<GeoIpRestriction/>



---

---
title: Error Events | Video SDK
hide_title: true
hide_table_of_contents: false
description: Video SDK and Audio SDK, developers need to implement a token server. This requires efforts on both the front-end and backend.
sidebar_label: Error Events
pagination_label: Error Events
keywords:
  - audio calling
  - video calling
  - real-time communication
  - collaboration
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: error-events
---

import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>

# Error Events - Android

VideoSDK provides `onError` event which will notify you of any error happening during the meeting.

### onError

- This event will be triggered whenever any invalid configuration provided or server/network errors arise, this event will trigger with a specific error code and message.
- This event is helpful for development level troubleshooting while integrating SDK.
- You can implement this method of the abstract Class `MeetingEventListener` and add the listener to `Meeting` class using the `addEventListener()` method of `Meeting` Class.

### Example

Here is the usage of the event mentioned in this page.

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
private val meetingEventListener: MeetingEventListener = object : MeetingEventListener() {
  //..
  override fun onError(error: JSONObject) {
  try {
      val errorCodes: JSONObject = VideoSDK.getErrorCodes()
      val code = error.getInt("code")
      Log.d("#error", "Error is: " + error["message"])
  } catch (e: Exception) {
          e.printStackTrace()
      }
  }
}
```

</TabItem>

<TabItem value="Java">

```js
private final MeetingEventListener meetingEventListener = new MeetingEventListener() {
  //..
  @Override
  public void onError(JSONObject error) {
      try {
          JSONObject errorCodes = VideoSDK.getErrorCodes();
          int code = error.getInt("code");
          Log.d("#error", "Error is: " + error.get("message"));
      } catch (Exception e) {
          e.printStackTrace();
      }
  }
};
```

</TabItem>

</Tabs>

### Error Codes

We have depicted a specific constant with code and message in the below table.

import ServerErrorCodes from '../../../../../mdx/\_server-error-codes.mdx'
import SDKErrorCodes from '../../../data/\_sdk-error-codes.mdx'

<ServerErrorCodes />

<SDKErrorCodes/>

### API Reference

The API references for all the methods and events utilised in this guide are provided below.

- [onError()](/android/api/sdk-reference/error-codes)


---

---
title: External Call Detection Video & Audio Call - Video SDK Docs
hide_title: false
hide_table_of_contents: false
sidebar_label: External Call Detection Event
pagination_label: External Call Detection Event
keywords:
  - External Call Detection
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: external-call-detection-event
---

# External Call Detection Event - Android

External call detection event in VideoSDK let you know, participant is on the call during meeting.

Whenever local participant accept the incoming call or place outgoing call, `externalcall-started` event will trigger.`externalcall-started` event only received by localParticipant.

For example, the meeting is running with **Alice** and **Bob**. Whenever **Alice** receives the call or she call someone, **Alice** will receive `externalcall-started` event.

We can access `externalcall-started` event through `Meeting` class.

### externalcall-started Event

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
private val meetingEventListener: MeetingEventListener = object : MeetingEventListener() {
     // ...
    override fun onExternalCallStarted() {
      Log.d("#VideoSDK", "onExternalCallAnswered")
    }
};

override fun onCreate(savedInstanceState: Bundle?) {
  //...

  // add listener to meeting
  //highlight-next-line
  meeting!!.addEventListener(meetingEventListener)
}
```

</TabItem>

<TabItem value="Java">

```js
private final MeetingEventListener meetingEventListener = new MeetingEventListener() {
     // ...
    @Override
    public void onExternalCallStarted() {
        Log.d("#VideoSDK", "onExternalCallStarted");
    }
};

@Override
protected void onCreate(Bundle savedInstanceState) {
  //...

  // add listener to meeting
  //highlight-next-line
  meeting.addEventListener(meetingEventListener);
}
```

</TabItem>

</Tabs>


---

---
title: HLS Events | Video SDK
hide_title: true
hide_table_of_contents: false
description: Video SDK and Audio SDK, developers need to implement a token server. This requires efforts on both the front-end and backend.
sidebar_label: HLS Events
pagination_label: HLS Events
keywords:
  - audio calling
  - video calling
  - real-time communication
  - collaboration
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: hls-events
---

# HLS Events - Android

VideoSDK provides `onHlsStateChanged` event which will notify you of the current state of HLS for the meeting.

### onHlsStateChanged

- This event will be triggered when the meeting's HLS status changed.
- You can implement this method of the abstract Class `MeetingEventListener` and add the listener to `Meeting` class using the `addEventListener()` method of `Meeting` Class.
- when you receive `HLS_PLAYABLE` status you will receive 2 urls in response
  - `playbackHlsUrl` - Live HLS with playback support
  - `livestreamUrl` - Live HLS without playback support

:::note
`downstreamUrl` is now depecated. Use `playbackHlsUrl` or `livestreamUrl` in place of `downstreamUrl`
:::

### Example

Here is the usage of the event mentioned in this page.

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
private val meetingEventListener: MeetingEventListener = object : MeetingEventListener() {
  override fun onHlsStateChanged(HlsState: JSONObject) {
    when (HlsState.getString("status")) {
        "HLS_STARTING" -> Log.d("onHlsStateChanged", "Meeting hls is starting")
        "HLS_STARTED" -> Log.d("onHlsStateChanged", "Meeting hls is started")
        "HLS_PLAYABLE" -> {
            Log.d("onHlsStateChanged", "Meeting hls is playable now")
            // on hls playable you will receive playbackHlsUrl and livestreamUrl
            val playbackHlsUrl = HlsState.getString("playbackHlsUrl")
            val livestreamUrl = HlsState.getString("livestreamUrl")
        }
        "HLS_STOPPING" -> Log.d("onHlsStateChanged", "Meeting hls is stopping")
        "HLS_STOPPED" -> Log.d("onHlsStateChanged", "Meeting hls is stopped")
    }
  }
}

override fun onCreate(savedInstanceState: Bundle?) {
  //...

  // add listener to meeting
  //highlight-next-line
  meeting!!.addEventListener(meetingEventListener)
}
```

</TabItem>

<TabItem value="Java">

```js
private final MeetingEventListener meetingEventListener = new MeetingEventListener() {
  @Override
  public void onHlsStateChanged(JSONObject HlsState) {
      switch (HlsState.getString("status")) {
          case "HLS_STARTING":
              Log.d("onHlsStateChanged", "Meeting hls is starting");
              break;
          case "HLS_STARTED":
              Log.d("onHlsStateChanged", "Meeting hls is started");
              break;
          case "HLS_PLAYABLE":
              Log.d("onHlsStateChanged", "Meeting hls is playable now");
              // on hls started you will receive playbackHlsUrl and livestreamUrl
              String playbackHlsUrl = HlsState.getString("playbackHlsUrl");
              String livestreamUrl = HlsState.getString("livestreamUrl");
              break;
          case "HLS_STOPPING":
              Log.d("onHlsStateChanged", "Meeting hls is stopping");
              break;
          case "HLS_STOPPED":
              Log.d("onHlsStateChanged", "Meeting hls is stopped");
              break;
      }
  }
}

@Override
protected void onCreate(Bundle savedInstanceState) {
  //...

  // add listener to meeting
  //highlight-next-line
  meeting.addEventListener(meetingEventListener);
}
```

</TabItem>

</Tabs>

### API Reference

The API references for all the methods and events utilised in this guide are provided below.

- [onHlsStateChanged()](/android/api/sdk-reference/meeting-class/meeting-event-listener-class#onhlsstatechanged)


---

---
title: Media Events | Video SDK
hide_title: true
hide_table_of_contents: false
description: Video SDK and Audio SDK, developers need to implement a token server. This requires efforts on both the front-end and backend.
sidebar_label: Media Events
pagination_label: Media Events
keywords:
  - audio calling
  - video calling
  - real-time communication
  - collaboration
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: media-events
---

# Media Events - Android

VideoSDK provides multiple types of events which can be listened to know the about the participant's media status in the meeting.

You can implement all the methods of `ParticipantEventListener` abstract Class and add the listener to `Participant` class using the `addEventListener()` method of `Participant` Class.

Here are the events which specifically relate to the stream.

### onStreamEnabled

- This event is triggered whenever a participant's video, audio or screen share stream is enabled.

### onStreamDisabled

- This event is triggered whenever a participant's video, audio or screen share stream is disabled.

### Example

Here is the usage of all the events mentioned in this page.

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
participant.addEventListener(object : ParticipantEventListener() {
  override fun onStreamEnabled(stream: Stream) {
    Log.d("VideoSDK","onStreamEnabled $stream");
  }

  override fun onStreamDisabled(stream: Stream) {
    Log.d("VideoSDK","onStreamDisabled $stream");
  }
});
```

</TabItem>

<TabItem value="Java">

```js
participant.addEventListener(new ParticipantEventListener() {
  @Override
  public void onStreamEnabled(Stream stream) {
    Log.d("VideoSDK","onStreamEnabled" + stream);
  }

  @Override
  public void onStreamDisabled(Stream stream) {
    Log.d("VideoSDK","onStreamDisabled" + stream);
  }
});
```

</TabItem>

</Tabs>

### API Reference

The API references for all the methods and events utilised in this guide are provided below.

- [onStreamEnabled()](/android/api/sdk-reference/participant-class/participant-event-listener-class#onstreamenabled)
- [onStreamDisabled()](/android/api/sdk-reference/participant-class/participant-event-listener-class#onstreamdisabled)


---

---
title: Meeting Connection Events | Video SDK
hide_title: true
hide_table_of_contents: false
description: Video SDK and Audio SDK, developers need to implement a token server. This requires efforts on both the front-end and backend.
sidebar_label: Meeting Connection Events
pagination_label: Meeting Connection Events
keywords:
  - audio calling
  - video calling
  - real-time communication
  - collaboration
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: meeting-connection-events
---

# Meeting Connection Events - Android

VideoSDK provides `onMeetingStateChanged` event which will notify you of the current connection state of the meeting.

### onMeetingStateChanged

- This event will be triggered when state of meeting changes.
- It will pass **`state`** as an event callback parameter which will indicate current state of the meeting.
- All available states are :
  - **CONNECTING**: The meeting is in the process of establishing a connection.
  - **CONNECTED**: The meeting has successfully connected.
  - **RECONNECTING**: The meeting is trying to reconnect after the connection was lost.
  - **DISCONNECTED**: The meeting has been disconnected.

- You can implement this method of the abstract Class `MeetingEventListener` and add the listener to `Meeting` class using the `addEventListener()` method of `Meeting` Class.

### Example

Here is the usage of the event mentioned in this page.

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
private val meetingEventListener: MeetingEventListener = object : MeetingEventListener() {
  override fun onMeetingStateChanged(state: MeetingState) {
    when (state) {
        MeetingState.CONNECTING -> {
            Log.d("onMeetingStateChanged", "Meeting is Connecting")
        }
        MeetingState.CONNECTED -> {
            Log.d("onMeetingStateChanged", "Meeting is Connected")
        }
        MeetingState.RECONNECTING -> {
            Log.d("onMeetingStateChanged", "Meeting is RECONNECTING")
        }
        MeetingState.DISCONNECTED -> {
            Log.d("onMeetingStateChanged", "Meeting is Disconnected")
        }
    }
  }

}

override fun onCreate(savedInstanceState: Bundle?) {
  //...

  // add listener to meeting
  //highlight-next-line
  meeting!!.addEventListener(meetingEventListener)
}
```

</TabItem>

<TabItem value="Java">

```javascript
private final MeetingEventListener meetingEventListener = new MeetingEventListener() {
  @Override
  public void onMeetingStateChanged(MeetingState state) {
      switch (state) {
      case CONNECTING:
          Log.d("onMeetingStateChanged: ", "Meeting is Connecting");
          break;
      case CONNECTED:
          Log.d("onMeetingStateChanged: ", "Meeting is Connected");
          break;
      case RECONNECTING:
          Log.d("onMeetingStateChanged: ", "Meeting is RECONNECTING");
          break;
      case DISCONNECTED:
          Log.d("onMeetingStateChanged: ", "Meeting is disconnected");
          break;
  }
}

@Override
protected void onCreate(Bundle savedInstanceState) {
  //...

  // add listener to meeting
  //highlight-next-line
  meeting.addEventListener(meetingEventListener);
}
```

</TabItem>

</Tabs>

### API Reference

The API references for all the methods and events utilised in this guide are provided below.

- [onMeetingStateChanged()](/android/api/sdk-reference/meeting-class/meeting-event-listener-class#onmeetingstatechanged)


---

---
title: Meeting Events | Video SDK
hide_title: true
hide_table_of_contents: false
description: Video SDK and Audio SDK, developers need to implement a token server. This requires efforts on both the front-end and backend.
sidebar_label: Meeting Events
pagination_label: Meeting Events
keywords:
  - audio calling
  - video calling
  - real-time communication
  - collaboration
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: meeting-events
---

# Meeting Events - Android

VideoSDK provides multiple types of events which can be listened to know the current state of the meeting.

You can implement all the methods of `MeetingEventListener` abstract Class and add the listener to `Meeting` class using the `addEventListener()` method of `Meeting` Class.

Here are the events which specifically relate to the meeting.

### onMeetingJoined

- This event is triggered when the meeting is successfully joined.

### onMeetingLeft

- This event is triggered when the meeting is left.

### onSpeakerChanged

- This event is triggered when the active speaker in the meeting gets changed.

### onPresenterChanged

- This event is triggered when the presenter in the meeting gets changed.

### Example

Here is the usage of all the events mentioned in this page.

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
private val meetingEventListener: MeetingEventListener = object : MeetingEventListener() {
  override fun onMeetingJoined() {
      Log.d("VideoSDK", "onMeetingJoined: ")
  }

  override fun onMeetingLeft() {
      Log.d("VideoSDK", "onMeetingLeft: ")
  }

  override fun onSpeakerChanged(participantId: String) {
      Log.d("VideoSDK", "onSpeakerChanged: $participantId")
  }

  override fun onPresenterChanged(participantId: String) {
      Log.d("VideoSDK", "onPresenterChanged: $participantId")
  }
}

override fun onCreate(savedInstanceState: Bundle?) {
  //...

  // add listener to meeting
  //highlight-next-line
  meeting!!.addEventListener(meetingEventListener)
}
```

</TabItem>

<TabItem value="Java">

```js
private final MeetingEventListener meetingEventListener = new MeetingEventListener() {
  @Override
  public void onMeetingJoined() {
    Log.d("VideoSDK", "onMeetingJoined: ");
  }

  @Override
  public void onMeetingLeft() {
    Log.d("VideoSDK", "onMeetingLeft: ");
  }

  @Override
  public void onSpeakerChanged(String participantId) {
    Log.d("VideoSDK", "onSpeakerChanged: " + participantId);
  }

  @Override
  public void onPresenterChanged(String participantId) {
    Log.d("VideoSDK", "onPresenterChanged: " + participantId);
  }
};

@Override
protected void onCreate(Bundle savedInstanceState) {
  //...

  // add listener to meeting
  //highlight-next-line
  meeting.addEventListener(meetingEventListener);
}
```

</TabItem>

</Tabs>

### API Reference

The API references for all the methods and events utilised in this guide are provided below.

- [onMeetingJoined()](/android/api/sdk-reference/meeting-class/meeting-event-listener-class#onmeetingjoined)
- [onMeetingLeft()](/android/api/sdk-reference/meeting-class/meeting-event-listener-class#onmeetingleft)
- [onSpeakerChanged()](/android/api/sdk-reference/meeting-class/meeting-event-listener-class#onspeakerchanged)
- [onPresenterChanged()](/android/api/sdk-reference/meeting-class/meeting-event-listener-class#onpresenterchanged)


---

---
title: Participant Events | Video SDK
hide_title: true
hide_table_of_contents: false
description: Video SDK and Audio SDK, developers need to implement a token server. This requires efforts on both the front-end and backend.
sidebar_label: Participant Events
pagination_label: Participant Events
keywords:
  - audio calling
  - video calling
  - real-time communication
  - collaboration
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: participant-events
---

# Participant Events - Android

VideoSDK provides multiple types of events which can be listened to know the about the participants in the meeting.

You can implement all the methods of `MeetingEventListener` abstract Class and add the listener to `Meeting` class using the `addEventListener()` method of `Meeting` Class.

Here are the events which specifically relate to the participants.

### onParticipantJoined

- This event is triggered when someone joins the meeting and return the `Participant` object as parameter.

### onParticipantLeft

- This event is triggered when the someone leaves the meeting.

### onWebcamRequested

- This event will be triggered to the participant `B` when any other participant `A` requests to enable webcam of participant `B`.
- On accepting the request, webcam of participant `B` will be enabled.

### onMicRequested

- This event will be triggered to the participant `B` when any other participant `A` requests to enable mic of participant `B`.
- On accepting the request, mic of participant `B` will be enabled.
- This event can be subscribed from the `useMeeting` hook.

### Example

Here is the usage of all the events mentioned in this page.

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
private val meetingEventListener: MeetingEventListener = object : MeetingEventListener() {
  override fun onParticipantJoined(participant: Participant) {
    Log.d("VideoSDK", participant.displayName + " joined");
  }

  override fun onParticipantLeft(participant: Participant) {
    Log.d("VideoSDK", participant.displayName + " left");
  }

  override fun onWebcamRequested(participantId: String, listener: WebcamRequestListener) {

    // participantId, will be the id of participant who requested to enable mic

    // if accept request
    listener.accept()

    // if reject request
    listener.reject()
  }

  override fun onMicRequested(participantId: String, listener: MicRequestListener) {

    // participantId, will be the id of participant who requested to enable mic

    // if accept request
    listener.accept()

    // if reject request
    listener.reject()
  }
}

override fun onCreate(savedInstanceState: Bundle?) {
  //...

  // add listener to meeting
  //highlight-next-line
  meeting!!.addEventListener(meetingEventListener)
}
```

</TabItem>

<TabItem value="Java">

```javascript
private final MeetingEventListener meetingEventListener = new MeetingEventListener() {
  @Override
  public void onParticipantJoined(Participant participant) {
      Log.d("VideoSDK", participant.getDisplayName() + " joined");
  }

  @Override
  public void onParticipantLeft(Participant participant) {
      Log.d("VideoSDK", participant.getDisplayName() + " left");
  }

  @Override
  public void onWebcamRequested(String participantId, WebcamRequestListener listener) {

    // participantId, will be the id of participant who requested to enable webcam

    // if accept request
    listener.accept();

    // if reject request
    listener.reject();
  }

  @Override
  public void onMicRequested(String participantId, MicRequestListener listener) {

    // participantId, will be the id of participant who requested to enable mic

    // if accept request
    listener.accept();

    // if reject request
    listener.reject();
 }
}

@Override
protected void onCreate(Bundle savedInstanceState) {
  //...

  // add listener to meeting
  //highlight-next-line
  meeting.addEventListener(meetingEventListener);
}
```

</TabItem>

</Tabs>

### API Reference

The API references for all the methods and events utilised in this guide are provided below.

- [onParticipantJoined()](/android/api/sdk-reference/meeting-class/meeting-event-listener-class#onparticipantjoined)
- [onParticipantLeft()](/android/api/sdk-reference/meeting-class/meeting-event-listener-class#onparticipantleft)
- [onWebcamRequested()](/android/api/sdk-reference/meeting-class/meeting-event-listener-class#onwebcamrequested)
- [onMicRequested()](/android/api/sdk-reference/meeting-class/meeting-event-listener-class#onmicrequested)


---

---
title: Recording Events | Video SDK
hide_title: true
hide_table_of_contents: false
description: Video SDK and Audio SDK, developers need to implement a token server. This requires efforts on both the front-end and backend.
sidebar_label: Recording Events
pagination_label: Recording Events
keywords:
  - audio calling
  - video calling
  - real-time communication
  - collaboration
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: recording-events
---

# Recording Events - Android

VideoSDK provides `onRecordingStateChanged` event which will notify you of the current state of recording for the meeting.

### onRecordingStateChanged

- This event will be triggered when the meeting's recording status changed.
- You can implement this method of the abstract Class `MeetingEventListener` and add the listener to `Meeting` class using the `addEventListener()` method of `Meeting` Class.

### Example

Here is the usage of the event mentioned in this page.

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
private val meetingEventListener: MeetingEventListener = object : MeetingEventListener() {
  override fun onRecordingStateChanged(recordingState: String) {
    when (recordingState) {
        "RECORDING_STARTING" -> {
            Log.d("onRecordingStateChanged", "Meeting recording is starting")
        }
        "RECORDING_STARTED" -> {
            Log.d("onRecordingStateChanged", "Meeting recording is started")
        }
        "RECORDING_STOPPING" -> {
            Log.d("onRecordingStateChanged", "Meeting recording is stopping")
        }
        "RECORDING_STOPPED" -> {
            Log.d("onRecordingStateChanged", "Meeting recording is stopped")
        }
    }
  }
}

override fun onCreate(savedInstanceState: Bundle?) {
  //...

  // add listener to meeting
  //highlight-next-line
  meeting!!.addEventListener(meetingEventListener)
}
```

</TabItem>

<TabItem value="Java">

```js
private final MeetingEventListener meetingEventListener = new MeetingEventListener() {
  @Override
  public void onRecordingStateChanged(String recordingState) {
      switch (recordingState) {
          case "RECORDING_STARTING":
              Log.d("onRecordingStateChanged", "Meeting recording is starting");
              break;
          case "RECORDING_STARTED":
              Log.d("onRecordingStateChanged", "Meeting recording is started");
              break;
          case "RECORDING_STOPPING":
              Log.d("onRecordingStateChanged", "Meeting recording is stopping");
              break;
          case "RECORDING_STOPPED":
              Log.d("onRecordingStateChanged", "Meeting recording is stopped");
              break;
      }
  }
}

@Override
protected void onCreate(Bundle savedInstanceState) {
  //...

  // add listener to meeting
  //highlight-next-line
  meeting.addEventListener(meetingEventListener);
}
```

</TabItem>

</Tabs>

### API Reference

The API references for all the methods and events utilised in this guide are provided below.

- [onRecordingStateChanged()](/android/api/sdk-reference/meeting-class/meeting-event-listener-class#onrecordingstatechanged)


---

---
title: RTMP Events | Video SDK
hide_title: true
hide_table_of_contents: false
description: Video SDK and Audio SDK, developers need to implement a token server. This requires efforts on both the front-end and backend.
sidebar_label: RTMP Events
pagination_label: RTMP Events
keywords:
  - audio calling
  - video calling
  - real-time communication
  - collaboration
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: rtmp-events
---

# RTMP Events - Android

VideoSDK provides `onLivestreamStateChanged` event which will notify you of the current state of livestream for the meeting.

### onLivestreamStateChanged

- This event will be triggered when the meeting's livestream status changed.
- You can implement this method of the abstract Class `MeetingEventListener` and add the listener to `Meeting` class using the `addEventListener()` method of `Meeting` Class.

### Example

Here is the usage of the event mentioned in this page.

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
private val meetingEventListener: MeetingEventListener = object : MeetingEventListener() {
  override fun onLivestreamStateChanged(livestreamState: String?) {
    when (livestreamState) {
      "LIVESTREAM_STARTING" -> Log.d( "LivestreamStateChanged",
          "Meeting livestream is starting"
      )
      "LIVESTREAM_STARTED" -> Log.d( "LivestreamStateChanged",
          "Meeting livestream is started"
      )
      "LIVESTREAM_STOPPING" -> Log.d("LivestreamStateChanged",
          "Meeting livestream is stopping"
      )
      "LIVESTREAM_STOPPED" -> Log.d("LivestreamStateChanged",
          "Meeting livestream is stopped"
      )
    }
  }
}

override fun onCreate(savedInstanceState: Bundle?) {
  //...

  // add listener to meeting
  //highlight-next-line
  meeting!!.addEventListener(meetingEventListener)
}
```

</TabItem>

<TabItem value="Java">

```js
private final MeetingEventListener meetingEventListener = new MeetingEventListener() {
  @Override
  public void onLivestreamStateChanged(String livestreamState) {
    switch (livestreamState) {
      case "LIVESTREAM_STARTING":
          Log.d("LivestreamStateChanged", "Meeting livestream is starting");
          break;
      case "LIVESTREAM_STARTED":
          Log.d("LivestreamStateChanged", "Meeting livestream is started");
          break;
      case "LIVESTREAM_STOPPING":
          Log.d("LivestreamStateChanged", "Meeting livestream is stopping");
          break;
      case "LIVESTREAM_STOPPED":
          Log.d("LivestreamStateChanged", "Meeting livestream is stopped");
          break;
    }
  }
}

@Override
protected void onCreate(Bundle savedInstanceState) {
  //...

  // add listener to meeting
  //highlight-next-line
  meeting.addEventListener(meetingEventListener);
}
```

</TabItem>

</Tabs>

### API Reference

The API references for all the methods and events utilised in this guide are provided below.

- [onLivestreamStateChanged()](/android/api/sdk-reference/meeting-class/meeting-event-listener-class#onlivestreamstatechanged)


---

---
title: Get Started with Video & Audio Call - Video SDK Documentation
hide_title: true
hide_table_of_contents: false
description: Video SDK enables the opportunity to integrate native IOS, Android & Web SDKs to add live video & audio conferencing to your applications.
sidebar_label: Getting Started
pagination_label: Getting Started
keywords:
  - audio calling
  - video calling
  - real-time communication
  - collaboration
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: getting-started
---

import Mermaid from '@theme/Mermaid';
import GettingStarted from '/mdx/introduction/\_getting-started.mdx';
import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>
<GettingStarted title="Get Started with Android" />

## Steps

import Card from '@theme/Card';

<div class="container guide-steps-block">
  <div class="row ">
    <div class="col col--6">
      <Card heading="1. Get your API key and Secret" link="/android/guide/video-and-audio-calling-api-sdk/signup-and-create-api" description="Generate your API key and Secret from Video SDK." />
    </div>
     <div class="col col--6">
      <Card heading="2. Client Setup for Android" link="/android/guide/video-and-audio-calling-api-sdk/android-sdk" description="Easy to integrate SDK with cross-channel support." />
    </div>
  </div>
  <div class="row ">
   <div class="col col--6" >
      <Card heading="3. Authentication and Tokens" link="/android/guide/video-and-audio-calling-api-sdk/server-setup" description="Setup secured server authentication and authorization."  />
    </div>
    <div class="col col--6">
      <Card heading="4. Start a Audio / Video Call" link="/android/guide/video-and-audio-calling-api-sdk/quick-start" description="Get started with step by step guide of integrating Video SDK." />
    </div>
  </div>
  <div class="row ">
   <div class="col col--6" >
      <Card heading="5. Basic Features" link="/android/guide/video-and-audio-calling-api-sdk/features/start-join-meeting" description="Explore basic features such as join, leave and customise sessions."  />
    </div>
    <div class="col col--6">
      <Card heading="6. Advanced Features" link="/android/guide/video-and-audio-calling-api-sdk/features/error-event" description="Explore advanced features such as screen sharing, recording and live streaming." />
    </div>
  </div>
</div>

## Architecture

This diagram demonstrates end-to-end flow to implement video & audio calling, record calls and go-live on social media.

![Video-sdk-architecture!](/img/video-sdk-archietecture.svg)


---

---
title: Active Speaker Indication | Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: Speaker Indication features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Active Speaker Indication
pagination_label: Active Speaker Indication
keywords:
  - Active Speaker
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: active-speaker-indication
---

# Active Speaker Indication - Android

Active Speaker indication feature in VideoSDK let you know, which participant in a meeting is active speaker. This feature can be particularly useful in larger meetings or webinars, where there may be many participants and it can be difficult to tell who is speaking.

Whenever any participant speaks in meeting, `onSpeakerChanged` event will trigger with the participant id of the active speaker.

For example, the meeting is running with **Alice** and **Bob**. Whenever any of them speaks, `onSpeakerChanged` event will trigger and return the speaker `participantId`.

### Event

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
private val meetingEventListener: MeetingEventListener = object : MeetingEventListener() {
    override fun onSpeakerChanged(participantId: String?) {
        Toast.makeText(this@MainActivity, "Active Speaker participantId" + participantId, Toast.LENGTH_SHORT).show();
        super.onSpeakerChanged(participantId)
    }
};
```

</TabItem>

<TabItem value="Java">

```js
private final MeetingEventListener meetingEventListener = new MeetingEventListener() {
    @Override
    public void onSpeakerChanged(String participantId) {
        Toast.makeText(MainActivity.this, "Active Speaker participantId" + participantId, Toast.LENGTH_SHORT).show();
        super.onSpeakerChanged(participantId);
    }
};
```

</TabItem>

</Tabs>

### API Reference

The API references for all the methods and events utilised in this guide are provided below.

- [onSpeakerChanged()](/android/api/sdk-reference/meeting-class/meeting-event-listener-class#onspeakerchanged)


---

---
title: Change Input/Output Device | Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: Speaker Indication features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Change Input/Output Device
pagination_label: Change Input/Output Device
keywords:
  - Active Speaker
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: change-input-output-device
---

# Change Input/Output Device - Android

During the meeting at any point a participant wishes to switch his/her audio or video device, it can be done using the below mentioned methods.

## Changing Input/Output Audio Device

### `getMics()`

- The `getMics()` method will return a list of all available microphones that are connected to the mobile device.

- This method will return a Set of `AppRTCAudioManager.AudioDevice`.

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
  private fun getMics(): MutableSet<AppRTCAudioManager.AudioDevice>? {
    //highlight-next-line
    val mics= meeting!!.mics
    return mics  // returns all connected mics
  }
```

</TabItem>

<TabItem value="Java">

```js
  private Set<AppRTCAudioManager.AudioDevice> getMics() {
    //highlight-next-line
    Set<AppRTCAudioManager.AudioDevice> mics = meeting.getMics();
    return mics; // returns all connected mics
  }
```

</TabItem>

</Tabs>

### `changeMic()`

- Participant can change the audio device using `changeMic(AppRTCAudioManager.AudioDevice device)` method of `Meeting` class.

- Parameters that can be passed to `changeMic` are

  | Audio Devices                                | Usage                        |
  | -------------------------------------------- | ---------------------------- |
  | AppRTCAudioManager.AudioDevice.BLUETOOTH     | For Bluetooth Device.        |
  | AppRTCAudioManager.AudioDevice.WIRED_HEADSET | For Wired Handset Device.    |
  | AppRTCAudioManager.AudioDevice.SPEAKER_PHONE | For Inbuilt - Speaker Device |
  | AppRTCAudioManager.AudioDevice.EARPIECE      | For Earpiece Device          |

- When participant changes the Mic, `AppRTCAudioManager.AudioManagerEvents()` is triggered which can be set to `Meeting` class by using `setAudioDeviceChangeListener()`.

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js

  btnChangeMic!!.setOnClickListener { _: View? ->
  // Change Mic during Meeting
  //highlight-next-line
    meeting!!.changeMic(AppRTCAudioManager.AudioDevice.BLUETOOTH)
  }

  private fun setAudioDeviceListeners() {
    //highlight-start
    meeting!!.setAudioDeviceChangeListener(object : AudioManagerEvents {
      override fun onAudioDeviceChanged(
        selectedAudioDevice: AppRTCAudioManager.AudioDevice,
        availableAudioDevices: Set<AppRTCAudioManager.AudioDevice>
      ) {
          when (selectedAudioDevice) {
            AppRTCAudioManager.AudioDevice.BLUETOOTH ->
              Toast.makeText(this@MainActivity, "Selected AudioDevice: BLUETOOTH", Toast.LENGTH_SHORT).show()

            AppRTCAudioManager.AudioDevice.WIRED_HEADSET ->
              Toast.makeText(this@MainActivity, "Selected AudioDevice: WIRED_HEADSET", Toast.LENGTH_SHORT).show()

            AppRTCAudioManager.AudioDevice.SPEAKER_PHONE ->
              Toast.makeText(this@MainActivity, "Selected AudioDevice: SPEAKER_PHONE", Toast.LENGTH_SHORT).show()

            AppRTCAudioManager.AudioDevice.EARPIECE ->
              Toast.makeText(this@MainActivity, "Selected AudioDevice: EARPIECE", Toast.LENGTH_SHORT).show()
          }
        }
    })
    //highlight-end
  }

  override fun onCreate(savedInstanceState: Bundle?) {
       // ...
       setAudioDeviceListeners()
  }
```

</TabItem>

<TabItem value="Java">

```js
  btnChangeMic.setOnClickListener(new View.OnClickListener() {
      @Override
      public void onClick(View v) {
        // Change Mic during Meeting
        //highlight-next-line
        meeting.changeMic(AppRTCAudioManager.AudioDevice.BLUETOOTH);
      }
  });

  private void setAudioDeviceListeners() {
    //highlight-start
    meeting.setAudioDeviceChangeListener(new AppRTCAudioManager.AudioManagerEvents() {
         @Override
        public void onAudioDeviceChanged(AppRTCAudioManager.AudioDevice selectedAudioDevice, Set<AppRTCAudioManager.AudioDevice> availableAudioDevices) {
            switch (selectedAudioDevice) {
                case BLUETOOTH:
                  Toast.makeText(MainActivity.this, "Selected AudioDevice: BLUETOOTH", Toast.LENGTH_SHORT).show();
                  break;
                case WIRED_HEADSET:
                  Toast.makeText(MainActivity.this, "Selected AudioDevice: WIRED_HEADSET", Toast.LENGTH_SHORT).show();
                  break;
                case SPEAKER_PHONE:
                  Toast.makeText(MainActivity.this, "Selected AudioDevice: SPEAKER_PHONE", Toast.LENGTH_SHORT).show();
                  break;
                case EARPIECE:
                  Toast.makeText(MainActivity.this, "Selected AudioDevice: EARPIECE", Toast.LENGTH_SHORT).show();
                  break;
               }
        }
    });
    //highlight-end
  }

  @Override
    protected void onCreate(Bundle savedInstanceState) {
       // ...
       setAudioDeviceListeners();
    }
```

</TabItem>

</Tabs>

- To use Bluetooth device, you must declare `BLUETOOTH` permission in `AndroidManifest.xml` file.

```js
<manifest ... >
//...
<uses-permission android:name="android.permission.BLUETOOTH" />
<uses-permission android:name="android.permission.BLUETOOTH_ADMIN" />
<uses-permission android:name="android.permission.BLUETOOTH_CONNECT" />
</manifest>
```

## Changing Camera Input Device

### `changeWebcam()`

- By using `changeWebcam()` function, a participant can stream from front / rear camera during the meeting.

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
  btnWebcam!!.setOnClickListener {
    // Change Webcam during Meeting
    //highlight-next-line
    meeting!!.changeWebcam()
  }
```

</TabItem>

<TabItem value="Java">

```js
  btnWebcam.setOnClickListener(new View.OnClickListener() {
      @Override
      public void onClick(View v) {
        // Change Webcam during Meeting
        //highlight-next-line
        meeting.changeWebcam();
      }
  });
```

</TabItem>

</Tabs>

### API Reference

The API references for all the methods and events utilised in this guide are provided below.

- [getMics()](/android/api/sdk-reference/meeting-class/methods#getmics)
- [changeMic()](/android/api/sdk-reference/meeting-class/methods#changemic)
- [changeWebcam()](/android/api/sdk-reference/meeting-class/methods#changewebcam)


---

---
title: Image Capturer | Video SDK
hide_title: true
hide_table_of_contents: false
description: Stream Image Capturer.
sidebar_label: Image Capturer
pagination_label: Image Capturer
keywords:
  - image capturer
  - stream image capturer
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: image-capturer
--- 

# Image Capturer - Android

This guide provides instructions on capturing images of participants from a video stream. 

This capability proves particularly valuable in Video KYC scenarios, enabling the capture of images where users can hold up their identity for verification.

### `captureImage()`

- By using the `captureImage()` method of the `Participant` class, you can capture image of a local participant from their video stream.
- You have the option to specify the desired height and width in the `captureImage()` method; however, these parameters are optional. If not provided, the VideoSDK will automatically use the dimensions of the local participant's webcamStream. 
- You need to pass an implementation of `TaskCompletionListener` as a parameter in the `captureImage()` method. This listener will handle the result of the image capture task.
- When the image capture task is complete, the `onComplete()` method will provide the image in the form of a `base64` string. If an error occurs, the `onError()` method will provide the error details.

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
private fun imageCapture() {
  meeting!!.localParticipant.
    .captureImage(400, 400, object : TaskCompletionListener<String?, String?> {
      override fun onComplete(data: String?) {
          Log.d("VideoSDK", "capturedImage in base64 format: $data")
      }

      override fun onError(error: String?) {
          Log.d("VideoSDK", "Error in imageCapture $error")
      }
  })
}
```

</TabItem>

<TabItem value="Java">

```js
private void imageCapture() {
  meeting.getLocalParticipant().captureImage(400, 400, new TaskCompletionListener<String,String>() {
    @Override
    public void onComplete(@Nullable String data) {
        Log.d("VideoSDK", "capturedImage in base64 format: " + data);
    }

    @Override
    public void onError(@Nullable String error) {
        Log.d("VideoSDK", "Error in imageCapture " + error);
    }
  });
}
```

</TabItem>

</Tabs>


:::note

You can only capture an image of the local participant. If you called `captureImage()` method on a remote participant, you will receive an error. To capture an image of a remote participant, refer to the documentation below.

:::

### How to capture image of a remote participant ?

- Before proceeding, it's crucial to understand [VideoSDK's temporary file storage system](/android/guide/video-and-audio-calling-api-sdk/collaboration-in-meeting/upload-fetch-temporary-file) and the underlying [pubsub mechanism](/android/guide/video-and-audio-calling-api-sdk/collaboration-in-meeting/pubsub).

- Here's a break down of the steps, using the names Participant A and Participant B for clarity:

#### Step 1 : Initiate Image Capture Request

- In this step, you have to first send a request to Participant B, whose image you want to capture, using pubsub.
- In order to do that, you have to publish a message. Here, `IMAGE_CAPTURE` pubsub topic is used.
- Also, you will be using the `sendOnly` property of the `PubSubPublishOptions` class. Therefore, the request will be sent to that participant only.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
class MainActivity : AppCompatActivity() {

  //..
  
  private fun sendRequest(participantId: String) {
    if (participantId != meeting.localParticipant.id) {
      val publishOptions = PubSubPublishOptions()
      publishOptions.isPersist = false
      //highlight-start
      // Pass the participantId of the participant whose image you want to capture
      // Here, it will be Participant B's id, as you want to capture the the image of Participant B
      val sendOnly = arrayOf(participantId)
      publishOptions.setSendOnly(sendOnly)
      //highlight-end

      // send request to participant using the publish method
      //highlight-next-line
      meeting.pubSub.publish("IMAGE_CAPTURE", "Sending request to capture image", publishOptions)
    }
  }
}
```

</TabItem>

<TabItem value="Java">

```js
public class MainActivity extends AppCompatActivity {
 
  //...

  private void sendRequest(String participantId) {
    if (!participantId.equals(meeting.getLocalParticipant().getId())) {
      PubSubPublishOptions publishOptions = new PubSubPublishOptions();
      publishOptions.setPersist(false);
      //highlight-start
      // Pass the participantId of the participant whose image you want to capture
      // Here, it will be Participant B's id, as you want to capture the the image of Participant B
      String[] sendOnly = {participantId};
      publishOptions.setSendOnly(sendOnly);
      //highlight-end

      // send request to participant using the publish method
      //highlight-next-line
      meeting.pubSub.publish("IMAGE_CAPTURE", "Sending request to capture image", publishOptions);
    }
  }
}
```

</TabItem>

</Tabs>

#### Step 2 : Capture and Upload File

- To capture an image from a remote participant [Participant B], you will filter out the request from the `onMessageReceived` event of the `PubSubMessageListener`. For that, you need to subscribe to a topic called `IMAGE_CAPTURE`. When you receive an image capture request, you will capture the image using the `captureImage()` method of the `Participant` class.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
class MainActivity : AppCompatActivity() {
  override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    setContentView(R.layout.activity_main)

    //...

    // add listener to meeting
    //highlight-next-line
    meeting!!.addEventListener(meetingEventListener) 
  }

  private val meetingEventListener: MeetingEventListener = object : MeetingEventListener() {

    override fun onMeetingJoined() {
      Log.d("#meeting", "onMeetingJoined()")
      val pubSubMessageListener =
        PubSubMessageListener { message ->
          if (message.senderId != meeting!!.localParticipant.id) {
            //highlight-start
            // capture and store image when message received
            captureAndStoreImage(message.senderId)
            //highlight-end
          }
        }
      // subscribe for 'IMAGE_CAPTURE' topic to receive request
      //highlight-next-line
      meeting!!.pubSub.subscribe("IMAGE_CAPTURE", pubSubMessageListener)
    }

    //...
  }

  private fun captureAndStoreImage(senderId: String) {
    //highlight-start
    // capture image
    meeting!!.localParticipant
      .captureImage(object : TaskCompletionListener<String?, String?> {
        override fun onComplete(@Nullable base64Data: String?) {
            Log.d("VideoSDK", "capturedImage in base64 format: $base64Data")
        }

        override fun onError(@Nullable error: String?) {
            Log.d("VideoSDK", "Error in image capture: $error")
        }
    })
    //highlight-end
  }
}
```

</TabItem>

<TabItem value="Java">

```js
public class MainActivity extends AppCompatActivity {
 @Override
  protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);

    //...

    // add listener to meeting
    //highlight-next-line
    meeting.addEventListener(meetingEventListener);
  }

   private final MeetingEventListener meetingEventListener = new MeetingEventListener() {
      @Override
      public void onMeetingJoined() {
        Log.d("#meeting", "onMeetingJoined()");

        PubSubMessageListener pubSubMessageListener = new PubSubMessageListener() {
          @Override
          public void onMessageReceived(PubSubMessage message) {
            if (!message.getSenderId().equals(meeting.getLocalParticipant().getId())) 
            {
              //highlight-start
              // capture and store image when message received
              captureAndStoreImage(message.getSenderId());
              //highlight-end
            }
          }
        }  
        // subscribe for 'IMAGE_CAPTURE' topic to receive request
        //highlight-next-line
        meeting.pubSub.subscribe("IMAGE_CAPTURE", pubSubMessageListener);
      }

      //...
    };

  private void captureAndStoreImage(String senderId) {
    //highlight-start
    // capture image
    meeting.getLocalParticipant().captureImage(new TaskCompletionListener<String, String>() {
      @Override
      public void onComplete(@Nullable String base64Data) {   
        Log.d("VideoSDK", "capturedImage in base64 format: " + base64Data);    
      }

      @Override
      public void onError(@Nullable String error) {
          Log.d("VideoSDK", "Error in image capture: " + error);
      }
    });
    //highlight-end
  }
}
```

</TabItem>

</Tabs>

- After capturing the image of the remote participant, you need to store this image in VideoSDK's temporary file storage system. This will allow you to send the image to the participant who initiated the request.
- Utilize the `uploadBase64File()` method of the `Meeting` class to store the captured image in VideoSDK's temporary file storage system.
- When the upload is complete, the `onComplete()` method of `TaskCompletionListener` will provide the corresponding `fileUrl`, which can be used to retrieve the uploaded file.
- If an error occurs during the upload process, the `onError()` method of `TaskCompletionListener` will provide the error details.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
class MainActivity : AppCompatActivity() {
  override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    setContentView(R.layout.activity_main)
    //...
  }

  private fun captureAndStoreImage(senderId: String) {
    // listener for file-upload
    val fileUploadListener: TaskCompletionListener<String, String> =
      object : TaskCompletionListener<String?, String?> {
        override fun onComplete(@Nullable fileUrl: String?) {
          //highlight-next-line
          Log.d("VideoSDK", "Uploaded file url: $fileUrl")
        }

        override fun onError(@Nullable error: String?) {
          Log.d("VideoSDK", "Error in upload file: $error")
        }
    }

    // capture image
    meeting!!.localParticipant
      .captureImage(object : TaskCompletionListener<String?, String?> {
        override fun onComplete(@Nullable base64Data: String?) {
          Log.d("VideoSDK", "capturedImage in base64 format: $base64Data")
          val token = "<VIDEOSDK_TOKEN>"
          val fileName = "myCapture.jpeg" // specify a name for image file with extension
          //highlight-start
          // upload image to videosdk storage system
          meeting!!.uploadBase64File(base64Data, token, fileName, fileUploadListener)
          //highlight-end
        }

        override fun onError(@Nullable error: String?) {
            Log.d("VideoSDK", "Error in image capture: $error")
        }
      })
  }
}
```

</TabItem>

<TabItem value="Java">

```js
public class MainActivity extends AppCompatActivity {
  @Override
  protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);
    //...
  }

  private void captureAndStoreImage(String senderId) {
    // listener for file-upload
    TaskCompletionListener<String, String> fileUploadListener = new TaskCompletionListener<>() {
      @Override
      public void onComplete(@Nullable String fileUrl) {
        //highlight-next-line
        Log.d("VideoSDK", "Uploaded file url: " + fileUrl);
      }

      @Override
      public void onError(@Nullable String error) {
        Log.d("VideoSDK", "Error in upload file: " + error);
      }
    };

    // capture image
    meeting.getLocalParticipant().captureImage(new TaskCompletionListener<String, String>() {
        @Override
        public void onComplete(@Nullable String base64Data) {   
          Log.d("VideoSDK", "capturedImage in base64 format: " + base64Data); 
          String token = "<VIDEOSDK_TOKEN>";
          String fileName = "myCapture.jpeg"; // specify a name for image file with extension
          //highlight-start
          // upload image to videosdk storage system
          meeting.uploadBase64File(base64Data, token, fileName, fileUploadListener); 
          //highlight-end 
        }

        @Override
        public void onError(@Nullable String error) {
            Log.d("VideoSDK", "Error in image capture: " + error);
        }
    });
  }
}
```

</TabItem>

</Tabs>


- Next, the `fileUrl` is sent back to the participant who initiated the request using the `IMAGE_TRANSFER` topic.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
class MainActivity : AppCompatActivity() {

  //..
  
  private fun captureAndStoreImage(senderId: String) {
    // listener for file-upload
    val fileUploadListener: TaskCompletionListener<String, String> =
      object : TaskCompletionListener<String?, String?> {
        override fun onComplete(@Nullable fileUrl: String?) {
          //highlight-start
          Log.d("VideoSDK", "Uploaded file url: $fileUrl")
          imageTransfer(fileUrl, senderId)
          //highlight-end
        }

        override fun onError(@Nullable error: String?) {
          Log.d("VideoSDK", "Error in upload file: $error")
        }
    }

    //...
  }

  private fun imageTransfer(fileUrl: String?, senderId: String) {
    val publishOptions = PubSubPublishOptions()
    publishOptions.isPersist = false
    //highlight-start
    // Pass the participantId who initiated the request
    val sendOnly = arrayOf(senderId)
    publishOptions.setSendOnly(sendOnly)
    //highlight-end

    // send fileUrl to the participant who request for image using the publish method
    //highlight-next-line
    meeting!!.pubSub.publish("IMAGE_TRANSFER", fileUrl, publishOptions)
  }
}
```

</TabItem>

<TabItem value="Java">

```js
public class MainActivity extends AppCompatActivity {

  //...

  private void captureAndStoreImage(String senderId) {
      // listener for file-upload
      TaskCompletionListener<String, String> fileUploadListener = new TaskCompletionListener<>() {
          @Override
          public void onComplete(@Nullable String fileUrl) {
            //highlight-start
            Log.d("VideoSDK", "Uploaded file url: " + fileUrl);
            imageTransfer(fileUrl, senderId);
            //highlight-end
          }

          @Override
          public void onError(@Nullable String error) {
            Log.d("VideoSDK", "Error in upload file: " + error);
          }
      };

      //...

    }

    private void imageTransfer(String fileUrl,String senderId) {
      PubSubPublishOptions publishOptions = new PubSubPublishOptions();
      publishOptions.setPersist(false);
      //highlight-start
      // Pass the participantId who initiated the request
      String[] sendOnly = {senderId};
      publishOptions.setSendOnly(sendOnly);
      //highlight-end

      // send fileUrl to the participant who request for image using the publish method
      //highlight-next-line
      meeting.pubSub.publish("IMAGE_TRANSFER", fileUrl, publishOptions);
    }
}
```

</TabItem>

</Tabs>

#### Step 3 : Fetch and Display Image

- To display a captured image, the `showCapturedImage()` method is used. Here's how it works:

- Within the `showCapturedImage()` method, subscribe to the `IMAGE_TRANSFER` topic to receive the `fileUrl` associated with the captured image.

- Once the `fileUrl` is obtained, use the `fetchBase64File()` method from the `Meeting` class to retrieve the file in `base64` format from VideoSDK's temporary storage.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
class MainActivity : AppCompatActivity() {

  @Override
  protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);
    
    showCapturedImage()
  }
  
  private fun showCapturedImage() {
    val pubSubMessageListener =
      PubSubMessageListener { message: PubSubMessage ->
        if (message.senderId != meeting!!.localParticipant.id) {
          // fetch the image when message received
          val url = message.message
          val token = "<VIDEOSDK_TOKEN>"
          meeting!!.fetchBase64File(
            url,
            token,
            object : TaskCompletionListener<String?, String?> {
              override fun onComplete(@Nullable base64Data: String?) {
                  // here is your image in the form of base64
                  Log.d("VideoSDK", "Fetched file in base64:$base64Data")
                  // coverting base64 to bitmap to display an image in the imageView
                  val capturedImage =
                      findViewById<ImageView>(R.id.capturedImage)
                  val decodedString: ByteArray =
                      Base64.decode(base64Data, Base64.DEFAULT)
                  val decodedByte =
                      BitmapFactory.decodeByteArray(
                          decodedString,
                          0,
                          decodedString.size
                      )
                  capturedImage.setImageBitmap(decodedByte)
              }

              override fun onError(@Nullable error: String?) {
                  Log.d("VideoSDK", "Error in fetch file: $error")
              }
            }
          )
        }
      }

    // Subscribe for 'IMAGE_TRANSFER' topic to receive fileUrl
    meeting!!.pubSub.subscribe("IMAGE_TRANSFER", pubSubMessageListener)
  }
}
```

</TabItem>

<TabItem value="Java">

```js
public class MainActivity extends AppCompatActivity {
  @Override
  protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);

    //...
    
    showCapturedImage();
  }

  private void showCapturedImage(){
    PubSubMessageListener pubSubMessageListener = message -> {
      if (!message.getSenderId().equals(meeting.getLocalParticipant().getId())) {
        // fetch the image when message received
        String url = message.getMessage();
        String token = "<VIDEOSDK_TOKEN>";
        meeting.fetchBase64File(url, token, new TaskCompletionListener<String, String>() {
          @Override
          public void onComplete(@Nullable String base64Data) {
            // here is your image in the form of base64
            Log.d("VideoSDK", "Fetched file in base64:" + base64Data); 
            // coverting base64 to bitmap to display an image in the imageView
            ImageView capturedImage = findViewById(R.id.capturedImage);
            byte[] decodedString = Base64.decode(base64Data, Base64.DEFAULT);
            Bitmap decodedByte = BitmapFactory.decodeByteArray(decodedString, 0, decodedString.length);
            capturedImage.setImageBitmap(decodedByte);
          }

          @Override
          public void onError(@Nullable String error) {
              Log.d("VideoSDK", "Error in fetch file: " + error);
          }
        });
      }
    };

    // Subscribe for 'IMAGE_TRANSFER' topic to receive fileUrl
    meeting.pubSub.subscribe("IMAGE_TRANSFER", pubSubMessageListener);
  }
}
```

</TabItem>

</Tabs>

:::note

The file stored in the [VideoSDK's temporary file storage system](/react/guide/video-and-audio-calling-api-sdk/collaboration-in-meeting/upload-fetch-temporary-file) will be automatically deleted once the current room/meeting comes to an end.

:::

## API Reference

The API references for all the methods utilized in this guide are provided below.

- [captureImage()](/android/api/sdk-reference/participant-class/methods#captureimage)
- [pubSub()](/android/api/sdk-reference/pubsub-class/introduction)
- [uploadBase64File()](/android/api/sdk-reference/meeting-class/methods#uploadbase64file)
- [fetchBase64File()](/android/api/sdk-reference/meeting-class/methods#fetchbase64file)


---

---
title: Mute / Unmute Mic | Video SDK
hide_title: true
hide_table_of_contents: false
description: Mic Controls features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Mute / Unmute Mic
pagination_label: Mute / Unmute Mic
keywords:
  - audio calling
  - video calling
  - real-time communication
  - collaboration
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: mute-unmute-mic
---

# Mute / Unmute Mic - Android

Muting and Unmuting your microphone refers to turning your microphone off and on, respectively.

When you mute your microphone, you prevent any sound from your microphone from being transmitted to other meeting participants, while unmuting it allows others to hear you.

### `unmuteMic()`

- By using `unmuteMic()` function of `Meeting` class, local participant can publish audio to other participants.

  - You can call this method when the local participant is not broadcasting any audio to others.

- You can pass customised audio track in `unmuteMic()` by using [Custom Audio Track](/android/guide/video-and-audio-calling-api-sdk/render-media/optimize-audio-track).

- Audio stream of the participant can be accessed from the `onStreamEnabled` event of `ParticipantEventListener`.

### `muteMic()`

- By using `muteMic()` function of `Meeting` class, local participant can stop publish audio to other participants.

- You can call this method when the local participant is broadcasting any audio to others.

#### Example

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
  private var micEnabled = false

  btnMic!!.setOnClickListener { _: View? ->
     if (micEnabled) {
      // Muting Mic
      //highlight-next-line
       meeting!!.muteMic()
       micEnabled=false
     } else {
      // Unmuting Mic
      //highlight-next-line
      meeting!!.unmuteMic()
      micEnabled=true
     }
  }
```

</TabItem>

<TabItem value="Java">

```js
  private boolean micEnabled = false;

  btnMic.setOnClickListener(new View.OnClickListener() {
      @Override
      public void onClick(View v) {
          if (micEnabled) {
              // Muting Mic
              //highlight-next-line
              meeting.muteMic();
              micEnabled = false;
          } else {
            // Unmuting Mic
            //highlight-next-line
              meeting.unmuteMic();
              micEnabled = true;
          }
      }
  });
```

</TabItem>

</Tabs>

### Events associated with `unmuteMic`

- Every Participant will receive a callback on [`onStreamEnabled()`](/android/api/sdk-reference/participant-class/participant-event-listener-class#onstreamenabled) of the [`Participant`](/android/api/sdk-reference/participant-class/introduction) with `Stream` object.

### Events associated with `muteMic`

- Every Participant will receive a callback on [`onStreamDisabled()`](/android/api/sdk-reference/participant-class/participant-event-listener-class#onstreamdisabled) of the [`Participant`](/android/api/sdk-reference/participant-class/introduction) with `Stream` object.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
  meeting!!.localParticipant.addEventListener(object : ParticipantEventListener() {
    //Callback for when the participant starts a stream
    //highlight-start
    override fun onStreamEnabled(stream: Stream) {
        if(stream.getKind().equals("audio")){
          Log.d("VideoSDK","Audio Stream On: onStreamEnabled $stream");
        }
    }
    //highlight-end

    //Callback for when the participant stops a stream
    //highlight-start
    override fun onStreamDisabled(stream: Stream) {
        if(stream.getKind().equals("audio")){
          Log.d("VideoSDK","Audio Stream On: onStreamDisabled $stream");
        }
    }
    //highlight-end
  });
```

</TabItem>

<TabItem value="Java">

```js
  participant.addEventListener(new ParticipantEventListener() {
    //Callback for when the participant starts a stream
    //highlight-start
    @Override
    public void onStreamEnabled(Stream stream) {
        if(stream.getKind().equals("audio")){
          Log.d("VideoSDK","Audio Stream On: onStreamEnabled" + stream);
        }
    }
    //highlight-end

    //Callback for when the participant stops a stream
    //highlight-start
    @Override
    public void onStreamDisabled(Stream stream) {
        if(stream.getKind().equals("audio")){
          Log.d("VideoSDK","Audio Stream Off: onStreamDisabled" + stream);
        }
    }
    //highlight-end
  });
```

</TabItem>

</Tabs>

### Audio Permissions

- To use the microphone in a meeting, you need to add permission in `app/src/main/AndroidManifest.xml` after `</application>`.

```xml title="AndroidManifest.xml"
<uses-permission android:name="android.permission.RECORD_AUDIO" />
```

- You need to set up a permission request that provides this access.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
import android.Manifest
import android.content.pm.PackageManager
import android.os.Bundle
import android.widget.Toast
import androidx.appcompat.app.AppCompatActivity
import androidx.core.app.ActivityCompat
import androidx.core.content.ContextCompat

class MainActivity : AppCompatActivity() {
    private val PERMISSION_REQUEST_CODE: Int = 1;

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        //highlight-start
        if (checkPermission()) {
            // . write your main code to execute, It will execute if the permission is already given.
        } else {
            requestPermission()
        }
        //highlight-end
    }
    private fun checkPermission(): Boolean {
        //highlight-next-line
        return ContextCompat.checkSelfPermission(this, Manifest.permission.RECORD_AUDIO) == PackageManager.PERMISSION_GRANTED
    }

    private fun requestPermission() {
      //highlight-start
        ActivityCompat.requestPermissions(
            this, arrayOf(Manifest.permission.RECORD_AUDIO),
            PERMISSION_REQUEST_CODE
        )
      //highlight-end
    }

    override
    fun onRequestPermissionsResult(
        requestCode: Int,
        permissions: Array<out String>,
        grantResults: IntArray
    ) {
        super.onRequestPermissionsResult(requestCode, permissions, grantResults)
        when (requestCode) {
            PERMISSION_REQUEST_CODE -> if (grantResults.isNotEmpty() && grantResults[0] == PackageManager.PERMISSION_GRANTED) {
                Toast.makeText(applicationContext, "Permission Granted", Toast.LENGTH_SHORT).show()
                // main logic
            } else {
                Toast.makeText(applicationContext, "Permission Denied", Toast.LENGTH_SHORT).show()
            }
        }
    }
}
```

</TabItem>

<TabItem value="Java">

```js
import androidx.annotation.NonNull;
import androidx.appcompat.app.AppCompatActivity;
import androidx.core.app.ActivityCompat;
import androidx.core.content.ContextCompat;

import android.Manifest;
import android.content.pm.PackageManager;
import android.os.Bundle;
import android.widget.Toast;

import java.util.ArrayList;
import java.util.List;

public class MainActivity extends AppCompatActivity {

    private static final int PERMISSION_REQUEST_CODE = 1;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        //highlight-start
        if (checkPermission()) {
            // . write your main code to execute, It will execute if the permission is already given.
        } else {
            requestPermission();
        }
        //highlight-end
    }

    private boolean checkPermission() {
        //highlight-next-line
        return ContextCompat.checkSelfPermission(this, Manifest.permission.RECORD_AUDIO) == PackageManager.PERMISSION_GRANTED;
    }

    private void requestPermission() {
        List<String> permissionList = new ArrayList<String>();
        String[] permissions = {};
        permissionList.add(Manifest.permission.RECORD_AUDIO);
        //highlight-start
        ActivityCompat.requestPermissions(
                this, permissionList.toArray(permissions),
                PERMISSION_REQUEST_CODE
        );
        //highlight-end
    }

    @Override
    public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
        super.onRequestPermissionsResult(requestCode, permissions, grantResults);
        switch (requestCode) {
            case PERMISSION_REQUEST_CODE:
                if (grantResults.length > 0 && grantResults[0] == PackageManager.PERMISSION_GRANTED) {
                    Toast.makeText(MainActivity.this, "Permission Granted", Toast.LENGTH_SHORT).show();
                    // main logic
                } else {
                    Toast.makeText(MainActivity.this, "Permission Denied", Toast.LENGTH_SHORT).show();
                }
                break;
        }
    }
}
```

</TabItem>

</Tabs>

### API Reference

The API references for all the methods and events utilised in this guide are provided below.

- [unmuteMic()](/android/api/sdk-reference/meeting-class/methods#unmutemic)
- [muteMic()](/android/api/sdk-reference/meeting-class/methods#mutemic)
- [onStreamEnabled()](/android/api/sdk-reference/participant-class/participant-event-listener-class#onstreamenabled)
- [onStreamDisabled()](/android/api/sdk-reference/participant-class/participant-event-listener-class#onstreamdisabled)


---

---
title: On / Off Camera | Video SDK
hide_title: true
hide_table_of_contents: false
description: Camera Controls features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: On / Off Camera
pagination_label: On / Off Camera
keywords:
  - audio calling
  - video calling
  - real-time communication
  - collaboration
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: on-off-camera
---

# On / Off Camera - Android

Any participant can turn on or off his camera in the meeting using below methods.

### `enableWebcam()`

- By using `enableWebcam()` function of `Meeting` class, local participant can publish video to other participants.

- You can call this method when the local participant is not broadcasting any video to others.

- You can pass customised video track in `enableWebcam()` by using [Custom Video Track](/android/guide/video-and-audio-calling-api-sdk/render-media/optimize-video-track#custom-video-track).

- Video stream of the participant can be accessed from the `onStreamEnabled` event of `ParticipantEventListener`.

### `disableWebcam()`

- By using `disableWebcam()` function of `Meeting` class, local participant can stop publish video to other participants.

- You can call this method when the local participant is broadcasting any video to others.

#### Example

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
  btnWebcam!!.setOnClickListener {
    if (webcamEnabled) {
      // Disabling camera
      //highlight-next-line
      meeting!!.disableWebcam()
    } else {
      // Enabling camera
      //highlight-next-line
      meeting!!.enableWebcam()
    }
    webcamEnabled=!webcamEnabled
  }
```

</TabItem>

<TabItem value="Java">

```js
  btnWebcam.setOnClickListener(new View.OnClickListener() {
      @Override
      public void onClick(View v) {
        if (webcamEnabled) {
          // Disabling camera
          //highlight-next-line
          meeting.disableWebcam();
        } else {
          // Enabling camera
          //highlight-next-line
          meeting.enableWebcam();
        }
        webcamEnabled=!webcamEnabled;
      }
  });
```

</TabItem>

</Tabs>

:::important
To learn, how to render video in the meeting, [follow this](/android/guide/video-and-audio-calling-api-sdk/render-media/display-video/render-participant) detailed guide.
:::

### Events associated with `enableWebcam`

- Every Participant will receive a callback on [`onStreamEnabled()`](/android/api/sdk-reference/participant-class/participant-event-listener-class#onstreamenabled) of the [`Participant`](/android/api/sdk-reference/participant-class/introduction) with `Stream` object.

### Events associated with `disableWebcam`

- Every Participant will receive a callback on [`onStreamDisabled()`](/android/api/sdk-reference/participant-class/participant-event-listener-class#onstreamdisabled) of the [`Participant`](/android/api/sdk-reference/participant-class/introduction) with `Stream` object.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
  meeting!!.localParticipant.addEventListener(object : ParticipantEventListener() {
    //Callback for when the participant starts a stream
    //highlight-start
    override fun onStreamEnabled(stream: Stream) {
        if(stream.getKind().equals("video")){
          Log.d("VideoSDK","Video Stream On: onStreamEnabled $stream");
        }
    }
    //highlight-end

    //Callback for when the participant stops a stream
    //highlight-start
    override fun onStreamDisabled(stream: Stream) {
        if(stream.getKind().equals("video")){
          Log.d("VideoSDK","Video Stream On: onStreamDisabled $stream");
        }
    }
    //highlight-end
  });
```

</TabItem>

<TabItem value="Java">

```js
  participant.addEventListener(new ParticipantEventListener() {
    //Callback for when the participant starts a stream
    //highlight-start
    @Override
    public void onStreamEnabled(Stream stream) {
        if(stream.getKind().equals("video")){
          Log.d("VideoSDK","Video Stream On: onStreamEnabled" + stream);
        }
    }
    //highlight-end

    //Callback for when the participant stops a stream
    //highlight-start
    @Override
    public void onStreamDisabled(Stream stream) {
        if(stream.getKind().equals("video")){
          Log.d("VideoSDK","Video Stream Off: onStreamDisabled" + stream);
        }
    }
    //highlight-end
  });
```

</TabItem>

</Tabs>

### Video Permissions

- To use the camera in a meeting, you need to add permission in `app/src/main/AndroidManifest.xml` after `</application>`.

```xml title="AndroidManifest.xml"
<uses-permission android:name="android.permission.CAMERA" />
```

- You need to set up a permission request that provides this access.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
import android.Manifest
import android.content.pm.PackageManager
import android.os.Bundle
import android.widget.Toast
import androidx.appcompat.app.AppCompatActivity
import androidx.core.app.ActivityCompat
import androidx.core.content.ContextCompat

class MainActivity : AppCompatActivity() {
    private val PERMISSION_REQUEST_CODE: Int = 1;

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        //highlight-start
        if (checkPermission()) {
            // . write your main code to execute, It will execute if the permission is already given.
        } else {
            requestPermission()
        }
        //highlight-end
    }
    private fun checkPermission(): Boolean {
        //highlight-next-line
        return ContextCompat.checkSelfPermission(this, Manifest.permission.CAMERA) == PackageManager.PERMISSION_GRANTED
    }

    private fun requestPermission() {
      //highlight-start
        ActivityCompat.requestPermissions(
            this, arrayOf(Manifest.permission.CAMERA),
            PERMISSION_REQUEST_CODE
        )
      //highlight-end
    }

    override
    fun onRequestPermissionsResult(
        requestCode: Int,
        permissions: Array<out String>,
        grantResults: IntArray
    ) {
        super.onRequestPermissionsResult(requestCode, permissions, grantResults)
        when (requestCode) {
            PERMISSION_REQUEST_CODE -> if (grantResults.isNotEmpty() && grantResults[0] == PackageManager.PERMISSION_GRANTED) {
                Toast.makeText(applicationContext, "Permission Granted", Toast.LENGTH_SHORT).show()
                // main logic
            } else {
                Toast.makeText(applicationContext, "Permission Denied", Toast.LENGTH_SHORT).show()
            }
        }
    }
}
```

</TabItem>

<TabItem value="Java">

```js
import androidx.annotation.NonNull;
import androidx.appcompat.app.AppCompatActivity;
import androidx.core.app.ActivityCompat;
import androidx.core.content.ContextCompat;

import android.Manifest;
import android.content.pm.PackageManager;
import android.os.Bundle;
import android.widget.Toast;

import java.util.ArrayList;
import java.util.List;

public class MainActivity extends AppCompatActivity {

    private static final int PERMISSION_REQUEST_CODE = 1;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        //highlight-start
        if (checkPermission()) {
            // . write your main code to execute, It will execute if the permission is already given.
        } else {
            requestPermission();
        }
        //highlight-end
    }

    private boolean checkPermission() {
        //highlight-next-line
        return ContextCompat.checkSelfPermission(this, Manifest.permission.CAMERA) == PackageManager.PERMISSION_GRANTED;
    }

    private void requestPermission() {
        List<String> permissionList = new ArrayList<String>();
        String[] permissions = {};
        permissionList.add(Manifest.permission.CAMERA);
        //highlight-start
        ActivityCompat.requestPermissions(
                this, permissionList.toArray(permissions),
                PERMISSION_REQUEST_CODE
        );
        //highlight-end
    }

    @Override
    public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
        super.onRequestPermissionsResult(requestCode, permissions, grantResults);
        switch (requestCode) {
            case PERMISSION_REQUEST_CODE:
                if (grantResults.length > 0 && grantResults[0] == PackageManager.PERMISSION_GRANTED) {
                    Toast.makeText(MainActivity.this, "Permission Granted", Toast.LENGTH_SHORT).show();
                    // main logic
                } else {
                    Toast.makeText(MainActivity.this, "Permission Denied", Toast.LENGTH_SHORT).show();
                }
                break;
        }
    }
}
```

</TabItem>

</Tabs>

:::important
If the app goes to the background, VideoSDK detectes this event based on activity lifecycle and release the camera so that it can be used by other apps. In order to make sure this functionality works properly use  `VideoSDK.setActivityForLifeCycle(activity)` to specify which activity VideoSDK should monitor for lifecycle changes.
:::

### API Reference

The API references for all the methods and events utilised in this guide are provided below.

- [enableWebcam()](/android/api/sdk-reference/meeting-class/methods#enablewebcam)
- [disableWebcam()](/android/api/sdk-reference/meeting-class/methods#disablewebcam)
- [onStreamEnabled()](/android/api/sdk-reference/participant-class/participant-event-listener-class#onstreamenabled)
- [onStreamDisabled()](/android/api/sdk-reference/participant-class/participant-event-listener-class#onstreamdisabled)


---

---
title: Screen Share | Video SDK
hide_title: true
hide_table_of_contents: false
description: Share your Screen features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Screen Share
pagination_label: Screen Share
keywords:
  - audio calling
  - video calling
  - real-time communication
  - collaboration
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: screen-share
---

# Screen Share - Android

Screen sharing in a meeting is the process of sharing your mobile screen with other participants in the meeting. It allows everyone in the meeting to see exactly what you are seeing on your screen, which can be helpful for presentations, demonstrations, or collaborations.

## How Screen share works?

- The following diagram shows flow of the screen sharing in android using VideoSDK :

<div style={{textAlign: 'center'}}>

![VideoSDK Android Screenshare Flow Diagram](/img/android/screenshare/flow_diagram.png)

</div>

### `enableScreenShare()`

- By using `enableScreenShare()` function of `Meeting` class, local participant can share his/her mobile screen to other participants.

- You can pass customised screenshare track in `enableScreenShare()` by using [Custom Screen Share Track](/android/guide/video-and-audio-calling-api-sdk/render-media/optimize-video-track#custom-screen-share-track).

- Screen Share stream of the participant can be accessed from the `onStreamEnabled` event of `ParticipantEventListener`.

### Screenshare permission

- A participant’s Screen share stream is provided via the `MediaProjection` API. This API is only compatible with `Build.VERSION_CODES.LOLLIPOP` or higher.

- Get an instance of the `MediaProjectionManager` and Call the `createScreenCaptureIntent()` method in an activity. This initiates a prompt dialog for the user to confirm screen projection.

- One will get a prompt dialog like this:

<div style={{textAlign: 'center'}}>

<img
src={require('/img/android/screenshare/user_permission.jpg').default}
alt="user permission"
width="450"
/>

</div>

<br/>

- After permission is received from the user, you can call `enableScreenShare()` method.

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
private fun enableScreenShare() {
    val mediaProjectionManager = application.getSystemService(
        MEDIA_PROJECTION_SERVICE
    ) as MediaProjectionManager
    startActivityForResult(
        mediaProjectionManager.createScreenCaptureIntent(), CAPTURE_PERMISSION_REQUEST_CODE
    )
}

public override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) {
    super.onActivityResult(requestCode, resultCode, data)
    if (requestCode != CAPTURE_PERMISSION_REQUEST_CODE) return
    if (resultCode == RESULT_OK) {
        // Enabling screen share
        //highlight-next-line
        meeting!!.enableScreenShare(data)
    }
}
```

</TabItem>

<TabItem value="Java">

```js
private void enableScreenShare() {
    MediaProjectionManager mediaProjectionManager =
        (MediaProjectionManager) getApplication().getSystemService(
            Context.MEDIA_PROJECTION_SERVICE);
    startActivityForResult(
        mediaProjectionManager.createScreenCaptureIntent(), CAPTURE_PERMISSION_REQUEST_CODE);
}

@Override
public void onActivityResult(int requestCode, int resultCode, Intent data) {
    super.onActivityResult(requestCode, resultCode, data);
    if (requestCode != CAPTURE_PERMISSION_REQUEST_CODE)
        return;
    if (resultCode == Activity.RESULT_OK) {
        // Enabling screen share
        //highlight-next-line
        meeting.enableScreenShare(data);
    }
}
```

</TabItem>

</Tabs>

### Customise notification

- When a presenter starts screen share, presenter will receive a notification with a pre-defined title and message.

- Notification with pre-defined title and message will look like this:

<div style={{textAlign: 'center'}}>

<img
src={require('/img/android/screenshare/notification.jpg').default}
alt="notification"
width="450"
/>

</div>

- You can Customise those title, message and icon as per your requirements using `<meta-data>` specified in `app/src/main/AndroidManifest.xml`.

```js
<application>
  <meta-data
    android:name="notificationTitle"
    //highlight-next-line
    android:value="@string/notificationTitle"
  />
  <meta-data
    android:name="notificationContent"
    //highlight-next-line
    android:value="@string/notificationContent"
  />
  <meta-data
    android:name="notificationIcon"
    //highlight-next-line
    android:resource="@mipmap/ic_launcher_round"
  />
</application>
```

### `disableScreenShare()`

- By using `disableScreenShare()` function of `Meeting` class, local participant can stop sharing his/her mobile screen to other participants.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
private fun disableScreenShare() {
    // Disabling screen share
    //highlight-next-line
    meeting!!.disableScreenShare()
}
```

</TabItem>

<TabItem value="Java">

```js
private void disableScreenShare(){
    // Disabling screen share
    //highlight-next-line
    meeting.disableScreenShare();
}
```

</TabItem>

</Tabs>

### Events associated with enableScreenShare

- Participant who share their mobile screen will receive a callback on [`onStreamEnabled()`](/android/api/sdk-reference/participant-class/participant-event-listener-class#onstreamenabled) of the [`Participant`](/android/api/sdk-reference/participant-class/introduction) with `Stream` object.

- While other Participants will receive [`onPresenterChanged()`](/android/api/sdk-reference/meeting-class/meeting-event-listener-class#onpresenterchanged) callback of the [`Meeting`](/android/api/sdk-reference/meeting-class/introduction) class with the participantId as `presenterId` who started the screen share.

### Events associated with disableScreenShare

- Participant who shared their mobile screen will receive a callback on [`onStreamDisabled()`](/android/api/sdk-reference/participant-class/participant-event-listener-class#onstreamdisabled) of the [`Participant`](/android/api/sdk-reference/participant-class/introduction) with `Stream` object.

- While other Participants will receive [`onPresenterChanged()`](/android/api/sdk-reference/meeting-class/meeting-event-listener-class#onpresenterchanged) callback of the [`Meeting`](/android/api/sdk-reference/meeting-class/introduction) class with the `presenterId` as `null` indicating there is no presenter.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
private fun setLocalListeners() {
    meeting!!.localParticipant.addEventListener(object : ParticipantEventListener() {
        //Callback for when the participant starts a stream
        //highlight-start
        override fun onStreamEnabled(stream: Stream) {
           if (stream.kind.equals("share", ignoreCase = true)) {
              Log.d("VideoSDK","Share Stream On: onStreamEnabled $stream");
            }
        }
        //highlight-end

        //Callback for when the participant stops a stream
        //highlight-start
        override fun onStreamDisabled(stream: Stream) {
            if (stream.kind.equals("share", ignoreCase = true)) {
               Log.d("VideoSDK","Share Stream On: onStreamDisabled $stream");
            }
        }
        //highlight-end
    });
}

private val meetingEventListener: MeetingEventListener = object : MeetingEventListener() {
    //Callback for when the presenter changes
    //highlight-start
    override fun onPresenterChanged(participantId: String) {
        if(!TextUtils.isEmpty(participantId))
        {
          Log.d("VideoSDK","$participantId started screen share");
        }else{
          Log.d("VideoSDK","some one stopped screen share");
        }
    }
    //highlight-end
}
```

</TabItem>

<TabItem value="Java">

```js
private void setLocalListeners() {
    meeting.getLocalParticipant().addEventListener(new ParticipantEventListener() {
        //Callback for when the participant starts a stream
        //highlight-start
        @Override
        public void onStreamEnabled(Stream stream) {
            if (stream.getKind().equalsIgnoreCase("share")) {
                Log.d("VideoSDK","Share Stream On: onStreamEnabled" + stream);
            }
        }
        //highlight-end

        //Callback for when the participant stops a stream
        //highlight-start
        @Override
        public void onStreamDisabled(Stream stream) {
            if (stream.getKind().equalsIgnoreCase("share")) {
                Log.d("VideoSDK","Share Stream Off: onStreamDisabled" + stream);
            }
        }
        //highlight-end
    });
}

private final MeetingEventListener meetingEventListener = new MeetingEventListener() {
    //Callback for when the presenter changes
    //highlight-start
    @Override
    public void onPresenterChanged(String participantId) {
      if(participantId != null){
        Log.d("VideoSDK",participantId + "started screen share");
      }else{
        Log.d("VideoSDK","some one stopped screen share");
      }
    }
    //highlight-end
};
```

</TabItem>

</Tabs>

### Rendering Screen Share Stream

- When a local participant shares their screen, the `onStreamEnabled()` function of the `ParticipantEventListener` is triggered, allowing the `Stream` to be added to a `VideoView`.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
private fun setLocalListeners() {
    meeting!!.localParticipant.addEventListener(object : ParticipantEventListener() {
        override fun onStreamEnabled(stream: Stream) {
           if (stream.kind.equals("share", ignoreCase = true)) {
                // display share video
                val videoTrack = stream.track as VideoTrack
                shareView!!.addTrack(videoTrack)
            }
        }
        override fun onStreamDisabled(stream: Stream) {
            if (stream.kind.equals("share", ignoreCase = true)) {
               shareView!!.removeTrack()
            }
        }
    });
}
```

</TabItem>

<TabItem value="Java">

```js
private void setLocalListeners() {
    meeting.getLocalParticipant().addEventListener(new ParticipantEventListener() {
        @Override
        public void onStreamEnabled(Stream stream) {
            if (stream.getKind().equalsIgnoreCase("share")) {
                // display share video
                VideoTrack videoTrack = (VideoTrack) stream.getTrack();
                shareView.addTrack(videoTrack);
            }
        }
        @Override
        public void onStreamDisabled(Stream stream) {
            if (stream.getKind().equalsIgnoreCase("share")) {
                shareView.removeTrack();
            }
        }
    });
}
```

</TabItem>

</Tabs>


- When another participant (excluding the local participant) shares their screen, the `onPresenterChanged()` function in the `MeetingEventListener` is triggered, providing the `participantId` of the screen sharer.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
private val meetingEventListener: MeetingEventListener = object : MeetingEventListener() {
    override fun onPresenterChanged(participantId: String) {
        updatePresenter(participantId)
    }
}

//Getting the stream from the participantId
private fun updatePresenter(participantId: String?) {
    // find participant
    val participant = meeting!!.participants.get(participantId) ?: return

    // find share stream in participant
    var shareStream: Stream? = null
    for (stream: Stream in participant.streams.values) {
        if ((stream.kind == "share")) {
            shareStream = stream
            break
        }
    }
    if (shareStream == null) return

    // display share video
    val videoTrack = shareStream.track as VideoTrack
    shareView!!.addTrack(videoTrack)

    // listen for share stop event
    participant.addEventListener(object : ParticipantEventListener() {
        override fun onStreamDisabled(stream: Stream) {
            if ((stream.kind == "share")) {
                shareView!!.removeTrack()
            }
        }
    })
}
```

</TabItem>

<TabItem value="Java">

```js
private final MeetingEventListener meetingEventListener = new MeetingEventListener() {
    //Triggered when Presenter changes
    @Override
    public void onPresenterChanged(String participantId) {
        updatePresenter(participantId);
    }
};

//Getting the stream from the participantId
private void updatePresenter(String participantId) {
    // find participant
    Participant participant = meeting.getParticipants().get(participantId);
    if (participant == null) return;

    // find share stream in participant
    Stream shareStream = null;
    for (Stream stream: participant.getStreams().values()) {
        if (stream.getKind().equals("share")) {
            shareStream = stream;
            break;
        }
    }
    if (shareStream == null) return;

    // display share video
    VideoTrack videoTrack = (VideoTrack) shareStream.getTrack();
    shareView.addTrack(videoTrack)

    // listen for share stop event
    participant.addEventListener(new ParticipantEventListener() {
        @Override
        public void onStreamDisabled(Stream stream) {
            if (stream.getKind().equals("share")) {
                shareView.removeTrack();
            }
        }
    });
}
```

</TabItem>

</Tabs>

:::info

- Here screenShare stream is displayed using `VideoView`, but you may also use `SurfaceViewRender` for the same.
- For `VideoView`, SDK version should be `0.1.13` or higher.
- To know more about `VideoView`, please visit [here](/android/guide/video-and-audio-calling-api-sdk/render-media/display-video/understand-videoView-component)

:::

### API Reference

The API references for all the methods and events utilised in this guide are provided below.

- [enableScreenShare()](/android/api/sdk-reference/meeting-class/methods#enablescreenshare)
- [disableScreenShare()](/android/api/sdk-reference/meeting-class/methods#disablescreenshare)
- [onStreamEnabled()](/android/api/sdk-reference/participant-class/participant-event-listener-class#onstreamenabled)
- [onStreamDisabled()](/android/api/sdk-reference/participant-class/participant-event-listener-class#onstreamdisabled)
- [onPresenterChanged()](/android/api/sdk-reference/meeting-class/meeting-event-listener-class#onpresenterchanged)


---

---
title: Integrating Android SDK - Video SDK
hide_title: false
hide_table_of_contents: false
description: Create customizable real-time video & audio calling applications with Android SDK with Video SDK add live Video & Audio conferencing to your applications.
sidebar_label: "Integrate Android SDK"
pagination_label: "Integrate Android SDK"
keywords:
  - android sdk
  - video call
  - audio call
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: integrate-sdk
---

Android SDK is a Java-based native SDK. It is compatible with both Java and Kotlin. It makes it extremely simple to integrate video and audio calls into your app.

### Installing Android SDK

#### Step 1: Add the repositories into your project

You can install our Android SDK by using Maven Central or [Jitpack](https://central.sonatype.com/artifact/live.videosdk/rtc-android-sdk/0.1.14) package repositories.

Add the repository to `settings.gradle` file in your project.

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Maven Central"
groupId={"android-repositories"}
values={[{label: 'Maven Central', value: 'Maven Central'},{label: 'Jitpack', value: 'Jitpack'},]}>

<TabItem value="Maven Central">

```js title="settings.gradle"
dependencyResolutionManagement{
  repositories {
    // ...
    google()
    mavenCentral()
    maven { url "https://maven.aliyun.com/repository/jcenter" }
  }
}
```

</TabItem>

<TabItem value="Jitpack">

```js title="settings.gradle"
dependencyResolutionManagement{
  repositories {
    // ...
    google()
    maven { url 'https://jitpack.io' }
    mavenCentral()
    maven { url "https://maven.aliyun.com/repository/jcenter" }
  }
}
```

</TabItem>

</Tabs>

:::note
You can use imports with Maven Central after rtc-android-sdk version `0.1.12`.

Whether on Maven or Jitpack, the same version numbers always refer to the same SDK.
:::

#### Step 2: Add the dependency in `app/build.gradle`

```js title="app/build.gradle"
dependencies {
		implementation 'live.videosdk:rtc-android-sdk:0.3.0'
		// other app dependencies
}
```





:::important

- Android SDK compatible with armeabi-v7a, arm64-v8a, x86_64 architectures. If you want to run the application in an emulator, choose ABI x86_64 when creating a device.

:::


---

---
sidebar_label: Known Issues
pagination_label: Known Issues
---

# Known Issues - Android

This page will let you updated with Android SDK known issues with better solution.

## Issue : 1

```
Missing Class kotlin.jvm.internal.SourceDebugExtension (referenced from: io.github.crow_misia.mediasoup.Consumer and 8 other contexts)
```

### Solution

To resolve the issue related to the missing class `kotlin.jvm.internal.SourceDebugExtension` when building an APK with ProGuard, you can follow these steps:

#### Step 1: Update Kotlin Version (Optional)

If you are using Kotlin version 1.7.20, consider upgrading it to version 1.8.0. This update may resolve the error you're facing. Check if your project is compatible with Kotlin 1.8.0 and update the Kotlin version in your project configuration accordingly.

#### Step 2: Modify proguard-rules.pro

Open the proguard-rules.pro file in your project and add the following rule:

```java
-dontwarn kotlin.jvm.internal.SourceDebugExtension
```

This rule tells ProGuard to suppress warnings related to the missing class "kotlin.jvm.internal.SourceDebugExtension". By adding this rule, the build process will no longer show the error associated with this class.


---

---
title: Custom Template
sidebar_position: 1
sidebar_label: Custom Template
hide_table_of_contents: false
---

import CustomTemplate from '../../../../../mdx/\_custom-template.mdx';

<CustomTemplate title="Custom Template With LiveStreaming"/>


---

---
title: Interactive Livestream - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: Interactive Livestream features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Interactive Livestream (HLS)
pagination_label: Interactive Livestream (HLS)
keywords:
  - Start HLS meeting
  - Stop HLS meeting
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: interactive-livestream
---

# Interactive Livestream (HLS) - Android

Interactive live streaming (HLS) refers to a type of live streaming where viewers can actively engage with the content being streamed and with other viewers in real-time.

In an interactive live stream (HLS), viewers can take part in a variety of activities like live polling, Q&A sessions, and even sending virtual gifts to the content creator or each other.

<center>

<img src='https://cdn.videosdk.live/website-resources/docs-resources/mobile_hls.png' />

</center>

VideoSDK also allows you to configure the interactive livestream layouts in numerous ways like by simply setting different prebuilt layouts in the configuration or by providing your own custom template to do the livestream according to your layout choice.

This guide will provide an overview of how to implement start and stop Interactive live streaming (HLS).

:::important

To initiate automatic Interactive live streaming (HLS) at the beginning of a `session`, simply provide the `autoStartConfig` feature `hls` during `room` creation. For more information on configuring the `autoStartConfig`, please refer to the provided documentation **[<u>here</u>](/api-reference/realtime-communication/create-room#autoStartConfig)**.

:::

### `startHls()`

`startHls()` can be used to start a interactive livestream of the meeting which can be accessed from the `Meeting` class. This method accepts two parameter:

- `config`: This parameter will define how the interactive livestream layout should look like.

- `transcription`: This parameter lets you start post transcription for the Livestreaming.

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
val config = JSONObject()

//highlight-next-line
// Layout Configuration
val layout = JSONObject()
JsonUtils.jsonPut(layout, "type", "GRID") // "SPOTLIGHT" | "SIDEBAR",  Default : "GRID"
JsonUtils.jsonPut(layout, "priority", "SPEAKER") // "PIN", Default : "SPEAKER"
JsonUtils.jsonPut(layout, "gridSize", 4) // MAX : 25
JsonUtils.jsonPut(config, "layout", layout)

//highlight-next-line
// Theme of interactive livestream layout
JsonUtils.jsonPut(config, "theme", "DARK") //  "LIGHT" | "DEFAULT"

//highlight-next-line
// `mode` is used to either interactive livestream video & audio both or only audio.
JsonUtils.jsonPut(config, "mode", "video-and-audio") // "audio", Default : "video-and-audio"

//highlight-next-line
// Quality of interactive livestream and is only applicable to `video-and-audio` type mode.
JsonUtils.jsonPut(config, "quality", "high") // "low" | "med",  Default : "med"

//highlight-start
// This mode refers to orientation of interactive livestream.
// landscape : Start interactive livestream of the meeting in horizontally
// portrait : Start interactive livestream of the meeting in vertically (Best for mobile view)
//highlight-end
JsonUtils.jsonPut(config, "orientation", "portrait") // "landscape",  Default : "landscape"

//highlight-next-line
// Post Transcription Configuration
val prompt = "Write summary in sections like Title, Agenda, Speakers, Action Items, Outlines, Notes and Summary"
val summaryConfig = SummaryConfig(true, prompt)
val modelId = "raman_v1"
val transcription = PostTranscriptionConfig(true, summaryConfig, modelId)

meeting.startHls(config, transcription)
```

</TabItem>

<TabItem value="Java">

```js
JSONObject config = new JSONObject();

//highlight-next-line
// Layout Configuration
JSONObject layout = new JSONObject();
JsonUtils.jsonPut(layout, "type", "GRID"); // "SPOTLIGHT" | "SIDEBAR",  Default : "GRID"
JsonUtils.jsonPut(layout, "priority", "SPEAKER");  // "PIN", Default : "SPEAKER"
JsonUtils.jsonPut(layout, "gridSize", 4); // MAX : 25
JsonUtils.jsonPut(config, "layout", layout);

//highlight-next-line
// Theme of interactive livestream layout
JsonUtils.jsonPut(config, "theme", "DARK"); //  "LIGHT" | "DEFAULT"

//highlight-next-line
// `mode` is used to either interactive livestream video & audio both or only audio.
JsonUtils.jsonPut(config, "mode", "video-and-audio"); // "audio", Default : "video-and-audio"

//highlight-next-line
// Quality of interactive livestream and is only applicable to `video-and-audio` type mode.
JsonUtils.jsonPut(config, "quality", "high"); // "low" | "med",  Default : "med"

//highlight-start
// This mode refers to orientation of interactive livestream.
// landscape : Start interactive livestream of the meeting in horizontally
// portrait : Start interactive livestream of the meeting in vertically (Best for mobile view)
//highlight-end
JsonUtils.jsonPut(config, "orientation", "portrait"); // "landscape",  Default : "landscape"

//highlight-next-line
// Post Transcription Configuration
String prompt = "Write summary in sections like Title, Agenda, Speakers, Action Items, Outlines, Notes and Summary";
SummaryConfig summaryConfig = new SummaryConfig(true, prompt);
String modelId = "raman_v1";
PostTranscriptionConfig transcription = new PostTranscriptionConfig(true, summaryConfig, modelId);

meeting.startHls(config, transcription);
```

</TabItem>

</Tabs>

### `stopHls()`

- `stopHls()` is used to stop interactive livestream of the meeting which can be accessed from the `Meeting` class.

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
// keep track of hls
val hls = false

findViewById<View>(R.id.btnHls).setOnClickListener { view: View? ->
  if (!hls) {
    //highlight-start
    val config = JSONObject()
    val layout = JSONObject()
    JsonUtils.jsonPut(layout, "type", "GRID")
    JsonUtils.jsonPut(layout, "priority", "SPEAKER")
    JsonUtils.jsonPut(layout, "gridSize", 4)
    JsonUtils.jsonPut(config, "layout", layout)
    JsonUtils.jsonPut(config, "theme", "DARK")
    JsonUtils.jsonPut(config, "mode", "video-and-audio")
    JsonUtils.jsonPut(config, "quality", "high")
    JsonUtils.jsonPut(config, "orientation", "portrait")
    //highlight-end

    //highlight-next-line
    // Post Transcription Configuration
    val prompt = "Write summary in sections like Title, Agenda, Speakers, Action Items, Outlines, Notes and Summary"
    val summaryConfig = SummaryConfig(true, prompt)
    val modelId = "raman_v1"
    val transcription = PostTranscriptionConfig(true, summaryConfig, modelId)

    // Start Hls
    //highlight-next-line
    meeting!!.startHls(config)
  } else {
    // Stop Hls
    //highlight-next-line
    meeting!!.stopHls()
  }
}
```

</TabItem>

<TabItem value="Java">

```js
// keep track of hls
boolean hls = false;

findViewById(R.id.btnHls).setOnClickListener(view -> {
  if (!hls) {
    //highlight-start
    JSONObject config = new JSONObject();
    JSONObject layout = new JSONObject();
    JsonUtils.jsonPut(layout, "type", "GRID");
    JsonUtils.jsonPut(layout, "priority", "SPEAKER");
    JsonUtils.jsonPut(layout, "gridSize", 4);
    JsonUtils.jsonPut(config, "layout", layout);
    JsonUtils.jsonPut(config, "theme", "DARK");
    JsonUtils.jsonPut(config, "mode", "video-and-audio");
    JsonUtils.jsonPut(config, "quality", "high");
    JsonUtils.jsonPut(config, "orientation", "portrait");
    //highlight-end

    //highlight-next-line
    // Post Transcription Configuration
    String prompt = "Write summary in sections like Title, Agenda, Speakers, Action Items, Outlines, Notes and Summary";
    SummaryConfig summaryConfig = new SummaryConfig(true, prompt);
    String modelId = "raman_v1";
    PostTranscriptionConfig transcription = new PostTranscriptionConfig(true, summaryConfig, modelId);

    // Start Hls
    //highlight-next-line
    meeting.startHls(config);
  } else {
    // Stop Hls
    //highlight-next-line
    meeting.stopHls();
  }
});
```

</TabItem>

</Tabs>

:::tip
If you want to learn more about the Interactive Livestream and how you can implement it in your own platform, you can checkout this [guide](/android/guide/interactive-live-streaming/integrate-hls/overview).
:::

### Event associated with HLS

- **onHlsStateChanged** - Whenever meeting HLS state changes, then `onHlsStateChanged` event will trigger.

- You can get the `playbackHlsUrl` and `livestreamUrl` of the HLS to play it on the Viewer side when the state changes to `HLS_PLAYABLE`.
  - `playbackHlsUrl` - Live HLS with playback support
  - `livestreamUrl` - Live HLS without playback support

:::note
`downstreamUrl` is now depecated. Use `playbackHlsUrl` or `livestreamUrl` in place of `downstreamUrl`
:::

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
private val meetingEventListener: MeetingEventListener = object : MeetingEventListener() {
  override fun onHlsStateChanged(HlsState: JSONObject) {
    when (HlsState.getString("status")) {
        "HLS_STARTING" -> Log.d("onHlsStateChanged", "Meeting hls is starting")
        "HLS_STARTED" -> Log.d("onHlsStateChanged", "Meeting hls is started")
        "HLS_PLAYABLE" -> {
            Log.d("onHlsStateChanged", "Meeting hls is playable now")
            //highlight-start
             // on hls playable you will receive playbackHlsUrl and livestreamUrl
            val playbackHlsUrl = HlsState.getString("playbackHlsUrl")
            val livestreamUrl = HlsState.getString("livestreamUrl")
            //highlight-end
        }
        "HLS_STOPPING" -> Log.d("onHlsStateChanged", "Meeting hls is stopping")
        "HLS_STOPPED" -> Log.d("onHlsStateChanged", "Meeting hls is stopped")
    }
  }
}

override fun onCreate(savedInstanceState: Bundle?) {
  //...

  // add listener to meeting
  //highlight-next-line
  meeting!!.addEventListener(meetingEventListener)
}
```

</TabItem>

<TabItem value="Java">

```js
private final MeetingEventListener meetingEventListener = new MeetingEventListener() {
  @Override
  public void onHlsStateChanged(JSONObject HlsState) {
      switch (HlsState.getString("status")) {
          case "HLS_STARTING":
              Log.d("onHlsStateChanged", "Meeting hls is starting");
              break;
          case "HLS_STARTED":
              Log.d("onHlsStateChanged", "Meeting hls is started");
              break;
          case "HLS_PLAYABLE":
              Log.d("onHlsStateChanged", "Meeting hls is playable now");
              //highlight-start
              // on hls started you will receive playbackHlsUrl and livestreamUrl
              String playbackHlsUrl = HlsState.getString("playbackHlsUrl");
              String livestreamUrl = HlsState.getString("livestreamUrl");
              //highlight-end
              break;
          case "HLS_STOPPING":
              Log.d("onHlsStateChanged", "Meeting hls is stopping");
              break;
          case "HLS_STOPPED":
              Log.d("onHlsStateChanged", "Meeting hls is stopped");
              break;
      }
  }
}

@Override
protected void onCreate(Bundle savedInstanceState) {
  //...

  // add listener to meeting
  //highlight-next-line
  meeting.addEventListener(meetingEventListener);
}
```

</TabItem>

</Tabs>

### API Reference

The API references for all the methods utilised in this guide are provided below.

- [startHls()](/android/api/sdk-reference/meeting-class/methods#starthls)
- [stopHls()](/android/api/sdk-reference/meeting-class/methods#stophls)
- [onHlsStateChanged](/android/api/sdk-reference/meeting-class/meeting-event-listener-class#onhlsstatechanged)
- [autoStartConfig](/api-reference/realtime-communication/create-room#autoStartConfig)


---

---
title: RTMP Livestream - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: RTMP Livestream features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: RTMP Livestream
pagination_label: RTMP Livestream
keywords:
  - Start Livestream meeting
  - Stop Livestream meeting
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: rtmp-livestream
---

# RTMP Livestream - Android

RTMP is a popular protocol for live streaming video content from a VideoSDK to platforms such as YouTube, Twitch, Facebook, and others.

By providing the platform-specific stream key and stream URL, the VideoSDK can connect to the platform's RTMP server and transmit the live video stream.

VideoSDK allows you to livestream your meeting to platform which support RTMP ingestion just by providing the platform-specific stream key and stream URL, we can connect to the platform's RTMP server and transmit the live video stream.

VideoSDK also allows you to configure the livestream layouts in numerous ways like by simply setting different prebuilt layouts in the configuration or by providing your own custom template to do the livestream according to your layout choice.

This guide will provide an overview of how to implement start and stop RTMP Livestreaming.

### `startLivestream()`

`startLivestream()` can be used to start a RTMP livestream of the meeting which can be accessed from the `Meeting` class. This method accepts two parameters:

- `1. outputs`: This parameter accepts a list of `LivestreamOutput` objects which contains the RTMP `url` and `streamKey` of the platforms you want to start the livestream.

- `2. config`: This parameter will define how the livestream layout should look like. You can pass `null` for default layout.

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
val config = JSONObject()

//highlight-next-line
// Layout Configuration
val layout = JSONObject()
JsonUtils.jsonPut(layout, "type", "GRID") // "SPOTLIGHT" | "SIDEBAR",  Default : "GRID"
JsonUtils.jsonPut(layout, "priority", "SPEAKER") // "PIN", Default : "SPEAKER"
JsonUtils.jsonPut(layout, "gridSize", 4) // MAX : 4
JsonUtils.jsonPut(config, "layout", layout)

//highlight-next-line
// Theme of livestream layout
JsonUtils.jsonPut(config, "theme", "DARK") //  "LIGHT" | "DEFAULT"

val outputs: MutableList<LivestreamOutput> = ArrayList()
outputs.add(LivestreamOutput(RTMP_URL, RTMP_STREAM_KEY))

meeting!!.startLivestream(outputs,config)
```

</TabItem>

<TabItem value="Java">

```js
JSONObject config = new JSONObject();

//highlight-next-line
// Layout Configuration
JSONObject layout = new JSONObject();
JsonUtils.jsonPut(layout, "type", "GRID"); // "SPOTLIGHT" | "SIDEBAR",  Default : "GRID"
JsonUtils.jsonPut(layout, "priority", "SPEAKER");  // "PIN", Default : "SPEAKER"
JsonUtils.jsonPut(layout, "gridSize", 4); // MAX : 4
JsonUtils.jsonPut(config, "layout", layout);

//highlight-next-line
// Theme of livestream layout
JsonUtils.jsonPut(config, "theme", "DARK"); //  "LIGHT" | "DEFAULT"

List<LivestreamOutput> outputs = new ArrayList<>();
outputs.add(new LivestreamOutput(RTMP_URL, RTMP_STREAM_KEY));

meeting.startLivestream(outputs,config);
```

</TabItem>

</Tabs>

### `stopLivestream()`

- `stopLivestream()` is used to stop the meeting livestream which can be accessed from the `Meeting` class.

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
// keep track of livestream status
val liveStream = false

findViewById<View>(R.id.btnLiveStream).setOnClickListener { view: View? ->
  if (!liveStream) {
    //highlight-start
    val config = JSONObject()
    val layout = JSONObject()
    JsonUtils.jsonPut(layout, "type", "GRID")
    JsonUtils.jsonPut(layout, "priority", "SPEAKER")
    JsonUtils.jsonPut(layout, "gridSize", 4)
    JsonUtils.jsonPut(config, "layout", layout)
    JsonUtils.jsonPut(config, "theme", "DARK")
    //highlight-end

    val outputs: MutableList<LivestreamOutput> = ArrayList()
    //highlight-next-line
    outputs.add(LivestreamOutput(RTMP_URL, RTMP_STREAM_KEY))

    // Start LiveStream
    //highlight-next-line
    meeting!!.startLivestream(outputs,config)
  } else {
    // Stop LiveStream
    //highlight-next-line
    meeting!!.stopLivestream()
  }
}
```

</TabItem>

<TabItem value="Java">

```js
// keep track of livestream status
boolean liveStream = false;

findViewById(R.id.btnLiveStream).setOnClickListener(view -> {
  if (!liveStream) {
    //highlight-start
    JSONObject config = new JSONObject();
    JSONObject layout = new JSONObject();
    JsonUtils.jsonPut(layout, "type", "GRID");
    JsonUtils.jsonPut(layout, "priority", "SPEAKER");
    JsonUtils.jsonPut(layout, "gridSize", 4);
    JsonUtils.jsonPut(config, "layout", layout);
    JsonUtils.jsonPut(config, "theme", "DARK");
    //highlight-end

    List<LivestreamOutput> outputs = new ArrayList<>();
    //highlight-next-line
    outputs.add(new LivestreamOutput(RTMP_URL, RTMP_STREAM_KEY));

    // Start LiveStream
    //highlight-next-line
    meeting.startLivestream(outputs,config);
  } else {
    // Stop LiveStream
    //highlight-next-line
    meeting.stopLivestream();
  }
});
```

</TabItem>

</Tabs>

### Event associated with Livestream

- **onLivestreamStateChanged** - Whenever meeting livestream state changes, then `onLivestreamStateChanged` event will trigger.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
private val meetingEventListener: MeetingEventListener = object : MeetingEventListener() {
  override fun onLivestreamStateChanged(livestreamState: String?) {
    when (livestreamState) {
      "LIVESTREAM_STARTING" -> Log.d( "LivestreamStateChanged",
          "Meeting livestream is starting"
      )
      "LIVESTREAM_STARTED" -> Log.d( "LivestreamStateChanged",
          "Meeting livestream is started"
      )
      "LIVESTREAM_STOPPING" -> Log.d("LivestreamStateChanged",
          "Meeting livestream is stopping"
      )
      "LIVESTREAM_STOPPED" -> Log.d("LivestreamStateChanged",
          "Meeting livestream is stopped"
      )
    }
  }
}

override fun onCreate(savedInstanceState: Bundle?) {
  //...

  // add listener to meeting
  //highlight-next-line
  meeting!!.addEventListener(meetingEventListener)
}
```

</TabItem>

<TabItem value="Java">

```js
private final MeetingEventListener meetingEventListener = new MeetingEventListener() {
  @Override
  public void onLivestreamStateChanged(String livestreamState) {
    switch (livestreamState) {
      case "LIVESTREAM_STARTING":
          Log.d("LivestreamStateChanged", "Meeting livestream is starting");
          break;
      case "LIVESTREAM_STARTED":
          Log.d("LivestreamStateChanged", "Meeting livestream is started");
          break;
      case "LIVESTREAM_STOPPING":
          Log.d("LivestreamStateChanged", "Meeting livestream is stopping");
          break;
      case "LIVESTREAM_STOPPED":
          Log.d("LivestreamStateChanged", "Meeting livestream is stopped");
          break;
    }
  }
}

@Override
protected void onCreate(Bundle savedInstanceState) {
  //...

  // add listener to meeting
  //highlight-next-line
  meeting.addEventListener(meetingEventListener);
}
```

</TabItem>

</Tabs>

### API Reference

The API references for all the methods utilised in this guide are provided below.

- [startLivestream()](/android/api/sdk-reference/meeting-class/methods#startlivestream)
- [stopLivestream()](/android/api/sdk-reference/meeting-class/methods#stoplivestream)
- [onLivestreamStateChanged](/android/api/sdk-reference/meeting-class/meeting-event-listener-class#onlivestreamstatechanged)


---

---
title: Quick Start With Http Live Streaming
hide_title: true
hide_table_of_contents: false
description: Video SDK enables the opportunity to integrate native IOS, Android & Web SDKs to add live video & audio conferencing to your applications.
sidebar_label: Start With Http Live Streaming(HLS)
pagination_label: Quick Start With Interactive Live Streaming
keywords:
  - audio calling
  - video calling
  - real-time communication
  - collaboration
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: quick-start-ILS
---

import Step from '@site/src/components/Step'

# Quick Start for Http Live Streaming(HLS) in Android

<ReactPlayer controls url="https://www.youtube.com/watch?v=KdiXs9w7qVE" height="500px" width={"100%"} />

VideoSDK empowers you to seamlessly integrate the Http Live Streaming(HLS) feature into your React Native application within minutes.

In this quickstart, you'll explore this feature of VideoSDK. Follow the step-by-step guide to integrate it within your application.

:::info

For low-latency interactive live streaming (under 100ms), follow this [documentation](./quick-start-android-ils.md).
:::

## Prerequisites

Before proceeding, ensure that your development environment meets the following requirements:

- Java Development Kit.
- Android Studio 3.0 or later.
- Android SDK API Level 21 or higher.
- A mobile device that runs Android 5.0 or later.

:::important

One should have a VideoSDK account to generate token.
Visit VideoSDK **[dashboard](https://app.videosdk.live/api-keys)** to generate token

:::

## Getting Started with the Code!

Follow the steps to create the environment necessary to add video calls into your app. Also you can find the code sample for [quickstart here](https://github.com/videosdk-live/quickstart/tree/main/android-hls).

import CautionMessage from '@site/src/theme/CautionMessage';

<CautionMessage sdk="Android SDK" version="v0.2.0" />

### Create new Android Project

For a new project in **Android Studio**, create a **Phone and Tablet** Android project with an **Empty Activity**.

![VideoSDK Android Quick Start New Project](/img/quick-start/android_newProject.png)

:::caution
After creating the project, Android Studio automatically starts gradle sync. Ensure that the sync succeeds before you continue.
:::

### Integrate Video SDK

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Maven Central"
groupId={"android-repositories"}
values={[{label: 'Maven Central', value: 'Maven Central'},{label: 'Jitpack', value: 'Jitpack'},]}>

<TabItem value="Maven Central">

```js title="settings.gradle"
dependencyResolutionManagement{
  repositories {
    // ...
    google()
    mavenCentral()
    maven { url "https://maven.aliyun.com/repository/jcenter" }
  }
}
```

</TabItem>

<TabItem value="Jitpack">

```js title="settings.gradle"
dependencyResolutionManagement{
  repositories {
    // ...
    google()
    maven { url 'https://jitpack.io' }
    mavenCentral()
    maven { url "https://maven.aliyun.com/repository/jcenter" }
  }
}
```

</TabItem>

</Tabs>

- Add the following dependency in your app's `app/build.gradle`.

```js title="app/build.gradle"
dependencies {
  implementation 'live.videosdk:rtc-android-sdk:0.3.0'

  // library to perform Network call to generate a meeting id
  implementation 'com.amitshekhar.android:android-networking:1.0.2'

  // other app dependencies
  }
```

:::important

Android SDK compatible with armeabi-v7a, arm64-v8a, x86_64 architectures. If you want to run the application in an emulator, choose ABI x86_64 when creating a device.

:::

### Add permissions into your project

- In `/app/Manifests/AndroidManifest.xml`, add the following permissions after `</application>`.

```xml title="AndroidManifest.xml"
<uses-permission android:name="android.permission.RECORD_AUDIO" />
<uses-permission android:name="android.permission.MODIFY_AUDIO_SETTINGS" />
<uses-permission android:name="android.permission.INTERNET" />
<uses-permission android:name="android.permission.CAMERA" />
```

:::note

If your project has set `android.useAndroidX=true`, then set `android.enableJetifier=true` in the `gradle.properties` file to migrate your project to AndroidX and avoid duplicate class conflict.

:::

### Structure of the project

Your project structure should look like this.

```jsx title="Project Structure"
   app
   ├── java
   │    ├── packagename
   │         ├── JoinActivity
   │         ├── MeetingActivity
   │         ├── SpeakerAdapter
   │         ├── SpeakerFragment
   |         ├── ViewerFragment
   ├── res
   │    ├── layout
   │    │    ├── activity_join.xml
   │    │    ├── activity_meeting.xml
   |    |    ├── fragment_speaker.xml
   |    |    ├── fragment_viewer.xml
   │    │    ├── item_remote_peer.xml
```

:::note

You have to set JoinActivity as Launcher activity.

:::

### App Architecture

<center>

<img src='https://cdn.videosdk.live/website-resources/docs-resources/android_ils_quickstart_app_structure.png' />

</center>


<div className="heading-toc-only">
### Step 1: Creating Joining Screen
</div>
<Step number={1} title="Creating Joining Screen">

Create a new Activity named `JoinActivity`.

The Joining screen will include :

1. **Create Button** - This button will create a new meeting for you.
2. **TextField for Meeting Id** - This text field will contain the meeting Id you want to join.
3. **Join as Host Button** - This button will join the meeting as **host** with `meetingId` you provided.
4. **Join as Viewer Button** - This button will join the meeting as **viewer** with `meetingId` you provided.

In `/app/res/layout/activity_join.xml` file, replace the content with the following.

```xml title="activity_join.xml"
<?xml version="1.0" encoding="utf-8"?>

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:id="@+id/createorjoinlayout"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:background="@color/black"
    android:gravity="center"
    android:orientation="vertical">

    <Button
        android:id="@+id/btnCreateMeeting"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Create Meeting"
        android:textAllCaps="false" />

    <TextView
        android:id="@+id/tvText"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:paddingVertical="5sp"
        android:text="OR"
        android:textColor="@color/white"
        android:textSize="20sp" />

    <EditText
        android:id="@+id/etMeetingId"
        android:theme="@android:style/Theme.Holo"
        android:layout_width="250dp"
        android:layout_height="wrap_content"
        android:hint="Enter Meeting Id"
        android:textColor="@color/white"
        android:textColorHint="@color/white" />

    <Button
        android:id="@+id/btnJoinHostMeeting"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_marginTop="8sp"
        android:text="Join as Host"
        android:textAllCaps="false" />

    <Button
        android:id="@+id/btnJoinViewerMeeting"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Join as Viewer"
        android:textAllCaps="false" />

</LinearLayout>
```

**Integration of Create Meeting API**

1. Create field `sampleToken` in `JoinActivity` which will hold the generated token from the [VideoSDK dashboard](https://app.videosdk.live/api-keys). This token will use in VideoSDK config as well as in generating meetingId.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js title="JoinActivity.kt"
class JoinActivity : AppCompatActivity() {

  //highlight-next-line
  //Replace with the token you generated from the VideoSDK Dashboard
  private var sampleToken = ""

  override fun onCreate(savedInstanceState: Bundle?) {
    //...
  }
}
```

</TabItem>

<TabItem value="Java">

```java title="JoinActivity.java"
public class JoinActivity extends AppCompatActivity {

  //highlight-next-line
  //Replace with the token you generated from the VideoSDK Dashboard
  private String sampleToken ="";

  @Override
  protected void onCreate(Bundle savedInstanceState) {
    //...
  }
}
```

</TabItem>

</Tabs>

2. On **Join Button as Host** `onClick` events, we will naviagte to `MeetingActivity` with token, meetingId and mode as `SEND_AND_RECV`.

3. On **Join Button as Viewer** `onClick` events, we will naviagte to `MeetingActivity` with token, meetingId and mode as `Viewer`.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js title="JoinActivity.kt"
class JoinActivity : AppCompatActivity() {

   //Replace with the token you generated from the VideoSDK Dashboard
   private var sampleToken = "";

   override fun onCreate(savedInstanceState: Bundle?) {
      super.onCreate(savedInstanceState)
      setContentView(R.layout.activity_join)

      val btnCreate = findViewById<Button>(R.id.btnCreateMeeting)
      val btnJoinHost = findViewById<Button>(R.id.btnJoinHostMeeting)
      val btnJoinViewer = findViewById<Button>(R.id.btnJoinViewerMeeting)
      val etMeetingId = findViewById<EditText>(R.id.etMeetingId)

      //highlight-next-line
      // create meeting and join as Host
      btnCreate.setOnClickListener {
          createMeeting(
              sampleToken
          )
      }

      //highlight-next-line
      // Join as Host
      btnJoinHost.setOnClickListener {
          val intent = Intent(this@JoinActivity, MeetingActivity::class.java)
          intent.putExtra("token", sampleToken)
          intent.putExtra("meetingId", etMeetingId.text.toString().trim { it <= ' ' })
          //highlight-next-line
          intent.putExtra("mode", "SEND_AND_RECV")
          startActivity(intent)
      }

      //highlight-next-line
      // Join as Viewer
      btnJoinViewer.setOnClickListener {
          val intent = Intent(this@JoinActivity, MeetingActivity::class.java)
          intent.putExtra("token", sampleToken)
          intent.putExtra("meetingId", etMeetingId.text.toString().trim { it <= ' ' })
          //highlight-next-line
          intent.putExtra("mode", "SIGNALLING_ONLY")
          startActivity(intent)
      }
    }

    private fun createMeeting(token: String) {
      // we will explore this method in the next step
    }
}
```

</TabItem>

<TabItem value="Java">

```java title="JoinActivity.java"
public class JoinActivity extends AppCompatActivity {

  //Replace with the token you generated from the VideoSDK Dashboard
  private String sampleToken ="";

  @Override
  protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_join);

    final Button btnCreate = findViewById(R.id.btnCreateMeeting);
    final Button btnJoinHost = findViewById(R.id.btnJoinHostMeeting);
    final Button btnJoinViewer = findViewById(R.id.btnJoinViewerMeeting);
    final EditText etMeetingId = findViewById(R.id.etMeetingId);

    //highlight-next-line
    // create meeting and join as Host
    btnCreate.setOnClickListener(v -> createMeeting(sampleToken));

    //highlight-next-line
    // Join as Host
    btnJoinHost.setOnClickListener(v -> {
        Intent intent = new Intent(JoinActivity.this, MeetingActivity.class);
        intent.putExtra("token", sampleToken);
        intent.putExtra("meetingId", etMeetingId.getText().toString().trim());
        //highlight-next-line
        intent.putExtra("mode", "SEND_AND_RECV");
        startActivity(intent);
    });

    //highlight-next-line
    // Join as Viewer
    btnJoinViewer.setOnClickListener(v -> {
        Intent intent = new Intent(JoinActivity.this, MeetingActivity.class);
        intent.putExtra("token", sampleToken);
        intent.putExtra("meetingId", etMeetingId.getText().toString().trim());
        //highlight-next-line
        intent.putExtra("mode", "SIGNALLING_ONLY");
        startActivity(intent);
    });
  }

  private void createMeeting(String token) {
    // we will explore this method in the next step
  }
}
```

</TabItem>

</Tabs>

4. For **Create Button**, under `createMeeting` method we will generate meetingId by calling API and navigate to `MeetingActivity` with token, generated meetingId and mode as `SEND_AND_RECV`.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js title="JoinActivity.kt"
class JoinActivity : AppCompatActivity() {
  //...onCreate
 private fun createMeeting(token: String) {
  // we will make an API call to VideoSDK Server to get a roomId
  AndroidNetworking.post("https://api.videosdk.live/v2/rooms")
      .addHeaders("Authorization", token) //we will pass the token in the Headers
      .build()
      .getAsJSONObject(object : JSONObjectRequestListener {
          override fun onResponse(response: JSONObject) {
            try {
              // response will contain `roomId`
              val meetingId = response.getString("roomId")

              // starting the MeetingActivity with received roomId and our sampleToken
              val intent = Intent(this@JoinActivity, MeetingActivity::class.java)
              intent.putExtra("token", sampleToken)
              intent.putExtra("meetingId", meetingId)
              //highlight-next-line
              intent.putExtra("mode", "SEND_AND_RECV")
              startActivity(intent)
            } catch (e: JSONException) {
                e.printStackTrace()
            }
          }

          override fun onError(anError: ANError) {
            anError.printStackTrace()
            Toast.makeText(this@JoinActivity, anError.message, Toast.LENGTH_SHORT)
                .show()
          }
      })
  }
}
```

</TabItem>

<TabItem value="Java">

```java title="JoinActivity.java"
public class JoinActivity extends AppCompatActivity {
  //...onCreate

  private void createMeeting(String token) {
    // we will make an API call to VideoSDK Server to get a roomId
    AndroidNetworking.post("https://api.videosdk.live/v2/rooms")
          .addHeaders("Authorization", token) //we will pass the token in the Headers
          .build()
          .getAsJSONObject(new JSONObjectRequestListener() {
              @Override
              public void onResponse(JSONObject response) {
                try {
                  // response will contain `roomId`
                  final String meetingId = response.getString("roomId");

                  // starting the MeetingActivity with received roomId and our sampleToken
                  Intent intent = new Intent(JoinActivity.this, MeetingActivity.class);
                  intent.putExtra("token", sampleToken);
                  intent.putExtra("meetingId", meetingId);
                  //highlight-next-line
                  intent.putExtra("mode", "SEND_AND_RECV");
                  startActivity(intent);
                } catch (JSONException e) {
                    e.printStackTrace();
                }
              }

              @Override
              public void onError(ANError anError) {
                anError.printStackTrace();
                Toast.makeText(JoinActivity.this, anError.getMessage(), Toast.LENGTH_SHORT).show();
              }
          });
  }
}
```

</TabItem>

</Tabs>

:::note

Don't confuse with Room and Meeting keyword, both are same thing 😃

:::

5. Our App is completely based on audio and video communicatation, that's why we need to ask for runtime permissions `RECORD_AUDIO` and `CAMERA`. So, we will implement permission logic on `JoinActivity`.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js title="JoinActivity.kt"
class JoinActivity : AppCompatActivity() {
  companion object {
    private const val PERMISSION_REQ_ID = 22
    private val REQUESTED_PERMISSIONS = arrayOf(
        Manifest.permission.RECORD_AUDIO,
        Manifest.permission.CAMERA
    )
  }

  private fun checkSelfPermission(permission: String, requestCode: Int) {
    if (ContextCompat.checkSelfPermission(this, permission) !=
        PackageManager.PERMISSION_GRANTED
    ) {
        ActivityCompat.requestPermissions(this, REQUESTED_PERMISSIONS, requestCode)
    }
  }

  override fun onCreate(savedInstanceState: Bundle?) {
    //... button listeneres
    //highlight-start
    checkSelfPermission(REQUESTED_PERMISSIONS[0], PERMISSION_REQ_ID)
    checkSelfPermission(REQUESTED_PERMISSIONS[1], PERMISSION_REQ_ID)
    //highlight-end
  }
}
```

</TabItem>

<TabItem value="Java">

```java title="JoinActivity.java"
public class JoinActivity extends AppCompatActivity {
  private static final int PERMISSION_REQ_ID = 22;

  private static final String[] REQUESTED_PERMISSIONS = {
    Manifest.permission.RECORD_AUDIO,
    Manifest.permission.CAMERA
  };

  private void checkSelfPermission(String permission, int requestCode) {
    if (ContextCompat.checkSelfPermission(this, permission) !=
            PackageManager.PERMISSION_GRANTED) {
      ActivityCompat.requestPermissions(this, REQUESTED_PERMISSIONS, requestCode);
    }
  }

  @Override
  protected void onCreate(Bundle savedInstanceState) {
    //... button listeneres
   //highlight-start
   checkSelfPermission(REQUESTED_PERMISSIONS[0], PERMISSION_REQ_ID);
   checkSelfPermission(REQUESTED_PERMISSIONS[1], PERMISSION_REQ_ID);
   //highlight-end
  }
}
```

</TabItem>

</Tabs>

#### Output

<center>

<img style={{height: '450px'}} src="https://cdn.videosdk.live/website-resources/docs-resources/android_ils_quickstart_join_screen.jpg" />

</center>
</Step>

<div className="heading-toc-only">
### Step 2: Creating Meeting Screen
</div>
<Step number={2} title="Creating Meeting Screen">

Create a new Activity named `MeetingActivity`.

In `/app/res/layout/activity_meeting.xml` file, replace the content with the following.

```xml title="activty_meeting.xml"
<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:id="@+id/mainLayout"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:background="@color/black"
    tools:context=".MeetingActivity">

    <TextView
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:gravity="center"
        android:text="Creating a meeting for you"
        android:textColor="@color/white"
        android:textFontWeight="700"
        android:textSize="20sp" />

</RelativeLayout>
```

**The next step is to initialize a meeting, After getting token and meetigId from JoinActivity:**

1. Initialize **VideoSDK**.
2. Configure **VideoSDK** with token.
3. Initialize the meeting with required params such as `meetingId`, `participantName`, `micEnabled`, `webcamEnabled` , `mode` and more.
4. Join the room with `meeting.join()` method.
5. Add `MeetingEventListener` for listening **Meeting Join** event.
6. Check mode of `localParticipant`, If mode is **SEND_AND_RECV** than we will replace mainLayout with `SpeakerFragment` otherwise replace with `ViewerFragment`.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js title="MeetingActivity.kt"
class MeetingActivity : AppCompatActivity() {
  var meeting: Meeting? = null
      private set

  override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    setContentView(R.layout.activity_meeting)

    val meetingId = intent.getStringExtra("meetingId")
    val token = intent.getStringExtra("token")
    val mode = intent.getStringExtra("mode")
    val localParticipantName = "John Doe"
    val streamEnable = mode == "SEND_AND_RECV"

    //highlight-next-line
    // initialize VideoSDK
    VideoSDK.initialize(applicationContext)

    //highlight-next-line
    // Configuration VideoSDK with Token
    VideoSDK.config(token)

    //highlight-next-line
    // Initialize VideoSDK Meeting
    meeting = VideoSDK.initMeeting(
        this@MeetingActivity, meetingId, localParticipantName,
        streamEnable, streamEnable, null, mode, false, null, null
    )

    //highlight-next-line
    // join Meeting
    meeting!!.join()

    //highlight-next-line
    // if mode is SEND_AND_RECV than replace mainLayout with SpeakerFragment otherwise with ViewerFragment
    meeting!!.addEventListener(object : MeetingEventListener() {
      override fun onMeetingJoined() {
          if (meeting != null) {
            if (mode == "SEND_AND_RECV") {
              //highlight-next-line
              //pin the local participant
              meeting!!.localParticipant.pin("SHARE_AND_CAM")
              supportFragmentManager
                  .beginTransaction()
                  .replace(R.id.mainLayout, SpeakerFragment(), "MainFragment")
                  .commit()
              } else if (mode == "SIGNALLING_ONLY") {
                supportFragmentManager
                    .beginTransaction()
                    .replace(R.id.mainLayout, ViewerFragment(), "viewerFragment")
                    .commit()
              }
          }
      }
    })
  }
}
```

</TabItem>

<TabItem value="Java">

```java title="MeetingActivity.java"
public class MeetingActivity extends AppCompatActivity {
  private Meeting meeting;

  @Override
  protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_meeting);

    final String meetingId = getIntent().getStringExtra("meetingId");
    String token = getIntent().getStringExtra("token");
    String mode = getIntent().getStringExtra("mode");
    String localParticipantName = "John Doe";
    boolean streamEnable = mode.equals("SEND_AND_RECV");

    //highlight-next-line
    // initialize VideoSDK
    VideoSDK.initialize(getApplicationContext());

    //highlight-next-line
    // Configuration VideoSDK with Token
    VideoSDK.config(token);

    //highlight-next-line
    // Initialize VideoSDK Meeting
    meeting = VideoSDK.initMeeting(
            MeetingActivity.this, meetingId, localParticipantName,
            streamEnable, streamEnable, null, mode, false, null, null);

    //highlight-next-line
    // join Meeting
    meeting.join();

    //highlight-next-line
    // if mode is SEND_AND_RECV than replace mainLayout with SpeakerFragment otherwise with ViewerFragment
    meeting.addEventListener(new MeetingEventListener() {
        @Override
        public void onMeetingJoined() {
          if (meeting != null) {
            if (mode.equals("SEND_AND_RECV")) {
              //highlight-next-line
              //pin the local participant
              meeting.getLocalParticipant().pin("SHARE_AND_CAM");
              getSupportFragmentManager()
                  .beginTransaction()
                  .replace(R.id.mainLayout, new SpeakerFragment(), "MainFragment")
                  .commit();
            } else if (mode.equals("SIGNALLING_ONLY")) {
              getSupportFragmentManager()
                  .beginTransaction()
                  .replace(R.id.mainLayout, new ViewerFragment(), "viewerFragment")
                  .commit();
            }
          }
        }
      });
  }
  public Meeting getMeeting() {
      return meeting;
  }
}
```

</TabItem>

</Tabs>

#### Output

<center>

<img style={{height: '450px'}} src="https://cdn.videosdk.live/website-resources/docs-resources/android_ils_quickstart_meeting_screen.jpg" />

</center>


</Step>

<div className="heading-toc-only">
### Step 3: Implement SpeakerView
</div>
<Step number={3} title="Implement SpeakerView">

After successfully enter into the meeting, it's time to render speaker's view and manage controls such as toggle webcam/mic,start/stop HLS and leave the meeting.

1. Create a new fragment named `SpeakerFragment`.

2. In `/app/res/layout/fragment_speaker.xml` file, replace the content with the following.

```xml title="fragment_speaker.xml"
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:background="@color/black"
    android:gravity="center"
    android:orientation="vertical"
    tools:context=".SpeakerFragment">

    <LinearLayout
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:layout_marginVertical="8sp"
        android:paddingHorizontal="10sp">

        <TextView
            android:id="@+id/tvMeetingId"
            android:layout_width="0dp"
            android:layout_height="wrap_content"
            android:text="Meeting Id : "
            android:textColor="@color/white"
            android:textSize="18sp"
            android:layout_weight="3"/>

        <Button
            android:id="@+id/btnLeave"
            android:layout_width="0dp"
            android:layout_height="wrap_content"
            android:text="Leave"
            android:textAllCaps="false"
            android:layout_weight="1"/>

    </LinearLayout>

    <TextView
        android:id="@+id/tvHlsState"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Current HLS State : NOT_STARTED"
        android:textColor="@color/white"
        android:textSize="18sp" />

    <androidx.recyclerview.widget.RecyclerView
        android:id="@+id/rvParticipants"
        android:layout_width="match_parent"
        android:layout_height="0dp"
        android:layout_marginVertical="10sp"
        android:layout_weight="1" />

    <LinearLayout
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:gravity="center">

        <Button
            android:id="@+id/btnHLS"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:text="Start HLS"
            android:textAllCaps="false" />

        <Button
            android:id="@+id/btnWebcam"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:layout_marginHorizontal="5sp"
            android:text="Toggle Webcam"
            android:textAllCaps="false" />

        <Button
            android:id="@+id/btnMic"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:text="Toggle Mic"
            android:textAllCaps="false" />

    </LinearLayout>

</LinearLayout>
```

3. Now, let's set listener for buttons which will allow the participant to toggle media.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js title="SpeakerFragment.kt"
class SpeakerFragment : Fragment() {
  private var micEnabled = true
  private var webcamEnabled = true
  private var hlsEnabled = false
  private var btnMic: Button? = null
  private var btnWebcam: Button? = null
  private var btnHls: Button? = null
  private var btnLeave: Button? = null
  private var tvMeetingId: TextView? = null
  private var tvHlsState: TextView? = null
  override fun onAttach(context: Context) {
    super.onAttach(context)
    mContext = context
    if (context is Activity) {
      mActivity = context
      //highlight-next-line
      // getting meeting object from Meeting Activity
      meeting = (mActivity as MeetingActivity?)!!.meeting
    }
  }

  override fun onCreateView(
      inflater: LayoutInflater, container: ViewGroup?,
      savedInstanceState: Bundle?
  ): View? {
    // Inflate the layout for this fragment
    val view = inflater.inflate(R.layout.fragment_speaker, container, false)
    btnMic = view.findViewById(R.id.btnMic)
    btnWebcam = view.findViewById(R.id.btnWebcam)
    btnHls = view.findViewById(R.id.btnHLS)
    btnLeave = view.findViewById(R.id.btnLeave)
    tvMeetingId = view.findViewById(R.id.tvMeetingId)
    tvHlsState = view.findViewById(R.id.tvHlsState)
    if (meeting != null) {
      tvMeetingId!!.text = "Meeting Id : " + meeting!!.meetingId
      //highlight-next-line
      setActionListeners()
    }
    return view
  }

  private fun setActionListeners() {
    btnMic!!.setOnClickListener {
      if (micEnabled) {
        //highlight-next-line
        meeting!!.muteMic()
        Toast.makeText(mContext, "Mic Muted", Toast.LENGTH_SHORT).show()
      } else {
        //highlight-next-line
        meeting!!.unmuteMic()
        Toast.makeText(
            mContext,
            "Mic Enabled",
            Toast.LENGTH_SHORT
        ).show()
      }
      micEnabled = !micEnabled
    }
    btnWebcam!!.setOnClickListener {
      if (webcamEnabled) {
        //highlight-next-line
        meeting!!.disableWebcam()
        Toast.makeText(
            mContext,
            "Webcam Disabled",
            Toast.LENGTH_SHORT
        ).show()
      } else {
        //highlight-next-line
        meeting!!.enableWebcam()
        Toast.makeText(
            mContext,
            "Webcam Enabled",
            Toast.LENGTH_SHORT
        ).show()
      }
      webcamEnabled = !webcamEnabled
    }
    //highlight-next-line
    btnLeave!!.setOnClickListener { meeting!!.leave() }
    btnHls!!.setOnClickListener {
      if (!hlsEnabled) {
        //highlight-start
        val config = JSONObject()
        val layout = JSONObject()
        JsonUtils.jsonPut(layout, "type", "SPOTLIGHT")
        JsonUtils.jsonPut(layout, "priority", "PIN")
        JsonUtils.jsonPut(layout, "gridSize", 4)
        JsonUtils.jsonPut(config, "layout", layout)
        JsonUtils.jsonPut(config, "orientation", "portrait")
        JsonUtils.jsonPut(config, "theme", "DARK")
        JsonUtils.jsonPut(config, "quality", "high")
        meeting!!.startHls(config)
        //highlight-end
      } else {
        //highlight-next-line
        meeting!!.stopHls()
      }
    }
  }

  companion object {
    private var mActivity: Activity? = null
    private var mContext: Context? = null
    private var meeting: Meeting? = null
  }
}
```

</TabItem>

<TabItem value="Java">

```java title="SpeakerFragment.java"
public class SpeakerFragment extends Fragment {

  private static Activity mActivity;
  private static Context mContext;
  private static Meeting meeting;
  private boolean micEnabled = true;
  private boolean webcamEnabled = true;
  private boolean hlsEnabled = false;
  private Button btnMic, btnWebcam, btnHls, btnLeave;
  private TextView tvMeetingId, tvHlsState;

  public SpeakerFragment() {
    // Required empty public constructor
  }

  @Override
  public void onAttach(@NonNull Context context) {
    super.onAttach(context);
    mContext = context;
    if (context instanceof Activity) {
      mActivity = (Activity) context;
      //highlight-next-line
      // getting meeting object from Meeting Activity
      meeting = ((MeetingActivity) mActivity).getMeeting();
    }
  }

  @Override
  public View onCreateView(LayoutInflater inflater, ViewGroup container,
                            Bundle savedInstanceState) {
    // Inflate the layout for this fragment
    View view = inflater.inflate(R.layout.fragment_speaker, container, false);
    btnMic = view.findViewById(R.id.btnMic);
    btnWebcam = view.findViewById(R.id.btnWebcam);
    btnHls = view.findViewById(R.id.btnHLS);
    btnLeave = view.findViewById(R.id.btnLeave);

    tvMeetingId = view.findViewById(R.id.tvMeetingId);
    tvHlsState = view.findViewById(R.id.tvHlsState);

    if (meeting != null) {
        tvMeetingId.setText("Meeting Id : " + meeting.getMeetingId());
        //highlight-next-line
        setActionListeners();
    }
    return view;
  }

  private void setActionListeners() {
    btnMic.setOnClickListener(v -> {
        if (micEnabled) {
          //highlight-next-line
          meeting.muteMic();
          Toast.makeText(mContext,"Mic Muted",Toast.LENGTH_SHORT).show();
        } else {
          //highlight-next-line
          meeting.unmuteMic();
          Toast.makeText(mContext,"Mic Enabled",Toast.LENGTH_SHORT).show();
        }
        micEnabled=!micEnabled;
    });

    btnWebcam.setOnClickListener(v -> {
        if (webcamEnabled) {
          //highlight-next-line
          meeting.disableWebcam();
          Toast.makeText(mContext,"Webcam Disabled",Toast.LENGTH_SHORT).show();
        } else {
          //highlight-next-line
          meeting.enableWebcam();
          Toast.makeText(mContext,"Webcam Enabled",Toast.LENGTH_SHORT).show();
        }
        webcamEnabled=!webcamEnabled;
    });

    //highlight-next-line
    btnLeave.setOnClickListener(v -> meeting.leave());

    btnHls.setOnClickListener(v -> {
      if (!hlsEnabled) {
        //highlight-start
        JSONObject config = new JSONObject();
        JSONObject layout = new JSONObject();
        JsonUtils.jsonPut(layout, "type", "SPOTLIGHT");
        JsonUtils.jsonPut(layout, "priority", "PIN");
        JsonUtils.jsonPut(layout, "gridSize", 4);
        JsonUtils.jsonPut(config, "layout", layout);
        JsonUtils.jsonPut(config, "orientation", "portrait");
        JsonUtils.jsonPut(config, "theme", "DARK");
        JsonUtils.jsonPut(config, "quality", "high");
        meeting.startHls(config);
        //highlight-end
      } else {
        //highlight-next-line
        meeting.stopHls();
      }
    });
  }
}
```

</TabItem>

</Tabs>

4. After adding listners for buttons, let's add `MeetingEventListener` to the meeting and remove all listners in `onDestroy()` method.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js title="SpeakerFragment.kt"
class SpeakerFragment : Fragment() {

  override fun onCreateView(
      inflater: LayoutInflater, container: ViewGroup?,
      savedInstanceState: Bundle?
  ): View? {
    //...
    if (meeting != null) {
      //...
      //highlight-next-line
      // add Listener to the meeting
      meeting!!.addEventListener(meetingEventListener)
    }
    return view
  }

  private val meetingEventListener: MeetingEventListener = object : MeetingEventListener() {
      override fun onMeetingLeft() {
        //highlight-next-line
        // unpin the local participant
        meeting!!.localParticipant.unpin("SHARE_AND_CAM")
        if (isAdded) {
          val intents = Intent(mContext, JoinActivity::class.java)
          intents.addFlags(
              Intent.FLAG_ACTIVITY_NEW_TASK
                      or Intent.FLAG_ACTIVITY_CLEAR_TOP or Intent.FLAG_ACTIVITY_CLEAR_TASK
          )
          startActivity(intents)
          mActivity!!.finish()
        }
      }

      @RequiresApi(api = Build.VERSION_CODES.P)
      override fun onHlsStateChanged(HlsState: JSONObject) {
        if (HlsState.has("status")) {
          try {
              tvHlsState!!.text = "Current HLS State : " + HlsState.getString("status")
              //highlight-next-line
              if (HlsState.getString("status") == "HLS_STARTED") {
                hlsEnabled = true
                btnHls!!.text = "Stop HLS"
              }
              //highlight-next-line
              if (HlsState.getString("status") == "HLS_STOPPED") {
                hlsEnabled = false
                btnHls!!.text = "Start HLS"
              }
            } catch (e: JSONException) {
                e.printStackTrace()
            }
        }
      }
  }

  override fun onDestroy() {
      mContext = null
      mActivity = null
      if (meeting != null) {
          meeting!!.removeAllListeners()
          meeting = null
      }
      super.onDestroy()
  }
}
```

</TabItem>

<TabItem value="Java">

```java title="SpeakerFragment.java"
public class SpeakerFragment extends Fragment {

  @Override
  public View onCreateView(LayoutInflater inflater, ViewGroup container,
                            Bundle savedInstanceState) {
    //...
    if (meeting != null) {
        //...
        //highlight-next-line
        // add Listener to the meeting
        meeting.addEventListener(meetingEventListener);
    }
    return view;
  }

  private final MeetingEventListener meetingEventListener = new MeetingEventListener() {
    @Override
    public void onMeetingLeft() {
      //highlight-next-line
      //unpin local participant
      meeting.getLocalParticipant().unpin("SHARE_AND_CAM");
      if (isAdded()) {
        Intent intents = new Intent(mContext, JoinActivity.class);
        intents.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK
                | Intent.FLAG_ACTIVITY_CLEAR_TOP | Intent.FLAG_ACTIVITY_CLEAR_TASK);
        startActivity(intents);
        mActivity.finish();
      }
    }

    @RequiresApi(api = Build.VERSION_CODES.P)
    @Override
    public void onHlsStateChanged(JSONObject HlsState) {
        if (HlsState.has("status")) {
          try {
            tvHlsState.setText("Current HLS State : " + HlsState.getString("status"));
            //highlight-next-line
            if (HlsState.getString("status").equals("HLS_STARTED")) {
                hlsEnabled=true;
                btnHls.setText("Stop HLS");
            }
            //highlight-next-line
            if (HlsState.getString("status").equals("HLS_STOPPED")) {
                hlsEnabled = false;
                btnHls.setText("Start HLS");
            }
          } catch (JSONException e) {
              e.printStackTrace();
          }
        }
    }
  };

  @Override
  public void onDestroy() {
    mContext = null;
    mActivity = null;
    if (meeting != null) {
        meeting.removeAllListeners();
        meeting = null;
    }
    super.onDestroy();
  }

}
```

</TabItem>

</Tabs>

5. Next step is to render speaker's view. With `RecyclerView`, we will be display list of participant who joined the meeting as a `host`.

:::info

- Here the participant's video is displayed using `VideoView`, but you may also use `SurfaceViewRender` for the same.
- For `VideoView`, SDK version should be `0.1.13` or higher.
- To know more about `VideoView`, please visit [here](/android/guide/video-and-audio-calling-api-sdk/render-media/display-video/understand-videoView-component)

:::

- Create a new layout for the participant view named `item_remote_peer.xml` in the `res/layout` folder.

```xml title="item_remote_peer.xml"
<?xml version="1.0" encoding="utf-8"?>
<FrameLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="200dp"
    android:background="@color/cardview_dark_background"
    tools:layout_height="200dp">

    <live.videosdk.rtc.android.VideoView
        android:id="@+id/participantView"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:visibility="gone" />

    <LinearLayout
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:layout_gravity="bottom"
        android:background="#99000000"
        android:orientation="horizontal">

        <TextView
            android:id="@+id/tvName"
            android:layout_width="0dp"
            android:layout_height="wrap_content"
            android:layout_weight="1"
            android:gravity="center"
            android:padding="4dp"
            android:textColor="@color/white" />

    </LinearLayout>

</FrameLayout>
```

- Create a recycler view adapter named `SpeakerAdapter` which will show the participant list. Create `PeerViewHolder` in the adapter which will extend `RecyclerView.ViewHolder`.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js title="SpeakerAdapter.kt"
class SpeakerAdapter(private val meeting: Meeting) :
    RecyclerView.Adapter<SpeakerAdapter.PeerViewHolder?>() {
    private var participantList: MutableList<Participant> = ArrayList()

    init {
      updateParticipantList()
      //highlight-next-line
      // adding Meeting Event listener to get the participant join/leave event in the meeting.
      meeting.addEventListener(object : MeetingEventListener() {
        override fun onParticipantJoined(participant: Participant) {
          //highlight-next-line
          // check participant join as Host/Speaker or not
          if (participant.mode == "SEND_AND_RECV") {
              //highlight-next-line
              // pin the participant
              participant.pin("SHARE_AND_CAM")
              //highlight-next-line
              // add participant in participantList
              participantList.add(participant)
          }
          notifyDataSetChanged()
        }

        override fun onParticipantLeft(participant: Participant) {
          var pos = -1
          for (i in participantList.indices) {
              if (participantList[i].id == participant.id) {
                  pos = i
                  break
              }
          }
          if (participantList.contains(participant)) {
              //highlight-next-line
              // unpin participant who left the meeting
              participant.unpin("SHARE_AND_CAM")
              //highlight-next-line
              // remove participant from participantList
              participantList.remove(participant)
          }
          if (pos >= 0) {
              notifyItemRemoved(pos)
          }
        }
      })
    }

    private fun updateParticipantList() {
      //highlight-next-line
      // adding the local participant(You) to the list
      participantList.add(meeting.localParticipant)

      //highlight-next-line
      // adding participants who join as Host/Speaker
      val participants: Iterator<Participant> = meeting.participants.values.iterator()
      for (i in 0 until meeting.participants.size) {
        val participant = participants.next()
        if (participant.mode == "SEND_AND_RECV") {
            //highlight-next-line
            // pin the participant
            participant.pin("SHARE_AND_CAM")
            //highlight-next-line
            // add participant in participantList
            participantList.add(participant)
        }
      }
    }

    override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): PeerViewHolder {
      return PeerViewHolder(
          LayoutInflater.from(parent.context).inflate(R.layout.item_remote_peer, parent, false)
      )
    }

    override fun onBindViewHolder(holder: PeerViewHolder, position: Int) {
      val participant = participantList[position]
      holder.tvName.text = participant.displayName

      // adding the initial video stream for the participant into the 'VideoView'
      for ((_, stream) in participant.streams) {
        if (stream.kind.equals("video", ignoreCase = true)) {
          holder.participantView.visibility = View.VISIBLE
          val videoTrack = stream.track as VideoTrack
          //highlight-next-line
          holder.participantView.addTrack(videoTrack)
          break
        }
      }

      // add Listener to the participant which will update start or stop the video stream of that participant
      participant.addEventListener(object : ParticipantEventListener() {
        override fun onStreamEnabled(stream: Stream) {
          if (stream.kind.equals("video", ignoreCase = true)) {
            holder.participantView.visibility = View.VISIBLE
            val videoTrack = stream.track as VideoTrack
            //highlight-next-line
            holder.participantView.addTrack(videoTrack)
          }
        }

        override fun onStreamDisabled(stream: Stream) {
          if (stream.kind.equals("video", ignoreCase = true)) {
            //highlight-next-line
            holder.participantView.removeTrack()
            holder.participantView.visibility = View.GONE
          }
        }
      })
    }

    override fun getItemCount(): Int {
      //highlight-next-line
      return participantList.size
    }

    class PeerViewHolder(view: View) : RecyclerView.ViewHolder(view) {
      // 'VideoView' to show Video Stream
      var participantView: VideoView
      var tvName: TextView

      init {
        tvName = view.findViewById(R.id.tvName)
        participantView = view.findViewById(R.id.participantView)
      }
    }
}
```

</TabItem>

<TabItem value="Java">

```java title="SpeakerAdapter.java"
public class SpeakerAdapter extends RecyclerView.Adapter<SpeakerAdapter.PeerViewHolder> {
  private List<Participant> participantList = new ArrayList<>();
  private final Meeting meeting;
  public SpeakerAdapter(Meeting meeting) {
    this.meeting = meeting;

    updateParticipantList();

    //highlight-next-line
    // adding Meeting Event listener to get the participant join/leave event in the meeting.
    meeting.addEventListener(new MeetingEventListener() {
      @Override
      public void onParticipantJoined(Participant participant) {
        //highlight-next-line
        // check participant join as Host/Speaker or not
        if (participant.getMode().equals("SEND_AND_RECV")) {
          //highlight-next-line
          // pin the participant
          participant.pin("SHARE_AND_CAM");
          //highlight-next-line
          // add participant in participantList
          participantList.add(participant);
        }
        notifyDataSetChanged();
      }

      @Override
      public void onParticipantLeft(Participant participant) {
        int pos = -1;
        for (int i = 0; i < participantList.size(); i++) {
          if (participantList.get(i).getId().equals(participant.getId())) {
            pos = i;
            break;
          }
        }
        if(participantList.contains(participant)) {
          //highlight-next-line
          // unpin participant who left the meeting
          participant.unpin("SHARE_AND_CAM");
          //highlight-next-line
          // remove participant from the list
          participantList.remove(participant);
        }
        if (pos >= 0) {
            notifyItemRemoved(pos);
        }
      }
    });
  }

  private void updateParticipantList() {
    participantList = new ArrayList<>();

    //highlight-next-line
    // adding the local participant(You) to the list
    participantList.add(meeting.getLocalParticipant());

    //highlight-next-line
    // adding participants who join as Host/Speaker
    Iterator<Participant> participants = meeting.getParticipants().values().iterator();
    for (int i = 0; i < meeting.getParticipants().size(); i++) {
      final Participant participant = participants.next();
      if (participant.getMode().equals("SEND_AND_RECV")) {
        //highlight-next-line
        // pin the participant
        participant.pin("SHARE_AND_CAM");
        //highlight-next-line
        // add participant in participantList
        participantList.add(participant);
      }
    }
  }

  @NonNull
  @Override
  public PeerViewHolder onCreateViewHolder(@NonNull ViewGroup parent, int viewType) {
    return new PeerViewHolder(LayoutInflater.from(parent.getContext()).inflate(R.layout.item_remote_peer, parent, false));
  }

  @Override
  public void onBindViewHolder(@NonNull PeerViewHolder holder, int position) {
    Participant participant = participantList.get(position);

    holder.tvName.setText(participant.getDisplayName());

    // adding the initial video stream for the participant into the 'VideoView'
    for (Map.Entry<String, Stream> entry : participant.getStreams().entrySet()) {
      Stream stream = entry.getValue();
      if (stream.getKind().equalsIgnoreCase("video")) {
        holder.participantView.setVisibility(View.VISIBLE);
        VideoTrack videoTrack = (VideoTrack) stream.getTrack();
        //highlight-next-line
        holder.participantView.addTrack(videoTrack);
        break;
      }
    }

    // add Listener to the participant which will update start or stop the video stream of that participant
    participant.addEventListener(new ParticipantEventListener() {
        @Override
        public void onStreamEnabled(Stream stream) {
          if (stream.getKind().equalsIgnoreCase("video")) {
            holder.participantView.setVisibility(View.VISIBLE);
            VideoTrack videoTrack = (VideoTrack) stream.getTrack();
            //highlight-next-line
            holder.participantView.addTrack(videoTrack);
          }
        }

        @Override
        public void onStreamDisabled(Stream stream) {
          if (stream.getKind().equalsIgnoreCase("video")) {
            //highlight-next-line
            holder.participantView.removeTrack();
            holder.participantView.setVisibility(View.GONE);
          }
        }
    });
  }

  @Override
  public int getItemCount() {
    //highlight-next-line
    return participantList.size();
  }

  static class PeerViewHolder extends RecyclerView.ViewHolder {
    // 'VideoView' to show Video Stream
    public VideoView participantView;
    public TextView tvName;
    public View itemView;

    PeerViewHolder(@NonNull View view) {
        super(view);
        itemView = view;
        tvName = view.findViewById(R.id.tvName);
        participantView = view.findViewById(R.id.participantView);
    }
  }
}
```

</TabItem>

</Tabs>

6. Add this adapter to the `SpeakerFragment`

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js title="SpeakerFragment.kt"
 override fun onCreateView(
      inflater: LayoutInflater, container: ViewGroup?,
      savedInstanceState: Bundle?
  ): View? {
    //...
    if (meeting != null) {
      //...
      val rvParticipants = view.findViewById<RecyclerView>(R.id.rvParticipants)
      rvParticipants.layoutManager = GridLayoutManager(mContext, 2)
      rvParticipants.adapter = SpeakerAdapter(meeting!!)
  }
}
```

</TabItem>

<TabItem value="Java">

```java title="SpeakerFragment.java"
 @Override
  public View onCreateView(LayoutInflater inflater, ViewGroup container,
                            Bundle savedInstanceState) {
    //...
    if (meeting != null) {
      //...
      final RecyclerView rvParticipants = view.findViewById(R.id.rvParticipants);
      rvParticipants.setLayoutManager(new GridLayoutManager(mContext, 2));
      rvParticipants.setAdapter(new SpeakerAdapter(meeting));
    }
}
```

</TabItem>

</Tabs>

#### Output

<center>

<img style={{height: '450px'}} src="https://cdn.videosdk.live/website-resources/docs-resources/android_ils_quickstart_speaker_screen.jpg" />

</center>




</Step>

<div className="heading-toc-only">
### Step 4: Implement ViewerView
</div>
<Step number={4} title="Implement ViewerView">

When host start the live streaming, viewer will be able to see the live streaming.

To implement player view, we are going to use `ExoPlayer`. It will be helpful to play hls stream.

Let's first add dependency into the project.

```js title="app/build.gradle"
dependencies {
  implementation 'com.google.android.exoplayer:exoplayer:2.18.5'
  // other app dependencies
  }
```

Create a new Fragment named `ViewerFragment`

The Viewer Fragment will include :

1. **TextView for Meeting Id** - The meeting Id that you joined will be displayed in this text view.
2. **Leave Button** - This button will leave the meeting.
3. **waitingLayout** - This is textView that will be shown when there is no active HLS.
4. **StyledPlayerView** - This is mediaplayer which will display livestreaming.

In `/app/res/layout/fragment_viewer.xml` file, replace the content with the following.

```xml title="fragment_viewer.xml"
<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:background="@color/black"
    tools:context=".ViewerFragment">

    <LinearLayout
        android:id="@+id/meetingLayout"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:paddingHorizontal="12sp"
        android:paddingVertical="5sp">

        <TextView
            android:id="@+id/meetingId"
            android:layout_width="0dp"
            android:layout_height="wrap_content"
            android:layout_weight="3"
            android:text="Meeting Id : "
            android:textColor="@color/white"
            android:textSize="20sp" />

        <Button
            android:id="@+id/btnLeave"
            android:layout_width="0dp"
            android:layout_height="wrap_content"
            android:layout_weight="1"
            android:text="Leave" />

    </LinearLayout>

    <TextView
        android:id="@+id/waitingLayout"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:text="Waiting for host \n to start the live streaming"
        android:textColor="@color/white"
        android:textFontWeight="700"
        android:textSize="20sp"
        android:gravity="center"/>

    <com.google.android.exoplayer2.ui.StyledPlayerView
        android:id="@+id/player_view"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:visibility="gone"
        app:resize_mode="fixed_width"
        app:show_buffering="when_playing"
        app:show_subtitle_button="false"
        app:use_artwork="false"
        app:show_next_button="false"
        app:show_previous_button="false"
        app:use_controller="true"
        android:layout_below="@id/meetingLayout"/>

</RelativeLayout>
```

**Initialize player and Playing HLS stream**

1. Initialize player and play the HLS when the meeting HLS state is `HLS_PLAYABLE`, and release it when the HLS state is `HLS_STOPPED`. Whenever the meeting HLS state changes, the event `onHlsStateChanged` will be triggered.

- when you receive `HLS_PLAYABLE` status you will receive 2 urls
  - `playbackHlsUrl` - Live HLS with playback support
  - `livestreamUrl` - Live HLS without playback support

:::note
`downstreamUrl` is now depecated. Use `playbackHlsUrl` or `livestreamUrl` in place of `downstreamUrl`
:::

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js title="ViewerFragment.kt"
class ViewerFragment : Fragment() {
  private var meeting: Meeting? = null
  private var playerView: StyledPlayerView? = null
  private var waitingLayout: TextView? = null
  private var player: ExoPlayer? = null
  private var dataSourceFactory: DefaultHttpDataSource.Factory? = null
  private val startAutoPlay = true
  private var playbackHlsUrl: String? = ""


  override fun onCreateView(
    inflater: LayoutInflater, container: ViewGroup?,
    savedInstanceState: Bundle?
  ): View? {
    // Inflate the layout for this fragment
    val view = inflater.inflate(R.layout.fragment_viewer, container, false)
    playerView = view.findViewById(R.id.player_view)
    waitingLayout = view.findViewById(R.id.waitingLayout)
    if (meeting != null) {
        //highlight-next-line
        // set MeetingId to TextView
        (view.findViewById<View>(R.id.meetingId) as TextView).text =
            "Meeting Id : " + meeting!!.meetingId
        //highlight-next-line
        // leave the meeting on btnLeave click
        (view.findViewById<View>(R.id.btnLeave) as Button).setOnClickListener { meeting!!.leave() }
        //highlight-next-line
        // add listener to meeting
        meeting!!.addEventListener(meetingEventListener)
    }
    return view
  }

  override fun onAttach(context: Context) {
      super.onAttach(context)
      mContext = context
      if (context is Activity) {
        mActivity = context
        //highlight-next-line
        // get meeting object from MeetingActivity
        meeting = (mActivity as MeetingActivity?)!!.meeting
      }
  }

  private val meetingEventListener: MeetingEventListener = object : MeetingEventListener() {
      override fun onMeetingLeft() {
        if (isAdded) {
          val intents = Intent(mContext, JoinActivity::class.java)
          intents.addFlags(
              Intent.FLAG_ACTIVITY_NEW_TASK
                      or Intent.FLAG_ACTIVITY_CLEAR_TOP or Intent.FLAG_ACTIVITY_CLEAR_TASK
          )
          startActivity(intents)
          mActivity!!.finish()
        }
      }

      //highlight-start
      @RequiresApi(api = Build.VERSION_CODES.P)
      override fun onHlsStateChanged(HlsState: JSONObject) {
        if (HlsState.has("status")) {
            try {
              if (HlsState.getString("status") == "HLS_PLAYABLE" && HlsState.has("playbackHlsUrl")) {
                playbackHlsUrl = HlsState.getString("playbackHlsUrl")
                waitingLayout!!.visibility = View.GONE
                playerView!!.visibility = View.VISIBLE
                // initialize player
                initializePlayer()
              }
              if (HlsState.getString("status") == "HLS_STOPPED") {
                // release the player
                releasePlayer()
                playbackHlsUrl = null
                waitingLayout!!.text = "Host has stopped \n the live streaming"
                waitingLayout!!.visibility = View.VISIBLE
                playerView!!.visibility = View.GONE
              }
            } catch (e: JSONException) {
                e.printStackTrace()
            }
          }
      }
      //highlight-end
  }

  private fun initializePlayer() {
    if (player == null) {
      dataSourceFactory = DefaultHttpDataSource.Factory()
      val mediaSource = HlsMediaSource.Factory(dataSourceFactory!!).createMediaSource(
          MediaItem.fromUri(Uri.parse(playbackHlsUrl))
      )
      val playerBuilder = ExoPlayer.Builder( /* context = */mContext!!)
      player = playerBuilder.build()
      // auto play when player is ready
      player!!.playWhenReady = startAutoPlay
      player!!.setMediaSource(mediaSource)
      // if you want display setting for player then remove this line
      playerView!!.findViewById<View>(com.google.android.exoplayer2.ui.R.id.exo_settings).visibility =
          View.GONE
      playerView!!.player = player
    }
    player!!.prepare()
  }

  private fun releasePlayer() {
    if (player != null) {
      player!!.release()
      player = null
      dataSourceFactory = null
      playerView!!.player = null
    }
  }

  override fun onDestroy() {
    mContext = null
    mActivity = null
    playbackHlsUrl = null
    releasePlayer()
    if (meeting != null) {
        meeting!!.removeAllListeners()
        meeting = null
    }
    super.onDestroy()
  }

  companion object {
    private var mActivity: Activity? = null
    private var mContext: Context? = null
  }
}
```

</TabItem>

<TabItem value="Java">

```java title="ViewerFragment.java"
public class ViewerFragment extends Fragment {

  private Meeting meeting;
  protected StyledPlayerView playerView;
  private TextView waitingLayout;
  protected @Nullable
  ExoPlayer player;

  private DefaultHttpDataSource.Factory dataSourceFactory;
  private boolean startAutoPlay=true;
  private String playbackHlsUrl = "";
  private static Activity mActivity;
  private static Context mContext;

  public ViewerFragment() {
      // Required empty public constructor
  }

  @Override
  public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
  }

  @Override
  public View onCreateView(LayoutInflater inflater, ViewGroup container,
                            Bundle savedInstanceState) {
    // Inflate the layout for this fragment
    View view = inflater.inflate(R.layout.fragment_viewer, container, false);

    playerView = view.findViewById(R.id.player_view);

    waitingLayout = view.findViewById(R.id.waitingLayout);
    if(meeting != null) {
      //highlight-next-line
      // set MeetingId to TextView
      ((TextView) view.findViewById(R.id.meetingId)).setText("Meeting Id : " + meeting.getMeetingId());
      //highlight-next-line
      // leave the meeting on btnLeave click
      ((Button) view.findViewById(R.id.btnLeave)).setOnClickListener(v -> meeting.leave());
      //highlight-next-line
      // add listener to meeting
      meeting.addEventListener(meetingEventListener);
    }
    return view;
  }


  @Override
  public void onAttach(@NonNull Context context) {
    super.onAttach(context);
    mContext = context;
    if (context instanceof Activity) {
      mActivity = (Activity) context;
      //highlight-next-line
      // get meeting object from MeetingActivity
      meeting = ((MeetingActivity) mActivity).getMeeting();
    }
  }

  private final MeetingEventListener meetingEventListener = new MeetingEventListener() {

      @Override
      public void onMeetingLeft() {
        if (isAdded()) {
          Intent intents = new Intent(mContext, JoinActivity.class);
          intents.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK
                  | Intent.FLAG_ACTIVITY_CLEAR_TOP | Intent.FLAG_ACTIVITY_CLEAR_TASK);
          startActivity(intents);
          mActivity.finish();
        }
      }

      //highlight-start
      @RequiresApi(api = Build.VERSION_CODES.P)
      @Override
      public void onHlsStateChanged(JSONObject HlsState) {
        if (HlsState.has("status")) {
          try {
            if (HlsState.getString("status").equals("HLS_PLAYABLE") && HlsState.has("playbackHlsUrl")) {
              playbackHlsUrl = HlsState.getString("playbackHlsUrl");
              waitingLayout.setVisibility(View.GONE);
              playerView.setVisibility(View.VISIBLE);
              // initialize player
              initializePlayer();
            }
            if (HlsState.getString("status").equals("HLS_STOPPED")) {
              // release the player
              releasePlayer();
              playbackHlsUrl = null;
              waitingLayout.setText("Host has stopped \n the live streaming");
              waitingLayout.setVisibility(View.VISIBLE);
              playerView.setVisibility(View.GONE);
            }
          } catch (JSONException e) {
              e.printStackTrace();
          }
        }
    }
    //highlight-end
  };

  protected void initializePlayer() {
    if (player == null) {
      dataSourceFactory = new DefaultHttpDataSource.Factory();
      HlsMediaSource mediaSource = new HlsMediaSource.Factory(dataSourceFactory).createMediaSource(
              MediaItem.fromUri(Uri.parse(this.playbackHlsUrl)));
      ExoPlayer.Builder playerBuilder =
              new ExoPlayer.Builder(/* context= */ mContext);
      player = playerBuilder.build();
      // auto play when player is ready
      player.setPlayWhenReady(startAutoPlay);
      player.setMediaSource(mediaSource);
      // if you want display setting for player then remove this line
      playerView.findViewById(com.google.android.exoplayer2.ui.R.id.exo_settings).setVisibility(View.GONE);
      playerView.setPlayer(player);
    }
    player.prepare();
  }

  protected void releasePlayer() {
    if (player != null) {
      player.release();
      player = null;
      dataSourceFactory = null;
      playerView.setPlayer(/* player= */ null);
    }
  }

  @Override
  public void onDestroy() {
    mContext = null;
    mActivity = null;
    playbackHlsUrl = null;
    releasePlayer();
    if (meeting != null) {
      meeting.removeAllListeners();
      meeting = null;
    }
    super.onDestroy();
  }

}
```

</TabItem>

</Tabs>

#### Output

<center>

<img style={{height: '450px',marginRight:'15px'}} src="https://cdn.videosdk.live/website-resources/docs-resources/android_ils_quickstart_viewer_screen_waiting.jpg" />

<img style={{height: '450px'}} src="https://cdn.videosdk.live/website-resources/docs-resources/android_ils_quickstart_viewer_screen.jpg" />

</center>

<br/>

</Step>

## Final Output

We are done with implementation of customised video calling app in Android using Video SDK. To explore more features go through Basic and Advanced features.

import ReactPlayer from 'react-player'

<div style={{textAlign: 'center'}}>

<ReactPlayer muted controls url="https://cdn.videosdk.live/website-resources/docs-resources/android_ils_quickstart.mp4" height="500px" width={"100%"} />

</div>

<br/>

:::tip
You can checkout the complete [quick start example here](https://github.com/videosdk-live/quickstart/tree/main/android-hls).
:::


---

---
title: Quick Start With Interactive Live Streaming | VideoSDK Android
hide_title: true
hide_table_of_contents: false
description: Learn how to quickly integrate interactive live streaming features using VideoSDK's Android SDK. Step-by-step guide for implementing real-time video & audio streaming in mobile applications with code examples.
sidebar_label: Start With Interactive Live Streaming
pagination_label: Start With Interactive Live Streaming
keywords:
  - android sdk
  - live streaming api
  - webrtc streaming
  - interactive livestream
  - video streaming
  - audio streaming
  - real-time communication
  - video conferencing
  - streaming tutorial
  - web sdk
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: quick-start-android-ils
---

import Step from '@site/src/components/Step'

import CautionMessage from '@site/src/theme/CautionMessage';

# Quick Start for Interactive Live Streaming in Android

**VideoSDK** empowers you to seamlessly integrate **interactive live streaming** features into your Android application in minutes. While built for meetings, the SDK is easily adaptable for live streaming with support for up to **100 hosts/co-hosts** and **2,000 viewers** in **real-time**. Perfect for social use cases, this guide will walk you through integrating live streaming into your app.

:::info

For standard live streaming with 6-7 second latency and playback support, follow this [documentation](./quick-start-ILS.md).
:::

## Prerequisites

Before proceeding, ensure that your development environment meets the following requirements:

- Android Studio Arctic Fox (2020.3.1) or later.
- Android SDK API Level 21 or higher.
- A mobile device that runs Android 5.0 or later.

## Getting Started with the Code!

Follow the steps to create the environment necessary to add video calls into your app. Also you can find the code sample for [quickstart here](https://github.com/videosdk-live/quickstart/tree/main/interactive-live-streaming/android-ils).

<CautionMessage sdk="Android SDK" version="v0.2.0" />

### Create new Android Project

For a new project in **Android Studio**, create a **Phone and Tablet** Android project with an **Empty Activity**.

![VideoSDK Android Quick Start New Project](https://cdn.videosdk.live/docs/images/android/quickstart/android_compose_newProject.jpg)

:::caution
After creating the project, Android Studio automatically starts gradle sync. Ensure that the sync succeeds before you continue.
:::

### Integrate Video SDK

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Maven Central"
groupId={"android-repositories"}
values={[{label: 'Maven Central', value: 'Maven Central'},{label: 'Jitpack', value: 'Jitpack'},]}>

<TabItem value="Maven Central">

```js title="settings.gradle"
dependencyResolutionManagement {
    repositories {
    google()
    mavenCentral()
    maven {url= uri("https://maven.aliyun.com/repository/jcenter")}
  }
}
```

</TabItem>

<TabItem value="Jitpack">

```js title="settings.gradle"
dependencyResolutionManagement{
  repositories {
    google()
    maven { url = uri("https://www.jitpack.io") }
    mavenCentral()
    maven {url= uri("https://maven.aliyun.com/repository/jcenter")}
  }
}
```

</TabItem>

</Tabs>

- Add the following dependency in your app's `app/build.gradle`.

```js title="app/build.gradle"
dependencies {
  implementation ("live.videosdk:rtc-android-sdk:0.3.0")

  // library to perform Network call to generate a stream id
  implementation ("com.amitshekhar.android:android-networking:1.0.2")

  // other app dependencies
  }
```

:::important

Android SDK compatible with armeabi-v7a, arm64-v8a, x86_64 architectures. If you want to run the application in an emulator, choose ABI x86_64 when creating a device.

:::

### Add permissions into your project

- In `/app/Manifests/AndroidManifest.xml`, add the following permissions.

```xml title="AndroidManifest.xml"
<uses-feature android:name="android.hardware.camera" android:required="false" />
<uses-permission android:name="android.permission.INTERNET"/>
<uses-permission android:name="android.permission.CAMERA"/>
<uses-permission android:name="android.permission.RECORD_AUDIO"/>
<uses-permission android:name="android.permission.MODIFY_AUDIO_SETTINGS"/>
```

:::note

If your project has set `android.useAndroidX=true`, then set `android.enableJetifier=true` in the `gradle.properties` file to migrate your project to AndroidX and avoid duplicate class conflict.

:::

### Structure of the project

Your project structure should look like this.

```jsx title="Project Structure"
app/
├── src/main/
│   ├── java/com/example/app/
│   │   ├── components/
│   │   ├── screens/
│   │   ├── ui/
│   │   │   └── theme/
│   │   ├── model/
│   │   ├── MainApplication.kt
│   │   ├── MainActivity.kt
│   │   └── NetworkClass.kt
|   |   └── StreamingMode.kt
│   ├── res/
│   └── AndroidManifest.xml
├── build.gradle
└── settings.gradle
```

### App Architecture

<center>

<img src='https://cdn.videosdk.live/website-resources/docs-resources/ils_qs_android_app_ architecture.png' />

</center>

<div className="heading-toc-only">
### Step 1: Initialize VideoSDK
</div>
<Step number={1} title="Initialize VideoSDK">

1. Create `MainApplication` class which will extend the `android.app.Application`.

- Create field `sampleToken` in `MainApplication` which will hold the generated token from the [VideoSDK dashboard](https://app.videosdk.live/api-keys). This token will use in VideoSDK config as well as generating meetingId.

```js title="MainApplication.kt"
import android.app.Application
import live.videosdk.rtc.android.VideoSDK

class MainApplication: Application() {

    val sampleToken = "YOUR_TOKEN" //paste your token here

    override fun onCreate() {
        super.onCreate()
        VideoSDK.initialize(applicationContext)
    }
}
```

2. Add `MainApplication` to `AndroidManifest.xml`

```xml title="AndroidManifest.xml"
<application
    android:name=".MainApplication"
   <!-- ... -->
</application>
```
</Step>

<div className="heading-toc-only">
### Step 2: Managing Permissions and Setting Up Navigation
</div>
<Step number={2} title="Managing Permissions and Setting Up Navigation">

The `MainActivity` handles permission requests for the camera and microphone and sets up navigation using Jetpack Compose.

Upon creation, it checks for required permissions (RECORD_AUDIO and CAMERA). If not granted, it requests them. Once permissions are granted, the MyApp composable is initialized, which contains the navigation logic through the NavigationGraph.

The NavigationGraph defines two screens:

- JoinScreen: For joining or create stream.
- StreamingScreen: For participating in a stream, passing meetingId and mode as arguments.

```js title="MainActivity.kt"
class MainActivity : ComponentActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        checkSelfPermission(REQUESTED_PERMISSIONS[0], PERMISSION_REQ_ID)
        checkSelfPermission(REQUESTED_PERMISSIONS[1], PERMISSION_REQ_ID)

        setContent {
            Videosdk_android_modes_quickstartTheme {
                MyApp(this) } }
    }

    private fun checkSelfPermission(permission: String, requestCode: Int): Boolean {
        if (ContextCompat.checkSelfPermission(this, permission) != PackageManager.PERMISSION_GRANTED) {
            ActivityCompat.requestPermissions(this, REQUESTED_PERMISSIONS, requestCode)
            return false
        }
        return true
    }

    companion object {
        private const val PERMISSION_REQ_ID = 22
        private val REQUESTED_PERMISSIONS = arrayOf(Manifest.permission.RECORD_AUDIO, Manifest.permission.CAMERA)
    }
}

@Composable
fun MyApp(context: Context) {
    NavigationGraph(context = context)
}

@Composable
fun NavigationGraph(navController: NavHostController = rememberNavController(), context: Context) {
    NavHost(navController = navController, startDestination = "join_screen") {
        composable("join_screen") { JoinScreen(navController, context) }
        composable("stream_screen?streamId={streamId}&mode={mode}") { backStackEntry ->
            val streamId = backStackEntry.arguments?.getString("streamId")
            val modeStr = backStackEntry.arguments?.getString("mode")
            val mode = StreamingMode.valueOf(modeStr ?: StreamingMode.SendAndReceive.name)

            streamId?.let {
                StreamingScreen(viewModel = StreamViewModel(), navController, streamId, mode, context)
            }
        }
    }
}
```
</Step>

<div className="heading-toc-only">
### Step 3: Creating Reusable Components
</div>
<Step number={3} title="Creating Reusable Components">

- Before building the individual screens, it's essential to develop reusable composable components that will be used throughout the project.

1. Create a `ReusableComponents.kt` file to organize all reusable components for the project, such as buttons, spacers, and customizable text.

```js title="ReusableComponents.kt"
@Composable
fun MyAppButton(task: () -> Unit, buttonName: String) {
    Button(onClick = task) {
        Text(text = buttonName) }
}

@Composable
fun MySpacer() {
    Spacer(modifier = Modifier.fillMaxWidth()
            .height(1.dp)
            .background(color = Color.Gray)) }

@Composable
fun MyText(text: String, fontSize: TextUnit = 23.sp) {
    Text(text = text,
        fontSize = fontSize,
        fontWeight = FontWeight.Normal,
        modifier = Modifier.padding(4.dp),
        style = MaterialTheme.typography.bodyMedium.copy(fontSize = 16.sp),
        color = MaterialTheme.colorScheme.onSurface.copy(alpha = 0.7f))
}
```

2. Create a `ParticipantVideoView.kt` file that includes two composable functions: `ParticipantVideoView` for rendering individual participant video streams, and `ParticipantsGrid` for displaying a grid of participant videos.

:::info

- Here the participant's video is displayed using `VideoView`. To know more about `VideoView`, please visit [here](/android/guide/video-and-audio-calling-api-sdk/render-media/display-video/understand-videoView-component)
- `VideoView` is a custom View. Since Jetpack Compose does not natively support traditional `View` objects, we need to integrate the `VideoView` into the Compose layout using the `AndroidView` wrapper.
- `AndroidView()` is a composable that can be used to add Android views inside a @Composable function.

:::

```js title="ParticipantVideoView.kt"
@Composable
fun ParticipantVideoView(
    participant: Participant
) {
        var isVideoEnabled by remember { mutableStateOf(false) }
        // Remember the event listener to prevent recreation on each recomposition
        val eventListener = remember(participant) {
            object : ParticipantEventListener() {
                override fun onStreamEnabled(stream: Stream) {
                    if (stream.kind.equals("video", ignoreCase = true)) {
                        val videoTrack = stream.track as VideoTrack
                        isVideoEnabled = true
                    }
                }
                override fun onStreamDisabled(stream: Stream) {
                    if (stream.kind.equals("video", ignoreCase = true)) {
                        isVideoEnabled = false
                    }
                }
            }
        }

        // Add and remove the event listener using side effects
        DisposableEffect(participant, eventListener) {
            participant.addEventListener(eventListener)
            onDispose { participant.removeEventListener(eventListener) }
        }

        // Initial video state check
        LaunchedEffect(participant) {
            val hasVideoStream = participant.streams.any { (_, stream) ->
                stream.kind.equals("video", ignoreCase = true) && stream.track != null
            }
            isVideoEnabled = hasVideoStream
        }

        Box(
            modifier = Modifier.fillMaxWidth()
                .height(200.dp)
                .background(if (isVideoEnabled) Color.DarkGray else Color.Gray)
        ) {
            AndroidView(
                factory = { context ->
                    VideoView(context).apply {
                        for ((_, stream) in participant.streams) {
                            if (stream.kind.equals("video", ignoreCase = true)) {
                                val videoTrack = stream.track as VideoTrack
                                addTrack(videoTrack)
                                isVideoEnabled = true
                            }
                        }
                    }
                },
                update = { videoView ->
                    // Handle video track updates only
                    // The event listener is now managed separately
                    for ((_, stream) in participant.streams) {
                        if (stream.kind.equals(
                                "video",
                                ignoreCase = true
                            ) && stream.track != null
                        ) {
                            val videoTrack = stream.track as VideoTrack
                            videoView.addTrack(videoTrack)
                        }
                    }
                },
                modifier = Modifier.fillMaxSize()
            )

            if (!isVideoEnabled) {
                Box(
                    modifier = Modifier.fillMaxSize()
                        .background(Color.DarkGray),
                    contentAlignment = Alignment.Center
                ) {
                    Text(text = "Camera Off", color = Color.White)
                }
            }

            Box(
                modifier = Modifier.align(Alignment.BottomCenter)
                    .fillMaxWidth()
                    .background(Color(0x99000000))
                    .padding(4.dp)
            ) {
                Text(
                    text = participant.displayName,
                    color = Color.White,
                    modifier = Modifier.align(Alignment.Center)
                )
            }
        }
}

@Composable
fun ParticipantsGrid(
    participants: List<Participant>,
    modifier: Modifier = Modifier
) {
    LazyVerticalGrid(columns = GridCells.Fixed(2),
        verticalArrangement = Arrangement.spacedBy(16.dp),
        horizontalArrangement = Arrangement.spacedBy(16.dp),
        modifier = modifier.fillMaxWidth()
            .padding(8.dp)
    ) {
        items(participants.size) { index ->
            ParticipantVideoView(participant = participants[index])
        }
    }
}
```

Before proceeding, let's understand the two modes of a Live Stream:

<div style={{textAlign: 'center'}}>
<img
  src="https://cdn.videosdk.live/website-resources/docs-resources/ils_mode_demonstration-compressed.jpg"
  alt="ILS Mode Demonstration"
  width="550"
  height="450"
/>
</div>

1. SEND_AND_RECV:

- Designed primarily for the Host or Co-host.
- Allows sending and receiving media.
- Hosts can broadcast their audio/video and interact directly with the audience.

2. RECV_ONLY:

- Tailored for the Audience.
- Enables receiving media shared by the Host.
- Audience members can view and listen but cannot share their own media.

```js title="StreamingMode"
enum class StreamingMode {
    SendAndReceive,
    ReceiveOnly
}
```
</Step>

<div className="heading-toc-only">
### Step 4: Creating Joining Screen
</div>
<Step number={4} title="Creating Joining Screen">

Join screen will serve as a medium to either Create a new Live Stream or join an existing one as a host or a audience.

We will create a simple UI for the Join screen that includes three action buttons for joining or creating a Live Stream:

1. **`Create Stream`**: Lets the user initiate a new Live Stream in SEND_AND_RECV mode, granting full host controls.
2. **`Join as Host`**: Allows the user to join an existing Live Stream using the provided meetingId with the SEND_AND_RECV mode, enabling full host privileges.
3. **`Join as Audience`**: Enables the user to join an existing Live Stream using the provided meetingId with the RECV_ONLY mode, allowing view-only access.

```js title="JoinScreen.kt"
@Composable
fun JoinScreen(
    navController: NavController, context: Context
) {
    val app = context.applicationContext as MainApplication
    val token = app.sampleToken
    Box(
        modifier = Modifier.fillMaxSize()
            .padding(8.dp),
        contentAlignment = Alignment.Center
    ) {
        Column(
            modifier = Modifier.padding(4.dp),
            horizontalAlignment = Alignment.CenterHorizontally,
            verticalArrangement = Arrangement.SpaceEvenly
        ) {
            var input by rememberSaveable { mutableStateOf("") }
            CreateStreamBtn(navController, token)
            Text(text = "OR")
            InputMeetingId(input) { updateInput -> input = updateInput }
            JoinHostBtn(navController, input)
            JoinAudienceBtn(navController, input)
        }
    }
}


@Composable
fun JoinHostBtn(navController: NavController, streamId: String) {
    MyAppButton({
        if (streamId.isNotEmpty()) {
            navController.navigate("stream_screen?streamId=$streamId&mode=${StreamingMode.SendAndReceive.name}")
        }
    }, "Join as Host")
}

@Composable
fun JoinAudienceBtn(navController: NavController, streamId: String) {
    MyAppButton({
        if (streamId.isNotEmpty()) {
            navController.navigate("stream_screen?streamId=$streamId&mode=${StreamingMode.ReceiveOnly.name}")
        }
    }, "Join as Audience")
}

@Composable
fun CreateStreamBtn(navController: NavController, token: String) {
    MyAppButton({
        NetworkManager.createStreamId(token) { streamId ->
            navController.navigate("stream_screen?streamId=$streamId&mode=${StreamingMode.SendAndReceive.name}")
        }
    }, "Create Stream")
}

@Composable
fun InputMeetingId(input: String, onInputChange: (String) -> Unit) {
    OutlinedTextField(value = input,
        onValueChange = onInputChange,
        label = { Text(text = "Enter Stream Id") })
}
```

#### Output

<div style={{ textAlign: 'center' }}>
    <img 
        src='https://cdn.videosdk.live/website-resources/docs-resources/ils_qs_android_join_screen.png' 
        alt="VideoSDK Android Quick Start joining Screen" 
         style={{height: '450px'}}
    />
</div>
</Step>

<div className="heading-toc-only">
### Step 5: Creating StreamId
</div>
<Step number={5} title="Creating StreamId">

The `NetworkManager` singleton handles stream creation by making a POST request to the [VideoSDK API](https://docs.videosdk.live/api-reference/realtime-communication/create-room):

- stream Creation: Sends a request to the API with an authorization token to create a stream.
- Response Handling: Extracts the roomId from the response and triggers the `onMeetingCreated` callback.

```js title="NetworkManager"
object NetworkManager {
    fun createStreamId(token: String, onStreamIdCreated: (String) -> Unit) {
        AndroidNetworking.post("https://dev-api.videosdk.live/v2/rooms")
            .addHeaders("Authorization", token)
            .build()
            .getAsJSONObject(object : JSONObjectRequestListener {
                override fun onResponse(response: JSONObject) {
                    try {
                        val streamId = response.getString("roomId")
                        onStreamIdCreated(streamId)
                    } catch (e: JSONException) {
                        e.printStackTrace()
                    }
                }
                override fun onError(anError: ANError) {
                    anError.printStackTrace()
                    Log.d("TAG", "onError: $anError")
                }
            })
    }
}
```

:::note

Don't confuse with Room and stream keyword, both are same thing 😃

:::
</Step>

<div className="heading-toc-only">
### Step 6: Creating Streaming Screen
</div>
<Step number={6} title="Creating Streaming Screen">

We will create a simple Streaming screen UI with two main sections:

1. `Header`: Displays the stream ID and current streaming mode at the top of the screen for reference.
2. `ParticipantsGrid`: Shows the list of participants in a grid layout, adjusting dynamically.

:::note

In Step 3, we created the ParticipantsGrid component.

:::

```js title="StreamingScreen.kt"
@Composable
fun StreamingScreen(viewModel: StreamViewModel, navController: NavController,
    streamId: String,
    mode: StreamingMode,
    context: Context
) {
    val app = context.applicationContext as MainApplication
    val isStreamLeft = viewModel.isStreamLeft
    val currentMode = viewModel.currentMode
    val isJoined = viewModel.isJoined

    LaunchedEffect(isStreamLeft) {
        if (isStreamLeft) {
            navController.navigate("join_screen") }
    }

    Column(modifier = Modifier.fillMaxSize()) {
        Header(streamId, currentMode)
        MySpacer()
        ParticipantsGrid(
            participants = viewModel.currentParticipants,
            modifier = Modifier.weight(1f)
        )
        MySpacer()
        MediaControlButtons(
            onJoinClick = { viewModel.initStream(context, app.sampleToken, streamId, mode)},
            onMicClick = { viewModel.toggleMic() },
            onCamClick = { viewModel.toggleWebcam()},
            onModeToggleClick = { viewModel.toggleMode() },
            showMediaControls = currentMode == StreamingMode.SendAndReceive,
            currentMode = currentMode,
            onLeaveClick = { viewModel.leaveStream() },
            isJoined = isJoined )
    }
}
@Composable
fun Header(streamId: String, mode: StreamingMode) {
    val context = LocalContext.current
    val clipboardManager = context.getSystemService(Context.CLIPBOARD_SERVICE) as ClipboardManager

    Box(modifier = Modifier.fillMaxWidth()
                        .padding(8.dp),
        contentAlignment = Alignment.TopStart
    ) {
        Row( modifier = Modifier.fillMaxWidth(),
            horizontalArrangement = Arrangement.SpaceBetween,
            verticalAlignment = Alignment.CenterVertically
        ) {
            Column {
                Row(verticalAlignment = Alignment.CenterVertically) {
                    MyText("StreamID: ", 28.sp)
                    MyText(streamId, 25.sp)
                    IconButton( onClick = {
                            val clip = ClipData.newPlainText("Stream ID", streamId)
                            clipboardManager.setPrimaryClip(clip)
                        })
                    {
                        //get baseline_content_copy_24 icon from Vector Asset
                        Icon( painter = painterResource(R.drawable.baseline_content_copy_24),
                            contentDescription = "Copy Stream ID",
                            modifier = Modifier.size(40.dp).padding(start = 8.dp)
                        )
                    }
                }
                Row {
                    MyText("Mode: ", 20.sp)
                    MyText(mode.name, 18.sp)
                }
            }
        }
    }
}
//...
```
</Step>

<div className="heading-toc-only">
### Step 7: Implementing Mode Switch and Media Toggles
</div>
<Step number={7} title="Implementing Mode Switch and Media Toggles">

Implement interactive controls to leave the stream, toggle microphone and webcam, and switch between Host (SEND_AND_RECV) and Audience (RECV_ONLY) modes for a seamless experience.

```js title="StreamingScreen.kt"
@Composable
fun MediaControlButtons(
    onJoinClick: () -> Unit,
    onMicClick: () -> Unit,
    onCamClick: () -> Unit,
    onModeToggleClick: () -> Unit,
    onLeaveClick: () -> Unit,
    showMediaControls: Boolean = true,
    currentMode: StreamingMode,
    isJoined: Boolean
) {
    Column( modifier = Modifier.fillMaxWidth()
                        .padding(6.dp),
        horizontalAlignment = Alignment.CenterHorizontally,
        verticalArrangement = Arrangement.spacedBy(8.dp)
    ) {
        Row( modifier = Modifier.fillMaxWidth(),
            horizontalArrangement = Arrangement.SpaceEvenly,
            verticalAlignment = Alignment.CenterVertically
        ) {
            if (!isJoined) {
                MyAppButton(onJoinClick, "Join")
            }
            if (showMediaControls && isJoined) {  // Only show media controls if joined
                MyAppButton(onMicClick, "ToggleMic")
                MyAppButton(onCamClick, "ToggleCam")
            }
        }

        Row( modifier = Modifier.fillMaxWidth(),
            horizontalArrangement = Arrangement.SpaceEvenly,
            verticalAlignment = Alignment.CenterVertically
        ) {
            if (isJoined) {
                MyAppButton(onLeaveClick, "Leave")
                MyAppButton(
                    task = onModeToggleClick,
                    buttonName = if (currentMode == StreamingMode.SendAndReceive)
                        "Switch to Audience"
                    else
                        "Switch to Host"
                )
            }
        }
    }
}
```
</Step>

<div className="heading-toc-only">
### Step 8: Setting Up StreamViewModel
</div>
<Step number={8} title="Setting Up StreamViewModel">

The `StreamViewModel` manages the core functionality of Interactive Live Streaming (ILS), serving as the central state manager:

1. **Stream State Management**

   - Handles stream initialization with appropriate mode (Conference/Audience)
   - Tracks stream lifecycle (joined, left, current mode)

2. **Media Control Integration**

   - Provides microphone toggle (mute/unmute)
   - Controls webcam state (enable/disable)

3. **Mode Switching**
   - Enables seamless transitions between Conference and Audience modes

```js title="StreamViewModel"
class StreamViewModel : ViewModel() {
    private var stream: Meeting? = null
    private var micEnabled by mutableStateOf(true)
    private var webcamEnabled by mutableStateOf(true)
    var isConferenceMode by mutableStateOf(true)
    val currentParticipants = mutableStateListOf<Participant>()

    var localParticipantId by mutableStateOf("")
        private set

    var isStreamLeft by mutableStateOf(false)
        private set

    var currentMode by mutableStateOf(StreamingMode.SendAndReceive)
        private set

    var isJoined by mutableStateOf(false)
        private set

    fun initStream(context: Context, token: String, streamId: String, mode: StreamingMode) {
        VideoSDK.config(token)
        currentMode = mode
        if (stream == null) {
            stream = if (mode.name == StreamingMode.SendAndReceive.name) {
                VideoSDK.initMeeting(
                    context,"54dr-h8c5-hsif", "John Doe",
                    micEnabled, webcamEnabled, null, null, true, null, null
                )
            } else {
                VideoSDK.initMeeting(
                    context, "54dr-h8c5-hsif", "John Doe",
                    micEnabled, webcamEnabled, null, "RECV_ONLY", true, null, null
                )
            }
        }
        stream!!.addEventListener(meetingEventListener)
        stream!!.join()
        isJoined = true
    }

    private val meetingEventListener: MeetingEventListener = object : MeetingEventListener() {
        override fun onMeetingJoined() {
            stream?.let {
                if (it.localParticipant.mode != "RECV_ONLY") {
                    if (!currentParticipants.contains(it.localParticipant)) {
                        currentParticipants.add(it.localParticipant)
                    }
                }
                localParticipantId = it.localParticipant.id
            }
        }

        override fun onMeetingLeft() {
            currentParticipants.clear()
            stream = null
            isStreamLeft = true
        }

        override fun onParticipantJoined(participant: Participant) {
            if (participant.mode != "RECV_ONLY") {
                currentParticipants.add(participant)
            }
        }

        override fun onParticipantLeft(participant: Participant) {
            currentParticipants.remove(participant)
        }

        override fun onParticipantModeChanged(data: JSONObject?) {
            try {
                val participantId = data?.getString("peerId")
                val participant = if (stream?.localParticipant?.id == participantId) {
                    stream?.localParticipant
                } else {
                    stream?.participants?.get(participantId)
                }

                participant?.let {
                    when (it.mode) {
                        "RECV_ONLY" -> {
                            currentParticipants.remove(it)
                        }
                        "SEND_AND_RECV" -> {
                            if (!currentParticipants.contains(it)) {
                                currentParticipants.add(it)
                            } else { }
                        }
                        else -> {}
                    }
                }
            } catch (e: JSONException) {
                e.printStackTrace()
            }
        }
    }

    fun toggleMic() {
        if (micEnabled) stream?.muteMic() else stream?.unmuteMic()
        micEnabled = !micEnabled
    }

    fun toggleWebcam() {
        if (webcamEnabled) stream?.disableWebcam() else stream?.enableWebcam()
        webcamEnabled = !webcamEnabled
    }

    fun leaveStream() {
        currentParticipants.clear()
        stream?.leave()
        stream?.removeAllListeners()
        isStreamLeft = true
        isJoined = false
    }

    fun toggleMode() {
        val newMode = if (currentMode == StreamingMode.SendAndReceive) {
            stream?.disableWebcam()
            stream?.changeMode("RECV_ONLY")
            isConferenceMode = false
            StreamingMode.ReceiveOnly
        } else {
            stream?.changeMode("SEND_AND_RECV")
            isConferenceMode = true
            StreamingMode.SendAndReceive
        }

        // Clear all participants first
        currentParticipants.clear()

        // Wait briefly for mode change to complete
        stream?.let { it ->
            // Add back all non-viewer participants
            it.participants.values.forEach { participant ->
                if (participant.mode != "RECV_ONLY") {
                    currentParticipants.add(participant)
                }
            }

            // Add local participant only if in SEND_AND_RECV mode
            if (newMode == StreamingMode.SendAndReceive) {
                it.localParticipant?.let { localParticipant ->
                    if (!currentParticipants.contains(localParticipant)) {
                        currentParticipants.add(localParticipant)
                    }
                }
                // Re-enable webcam if it was enabled before
                if (webcamEnabled) {
                    it.enableWebcam() }
            }
        }
        currentMode = newMode
    }
}
```

<div style={{ textAlign: 'center' }}>
    <img 
        src='https://cdn.videosdk.live/website-resources/docs-resources/ils_qs_android_send_and_receive_screen.png'  
        alt="VideoSDK Android Quick Start Meeting Screen" 
       style={{height: '450px'}}
    />
</div>
</Step>

## Final Output

We are done with implementation of customised video calling app in Android using Video SDK. To explore more features go through Basic and Advanced features.


import ReactPlayer from 'react-player'

<div style={{textAlign: 'center'}}>

<ReactPlayer autoplay muted loop playing controls url="https://cdn.videosdk.live/website-resources/docs-resources/ils_qs_android_screen_recording.mp4" playbackRate={1.8} height="500px" width={"100%"} />

</div>

:::tip
You can checkout the complete [quick start example here](https://github.com/videosdk-live/quickstart/tree/main/interactive-live-streaming/android-ils).
:::


---

---
title: ComposeUI Quick Start with Android
hide_title: false
hide_table_of_contents: false
description: Video SDK enables the opportunity to integrate native IOS, Android & Web SDKs to add live video & audio conferencing to your applications.
sidebar_label: Start a Audio / Video Call (Compose)
pagination_label: Quick Start with Android
keywords:
  - audio calling
  - video calling
  - real-time communication
  - collaboration
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: quick-start-compose-ui
---

import Step from '@site/src/components/Step'

# Quick Start for Conference in Android

VideoSDK enables you to embed the video calling feature into your Android application in minutes.

In this quickstart, we are going to explore group calling feature of Video SDK. We will go through step by step guide of integrating video calling with Android Video SDK.

This guide will get you running with the VideoSDK video & audio calling in minutes.

## Prerequisites

Before proceeding, ensure that your development environment meets the following requirements:

- Android Studio Arctic Fox (2020.3.1) or later.
- Android SDK API Level 21 or higher.
- A mobile device that runs Android 5.0 or later.

:::important

One should have a VideoSDK account to generate token.
Visit VideoSDK **[dashboard](https://app.videosdk.live/api-keys)** to generate token

:::

## Getting Started with the Code!

Follow the steps to create the environment necessary to add video calls into your app. Also you can find the code sample for [quickstart here](https://github.com/videosdk-live/quickstart/tree/main/android-rtc/Videosdk_android_compose_quickstart/).

### Create new Android Project

For a new project in **Android Studio**, create a **Phone and Tablet** Android project with an **Empty Activity**.

![VideoSDK Android Quick Start New Project](https://cdn.videosdk.live/docs/images/android/quickstart/android_compose_newProject.jpg )

:::caution
After creating the project, Android Studio automatically starts gradle sync. Ensure that the sync succeeds before you continue.
:::

### Integrate Video SDK

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Maven Central"
groupId={"android-repositories"}
values={[{label: 'Maven Central', value: 'Maven Central'},{label: 'Jitpack', value: 'Jitpack'},]}>

<TabItem value="Maven Central">

```js title="settings.gradle"
dependencyResolutionManagement {
    repositories {
    google()
    mavenCentral()
    maven {url= uri("https://maven.aliyun.com/repository/jcenter")}
  }
}
```

</TabItem>

<TabItem value="Jitpack">

```js title="settings.gradle"
dependencyResolutionManagement{
  repositories {
    google()
    maven { url = uri("https://www.jitpack.io") }
    mavenCentral()
    maven {url= uri("https://maven.aliyun.com/repository/jcenter")}
  }
}
```

</TabItem>

</Tabs>

- Add the following dependency in your app's `app/build.gradle`.

```js title="app/build.gradle"
dependencies {
  implementation ("live.videosdk:rtc-android-sdk:0.3.0")

  // library to perform Network call to generate a meeting id
  implementation ("com.amitshekhar.android:android-networking:1.0.2")

  // other app dependencies
  }
```

:::important

Android SDK compatible with armeabi-v7a, arm64-v8a, x86_64 architectures. If you want to run the application in an emulator, choose ABI x86_64 when creating a device.

:::

### Add permissions into your project

- In `/app/Manifests/AndroidManifest.xml`, add the following permissions.

```xml title="AndroidManifest.xml"
<uses-feature android:name="android.hardware.camera" android:required="false" />
<uses-permission android:name="android.permission.INTERNET"/>
<uses-permission android:name="android.permission.CAMERA"/>
<uses-permission android:name="android.permission.RECORD_AUDIO"/>
<uses-permission android:name="android.permission.MODIFY_AUDIO_SETTINGS"/>
```

:::note

If your project has set `android.useAndroidX=true`, then set `android.enableJetifier=true` in the `gradle.properties` file to migrate your project to AndroidX and avoid duplicate class conflict.

:::

### Structure of the project

Your project structure should look like this.

```jsx title="Project Structure"
app/
├── src/main/
│   ├── java/com/example/app/
│   │   ├── components/          
│   │   ├── screens/            
│   │   ├── navigation/          
│   │   ├── ui/                  
│   │   │   └── theme/           
│   │   ├── model/               
│   │   ├── MainApplication.kt   
│   │   ├── MainActivity.kt      
│   │   └── NetworkClass.kt      
│   ├── res/                     
│   └── AndroidManifest.xml      
├── build.gradle
└── settings.gradle
```


### App Architecture

<center>

<img src='https://cdn.videosdk.live/docs/images/android/quickstart/android_compose_quickstart_app_structure.jpg ' />

</center>

<div className="heading-toc-only">
### Step 1: Initialize VideoSDK
</div>
<Step number={1} title="Initialize VideoSDK">

1. Create `MainApplication` class which will extend the `android.app.Application`.

- Create field `sampleToken` in `MainApplication` which will hold the generated token from the [VideoSDK dashboard](https://app.videosdk.live/api-keys). This token will use in VideoSDK config as well as in generating meetingId.


```js title="MainApplication.kt"
import android.app.Application
import live.videosdk.rtc.android.VideoSDK

class MainApplication: Application() {

    val sampleToken = "YOUR_TOKEN" //paste your token here

    override fun onCreate() {
        super.onCreate()
        VideoSDK.initialize(applicationContext)
    }
}
```

2. Add `MainApplication` to `AndroidManifest.xml`

```xml title="AndroidManifest.xml"
<application
    android:name=".MainApplication" >
   <!-- ... -->
</application>
```
</Step>

<div className="heading-toc-only">
### Step 2: Managing Permissions
</div>
<Step number={2} title="Managing Permissions">

The `MainActivity` is the entry point of the application. It handles permission requests for accessing the camera and microphone.

On creation, it checks if the required permissions (RECORD_AUDIO and CAMERA) are granted.

If not, it requests them. Once permissions are granted, it sets the content view using Jetpack Compose and initializes the MyApp composable, which contains the app's navigation and UI logic.

```js title="MainActivity.kt"
class MainActivity : ComponentActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        checkSelfPermission(REQUESTED_PERMISSIONS[0], PERMISSION_REQ_ID)
        checkSelfPermission(REQUESTED_PERMISSIONS[1], PERMISSION_REQ_ID)

        setContent {
            Videosdk_android_compose_quickstartTheme {
                MyApp(this)
            }
        }
    }

    private fun checkSelfPermission(permission: String, requestCode: Int): Boolean {
        if (ContextCompat.checkSelfPermission(this, permission) !=
            PackageManager.PERMISSION_GRANTED
        ) {
            ActivityCompat.requestPermissions(this,
                REQUESTED_PERMISSIONS, requestCode)
            return false
        }
        return true
    }

    companion object {
        private const val PERMISSION_REQ_ID = 22
        private val REQUESTED_PERMISSIONS = arrayOf(
            Manifest.permission.RECORD_AUDIO,
            Manifest.permission.CAMERA
        )
    }
}

@Composable
fun MyApp(context: Context) {
    NavigationGraph(context = context)
}
```
</Step>

<div className="heading-toc-only">
### Step 3: Setting Up Navigation
</div>
<Step number={3} title="Setting Up Navigation">

The `NavigationGraph` composable manages navigation between the `JoinScreen` and `MeetingScreen` using `NavController`.

```js title="NavigationGraph.kt"
@Composable
fun NavigationGraph(navController: NavHostController = rememberNavController(),context: Context) {
    NavHost(navController = navController, startDestination = "join_screen") {
        composable("join_screen") {
            JoinScreen(navController,context)
        }
        composable("meeting_screen?meetingId={meetingId}") { backStackEntry ->
            val meetingId = backStackEntry.arguments?.getString("meetingId")
            meetingId?.let {
                MeetingScreen(viewModel = MeetingViewModel(),navController, meetingId, context)
            }
        }
    }
}
```
</Step>

<div className="heading-toc-only">
### Step 4: Creating Components
</div>
<Step number={4} title="Creating Components">

- Before building the individual screens, it's essential to develop reusable composable components that will be used throughout the project.

1. Create a `ReusableComponents.kt` file to organize all reusable components for the project, such as buttons, spacers, and customizable text.

```js title="ReusableComponents.kt"
@Composable
fun MyAppButton(task: () -> Unit, buttonName: String) {
    Button(onClick = task) {
        Text(text = buttonName)
    }
}
@Composable
fun MySpacer() {
    Spacer(
        modifier = Modifier
            .fillMaxWidth()
            .height(1.dp)
            .background(color = Color.Gray))}
@Composable
fun MyText(text: String, fontSize: TextUnit = 23.sp) {
    Text(
        text = text,
        fontSize = fontSize,
        fontWeight = FontWeight.Normal,
        modifier = Modifier.padding(4.dp),
        style = MaterialTheme.typography.bodyMedium.copy(fontSize = 16.sp),
        color = MaterialTheme.colorScheme.onSurface.copy(alpha = 0.7f)
    )}
```
2. Create a `ParticipantVideoView.kt` file that includes two composable functions: `ParticipantVideoView` for rendering individual participant video streams, and `ParticipantsGrid` for displaying a grid of participant videos.

:::info

- Here the participant's video is displayed using `VideoView`. To know more about `VideoView`, please visit [here](/android/guide/video-and-audio-calling-api-sdk/render-media/display-video/understand-videoView-component)
- `VideoView` is a custom View. Since Jetpack Compose does not natively support traditional `View` objects, we need to integrate the `VideoView` into the Compose layout using the `AndroidView` wrapper.
- `AndroidView()` is a composable that can be used to add Android views inside a @Composable function.

:::

```js title="ParticipantVideoView.kt"
@Composable
fun ParticipantVideoView(
    participant: Participant
) {
    var isVideoEnabled by remember { mutableStateOf(false) }

    LaunchedEffect(participant) {
        isVideoEnabled = participant.streams.any { (_, stream) ->
            stream.kind.equals("video", ignoreCase = true) && stream.track != null
        }
    }
    Box(
        modifier = Modifier
            .fillMaxWidth()
            .height(200.dp)
            .background(if (isVideoEnabled) Color.DarkGray else Color.Gray)
    ) {
        AndroidView(
            factory = { context ->
                VideoView(context).apply {
                    for ((_, stream) in participant.streams) {
                        if (stream.kind.equals("video", ignoreCase = true)) {
                            val videoTrack = stream.track as VideoTrack
                            addTrack(videoTrack)
                            isVideoEnabled = true
                        }
                    }
                }
            },
            update = { videoView ->
                participant.addEventListener(object : ParticipantEventListener() {
                    override fun onStreamEnabled(stream: Stream) {
                        if (stream.kind.equals("video", ignoreCase = true)) {
                            val videoTrack = stream.track as VideoTrack
                            videoView.addTrack(videoTrack)
                            isVideoEnabled = true
                        }
                    }

                    override fun onStreamDisabled(stream: Stream) {
                        if (stream.kind.equals("video", ignoreCase = true)) {
                            videoView.removeTrack()
                            isVideoEnabled = false
                        }
                    }
                })
            },
            onRelease = { videoView ->
                videoView.releaseSurfaceViewRenderer()
            },
            modifier = Modifier.fillMaxSize()
        )

        if (!isVideoEnabled) {
            Box(
                modifier = Modifier
                    .fillMaxSize()
                    .background(Color.DarkGray),
                contentAlignment = Alignment.Center
            ) {
                Text(
                    text = "Camera Off",
                    color = Color.White
                )
            }
        }

        Box(
            modifier = Modifier
                .align(Alignment.BottomCenter)
                .fillMaxWidth()
                .background(Color(0x99000000))
                .padding(4.dp)
        ) {
            Text(
                text = participant.displayName,
                color = Color.White,
                modifier = Modifier.align(Alignment.Center)
            )
        }
    }
}
@Composable
fun ParticipantsGrid(
    participants: List<Participant>,
    modifier: Modifier = Modifier
) {
    LazyVerticalGrid(
        columns = GridCells.Fixed(2),
        verticalArrangement = Arrangement.spacedBy(16.dp),
        horizontalArrangement = Arrangement.spacedBy(16.dp),
        modifier = modifier
            .fillMaxWidth()
            .padding(8.dp)
    ) {
        items(participants.size) { index ->
            ParticipantVideoView(
                participant = participants[index],
            )
        }
    }
}
```
</Step>

<div className="heading-toc-only">
### Step 5: Creating Joining Screen
</div>
<Step number={5} title="Creating Joining Screen">

We will create a simple Join screen UI that supports two primary roles:

- Create Meeting: Starts a new meeting.
- Join Meeting: Enter a Meeting ID to join an existing meeting.

The Joining screen will include :

1. **Create Button** - This button will create a new meeting for you.
2. **TextField for Meeting Id** - This text field will contain the meeting Id you want to join.
3. **Join Button** - This button will join the meeting with `meetingId` you provided.

```js title="JoinScreen.kt"
@Composable
fun JoinScreen(
    navController: NavController, context: Context
) {
    val app = context.applicationContext as MainApplication
    val token = app.sampleToken
    Box(
        modifier = Modifier
            .fillMaxSize()
            .padding(8.dp),
        contentAlignment = Alignment.Center
    ) {
        Column(
            modifier = Modifier.padding(4.dp),
            horizontalAlignment = Alignment.CenterHorizontally,
            verticalArrangement = Arrangement.SpaceEvenly
        ) {
            var input by rememberSaveable { mutableStateOf("") }
            CreateMeetingBtn(navController, token)
            Text(text = "OR")
            InputMeetingId(input) { updateInput ->
                input = updateInput
            }
            JoinMeetingBtn(navController, input)
        }
    }
}

@Composable
fun CreateMeetingBtn(navController: NavController, token: String) {
    MyAppButton({
        NetworkManager.createMeetingId(token) { meetingId ->
            navController.navigate("meeting_screen?meetingId=$meetingId")
        }
    }, "Create Meeting")
}

@Composable
fun InputMeetingId(input: String, onInputChange: (String) -> Unit) {
    OutlinedTextField(value = input,
        onValueChange = onInputChange,
        label = { Text(text = "Enter Meeting Id") })
}

@Composable
fun JoinMeetingBtn(navController: NavController, meetingId: String) {
    MyAppButton({
        if (meetingId.isNotEmpty()) {
            navController.navigate("meeting_screen?meetingId=$meetingId")
        }
    }, "Join Meeting")
}
```

#### Output

<div style={{ textAlign: 'center' }}>
    <img 
        src="https://cdn.videosdk.live/docs/images/android/quickstart/android_compose-join-screen.jpg" 
        alt="VideoSDK Android Quick Start joining Screen" 
         style={{height: '450px'}}
    />
</div>
</Step>

<div className="heading-toc-only">
### Step 6: Creating MeetingId
</div>
<Step number={6} title="Creating MeetingId">

The `NetworkManager` singleton handles meeting creation by making a POST request to the [VideoSDK API](https://docs.videosdk.live/api-reference/realtime-communication/create-room):

- Meeting Creation: Sends a request to the API with an authorization token to create a meeting.
- Response Handling: Extracts the roomId from the response and triggers the `onMeetingCreated` callback.


```js title="NetworkManager.kt"
object NetworkManager {
    fun createMeetingId(token: String, onMeetingIdCreated: (String) -> Unit) {
        AndroidNetworking.post("https://api.videosdk.live/v2/rooms")
            .addHeaders("Authorization", token)
            .build()
            .getAsJSONObject(object : JSONObjectRequestListener {
                override fun onResponse(response: JSONObject) {
                    try {
                        val meetingId = response.getString("roomId")
                        onMeetingIdCreated(meetingId)
                    } catch (e: JSONException) {
                        e.printStackTrace()
                    }
                }

                override fun onError(anError: ANError) {
                    anError.printStackTrace()
                    Log.d("TAG", "onError: $anError")
                }
            })
    }
}
```

:::note

Don't confuse with Room and Meeting keyword, both are same thing 😃

:::
</Step>

<div className="heading-toc-only">
### Step 7: Creating Meeting Screen
</div>
<Step number={7} title="Creating Meeting Screen">

We will create a simple Meeting screen UI with two main sections:

- Participants' Video Streams: Displays video feeds of meeting participants.
- Media Control Buttons: Includes buttons to control the mic, camera, and leave the meeting.

The `MeetingScreen` composable is the main UI for a video call meeting, handling meeting details and user actions. The `MeetingScreen` composable is organized into three sections, each serving a specific purpose:

1. `Header`: Displays the meeting ID at the top of the screen for reference.
2. `ParticipantsGrid`: Shows the list of participants in a grid layout, adjusting dynamically.
3. `MediaControlButtons`: A set of buttons to control the microphone, camera, and leave the meeting.


```js title="MeetingScreen.kt"
@Composable
fun MeetingScreen(viewModel: MeetingViewModel, navController: NavController, meetingId: String, context: Context) {

    val app = context.applicationContext as MainApplication
    val isMeetingLeft = viewModel.isMeetingLeft

    LaunchedEffect(isMeetingLeft) {
        if (isMeetingLeft) {
            navController.navigate("join_screen")
        }
    }
    Column(modifier = Modifier.fillMaxSize()) {
        Header(meetingId)
        MySpacer()
        ParticipantsGrid(viewModel.participants, Modifier.weight(1f))
        MySpacer()
        MediaControlButtons(
            onJoinClick = {
                viewModel.initMeeting(context, app.sampleToken, meetingId)
            },
            onMicClick = { viewModel.toggleMic() },
            onCamClick = { viewModel.toggleWebcam() },
            onLeaveClick = {
                viewModel.leaveMeeting()
            }
        )
    }
}
@Composable
fun Header(meetingId: String) {
    Box(
        modifier = Modifier
            .fillMaxWidth()
            .padding(8.dp),
        contentAlignment = Alignment.TopStart
    ) {
        Row {
            MyText("MeetingID: ", 28.sp)
            MyText(meetingId, 25.sp)
        }
    }
}
@Composable
fun MediaControlButtons(onJoinClick:()->Unit,onMicClick: () -> Unit, onCamClick: () -> Unit, onLeaveClick: () -> Unit) {
    Row(
        modifier = Modifier
            .fillMaxWidth()
            .padding(6.dp),
        verticalAlignment = Alignment.CenterVertically,
        horizontalArrangement = Arrangement.SpaceAround
    ) {
        MyAppButton(onJoinClick,"Join")
        MyAppButton(onMicClick,"ToggleMic")
        MyAppButton(onCamClick,"ToggleCam")
        MyAppButton(onLeaveClick,"Leave")
    }
}
```
</Step>

<div className="heading-toc-only">
### Step 8: Setting Up MeetingViewModel
</div>
<Step number={8} title="Setting Up MeetingViewModel">

The `MeetingViewModel` manages the meeting state, handles participants, and controls microphone and camera settings to ensure a smooth video call experience.

Managing Meeting State and Media Control:

1. Meeting Initialization: Initializes the meeting with the VideoSDK and adds an event listener.
2. Participant Management: Tracks participants, adding/removing them as they join/leave.
3. Media Control: Toggles microphone and webcam states.
4. Leave Meeting: Allows users to leave the meeting.

```js title="MeetingViewModel.kt"
class MeetingViewModel : ViewModel() {

    private var meeting: Meeting? = null
    private var micEnabled by mutableStateOf(true)
    private var webcamEnabled by mutableStateOf(true)
    val participants = mutableStateListOf<Participant>()

    //used in MeetingScreen to handle navigation
    var isMeetingLeft by mutableStateOf(false)
        private set

    fun initMeeting(context: Context, token: String, meetingId: String ) {
        VideoSDK.config(token)
        if(meeting==null){
            meeting = VideoSDK.initMeeting(
                context, meetingId, "John Doe",
                micEnabled, webcamEnabled, null, null, true, null, null)
        }
        meeting!!.addEventListener(meetingEventListener)
        meeting!!.join()
    }

    private val meetingEventListener: MeetingEventListener = object : MeetingEventListener() {
        override fun onMeetingJoined() {
            Log.d("#meeting", "onMeetingJoined()")
            meeting?.let { participants.add(it.localParticipant) }
        }
        override fun onMeetingLeft() {
            Log.d("#meeting", "onMeetingLeft()")
            meeting = null
            isMeetingLeft = true
        }

        override fun onParticipantJoined(participant: Participant) {
                participants.add(participant)
        }

        override fun onParticipantLeft(participant: Participant) {
            participants.remove(participant)
        }
    }

    fun toggleMic() {
        if (micEnabled) {
            meeting?.muteMic()
        } else {
            meeting?.unmuteMic()
        }
        micEnabled = !micEnabled
    }

    fun toggleWebcam() {
        if (webcamEnabled) {
            meeting?.disableWebcam()
        } else {
            meeting?.enableWebcam()
        }
        webcamEnabled = !webcamEnabled
    }

    fun leaveMeeting() {
        meeting?.leave()
    }
}
```

<div style={{ textAlign: 'center' }}>
    <img 
        src="https://cdn.videosdk.live/docs/images/android/quickstart/android_compose-meeting-screen.jpg" 
        alt="VideoSDK Android Quick Start Meeting Screen" 
       style={{height: '450px'}}
    />
</div>
</Step>

## Final Output

We are done with implementation of customised video calling app in Android using Video SDK. To explore more features go through Basic and Advanced features.

import ReactPlayer from 'react-player'

<div style={{textAlign: 'center'}}>

<ReactPlayer muted controls url="https://cdn.videosdk.live/docs/images/android/quickstart/android_compose_quickstart.mp4 " height="500px" width={"100%"} />

</div>

:::tip
You can checkout the complete [quick start example here](https://github.com/videosdk-live/quickstart/tree/main/android-rtc/Videosdk_android_compose_quickstart/).
:::


---

---
title: Quick Start with Android
hide_title: false
hide_table_of_contents: false
description: Video SDK enables the opportunity to integrate native IOS, Android & Web SDKs to add live video & audio conferencing to your applications.
sidebar_label: Start a Audio / Video Call (XML)
pagination_label: Quick Start with Android
keywords:
  - audio calling
  - video calling
  - real-time communication
  - collaboration
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: quick-start
---

import Step from '@site/src/components/Step'

# Quick Start for Conference in Android

<ReactPlayer controls url="https://www.youtube.com/watch?v=Kj7jS3dbJFA" height="500px" width={"100%"} />

VideoSDK enables you to embed the video calling feature into your Android application in minutes.

In this quickstart, we are going to explore group calling feature of Video SDK. We will go through step by step guide of integrating video calling with Android Video SDK.

This guide will get you running with the VideoSDK video & audio calling in minutes.

## Prerequisites

Before proceeding, ensure that your development environment meets the following requirements:

- Java Development Kit.
- Android Studio 3.0 or later.
- Android SDK API Level 21 or higher.
- A mobile device that runs Android 5.0 or later.

:::important

One should have a VideoSDK account to generate token.
Visit VideoSDK **[dashboard](https://app.videosdk.live/api-keys)** to generate token

:::

## Getting Started with the Code!

Follow the steps to create the environment necessary to add video calls into your app. Also you can find the code sample for [quickstart here](https://github.com/videosdk-live/quickstart/tree/main/android-rtc).

### Create new Android Project

For a new project in **Android Studio**, create a **Phone and Tablet** Android project with an **Empty Activity**.

![VideoSDK Android Quick Start New Project](/img/quick-start/android_newProject.png)

:::caution
After creating the project, Android Studio automatically starts gradle sync. Ensure that the sync succeeds before you continue.
:::

### Integrate Video SDK

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Maven Central"
groupId={"android-repositories"}
values={[{label: 'Maven Central', value: 'Maven Central'},{label: 'Jitpack', value: 'Jitpack'},]}>

<TabItem value="Maven Central">

```js title="settings.gradle"
dependencyResolutionManagement{
  repositories {
    // ...
    google()
    mavenCentral()
    maven { url "https://maven.aliyun.com/repository/jcenter" }
  }
}
```

</TabItem>

<TabItem value="Jitpack">

```js title="settings.gradle"
dependencyResolutionManagement{
  repositories {
    // ...
    google()
    maven { url 'https://jitpack.io' }
    mavenCentral()
    maven { url "https://maven.aliyun.com/repository/jcenter" }
  }
}
```

</TabItem>

</Tabs>

- Add the following dependency in your app's `app/build.gradle`.

```js title="app/build.gradle"
dependencies {
  implementation 'live.videosdk:rtc-android-sdk:0.3.0'

  // library to perform Network call to generate a meeting id
  implementation 'com.amitshekhar.android:android-networking:1.0.2'

  // other app dependencies
  }
```

:::important

Android SDK compatible with armeabi-v7a, arm64-v8a, x86_64 architectures. If you want to run the application in an emulator, choose ABI x86_64 when creating a device.

:::

### Add permissions into your project

- In `/app/Manifests/AndroidManifest.xml`, add the following permissions after `</application>`.

```xml title="AndroidManifest.xml"
<uses-permission android:name="android.permission.RECORD_AUDIO" />
<uses-permission android:name="android.permission.MODIFY_AUDIO_SETTINGS" />
<uses-permission android:name="android.permission.INTERNET" />
<uses-permission android:name="android.permission.CAMERA" />
```

:::note

If your project has set `android.useAndroidX=true`, then set `android.enableJetifier=true` in the `gradle.properties` file to migrate your project to AndroidX and avoid duplicate class conflict.

:::

### Structure of the project

Your project structure should look like this.

```jsx title="Project Structure"
   app
   ├── java
   │    ├── packagename
   │         ├── JoinActivity
   │         ├── MainApplication
   │         ├── MeetingActivity
   │         ├── ParticipantAdapter
   ├── res
   │    ├── layout
   │    │    ├── activity_join.xml
   │    │    ├── activity_meeting.xml
   │    │    ├── item_remote_peer.xml
```

:::note

You have to set JoinActivity as Launcher activity.

:::

### App Architecture

<center>

<img src='https://cdn.videosdk.live/website-resources/docs-resources/android_quickstart_app_structure.png' />

</center>

<div className="heading-toc-only">
### Step 1: Initialize VideoSDK
</div>
<Step number={1} title="Initialize VideoSDK">
1. Create `MainApplication` class which will extend the `android.app.Application`.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js title="MainApplication.kt"
import live.videosdk.rtc.android.VideoSDK

class MainApplication : Application() {
  override fun onCreate() {
      super.onCreate()
      //highlight-next-line
      VideoSDK.initialize(applicationContext)
  }
}
```

</TabItem>

<TabItem value="Java">

```java title="MainApplication.java"
import android.app.Application;
import live.videosdk.rtc.android.VideoSDK;

public class MainApplication extends Application {
  @Override
  public void onCreate() {
    super.onCreate();
    //highlight-next-line
    VideoSDK.initialize(getApplicationContext());
  }
}
```

</TabItem>

</Tabs>

2. Add `MainApplication` to `AndroidManifest.xml`

```xml title="AndroidManifest.xml"
<application
    android:name=".MainApplication" >
   <!-- ... -->
</application>
```
</Step>

<div className="heading-toc-only">
### Step 2: Creating Joining Screen
</div>
<Step number={2} title="Creating Joining Screen">

Create a new Activity named `JoinActivity`. The Joining screen will include :

1. **Create Button** - This button will create a new meeting for you.
2. **TextField for Meeting Id** - This text field will contain the meeting Id you want to join.
3. **Join Button** - This button will join the meeting with `meetingId` you provided.

In `/app/res/layout/activity_join.xml` file, replace the content with the following.

```xml title="activity_join.xml"
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:gravity="center"
    android:orientation="vertical"
    tools:context=".JoinActivity">

    <Button
        android:id="@+id/btnCreateMeeting"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_marginBottom="16dp"
        android:text="Create Meeting" />

    <TextView
        style="@style/TextAppearance.AppCompat.Headline"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="OR" />

    <com.google.android.material.textfield.TextInputLayout
        style="@style/Widget.MaterialComponents.TextInputLayout.OutlinedBox"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_marginVertical="16dp"
        android:hint="Enter Meeting ID">

        <EditText
            android:id="@+id/etMeetingId"
            android:layout_width="250dp"
      android:layout_height="wrap_content" />
    </com.google.android.material.textfield.TextInputLayout>

    <Button
        android:id="@+id/btnJoinMeeting"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Join Meeting" />
</LinearLayout>
```
**Here is the implementation for the Join Activity:**


1. Create field `sampleToken` in `JoinActivity` which will hold the generated token from the [VideoSDK dashboard](https://app.videosdk.live/api-keys). This token will use in VideoSDK config as well as in generating meetingId.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js title="JoinActivity.kt"
class JoinActivity : AppCompatActivity() {

  //highlight-next-line
  //Replace with the token you generated from the VideoSDK Dashboard
  private var sampleToken = ""

  override fun onCreate(savedInstanceState: Bundle?) {
    //...
  }
}
```

</TabItem>

<TabItem value="Java">

```java title="JoinActivity.java"
public class JoinActivity extends AppCompatActivity {

  //highlight-next-line
  //Replace with the token you generated from the VideoSDK Dashboard
  private String sampleToken ="";

  @Override
  protected void onCreate(Bundle savedInstanceState) {
    //...
  }
}
```

</TabItem>

</Tabs>

2. On **Join Button** `onClick` events, we will naviagte to `MeetingActivity` with token and meetingId.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js title="JoinActivity.kt"
class JoinActivity : AppCompatActivity() {

   //Replace with the token you generated from the VideoSDK Dashboard
   private var sampleToken = ""

   override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_join)

        val btnCreate = findViewById<Button>(R.id.btnCreateMeeting)
        val btnJoin = findViewById<Button>(R.id.btnJoinMeeting)
        val etMeetingId = findViewById<EditText>(R.id.etMeetingId)

        btnCreate.setOnClickListener { v: View? ->
            createMeeting(sampleToken)
        }
        btnJoin.setOnClickListener { v: View? ->
            val intent = Intent(this@JoinActivity, MeetingActivity::class.java)
            intent.putExtra("token", sampleToken)
            intent.putExtra("meetingId", etMeetingId.text.toString())
            startActivity(intent)
        }
    }

    private fun createMeeting(token: String) {
      // we will explore this method in the next step
    }
}
```

</TabItem>

<TabItem value="Java">

```java title="JoinActivity.java"
public class JoinActivity extends AppCompatActivity {

  //Replace with the token you generated from the VideoSDK Dashboard
  private String sampleToken ="";

  @Override
  protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_join);

    final Button btnCreate = findViewById(R.id.btnCreateMeeting);
    final Button btnJoin = findViewById(R.id.btnJoinMeeting);
    final EditText etMeetingId = findViewById(R.id.etMeetingId);

    btnCreate.setOnClickListener(v -> {
      createMeeting(sampleToken);
    });

    btnJoin.setOnClickListener(v -> {
      Intent intent = new Intent(JoinActivity.this, MeetingActivity.class);
      intent.putExtra("token", sampleToken);
      intent.putExtra("meetingId", etMeetingId.getText().toString());
      startActivity(intent);
    });
  }

  private void createMeeting(String token) {
    // we will explore this method in the next step
  }
}
```

</TabItem>

</Tabs>

3. For **Create Button**, under `createMeeting` method we will generate meetingId by calling API and navigate to `MeetingActivity` with token and generated meetingId.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js title="JoinActivity.kt"
class JoinActivity : AppCompatActivity() {
  //...onCreate
 private fun createMeeting(token: String) {
    // we will make an API call to VideoSDK Server to get a roomId
    AndroidNetworking.post("https://api.videosdk.live/v2/rooms")
      .addHeaders("Authorization", token) //we will pass the token in the Headers
      .build()
      .getAsJSONObject(object : JSONObjectRequestListener {
          override fun onResponse(response: JSONObject) {
              try {
                  // response will contain `roomId`
                  val meetingId = response.getString("roomId")

                  // starting the MeetingActivity with received roomId and our sampleToken
                  val intent = Intent(this@JoinActivity, MeetingActivity::class.java)
                  intent.putExtra("token", sampleToken)
                  intent.putExtra("meetingId", meetingId)
                  startActivity(intent)
              } catch (e: JSONException) {
                  e.printStackTrace()
              }
          }

          override fun onError(anError: ANError) {
              anError.printStackTrace()
                    Toast.makeText(
                        this@JoinActivity, anError.message,
                        Toast.LENGTH_SHORT
                    ).show()
          }
      })
  }
}
```

</TabItem>

<TabItem value="Java">

```java title="JoinActivity.java"
public class JoinActivity extends AppCompatActivity {
  //...onCreate

  private void createMeeting(String token) {
      // we will make an API call to VideoSDK Server to get a roomId
      AndroidNetworking.post("https://api.videosdk.live/v2/rooms")
        .addHeaders("Authorization", token) //we will pass the token in the Headers
        .build()
        .getAsJSONObject(new JSONObjectRequestListener() {
            @Override
            public void onResponse(JSONObject response) {
                try {
                    // response will contain `roomId`
                    final String meetingId = response.getString("roomId");

                    // starting the MeetingActivity with received roomId and our sampleToken
                    Intent intent = new Intent(JoinActivity.this, MeetingActivity.class);
                    intent.putExtra("token", sampleToken);
                    intent.putExtra("meetingId", meetingId);
                    startActivity(intent);
                } catch (JSONException e) {
                    e.printStackTrace();
                }
            }

            @Override
            public void onError(ANError anError) {
                anError.printStackTrace();
                Toast.makeText(JoinActivity.this, anError.getMessage(), Toast.LENGTH_SHORT).show();
            }
        });
  }
}
```

</TabItem>

</Tabs>

:::note

Don't confuse with Room and Meeting keyword, both are same thing 😃

:::

4. Our App is completely based on audio and video commutation, that's why we need to ask for runtime permissions `RECORD_AUDIO` and `CAMERA`. So, we will implement permission logic on `JoinActivity`.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js title="JoinActivity.kt"
class JoinActivity : AppCompatActivity() {
    companion object {
        private const val PERMISSION_REQ_ID = 22
        private val REQUESTED_PERMISSIONS = arrayOf(
            Manifest.permission.RECORD_AUDIO,
            Manifest.permission.CAMERA
        )
    }

  private fun checkSelfPermission(permission: String, requestCode: Int): Boolean {
        if (ContextCompat.checkSelfPermission(this, permission) !=
            PackageManager.PERMISSION_GRANTED)
        {
            ActivityCompat.requestPermissions(this, REQUESTED_PERMISSIONS, requestCode)
            return false
        }
        return true
    }

  override fun onCreate(savedInstanceState: Bundle?) {
    //... button listeneres
    //highlight-start
    checkSelfPermission(REQUESTED_PERMISSIONS[0], PERMISSION_REQ_ID)
    checkSelfPermission(REQUESTED_PERMISSIONS[1], PERMISSION_REQ_ID)
    //highlight-end
  }
}
```

</TabItem>

<TabItem value="Java">

```java title="JoinActivity.java"
public class JoinActivity extends AppCompatActivity {
  private static final int PERMISSION_REQ_ID = 22;

  private static final String[] REQUESTED_PERMISSIONS = {
    Manifest.permission.RECORD_AUDIO,
    Manifest.permission.CAMERA
  };

  private boolean checkSelfPermission(String permission, int requestCode) {
    if (ContextCompat.checkSelfPermission(this, permission) != PackageManager.PERMISSION_GRANTED) {
      ActivityCompat.requestPermissions(this, REQUESTED_PERMISSIONS, requestCode);
      return false;
    }
    return true;
  }

  @Override
  protected void onCreate(Bundle savedInstanceState) {
    //... button listeneres
    //highlight-start
    checkSelfPermission(REQUESTED_PERMISSIONS[0], PERMISSION_REQ_ID);
    checkSelfPermission(REQUESTED_PERMISSIONS[1], PERMISSION_REQ_ID);
    //highlight-end
  }
}
```

</TabItem>

</Tabs>

#### Output

<div style={{textAlign: 'center'}}>

![VideoSDK Android Quick Start joining Screen](/img/quick-start/android-join-screen.jpg)

</div>
</Step>

<div className="heading-toc-only">
### Step 3: Creating Meeting Screen
</div>
<Step number={3} title="Creating Meeting Screen">
Create a new Activity named `MeetingActivity`. 

In `/app/res/layout/activity_meeting.xml` file, replace the content with the following.

```xml title="activty_meeting.xml"
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:gravity="center"
    android:orientation="vertical"
    tools:context=".MeetingActivity">

    <TextView
        android:id="@+id/tvMeetingId"
        style="@style/TextAppearance.AppCompat.Display1"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Meeting Id" />

    <androidx.recyclerview.widget.RecyclerView
        android:id="@+id/rvParticipants"
        android:layout_width="match_parent"
        android:layout_height="0dp"
        android:layout_weight="1" />

    <LinearLayout
        android:layout_width="wrap_content"
        android:layout_height="wrap_content">

        <Button
            android:id="@+id/btnMic"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:layout_marginVertical="8dp"
            android:text="Mic"/>

        <Button
            android:id="@+id/btnLeave"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:layout_marginVertical="8dp"
            android:layout_marginHorizontal="8dp"
            android:text="Leave"/>

        <Button
            android:id="@+id/btnWebcam"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:layout_marginVertical="8dp"
            android:text="Webcam" />

    </LinearLayout>

</LinearLayout>
```

**The next step is to initialize a meeting, After getting token and meetigId from JoinActivity:**

1. Configure **VideoSDK** with token.
2. Initialize the meeting with required params such as `meetingId`, `participantName`, `micEnabled`, `webcamEnabled` and more.
3. Add `MeetingEventListener` for listening events such as **Meeting Join/Left** and **Participant Join/Left**.
4. Join the room with `meeting.join()` method.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js title="MeetingActivity.kt"
class MeetingActivity : AppCompatActivity() {
  // declare the variables we will be using to handle the meeting
  private var meeting: Meeting? = null
  private var micEnabled = true
  private var webcamEnabled = true

  override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    setContentView(R.layout.activity_meeting)

    val token = intent.getStringExtra("token")
    val meetingId = intent.getStringExtra("meetingId")
    val participantName = "John Doe"

    //highlight-next-line
    // 1. Configuration VideoSDK with Token
    VideoSDK.config(token)

    //highlight-next-line
    // 2. Initialize VideoSDK Meeting
    meeting = VideoSDK.initMeeting(
      this@MeetingActivity, meetingId, participantName,
      micEnabled, webcamEnabled, null, null, false, null, null)

    //highlight-next-line
    // 3. Add event listener for listening upcoming events
    meeting!!.addEventListener(meetingEventListener)

    //highlight-next-line
    //4. Join VideoSDK Meeting
    meeting!!.join()

    (findViewById<View>(R.id.tvMeetingId) as TextView).text = meetingId
  }

  //highlight-next-line
  // creating the MeetingEventListener
  private val meetingEventListener: MeetingEventListener = object : MeetingEventListener() {
    override fun onMeetingJoined() {
      Log.d("#meeting", "onMeetingJoined()")
    }

    override fun onMeetingLeft() {
      Log.d("#meeting", "onMeetingLeft()")
      meeting = null
      if (!isDestroyed) finish()
    }

    override fun onParticipantJoined(participant: Participant) {
      Toast.makeText(
        this@MeetingActivity, participant.displayName + " joined",
        Toast.LENGTH_SHORT
      ).show()
    }

    override fun onParticipantLeft(participant: Participant) {
      Toast.makeText(
         this@MeetingActivity, participant.displayName + " left",
         Toast.LENGTH_SHORT
      ).show()
    }
  }
}
```

</TabItem>

<TabItem value="Java">

```java title="MeetingActivity.java"
public class MeetingActivity extends AppCompatActivity {
  // declare the variables we will be using to handle the meeting
  private Meeting meeting;
  private boolean micEnabled = true;
  private boolean webcamEnabled = true;

  @Override
  protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_meeting);

    final String token = getIntent().getStringExtra("token");
    final String meetingId = getIntent().getStringExtra("meetingId");
    final String participantName = "John Doe";

    //highlight-next-line
    // 1. Configuration VideoSDK with Token
    VideoSDK.config(token);

    //highlight-next-line
    // 2. Initialize VideoSDK Meeting
    meeting = VideoSDK.initMeeting(
            MeetingActivity.this, meetingId, participantName,
            micEnabled, webcamEnabled, null, null, false, null, null);

    //highlight-next-line
    // 3. Add event listener for listening upcoming events
    meeting.addEventListener(meetingEventListener);

    //highlight-next-line
    //4. Join VideoSDK Meeting
    meeting.join();

    ((TextView)findViewById(R.id.tvMeetingId)).setText(meetingId);
  }

  //highlight-next-line
  // creating the MeetingEventListener
  private final MeetingEventListener meetingEventListener = new MeetingEventListener() {
    @Override
    public void onMeetingJoined() {
      Log.d("#meeting", "onMeetingJoined()");
    }

    @Override
    public void onMeetingLeft() {
      Log.d("#meeting", "onMeetingLeft()");
      meeting = null;
      if (!isDestroyed()) finish();
    }

    @Override
    public void onParticipantJoined(Participant participant) {
      Toast.makeText(MeetingActivity.this, participant.getDisplayName() + " joined", Toast.LENGTH_SHORT).show();
    }

    @Override
    public void onParticipantLeft(Participant participant) {
      Toast.makeText(MeetingActivity.this, participant.getDisplayName() + " left", Toast.LENGTH_SHORT).show();
    }
  };
}
```

</TabItem>

</Tabs>
</Step>

<div className="heading-toc-only">
### Step 4: Handle Local Participant Media
</div>
<Step number={4} title="Handle Local Participant Media">
After successfully enter into the meeting, it's time to **enable/disable** local participant(You) webcam and mic, for that we will use `Meeting` class method `enableWebcam` / `disableWebcam` for camera and `muteMic` / `unmuteMic` for mic.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js title="MeetingActivity.kt"
class MeetingActivity : AppCompatActivity() {
  override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    setContentView(R.layout.activity_meeting)
    //...Meeting Setup is Here

    // actions
    setActionListeners()
  }

  private fun setActionListeners() {
    // toggle mic
    findViewById<View>(R.id.btnMic).setOnClickListener { view: View? ->
      if (micEnabled) {
        // this will mute the local participant's mic
        //highlight-next-line
        meeting!!.muteMic()
        Toast.makeText(this@MeetingActivity, "Mic Muted", Toast.LENGTH_SHORT).show()
      } else {
        // this will unmute the local participant's mic
        //highlight-next-line
        meeting!!.unmuteMic()
        Toast.makeText(this@MeetingActivity, "Mic Enabled", Toast.LENGTH_SHORT).show()
      }
        micEnabled=!micEnabled
    }

    // toggle webcam
    findViewById<View>(R.id.btnWebcam).setOnClickListener { view: View? ->
      if (webcamEnabled) {
        // this will disable the local participant webcam
        //highlight-next-line
        meeting!!.disableWebcam()
        Toast.makeText(this@MeetingActivity, "Webcam Disabled", Toast.LENGTH_SHORT).show()
      } else {
        // this will enable the local participant webcam
        //highlight-next-line
        meeting!!.enableWebcam()
        Toast.makeText(this@MeetingActivity, "Webcam Enabled", Toast.LENGTH_SHORT).show()
      }
       webcamEnabled=!webcamEnabled
    }

    // leave meeting
    findViewById<View>(R.id.btnLeave).setOnClickListener { view: View? ->
      // this will make the local participant leave the meeting
      //highlight-next-line
      meeting!!.leave()
    }
  }
}
```

</TabItem>

<TabItem value="Java">

```java title="MeetingActivity.java"
public class MeetingActivity extends AppCompatActivity {
  @Override
  protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_meeting);
    //...Meeting Setup is Here

    // actions
    setActionListeners();
  }

  private void setActionListeners() {
    // toggle mic
    findViewById(R.id.btnMic).setOnClickListener(view -> {
      if (micEnabled) {
        // this will mute the local participant's mic
        //highlight-next-line
        meeting.muteMic();
        Toast.makeText(MeetingActivity.this, "Mic Disabled", Toast.LENGTH_SHORT).show();
      } else {
        // this will unmute the local participant's mic
        //highlight-next-line
        meeting.unmuteMic();
        Toast.makeText(MeetingActivity.this, "Mic Enabled", Toast.LENGTH_SHORT).show();
      }
      micEnabled=!micEnabled;
    });

    // toggle webcam
    findViewById(R.id.btnWebcam).setOnClickListener(view -> {
      if (webcamEnabled) {
        // this will disable the local participant webcam
        //highlight-next-line
        meeting.disableWebcam();
        Toast.makeText(MeetingActivity.this, "Webcam Disabled", Toast.LENGTH_SHORT).show();
      } else {
        // this will enable the local participant webcam
        //highlight-next-line
        meeting.enableWebcam();
        Toast.makeText(MeetingActivity.this, "Webcam Enabled", Toast.LENGTH_SHORT).show();
      }
      webcamEnabled=!webcamEnabled;
    });

    // leave meeting
    findViewById(R.id.btnLeave).setOnClickListener(view -> {
      // this will make the local participant leave the meeting
      //highlight-next-line
      meeting.leave();
    });
  }
}
```

</TabItem>

</Tabs>

#### Output

<div style={{textAlign: 'center'}}>

<img style={{height: '200px'}} src="/img/quick-start/android_controls.jpeg" />

</div>
</Step>

<div className="heading-toc-only">
### Step 5: Handling the Participants View
</div>
<Step number={5} title="Handling the Participants View">
We will be showing the list of participant in a `RecyclerView`.

:::info

- Here the participant's video is displayed using `VideoView`, but you may also use `SurfaceViewRender` for the same.
- For `VideoView`, SDK version should be `0.1.13` or higher.
- To know more about `VideoView`, please visit [here](/android/guide/video-and-audio-calling-api-sdk/render-media/display-video/understand-videoView-component)

:::

1. Create a new layout for the participant view named `item_remote_peer.xml` in the `res/layout` folder.

```xml title="item_remote_peer.xml"
<?xml version="1.0" encoding="utf-8"?>
<FrameLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="200dp"
    android:background="@color/cardview_dark_background"
    tools:layout_height="200dp">

    <live.videosdk.rtc.android.VideoView
        android:id="@+id/participantView"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:visibility="gone" />

    <LinearLayout
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:layout_gravity="bottom"
        android:background="#99000000"
        android:orientation="horizontal">

        <TextView
            android:id="@+id/tvName"
            android:layout_width="0dp"
            android:layout_height="wrap_content"
            android:layout_weight="1"
            android:gravity="center"
            android:padding="4dp"
            android:textColor="@color/white" />

    </LinearLayout>

</FrameLayout>
```

2. Create a recycler view adapter named `ParticipantAdapter` which will show the participant list. Create `PeerViewHolder` in the adapter which will extend `RecyclerView.ViewHolder`.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js title="ParticipantAdapter.kt"
class ParticipantAdapter(meeting: Meeting) : RecyclerView.Adapter<ParticipantAdapter.PeerViewHolder>() {

  override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): PeerViewHolder {
    return PeerViewHolder(
      LayoutInflater.from(parent.context)
        .inflate(R.layout.item_remote_peer, parent, false)
    )
  }

  override fun onBindViewHolder(holder: PeerViewHolder, position: Int) {
  }

  override fun getItemCount(): Int {
    return 0
  }

  class PeerViewHolder(view: View) : RecyclerView.ViewHolder(view) {
    // 'VideoView' to show Video Stream
    var participantView: VideoView
    var tvName: TextView

    init {
        tvName = view.findViewById(R.id.tvName)
        participantView = view.findViewById(R.id.participantView)
    }
  }
}
```

</TabItem>

<TabItem value="Java">

```java title="ParticipantAdapter.java"
public class ParticipantAdapter extends RecyclerView.Adapter<ParticipantAdapter.PeerViewHolder> {

  @NonNull
  @Override
  public PeerViewHolder onCreateViewHolder(@NonNull ViewGroup parent, int viewType) {
      return new PeerViewHolder(LayoutInflater.from(parent.getContext()).inflate(R.layout.item_remote_peer, parent, false));
  }

  @Override
  public void onBindViewHolder(@NonNull PeerViewHolder holder, int position) {
  }

  @Override
  public int getItemCount() {
      return 0;
  }

  static class PeerViewHolder extends RecyclerView.ViewHolder {
    // 'VideoView' to show Video Stream
    public VideoView participantView;
    public TextView tvName;
    public View itemView;

    PeerViewHolder(@NonNull View view) {
        super(view);
        itemView = view;
        tvName = view.findViewById(R.id.tvName);
        participantView = view.findViewById(R.id.participantView);
    }
  }
}
```

</TabItem>

</Tabs>

3. Now, we will render a list of `Participant` for the meeting.
   We will initialize this list in the constructor of the `ParticipantAdapter`

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js title="ParticipantAdapter.kt"
class ParticipantAdapter(meeting: Meeting) :
    RecyclerView.Adapter<ParticipantAdapter.PeerViewHolder>() {

  // creating a empty list which will store all participants
  private val participants: MutableList<Participant> = ArrayList()

  init {
    //highlight-next-line
    // adding the local participant(You) to the list
    participants.add(meeting.localParticipant)

    //highlight-next-line
    // adding Meeting Event listener to get the participant join/leave event in the meeting.
    meeting.addEventListener(object : MeetingEventListener() {
      override fun onParticipantJoined(participant: Participant) {
        // add participant to the list
        participants.add(participant)
        notifyItemInserted(participants.size - 1)
      }

      override fun onParticipantLeft(participant: Participant) {
        var pos = -1
        for (i in participants.indices) {
          if (participants[i].id == participant.id) {
            pos = i
            break
          }
        }
        // remove participant from the list
        participants.remove(participant)
        if (pos >= 0) {
          notifyItemRemoved(pos)
        }
      }
    })
  }

  // replace getItemCount() method with following.
  // this method returns the size of total number of participants
  override fun getItemCount(): Int {
    //highlight-next-line
    return participants.size
  }
  //...
}
```

</TabItem>

<TabItem value="Java">

```java title="ParticipantAdapter.java"
public class ParticipantAdapter extends RecyclerView.Adapter<ParticipantAdapter.PeerViewHolder> {

  // creating a empty list which will store all participants
  private final List<Participant> participants = new ArrayList<>();

  public ParticipantAdapter(Meeting meeting) {
    //highlight-next-line
    // adding the local participant(You) to the list
    participants.add(meeting.getLocalParticipant());

    //highlight-next-line
    // adding Meeting Event listener to get the participant join/leave event in the meeting.
    meeting.addEventListener(new MeetingEventListener() {
      @Override
      public void onParticipantJoined(Participant participant) {
        // add participant to the list
        participants.add(participant);
        notifyItemInserted(participants.size() - 1);
      }

      @Override
      public void onParticipantLeft(Participant participant) {
        int pos = -1;
        for (int i = 0; i < participants.size(); i++) {
          if (participants.get(i).getId().equals(participant.getId())) {
            pos = i;
            break;
          }
        }
        // remove participant from the list
        participants.remove(participant);

        if (pos >= 0) {
          notifyItemRemoved(pos);
        }
      }
    });
  }

  // replace getItemCount() method with following.
  // this method returns the size of total number of participants
  @Override
  public int getItemCount() {
    //highlight-next-line
    return participants.size();
  }
  //...
}
```

</TabItem>

</Tabs>

4. We have listed our participants. Let's set up the view holder to display a participant video.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js title="PartipantAdapter.kt"
class ParticipantAdapter(meeting: Meeting) :
    RecyclerView.Adapter<ParticipantAdapter.PeerViewHolder>() {

  // replace onBindViewHolder() method with following.
  override fun onBindViewHolder(holder: PeerViewHolder, position: Int) {
    val participant = participants[position]

    holder.tvName.text = participant.displayName

    // adding the initial video stream for the participant into the 'VideoView'
    for ((_, stream) in participant.streams) {
      if (stream.kind.equals("video", ignoreCase = true)) {
        holder.participantView.visibility = View.VISIBLE
        val videoTrack = stream.track as VideoTrack
        //highlight-next-line
        holder.participantView.addTrack(videoTrack)
        break
      }
    }

    // add Listener to the participant which will update start or stop the video stream of that participant
    participant.addEventListener(object : ParticipantEventListener() {
      override fun onStreamEnabled(stream: Stream) {
        if (stream.kind.equals("video", ignoreCase = true)) {
          holder.participantView.visibility = View.VISIBLE
          val videoTrack = stream.track as VideoTrack
          //highlight-next-line
          holder.participantView.addTrack(videoTrack)
       }
      }

      override fun onStreamDisabled(stream: Stream) {
        if (stream.kind.equals("video", ignoreCase = true)) {
          //highlight-next-line
          holder.participantView.removeTrack()
          holder.participantView.visibility = View.GONE
        }
      }
    })
  }
}
```

</TabItem>

<TabItem value="Java">

```java title="PartipantAdapter.java"
public class ParticipantAdapter extends RecyclerView.Adapter<ParticipantAdapter.PeerViewHolder> {

  // replace onBindViewHolder() method with following.
  @Override
  public void onBindViewHolder(@NonNull PeerViewHolder holder, int position) {
    Participant participant = participants.get(position);

    holder.tvName.setText(participant.getDisplayName());

    // adding the initial video stream for the participant into the 'VideoView'
    for (Map.Entry<String, Stream> entry : participant.getStreams().entrySet()) {
      Stream stream = entry.getValue();
      if (stream.getKind().equalsIgnoreCase("video")) {
        holder.participantView.setVisibility(View.VISIBLE);
        VideoTrack videoTrack = (VideoTrack) stream.getTrack();
        //highlight-next-line
        holder.participantView.addTrack(videoTrack)
        break;
      }
    }
    // add Listener to the participant which will update start or stop the video stream of that participant
    participant.addEventListener(new ParticipantEventListener() {
      @Override
      public void onStreamEnabled(Stream stream) {
        if (stream.getKind().equalsIgnoreCase("video")) {
          holder.participantView.setVisibility(View.VISIBLE);
          VideoTrack videoTrack = (VideoTrack) stream.getTrack();
          //highlight-next-line
          holder.participantView.addTrack(videoTrack)
        }
      }

      @Override
      public void onStreamDisabled(Stream stream) {
        if (stream.getKind().equalsIgnoreCase("video")) {
          //highlight-next-line
          holder.participantView.removeTrack();
          holder.participantView.setVisibility(View.GONE);
        }
      }
    });
  }
}
```

</TabItem>

</Tabs>

5. Add this adapter to the `MeetingActivity`

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js title="MeetingActivity.kt"
override fun onCreate(savedInstanceState: Bundle?) {
  //Meeting Setup...
  //...
  val rvParticipants = findViewById<RecyclerView>(R.id.rvParticipants)
  rvParticipants.layoutManager = GridLayoutManager(this, 2)
  rvParticipants.adapter = ParticipantAdapter(meeting!!)
}
```

</TabItem>

<TabItem value="Java">

```java title="MeetingActivity.java"
@Override
protected void onCreate(Bundle savedInstanceState) {
  //Meeting Setup...
  //...
  final RecyclerView rvParticipants = findViewById(R.id.rvParticipants);
  rvParticipants.setLayoutManager(new GridLayoutManager(this, 2));
  rvParticipants.setAdapter(new ParticipantAdapter(meeting));
}
```

</TabItem>

</Tabs>

:::tip

Stuck anywhere? Check out this [example code](https://github.com/videosdk-live/videosdk-rtc-android-java-sdk-example) on GitHub.

:::
</Step>

## Final Output

We are done with implementation of customised video calling app in Android using Video SDK. To explore more features go through Basic and Advanced features.

import ReactPlayer from 'react-player'

<div style={{textAlign: 'center'}}>

<ReactPlayer muted controls url="https://cdn.videosdk.live/website-resources/docs-resources/android_quickstart.mp4" height="500px" width={"100%"} />

</div>

:::tip
You can checkout the complete [quick start example here](https://github.com/videosdk-live/quickstart/tree/main/android-rtc).
:::


---

---
title: Understanding Usage Quota Limits
hide_title: true
hide_table_of_contents: false
description: Explore VideoSDK quota limits and subscription plans. Learn how to optimize usage and choose the right plan for your video development needs.
sidebar_label: Understanding Usage Quota Limits
pagination_label: Understanding Usage Quota Limits
keywords:
  - videosdk plans
  - videosdk quota
  - videosdk limit
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: quotas-and-limit
---

import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>

## Understanding Usage Quota Limits - Android

In this documentation, you will find detailed information about the quotas associated with each plan, including usage limits for various features and functionalities. Understanding these quotas will help you optimize your usage, selecting the best pricing plan and make the most of your VideoSDK experience.

## How VideoSDK limits concurrent usage quota

VideoSDK's approach to limiting usage focuses on concurrent usage rather than overall usage. Concurrent usage refers to the number of participants or requests that can be hosted or processed simultaneously. 

For example, if there's a limit of 50 concurrent participants per organization, users can run multiple calls (sessions) simultaneously, with a maximum of 50 participants across all sessions combined.

## How to view my current plan’s quota limits?

To view the current quota limits on your organization, simply navigate to the [VideoSDK Dashboard](https://app.videosdk.live/), go to your Profile section, and click on the Billing tab.

## Free Plan

Since, we’ve designed Free Plan for developers who are just exploring, we’ve kept the limits that would get you started without a hitch.

Organisations on Free Plan have the following limits on concurrent usage:

| Feature | Concurrent Limit |
| --- | --- |
| Participants in Video Calls | 50 concurrent participants |
| Viewers in Live Streams | 100 concurrent viewers |
| Recording Request | 1 concurrent request at a time |
| HLS Encoding Request | 1 concurrent request at a time |
| RTMP-Out Request | 1 concurrent request at a time |

 
### How to increase my limits?

To increase your limits, simply upgrade your plan by providing billing details and credit card information.

## Pay-as-you-Go Plan

We've increased participant limits for this paid plan. This way, it won't significantly impact users heavily involved in production or integration.

Organisations on Pay-as-you-Go have the following limits on concurrent usage:

| Feature | Concurrent Limit |
| --- | --- |
| Participants in Video Calls | 100 concurrent participants |
| Viewers in Live Streams | 500 concurrent viewers |
| Recording Request | 5 concurrent request at a time |
| HLS Encoding Request | 5 concurrent request at a time |
| RTMP-Out Request | 5 concurrent request at a time |

### How to increase my limits?

To increase your limits further more, simply get in touch with us. [Contact us](https://www.videosdk.live/contact) directly or reach out via email at [support@videosdk.live](mailto:support@videosdk.live), and we'll handle the rest gladly.

## Enterprise Plan

For Enterprise users, all limits are tailored to the specific needs. Customised limits ensure optimal performance for your unique requirements.

To get started as an Enterprise user, simply get in touch with us, explain your requirements and use case, and we’ll customise the quota and limits according to your needs.

## Examples to understand concurrent limits

**Example #1**

Let's say you're using video callings (RTC) in your organization on the Free Plan. In this scenario, you can concurrently host up to 50 participants. However, the number of calls (sessions) you initiate is unrestricted.

To simplify, you can run multiple sessions simultaneously, but concurrently, you can only accommodate a maximum of 50 participants across all sessions. If a 51st participant attempts to join, they won't be able to access the session until you upgrade your plan to increase your participant limits.

**Example #2**

Let’s say you're using live streaming in your organization on the Free Plan. In this setup, you can concurrently host up to 100 viewers joining the sessions. While you have the flexibility to host multiple live streaming sessions, the number of viewers joining session concurrently is restricted.

**Example #3**

Lets say you’re using video callings (RTC) in your organization on the Pay-as-you-Go Plan and you're hosting 5 concurrent calls (sessions), all of which are being recorded. Now, when you initiate the 6th call (session) and request recording, VideoSDK will not process your recording request. Instead, it will throw an error because you've reached your recording request limit.

If you have any questions regarding quota limits and pricing plan, post in our [Discord community](https://discord.com/invite/Qfm8j4YAUJ), [contact us](https://www.videosdk.live/contact) directly, or reach out to us on [support@videosdk.live](mailto:support@videosdk.live).

---

---
title: Custom Template - Android
sidebar_position: 1
sidebar_label: Customize Recording UI
hide_table_of_contents: false
---

import CustomTemplate from '../../../../../mdx/\_custom-template.mdx';

<CustomTemplate title="Custom Template With Recording"/>


---

---
title: Geo Tag Meeting recordings - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: Geo Tag meeting recordings feature quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Geo Tag Recording
pagination_label: Geo Tag Recording
keywords:
  - Start Recording meeting
  - Stop Recording meeting
  - audio calling
  - video calling
  - geo tag
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: geo-tag-recording
---

# Geo Tag Meeting Recordings - Android

To ensure compliance for BFSIs doing vKYC, it very important to include the co-ordinates(location) of the customer in the recordings. VideoSDK provides a very customizable solution to implement this feature. You will be using custom templates for this purpose.

We have created a ready to use template for this use case which can be found [here](https://github.com/videosdk-live/videosdk-rtc-react-prebuilt-ui/tree/template/geo-tag-watermark). To integrate this template with your recordings follow the below mentiond instructions.

### Host the template

1. Clone the template repository and switch to the branch `template/geo-tag-watermark`.

```bash
git clone https://github.com/videosdk-live/videosdk-rtc-react-prebuilt-ui.git
cd videosdk-rtc-react-prebuilt-ui
git checkout template/geo-tag-watermark
```

2. Install the dependencies and create a build of the project using below mentioned commands.

```bash
npm install
npm run build
```

3. Host the contents of the build folder on your server and check if the template is up and running.

:::note

If you want to create the complete template from scratch you can [follow this guide.](./custom-template.md)

:::

### Using the template for recording

1. To use the template that we deployed earlier, we will be using the `templateUrl` feature in the `startRecording` API.
   To generate the template URL, you will have to append the `meetingId`, and `token` has to be added in the query parameters. Also if you are using the template provided above you need to added a few extra paramters mentioned below. Here is the code snippet to generate the URL.

```js
async function main() {
  let meetingId = "Your MeetingID";
  let token = "Your Token";
  const templateUrl = `https://${YOUR Template URL}/?meetingId=${meetingId}&token=${token}&name=recorder&isRecorder=true&joinWithoutUserInteraction=true`;

  console.log(templateUrl);
}

main();
```

2. Now that we have the template URL, we will use this URL to start the recording using the below provided API call.

```js
async function main() {
  let meetingId = "Your MeetingID";
  let token = "Your Token";
  const templateUrl = `https://${YOUR Template URL}/?meetingId=${meetingId}&token=${token}&name=recorder&isRecorder=true&joinWithoutUserInteraction=true`;

  console.log(templateUrl);

  //Using the previouly created template URL and starting the recording using the API.
  const options = {
    method: "POST",
    headers: {
      Authorization: "$YOUR_TOKEN",
      "Content-Type": "application/json",
    },
    body: JSON.stringify({
      roomId: "Your MeetingId",
      templateUrl: templateUrl,
    }),
  };
  const url = `https://api.videosdk.live/v2/recordings/start`;
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
}

main();
```

### Updating the Geo Tagging Coordinates

We will be using the PubSub feature of VideoSDK to update the data of latitude and longitude. For the predefined template provided by us we are using `GEO_TAG` as topic name. We will be publishing the `participantName`, `latitude` and `longitude` of the participant for whom we want to show in the recording.

:::note

You will have to fetch the longitude and latitude of the participant before sending it using the pubsub.

:::

Here is the code how you will have to publish the message:

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
private fun sendMessage() {
  // publish message
  val options = PubSubPublishOptions()
  options.isPersist = true
  val geoTagData = JSONObject()
  JsonUtils.jsonPut(geoTagData, "latitude", "PARTICIPANT LATITUDE")
  JsonUtils.jsonPut(geoTagData, "longitude", "PARTICIPANT LONGITUDE")
  JsonUtils.jsonPut(geoTagData, "participantName", "PARTICIPANT NAME")

  //highlight-next-line
  meeting!!.pubSub.publish("GEO_TAG", "GEO_TAG_DATA", options, geoTagData)
}
```

</TabItem>

<TabItem value="Java">

```js
protected void sendMessage() {
  // publish message
  PubSubPublishOptions options = new PubSubPublishOptions();
  options.setPersist(true);
  JSONObject geoTagData = JSONObject()
  JsonUtils.jsonPut(geoTagData, "latitude", "YOUR LATITUDE")
  JsonUtils.jsonPut(geoTagData, "longitude", "YOUR LONGITUDE")
  JsonUtils.jsonPut(geoTagData, "participantName", "PARTICIPANT NAME")
  //highlight-next-line
  meeting.pubSub.publish("GEO_TAG", "GEO TAG DATA", options, geoTagData);
}
```

</TabItem>

</Tabs>

After implementing this, you should get the recording in the following format:

![Geo Tagging Recoridng](https://cdn.videosdk.live/website-resources/docs-resources/geo-tag-recording-template.png)

If you wish to change how UI looks on recording, you can change it by updating the layout in the template itself.

### API Reference

The API references for all the methods utilized in this guide are provided below.

- [Start Recording API](/api-reference/realtime-communication/start-recording)
- [Learn more about Custom Templates](./custom-template.md)


---

---
title: Recording Overview - Android
hide_title: false
hide_table_of_contents: false
description: Record Meeting features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Overview
pagination_label: Overview
keywords:
  - Overview
  - Start Recording meeting
  - Stop Recording meeting
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: Overview
---

import Overview from '../../../../../mdx/\_recording-overview.mdx';

<Overview title="Recording Overview"/>


---

---
title: Generate presigned URL - Android
hide_title: false
hide_table_of_contents: false
description: presigned URL features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Generate presigned URL
pagination_label: Generate presigned URL
keywords:
  - Start Recording meeting
  - Stop Recording meeting
  - audio calling
  - video calling
  - real-time communication
  - presigned URL
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: presigned-URL
---

import PreSignedUrl from '../../../../../mdx/\_presigned-url.mdx';

<PreSignedUrl title="Generate presigned URL - Android"/>


---

---
title: Record Meeting Video & Audio Call - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: Record Meeting features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Start and Stop
pagination_label: Start and Stop
keywords:
  - Start Recording meeting
  - Stop Recording meeting
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: record-meeting
---

# Start and Stop - Android

This guide will provide an overview of how to implement start and stop Meeting Recording.

### `startRecording()`

`startRecording()` can be used to start a recording of the meeting which can be accessed from the `Meeting` class. This method accepts four parameters:

- `1. webhookUrl`: This would the webhook URL where you would like to listen to event happening for the recording like starting and stopping of recording. It will be triggered when the recording is completed and stored into server. Read more about webhooks [here](https://en.wikipedia.org/wiki/Webhook)

- `2. awsDirPath`: This parameter accepts the path for the your S3 bucket where you want to store recordings to. To allow us to store recording in your S3 bucket, you will need to fill this form by providing the required values. ([VideoSDK Cloud (AWS S3, Azure Blob or GCP ) Integration](/android/guide/video-and-audio-calling-api-sdk/recording/recording-storage-config))

- `3. config`: This parameter will define how the meeting should be recorded.

- `4. transcription`: This parameter lets you start post transcription for the recording.

:::note

If you don't have a value for `webhookUrl`,`awsDirPath` or `config`, you should pass `null` in place of the missing value. If you pass `null` in `awsDirPath` parameter then by default recordings will be store on the VideoSDK's storage.
:::

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
val config = JSONObject()

//highlight-next-line
// Layout Configuration
val layout = JSONObject()
JsonUtils.jsonPut(layout, "type", "GRID") // "SPOTLIGHT" | "SIDEBAR",  Default : "GRID"
JsonUtils.jsonPut(layout, "priority", "SPEAKER") // "PIN", Default : "SPEAKER"
JsonUtils.jsonPut(layout, "gridSize", 4) // MAX : 4
JsonUtils.jsonPut(config, "layout", layout)

//highlight-next-line
// Theme of recording
JsonUtils.jsonPut(config, "theme", "DARK") //  "LIGHT" | "DEFAULT"

//highlight-next-line
// `mode` is used to either record video & audio both or only audio.
JsonUtils.jsonPut(config, "mode", "video-and-audio") // "audio", Default : "video-and-audio"

//highlight-next-line
// Quality of recording and is only applicable to `video-and-audio` type mode.
JsonUtils.jsonPut(config, "quality", "high") // "low" | "med",  Default : "med"

//highlight-start
// This mode refers to orientation of recording.
// landscape : Record the meeting in horizontally
// portrait : Record the meeting in vertically (Best for mobile view)
//highlight-end
JsonUtils.jsonPut(config, "orientation", "portrait") // "landscape",  Default : "landscape"

//highlight-next-line
// Post Transcription Configuration
val prompt = "Write summary in sections like Title, Agenda, Speakers, Action Items, Outlines, Notes and Summary"
val summaryConfig = SummaryConfig(true, prompt)
val modelId = "raman_v1"
val transcription = PostTranscriptionConfig(true, summaryConfig, modelId)

meeting.startRecording(null, null, config, transcription)
```

</TabItem>

<TabItem value="Java">

```js
JSONObject config = new JSONObject();

//highlight-next-line
// Layout Configuration
JSONObject layout = new JSONObject();
JsonUtils.jsonPut(layout, "type", "GRID"); // "SPOTLIGHT" | "SIDEBAR",  Default : "GRID"
JsonUtils.jsonPut(layout, "priority", "SPEAKER");  // "PIN", Default : "SPEAKER"
JsonUtils.jsonPut(layout, "gridSize", 4); // MAX : 4
JsonUtils.jsonPut(config, "layout", layout);

//highlight-next-line
// Theme of recording
JsonUtils.jsonPut(config, "theme", "DARK"); //  "LIGHT" | "DEFAULT"

//highlight-next-line
// `mode` is used to either record video & audio both or only audio.
JsonUtils.jsonPut(config, "mode", "video-and-audio"); // "audio", Default : "video-and-audio"

//highlight-next-line
// Quality of recording and is only applicable to `video-and-audio` type mode.
JsonUtils.jsonPut(config, "quality", "high"); // "low" | "med",  Default : "med"

//highlight-start
// This mode refers to orientation of recording.
// landscape : Record the meeting in horizontally
// portrait : Record the meeting in vertically (Best for mobile view)
//highlight-end
JsonUtils.jsonPut(config, "orientation", "portrait"); // "landscape",  Default : "landscape"

//highlight-next-line
// Post Transcription Configuration
String prompt = "Write summary in sections like Title, Agenda, Speakers, Action Items, Outlines, Notes and Summary";
SummaryConfig summaryConfig = new SummaryConfig(true, prompt);
String modelId = "raman_v1";
PostTranscriptionConfig transcription = new PostTranscriptionConfig(true, summaryConfig, modelId);

meeting.startRecording(null, null, config, transcription);
```

</TabItem>

</Tabs>

### `stopRecording()`

- `stopRecording()` is used to stop the meeting recording which can be accessed from the `Meeting` class.

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
// keep track of recording
val recording = false

findViewById<View>(R.id.btnRecording).setOnClickListener { view: View? ->
    if (!recording) {
      //highlight-start
      val config = JSONObject()
      val layout = JSONObject()
      JsonUtils.jsonPut(layout, "type", "GRID")
      JsonUtils.jsonPut(layout, "priority", "SPEAKER")
      JsonUtils.jsonPut(layout, "gridSize", 4)
      JsonUtils.jsonPut(config, "layout", layout)
      JsonUtils.jsonPut(config, "theme", "DARK")
      JsonUtils.jsonPut(config, "mode", "video-and-audio")
      JsonUtils.jsonPut(config, "quality", "high")
      JsonUtils.jsonPut(config, "orientation", "portrait")
      //highlight-end

      //highlight-next-line
      // Post Transcription Configuration
      val prompt = "Write summary in sections like Title, Agenda, Speakers, Action Items, Outlines, Notes and Summary"
      val summaryConfig = SummaryConfig(true, prompt)
      val modelId = "raman_v1"
      val transcription = PostTranscriptionConfig(true, summaryConfig, modelId)

      // Start Recording
      // If you don't have a `webhookUrl` or `awsDirPath`, you should pass null.
      // If you don't want to enable transcription, you can pass null as parameter.
      //highlight-next-line
      meeting!!.startRecording("YOUR WEB HOOK URL", "AWS Directory Path", config, transcription)
    } else {
      // Stop Recording
      //highlight-next-line
      meeting!!.stopRecording()
    }
}
```

</TabItem>

<TabItem value="Java">

```js
// keep track of recording
boolean recording = false;

findViewById(R.id.btnRecording).setOnClickListener(view -> {
    if (!recording) {
      //highlight-start
      JSONObject config = new JSONObject();
      JSONObject layout = new JSONObject();
      JsonUtils.jsonPut(layout, "type", "GRID");
      JsonUtils.jsonPut(layout, "priority", "SPEAKER");
      JsonUtils.jsonPut(layout, "gridSize", 4);
      JsonUtils.jsonPut(config, "layout", layout);
      JsonUtils.jsonPut(config, "theme", "DARK");
      JsonUtils.jsonPut(config, "mode", "video-and-audio");
      JsonUtils.jsonPut(config, "quality", "high");
      JsonUtils.jsonPut(config, "orientation", "portrait");
      //highlight-end

      //highlight-next-line
      // Post Transcription Configuration
      String prompt = "Write summary in sections like Title, Agenda, Speakers, Action Items, Outlines, Notes and Summary";
      SummaryConfig summaryConfig = new SummaryConfig(true, prompt);
      String modelId = "raman_v1";
      PostTranscriptionConfig transcription = new PostTranscriptionConfig(true, summaryConfig, modelId);

      // Start Recording
      // If you don't have a `webhookUrl` or `awsDirPath`, you should pass null.
      // If you don't want to enable transcription, you can pass null as parameter.
      //highlight-next-line
      meeting.startRecording("YOUR WEB HOOK URL", "AWS Directory Path", config, transcription);
    } else {
      // Stop Recording
      //highlight-next-line
      meeting.stopRecording();
    }
});
```

</TabItem>

</Tabs>

:::important

To initiate automatic recording at the beginning of a `session`, simply provide the `autoStartConfig` feature `recording` during `room` creation. For more information on configuring the `autoStartConfig`, please refer to the provided documentation **[<u>here</u>](/api-reference/realtime-communication/create-room#autoStartConfig)**.

:::

### API Reference

The API references for all the methods utilised in this guide are provided below.

- [startRecording()](/android/api/sdk-reference/meeting-class/methods#startrecording)
- [stopRecording()](/android/api/sdk-reference/meeting-class/methods#stoprecording)
- [onRecordingStateChanged](/android/api/sdk-reference/meeting-class/meeting-event-listener-class#onrecordingstatechanged)
- [autoStartConfig](/api-reference/realtime-communication/create-room#autoStartConfig)


---

---
title: Participant Recording (Individual) - Android
hide_title: false
hide_table_of_contents: false
description: Individual participant recording features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Participant Recording (Individual)
pagination_label: Participant Recording
keywords:
  - Start Participant Recording
  - Stop Participant Recording
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: record-participant
---

import RecordParticipant from '../../../../../mdx/\_intro-participant-recording.mdx';
import WebhookParticipantRecording from '../../../../../mdx/\_webhook-participant-recording.mdx';

<RecordParticipant title="Record Participant"/>

## Start Individual Participant Recording

To start a participant recording, you will have to call `/v2/recordings/participant/start` API with following body parameters.

- `roomId`: RoomId for which the participant recording is to be started
- `participantId`: participantId of the participant to be recorder.
- `fileFormat`: Currently only `webm` is supported as file format. We will add the support for other formats in future.
- `webhookUrl`: The webhook URL where you would like to get the status updates of the recording. To learn more about webhooks refer [here](#participant-track-recording-starting).
- `bucketDirPath`: If you are using your own storage, you can provide the directory path where you want to store the recording. To configure the storage please [refere this quide](/javascript/guide/video-and-audio-calling-api-sdk/recording/recording-storage-config).

The usual recording path would look like `${sessionId}/${participantId}/${filename}`.

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'}]}>

<TabItem value="Kotlin">

```kotlin
import org.json.JSONObject
import java.io.OutputStream
import java.net.HttpURLConnection
import java.net.URL
import java.io.IOException

fun StartParticipantRecording() {
    val roomId = "<YOUR ROOM ID>"
    val participantId = "<PARTICIPANT ID>"
    val fileFormat = "<YOUR FILE FORMAT>" // (Optional) default: webm
    val bucketDirPath = "<YOUR CLOUD STORAGE BUCKET PATH>" // (Optional) test/abc
    val webhookUrl = "<YOUR WEBHOOK URL>" // (Optional)

    try {
        val url = URL("https://api.videosdk.live/v2/recordings/participant/start")
        val conn = url.openConnection() as HttpURLConnection
        conn.requestMethod = "POST"
        conn.setRequestProperty("Authorization", "$YOUR_TOKEN")
        conn.setRequestProperty("Content-Type", "application/json")
        conn.doOutput = true

        val json = JSONObject()
        json.put("roomId", roomId)
        json.put("participantId", participantId)
        json.put("fileFormat", fileFormat)
        json.put("bucketDirPath", bucketDirPath)
        json.put("webhookUrl", webhookUrl)

        conn.outputStream.use { os: OutputStream ->
            val input = json.toString().toByteArray(Charsets.UTF_8)
            os.write(input, 0, input.size)
        }

        val responseCode = conn.responseCode
        if (responseCode == HttpURLConnection.HTTP_OK) {
            println("Participant Recording started successfully.")
        } else {
            println("Failed to start participant recording.")
        }
    } catch (e: Exception) {
        e.printStackTrace()
    }
}

```

</TabItem>

<TabItem value="Java">

```java
import java.io.OutputStream;
import java.net.HttpURLConnection;
import java.net.URL;
import org.json.JSONObject;

private void StartParticipantRecording() {
    String roomId = "<YOUR ROOM ID>";
    String participantId = "<PARTICIPANT ID>";
    String fileFormat = "<YOUR FILE FORMAT>"; // (Optional) default: webm
    String bucketDirPath = "<YOUR CLOUD STORAGE BUCKET PATH>"; // (Optional) test/abc
    String webhookUrl = "<YOUR WEBHOOK URL>"; // (Optional)

    try {
        URL url = new URL("https://api.videosdk.live/v2/recordings/participant/start");
        HttpURLConnection conn = (HttpURLConnection) url.openConnection();
        conn.setRequestMethod("POST");
        conn.setRequestProperty("Authorization", "$YOUR_TOKEN");
        conn.setRequestProperty("Content-Type", "application/json");
        conn.setDoOutput(true);

        JSONObject json = new JSONObject();
        json.put("roomId", roomId);
        json.put("participantId", participantId);
        json.put("fileFormat", fileFormat);
        json.put("bucketDirPath", bucketDirPath);
        json.put("webhookUrl", webhookUrl);

        try (OutputStream os = conn.getOutputStream()) {
            byte[] input = json.toString().getBytes("utf-8");
            os.write(input, 0, input.length);
        }

        int responseCode = conn.getResponseCode();
        if (responseCode == HttpURLConnection.HTTP_OK) {
            System.out.println("Participant Recording started successfully.");
        } else {
            System.out.println("Failed to start participant recording.");
        }
    } catch (Exception e) {
        e.printStackTrace();
    }
}

```

</TabItem>

</Tabs>

## Stop Individual Participant Recording

To stop a participant recording, you will have to call `/v2/recordings/participant/stop` API with following body parameters.

- `roomId`: RoomId for which the participant recording is to be stopped
- `participantId`: participantId for which the recording is to be stopped.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```kotlin
import org.json.JSONObject
import java.io.OutputStream
import java.net.HttpURLConnection
import java.net.URL

fun StopParticipantRecording() {
val roomId = "<YOUR ROOM ID>"
val participantId = "<PARTICIPANT ID>"

    try {
        val url = URL("https://api.videosdk.live/v2/recordings/participant/stop")
        val conn = url.openConnection() as HttpURLConnection
        conn.requestMethod = "POST"
        conn.setRequestProperty("Authorization", "$YOUR_TOKEN")
        conn.setRequestProperty("Content-Type", "application/json")
        conn.doOutput = true

        val json = JSONObject()
        json.put("roomId", roomId)
        json.put("participantId", participantId)

        conn.outputStream.use { os: OutputStream ->
            val input = json.toString().toByteArray(Charsets.UTF_8)
            os.write(input, 0, input.size)
        }

        val responseCode = conn.responseCode
        if (responseCode == HttpURLConnection.HTTP_OK) {
            println("Participant Recording stopped successfully.")
        } else {
            println("Failed to stop participant recording.")
        }
    } catch (e: Exception) {
        e.printStackTrace()
    }

}

```

</TabItem>

<TabItem value="Java">

```java
import java.io.OutputStream;
import java.net.HttpURLConnection;
import java.net.URL;
import org.json.JSONObject;

private void StopParticipantRecording() {
    String roomId = "<YOUR ROOM ID>";
    String participantId = "<PARTICIPANT ID>";

    try {
        URL url = new URL("https://api.videosdk.live/v2/recordings/participant/stop");
        HttpURLConnection conn = (HttpURLConnection) url.openConnection();
        conn.setRequestMethod("POST");
        conn.setRequestProperty("Authorization", "$YOUR_TOKEN");
        conn.setRequestProperty("Content-Type", "application/json");
        conn.setDoOutput(true);

        JSONObject json = new JSONObject();
        json.put("roomId", roomId);
        json.put("participantId", participantId);

        try (OutputStream os = conn.getOutputStream()) {
            byte[] input = json.toString().getBytes("utf-8");
            os.write(input, 0, input.length);
        }

        int responseCode = conn.getResponseCode();
        if (responseCode == HttpURLConnection.HTTP_OK) {
            System.out.println("Participant Recording stopped successfully.");
        } else {
            System.out.println("Failed to stop participant recording.");
        }
    } catch (Exception e) {
        e.printStackTrace();
    }
}


```

</TabItem>

</Tabs>

<WebhookParticipantRecording title="Webhooks"/>


---

---
title: Participant Track Recording - Android
hide_title: false
hide_table_of_contents: false
description: Participant track recording features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Participant Track Recording
pagination_label: Participant Track Recording
keywords:
  - Start Track Recording
  - Start Track Recording
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: record-track
---

import RecordTrack from '../../../../../mdx/\_intro-track-recording.mdx';
import WebhookTrackRecording from '../../../../../mdx/\_webhook-track-recording.mdx';

<RecordTrack title="Record Track"/>

## Start Participant Track Recording

To start a participant track recording, you will have to call `/v2/recordings/participant/track/start` API with following body parameters.

- `roomId`: RoomId for which the participant track recording is to be started
- `participantId`: participantId of the participant to be recorder.
- `kind`: The kind of tracks you want to record.
  - You can pass following values: _`audio`_ | _`video`_ | _`screen_audio`_ | _`screen_video`_
- `fileFormat`: Currently only `webm` is supported as file format. We will add the support for other formats in future.
- `webhookUrl`: The webhook URL where you would like to get the status updates of the recording. To learn more about webhooks refer [here](#participant-track-recording-starting).
- `bucketDirPath`: If you are using your own storage, you can provide the directory path where you want to store the recording. To configure the storage please [refere this quide](/javascript/guide/video-and-audio-calling-api-sdk/recording/recording-storage-config).

The usual recording path would look like `${sessionId}/${participantId}/${kind}/${filename}`.

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'}]}>

<TabItem value="Kotlin">

```kotlin
import org.json.JSONObject
import java.io.OutputStream
import java.net.HttpURLConnection
import java.net.URL
import java.io.IOException

fun StartTrackRecording() {
    val roomId = "<YOUR ROOM ID>"
    val participantId = "<PARTICIPANT ID>"
    val kind = "<YOUR STREAM KIND>"
    val fileFormat = "<YOUR FILE FORMAT>"
    val bucketDirPath = "<YOUR CLOUD STORAGE BUCKET PATH>"
    val webhookUrl = "<YOUR WEBHOOK URL>"

    try {
        val url = URL("https://api.videosdk.live/v2/recordings/participant/track/start")
        val conn = url.openConnection() as HttpURLConnection
        conn.requestMethod = "POST"
        conn.setRequestProperty("Authorization", "$YOUR_TOKEN")
        conn.setRequestProperty("Content-Type", "application/json")
        conn.doOutput = true

        val jsonBody = JSONObject()
        jsonBody.put("roomId", roomId)
        jsonBody.put("participantId", participantId)
        jsonBody.put("kind", kind)
        jsonBody.put("fileFormat", fileFormat)
        jsonBody.put("bucketDirPath", bucketDirPath)
        jsonBody.put("webhookUrl", webhookUrl)

        conn.outputStream.use { os: OutputStream ->
            val input = json.toString().toByteArray(Charsets.UTF_8)
            os.write(input, 0, input.size)
        }

        val responseCode = conn.responseCode
        if (responseCode == HttpURLConnection.HTTP_OK) {
            println("Track Recording started successfully.")
        } else {
            println("Failed to start track recording.")
        }
    } catch (e: Exception) {
        e.printStackTrace()
    }
}



```

</TabItem>

<TabItem value="Java">

```java
import java.io.OutputStream;
import java.net.HttpURLConnection;
import java.net.URL;
import org.json.JSONObject;

public void StartTrackRecording() {
    String roomId = "<YOUR ROOM ID>";
    String participantId = "<PARTICIPANT ID>";
    String kind = "<YOUR STREAM KIND>";
    String fileFormat = "<YOUR FILE FORMAT>";
    String bucketDirPath = "<YOUR CLOUD STORAGE BUCKET PATH>";
    String webhookUrl = "<YOUR WEBHOOK URL>";

    try {
        URL url = new URL("https://api.videosdk.live/v2/recordings/participant/track/start");
        HttpURLConnection conn = (HttpURLConnection) url.openConnection();
        conn.setRequestMethod("POST");
        conn.setRequestProperty("Authorization", "$YOUR_TOKEN");
        conn.setRequestProperty("Content-Type", "application/json");
        conn.setDoOutput(true);

        JSONObject jsonBody = new JSONObject();
        jsonBody.put("roomId", roomId);
        jsonBody.put("participantId", participantId);
        jsonBody.put("kind", kind);
        jsonBody.put("fileFormat", fileFormat);
        jsonBody.put("bucketDirPath", bucketDirPath);
        jsonBody.put("webhookUrl", webhookUrl);

        try (OutputStream os = conn.getOutputStream()) {
        byte[] input = json.toString().getBytes("utf-8");
        os.write(input, 0, input.length);
        }

        int responseCode = conn.getResponseCode();
        if (responseCode == HttpURLConnection.HTTP_OK) {
            System.out.println("Track Recording started successfully.");
        } else {
            System.out.println("Failed to start track recording.");
        }
    } catch (Exception e) {
        e.printStackTrace();
    }
}

```

</TabItem>

</Tabs>

## Stop Participant Track Recording

To stop a participant track recording, you will have to call `/v2/recordings/participant/track/stop` API with following body parameters.

- `roomId`: RoomId for which the participant track recording is to be stopped
- `participantId`: participantId for which the recording is to be stopped.
- `kind`: The kind of track recording you want to stop for the given participant.
  - You can pass following values: _`audio`_ | _`video`_ | _`screen_audio`_ | _`screen_video`_

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```kotlin
import org.json.JSONObject
import java.io.OutputStream
import java.net.HttpURLConnection
import java.net.URL

fun StopTrackRecording() {
    val roomId = "<YOUR ROOM ID>"
    val participantId = "<PARTICIPANT ID>"
    val kind = "<YOUR STREAM KIND>"

    try {
        val url = URL("https://api.videosdk.live/v2/recordings/participant/track/stop")
        val conn = url.openConnection() as HttpURLConnection
        conn.requestMethod = "POST"
        conn.setRequestProperty("Authorization", "$YOUR_TOKEN")
        conn.setRequestProperty("Content-Type", "application/json")
        conn.doOutput = true

        val jsonBody = JSONObject()
        jsonBody.put("roomId", roomId)
        jsonBody.put("participantId", participantId)
        jsonBody.put("kind", kind)

        conn.outputStream.use { os: OutputStream ->
            val input = json.toString().toByteArray(Charsets.UTF_8)
            os.write(input, 0, input.size)
        }

        val responseCode = conn.responseCode
        if (responseCode == HttpURLConnection.HTTP_OK) {
            println("Track Recording stopped successfully.")
        } else {
            println("Failed to stop track recording.")
        }
    } catch (e: Exception) {
        e.printStackTrace()
    }
}

```

</TabItem>

<TabItem value="Java">

```java
import java.io.OutputStream;
import java.net.HttpURLConnection;
import java.net.URL;
import org.json.JSONObject;

public void StopTrackRecording() {
    String roomId = "<YOUR ROOM ID>";
    String participantId = "<PARTICIPANT ID>";
    String kind = "<YOUR STREAM KIND>";


    try {
        URL url = new URL("https://api.videosdk.live/v2/recordings/participant/track/stop");
        HttpURLConnection conn = (HttpURLConnection) url.openConnection();
        conn.setRequestMethod("POST");
        conn.setRequestProperty("Authorization", "$YOUR_TOKEN");
        conn.setRequestProperty("Content-Type", "application/json");
        conn.setDoOutput(true);

        JSONObject jsonBody = new JSONObject();
        jsonBody.put("roomId", roomId);
        jsonBody.put("participantId", participantId);
        jsonBody.put("kind", kind);

        try (OutputStream os = conn.getOutputStream()) {
        byte[] input = json.toString().getBytes("utf-8");
        os.write(input, 0, input.length);
        }

        int responseCode = conn.getResponseCode();
        if (responseCode == HttpURLConnection.HTTP_OK) {
            System.out.println("Track Recording stopped successfully.");
        } else {
            System.out.println("Failed to stop track recording.");
        }
    } catch (Exception e) {
        e.printStackTrace();
    }
}

```

</TabItem>

</Tabs>

<WebhookTrackRecording title="Webhooks" />


---

---
title: Configure Recording Storage - Android
hide_title: false
hide_table_of_contents: false
sidebar_label: Configure Recording Storage
sidebar_position: 1
pagination_label: Configure Recording Storage
keywords:
  - configure recording storage
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
slug: recording-storage-config
---

### Storage Configuration

While recording your meetings, you have the flexibility to store them either on VideoSDK's storage or configure your own storage solution such as **`AWS S3 Storage, Azure Blob or GCP Cloud Storage`**. To set up your own storage, you can navigate to the [API section](https://app.videosdk.live/api-keys) in the VideoSDK Dashboard.

- This feature allows you to configure storage provider for your meeting recordings.

- You can configure multiple storage provider with multiple API Keys.

- Currently, we support `AWS S3`, `Azure Blob` and `GCP Cloud Storage`. We will add support for other storage provider soon !!

## Prerequisites

- An active [VideoSDK Developer Account](https://app.videosdk.live)
- `Aws S3`, `Azure Blob Storage` or `GCP Cloud Storage` Credentials

## How to setup ?

### Step 1 : Select Api Key

![Dashboard](/img/tutorial/dashboard/api-key-dashboard.png)

- Go to [VideoSDK Dashboard](https://app.videosdk.live/api-keys).
- Select API Key for which, you want to set storage configuration.
- Then click on `Storage Config` Icon in Actions.

### Step 2 : Choose Cloud Storage Provider

![Dashboard](/img/tutorial/dashboard/storage-config.png)

- As you can see in the image, there are 3 Cloud Storage Provider (`Aws`, `Azure`, `GCP`).
- You can select a Cloud Storage Provider as per your requirements.

### Step 3 : Configure Bucket or Container

<h4> For Aws S3 Storage </h4>

![Aws S3](/img/tutorial/dashboard/s3.png)

- You will need AWS S3 Bucket. [Learn to create S3 Bucket](https://docs.aws.amazon.com/AmazonS3/latest/userguide/creating-bucket.html).

- As you can see in the image, you will need enter `accessKeyId`, `secretAccessKey`, `region`, `bucket`, and `ACL` to setup for Aws S3 Storage.

- Click on `Save` button.

<hr />

<h4> For Azure Blob Storage: </h4>

![Azure Blob](/img/tutorial/dashboard/blob.png)

- You will need Azure Blob Container. [Learn to create Blob Container](https://docs.microsoft.com/en-us/azure/storage/blobs/storage-quickstart-blobs-portal#create-a-container).

- As you can see in the image, you will need to enter `connectionString` and `containerName` to setup for Azure Blob.

- Click on `Save` button.

<hr />

<h4> For Google Cloud Storage: </h4>

<img src="/img/tutorial/dashboard/gcp.png" alt="GCP Cloud Storage" width="436" height="632"/>

1. You will need Google Cloud Storage Bucket. [Learn to create Google Cloud Storage Bucket](https://cloud.google.com/storage/docs/creating-buckets).

2. After creation, click on the <b> &#xFE19; </b>button in the upper right corner and select **`Project settings`**.

3. Under **`IAM and Admin`**, select **`Service Accounts`**. In the service account list, click on the <b> &#xFE19; </b> button for the account just added or created before, and select **`Manage keys`**.

4. Click **`ADD KEY > Create new key`**. Select **`JSON`** in the pop-up box and click **`CREATE`**. A json file is downloaded with the name format `projectId-xxxxxxxx.json`.

5. Open the downloaded json file, which looks like the following example:

```
{
  "type": "service_account",
  "project_id": "videosdk-12345",
  "private_key_id": "yourprivateidkeyyourprivateidkeyyourprivateidkey",
  "private_key": "-----BEGIN PRIVATE KEY-----\nThisisYourPrivateKeyThisisYourPrivateKeyThisisYourPrivateKey\nThisisYourPrivateKey\nThisisYourPrivateKey\nThisisYourPrivateKey\n-----END PRIVATE KEY-----\n",
  "client_email": "xxxx-xxxx@videosdk-12345.iam.gserviceaccount.com",
  "client_id": "123456789012345678901",
  "auth_uri": "https://accounts.google.com/o/oauth2/auth",
  "token_uri": "https://oauth2.googleapis.com/token",
  "auth_provider_x509_cert_url": "https://www.googleapis.com/oauth2/v1/certs",
  "client_x509_cert_url": "https://www.googleapis.com/robot/v1/metadata/x509/videosdk%40videosdk-404307.iam.gserviceaccount.com",
  "universe_domain": "googleapis.com"
}
```

- As you can see in the image, you will need to enter `Project Id`, `Client Email`, `Bucket`, `Private Key` to setup for Google Cloud Storage Bucket. You can retrieve these details from the json file.

- Click on `Save` button.

### Step 4 : Test

- It's time to test !!
- [Create Room](https://docs.videosdk.live/api-reference/realtime-communication/create-room) with token generated with the API Key, you have configured for.
- Start meeting with the roomId created and Start Recording !!
- Then, you can see that recording will be available in your Bucket or Container.

:::note

- Only a single Recording Storage Config can be possible for a particular Api Key at a time.
- In order to add new Recording Configuration, first you need to delete current configuration.

:::


---

---
title: Record Meeting Video & Audio Call - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: Record Meeting features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Webhook and Events
pagination_label: Webhook and Events
keywords:
  - Start Recording meeting
  - Stop Recording meeting
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: webhook-and-events
---

# Webhooks and Events - Android

### Event associated with Recording

- **onRecordingStateChanged** - Whenever meeting recording state changes, then `onRecordingStateChanged` event will trigger.

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
private val meetingEventListener: MeetingEventListener = object : MeetingEventListener() {
  override fun onRecordingStateChanged(recordingState: String) {
    when (recordingState) {
        "RECORDING_STARTING" -> {
            Log.d("onRecordingStateChanged", "Meeting recording is starting")
        }
        "RECORDING_STARTED" -> {
            Log.d("onRecordingStateChanged", "Meeting recording is started")
        }
        "RECORDING_STOPPING" -> {
            Log.d("onRecordingStateChanged", "Meeting recording is stopping")
        }
        "RECORDING_STOPPED" -> {
            Log.d("onRecordingStateChanged", "Meeting recording is stopped")
        }
    }
  }
}

override fun onCreate(savedInstanceState: Bundle?) {
  //...

  // add listener to meeting
  //highlight-next-line
  meeting!!.addEventListener(meetingEventListener)
}
```

</TabItem>

<TabItem value="Java">

```js
private final MeetingEventListener meetingEventListener = new MeetingEventListener() {
  @Override
  public void onRecordingStateChanged(String recordingState) {
      switch (recordingState) {
          case "RECORDING_STARTING":
              Log.d("onRecordingStateChanged", "Meeting recording is starting");
              break;
          case "RECORDING_STARTED":
              Log.d("onRecordingStateChanged", "Meeting recording is started");
              break;
          case "RECORDING_STOPPING":
              Log.d("onRecordingStateChanged", "Meeting recording is stopping");
              break;
          case "RECORDING_STOPPED":
              Log.d("onRecordingStateChanged", "Meeting recording is stopped");
              break;
      }
  }
}

@Override
protected void onCreate(Bundle savedInstanceState) {
  //...

  // add listener to meeting
  //highlight-next-line
  meeting.addEventListener(meetingEventListener);
}
```

</TabItem>

</Tabs>

## Webhook associated with Recording

### recording-starting

- A "Recording Starting" webhook is triggered when the recording process for a meeting is initiated.

###### Example

```javascript
{
    "webhookType": "recording-starting",
    "data": {
        "meetingId": "jvsg-8rjn-j304",
        "sessionId": "613731342f27f56e4fc4b6d0",
    },
}
```

---

### recording-started

- Recording started webhook will be received when successfully recording is started in meeting

###### Example

```javascript
{
    "webhookType": "recording-started",
    "data": {
        "meetingId": "jvsg-8rjn-j304",
        "sessionId": "613731342f27f56e4fc4b6d0",
    },
}
```

---

### recording-stopping

- A "Recording Stopping" webhook is triggered when the recording end process for a meeting is initiated.

###### Example

```javascript
{
    "webhookType": "recording-stopping",
    "data": {
        "meetingId": "jvsg-8rjn-j304",
        "sessionId": "613731342f27f56e4fc4b6d0",
    },
}
```

---

### recording-stopped

- Recording stopped webhook will be received when recording is successfully stopped in meeting.

###### Example

```javascript
{
    "webhookType": "recording-stopped",
    "data": {
        "meetingId": "jvsg-8rjn-j304",
        "sessionId": "613731342f27f56e4fc4b6d0",
        "filePath" : "/encoded/videos/62d148951a1eb20029fc9b05.mp4",
        "fileUrl" : "https://cdn.videosdk.live/encoded/videos/62d148951a1eb20029fc9b05.mp4",

    },
}
```

---

### recording-failed

- A "Recording Failed" webhook is generated when the recording process encounters an interruption or issue during either the starting or stopping phases.

###### Example

```javascript
{
    "webhookType": "recording-failed",
    "data": {
        "meetingId": "jvsg-8rjn-j304",
        "sessionId": "613731342f27f56e4fc4b6d0",
    },
}
```


---

---
title: Interactive Livestream - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: Interactive Livestream features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Interactive Livestream (HLS)
pagination_label: Interactive Livestream (HLS)
keywords:
  - Start HLS meeting
  - Stop HLS meeting
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: interactive-livestream
---

# Interactive Livestream (HLS) - Android

Interactive live streaming (HLS) refers to a type of live streaming where viewers can actively engage with the content being streamed and with other viewers in real-time.

In an interactive live stream (HLS), viewers can take part in a variety of activities like live polling, Q&A sessions, and even sending virtual gifts to the content creator or each other.

<center>

<img src='https://cdn.videosdk.live/website-resources/docs-resources/mobile_hls.png' />

</center>

VideoSDK also allows you to configure the interactive livestream layouts in numerous ways like by simply setting different prebuilt layouts in the configuration or by providing your own custom template to do the livestream according to your layout choice.

This guide will provide an overview of how to implement start and stop Interactive live streaming (HLS).

:::important

To initiate automatic Interactive live streaming (HLS) at the beginning of a `session`, simply provide the `autoStartConfig` feature `hls` during `room` creation. For more information on configuring the `autoStartConfig`, please refer to the provided documentation **[<u>here</u>](/api-reference/realtime-communication/create-room#autoStartConfig)**.

:::

### `startHls()`

`startHls()` can be used to start a interactive livestream of the meeting which can be accessed from the `Meeting` class. This method accepts two parameter:

- `config`: This parameter will define how the interactive livestream layout should look like.

- `transcription`: This parameter lets you start post transcription for the Livestreaming.


import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
val config = JSONObject()

//highlight-next-line
// Layout Configuration
val layout = JSONObject()
JsonUtils.jsonPut(layout, "type", "GRID") // "SPOTLIGHT" | "SIDEBAR",  Default : "GRID"
JsonUtils.jsonPut(layout, "priority", "SPEAKER") // "PIN", Default : "SPEAKER"
JsonUtils.jsonPut(layout, "gridSize", 4) // MAX : 25
JsonUtils.jsonPut(config, "layout", layout)

//highlight-next-line
// Theme of interactive livestream layout
JsonUtils.jsonPut(config, "theme", "DARK") //  "LIGHT" | "DEFAULT"

//highlight-next-line
// `mode` is used to either interactive livestream video & audio both or only audio.
JsonUtils.jsonPut(config, "mode", "video-and-audio") // "audio", Default : "video-and-audio"

//highlight-next-line
// Quality of interactive livestream and is only applicable to `video-and-audio` type mode.
JsonUtils.jsonPut(config, "quality", "high") // "low" | "med",  Default : "med"

//highlight-start
// This mode refers to orientation of interactive livestream.
// landscape : Start interactive livestream of the meeting in horizontally
// portrait : Start interactive livestream of the meeting in vertically (Best for mobile view)
//highlight-end
JsonUtils.jsonPut(config, "orientation", "portrait") // "landscape",  Default : "landscape"

//highlight-next-line
// Post Transcription Configuration
val prompt = "Write summary in sections like Title, Agenda, Speakers, Action Items, Outlines, Notes and Summary"
val summaryConfig = SummaryConfig(true, prompt)
val modelId = "raman_v1"
val transcription = PostTranscriptionConfig(true, summaryConfig, modelId)

meeting.startHls(config, transcription)
```

</TabItem>

<TabItem value="Java">

```js
JSONObject config = new JSONObject();

//highlight-next-line
// Layout Configuration
JSONObject layout = new JSONObject();
JsonUtils.jsonPut(layout, "type", "GRID"); // "SPOTLIGHT" | "SIDEBAR",  Default : "GRID"
JsonUtils.jsonPut(layout, "priority", "SPEAKER");  // "PIN", Default : "SPEAKER"
JsonUtils.jsonPut(layout, "gridSize", 4); // MAX : 25
JsonUtils.jsonPut(config, "layout", layout);

//highlight-next-line
// Theme of interactive livestream layout
JsonUtils.jsonPut(config, "theme", "DARK"); //  "LIGHT" | "DEFAULT"

//highlight-next-line
// `mode` is used to either interactive livestream video & audio both or only audio.
JsonUtils.jsonPut(config, "mode", "video-and-audio"); // "audio", Default : "video-and-audio"

//highlight-next-line
// Quality of interactive livestream and is only applicable to `video-and-audio` type mode.
JsonUtils.jsonPut(config, "quality", "high"); // "low" | "med",  Default : "med"

//highlight-start
// This mode refers to orientation of interactive livestream.
// landscape : Start interactive livestream of the meeting in horizontally
// portrait : Start interactive livestream of the meeting in vertically (Best for mobile view)
//highlight-end
JsonUtils.jsonPut(config, "orientation", "portrait"); // "landscape",  Default : "landscape"

//highlight-next-line
// Post Transcription Configuration
String prompt = "Write summary in sections like Title, Agenda, Speakers, Action Items, Outlines, Notes and Summary";
SummaryConfig summaryConfig = new SummaryConfig(true, prompt);
String modelId = "raman_v1";
PostTranscriptionConfig transcription = new PostTranscriptionConfig(true, summaryConfig, modelId);

meeting.startHls(config, transcription);
```

</TabItem>

</Tabs>

### `stopHls()`

- `stopHls()` is used to stop interactive livestream of the meeting which can be accessed from the `Meeting` class.

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
// keep track of hls
val hls = false

findViewById<View>(R.id.btnHls).setOnClickListener { view: View? ->
  if (!hls) {
    //highlight-start
    val config = JSONObject()
    val layout = JSONObject()
    JsonUtils.jsonPut(layout, "type", "GRID")
    JsonUtils.jsonPut(layout, "priority", "SPEAKER")
    JsonUtils.jsonPut(layout, "gridSize", 4)
    JsonUtils.jsonPut(config, "layout", layout)
    JsonUtils.jsonPut(config, "theme", "DARK")
    JsonUtils.jsonPut(config, "mode", "video-and-audio")
    JsonUtils.jsonPut(config, "quality", "high")
    JsonUtils.jsonPut(config, "orientation", "portrait")
    //highlight-end

    //highlight-next-line
    // Post Transcription Configuration
    val prompt = "Write summary in sections like Title, Agenda, Speakers, Action Items, Outlines, Notes and Summary"
    val summaryConfig = SummaryConfig(true, prompt)
    val modelId = "raman_v1"
    val transcription = PostTranscriptionConfig(true, summaryConfig, modelId)

    // Start Hls
    //highlight-next-line
    meeting!!.startHls(config)
  } else {
    // Stop Hls
    //highlight-next-line
    meeting!!.stopHls()
  }
}
```

</TabItem>

<TabItem value="Java">

```js
// keep track of hls
boolean hls = false;

findViewById(R.id.btnHls).setOnClickListener(view -> {
  if (!hls) {
    //highlight-start
    JSONObject config = new JSONObject();
    JSONObject layout = new JSONObject();
    JsonUtils.jsonPut(layout, "type", "GRID");
    JsonUtils.jsonPut(layout, "priority", "SPEAKER");
    JsonUtils.jsonPut(layout, "gridSize", 4);
    JsonUtils.jsonPut(config, "layout", layout);
    JsonUtils.jsonPut(config, "theme", "DARK");
    JsonUtils.jsonPut(config, "mode", "video-and-audio");
    JsonUtils.jsonPut(config, "quality", "high");
    JsonUtils.jsonPut(config, "orientation", "portrait");
    //highlight-end

    //highlight-next-line
    // Post Transcription Configuration
    String prompt = "Write summary in sections like Title, Agenda, Speakers, Action Items, Outlines, Notes and Summary";
    SummaryConfig summaryConfig = new SummaryConfig(true, prompt);
    String modelId = "raman_v1";
    PostTranscriptionConfig transcription = new PostTranscriptionConfig(true, summaryConfig, modelId);
    
    // Start Hls
    //highlight-next-line
    meeting.startHls(config);
  } else {
    // Stop Hls
    //highlight-next-line
    meeting.stopHls();
  }
});
```

</TabItem>

</Tabs>

:::tip
If you want to learn more about the Interactive Livestream and how you can implement it in your own platform, you can checkout this [guide](/android/guide/interactive-live-streaming/integrate-hls/overview).
:::

### Event associated with HLS

- **onHlsStateChanged** - Whenever meeting HLS state changes, then `onHlsStateChanged` event will trigger.

- You can get the `playbackHlsUrl` and `livestreamUrl` of the HLS to play it on the Viewer side when the state changes to `HLS_PLAYABLE`.
  - `playbackHlsUrl` - Live HLS with playback support
  - `livestreamUrl` - Live HLS without playback support

:::note
`downstreamUrl` is now depecated. Use `playbackHlsUrl` or `livestreamUrl` in place of `downstreamUrl`
:::

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
private val meetingEventListener: MeetingEventListener = object : MeetingEventListener() {
  override fun onHlsStateChanged(HlsState: JSONObject) {
    when (HlsState.getString("status")) {
        "HLS_STARTING" -> Log.d("onHlsStateChanged", "Meeting hls is starting")
        "HLS_STARTED" -> Log.d("onHlsStateChanged", "Meeting hls is started")
        "HLS_PLAYABLE" -> {
            Log.d("onHlsStateChanged", "Meeting hls is playable now")
            //highlight-start
             // on hls playable you will receive playbackHlsUrl and livestreamUrl
            val playbackHlsUrl = HlsState.getString("playbackHlsUrl")
            val livestreamUrl = HlsState.getString("livestreamUrl")
            //highlight-end
        }
        "HLS_STOPPING" -> Log.d("onHlsStateChanged", "Meeting hls is stopping")
        "HLS_STOPPED" -> Log.d("onHlsStateChanged", "Meeting hls is stopped")
    }
  }
}

override fun onCreate(savedInstanceState: Bundle?) {
  //...

  // add listener to meeting
  //highlight-next-line
  meeting!!.addEventListener(meetingEventListener)
}
```

</TabItem>

<TabItem value="Java">

```js
private final MeetingEventListener meetingEventListener = new MeetingEventListener() {
  @Override
  public void onHlsStateChanged(JSONObject HlsState) {
      switch (HlsState.getString("status")) {
          case "HLS_STARTING":
              Log.d("onHlsStateChanged", "Meeting hls is starting");
              break;
          case "HLS_STARTED":
              Log.d("onHlsStateChanged", "Meeting hls is started");
              break;
          case "HLS_PLAYABLE":
              Log.d("onHlsStateChanged", "Meeting hls is playable now");
              //highlight-start
              // on hls started you will receive playbackHlsUrl and livestreamUrl
              String playbackHlsUrl = HlsState.getString("playbackHlsUrl");
              String livestreamUrl = HlsState.getString("livestreamUrl");
              //highlight-end
              break;
          case "HLS_STOPPING":
              Log.d("onHlsStateChanged", "Meeting hls is stopping");
              break;
          case "HLS_STOPPED":
              Log.d("onHlsStateChanged", "Meeting hls is stopped");
              break;
      }
  }
}

@Override
protected void onCreate(Bundle savedInstanceState) {
  //...

  // add listener to meeting
  //highlight-next-line
  meeting.addEventListener(meetingEventListener);
}
```

</TabItem>

</Tabs>

### Custom Template

With VideoSDK, you can also use your own custom designed layout template to livestream the meetings. In order to use the custom template, you need to create a template for which you can [follow this guide](/react/guide/interactive-live-streaming/custom-template). Once you have setup the template, you can use the [REST API to start](/api-reference/realtime-communication/start-livestream) the livestream with the `templateURL` parameter.

### API Reference

The API references for all the methods utilised in this guide are provided below.

- [startHls()](/android/api/sdk-reference/meeting-class/methods#starthls)
- [stopHls()](/android/api/sdk-reference/meeting-class/methods#stophls)
- [onHlsStateChanged](/android/api/sdk-reference/meeting-class/meeting-event-listener-class#onhlsstatechanged)
- [autoStartConfig](/api-reference/realtime-communication/create-room#autoStartConfig)


---

---
title: Record Meeting Video & Audio Call - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: Record Meeting features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Record Meeting
pagination_label: Record Meeting
keywords:
  - Start Recording meeting
  - Stop Recording meeting
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: record-meeting
---

# Record Meeting - Android

VideoSDK allows you to record video & audio during the meeting. The recording files are available in developer dashboard or you can also choose to store them in your own cloud storage.

VideoSDK also allows you to configure the recording layouts in numerous ways like by simply setting different prebuilt layouts in the configuration or by providing your own custom template to do the recording according to your layout choice.

This guide will provide an overview of how to implement start and stop Meeting Recording.

:::important

To initiate automatic recording at the beginning of a `session`, simply provide the `autoStartConfig` feature `recording` during `room` creation. For more information on configuring the `autoStartConfig`, please refer to the provided documentation **[<u>here</u>](/api-reference/realtime-communication/create-room#autoStartConfig)**.

:::

### `startRecording()`

`startRecording()` can be used to start a recording of the meeting which can be accessed from the `Meeting` class. This method accepts four parameters:

- `1. webhookUrl`: This would the webhook URL where you would like to listen to event happening for the recording like starting and stopping of recording. It will be triggered when the recording is completed and stored into server. Read more about webhooks [here](https://en.wikipedia.org/wiki/Webhook)

- `2. awsDirPath`: This parameter accepts the path for the your S3 bucket where you want to store recordings to. To allow us to store recording in your S3 bucket, you will need to fill this form by providing the required values. ([VideoSDK Cloud (AWS S3, Azure Blob or GCP ) Integration](/android/guide/video-and-audio-calling-api-sdk/recording/recording-storage-config))

- `3. config`: This parameter will define how the meeting should be recorded.

- `4. transcription`: This parameter lets you start post transcription for the recording.

:::note

If you don't have a value for `webhookUrl`,`awsDirPath` or `config`, you should pass `null` in place of the missing value. If you pass `null` in `awsDirPath` parameter then by default recordings will be store on the VideoSDK's storage.
:::

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
val config = JSONObject()

//highlight-next-line
// Layout Configuration
val layout = JSONObject()
JsonUtils.jsonPut(layout, "type", "GRID") // "SPOTLIGHT" | "SIDEBAR",  Default : "GRID"
JsonUtils.jsonPut(layout, "priority", "SPEAKER") // "PIN", Default : "SPEAKER"
JsonUtils.jsonPut(layout, "gridSize", 4) // MAX : 4
JsonUtils.jsonPut(config, "layout", layout)

//highlight-next-line
// Theme of recording
JsonUtils.jsonPut(config, "theme", "DARK") //  "LIGHT" | "DEFAULT"

//highlight-next-line
// `mode` is used to either record video & audio both or only audio.
JsonUtils.jsonPut(config, "mode", "video-and-audio") // "audio", Default : "video-and-audio"

//highlight-next-line
// Quality of recording and is only applicable to `video-and-audio` type mode.
JsonUtils.jsonPut(config, "quality", "high") // "low" | "med",  Default : "med"

//highlight-start
// This mode refers to orientation of recording.
// landscape : Record the meeting in horizontally
// portrait : Record the meeting in vertically (Best for mobile view)
//highlight-end
JsonUtils.jsonPut(config, "orientation", "portrait") // "landscape",  Default : "landscape"

//highlight-next-line
// Post Transcription Configuration
val prompt = "Write summary in sections like Title, Agenda, Speakers, Action Items, Outlines, Notes and Summary"
val summaryConfig = SummaryConfig(true, prompt)
val modelId = "raman_v1"
val transcription = PostTranscriptionConfig(true, summaryConfig, modelId)

meeting.startRecording(null, null, config, transcription)
```

</TabItem>

<TabItem value="Java">

```js
JSONObject config = new JSONObject();

//highlight-next-line
// Layout Configuration
JSONObject layout = new JSONObject();
JsonUtils.jsonPut(layout, "type", "GRID"); // "SPOTLIGHT" | "SIDEBAR",  Default : "GRID"
JsonUtils.jsonPut(layout, "priority", "SPEAKER");  // "PIN", Default : "SPEAKER"
JsonUtils.jsonPut(layout, "gridSize", 4); // MAX : 4
JsonUtils.jsonPut(config, "layout", layout);

//highlight-next-line
// Theme of recording
JsonUtils.jsonPut(config, "theme", "DARK"); //  "LIGHT" | "DEFAULT"

//highlight-next-line
// `mode` is used to either record video & audio both or only audio.
JsonUtils.jsonPut(config, "mode", "video-and-audio"); // "audio", Default : "video-and-audio"

//highlight-next-line
// Quality of recording and is only applicable to `video-and-audio` type mode.
JsonUtils.jsonPut(config, "quality", "high"); // "low" | "med",  Default : "med"

//highlight-start
// This mode refers to orientation of recording.
// landscape : Record the meeting in horizontally
// portrait : Record the meeting in vertically (Best for mobile view)
//highlight-end
JsonUtils.jsonPut(config, "orientation", "portrait"); // "landscape",  Default : "landscape"

//highlight-next-line
// Post Transcription Configuration
String prompt = "Write summary in sections like Title, Agenda, Speakers, Action Items, Outlines, Notes and Summary";
SummaryConfig summaryConfig = new SummaryConfig(true, prompt);
String modelId = "raman_v1";
PostTranscriptionConfig transcription = new PostTranscriptionConfig(true, summaryConfig, modelId);

meeting.startRecording(null, null, config, transcription);
```

</TabItem>

</Tabs>

### `stopRecording()`

- `stopRecording()` is used to stop the meeting recording which can be accessed from the `Meeting` class.

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
// keep track of recording
val recording = false

findViewById<View>(R.id.btnRecording).setOnClickListener { view: View? ->
    if (!recording) {
      //highlight-start
      val config = JSONObject()
      val layout = JSONObject()
      JsonUtils.jsonPut(layout, "type", "GRID")
      JsonUtils.jsonPut(layout, "priority", "SPEAKER")
      JsonUtils.jsonPut(layout, "gridSize", 4)
      JsonUtils.jsonPut(config, "layout", layout)
      JsonUtils.jsonPut(config, "theme", "DARK")
      JsonUtils.jsonPut(config, "mode", "video-and-audio")
      JsonUtils.jsonPut(config, "quality", "high")
      JsonUtils.jsonPut(config, "orientation", "portrait")
      //highlight-end

      //highlight-next-line
      // Post Transcription Configuration
      val prompt = "Write summary in sections like Title, Agenda, Speakers, Action Items, Outlines, Notes and Summary"
      val summaryConfig = SummaryConfig(true, prompt)
      val modelId = "raman_v1"
      val transcription = PostTranscriptionConfig(true, summaryConfig, modelId)

      // Start Recording
      // If you don't have a `webhookUrl` or `awsDirPath`, you should pass null.
      // If you don't want to enable transcription, you can pass null as parameter.
      //highlight-next-line
      meeting!!.startRecording("YOUR WEB HOOK URL", "AWS Directory Path", config, transcription)
    } else {
      // Stop Recording
      //highlight-next-line
      meeting!!.stopRecording()
    }
}
```

</TabItem>

<TabItem value="Java">

```js
// keep track of recording
boolean recording = false;

findViewById(R.id.btnRecording).setOnClickListener(view -> {
    if (!recording) {
      //highlight-start
      JSONObject config = new JSONObject();
      JSONObject layout = new JSONObject();
      JsonUtils.jsonPut(layout, "type", "GRID");
      JsonUtils.jsonPut(layout, "priority", "SPEAKER");
      JsonUtils.jsonPut(layout, "gridSize", 4);
      JsonUtils.jsonPut(config, "layout", layout);
      JsonUtils.jsonPut(config, "theme", "DARK");
      JsonUtils.jsonPut(config, "mode", "video-and-audio");
      JsonUtils.jsonPut(config, "quality", "high");
      JsonUtils.jsonPut(config, "orientation", "portrait");
      //highlight-end

      //highlight-next-line
      // Post Transcription Configuration
      String prompt = "Write summary in sections like Title, Agenda, Speakers, Action Items, Outlines, Notes and Summary";
      SummaryConfig summaryConfig = new SummaryConfig(true, prompt);
      String modelId = "raman_v1";
      PostTranscriptionConfig transcription = new PostTranscriptionConfig(true, summaryConfig, modelId);

      // Start Recording
      // If you don't have a `webhookUrl` or `awsDirPath`, you should pass null.
      // If you don't want to enable transcription, you can pass null as parameter.
      //highlight-next-line
      meeting.startRecording("YOUR WEB HOOK URL", "AWS Directory Path", config, transcription);
    } else {
      // Stop Recording
      //highlight-next-line
      meeting.stopRecording();
    }
});
```

</TabItem>

</Tabs>

### Event associated with Recording

- **onRecordingStateChanged** - Whenever meeting recording state changes, then `onRecordingStateChanged` event will trigger.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
private val meetingEventListener: MeetingEventListener = object : MeetingEventListener() {
  override fun onRecordingStateChanged(recordingState: String) {
    when (recordingState) {
        "RECORDING_STARTING" -> {
            Log.d("onRecordingStateChanged", "Meeting recording is starting")
        }
        "RECORDING_STARTED" -> {
            Log.d("onRecordingStateChanged", "Meeting recording is started")
        }
        "RECORDING_STOPPING" -> {
            Log.d("onRecordingStateChanged", "Meeting recording is stopping")
        }
        "RECORDING_STOPPED" -> {
            Log.d("onRecordingStateChanged", "Meeting recording is stopped")
        }
    }
  }
}

override fun onCreate(savedInstanceState: Bundle?) {
  //...

  // add listener to meeting
  //highlight-next-line
  meeting!!.addEventListener(meetingEventListener)
}
```

</TabItem>

<TabItem value="Java">

```js
private final MeetingEventListener meetingEventListener = new MeetingEventListener() {
  @Override
  public void onRecordingStateChanged(String recordingState) {
      switch (recordingState) {
          case "RECORDING_STARTING":
              Log.d("onRecordingStateChanged", "Meeting recording is starting");
              break;
          case "RECORDING_STARTED":
              Log.d("onRecordingStateChanged", "Meeting recording is started");
              break;
          case "RECORDING_STOPPING":
              Log.d("onRecordingStateChanged", "Meeting recording is stopping");
              break;
          case "RECORDING_STOPPED":
              Log.d("onRecordingStateChanged", "Meeting recording is stopped");
              break;
      }
  }
}

@Override
protected void onCreate(Bundle savedInstanceState) {
  //...

  // add listener to meeting
  //highlight-next-line
  meeting.addEventListener(meetingEventListener);
}
```

</TabItem>

</Tabs>

### Storage Configuration

While recording your meetings, you can choose to store them on the VideoSDK's storage or you can also configure your own **`AWS S3 Storage, Azure Blob or GCP Cloud Storage`** to store the meeting recordings directly on your storage.

You can configure your own **`AWS S3 Storage, Azure Blob or GCP Cloud Storage`** from the [VideoSDK Dashboard's API section](https://app.videosdk.live/api-keys).

You can also go through this [guide to setup](/docs/tutorials/user-dashboard/recording-storage-config) the storage or watch this [video to configure](https://www.loom.com/share/23a2617f824a4a5da004d14d1a541a9d) your storage.

### Custom Template

With VideoSDK, you can also use your own custom designed layout template to record the meetings. In order to use the custom template, you need to create a template for which you can [follow this guide](/react/guide/interactive-live-streaming/custom-template). Once you have setup the template, you can use the [REST API to start](/api-reference/realtime-communication/start-recording) the recording with the `templateURL` parameter.

### API Reference

The API references for all the methods utilised in this guide are provided below.

- [startRecording()](/android/api/sdk-reference/meeting-class/methods#startrecording)
- [stopRecording()](/android/api/sdk-reference/meeting-class/methods#stoprecording)
- [onRecordingStateChanged](/android/api/sdk-reference/meeting-class/meeting-event-listener-class#onrecordingstatechanged)
- [autoStartConfig](/api-reference/realtime-communication/create-room#autoStartConfig)


---

---
title: RTMP Livestream - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: RTMP Livestream features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: RTMP Livestream
pagination_label: RTMP Livestream
keywords:
  - Start Livestream meeting
  - Stop Livestream meeting
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: rtmp-livestream
---

# RTMP Livestream - Android

RTMP is a popular protocol for live streaming video content from a VideoSDK to platforms such as YouTube, Twitch, Facebook, and others.

By providing the platform-specific stream key and stream URL, the VideoSDK can connect to the platform's RTMP server and transmit the live video stream.

VideoSDK allows you to livestream your meeting to platform which support RTMP ingestion just by providing the platform-specific stream key and stream URL, we can connect to the platform's RTMP server and transmit the live video stream.

VideoSDK also allows you to configure the livestream layouts in numerous ways like by simply setting different prebuilt layouts in the configuration or by providing your own custom template to do the livestream according to your layout choice.

This guide will provide an overview of how to implement start and stop RTMP Livestreaming.

### `startLivestream()`

`startLivestream()` can be used to start a RTMP livestream of the meeting which can be accessed from the `Meeting` class. This method accepts two parameters:

- `1. outputs`: This parameter accepts a list of `LivestreamOutput` objects which contains the RTMP `url` and `streamKey` of the platforms you want to start the livestream.

- `2. config`: This parameter will define how the livestream layout should look like. You can pass `null` for default layout.

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
val config = JSONObject()

//highlight-next-line
// Layout Configuration
val layout = JSONObject()
JsonUtils.jsonPut(layout, "type", "GRID") // "SPOTLIGHT" | "SIDEBAR",  Default : "GRID"
JsonUtils.jsonPut(layout, "priority", "SPEAKER") // "PIN", Default : "SPEAKER"
JsonUtils.jsonPut(layout, "gridSize", 4) // MAX : 4
JsonUtils.jsonPut(config, "layout", layout)

//highlight-next-line
// Theme of livestream layout
JsonUtils.jsonPut(config, "theme", "DARK") //  "LIGHT" | "DEFAULT"

val outputs: MutableList<LivestreamOutput> = ArrayList()
outputs.add(LivestreamOutput(RTMP_URL, RTMP_STREAM_KEY))

meeting!!.startLivestream(outputs,config)
```

</TabItem>

<TabItem value="Java">

```js
JSONObject config = new JSONObject();

//highlight-next-line
// Layout Configuration
JSONObject layout = new JSONObject();
JsonUtils.jsonPut(layout, "type", "GRID"); // "SPOTLIGHT" | "SIDEBAR",  Default : "GRID"
JsonUtils.jsonPut(layout, "priority", "SPEAKER");  // "PIN", Default : "SPEAKER"
JsonUtils.jsonPut(layout, "gridSize", 4); // MAX : 4
JsonUtils.jsonPut(config, "layout", layout);

//highlight-next-line
// Theme of livestream layout
JsonUtils.jsonPut(config, "theme", "DARK"); //  "LIGHT" | "DEFAULT"

List<LivestreamOutput> outputs = new ArrayList<>();
outputs.add(new LivestreamOutput(RTMP_URL, RTMP_STREAM_KEY));

meeting.startLivestream(outputs,config);
```

</TabItem>

</Tabs>

### `stopLivestream()`

- `stopLivestream()` is used to stop the meeting livestream which can be accessed from the `Meeting` class.

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
// keep track of livestream status
val liveStream = false

findViewById<View>(R.id.btnLiveStream).setOnClickListener { view: View? ->
  if (!liveStream) {
    //highlight-start
    val config = JSONObject()
    val layout = JSONObject()
    JsonUtils.jsonPut(layout, "type", "GRID")
    JsonUtils.jsonPut(layout, "priority", "SPEAKER")
    JsonUtils.jsonPut(layout, "gridSize", 4)
    JsonUtils.jsonPut(config, "layout", layout)
    JsonUtils.jsonPut(config, "theme", "DARK")
    //highlight-end

    val outputs: MutableList<LivestreamOutput> = ArrayList()
    //highlight-next-line
    outputs.add(LivestreamOutput(RTMP_URL, RTMP_STREAM_KEY))

    // Start LiveStream
    //highlight-next-line
    meeting!!.startLivestream(outputs,config)
  } else {
    // Stop LiveStream
    //highlight-next-line
    meeting!!.stopLivestream()
  }
}
```

</TabItem>

<TabItem value="Java">

```js
// keep track of livestream status
boolean liveStream = false;

findViewById(R.id.btnLiveStream).setOnClickListener(view -> {
  if (!liveStream) {
    //highlight-start
    JSONObject config = new JSONObject();
    JSONObject layout = new JSONObject();
    JsonUtils.jsonPut(layout, "type", "GRID");
    JsonUtils.jsonPut(layout, "priority", "SPEAKER");
    JsonUtils.jsonPut(layout, "gridSize", 4);
    JsonUtils.jsonPut(config, "layout", layout);
    JsonUtils.jsonPut(config, "theme", "DARK");
    //highlight-end

    List<LivestreamOutput> outputs = new ArrayList<>();
    //highlight-next-line
    outputs.add(new LivestreamOutput(RTMP_URL, RTMP_STREAM_KEY));

    // Start LiveStream
    //highlight-next-line
    meeting.startLivestream(outputs,config);
  } else {
    // Stop LiveStream
    //highlight-next-line
    meeting.stopLivestream();
  }
});
```

</TabItem>

</Tabs>

### Event associated with Livestream

- **onLivestreamStateChanged** - Whenever meeting livestream state changes, then `onLivestreamStateChanged` event will trigger.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
private val meetingEventListener: MeetingEventListener = object : MeetingEventListener() {
  override fun onLivestreamStateChanged(livestreamState: String?) {
    when (livestreamState) {
      "LIVESTREAM_STARTING" -> Log.d( "LivestreamStateChanged",
          "Meeting livestream is starting"
      )
      "LIVESTREAM_STARTED" -> Log.d( "LivestreamStateChanged",
          "Meeting livestream is started"
      )
      "LIVESTREAM_STOPPING" -> Log.d("LivestreamStateChanged",
          "Meeting livestream is stopping"
      )
      "LIVESTREAM_STOPPED" -> Log.d("LivestreamStateChanged",
          "Meeting livestream is stopped"
      )
    }
  }
}

override fun onCreate(savedInstanceState: Bundle?) {
  //...

  // add listener to meeting
  //highlight-next-line
  meeting!!.addEventListener(meetingEventListener)
}
```

</TabItem>

<TabItem value="Java">

```js
private final MeetingEventListener meetingEventListener = new MeetingEventListener() {
  @Override
  public void onLivestreamStateChanged(String livestreamState) {
    switch (livestreamState) {
      case "LIVESTREAM_STARTING":
          Log.d("LivestreamStateChanged", "Meeting livestream is starting");
          break;
      case "LIVESTREAM_STARTED":
          Log.d("LivestreamStateChanged", "Meeting livestream is started");
          break;
      case "LIVESTREAM_STOPPING":
          Log.d("LivestreamStateChanged", "Meeting livestream is stopping");
          break;
      case "LIVESTREAM_STOPPED":
          Log.d("LivestreamStateChanged", "Meeting livestream is stopped");
          break;
    }
  }
}

@Override
protected void onCreate(Bundle savedInstanceState) {
  //...

  // add listener to meeting
  //highlight-next-line
  meeting.addEventListener(meetingEventListener);
}
```

</TabItem>

</Tabs>

### Custom Template

With VideoSDK, you can also use your own custom designed layout template to livestream the meetings. In order to use the custom template, you need to create a template for which you can [follow this guide](/react/guide/interactive-live-streaming/custom-template). Once you have setup the template, you can use the [REST API to start](/api-reference/realtime-communication/start-livestream) the livestream with the `templateURL` parameter.

### API Reference

The API references for all the methods utilised in this guide are provided below.

- [startLivestream()](/android/api/sdk-reference/meeting-class/methods#startlivestream)
- [stopLivestream()](/android/api/sdk-reference/meeting-class/methods#stoplivestream)
- [onLivestreamStateChanged](/android/api/sdk-reference/meeting-class/meeting-event-listener-class#onlivestreamstatechanged)


---

---
sidebar_label: Release Notes
pagination_label: Release Notes
---

# Release Notes - Android

## v0.4.0

**Release Date** : 17th May 2025

**Change Log** :

- Introduced two new features to enhance the Interactive Livestream (ILS) experience:

1. **Fast Channel Switching** – New Fast Channel Switching feature enables instant transitions between live streams with minimal latency.

2. **Media Relay Support** – Introducing Relay Media, enabling hosts to share their media (audio, video, screen) with other live streams. Perfect for creating engaging "PK battles" and collaborative broadcasts.

**Docs**: [Fast Channel Switching](../interactive-live-streaming/fast-channel-switching.md)

**Docs**: [Media Relay](../interactive-live-streaming/relay-media.md)


## v0.3.1

**Release Date** : 30th April 2025

**Bug Fixed** : 

- Fixed issue where audio and video were not automatically enabled after reconnection.

## v0.3.0

**Release Date**: 1st April 2025

### Change Log:

- **New Getter in `Meeting` Class**:

  - `getConnectionState()`: Retrieves the current state of the meeting connection.

  **Docs**: [Meeting Class - properties](../../api/sdk-reference/meeting-class/properties.md)

- **New Methods in `Meeting` Class**:
  - `pauseAllStreams()`: Pauses all media streams (audio, video, and screen share) or a specific stream type if provided.
  - `resumeAllStreams()`: Resumes all paused media streams (audio, video, and screen share) or a specific stream type if provided.

  **Docs**: [Meeting Class - Methods](../../api/sdk-reference/meeting-class/methods.md)

- **New/Updated Event Listeners in `MeetingEventListener`**:
  - `onExternalCallRinging`: Triggered when an external call is ringing.
  - `onExternalCallStarted`: Triggered when an external call is answered.
  - `onExternalCallHangup`: Triggered when an external call ends.
  - `onMeetingStateChanged`: Triggered when there is a change in the state of the meeting.
  - `onPausedAllStreams`: Triggered when media streams is paused.
  - `onResumedAllStreams`: Triggered when media streams is resumed.

  **Docs**: [MeetingEventListener - Events](../../api/sdk-reference/meeting-class/meeting-event-listener-class.md)

- **Enhanced Meeting Connection Flow**:
  - Introduced a RECONNECTING state that activates if the network connection is lost during a meeting. The SDK will automatically attempt to rejoin, improving reliability.

  - Removed the FAILED, CLOSING, and CLOSED states. All disconnection scenarios are now handled under the DISCONNECTED state for a more streamlined experience.

---

## v0.2.0

**Release Date** : 22nd Jan 2025

Change Log :

- **Deprecated Modes:** Replaced `CONFERENCE` with `SEND_AND_RECV` and `VIEWER` with `SIGNALLING_ONLY`.
- **New Mode:** Added `RECV_ONLY` for live streaming, allowing participants to receive media only.
- **Role Switching:** Enabled seamless role switching between `SEND_AND_RECV` (host) and `RECV_ONLY` (audience) using `changeMode()` of Meeting Class.

**Docs:** [Quick Start for Interactive Live Streaming](./quick-start-android-ils)

---


## v0.2.0 & v0.3.0

**Release Date** : 29th June 2022

**Change log** :

1. Updated internal dependency.


---

---
title: Render Participant | Video SDK
hide_title: true
hide_table_of_contents: false
description: Video SDK and Audio SDK, developers need to implement a token server. This requires efforts on both the front-end and backend.
sidebar_label: Render Participant
pagination_label: Render Participant
keywords:
  - audio calling
  - video calling
  - real-time communication
  - collaboration
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: render-participant
---

# Render Participant - Android

In this guide, we will take a look at how to render the participant's video on the screen.

:::info

- Here the participant's video is displayed using `VideoView`, but you may also use `SurfaceViewRender` for the same.
- For `VideoView`, SDK version should be `0.1.13` or higher.
- To know more about `VideoView`, please visit [here](./understand-videoView-component)

:::

## Steps to render panticipant

**`Step 1:`** Create a new layout for the participant view named `item_participant.xml` in the `res/layout` folder.

```xml title="item_participant.xml"
<?xml version="1.0" encoding="utf-8"?>
<FrameLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="200dp"
    android:background="#616161"
    tools:layout_height="200dp">

    <ImageView
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_gravity="center"
        android:background="#99000000"
        android:contentDescription="webcam_turned_off"
        android:gravity="center"
        android:padding="4dp"
        android:src="@drawable/ic_outline_videocam_off_24"
        app:tint="@color/white" />

    <live.videosdk.rtc.android.VideoView
        android:id="@+id/participantView"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:visibility="gone" />

    <LinearLayout
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:layout_gravity="bottom"
        android:background="#99000000"
        android:orientation="horizontal">

        <TextView
            android:id="@+id/tvName"
            android:layout_width="0dp"
            android:layout_height="wrap_content"
            android:layout_weight="1"
            android:gravity="center"
            android:padding="4dp"
            android:textColor="@color/white" />

    </LinearLayout>
</FrameLayout>
```

**`Step 2:`** Now, Create a recycler view adapter named `ParticipantAdapter` which will show the participant list. Create `PeerViewHolder` in the adapter which will extend `RecyclerView.ViewHolder`

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js title="ParticipantAdapter.kt"
class ParticipantAdapter(meeting: Meeting) : RecyclerView.Adapter<ParticipantAdapter.PeerViewHolder>() {

  override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): PeerViewHolder {
      //highlight-start
      return PeerViewHolder(
        LayoutInflater.from(parent.context)
          .inflate(R.layout.item_participant, parent, false)
        )
      //highlight-end
  }

  override fun onBindViewHolder(holder: PeerViewHolder, position: Int) {
  }

  override fun getItemCount(): Int {
    return 0
  }

  class PeerViewHolder(view: View) : RecyclerView.ViewHolder(view) {
    // 'VideoView' to show Video Stream
    //highlight-next-line
    var participantView: VideoView = view.findViewById(R.id.participantView)
    var tvName: TextView = view.findViewById(R.id.tvName)
  }
}
```

</TabItem>

<TabItem value="Java">

```java title="ParticipantAdapter.java"
public class ParticipantAdapter extends RecyclerView.Adapter<ParticipantAdapter.PeerViewHolder> {

  @NonNull
  @Override
  public PeerViewHolder onCreateViewHolder(@NonNull ViewGroup parent, int viewType) {
    //highlight-next-line
    return new PeerViewHolder(LayoutInflater.from(parent.getContext()).inflate(R.layout.item_participant, parent, false));
  }

  @Override
  public void onBindViewHolder(@NonNull PeerViewHolder holder, int position) {

  }

  @Override
  public int getItemCount() {
      return 0;
  }

  static class PeerViewHolder extends RecyclerView.ViewHolder {
    // 'VideoView' to show Video Stream
    //highlight-next-line
    public VideoView participantView;
    public TextView tvName;
    public View itemView;

    PeerViewHolder(@NonNull View view) {
      super(view);
      itemView = view;
      tvName = view.findViewById(R.id.tvName);
      participantView = view.findViewById(R.id.participantView);
    }
  }
}
```

</TabItem>

</Tabs>

**`Step 3:`** Next, we will render a list of `Participant` for the meeting.
We will initialize this list in the constructor of the `ParticipantAdapter`

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js title="ParticipantAdapter.kt"
class ParticipantAdapter(meeting: Meeting) :
    RecyclerView.Adapter<ParticipantAdapter.PeerViewHolder>() {

  //highlight-next-line
  // creating a empty list which will store all participants
  private val participants: MutableList<Participant> = ArrayList()

  init {
    //highlight-next-line
    // adding the local participant(You) to the list
    participants.add(meeting.localParticipant)

    //highlight-next-line
    // adding Meeting Event listener to get the participant join/leave event in the meeting.
    meeting.addEventListener(object : MeetingEventListener() {
      override fun onParticipantJoined(participant: Participant) {
        // add participant to the list
        participants.add(participant)
        notifyItemInserted(participants.size - 1)
      }

      override fun onParticipantLeft(participant: Participant) {
        var pos = -1
        for (i in participants.indices) {
          if (participants[i].id == participant.id) {
            pos = i
            break
          }
        }
        // remove participant from the list
        participants.remove(participant)
        if (pos >= 0) {
          notifyItemRemoved(pos)
        }
      }
    })
  }

  // replace getItemCount() method with following.
  // this method returns the size of total number of participants
  override fun getItemCount(): Int {
    //highlight-next-line
    return participants.size
  }
  //...
}
```

</TabItem>

<TabItem value="Java">

```java title="ParticipantAdapter.java"
public class ParticipantAdapter extends RecyclerView.Adapter<ParticipantAdapter.PeerViewHolder> {

  //highlight-next-line
  // creating a empty list which will store all participants
  private final List<Participant> participants = new ArrayList<>();

  public ParticipantAdapter(Meeting meeting) {
    //highlight-next-line
    // adding the local participant(You) to the list
    participants.add(meeting.getLocalParticipant());

    //highlight-next-line
    // adding Meeting Event listener to get the participant join/leave event in the meeting.
    meeting.addEventListener(new MeetingEventListener() {
      @Override
      public void onParticipantJoined(Participant participant) {
        // add participant to the list
        participants.add(participant);
        notifyItemInserted(participants.size() - 1);
      }

      @Override
      public void onParticipantLeft(Participant participant) {
        int pos = -1;
        for (int i = 0; i < participants.size(); i++) {
          if (participants.get(i).getId().equals(participant.getId())) {
            pos = i;
            break;
          }
        }
        // remove participant from the list
        participants.remove(participant);

        if (pos >= 0) {
          notifyItemRemoved(pos);
        }
      }
    });
  }

  // replace getItemCount() method with following.
  // this method returns the size of total number of participants
  @Override
  public int getItemCount() {
    //highlight-next-line
    return participants.size();
  }
  //...
}
```

</TabItem>

</Tabs>

**`Step 4:`** Now, We have listed our participants. Let's set up the view holder to display a participant video.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js title="PartipantAdapter.kt"
class ParticipantAdapter(meeting: Meeting) :
    RecyclerView.Adapter<ParticipantAdapter.PeerViewHolder>() {

  //highlight-next-line
  // replace onBindViewHolder() method with following.
  override fun onBindViewHolder(holder: PeerViewHolder, position: Int) {
    val participant = participants[position]

    holder.tvName.text = participant.displayName

    //highlight-next-line
    // adding the initial video stream for the participant into the 'VideoView'
    for ((_, stream) in participant.streams) {
      if (stream.kind.equals("video", ignoreCase = true)) {
        holder.participantView.visibility = View.VISIBLE
        val videoTrack = stream.track as VideoTrack
        //highlight-next-line
        holder.participantView.addTrack(videoTrack)
        break
      }
    }

    //highlight-next-line
    // add Listener to the participant which will update start or stop the video stream of that participant
    participant.addEventListener(object : ParticipantEventListener() {
      override fun onStreamEnabled(stream: Stream) {
        if (stream.kind.equals("video", ignoreCase = true)) {
          holder.participantView.visibility = View.VISIBLE
          val videoTrack = stream.track as VideoTrack
          //highlight-next-line
          holder.participantView.addTrack(videoTrack)
       }
      }

      override fun onStreamDisabled(stream: Stream) {
        if (stream.kind.equals("video", ignoreCase = true)) {
          //highlight-next-line
          holder.participantView.removeTrack()
          holder.participantView.visibility = View.GONE
        }
      }
    })
  }
}
```

</TabItem>

<TabItem value="Java">

```java title="PartipantAdapter.java"
public class ParticipantAdapter extends RecyclerView.Adapter<ParticipantAdapter.PeerViewHolder> {

  //highlight-next-line
  // replace onBindViewHolder() method with following.
  @Override
  public void onBindViewHolder(@NonNull PeerViewHolder holder, int position) {
    Participant participant = participants.get(position);

    holder.tvName.setText(participant.getDisplayName());

    //highlight-next-line
    // adding the initial video stream for the participant into the 'VideoView'
    for (Map.Entry<String, Stream> entry : participant.getStreams().entrySet()) {
      Stream stream = entry.getValue();
      if (stream.getKind().equalsIgnoreCase("video")) {
        holder.participantView.setVisibility(View.VISIBLE);
        VideoTrack videoTrack = (VideoTrack) stream.getTrack();
        //highlight-next-line
        holder.participantView.addTrack(videoTrack)
        break;
      }
    }

    //highlight-next-line
    // add Listener to the participant which will update start or stop the video stream of that participant
    participant.addEventListener(new ParticipantEventListener() {
      @Override
      public void onStreamEnabled(Stream stream) {
        if (stream.getKind().equalsIgnoreCase("video")) {
          holder.participantView.setVisibility(View.VISIBLE);
          VideoTrack videoTrack = (VideoTrack) stream.getTrack();
          //highlight-next-line
          holder.participantView.addTrack(videoTrack)
        }
      }

      @Override
      public void onStreamDisabled(Stream stream) {
        if (stream.getKind().equalsIgnoreCase("video")) {
          //highlight-next-line
          holder.participantView.removeTrack();
          holder.participantView.setVisibility(View.GONE);
        }
      }
    });
  }
}
```

</TabItem>

</Tabs>

**`Step 5:`** Final step is to add this adapter to the `MeetingActivity`

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js title="MeetingActivity.kt"
override fun onCreate(savedInstanceState: Bundle?) {
  //Meeting Setup...
  //...
  val rvParticipants = findViewById<RecyclerView>(R.id.rvParticipants)
  rvParticipants.layoutManager = GridLayoutManager(this, 2)
  //highlight-next-line
  rvParticipants.adapter = ParticipantAdapter(meeting!!)
}
```

</TabItem>

<TabItem value="Java">

```java title="MeetingActivity.java"
@Override
protected void onCreate(Bundle savedInstanceState) {
  //Meeting Setup...
  //...
  final RecyclerView rvParticipants = findViewById(R.id.rvParticipants);
  rvParticipants.setLayoutManager(new GridLayoutManager(this, 2));
  //highlight-next-line
  rvParticipants.setAdapter(new ParticipantAdapter(meeting));
}
```

</TabItem>

</Tabs>

<center>

<img style={{height: '450px'}} src="https://cdn.videosdk.live/website-resources/docs-resources/android_display_video.jpeg" />

</center>

## Mirror Local Video View

If you wish to show the mirror view of the local participant, you can set `setMirror` property to `true` of `VideoView` class.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js title="PartipantAdapter.kt"
class ParticipantAdapter(meeting: Meeting) :
    RecyclerView.Adapter<ParticipantAdapter.PeerViewHolder>() {

  override fun onBindViewHolder(holder: PeerViewHolder, position: Int) {
    //...
    holder.tvName.text = participant.displayName
    //highlight-next-line
    holder.participantView.setMirror(true)
    //...
  }
}
```

</TabItem>

<TabItem value="Java">

```java title="PartipantAdapter.java"
public class ParticipantAdapter extends RecyclerView.Adapter<ParticipantAdapter.PeerViewHolder> {

  @Override
  public void onBindViewHolder(@NonNull PeerViewHolder holder, int position) {
    //...
    holder.tvName.setText(participant.getDisplayName());
    //highlight-next-line
    holder.participantView.setMirror(true);
    //...
  };
}
```

</TabItem>

</Tabs>

##### Sample of mirror view video

![mirror view](/img/mirror-view.jpg)

## API Reference

The API references for all the methods and events utilised in this guide are provided below.

- [Participant](/android/api/sdk-reference/participant-class/introduction)
- [VideoView](./understand-videoView-component)


---

---
title: VideoView Video & Audio Call - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: VideoView component quick integrate in Android with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Understand VideoView Componenet
pagination_label: Understand VideoView Componenet
keywords:
  - SurfaceViewRender
  - VideoView
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: understand-videoView-component
---

# What is SurfaceViewRender ?

`SurfaceViewRender` is a very powerful component of `WebRTC` since it is used to display the video stream on a SurfaceView. You can use `SurfaceViewRender` to show video of participant in your screen.

Here's the lifecycle of a SurfaceViewRenderer:

<div style={{textAlign: 'center'}}>

<img style={{height: '200px'}} src="/img/android/VideoView/life-cycle.png" />

</div>

Which means:

1. The SurfaceViewRenderer must be first initialised after being created and before it can be use at all. It starts a render thread.

2. `addSink()` needs to be called when you are having VideoTrack to render. addSink is method of `VideoTrack` that you want to add to it. You have to pass `surfaceViewRender` as parameter.

3. `removeSink()` should only be called when you're done showing the video. Another method of `VideoTrack`, and it takes the `surfaceViewRenderer` as a parameter.

4. Release at last to allow the render thread to terminate. This function should be called before the activity is destroyed and/or before init it again.

#### Mistakes you might make and stuck :

###### 1. Not initialised surfaceViewRender

The video never appears since a render thread was never start and you will see black view.

###### 2. Init it again before releasing it.

If you are not releasing surfaceViewRender before calling `init()` again, you will get this error.

```js
java.lang.IllegalStateException: svrParticipant Already initialized
        at org.webrtc.EglRenderer.init(EglRenderer.java:212)
```

###### 3. Two videos render on same SurfaceViewRender

If you called `addSink()` on the same `SurfaceViewRenderer` for two different tracks and did not call `removeSink` before that, then you will see two different videos on same SurfaceViewRenderer with flickers which would look like this :

import ReactPlayer from 'react-player'

<div style={{textAlign: 'center'}}>

<ReactPlayer controls url="/img/android/VideoView/android-flicker.mp4" height="500px" width={"100%"} />

</div>

<br/>

Too complicated right? However, VideoSDK makes it simple for you. You can use `VideoView` instead of `SurfaceViewRenderer`.

:::info

- If you want to use `VideoView`, please update SDK version to `0.1.13` or higher.

:::

### VideoView

`VideoView` provides a better abstraction to render live video and handles edge cases like managing init state, render more than one videos on same surfaceViewRender.

### Methods

1. **addTrack(VideoTrack videoTrack)** - `addTrack` will initialised SurfaceViewRender for you and render videoTrack that you provided.

2. **removeTrack()** - `removeTrack` should only be called when you're done showing the video.

3. **releaseSurfaceViewRenderer()** - `releaseSurfaceViewRenderer` should be called before the activity is destroyed.

#### How to use VideoView ?

##### Layout

```js
// <org.webrtc.SurfaceViewRenderer
//        android:id="@+id/svrParticipant"
//        android:layout_width="match_parent"
//        android:layout_height="match_parent" />

<live.videosdk.rtc.android.VideoView
  android:id="@+id/participantView"
  android:layout_width="match_parent"
  android:layout_height="match_parent"
/>
```

##### Initalising and adding video track

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
// svrParticipant.init(PeerConnectionUtils.getEglContext(), null)
// var track = stream.getTrack() as VideoTrack
// track!!.addSink(svrParticipant)

val track = stream.track as VideoTrack
participantView!!.addTrack(track);
```

</TabItem>

<TabItem value="Java">

```js
// svrParticipant.init(PeerConnectionUtils.getEglContext(), null);
// VideoTrack track = (VideoTrack) stream.getTrack();
// track.addSink(svrParticipant);

VideoTrack track = (VideoTrack) stream.getTrack();
participantView.addTrack(track);
```

</TabItem>

</Tabs>

##### removeTrack

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
// var track = stream.track as VideoTrack
// track!!.removeSink(svrParticipant);

participantView.removeTrack();
```

</TabItem>

<TabItem value="Java">

```js
// VideoTrack track = (VideoTrack) stream.getTrack();
// if (track != null) track.removeSink(svrParticipant);

participantView.removeTrack();
```

</TabItem>

</Tabs>

#### release

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
override fun onDestroy() {
        participantView.releaseSurfaceViewRenderer()
        super.onDestroy()
}
```

</TabItem>

<TabItem value="Java">

```js
@Override
protected void onDestroy() {
    participantView.releaseSurfaceViewRenderer();
    super.onDestroy();
}
```

</TabItem>

</Tabs>


---

---
title: Layout and Grid Management | Video SDK
hide_title: true
hide_table_of_contents: false
description: Video SDK and Audio SDK, developers need to implement a token server. This requires efforts on both the front-end and backend.
sidebar_label: Layout and Grid Management
pagination_label: Layout and Grid Management
keywords:
  - audio calling
  - video calling
  - pause/resume video stream
  - real-time communication
  - collaboration
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: layout-and-grid-management
---

# Layout and Grid Management - Android

In this guide, we will take a look at how to efficiently manage the participants in different types of layout.

## Grid Layout

The most usual way to showing participants within a grid. There are multiple things you should keep in mind when showing participants in the grid.

This includes the number of participants being shown on the screens, number of participants in the background(in the meeting but not on the grid), quality which is being consumed for each and every participant in the grid.

### Quality of Participant's Video

When there are large number of participants present on the screen, it is best to consume them in lower resolutions. For this we recommend you to call the `setQuality` method on the participants present in the grid with dynamic values based on the number of participants on the screen.

Here is the recommended video quality:

1. Participants less than 3: `setQuality("high")`
2. Participants between 3 to 4: `setQuality("med")`
3. Participants greater than 4: `setQuality("low")`

<center>
<img src='https://cdn.videosdk.live/website-resources/docs-resources/grid_quality_mobile.png' />
</center>

### Grid with Screen Share

When you are rendering a small grid along with the screen share of the presenter or you are showing a simple sidebar video of the participants while the screenshare is on, it is recommended to do `setQuality("low")` for the participants who are present in the sidebar.

## Grid with Pagination

If you are having large video calls where there are multiple speakers with video turned on, it is best to implement a pagination type setup where only a few (4-6) participants are shown on the grid and rest can be seen by changing the page.

To best utilize the resourses, you should pause the streams of the participants who are not present in the grid and resume them when the come in to the grid. You can [follow this guide](#pauseresume-stream) to pause/resume the stream.

<center>
<img src='https://cdn.videosdk.live/website-resources/docs-resources/grid_pagination.png' />
</center>

:::note
You can get the sample code for grid with pagination [here](https://github.com/videosdk-live/videosdk-rtc-android-kotlin-sdk-example/tree/main/app/src/main/java/live/videosdk/rtc/android/kotlin/GroupCall).
:::

## Pause/Resume Stream

Whenver you wish to stop/resume download stream(webcam, screenShare and mic) of participant, you can simply do it by using `pause`, `resume` methods.

### Pause stream

- `pause()` method is used for pause stream(webcam, screenShare and mic) of a particular participant.

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
for ((_, stream) in participant.streams) {
  //highlight-next-line
  stream.pause()
}
```

</TabItem>

<TabItem value="Java">

```js
for (Map.Entry<String, Stream> entry : participant.getStreams().entrySet()) {
  Stream stream = entry.getValue();
  //highlight-next-line
  stream.pause();
}
```

</TabItem>

</Tabs>

### Resume stream

- `resume()` method is used to resume stream(webcam, screenShare and mic) of a particular participant.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
for ((_, stream) in participant.streams) {
  //highlight-next-line
  stream.resume()
}
```

</TabItem>

<TabItem value="Java">

```js
for (Map.Entry<String, Stream> entry : participant.getStreams().entrySet()) {
  Stream stream = entry.getValue();
  //highlight-next-line
  stream.resume();
}
```

</TabItem>

</Tabs>

## API Reference

The API references for all the methods and events utilised in this guide are provided below.

- [setQuality](/android/api/sdk-reference/participant-class/methods#setquality)


---

---
title: Optimize Audio Track | VideoSDK Docs
hide_title: false
hide_table_of_contents: false
description: Optimize Audio Tracks features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Optimize Audio Track
pagination_label: Optimize Audio Track
keywords:
  - Mic on
  - Mic off
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
---

# Optimize Audio Track - Android

While optimizing for the best listening experience, it is necessary to fine-tune the audio track that is being used during the calls.

For the best fine-tuning experience, we have introduced the ability to pass a custom audio track for the participant's media before and during the meeting.

## Custom Audio Track

This feature can be used to create a custom Audio track for the Audio of the participants with different encoder configuration and send it to other participants.

### `How to Create Custom Audio Track ?`

- You can create a Audio Track using `createAudioTrack()` method of `VideoSDK`.

- This method can be used to create audio track using different encoding parameters.

#### Example

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
val audioCustomTrack: CustomStreamTrack = VideoSDK.createAudioTrack("speech_standard",this)
// `high_quality` | `music_standard`,  Default : `speech_standard`
```

</TabItem>

<TabItem value="Java">

```js
CustomStreamTrack audioCustomTrack=VideoSDK.createAudioTrack("speech_standard", this);
// `high_quality` | `music_standard`,  Default : `speech_standard`
```

</TabItem>

</Tabs>

- `speech_standard` : This config is optimised for normal voice communication.

- `high_quality` : This config is used for getting RAW audio, where you can apply your `noiseConfig`.

- `music_standard` : This config is optimised for communication, where sharing of musical notes such as songs or instrumental sounds, is important.

### `How to Setup Custom Audio Track ?`

The custom track can be set up both before and after the initialization of the meeting.

1. [Setting up a Custom Track during the initialization of a meeting](/android/guide/video-and-audio-calling-api-sdk/render-media/optimize-audio-track#1-setting-up-a-custom-track-during-the-initialization-of-a-meeting)
2. [Setting up a Custom Track with methods](/android/guide/video-and-audio-calling-api-sdk/render-media/optimize-audio-track#2-setting-up-a-custom-track-with-methods)

##### 1. Setting up a Custom Track during the initialization of a meeting

If you are passing `micEnabled: true` in the `initMeeting` of `VideoSDK` and want to use custom tracks from start of the meeting, you can pass custom track in the `initMeeting` as shown below.

:::caution
Custom Track will not apply on `micEnabled: false` configuration.
:::

##### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
override fun onCreate(savedInstanceState: Bundle?) {
  //..

  val customTracks: MutableMap<String, CustomStreamTrack> = HashMap()

  //highlight-start
  val audioCustomTrack: CustomStreamTrack = VideoSDK.createAudioTrack("high_quality", this)
  customTracks["mic"] = audioCustomTrack  //Key must be "mic"
  //highlight-end

  // create a new meeting instance
  val meeting = VideoSDK.initMeeting(
    this@MainActivity,meetingId,participantName,
    //MicEnabled , If true, it will use the passed custom track to turn mic on
    true,
    //WebcamEnabled
    true,
    //ParticipantId
    null,
    //Mode
    null,
    //MultiStream
    false,
    //Pass the custom tracks here
    //highlight-next-line
    customTracks,
    //MetaData
    null
  )
}
```

</TabItem>

<TabItem value="Java">

```js
@Override
protected void onCreate(Bundle savedInstanceState) {
  //..

  Map<String, CustomStreamTrack> customTracks = new HashMap<>();

  //highlight-start
  CustomStreamTrack audioCustomTrack = VideoSDK.createAudioTrack("high_quality", this);
  customTracks.put("mic", audioCustomTrack);  //Key must be "mic"
  //highlight-end

  // create a new meeting instance
  Meeting meeting = VideoSDK.initMeeting(
      MainActivity.this, meetingId, participantName,
      //MicEnabled , If true, it will use the passed custom track to turn mic on
      true,
      //WebcamEnabled
      true,
      //ParticipantId
      null,
      //Mode
      null,
      //MultiStream
      false,
      //Pass the custom tracks here
      //highlight-next-line
      customTracks,
      //MetaData
      null
  );
}
```

</TabItem>

</Tabs>

#### 2. Setting up a Custom Track with methods

In order to switch tracks during the meeting, you have to pass the `CustomStreamTrack` in the `unmuteMic()` method of `Meeting`.

You can also pass custom track in `changeMic()` method of `Meeting`.

:::tip
Make sure to call `muteMic()` before you create a new track as it may lead to unexpected behavior.
:::

##### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
try {
  val audioCustomTrack: CustomStreamTrack = VideoSDK.createAudioTrack("high_quality", this)
  meeting!!.unmuteMic(audioCustomTrack)

  //or
  meeting!!.changeMic(AppRTCAudioManager.AudioDevice.BLUETOOTH, audioCustomTrack)
} catch (e: JSONException) {
  e.printStackTrace()
}
```

</TabItem>

<TabItem value="Java">

```js
try {
  CustomStreamTrack audioCustomTrack = VideoSDK.createAudioTrack("high_quality", this);
  meeting.unmuteMic(audioCustomTrack);

  //or
  meeting.changeMic(AppRTCAudioManager.AudioDevice.BLUETOOTH,audioCustomTrack);
}catch (JSONException e) {
  e.printStackTrace();
}
```

</TabItem>

</Tabs>

## API Reference

The API references for all the methods and events utilised in this guide are provided below.

- [Custom Audio Track](/android/api/sdk-reference/custom-tracks#custom-audio-track---android)


---

---
title: Optimize Video Tracks | VideoSDK Docs
hide_title: false
hide_table_of_contents: false
description: Optimize Video Tracks features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Optimize Video Tracks
pagination_label: Optimize Video Tracks
keywords:
  - Camera on
  - Camera off
  - Webcam on
  - Webcam off
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
---

# Optimize Video Tracks - Android

While optimizing for the best viewing experience, it is necessary to fine-tune the video tracks that are being used during the calls.

For the best fine-tuning experience, we have introduced the ability to pass a custom video track for the participant's media before and during the meeting.

1. [Custom Video Track](#custom-video-track)
2. [Custom Screen Share Track](#custom-screen-share-track)

## Custom Video Track

This feature can be used to add custom video encoder configurations, optimization mode (whether you want to focus on **motion**, **text** or **detail** of the video) and background removal & video filter from external SDK(e.g., [Banuba](https://www.banuba.com/))and send it to other participants.

### `How to Create a Custom Video Track ?`

- You can create a Video Track using `createCameraVideoTrack()` method of `VideoSDK`.
- This method can be used to create video track using different encoding parameters, camera facing mode, and optimization mode and return `CustomStreamTrack`.

#### Example

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
val videoCustomTrack: CustomStreamTrack = VideoSDK.createCameraVideoTrack(

  // highlight-next-line
  // This will accept the resolution (height x width) of video you want to capture.
  "h720p_w960p", // "h720p_w960p" | "h720p_w1280p" ... // Default : "h480p_w720p"

  // highlight-next-line
  // It will specify whether to use front or back camera for the video track.
  "front", "back",  Default : "front"

  // highlight-next-line
  // We will discuss this parameter in next step.
  CustomStreamTrack.VideoMode.MOTION, // CustomStreamTrack.VideoMode.TEXT, CustomStreamTrack.VideoMode.DETAIL ,  Default : CustomStreamTrack.VideoMode.MOTION

  // highlight-next-line
  // multiStream - we will discuss this parameter in next step.
  false, // true

  // highlight-next-line
  // Pass Context
  this,

  // highlight-next-line
  // This is Optional parameter. We will discuss this parameter in next step.
  observer)
```

</TabItem>

<TabItem value="Java">

```javascript
CustomStreamTrack customStreamTrack = VideoSDK.createCameraVideoTrack(

  // highlight-next-line
  // This will accept the resolution (height x width) of video you want to capture.
  "h480p_w640p", // "h720p_w960p" | "h720p_w1280p" ... // Default : "h480p_w640p"

  // highlight-next-line
  // It will specify whether to use front or back camera for the video track.
  "front", // "back,  Default : "front""

  // highlight-next-line
  // We will discuss this parameter in next step.
  CustomStreamTrack.VideoMode.MOTION, // CustomStreamTrack.VideoMode.TEXT, CustomStreamTrack.VideoMode.DETAIL ,  Default : CustomStreamTrack.VideoMode.MOTION

  // highlight-next-line
  // multiStream - we will discuss this parameter in next step.
  false, // true

  // highlight-next-line
  // Pass Context
  this

  // highlight-next-line
  // This is Optional parameter. We will discuss this parameter in next step.
  observer);
```

</TabItem>

</Tabs>

:::caution
The capabilities of the device have a significant impact on how custom track configurations behave. Assuming a case where you set encoder configuration to 1080p but the camera only supports 720p, then encoder configuration will automatically switch to the highest resolution that the device can handle, which is 720p.
:::

##### What is `optimizationMode`?

- It will specify the optimization mode for the video track being generated.

- `motion` : This type of track should more focus on motion video. For example, webcam video, movies or video games.

  - This type of track will degrade `resolution` in order to maintain `frame rate`.

- `text` : This type of track should more focus on significant sharp edges and areas of consistent color that can change frequently. For example, presentations or web pages with text content.

  - This type of track will degrade `frame rate` in order to maintain `resolution`.

- `detail` : This type of track should more focus on details of the video. For example, presentations, painting or line art.

  - This type of track will degrade `frame rate` in order to maintain `resolution`.

##### What is `multiStream`?

- It will specify if the stream should send multiple resolution layers or single resolution layer.

**`multiStream : true`** By default, VideoSDK sends multiple resolution video streams to the server (whether you are using custom video track or not), For instance, user device capabilty is 720p, so VideoSDK sends 720p along with 640p and 480p streams. This allows VideoSDK to deliver the appropriate stream to each participant based on their network bandwidth.

<center>

![Multi Stream False](/img/multistream_true.png)

</center>

**`multiStream : false`** If you want to restrict the VideoSDK to send only one stream to maintain quality, you can set `multiStream` to `false`.

<center>

![Multi Stream False](/img/multistream_false.png)

</center>

:::danger
`setQuality` would not have any effect if multiStream is set to `false`.
:::

##### What is `observer`?

- If you want to use video filter from external SDK(e.g., [Banuba](https://www.banuba.com/)) then pass instance of `CapturerObserver` in this parameter.

:::note

For Banuba integraion with VideoSDK, please visit [Banuba Intergation with VideoSDK](../video-processor/banuba-integration.md)

:::

### `How to Setup a Custom Video Track ?`

The custom track can be set up both before and after the initialization of the meeting.

1. [Setting up a Custom Track during the initialization of a meeting](/android/guide/video-and-audio-calling-api-sdk/render-media/optimize-video-track#1-setting-up-a-custom-track-during-the-initialization-of-a-meeting)
2. [Setting up a Custom Track with methods](/android/guide/video-and-audio-calling-api-sdk/render-media/optimize-video-track#2-setting-up-a-custom-track-with-methods)

##### 1. Setting up a Custom Track during the initialization of a meeting

If you are passing `webcamEnabled: true` in the `initMeeting` of `VideoSDK` and want to use custom tracks from start of the meeting, you can pass custom track in the `initMeeting` as shown below.

:::caution
Custom Track will not apply on `webcamEnabled: false` configuration.
:::

##### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
override fun onCreate(savedInstanceState: Bundle?) {
  //..

  //highlight-start
  val customTracks: MutableMap<String, CustomStreamTrack> = HashMap()
  val videoCustomTrack: CustomStreamTrack =
  VideoSDK.createCameraVideoTrack("h720p_w960p", "front", CustomStreamTrack.VideoMode.MOTION, false, this)
  customTracks["video"] = videoCustomTrack  //Key must be "video"
  //highlight-end

  // create a new meeting instance
  val meeting = VideoSDK.initMeeting(
    this@MainActivity, meetingId, participantName,
    //MicEnabled
    true,
    //WebcamEnabled , If true, it will use the passed custom track to turn webcam on
    true,
    // ParticipantId
    null,
    // Mode
    null,
    // MultiStream
    false,
    //Pass the custom tracks here
    //highlight-next-line
    customTracks,
    //MetaData
    null
  )
}
```

</TabItem>

<TabItem value="Java">

```js
@Override
protected void onCreate(Bundle savedInstanceState) {
  //..

  //highlight-start
  Map<String, CustomStreamTrack> customTracks = new HashMap<>();
  CustomStreamTrack videoCustomTrack = VideoSDK.createCameraVideoTrack("h720p_w960p", "front", CustomStreamTrack.VideoMode.MOTION, false, this);
  customTracks.put("video", videoCustomTrack);  //Key must be "video"
  //highlight-end

  // create a new meeting instance
  Meeting meeting = VideoSDK.initMeeting(
    MainActivity.this, meetingId, participantName,
    //MicEnabled
    true,
    //WebcamEnabled , If true, it will use the passed custom track to turn webcam on
    true,
    // ParticipantId
    null,
    // Mode
    null,
    // MultiStream
    false,
    //Pass the custom tracks here
    //highlight-next-line
    customTracks,
    //MetaData
    null
    );
}
```

</TabItem>

</Tabs>

#### 2. Setting up a Custom Track with methods

In order to switch tracks during the meeting, you have to pass the `CustomStreamTrack` in the `enableWebcam()` method of `Meeting`.

:::tip
Make sure to call `disableWebcam()` before you create a new track as it may lead to unexpected behavior.
:::

##### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
val customStreamTrack: CustomStreamTrack = VideoSDK.createCameraVideoTrack("h720p_w960p", "back", CustomStreamTrack.VideoMode.MOTION, false, this)
meeting!!.enableWebcam(customStreamTrack)
```

</TabItem>

<TabItem value="Java">

```javascript
CustomStreamTrack customStreamTrack=VideoSDK.createCameraVideoTrack("h720p_w960p", "back", CustomStreamTrack.VideoMode.MOTION, false, this);
meeting.enableWebcam(customStreamTrack);
```

</TabItem>

</Tabs>

### `Which Configuration is suitable for Device ?`

In this section, we will understand participant size wise `encoder(Resolution)` and `multiStream` configuration.

<center>
<img src='https://cdn.videosdk.live/website-resources/docs-resources/mobile_device_config.png' />
</center>

## Custom Screen Share Track

This feature can be used to customise screenshare streams with enhanced optimization mode and predefined encoderConfig(Resolution + FPS) for specific use-case and send it to other participants.

### `How to Create Custom Screen Share Track ?`

- You can create a Screen Share track using `createScreenShareVideoTrack()` method of `VideoSDK`.
- This method can be used to create video track using different encoding parameters and optimization mode.

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
// data is received from onActivityResult method.
VideoSDK.createScreenShareVideoTrack(

  //highlight-next-line
  // This will accept the  height & FPS of video you want to capture.
  "h720p_15fps", //  `h360p_30fps` | `h1080p_30fps` // Default : `h720p_15fps`

  //highlight-next-line
  // It is Intent received from onActivityResult when user provide permission for ScreenShare.
  data,

  //highlight-next-line
  // Pass Conext
  this)

  //highlight-next-line
  //Callback to this listener will be made when track is ready with CustomTrack as parameter
  {
    track ->
    meeting!!.enableScreenShare(track)
  }
```

</TabItem>

<TabItem value="Java">

```javascript
// data is received from onActivityResult method.
VideoSDK.createScreenShareVideoTrack(
  //highlight-next-line
  // This will accept the  height & FPS of video you want to capture.
  "h720p_15fps", //  `h360p_30fps` | `h1080p_30fps` // Default : `h720p_15fps`

  /highlight-next-line
  // It is Intent received from onActivityResult when user provide permission for ScreenShare
  data,

  //highlight-next-line
  // Pass Conext
  this,

  //highlight-next-line
  //Callback to this listener will be made when track is ready with CustomTrack as parameter
  (track)->{meeting.enableScreenShare(track);}
);
```

</TabItem>

</Tabs>

### `How to Setup Custom Screen Share Track ?`

In order to switch tracks during the meeting, you have to pass the `CustomStreamTrack` in the `enableScreenShare()` method of `Meeting`.

:::note

Make sure to call `disableScreenShare()` before you create a new track as it may lead to unexpected behavior.

:::

##### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
@TargetApi(21)
private fun askPermissionForScreenShare() {
  val mediaProjectionManager = application.getSystemService<Any>(
      Context.MEDIA_PROJECTION_SERVICE
  ) as MediaProjectionManager
  startActivityForResult(
      mediaProjectionManager.createScreenCaptureIntent(), CAPTURE_PERMISSION_REQUEST_CODE
  )
}

@RequiresApi(api = Build.VERSION_CODES.LOLLIPOP)
override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) {
  super.onActivityResult(requestCode, resultCode, data)
  if (requestCode != CAPTURE_PERMISSION_REQUEST_CODE) return
  if (resultCode == RESULT_OK) {
    //highlight-start
    VideoSDK.createScreenShareVideoTrack("h720p_15fps", data, this) { track ->
        meeting!!.enableScreenShare(track)
    }
    //highlight-end
  }
}

```

</TabItem>

<TabItem value="Java">

```javascript
@TargetApi(21)
private void askPermissionForScreenShare() {
  MediaProjectionManager mediaProjectionManager =
      (MediaProjectionManager) getApplication().getSystemService(
          Context.MEDIA_PROJECTION_SERVICE);
  startActivityForResult(
      mediaProjectionManager.createScreenCaptureIntent(), CAPTURE_PERMISSION_REQUEST_CODE);
}

@RequiresApi(api = Build.VERSION_CODES.LOLLIPOP)
@Override
public void onActivityResult(int requestCode, int resultCode, Intent data) {
  super.onActivityResult(requestCode, resultCode, data);
  if (requestCode != CAPTURE_PERMISSION_REQUEST_CODE)
      return;
  if (resultCode == Activity.RESULT_OK) {
    //highlight-start
    VideoSDK.createScreenShareVideoTrack("h720p_15fps", data, this, (track)->{
        meeting.enableScreenShare(track);
    });
    //highlight-end
  }
}

```

</TabItem>

</Tabs>

## API Reference

The API references for all the methods and events utilised in this guide are provided below.

- [Custom Video Track](/react/api/sdk-reference/custom-tracks#custom-video-track---react)
- [Custom Screen Share Track](/react/api/sdk-reference/custom-tracks#custom-screen-share-track---react)


---

---
title: Picture-in-Picture Mode | Video SDK
hide_title: true
hide_table_of_contents: false
description: Picture-in-picture (PiP) is a feature that is commonly used in video conferencing software. It allows you to continue your video conference while also performing other tasks on your device.
sidebar_label: Picture-in-Picture Mode
pagination_label: Picture-in-Picture Mode
keywords:
  - audio calling
  - video calling
  - real-time communication
  - collaboration
  - Picture In Picture Mode 
  - Android Application 
  - Kotlin 
  - WebRTC PiP Mode
  - Android Picture In Picture Mode 
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: picture-in-picture
--- 

# Picture-in-Picture Mode - Android

## Overview

Picture-in-Picture (PiP) mode enables users to continue video calls while interacting with other apps. This native Android feature is particularly valuable for video conferencing applications, allowing seamless multitasking. Our implementation uses Android's built-in PiP API without third-party dependencies.

This guide will help you integrate PiP mode into your app, ensuring it activates both when the user presses the PiP button and when the app is sent to the background.

<center>
<img src='https://cdn.videosdk.live/docs/images/android/pip-mode/join_screen.png' style={{height: '500px'}}/>
</center>

:::note 
You can check out the complete implementation in the [Github repository](https://github.com/videosdk-live/videosdk-android-pip-mode-example).
:::

## Prerequisites

- Clone our [Quick Start Repository](https://github.com/videosdk-live/quickstart/tree/main/android-rtc/Videosdk_android_compose_quickstart)
- Run the base application
- Ensure Android API level 26+ (Oreo) for PiP support

## Android Manifest Setup

Add these essential attributes to your `AndroidManifest.xml`:

```xml title="AndroidManifest. xml"
<activity 
    android:name=".MainActivity"
    android:configChanges="orientation|screenSize|smallestScreenSize|screenLayout"
    android:resizeableActivity="true"
    android:supportsPictureInPicture="true">
</activity>
```

## Getting Started with the Code!

### ViewModel

The `MeetingViewModel` manages two key variables: `pipMode` and `meetingJoined`.

- `pipMode` tracks whether the app is currently in Picture-in-Picture (PiP) mode. This variable is primarily used in the UI to show or hide relevant controls based on the PiP state.

- `meetingJoined` indicates whether the user is currently in a meeting. This is useful in various scenarios, such as determining whether to allow PiP mode when `onPictureInPictureRequested` is called.


```kotlin title="MeetingViewModel.kt"
class MeetingViewModel : ViewModel() {
    // Track PiP activation state
    var pipMode = mutableStateOf(false)
    // Monitor meeting connection status
    var meetingJoined = mutableStateOf(false)
    private val meetingEventListener: MeetingEventListener = object : MeetingEventListener() {
        override fun onMeetingJoined() {
            meetingJoined.value = true
        }
        override fun onMeetingLeft() {
            meetingJoined.value = false
        }
    }
}
```

### MainActivity


1. **Handling PiP Mode Changes (`onPictureInPictureModeChanged`)**

- This method is triggered whenever the activity enters or exits PiP mode (e.g., when the user minimizes the app or returns to full-screen mode).
- The system passes a `Boolean` flag (`isInPictureInPictureMode`), which indicates whether the activity is currently in PiP mode.
- Here, we update the `pipMode` state in `MeetingViewModel` to notify the UI.

2. **Handling PiP Mode Requests (`onPictureInPictureRequested`)**

- This method is called when the system suggests entering PiP mode, typically when the user presses the home button or switches to another app.
- It checks whether the user is in a meeting (`meetingJoined == true`) before allowing PiP mode.

```kotlin title="MainActivity.kt"
class MainActivity : ComponentActivity() {
    // ViewModel instance for managing meeting state
    private lateinit var viewModel: MeetingViewModel
    @RequiresApi(Build.VERSION_CODES.O)
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        // Initialize the ViewModel using ViewModelProvider
        viewModel = ViewModelProvider(this)[MeetingViewModel::class.java]
    }
    override fun onPictureInPictureModeChanged(
        isInPictureInPictureMode: Boolean,
        newConfig: Configuration
    ) {
        // Update the ViewModel state when PiP mode changes
        viewModel.pipMode.value = isInPictureInPictureMode
        super.onPictureInPictureModeChanged(isInPictureInPictureMode, newConfig)
    }
    override fun onPictureInPictureRequested(): Boolean {
        // Allow PiP mode only if the meeting is active
        viewModel.pipMode.value = viewModel.meetingJoined.value
        return super.onPictureInPictureRequested()
    }
}
```

### MeetingScreen

The `MeetingScreen` UI includes a Picture-in-Picture (PiP) mode button, allowing users to switch to PiP mode when a meeting is joined. The screen displays meeting participants in a grid layout. If the user is alone, a message is shown. If there are more than two participants, only the first two are displayed.

- When not in PiP mode, the full meeting UI is shown, including the header, participant grid, and media control buttons (Join, Mic, Cam, Leave, PiP).

- When in PiP mode, the UI adapts by hiding the header and buttons. If the user is alone, a message is displayed. Otherwise, up to two participants are shown.


```kotlin title="MeetingScreen.kt"
@RequiresApi(Build.VERSION_CODES.O)
@Composable
fun MeetingScreen(
    viewModel: MeetingViewModel, 
    navController: NavController, 
    meetingId: String, 
    context: Context
) {
    // Observing the Picture-in-Picture (PiP) mode state from the ViewModel
    val pipMode = viewModel.pipMode
    // If PiP mode is not enabled, show the full meeting UI
    if (!pipMode.value) {
        Column(modifier = Modifier.fillMaxSize()) {
            Header(meetingId)
            MySpacer()
            ParticipantsGrid(
                gridCells = GridCells.Fixed(2),
                participants = viewModel.participants,
                modifier = Modifier.weight(1f)
            )
            MySpacer()
            // Media control buttons (Join, Mic, Cam, Leave, PiP)
            MediaControlButtons(
                onJoinClick = { viewModel.initMeeting(
                    context, app.sampleToken, meetingId
                ) },
                onMicClick = { viewModel.toggleMic() },
                onCamClick = { viewModel.toggleWebcam() },
                onLeaveClick = { viewModel.leaveMeeting() },
                // Enable PiP if meeting is joined
                onPiPClick = { pipMode.value = viewModel.meetingJoined.value } 
            )
        }
    }
    // If PiP mode is enabled, adjust UI accordingly
    if (pipMode.value) {
        activity?.enterPictureInPictureMode(
            PictureInPictureParams.Builder()
            // Custom aspect ratio for PiP window
            .setAspectRatio(Rational(16, 9)) .build()
        )
        if (viewModel.participants.size == 1) {
            Row(modifier = Modifier.fillMaxSize()) {
                // Display the single participant
                Box(modifier = Modifier.weight(1f)) {
                    ParticipantsGrid(
                        gridCells = GridCells.Fixed(1),
                        participants = viewModel.participants.take(1),
                    )
                }
                // Display a message when the user is alone in the meeting
                Box(
                    modifier = Modifier
                        .weight(1f)
                        .fillMaxHeight()
                        .wrapContentSize(Alignment.Center),
                    contentAlignment = Alignment.Center
                ) {
                    Text(
                        text = "You are alone \n in the \n meeting",
                        color = Color.Black,
                        textAlign = TextAlign.Center,
                        fontSize = 12.sp,
                        maxLines = 3,
                        overflow = TextOverflow.Ellipsis,
                        modifier = Modifier.fillMaxWidth()
                    )
                }
            }
        } else {
            // Display up to two participants in PiP mode
            ParticipantsGrid(
                gridCells = GridCells.Fixed(2),
                participants = viewModel.participants.take(2),
                modifier = Modifier.fillMaxSize()
            )
        }
    }
}
@Composable
fun MediaControlButtons(
    // .....
    onPiPClick: () -> Unit
) {
    Row {
        // Other buttons (Join, Mic, Cam, Leave) can be placed here
        // Button to toggle Picture-in-Picture mode
        MyAppButton(onPiPClick, "PiP Mode")
    }
}
```

## Final Output

The final output of Picture-in-Picture (PiP) Mode in the Android application using VideoSDK, without relying on any third-party packages. You can further customize the view and optimize it as per your requirements.

import ReactPlayer from 'react-player'

<div style={{ textAlign: 'center', marginBottom: '50px' }}> 
  <ReactPlayer 
    autoplay 
    muted 
    loop 
    playing 
    controls 
    url="https://cdn.videosdk.live/docs/images/android/pip-mode/pip-mode.mp4" 
    height="500px" 
    width="100%" 
  />
</div>

<div>
  :::tip  
  Stuck anywhere? Check out this [example code](https://github.com/videosdk-live/videosdk-android-pip-mode-example) on GitHub  
  :::  
</div>

---

---
title: Understanding Analytics Dashboard | Video SDK
hide_title: true
hide_table_of_contents: false
description: Video SDK and Audio SDK, developers need to implement a token server. This requires efforts on both the front-end and backend.
sidebar_label: Understanding Analytics Dashboard
pagination_label: Understanding Analytics Dashboard
keywords:
  - audio calling
  - video calling
  - real-time communication
  - collaboration
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: understanding-analytics-dashboard
---

import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>

# Understanding Analytics Dashboard - Android

Welcome to the world of actionable insights and empowered decision-making. VideoSDK's session analytics dashboard is your gateway to understanding, optimizing, and elevating every aspect of your sessions.

## Accessing Analytics Made Easy

Navigating through session data is a breeze with VideoSDK. Simply head to your session page at https://app.videosdk.live/meetings/sessions, where a treasure trove of session information awaits.

### How to Access Analytics?

Open Session Analytics effortlessly by following these steps:

1. **Click on Meeting-ID:**
    - Directly access analytics by clicking on the meeting-ID within the session table.
2. **Hover and Click View Analytics:**
    - Hover over a specific meeting row to reveal the **View Analytics** button in the Actions Column.
    - Click on **View Analytics** to open the Session Overview sidebar, unlocking a wealth of insights.

![Access Analytics](https://cdn.videosdk.live/website-resources/docs-resources/access_analytics.png)

---

There are three tabs available within the session analytics view:

## **1. Session Overview**

This tab provides an overview of the session, including its duration and participant details. You can explore individual participant statistics to understand their session performance better.

## **2. Errors**

In this tab, you can find information about any errors encountered during the session. It helps you identify and address issues like network problems or technical glitches promptly.

:::note

Session errors are visible with JS SDK v0.0.82 or higher, React SDK v0.1.85 or higher, and React Native v0.1.6 or newer versions.

:::

## **3. Session Stats**

Explore data and metrics sent and received by participants to measure performance of the session in this tab. It offers insights into data exchange among participants, including metrics on jitter, RTT, and packet loss, resolutions, and fps aiding in assessing communication efficiency.

Let's dive deeper into each of these tabs to gain a better understanding of session analytics.

# Session Overview

The session overview page is your compass in the sea of data. Here's what you'll uncover:

- **Meeting ID:** Unique identifier for the meeting in the format of `abcd-efgh-ijkl`.
- **Session ID:** Unique identifier for each session, uniquely identified by its `sessionId`.
- **Session Status:** Indicates if the session is ongoing or ended.
- **Session Initiating Time:** Time taken by the first participant to establish the connection.
- **Start and End Time:** Marks the start and end of the session.
- **Total Unique Participants Joined:** Total number of unique participants in the session.
- **Total Session Duration:** Overall duration of the session from start to end.
- **Total Participant Minutes:** A sum of all participant duration.
- **Recording, HLS, RTMP:** Additional services used in the session.

### Participant Table List

- **Participant ID:** Unique identifier for each participant.
- **Participant Name:** Personalized identification for each participant.
- **Join Time:** Time taken by the participant to establish connection.
- **Duration:** Total time spent by this participant in the session.

### Efficient Session Management with Actions

Enhance your session management with streamlined actions:

- **Kick Out Participants:** Effortlessly remove/kickout participants from ongoing sessions.
- **Detailed Participant Analytics:**
- Hover over a specific participant row to reveal the `View Stats` button at the end of the row.
- Click on `View Stats` to open the Participant Overview sidebar.


![View Stats](https://cdn.videosdk.live/website-resources/docs-resources/view_stats.png)


## Explore Participant Insights

Discover valuable participant data that provides a clear view of engagement and experience:

- **Participant ID:** Unique identifier for each participant.
- **Participant Name:** Personalized identification for better interaction.
- **Joined At:** Indicates the precise moment when participant connects to the session.
- **Left At:** Indicates the precise moment when participant left the session.
- **Total Duration:** Total duration of participant within that session.
- **Joining Time:** Time taken by the this participant to establish the connection.
- **Location:** Approx. geographic location from where the participant joined.
- **Platform:** Specifies whether participants are using a desktop or mobile device.
- **Device Info:** Offers details regarding the participant's device.
- **OS:** Provides information about the participant's OS.
- **Browser:** Provides specifics about the participant's browser
- **SDK Version:** Indicates the version of the SDK used by participants.

### Understanding Participant Call Health

We've developed call health to offer a rapid assessment of participant performance during calls. This feature highlights the performance of audio, video, and screen sharing audio-video separately. We've utilized color theory, with green indicating good performance, orange for moderate, and red for poor performance, to enhance clarity. For detailed insights, simply hover over the bars

![Participant Call Health](https://cdn.videosdk.live/website-resources/docs-resources/participant_call_health.png)

## Participant Session Stats

Dive into Participant Session Stats for valuable insights into your session experience! With just a click on `View Session Stats` at the bottom of the page, unlock a treasure trove of data crucial for understanding audio and video experiences.

Within this section, you can observe quality metrics for the selected participant, comparing them to others. Additionally, the `Sessions Stats` covers quality stats comparison for every participant. Keep reading to explore more about Session Stats.

**Visualizing Session Performance from Both Sides**

This section provides a two-sided view of your session's metrics.

- **Left Side: Sender Participant Graph** This section displays graphs representing the metrics sent by the sender participant.. Here, you can see how the various factors impacted the data you transmitted.
- **Right Side: Receiver Participant Graph** On the right side, you'll find a dropdown menu where you can select a specific participant. Choosing a receiver will display graphs showcasing the metrics **received by that participant**. This allows you to compare the sending experience (left side) with the receiving experience (right side) for different participants.

![VideoSDK Jitter Graph](https://cdn.videosdk.live/website-resources/docs-resources/video_jitter_graph.png)

**See How Your Session Performed**

These metrics give you a clear picture of your session's quality. Understanding them helps you spot any issues and keep things running smoothly. Let's dive into what each metric means!

**Jitter:** Imagine your internet connection like a bumpy road. Jitter is how much those bumps cause your signal to bounce around. Less jitter means a smoother ride for your data (audio and video, threshold ≤ 30ms).

**RTT (Latency):** This is how long it takes for data to travel between you and the server you're connected to. Think of it like the time it takes for a message to get delivered – a lower RTT means a faster delivery (affects both audio and video, threshold ≤ 300ms).

**Bitrate:** This measures the amount of data flowing through your connection per second. Imagine it like the width of a water pipe – a higher bitrate allows for more data to flow, which can be good for high-quality audio/video or fast downloads.

**Packet Loss:** Think of data traveling in tiny packets. Packet loss is when some of those packets get dropped along the way. More packet loss means information might be missing, affecting things like audio/video quality or lag in games (threshold ≤ 5%).

**Resolution:** This refers to the sharpness and detail of an image or video. Think of it like the number of pixels on your screen – a higher resolution means a crisper picture (**Video Only**).

**FPS (Frames Per Second):** This measures how many images (frames) are displayed on your screen every second. Imagine it like a flipbook – a higher FPS creates a smoother and more fluid animation or video experience (**Video Only**).

![VideoSDK FPS Graph](https://cdn.videosdk.live/website-resources/docs-resources/video_fps_graph.png)

![VideoSDK Resolution Graph](https://cdn.videosdk.live/website-resources/docs-resources/video_resolution_graph.png)

---

# **Analyse Session Stats**

Similar to `Participant Session Stats`, this tab covers quality statistics sent by individual participants. You can select any participant to compare effectively with others.

Choose a sender participant from the dropdown menu on the left and select a recipient on the right to compare data over different time frames. This allows you to identify and explore issues within specific durations.

This tab covers the same metrics as covered in the `participant session stats`: Jitter, RTT (Latency), Bitrate, Packet-loss, Resolution (Video only), and FPS (Video only).

![VideoSDK Session Stats](https://cdn.videosdk.live/website-resources/docs-resources/session_stats.png)

---

---
title: Understanding Call Quality | Video SDK
hide_title: true
hide_table_of_contents: false
description: Video SDK and Audio SDK, developers need to implement a token server. This requires efforts on both the front-end and backend.
sidebar_label: Understanding Call Quality
pagination_label: Understanding Call Quality
keywords:
  - audio calling
  - video calling
  - real-time communication
  - collaboration
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: understanding-call-quality
---

# Understanding Call Quality - Android

When developing a video call app, customer satisfaction heavily depends on your app's video and audio quality and its fluctuation.

## Call Quality

If we look at the video quality from the user's perspective, a good video quality can be defined as smooth and clear video, along with a crystal clear audio. If the same is viewed from the developer's perspective, a good video quality can be determined as a high resolution, high frame rate video with minimal latency along with a high bitrate audio with minimal audio loss.

## Factors affecting Quality

When it comes to measuring the video and audio quality of a call, there are multiple variables to consider, and the most common factors which affect the video and audio quality are:

### `1. Network Bandwidth`

- Network bandwidth is a measurement of a user's network capability to how large data can be received and send.
- If the bandwidth is low at participant side, he/she is likely to get pixelated or frozen video along with robotic voice or minor breaking in the audio.
- Frequent change in the network providers can also result in high fluctuation of the internet bandwidth, which can also result in poor quality video.

### `2. Latency`

- Latency basically means the time it takes for data to transfer from one machine to another.
- If the meeting is hosted in `Ohio` region, and users are joining from `Singapore` region, so this will create long delay for data to transfer from one machine to another, thus you should pick a server according to your user base.
- In VideoSDK you can set the server during creation of Meeting/Room.

### `3. CPU Usage`

- CPU Usage is an also quite determining factor as all the audio and video streams which are going out and coming in will have to encoded or decoded which will require a significant amount of computation.
- The high the resolution and frame rate of the videos, the larger would be the computation required, which can be a reason for the bottleneck of delivering a good quality video.
- If the CPU is being consumed heavily, it can also result in a choppy or robotic audio.

### `4. Camera and Mic Quality`

- The camera and microphone should capture good quality of streams so that remote user doesn't get low quality stream even if he/she has good network bandwidth

## Identifying the Quality Issues

In order to identify quality issues, VideoSDK collects multiple audio and video related metrics which can help in pinpointing the quality issues. Let's have a look at those metrics and understand what the indicates.

### `1. Resolutions and Framerates`

- Resolution and frame rate are key metrics for video quality in a video call app. Resolution refers to the number of pixels in a video image, while frame rate refers to the number of frames displayed per second.

- Higher resolutions and frame rates can provide better video quality, but they also require more bandwidth and processing power. It's important to optimize this metrics for the devices and network conditions of your users.

- For example, if most of your users are on mobile devices, a lower resolution and frame rate may be more appropriate to ensure smooth playback and minimize bandwidth usage.

- If most of your users are on mobile and desktop devices, having higher resolution for desktop and mid-resolutions for mobile devices can help in improving the performance and quality as we will be saving the bandwidth on the mobile end.

### `2. Bitrate`

- Bitrate is the number of bits per second send or received during the transmission of audio or video streams. Bitrate can be a key parameter to determine the quality of the audio or video streams, as it should be fine-tuned for each resolution to achieve the best match of performance and bandwidth utilization.

- If the users are having excellent network conditions, higher bitrate can result in much better video quality but on the other hand, having very high bitrates on the mobile devices can result in heating issues due to high computation required to encode and decode the videos.

##### Example

We joined using the same phone **(iPhone 14)**, but the resolution and bitrate were different, first participant having resolution **`1280x720`** with bitrate **`1442 kbps`** and second participant having resolution **`960x540`** with bitrate **`642 kbps`**, so as we can see both participants' video appeared to be of equal quality even though resolution and bitrate are different.

![resolution-and-bitrate](/img/resolution-and-bitrate.png)

### `3. Packet Loss`

- Packet loss is a metric that indicates how many data packets are lost during transmission from the sender to the receiver. Packet loss can occur due to network congestion, hardware or software issues, or network latency. Higher packet loss can result in poor video and audio quality, as the missing packets can cause gaps or distortions in the media stream.

import ReactPlayer from 'react-player'

<div style={{textAlign: 'center'}}>

<ReactPlayer autoplay muted loop playing url='/video/packet-loss-burst.mp4' width={"100%"}/>

</div>

### `4. Jitter`

- The audio and video packets are sent out at random intervals over a specified time frame as they are being sent between the server and client. Nevertheless, jitter is produced when there is a variation in transmitting or receiving this data packets as a result of a faulty network connection.

- When data packets delay while being transmitted to the participant, usually because the network is busy. They'll display as pixelated video on a video call or sound choppy, distorted, or robotic on a voice call as they arrive. They'll arrive at random intervals, creating jitter.

### `5. Round Trip Time (Latency)`

- Round trip time is the amount of time required to transmit the data packets to send or receive from the server. If the servers are located very far from the user's location, they can observe a high latency (delay).

- With VideoSDK, this factor is taken care of as we automatically choose the nearest available server for participants. But if you are geofencing to a certain region, you should make sure that you choose the server which will be nearest to your users.

<center>

![resolution-and-bitrate](/img/rtt.png)

</center>

## Checking Realtime Statistics

VideoSDK provides methods to check the realtime statistics of the audio and video of all the participants.

### `getVideoStats()`

- `getVideoStats()` returns an array of object containing the different quality parameters for video stream which can be accessed through the `useParticipant` hook.

- This objects will have values for the specific participant's video stream resolution, frame rate, bitrate, jitter, round trip time, and packet loss.

<div style={{textAlign: 'center'}}>

<ReactPlayer autoplay muted loop playing url='/video/realtime-stats.mp4' width={"100%"}/>

</div>

### `getAudioStats()`

- `getAudioStats()` returns an array of object containing the different quality parameters for audio stream which can be accessed through the `useParticipant` hook.

- This objects will have values for the specific participant's audio stream bitrate, jitter, round trip time and packet loss.

### `getShareStats()`

- `getShareStats()` returns an array of object containing the different quality parameters for screen share stream which can be accessed through the `useParticipant` hook.

- This objects will have values for the specific participant's screen share stream resolution, frame rate, bitrate, jitter, round trip time, and packet loss.

:::note
To show the popup dialog for the participant's realtime stats, you can [refer to this component](https://github.com/videosdk-live/videosdk-rtc-react-sdk-example/blob/main/src/utils/common.js#L142).
:::

## Quality analysis Graphs

For all the sessions taken using the VideoSDK, you can find the quality analysis graphs from the [VideoSDK Dashboard](https://app.videosdk.live/meetings/sessions) which can help you visualize the data you are seeing in realtime and identify the spikes of a few parameters happing during call which can help figure out the reason for the quality issue.

![quality analysis](/img/quality-analysis.png)

## API Reference

The API references for all the methods and events utilised in this guide are provided below.

- [getVideoStats()](/android/api/sdk-reference/participant-class/methods#getvideostats)
- [getAudioStats()](/android/api/sdk-reference/participant-class/methods#getaudiostats)
- [getShareStats()](/android/api/sdk-reference/participant-class/methods#getsharestats)


---

---
sidebar_label: Virtual Background
pagination_label: Virtual Background
---

# Virtual Background - Android

Virtual backgrounds allow you to replace your actual background during video calls or meetings with an image, a solid color, or even a blur effect. This can be useful for:

- Privacy: Hide your messy room or anything you don't want others to see.

- Focus: Minimize distractions and keep the focus on the conversation.

- Fun: Liven up the call with a cool background theme.

import ReactPlayer from 'react-player'

<ReactPlayer controls autoplay muted loop playing url='https://assets.videosdk.live/images/android-video-processor.mp4' width={"100%"} />

## Virtual Background using `MediaEffects` library

The `MediaEffects` library enables the integration of sophisticated virtual background effects within your video applications. By leveraging this library, users can replace their physical backgrounds with custom images or static backdrops, creating a more immersive and engaging experience. 

:::info

The Virtual Background feature in VideoSDK can be utilized regardless of the meeting environment, including the pre-call screen.

:::

### Install the library 
You can install our Android library by using Maven Central package repositories.

- Add the dependency in your `app/build.gradle` file.

```js title="app/build.gradle"
dependencies {
	implementation 'live.videosdk:videosdk-media-effects:0.0.2'
	// other app dependencies
}
```
### Apply Virtual Background

- The `applyVideoProcessor()` method of the `VideoSDK` class enables dynamic changes to the video background during a live session.
- This method accepts an instance of the `VideoFrameProcessor` class as its parameter.
- The following classes implement the `VideoFrameProcessor` interface. Depending on your requirements, you can create an instance of the appropriate class and pass it to the `applyVideoProcessor()` method:

    1. `BackgroundImageProcessor` : The `BackgroundImageProcessor` class takes a `Uri` as a parameter and uses it as the video stream background.
    2. `BackgroundBlurProcessor`: The `BackgroundBlurProcessor` class takes a `float` value for the blur radius and a `Context` to apply a blur effect to the video stream background. It supports range between 0 to 25.
    3. `BackgroundColorProcessor`: The `BackgroundColorProcessor` class takes an `int` value for the color and sets it as the background for the video stream.

### Change Virtual Background

- To change the virtual background, users can utilize a set of setters that allow easy switching between a new image, a blur effect, or a solid color. This functionality supports dynamic customization, enhancing the user's video experience by enabling seamless background updates in real-time.

- You can use following setters to change Virtual Background:

    1. `setBackgroundSource(Uri uri)`: This method of the `BackgroundImageProcessor` class takes a `Uri` as a parameter to update the current background image for the video stream.
    2. `setBlurRadius(float opacity)`: This method of the `BackgroundBlurProcessor` class takes a `float` value for the blur radius to adjust the blur effect of the current background.
    3. `setBackgroundColor(int color)`: This method of the `BackgroundColorProcessor` class takes an `int` value as a parameter to update the current background color for the video stream.
### Remove Virtual Background

- The `removeVideoProcessor()` method from the `VideoSDK` class provides users with a convenient way to revert their video background to its original state, removing any previously applied virtual background. This functionality ensures flexibility for users to switch between virtual and real backgrounds as needed.

#### Example

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
Class MeetingActivity : AppCompatActivity() {
    private var backgroundImageProcessor: BackgroundImageProcessor? = null
    private var backgroundBlurProcessor: BackgroundBlurProcessor? = null
    private var backgroundColorProcessor: BackgroundColorProcessor? = null

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)

        //...

        //To Apply Virtual Background
        findViewById<View>(R.id.applyBackground).setOnClickListener { view: View? ->
            val uri =
                Uri.parse("https://st.depositphotos.com/2605379/52364/i/450/depositphotos_523648932-stock-photo-concrete-rooftop-night-city-view.jpg")
            backgroundImageProcessor = BackgroundImageProcessor(uri)
      //    backgroundBlurProcessor = BackgroundBlurProcessor(25f, this)
      //    backgroundColorProcessor = BackgroundColorProcessor(Color.BLUE)
            VideoSDK.applyVideoProcessor(backgroundColorProcessor)
        }

        //To Change Virtual Background
        findViewById<View>(R.id.changeBackground).setOnClickListener { view: View? ->
            val newUri =
                Uri.parse("https://images.pexels.com/photos/531880/pexels-photo-531880.jpeg?cs=srgb&dl=pexels-pixabay-531880.jpg&fm=jpg")
            backgroundImageProcessor!!.setBackgroundSource(newUri)
      //    backgroundColorProcessor!!.setBackgroundColor(Color.CYAN)
      //    backgroundBlurProcessor!!.setBlurRadius(17f)
        }
        
        //To Remove Virtual Background
        findViewById<View>(R.id.changeBackground).setOnClickListener { view: View? ->
            VideoSDK.removeVideoProcessor()
        }
    }
}
```

</TabItem>

<TabItem value="Java">

```java
public class MeetingActivity extends AppCompatActivity {

    private BackgroundImageProcessor backgroundImageProcessor;
    private BackgroundBlurProcessor backgroundBlurProcessor;
    private BackgroundColorProcessor backgroundColorProcessor;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        //...

        //To Apply Virtual Background
        findViewById(R.id.applyBackground).setOnClickListener(view -> {
            Uri uri = Uri.parse("https://st.depositphotos.com/2605379/52364/i/450/depositphotos_523648932-stock-photo-concrete-rooftop-night-city-view.jpg");
            backgroundImageProcessor = new BackgroundImageProcessor(uri);
        //   backgroundBlurProcessor = new BackgroundBlurProcessor(25,this);
        //   backgroundColorProcessor = new BackgroundColorProcessor(Color.BLUE);
            VideoSDK.applyVideoProcessor(backgroundColorProcessor);
        });

        //To Change Virtual Background
        findViewById(R.id.changeBackground).setOnClickListener(view -> {
            Uri newUri = Uri.parse("https://images.pexels.com/photos/531880/pexels-photo-531880.jpeg?cs=srgb&dl=pexels-pixabay-531880.jpg&fm=jpg");
            backgroundImageProcessor.setBackgroundSource(newUri);
        //    backgroundColorProcessor.setBackgroundColor(Color.CYAN);
        //    backgroundBlurProcessor.setBlurRadius(17);    
        });
        
        //To Remove Virtual Background
        findViewById(R.id.removeBackground).setOnClickListener(view -> {
            VideoSDK.removeVideoProcessor();
        });
    }
}
```

</TabItem>

</Tabs>

## API Reference

The API references for all the methods utilized in this guide are provided below.

- [applyVideoProcessor()](/android/api/sdk-reference/videosdk-class/methods#applyvideoprocessor)
- [removeVideoProcessor()](/android/api/sdk-reference/videosdk-class/methods#removevideoprocessor)



---

---
title: Run the HLS Sample Android Project - Video SDK Docs
hide_title: true
hide_table_of_contents: false
description: Create customizable real-time video & audio calling applications with React JS SDK with Video SDK add live Video & Audio conferencing to your applications.
sidebar_label: Run Http Live Streaming Project
pagination_label: Run Http Live Streaming Project
keywords:
  - android sdk
  - sample project
  - android app
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: run-a-sample-android-hls-project
---

import Step from '@site/src/components/Step'

# Run a Sample HLS Project - Android

Video SDK provides open-source sample project [videosdk-hls-android-kotlin-example](https://github.com/videosdk-live/videosdk-hls-android-kotlin-example) on Github. This document introduces how to run this project.

## Prerequisites

- Development environment requirements:
  - [Java Development Kit](https://www.oracle.com/java/technologies/downloads/)
  - Android Studio 3.0 or later
- A physical or virtual mobile device running Android 5.0 or later
- Valid Video SDK [Account](https://app.videosdk.live/)

import APISecret from '../../../../mdx/introduction/_api-key.mdx';

<APISecret title="Get your API key and Secret key" />

## Run the Sample Project

<div className="heading-toc-only">
### Step 1: Clone the sample project
</div>
<Step number={1} title="Clone the sample project">
Clone the repository to your local environment.

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
git clone https://github.com/videosdk-live/videosdk-hls-android-kotlin-example.git
```

</TabItem>

<TabItem value="Java">

```js
git clone https://github.com/videosdk-live/videosdk-hls-android-java-example.git
```

</TabItem>

</Tabs>
</Step>

<div className="heading-toc-only">
### Step 2: Modify local.properties
</div>
<Step number={2} title="Modify local.properties">
Open your favorite code editor, add `auth_token` in `local.properties` file and paste the earlier generated temporary token as value.

```js title="local.properties"
auth_token = "TEMPORARY-TOKEN";
```
</Step>

<div className="heading-toc-only">
### Step 3: Run the Sample App
</div>
<Step number={3} title="Run the Sample App">
Run the android app with **Shift+F10** or the ** ▶ Run ** from toolbar.
</Step>


---

---
title: Run the ILS Sample Android Project - Video SDK Docs
hide_title: true
hide_table_of_contents: false
description: Create customizable real-time video & audio calling applications with React JS SDK with Video SDK add live Video & Audio conferencing to your applications.
sidebar_label: Run Interactive Live Streaming Project
pagination_label: Run the ILS Project
keywords:
  - android sdk
  - sample project
  - android app
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: run-a-sample-android-ils-project
---

import Step from '@site/src/components/Step'

# Run Interactive Live Streaming Project - Android

Video SDK provides open-source sample project [videosdk-ils-android-kotlin-example](https://github.com/videosdk-live/videosdk-ils-android-sdk-example) on Github. This document introduces how to run this project.

## Prerequisites

- Development environment requirements:
  - [Java Development Kit](https://www.oracle.com/java/technologies/downloads/)
  - Android Studio 3.0 or later
- A physical or virtual mobile device running Android 5.0 or later
- Valid Video SDK [Account](https://app.videosdk.live/)

import APISecret from '../../../../mdx/introduction/_api-key.mdx';

<APISecret title="Get your API key and Secret key" />

## Run the Sample Project

<div className="heading-toc-only">
### Step 1: Clone the sample project
</div>
<Step number={1} title="Clone the sample project">
Clone the repository to your local environment.

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
git clone https://github.com/videosdk-live/videosdk-ils-android-sdk-example
```

</TabItem>

<TabItem value="Java">

```js
git clone https://github.com/videosdk-live/videosdk-ils-android-sdk-example
```

</TabItem>

</Tabs>
</Step>

<div className="heading-toc-only">
### Step 2: Modify local.properties
</div>
<Step number={2} title="Modify local.properties">
Open your favorite code editor, add `auth_token` in `local.properties` file and paste the earlier generated temporary token as value.

```js title="local.properties"
auth_token = "TEMPORARY-TOKEN";
```
</Step>

<div className="heading-toc-only">
### Step 3: Run the Sample App
</div>
<Step number={3} title="Run the Sample App">
Run the android app with **Shift+F10** or the ** ▶ Run ** from toolbar.
</Step>


---

---
title: Run a sample Android Project - Video SDK Docs
hide_title: true
hide_table_of_contents: false
description: Create customizable real-time video & audio calling applications with Android SDK with Video SDK add live Video & Audio conferencing to your applications.
sidebar_label: "Run Audio & Video Call Project"
pagination_label: "Run Audio & Video Call Project"
keywords:
  - android sdk
  - java sdk
  - kotlin sdk
  - sample project
  - android app
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: run-a-sample-android-project
---

import Step from '@site/src/components/Step'

# Run Audio & Video Call Project - Android

Video SDK provides open-source sample project [videosdk-rtc-android-kotlin-sdk-example](https://github.com/videosdk-live/videosdk-rtc-android-kotlin-sdk-example) on Github. This document introduces how to run this project.

## Prerequisites

- Development environment requirements:
  - [Java Development Kit](https://www.oracle.com/java/technologies/downloads/)
  - Android Studio 3.0 or later
- A physical or virtual mobile device running Android 5.0 or later
- Valid Video SDK [Account](https://app.videosdk.live/)

import APISecret from '../../../../mdx/introduction/_api-key.mdx';

<APISecret title="Get your API key and Secret key" />

## Run the Sample Project

<div className="heading-toc-only">
### Step 1: Clone the sample project
</div>
<Step number={1} title="Clone the sample project">
Clone the repository to your local environment.

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
git clone https://github.com/videosdk-live/videosdk-rtc-android-kotlin-sdk-example.git
```

</TabItem>

<TabItem value="Java">

```js
git clone https://github.com/videosdk-live/videosdk-rtc-android-java-sdk-example.git
```

</TabItem>

</Tabs>
</Step>

<div className="heading-toc-only">
### Step 2: Modify local.properties
</div>
<Step number={2} title="Modify local.properties">
Open your favorite code editor, add `auth_token` in `local.properties` file and paste the earlier generated temporary token as value.

```js title="local.properties"
auth_token = "TEMPORARY-TOKEN";
```
</Step>

<div className="heading-toc-only">
### Step 3: Run the Sample App
</div>
<Step number={3} title="Run the Sample App">
Run the android app with **Shift+F10** or the ** ▶ Run ** from toolbar.
</Step>


---

---
title: Just Click Setup - Testing Token Server | Video SDK
hide_title: true
hide_table_of_contents: false
description: Video SDK and Audio SDK, developers need to implement a token server. This requires efforts on both the front-end and backend.
sidebar_label: Authentication and Tokens
pagination_label: Authentication and Tokens
keywords:
  - audio calling
  - video calling
  - real-time communication
  - collaboration
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: server-setup
---

import ServerSetup from '../../../../mdx/introduction/\_server-setup.mdx';
import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>
<ServerSetup />


---

---
title: Initialize Meeting | Video SDK
hide_title: true
hide_table_of_contents: false
description: Video SDK and Audio SDK, developers need to implement a token server. This requires efforts on both the front-end and backend.
sidebar_label: Initialize Meeting
pagination_label: Initialize Meeting
keywords:
  - audio calling
  - video calling
  - real-time communication
  - collaboration
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: initialize-meeting
---

# Initialize Meeting - Android

To configure a VideoSDK meeting you require two things, first the `token` which will be used for **Authentication** purpose and a `meetingId` which will be used to specify where a participant will join. Let's see each of the steps closely.

### Generating Token

You can generate a `token` in two ways:

1. **`Temporary Token`** : You can visit [Dashboard's API Key section](https://app.videosdk.live/api-keys) and generate the temporary token from there.

2. **`Server`** : You can setup **JWT** in backend and make an API call to get the token from your server.

To learn more about **Authentication** and token in detail you can follow [this guide](../authentication-and-token).

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
// With Temporary Token
fun getToken(): String? {
  // Update the token here from the VideoSDK dashboard
  // highlight-next-line
  return "YOUR_TOKEN"
}

// Server
fun getToken(): String? {
  val token = arrayOfNulls<String>(1)
  // highlight-start
  AndroidNetworking.get("http://localhost:3000/get-token")
      .build()
      .getAsJSONObject(object : JSONObjectRequestListener() {
          fun onResponse(response: JSONObject) {
              try {
                  token[0] = response.getString("token")
              } catch (e: JSONException) {
                  e.printStackTrace()
              }
          }

          fun onError(anError: ANError) {
              anError.printStackTrace()
          }
      })
  // highlight-end
  return token[0]
}
```

</TabItem>

<TabItem value="Java">

```java
// With Temporary Token
public String getToken()
{
  // Update the token here from the VideoSDK dashboard
  // highlight-next-line
  String token = "YOUR_TOKEN";
  return token;
}

// Server
public String getToken()
{
  final String[] token = new String[1];
  // highlight-start
  AndroidNetworking.get("http://localhost:3000/get-token")
      .build()
      .getAsJSONObject(new JSONObjectRequestListener() {
          @Override
          public void onResponse(JSONObject response) {
              try {
                  token[0] = response.getString("token");
              } catch (JSONException e) {
                  e.printStackTrace();
              }
          }
          @Override
          public void onError(ANError anError) {
              anError.printStackTrace();
          }
      });
  // highlight-end
  return token[0];
}
```

</TabItem>

</Tabs>

### Generating Meeting Id

With the token ready, we can get the `meetingId` from the [VideoSDK's rooms API](/api-reference/realtime-communication/create-room).

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
fun getMeetingId(token: String?): String? {
  var meetingId: String? =null;
  // We will use VideoSDK rooms API endpoint to create a meetingId
  // highlight-start
  AndroidNetworking.post("https://api.videosdk.live/v2/rooms")
      .addHeaders("Authorization", token) // We will pass the token in the headers
      .build()
      .getAsJSONObject(object : JSONObjectRequestListener() {
          fun onResponse(response: JSONObject) {
              try {
                  meetingId = response.getString("roomId")
              } catch (e: Exception) {
                  e.printStackTrace()
              }
          }

          fun onError(anError: ANError) {
              anError.printStackTrace()
          }
      })
  // highlight-end
  //we will return the meetingId which we got from the response of the api
  return meetingId
}
```

</TabItem>

<TabItem value="Java">

```java
public String getMeetingId(String token) {
  final String[] meetingId = new String[1];
  // We will use VideoSDK rooms API endpoint to create a meetingId
  // highlight-start
  AndroidNetworking.post("https://api.videosdk.live/v2/rooms")
      .addHeaders("Authorization", token) // We will pass the token in the headers
      .build()
      .getAsJSONObject(new JSONObjectRequestListener() {
          @Override
          public void onResponse(JSONObject response) {
              try {
                  meetingId[0] = response.getString("roomId");
              } catch (Exception e) {
                  e.printStackTrace();
              }
          }
          @Override
          public void onError(ANError anError) {
              anError.printStackTrace();
          }
      });
  // highlight-end
  //we will return the meetingId which we got from the response of the api
  return meetingId[0];
}
```

</TabItem>

</Tabs>

:::tip
To perform Network call you need to add [Fast Android Networking Library](https://github.com/amitshekhariitbhu/Fast-Android-Networking) in your application.
:::

### Initialization of Meeting

1. To initialize the meeting, first we have to initialize the VideoSDK.
   We can initialize the VideoSDK using `initialize()` method provided by the SDK.

```js title="initialize"
  VideoSDK.initialize(Context context)
```

2. Next, we have to set token property of VideoSDK class.
   By using `config()` method, you can set the token property of VideoSDK class.

```js title="config"
 VideoSDK.config(String token)
```

3. Now, we can initialize the meeting using a factory method provided by the SDK called `initMeeting()`.

`initMeeting()` is responsible for initializing the meeting with the provided configuration, which includes the `meetingId`, `name`, `participantId` and many more.

:::tip
When conducting one-to-one meetings, it is recommended to set `multistream:false`.For more information on multistream, refer to the [multistream documentation](/android/guide/video-and-audio-calling-api-sdk/render-media/optimize-video-track#what-is-multistream).
:::

Let's take a deeper look at the available configuration options first.

```js title="initMeeting"
  VideoSDK.initMeeting(
      Context context,  // context of activity
      String meetingId,  // id of meeting
      String name, // name of participant
      boolean micEnabled, // flag to enable-mic
      boolean webcamEnabled, // flag to enable-webcam
      String participantId,  // id of participant
      String mode, // mode of participant
      boolean multiStream, // multiStream
      Map<String, CustomStreamTrack> customTracks, // map of customTracks
      JSONObject metaData, // metaData
      String signalingBaseUrl // signalingBaseUrl
      PreferredProtocol preferredProtocol //preferredProtocol
  )
```

- **`context`** :

  - Context of activity.
  - It will accept `Context` type value.

- **`meetingId`** :

  - meetingId is unique identifiers that allow participants to join a specific meeting or room.
  - It will accept `String` type value.
  - It will be in the format of `xxx-yyy-zzz` and will be generated using the [VideoSDK's Room API](/api-reference/realtime-communication/create-room).

- **`name`**:

  - This will represent the name of the participant in the meeting.
  - It will accept `String` type value.

- **`micEnabled`**:

  - This is a `boolean` flag, indicating whether a participant's microphone will be automatically enabled when they join a meeting.

- **`webcamEnabled`**:

  - This is a `boolean` flag, indicating whether a participant's webcam will be automatically enabled when they join a meeting.

- **`participantId`**:

  - This will be the unique identifier for the participant inside the meeting.
  - It can be used to specify the **unique identifier** which can be linked with **your own database** service.
  - It has to be of `String` type.
  - If you passed `null` then by default VideoSDK will generate unique id for each participant.

- **`multistream`**:

  - This is a `boolean` flag, indicating if the stream should send multiple resolution layers or single resolution layer.

:::caution
You must ensure that the `participantId` is not repeated in the same meeting or room, It will enable VideoSDK to eliminate any participant respect to that `participantId`.
:::

- **`mode`**:

  - There are 3 types of modes:

    1. `SEND_AND_RECV` : Both audio and video streams will be produced and consumed in this mode.

    2. `SIGNALLING_ONLY` : Audio and video streams will not be produced or consumed in this mode.

    3. `RECV_ONLY`: This mode allows only the consumption of audio and video streams without producing any.

  - It has to be of `String` type.
  - If you passed `null` then by default VideoSDK will set `SEND_AND_RECV` mode.

import CautionMessage from '@site/src/theme/CautionMessage';

<CautionMessage sdk="Android SDK" version="v0.2.0" />

- **`multiStream`**:

  - It will specify if the stream should send multiple resolution layers or single resolution layer.

  - It has to be of `boolean` type.

- **`customTracks`**:

  - If you want to set the initial custom tracks, then you can pass map of custom tracks in this paramater.

  - It has to be of `Map<String, CustomStreamTrack>` type.

- **`metaData`**:

  - If you want to provide additional details about a user joining a meeting, such as their profile image, you can pass that information in this parameter.

  - It has to be of `JsonObject` type.

- **`signalingBaseUrl`**:

  - If you want to use a proxy server with the VideoSDK, you can specify your base URL here.

  - It has to be of `String` type.

  - It is Optional parameter.

:::note

If you intend to use a proxy server with the VideoSDK, priorly inform us at support@videosdk.live

:::

- **`preferredProtocol`**:

  - If you want to provide a preferred network protocol for communication, you can specify that in `PreferredProtocol`, with options including `UDP_ONLY`, `UDP_OVER_TCP`, and `TCP_ONLY`.

  - It has to be of `PreferredProtocol` type.

  - It is Optional parameter.

With all the configuration options explained, here is how you can initialize the meeting.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
class MainActivity : AppCompatActivity() {

  fun getToken(): String? {
    //highlight-next-line
    ...
  }

  fun getMeetingId(token: String?): String? {
    //highlight-next-line
    ...
  }

 override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    setContentView(R.layout.activity_main)

    // initialize AndroidNetworking to perform Network call
    AndroidNetworking.initialize(applicationContext)

    //We will fetch token and meetingId and store it in local variables
    val token: String = getToken()
    val meetingId = getMeetingId(token)

    // highlight-start
    // initialize the VideoSDK
    VideoSDK.initialize(this@MainActivity)

    // set token property of VideoSDK
    VideoSDK.config(token)

    // create a new meeting instance
    val meeting: Meeting = VideoSDK.initMeeting(
        this@MainActivity, meetingId, "NAME HERE",
        true, true, null, null, false, null, null
    )
    // highlight-end

    Log.d("VideoSDK", "onCreate: $meetingId")
  }
}
```

</TabItem>

<TabItem value="Java">

```java
public class MainActivity extends AppCompatActivity {

  public String getToken()
  {
    //highlight-next-line
    ...
  }

  public String getMeetingId(String token) {
    //highlight-next-line
    ...
  }

  @Override
  protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);

    // initialize AndroidNetworking to perform Network call
    AndroidNetworking.initialize(getApplicationContext());

    //We will fetch token and meetingId and store it in local variables
    String token = getToken();
    String meetingId = getMeetingId(token);

    // highlight-start
    // initialize the VideoSDK
    VideoSDK.initialize(MainActivity.this);

    // set token property of VideoSDK
    VideoSDK.config(token);

    // create a new meeting instance
    Meeting meeting = VideoSDK.initMeeting(
            MainActivity.this, meetingId, "NAME HERE",
            true, true, null, null, false, null, null
    // highlight-end

    Log.d("VideoSDK", "onCreate: " + meetingId);
  }
}
```

</TabItem>

</Tabs>

### API Reference

The API references for all the methods utilised in this guide are provided below.

- [initMeeting](/android/api/sdk-reference/initMeeting)


---

---
title: Join Meeting | Video SDK
hide_title: true
hide_table_of_contents: false
description: Video SDK and Audio SDK, developers need to implement a token server. This requires efforts on both the front-end and backend.
sidebar_label: Join Meeting
pagination_label: Join Meeting
keywords:
  - audio calling
  - video calling
  - real-time communication
  - collaboration
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: join-meeting
---

# Join Meeting - Android

### Overview

After meeting initialization by `initMeeting()` it returns a new instance of `Meeting`. If you have not initialized a meeting yet, you can [follow the guide here.](./initialize-meeting) However, by default, it will not automatically join the meeting. Hence, to join the meeting you have to call `join()` .

### `join()`

- To join the meeting you can call the `join()` method of `Meeting` class.
- This method can be called after the meeting is initialized using `VideoSDK` class.

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
class MainActivity : AppCompatActivity() {
 override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    setContentView(R.layout.activity_main)
    // initialize the meeting
    ...

    // join meeting
    // highlight-next-line
    meeting!!.join()
  }
}
```

</TabItem>

<TabItem value="Java">

```java
public class MainActivity extends AppCompatActivity {
  @Override
  protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);
    // initialize the meeting
    ...

    // join meeting
    // highlight-next-line
    meeting.join();
  }
}
```

</TabItem>

</Tabs>

### Events associated with Join

Following callbacks are received when a participant is successfully joined.

- [Local Participant](../concept-and-architecture#2-participant) will receive a [`onMeetingJoined`](/android/api/sdk-reference/meeting-class/meeting-event-listener-class#onmeetingjoined) event, when successfully joined.
- [Remote Participant](../concept-and-architecture#2-participant) will receive a [`onParticipantJoined`](/android/api/sdk-reference/meeting-class/meeting-event-listener-class#onparticipantjoined) event with the newly joined `Participant` object from the event callback.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
class MainActivity : AppCompatActivity() {
 override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    setContentView(R.layout.activity_main)
    // initialize the meeting
    ...

    // join meeting
    meeting!!.join()

    // Add event listener for listening upcoming events of meeting
    // highlight-next-line
    meeting!!.addEventListener(meetingEventListener)
  }

  private val meetingEventListener: MeetingEventListener = object : MeetingEventListener(){
    // Event to know meeting is joined
    //highlight-start
    fun onMeetingJoined() {
        Log.d("VideoSDK", "onMeetingJoined")
    }
    //highlight-end
    // Event to know some other participant joined
    //highlight-start
    fun onParticipantJoined(participant: Participant) {
        Log.d("#VideoSDK", participant.displayName + " joined");
    }
    //highlight-end
  }
}
```

</TabItem>

<TabItem value="Java">

```java
public class MainActivity extends AppCompatActivity {
  @Override
  protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);
    // initialize the meeting
    ...

    // join meeting
    meeting.join();

    // Add event listener for listening upcoming events of meeting
    //highlight-next-line
    meeting.addEventListener(meetingEventListener);
  }

  private final MeetingEventListener meetingEventListener=new MeetingEventListener() {
    // Event to know meeting is joined
    //highlight-start
    @Override
    public void onMeetingJoined() {
        Log.d("VideoSDK", "onMeetingJoined");
    }
    //highlight-end

    // Event to know some other participant joined
    //highlight-start
    @Override
    public void onParticipantJoined(Participant participant) {
        Log.d("#VideoSDK", participant.getDisplayName() + " joined");
    }
    //highlight-end
  };
}
```

</TabItem>

</Tabs>

### API Reference

The API references for all the methods and events utilised in this guide are provided below.

- [initMeeting](/android/api/sdk-reference/initMeeting)
- [join()](/android/api/sdk-reference/meeting-class/methods#join)
- [onMeetingJoined()](/android/api/sdk-reference/meeting-class/meeting-event-listener-class#onmeetingjoined)
- [onParticipantJoined()](/android/api/sdk-reference/meeting-class/meeting-event-listener-class#onparticipantjoined)


---

---
title: Leave or End Meeting | Video SDK
hide_title: true
hide_table_of_contents: false
description: Video SDK and Audio SDK, developers need to implement a token server. This requires efforts on both the front-end and backend.
sidebar_label: Leave or End Meeting
pagination_label: Leave or End Meeting
keywords:
  - audio calling
  - video calling
  - real-time communication
  - collaboration
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: leave-end-meeting
---

# Leave or End Meeting - Android

Participant can choose to leave the meeting without removing all the other participants. This is typically done by `Leave Meeting`.

Alternatively, if the participant is the host and the last person remaining in the session, they can choose `End Meeting` by removing all other participants, which will end the session for everyone.

### `leave()`

To leave the meeting without removing all the participant you need to call `leave()` method of `Meeting` class.

### `end()`

To leave the meeting by removing all the participant you need to call `end()` method of `Meeting` class.

:::note
This methods can be called after the meeting is joined successfully.
:::

#### Example

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
  btnLeave!!.setOnClickListener { _: View? ->
    //highlight-next-line
    meeting!!.leave() // Leaving Meeting
  }

  btnEnd!!.setOnClickListener { _: View? ->
    //highlight-next-line
    meeting!!.end() // Ending Meeting
  }
```

</TabItem>

<TabItem value="Java">

```js
  btnLeave.setOnClickListener(new View.OnClickListener() {
      @Override
      public void onClick(View v) {
        //highlight-next-line
        meeting.leave(); // Leaving Meeting
      }
  });

  btnEnd.setOnClickListener(new View.OnClickListener() {
      @Override
      public void onClick(View v) {
        //highlight-next-line
        meeting.end(); // Ending Meeting
      }
  });
```

</TabItem>

</Tabs>

### Events associated with Leave

Following callbacks are received when a participant leaves the meeting.

- [Local Participant](../concept-and-architecture#2-participant) will receive a callback[`onMeetingLeft`](/android/api/sdk-reference/meeting-class/meeting-event-listener-class#onmeetingleft).
- All [remote participants](../concept-and-architecture#2-participant) will receive a callback [`onParticipantLeft`](/android/api/sdk-reference/meeting-class/meeting-event-listener-class#onparticipantleft) with Participant object.

### Events associated with End

Following callbacks are received when a participant ends the meeting.

- All [remote participants](../concept-and-architecture#2-participant) and local participant will receive a callback on [`onMeetingLeft`](/android/api/sdk-reference/meeting-class/meeting-event-listener-class#onmeetingleft) of [`MeetingEventListener`](/android/api/sdk-reference/meeting-class/meeting-event-listener-class) class.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```javascript
private final MeetingEventListener meetingEventListener = new MeetingEventListener() {
  //Event to know meeting is left
  //highlight-start
  override fun onMeetingLeft() {
    Log.d("#VideoSDK", "onMeetingleft()")
  }
  //highlight-end

  //Event to know some other participant left
  //highlight-start
  override fun onParticipantLeft(participant: Participant) {
    Log.d("#VideoSDK", participant.displayName + " left");
  }
  //highlight-end
}
```

</TabItem>

<TabItem value="Java">

```javascript
private final MeetingEventListener meetingEventListener = new MeetingEventListener() {
  //Event to know meeting is left
  //highlight-start
  @Override
  public void onMeetingLeft() {
    Log.d("#VideoSDK", "onMeetingleft()")
  }
  //highlight-end

  //Event to know some other participant left
  //highlight-start
  @Override
  public void onParticipantLeft(Participant participant) {
    Log.d("#VideoSDK", participant.getDisplayName() + " left");
  }
  //highlight-end
}
```

</TabItem>

</Tabs>

### API Reference

The API references for all the methods and events utilised in this guide are provided below.

- [leave()](/android/api/sdk-reference/meeting-class/methods#leave)
- [end()](/android/api/sdk-reference/meeting-class/methods#end)
- [onMeetingLeft()](/android/api/sdk-reference/meeting-class/meeting-event-listener-class#onmeetingleft)
- [onParticipantLeft()](/android/api/sdk-reference/meeting-class/meeting-event-listener-class#onparticipantleft)


---

---
title: Precall Setup | Video SDK
hide_title: true
hide_table_of_contents: false
description: The precall feature allows users to configure their audio and video settings,  before starting a video call, ensuring a smooth and tailored communication experience.
sidebar_label: Precall Setup
pagination_label: Precall Setup
keywords:
  - audio calling
  - video calling
  - real-time communication
  - precall
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: precall
---

# Precall Setup - Android 

Picture this: before diving into the depths of a video call, imagine giving your setup a quick check-up, like a tech-savvy doctor ensuring all systems are a go. That's essentially what a precall experience does- it’s like your extensive debug session before the main code execution—a crucial step in ensuring your app's performance is top-notch.

## Why is it necessary?

Why invest time and effort into crafting a precall experience, you wonder? Well, picture this scenario: your users eagerly join a video call, only to encounter a myriad of technical difficulties—muted microphones, pixelated cameras, and laggy connections. Not exactly the smooth user experience you had in mind, right?

By integrating a robust precall process into your app, developers become the unsung heroes, preemptively addressing potential pitfalls and ensuring that users step into their video calls with confidence.

## Step-by-Step Guide: Integrating Precall Feature

### Step 1: Check and Request Permissions

- Begin by ensuring that your application has the necessary permissions to access user devices, such as the camera, microphone and Bluetooth.
- Utilize the `checkPermissions()` method of the `VideoSDK` class to verify if permissions are granted.
- If the permissions are not granted, the method will request the required permissions.
- `PermissionHandler` is used to manage and handle permission-related events (such as granting, denying, or blocking permissions).
  - `onGranted()`: This method is called when all requested permissions are granted.
  - `onBlocked()`: This method is called when one or more permissions are permanently blocked (i.e., the user has checked "Don't ask   again").
  - `onDenied()`: This method is called when one or more permissions are denied.
  - `onJustBlocked()`: This method is called when one or more permissions are just blocked (i.e., the user has just checked "Don't ask again" for the first time).

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
private fun checkPermissions() {
    val permissionList: MutableList<Permission> = ArrayList()
    permissionList.add(Permission.audio)
    permissionList.add(Permission.video)
    permissionList.add(Permission.bluetooth)
    val options = Permissions.Options()
                  .setRationaleDialogTitle("Info")
                  .setSettingsDialogTitle("Warning")
    VideoSDK.checkPermissions(this,
        permissionList,
        options,
        permissionHandler
    )
}

private val permissionHandler: PermissionHandler = object : PermissionHandler() {
    override fun onGranted() {
      Log.d("VideoSDK Permission", "onGranted: All permissions granted")          
    }
    override fun onBlocked(
      context: Context,
      blockedList: java.util.ArrayList<Permission>
    ): Boolean {
        for (blockedPermission in blockedList) {
              Log.d("VideoSDK Permission", "onBlocked: $blockedPermission")
            }
      return super.onBlocked(context, blockedList)
    }

    override fun onDenied(
      context: Context,
      deniedPermissions: java.util.ArrayList<Permission>
    ) {
        for (deniedPermission in deniedPermissions) {
              Log.d("VideoSDK Permission", "onDenied: $deniedPermission")
            }
      super.onDenied(context, deniedPermissions)
    }

    override fun onJustBlocked(
      context: Context,
      justBlockedList: java.util.ArrayList<Permission>,
      deniedPermissions: java.util.ArrayList<Permission>
      ) {
          for (justBlockedPermission in justBlockedList) {
              Log.d("VideoSDK Permission", "onJustBlocked: $justBlockedPermission")
            }
      super.onJustBlocked(context, justBlockedList, deniedPermissions)
    }
  }
```
</TabItem>

<TabItem value="Java">

```java
private void checkPermissions() {
    List<Permission> permissionList = new ArrayList<>();
    permissionListSDK.add(Permission.audio);
    permissionListSDK.add(Permission.video);
    permissionListSDK.add(Permission.bluetooth);

    Permissions.Options options = new Permissions
      .Options()
      .setRationaleDialogTitle("Info")
      .setSettingsDialogTitle("Warning");

    VideoSDK.checkPermissions(this, permissionList, options, permissionHandler);
}

PermissionHandler permissionHandler = new PermissionHandler() {
    @Override
    public void onGranted() {
      Log.d("VideoSDK Permission", "onGranted: All permissions granted")   
    }

    @Override
    public boolean onBlocked(Context context, ArrayList<Permission> blockedList) {
        for (Permission blockedPermission : blockedList) {
                Log.d("VideoSDK Permission", "onBlocked: " + blockedPermission);
            }
            return super.onBlocked(context, blockedList);
        }

      @Override
      public void onDenied(Context context, ArrayList<Permission> deniedPermissions) {
        for (Permission deniedPermission : deniedPermissions) {
                Log.d("VideoSDK Permission", "onDenied: " + deniedPermission);
            }
            super.onDenied(context, deniedPermissions);
        }

      @Override
      public void onJustBlocked(Context context, ArrayList<Permission> justBlockedList, ArrayList<Permission> deniedPermissions) {
        for (Permission justBlockedPermission : justBlockedList) {
                Log.d("VideoSDK Permission", "onJustBlocked: " + justBlockedPermission);
            }
            super.onJustBlocked(context, justBlockedList, deniedPermissions);
        }
};
```
</TabItem>

</Tabs>


<center>

<img src="https://cdn.videosdk.live/website-resources/docs-resources/android-precall-checkPermission.png" />

</center>


### Step 2: Render Device Lists

- You can fetch and render lists of available video and audio devices using the `getVideoDevices()` and `getAudioDevices()` methods of the VideoSDK class, respectively.
  
<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
private fun getAudioaDevices() {
  
  val audioDevices: Set<AudioDeviceInfo> = VideoSDK.getAudioDevices()
    for (audioDevice in audioDevices) {
        Log.d("VideoSDK", "Audio Device's DeviceId " + audioDevice.deviceId)
        Log.d("VideoSDK", "Audio Device's Label " + audioDevice.label)
        Log.d("VideoSDK", "Audio Device's Kind " + audioDevice.kind)
    }
}

private fun getVideoDevices() {
    val videoDevices: Set<VideoDeviceInfo> = VideoSDK.getVideoDevices()
    for (videoDevice in videoDevices) {
        Log.d("VideoSDK", "Video Device's DeviceId " + videoDevice.deviceId)
        Log.d("VideoSDK", "Video Device's Label " + videoDevice.label)
        Log.d("VideoSDK", "Video Device's Kind " + videoDevice.kind)
      }
}
```
</TabItem>

<TabItem value="Java">

```java

private void getAudioDevices() {
    Set<AudioDeviceInfo> audioDevices = VideoSDK.getAudioDevices();
    for (AudioDeviceInfo audioDevice:
        audioDevices) {
        Log.d("VideoSDK", "Audio Device's DeviceId " + audioDevice.getDeviceId());
        Log.d("VideoSDK", "Audio Device's Label " + audioDevice.getLabel());
        Log.d("VideoSDK", "Audio Device's Kind " + audioDevice.getKind());
    }
}

private void getVideoDevices() {
    Set<VideoDeviceInfo> videoDevices = VideoSDK.getVideoDevices();
    for (VideoDeviceInfo videoDevice:
            videoDevices) {
        Log.d("VideoSDK", "Video Device's DeviceId " + videoDevice.getDeviceId());
        Log.d("VideoSDK", "Video Device's Label " + videoDevice.getLabel());
        Log.d("VideoSDK", "Video Device's Kind " + videoDevice.getKind());
    }        
}
```
</TabItem>

</Tabs>


<center>
<img src="https://cdn.videosdk.live/website-resources/docs-resources/android-precall-audioDeviceList-new.png"  width="300" height="600"/>
</center>


### Step 3: Handle Audio Device Changes

- Implement the `onAudioDeviceChanged()` callback of the `VideoSDK` class to dynamically re-render audio device lists whenever new devices are attached or removed from the system.
- Ensure that users can seamlessly interact with newly connected devices without disruptions.


<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
VideoSDK.setAudioDeviceChangeListener(object : VideoSDK.AudioDeviceChangeEvent {
    override fun onAudioDeviceChanged(
        selectedAudioDevice: AudioDeviceInfo?,
        audioDevices: MutableSet<AudioDeviceInfo>?
    ) {
        Log.d(
            "VideoSDK",
            "Selected Audio Device: " + selectedAudioDevice.label
        )
        for (audioDevice in audioDevices) {
            Log.d("VideoSDK", "Audio Devices" + audioDevice.label)
        }
    }
})
```

</TabItem>

<TabItem value="Java">

```java
VideoSDK.setAudioDeviceChangeListener((selectedAudioDevice, audioDevices) -> {
    Log.d("VideoSDK", "Selected Audio Device: " + selectedAudioDevice.getLabel());
    for (AudioDeviceInfo audioDevice :
            audioDevices) {
        Log.d("VideoSDK", "Audio Devices" + audioDevice.getLabel());
    }
});
```

</TabItem>

</Tabs>



import ReactPlayer from 'react-player'

<ReactPlayer controls autoplay muted loop playing url='https://cdn.videosdk.live/website-resources/docs-resources/handle-new-device-android.mp4' width={"100%"} />

### Step 4: Ensuring the selected devices are used in the Meeting

- Ensure that the status of all relevant devices, such as the microphone and camera (on/off), as well as the selected devices, are correctly configured and passed into the meeting from the precall screen.
- To select a video device, you can either create a custom track with the chosen `VideoDeviceInfo` and pass it to the `initMeeting` method of the `VideoSDK` class, or you can use the `setSelectedVideoDevice()` method of the `VideoSDK` class.
- To select an audio device, use the `setSelectedAudioDevice()` method of the `VideoSDK` class.  
- By ensuring this integration, users can seamlessly transition from the precall setup to the actual meeting while preserving their preferred settings.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
class MainActivity : AppCompatActivity() {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)

        val customTracks: MutableMap<String, CustomStreamTrack> = HashMap()

        // Specify the video device to use in the meeting
        val videoDeviceInfo: VideoDeviceInfo = selectedVideoDeviceInfo

        val videoCustomTrack = VideoSDK.createCameraVideoTrack(
            "h720p_w960p", "front", CustomStreamTrack.VideoMode.TEXT, true,
            this, VideoSDK.getSelectedVideoDevice()
        )
        customTracks["video"] = videoCustomTrack

        VideoSDK.setSelectedVideoDevice(videoDeviceInfo)

        // Specify the audio device to use in the meeting
        val audioDeviceInfo: AudioDeviceInfo = selectedAudioDeviceInfo

        VideoSDK.setSelectedAudioDevice(audioDeviceInfo)

        val meeting: Meeting = VideoSDK.initMeeting(
            this@MainActivity, "meetingId", "John Due", true,
            true, null, null, false, customTracks, null
        );
    }
}
```
</TabItem>

<TabItem value="Java">

```java
public class MainActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        Map<String, CustomStreamTrack> customTracks = new HashMap<>();

        // Specify the video device to use in the meeting
        VideoDeviceInfo videoDeviceInfo = selectedVideoDeviceInfo; 

        CustomStreamTrack videoCustomTrack = VideoSDK.createCameraVideoTrack(
            "h720p_w960p", "front", CustomStreamTrack.VideoMode.TEXT, true,
            this, VideoSDK.getSelectedVideoDevice()
        );        
        customTracks.put("video", videoCustomTrack);

        VideoSDK.setSelectedVideoDevice(videoDeviceInfo);

        // Specify the audio device to use in the meeting
        AudioDeviceInfo audioDeviceInfo = selectedAudioDeviceInfo; 
 
        VideoSDK.setSelectedAudioDevice(audioDeviceInfo);

        Meeting meeting = VideoSDK.initMeeting(
            MainActivity.this, "meetingId", "John Due",true,
            true, null, null, false, customTracks,null
        );
    }
}
```
</TabItem>

</Tabs>

### Step 5: Get Selected Devices

- VideoSDK library provides two methods, `getSelectedVideoDevice()` and `getSelectedAudioDevice()`, which allow us to determine which video and audio devices are currently selected on our Android device.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
private fun getSelectedVideoDevice(){
    Log.d("TAG", "onCreate: " + VideoSDK.getSelectedVideoDevice().label)
}

private fun getSelectedAudioDevice(){
    Log.d("TAG", "onCreate: " + VideoSDK.getSelectedAudioDevice().label)
}
```

</TabItem>

<TabItem value="Java">

```java
private void getSelectedVideoDevice() {
  VideoDeviceInfo selectedVideoDevice = VideoSDK.getSelectedVideoDevice();
  Log.d("TAG", "Selected Video Device Label: " + selectedVideoDevice.getLabel());
}

private void getSelectedAudioDevice() {
  AudioDeviceInfo selectedAudioDevice = VideoSDK.getSelectedAudioDevice();
  Log.d("TAG", "Selected Audio Device Label: " + selectedAudioDevice.getLabel());
}
```

</TabItem>

</Tabs>


By following these step-by-step instructions, you can seamlessly integrate a precall feature into your application, empowering users to optimize their audio and video setup for a superior communication experience.

:::note

You can explore the complete implementation of the Precall feature in the official Android SDK example [available here.](https://github.com/videosdk-live/videosdk-rtc-android-kotlin-sdk-example)

:::

## API Reference

The API references for all the methods utilized in this guide are provided below.

- [checkPermissions](/android/api/sdk-reference/videosdk-class/methods#checkpermissions)
- [getAudioDevices](/android/api/sdk-reference/videosdk-class/methods#getaudiodevices)
- [getVideoDevices](/android/api/sdk-reference/videosdk-class/methods#getvideodevices)
- [setAudioDeviceChangeListener](/android/api/sdk-reference/videosdk-class/events)
- [getSelectedVideoDevice](/android/api/sdk-reference/videosdk-class/properties#getselectedvideodevice)
- [getSelectedAudioDevice](/android/api/sdk-reference/videosdk-class/properties#getselectedaudiodevice)






---

---
title: Sign up for free account Custom Video SDK
hide_title: false
hide_table_of_contents: false
description: Video SDK Sign up. Get started with 10,000 minutes free every month! Programmable Video SDKs and Rest APIs to build up scalable video conferencing applications.
sidebar_label: Get your API key and Secret key
pagination_label: Get your API key and Secret key
keywords:
  - authentication audio calling
  - authentication video calling
  - authentication real-time communication
  - tokens
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: signup-and-create-api
---

import APISecret from '../../../../mdx/introduction/\_api-key.mdx';
import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>
<APISecret title="Get your API key and Secret key" />


---

---
title: Supported Device OS And Architecture
hide_title: false
hide_table_of_contents: false
description: Build customizable real-time video & audio calling applications in Android SDK using Video SDK add live Video & Audio conferencing to your applications.
sidebar_label: Supported Device OS And Architecture
pagination_label: Supported Device OS And Architecture
keywords:
  - android sdk
  - java sdk
  - kotlin sdk
  - chromebook sdk
  - supported device os and architecture
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: supported-device-os-architecture
---

# Supported Device OS and Architecture

:::note
The following device OS version represent the minimum required version to ensure full support for the listed features.
:::

import SupportList from '../../../../src/theme/SupportedListContainer'

<SupportList renderOnlySDKList={true} isiOSSDKInclude={false}/>

<br/>

# Supported ABIs

import SupportABIList from '../../../../src/theme/SupportedABIContainer'

<SupportABIList />


---

---
title: Post Transcription & Summary - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: Post Transcription features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add support for post transcription or captioning to your applications.
sidebar_label: Post Transcription & Summary
pagination_label: Post Transcription & Summary
keywords:
  - Start Post Transcription meeting
  - Stop Post Transcription meeting
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: post-transcribe-meeting
---

# Post Transcription & Summary - Android

This guide will walk you through the necessary steps to enable post-transcription functionality in your application, allowing users to access transcriptions of recorded meetings.

Moreover, VideoSDK offers flexibility in configuring post-time transcription, allowing you to set up webhooks for this purpose.

## Integrating Post Transcription Feature

![alt text](/img/transcription/post-transcription.png)

In the image above, the recording begins with transcription and summary features turned on. This triggers a webhook call for the start of recording. When the recording stops, another webhook is activated. After the recording, our transcriber starts transcribing, which in turn activates a webhook. Once the transcription is finished, it's sent to the summarizer for summary generation, and then another webhook is triggered.

### **Step 1: Configure Post Transcription & Summary**

- In this step, we set up the configuration for post transcription and summary generation. We define the webhook URL where the webhooks will be received.

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
// Webhook URL where, webhooks are received
val webhookUrl = "https://www.example.com"

//highlight-next-line
// Post Transcription Configuration
val prompt = "Write summary in sections like Title, Agenda, Speakers, Action Items, Outlines, Notes and Summary"
val summaryConfig = SummaryConfig(true, prompt)
val modelId = "raman_v1"
val transcription = PostTranscriptionConfig(true, summaryConfig, modelId)
```

</TabItem>

<TabItem value="Java">

```js
// Webhook URL where, webhooks are received
final String webhookUrl = "https://www.example.com";

//highlight-next-line
// Post Transcription Configuration
String prompt = "Write summary in sections like Title, Agenda, Speakers, Action Items, Outlines, Notes and Summary";
SummaryConfig summaryConfig = new SummaryConfig(true, prompt);
String modelId = "raman_v1";
PostTranscriptionConfig transcription = new PostTranscriptionConfig(true, summaryConfig, modelId);
```

</TabItem>

</Tabs>

### **Step 2: Start Recording with Transcription Configuration**

- Once the configuration is set, we initiate the recording process for the meeting, incorporating the transcription configuration we defined earlier.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
// Start Recording
meeting!!.startRecording(webhookUrl, "AWS Directory Path", null, transcription)
```

</TabItem>

<TabItem value="Java">

```js
// Start Recording
meeting.startRecording(webhookUrl, "AWS Directory Path", null, transcription);
```

</TabItem>

</Tabs>

### **Step 3: Stop Recording**

- When the meeting concludes or recording is no longer needed, we stop the recording process.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
// Stop Recording
meeting!!.stopRecording()
```

</TabItem>

<TabItem value="Java">

```js
// Stop Recording
meeting.stopRecording();
```

</TabItem>

</Tabs>

### **Step 4: Fetch Post Transcriptions**

- After the meeting recording is stopped, post transcription and summary data can be obtained using the [Post Transcription API](/api-reference/realtime-communication/fetch-post-transcriptions-summary).

- The API provides information such as the status of transcription, file paths for transcription data in various formats (JSON, SRT, TXT, TSV, VTT), and a summarized text file.

- The transcription document is structured as follows:

```json
{
  "id": "40b0a4ed-9842-40c9-a288-e4b1bf98a90a",
  "status": "completed",
  "roomId": "abc-xyzw-lmno",
  "sessionId": "621497578bea0d0404c35c4c",
  "recordingId": "65d303d6d2c373dfd71b38a2",
  "filePath": "https://cdn.videosdk.live/encoded/videos/dummy.mp4",
  "transcriptionFilePaths": {
    "json": "https://cdn.videosdk.live/transcriptions/dummy/dummy.json",
    "srt": "https://cdn.videosdk.live/transcriptions/dummy/dummy.srt",
    "txt": "https://cdn.videosdk.live/transcriptions/dummy/dummy.txt",
    "tsv": "https://cdn.videosdk.live/transcriptions/dummy/dummy.tsv",
    "vtt": "https://cdn.videosdk.live/transcriptions/dummy/dummy.vtt"
  },
  "summarizedFilePaths": {
    "txt": "https://cdn.videosdk.live/transcriptions/dummy/dummy-summary.txt"
  },
  "userStorage": null,
  "start": "2024-02-27T16:00:36.828Z",
  "end": "2024-02-27T16:01:46.939Z"
}
```

### Example

- The following code snippet allows you to start and stop recording meetings with just a click. When you click the "Start Recording" button, it begins recording the meeting and enables post-transcription, which generates a summary of the meeting's content. Clicking the "Stop Recording" button ends the recording.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
import android.os.Bundle
import android.widget.Button
import android.widget.Toast
import androidx.appcompat.app.AppCompatActivity

class MeetingActivity : AppCompatActivity() {
    private lateinit var meeting: Meeting

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_meeting)

        //initialize a meeting
        //...

        val startButton = findViewById<Button>(R.id.startRecording)
        val stopButton = findViewById<Button>(R.id.stopRecording)

        startButton.setOnClickListener {
            //highlight-start
            // Configuration for post transcription
            val prompt = "Write summary in sections like Title, Agenda, Speakers, Action Items, Outlines, Notes and Summary"
            val summaryConfig = SummaryConfig(true, prompt)
            val modelId = "raman_v1"
            val transcription = PostTranscriptionConfig(true, summaryConfig, modelId)

            // If you don't have a `webhookUrl` or `awsDirPath`, you have to pass null.
            // Start recording with post transcription
            meeting.startRecording("YOUR WEB HOOK URL", "AWS Directory Path", null, transcription)
            //highlight-end
        }

        stopButton.setOnClickListener {
            //highlight-start
            // Stop recording
            meeting.stopRecording()
            //highlight-end
        }
    }
}
```

</TabItem>

<TabItem value="Java">

```js
import android.os.Bundle;
import android.widget.Button;
import android.widget.Toast;
import androidx.appcompat.app.AppCompatActivity;

public class MeetingActivity extends AppCompatActivity {
    private Meeting meeting;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_meeting);

        //initialize a meeting
        //...

        Button startButton = findViewById(R.id.startRecording);
        Button stopButton = findViewById(R.id.stopRecording);

        startButton.setOnClickListener(v -> {
            //highlight-start
            // Configuration for post transcription
            String prompt = "Write summary in sections like Title, Agenda, Speakers, Action Items, Outlines, Notes and Summary";
            SummaryConfig summaryConfig = new SummaryConfig(true, prompt);
            String modelId = "raman_v1";
            PostTranscriptionConfig transcription = new PostTranscriptionConfig(true, summaryConfig, modelId);

            // If you don't have a `webhookUrl` or `awsDirPath`, you have to pass null.
            // Start recording with post transcription
            meeting.startRecording("YOUR WEB HOOK URL", "AWS Directory Path", null, transcription);
            //highlight-end
        });

        stopButton.setOnClickListener(v -> {
            //highlight-start
            // Stop recording
            meeting.stopRecording();
            //highlight-end
        });
    }
}
```

</TabItem>

</Tabs>

:::important

Please be aware that there may be a delay in processing the transcription data after the recording has been stopped. This delay could vary depending on factors such as server load and the duration of the meeting.

:::

### API Reference

The API references for all the methods utilized in this guide are provided below.

- [startRecording()](/android/api/sdk-reference/meeting-class/methods#startrecording)
- [stopRecording()](/android/api/sdk-reference/meeting-class/methods#stoprecording)
- [fetchPostTranscriptions](/api-reference/realtime-communication/fetch-post-transcriptions-summary)


---

---
title: Realtime Transcription - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: Realtime Transcription features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with VideoSDK to add support for realtime transcription or captioning to your applications.
sidebar_label: Realtime Transcription
pagination_label: Realtime Transcription
keywords:
  - Start Realtime Transcription meeting
  - Stop Realtime Transcription meeting
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: realtime-transcribe-meeting
---

# Realtime Transcription - Android

Realtime transcription allows you to transcribe audio content into text in real-time during a session. This guide will walk you through using the `startTranscription()` and `stopTranscription()` functions to manage realtime transcription in your application.

Moreover, VideoSDK offers flexibility in configuring real-time transcription, allowing you to set up webhooks for this purpose.

## Integrating Realtime Transcription Feature

![alt text](/img/transcription/realtime-transcription.png)

The above image represents,

1. **Start Transcription:** The SDK Client initiates real-time transcription using the `startTranscription` method.

2. **Resource Acquisition:** VideoSDK server requests necessary resources from transcription service.

   - If the request is denied, the server sends a `transcription-failed` event to the SDK Client.
   - If the request is successful, the server sends a `onTranscriptionStateChanged` event with status `TRANSCRIPTION_STARTED` to the client, indicating that transcription has begun.

3. **Transcription Data:** As transcription progresses, the client receives `onTranscriptionText` event with data such as the text itself, participant ID, and timestamp.

4. **Stop Transcription:** When the client decides to stop transcription, it informs the VideoSDK server to release resources.
   - The server then sends a `onTranscriptionStateChanged` event with status `TRANSCRIPTION_STOPPED` to confirm that transcription has ended and resources are released.

### **Step 1: Configure Realtime Transcription**

- In this step, we set up the configuration for realtime transcription. We define the webhook URL where the webhooks will be received.

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
// Webhook URL where, webhooks are received
val webhookUrl = "YOUR_WEBHOOK_URL"

//highlight-next-line
// Realtime Transcription Configuration
val summaryConfig = SummaryConfig(
    true,
    "Write summary in sections like Title, Agenda, Speakers, Action Items, Outlines, Notes and Summary"
)
val transcription = TranscriptionConfig(
    webhookUrl,
    summaryConfig
)
```

</TabItem>

<TabItem value="Java">

```js
// Webhook URL where, webhooks are received
final String webhookUrl = "YOUR_WEBHOOK_URL";

//highlight-next-line
// Realtime Transcription Configuration
SummaryConfig summaryConfig = new SummaryConfig(
    true,
    "Write summary in sections like Title, Agenda, Speakers, Action Items, Outlines, Notes and Summary"
);
TranscriptionConfig transcription = new TranscriptionConfig(
    webhookUrl,
    summaryConfig
);
```

</TabItem>

</Tabs>

### **Step 2: Listen for the transcription events**

- Here, we configure the callback methods for transcription events.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
private val meetingEventListener: MeetingEventListener = object : MeetingEventListener() {
  override fun onTranscriptionStateChanged(data: JSONObject) {
    try {
        val status = data.getString("status")
        val id = data.getString("id")
        when (status) {
            TranscriptionState.TRANSCRIPTION_STARTING.name -> Log.d("onTranscriptionStateChanged", "Realtime Transcription is starting, ID: $id")
            TranscriptionState.TRANSCRIPTION_STARTED.name -> Log.d("onTranscriptionStateChanged", "Realtime Transcription is started, ID: $id")
            TranscriptionState.TRANSCRIPTION_STOPPING.name -> Log.d("onTranscriptionStateChanged", "Realtime Transcription is stopping, ID: $id")
            TranscriptionState.TRANSCRIPTION_STOPPED.name -> Log.d("onTranscriptionStateChanged", "Realtime Transcription is stopped, ID: $id")
            else -> Log.d("onTranscriptionStateChanged", "Unknown transcription state: $status, ID: $id")
        }
    } catch (e: JSONException) {
        Log.e("onTranscriptionStateChanged", "Error parsing transcription state", e)
    }
  }

  override fun onTranscriptionText(data: TranscriptionText) {
    val participantId: String = data.participantId
    val participantName: String = data.participantName
    val text: String = data.text
    val timestamp: Int = data.timestamp
    val type: String = data.type

    Log.d("onTranscriptionText", "$participantName: $text $timestamp")
  }
}

override fun onCreate(savedInstanceState: Bundle?) {
  //...

  // add listener to meeting
  //highlight-next-line
  meeting!!.addEventListener(meetingEventListener)
}
```

</TabItem>

<TabItem value="Java">

```js
private final MeetingEventListener meetingEventListener = new MeetingEventListener() {
  @Override
    public void onTranscriptionStateChanged(JSONObject data) {
        try {
            String status = data.getString("status");
            String id = data.getString("id");

            if (TranscriptionState.TRANSCRIPTION_STARTING.name().equals(status)) {
                Log.d("onTranscriptionStateChanged", "Realtime Transcription is starting, ID: " + id);
            }
            else if (TranscriptionState.TRANSCRIPTION_STARTED.name().equals(status)) {
                Log.d("onTranscriptionStateChanged", "Realtime Transcription is started, ID: " + id);
            }
            else if (TranscriptionState.TRANSCRIPTION_STOPPING.name().equals(status)) {
                Log.d("onTranscriptionStateChanged", "Realtime Transcription is stopping, ID: " + id);
            }
            else if (TranscriptionState.TRANSCRIPTION_STOPPED.name().equals(status)) {
                Log.d("onTranscriptionStateChanged", "Realtime Transcription is stopped, ID: " + id);
            }
            else {
                Log.d("onTranscriptionStateChanged", "Unknown transcription state: " + status + ", ID: " + id);
            }
        } catch (JSONException e) {
            Log.e("onTranscriptionStateChanged", "Error parsing transcription state", e.getMessage());
        }
    }

    @Override
    public void onTranscriptionText(TranscriptionText data) {
        String participantId = data.getParticipantId();
        String participantName = data.getParticipantName();
        String text = data.getText();
        int timestamp = data.getTimestamp();
        String type = data.getType();

        Log.d("onTranscriptionText", participantName + ": " + text + " " + timestamp);
    }
}

@Override
protected void onCreate(Bundle savedInstanceState) {
  //...

  // add listener to meeting
  //highlight-next-line
  meeting.addEventListener(meetingEventListener);
}
```

</TabItem>

</Tabs>

### **Step 3: Start realtime transcription**

- Initiate the realtime transcription using the `startTranscription()` method.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
fun startRealtimeTranscription() {
    // Webhook URL where, webhooks are received
    val webhookUrl = "YOUR_WEBHOOK_URL"

    //highlight-next-line
    // Realtime Transcription Configuration
    val summaryConfig = SummaryConfig(
        true,
        "Write summary in sections like Title, Agenda, Speakers, Action Items, Outlines, Notes and Summary"
    )
    val transcription = TranscriptionConfig(
        webhookUrl,
        summaryConfig
    )

    //highlight-next-line
    meeting!!.startTranscription(transcription)
}
```

</TabItem>

<TabItem value="Java">

```js
private void startRealtimeTranscription() {
    // Webhook URL where, webhooks are received
    final String webhookUrl = "YOUR_WEBHOOK_URL";

    //highlight-next-line
    // Realtime Transcription Configuration
    SummaryConfig summaryConfig = new SummaryConfig(
        true,
        "Write summary in sections like Title, Agenda, Speakers, Action Items, Outlines, Notes and Summary"
    );
    TranscriptionConfig transcription = new TranscriptionConfig(
        webhookUrl,
        summaryConfig
    );

    //highlight-next-line
    meeting.startTranscription(transcription);
}
```

</TabItem>

</Tabs>

### **Step 4: Stop realtime transcription**

- Terminate the realtime transcription using the `stopTranscription() `method.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
fun stopRealtimeTranscription() {
    meeting!!.stopTranscription()
}
```

</TabItem>

<TabItem value="Java">

```js
private void stopRealtimeTranscription() {
    meeting.stopTranscription();
}
```

</TabItem>

</Tabs>

:::important

You can access a summary of your realtime transcription using the **[<u>Fetch Realtime Transcription API</u>](/api-reference/realtime-communication/fetch-a-realtime-transcription)**.

:::

### Example

- The following code snippet allows you to start and stop realtime transcription with just a click. When you click the "Start Realtime Transcription" button, it begins realtime transcription. Clicking the "Stop Realtime Transcription" button ends the realtime transcription.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
import android.os.Bundle
import android.util.Log
import android.widget.Button
import androidx.appcompat.app.AppCompatActivity
import org.json.JSONObject

class MeetingActivity : AppCompatActivity() {
    private lateinit var meeting: Meeting

    // add meetingEventListener to handle transcription events
    private val meetingEventListener = object : MeetingEventListener {
        override fun onTranscriptionStateChanged(data: JSONObject) {
            val status = data.getString("status")
            Log.d("MeetingActivity", "Transcription status: $status")
        }

        override fun onTranscriptionText(data: TranscriptionText) {
            val participantId = data.participantId
            val participantName = data.participantName
            val text = data.text
            val timestamp = data.timestamp
            val type = data.type

            Log.d("MeetingActivity", "$participantName: $text $timestamp")
        }
    }

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_meeting)

        //initialize a meeting
        //...

        val startButton: Button = findViewById(R.id.startTranscriptionButton)
        val stopButton: Button = findViewById(R.id.stopTranscriptionButton)

        startButton.setOnClickListener { startRealtimeTranscription() }
        stopButton.setOnClickListener { stopRealtimeTranscription() }

        // add listener to meeting
        meeting!!.setEventListener(meetingEventListener)
    }

    private fun startRealtimeTranscription() {
        // Configuration for realtime transcription
        val summaryConfig = SummaryConfig(
            true,
            "Write summary in sections like Title, Agenda, Speakers, Action Items, Outlines, Notes and Summary"
        )
        val transcriptionConfig = TranscriptionConfig(
            null,
            summaryConfig
        )

        // Call to start transcription with the specified configuration
        meeting!!.startTranscription(transcriptionConfig)
    }

    private fun stopRealtimeTranscription() {
        // Call to stop transcription
        meeting!!.stopTranscription()
    }
}
```

</TabItem>

<TabItem value="Java">

```js
import android.os.Bundle;
import android.util.Log;
import android.widget.Button;
import android.widget.Toast;
import androidx.appcompat.app.AppCompatActivity;

public class MeetingActivity extends AppCompatActivity {
    private Meeting meeting;

    // add meetingEventListener to handle transcription events
    private final MeetingEventListener meetingEventListener = new MeetingEventListener() {
        @Override
        public void onTranscriptionStateChanged(JSONObject data) {
            String status = data.getString("status");
            Log.d("MeetingActivity", "Transcription status: " + status);
        }

        @Override
        public void onTranscriptionText(TranscriptionText data) {
            String participantId = data.getParticipantId();
            String participantName = data.getParticipantName();
            String text = data.getText();
            int timestamp = data.getTimestamp();
            String type = data.getType();

            Log.d("MeetingActivity", participantName + ": " + text + " " + timestamp);
        }
    };

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_meeting);

        //initialize a meeting
        //...

        Button startButton = findViewById(R.id.startTranscriptionButton);
        Button stopButton = findViewById(R.id.stopTranscriptionButton);

        startButton.setOnClickListener(v -> startRealtimeTranscription());
        stopButton.setOnClickListener(v -> stopRealtimeTranscription());

        // add listener to meeting
        meeting.setEventListener(meetingEventListener);
    }

    private void startRealtimeTranscription() {
        // Configuration for realtime transcription
        SummaryConfig summaryConfig = new SummaryConfig(
            true,
            "Write summary in sections like Title, Agenda, Speakers, Action Items, Outlines, Notes and Summary"
        );
        TranscriptionConfig transcriptionConfig = new TranscriptionConfig(
            null,
            summaryConfig
        );

        // Call to start transcription with the specified configuration
        meeting.startTranscription(transcriptionConfig);
    }

    private void stopRealtimeTranscription() {
        // Call to stop transcription
        meeting.stopTranscription();
    }
}
```

</TabItem>

</Tabs>

### API Reference

The API references for all the methods utilized in this guide are provided below.

- [startTranscription()](/android/api/sdk-reference/meeting-class/methods#starttranscription)
- [stopTranscription()](/android/api/sdk-reference/meeting-class/methods#stoptranscription)
- [onTranscriptionStateChanged](/android/api/sdk-reference/meeting-class/meeting-event-listener-class#ontranscriptionstatechanged)
- [onTranscriptionText](/android/api/sdk-reference/meeting-class/meeting-event-listener-class#ontranscriptiontext)


---

---
title: Integrate Banuba SDK with Android SDK - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: Describes how to integrate Banuba SDK with videosdk.live using Android SDK to enhance video calls with real-time face filters and virtual backgrounds.
sidebar_label: "Banuba Integration"
pagination_label: "Banuba Integration"
keywords:
  - android sdk
  - java sdk
  - kotlin sdk
  - banuba
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: banuba-integration
---

# How to integrate Banuba SDK with Android Video SDK?

The Banuba SDK is a software development kit that enables developers to integrate advanced augmented reality (AR) features, such as real-time face filters and effects, into their apps. It is widely used for creating engaging video experiences in applications like video conferencing, live streaming, and social media platforms.

<center>
<img src='https://assets.videosdk.live/images/android-banuba.png' style={{height: '400px'}}/>
</center>

To integrate the Banuba SDK with Android Video SDK, follow these steps:

### Step 1: Get Banuba Token

- To begin working with the Banuba SDK in your project, you'll need Banuba's client token.
- You can obtain this token by following the instructions in Banuba's documentation at [banuba.com](https://www.banuba.com/)

### Step 2: Add Banuba SDK dependencies

- Add custom maven repo to your `settings.gradle`:

```js title="settings.gradle"
dependencyResolutionManagement {
    repositoriesMode.set(RepositoriesMode.FAIL_ON_PROJECT_REPOS)
    repositories {
        google()
        mavenCentral()
        maven {
            name = "GitHubPackages"
            url = uri("https://maven.pkg.github.com/sdk-banuba/banuba-sdk-android")
            credentials {
                username = "sdk-banuba"
                password = "\u0067\u0068\u0070\u005f\u004a\u0067\u0044\u0052\u0079\u0049\u0032\u006d\u0032\u004e\u0055\u0059\u006f\u0033\u0033\u006b\u0072\u0034\u0049\u0069\u0039\u0049\u006f\u006d\u0077\u0034\u0052\u0057\u0043\u0064\u0030\u0052\u0078\u006d\u0045\u0069"
            }
        }
        maven { url 'https://jitpack.io' }
        maven { url "https://maven.aliyun.com/repository/jcenter" }
}}
```

- Add Banuba SDK and VideoSDK dependencies in `app/build.gradle` file.

```js title="app/build.gradle"
dependencies {
  // Banuba SDK dependencies
    implementation "com.banuba.sdk:banuba_sdk:1+"
  // Video SDK dependencies
    implementation 'live.videosdk:rtc-android-sdk:0.3.0'
  // other app dependencies
  }
```
### Step 3: Initialization of Banuba SDK

1. Create a `MainApplication` class that extends `android.app.Application`.

2. Within the `MainApplication` class, create a KEY field to store the token you generated from Banuba. This token will be used to initialize the `BanubaSdkManager`.

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js title="MainApplication.kt"
class MainApplication : Application() {
    override fun onCreate() {
        super.onCreate()

        //...
        val key = "Banuba Client Token"
        BanubaSdkManager.initialize(requireNonNull(applicationContext), key)
    }

    override fun onTerminate() {
        BanubaSdkManager.deinitialize()
        super.onTerminate()
    }
}
```

</TabItem>

<TabItem value="Java">
  
```js title="MainApplication.java"
public class MainApplication extends Application {
    @Override
    public void onCreate() {
        super.onCreate();

        //...
        String KEY ="Banuba Client Token";
        BanubaSdkManager.initialize(requireNonNull(getApplicationContext()), KEY);
    }
    @Override
    public void onTerminate() {
        BanubaSdkManager.deinitialize();
        super.onTerminate();
    }
}
```

</TabItem>

</Tabs>

### Step 4: Add effects into your project

- Create an effects folder under the assets directory in your project and add the filters you want to use. You can download test filters from here [Effects](https://docs.banuba.com/face-ar-sdk-v1/overview/demo_face_filters)

<div style={{textAlign: 'center'}}>

![Banuba SDK effects folder](/img/android/banuba/banuba_effects.png)

</div>

### Step 5: Integration of BanubaProcessor

- The `BanubaProcessor` class will implement the `VideoFrameProcessor` interface from VideoSDK.
- The `VideoFrameProcessor` interface provides `onFrameCaptured()` method, which is invoked when a new video frame is captured.
- The `onFrameCaptured()` method is used to manipulate the `VideoFrame` in order to achieve the desired effects.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js title="BanubaProcessor.kt"
class BanubaProcessor : VideoFrameProcessor {
    private var mPlayer: Player = Player()
    private var mFrameOutput: FrameOutput? = null
    private val eglContext: EglBase.Context = EglBase.create().eglBaseContext
    private var mSurfaceTextureHelper: SurfaceTextureHelper? = null
    private var videoFrame: VideoFrame? = null
    private val streamInput: StreamInput = StreamInput()

    init {
        mSurfaceTextureHelper = SurfaceTextureHelper.create("CaptureThread", eglContext, false)
    }

    // set a visual effect in the Banuba Player
    fun setEffect(effect: String) {
        mPlayer.loadAsync("effects/$effect")
        mPlayer.play()
    }

    // remove any applied effects
    fun removeEffect() {
        mPlayer.loadAsync("")
    }

    fun removePlayer() {
        // close the player when it's no longer needed
        mPlayer.close()
    }

    // method to initialize the frame output for video processing
    private fun initOutput(): VideoFrame? {
        val handler = mSurfaceTextureHelper!!.handler
        mFrameOutput = FrameOutput { iOutput, framePixelBuffer ->
            handler.post {
                val i420Buffer = JavaI420Buffer.wrap(
                    framePixelBuffer.width,
                    framePixelBuffer.height,
                    framePixelBuffer.getPlane(0),
                    framePixelBuffer.getBytesPerRowOfPlane(0),
                    framePixelBuffer.getPlane(1),
                    framePixelBuffer.getBytesPerRowOfPlane(1),
                    framePixelBuffer.getPlane(2),
                    framePixelBuffer.getBytesPerRowOfPlane(2),
                    null
                )
                videoFrame = VideoFrame(i420Buffer, 0, System.nanoTime())
            }
        }
        mFrameOutput!!.format = FramePixelBufferFormat.I420_BT601_FULL

        handler.postDelayed({
            mFrameOutput?.close()
        }, 2000)

        // attach the FrameOutput to the player for rendering
        mPlayer.use(mFrameOutput)

        // Return the processed video frame
        return videoFrame
    }

     // called whenever a new video frame is captured
    override fun onFrameCaptured(videoFrame: VideoFrame?): VideoFrame? {
        if (videoFrame != null) {
            // Determine the camera orientation based on the rotation of the video frame
            val cameraOrientation = CameraOrientation.values()[(videoFrame.rotation / 90) % 4]
            val orientation = FullImageData.Orientation(cameraOrientation, true, 0)
            val i420Buffer = videoFrame.buffer.toI420()

            // create FullImageData using the frame data and orientation
            val fullImageData = FullImageData(
                Size(i420Buffer.width, i420Buffer.height),
                i420Buffer.dataY,
                i420Buffer.dataU,
                i420Buffer.dataV,
                i420Buffer.strideY,
                i420Buffer.strideU,
                i420Buffer.strideV,
                1, 1, 1,
                orientation
            )

            val frameData = FrameData.create() ?: return null
            frameData.addFullImg(fullImageData)
            i420Buffer.release()
            streamInput.push(frameData, videoFrame.timestampNs)

            // attach the StreamInput to the player for further processing
            mPlayer.use(streamInput)

            // return the processed video frame
            return initOutput()
        }
        return null
    }
}
```

</TabItem>

<TabItem value="Java">

```js title="BanubaProcessor.java"
public class BanubaProcessor implements VideoFrameProcessor {
    private Player mPlayer;
    private FrameOutput mFrameOutput;
    private final EglBase.Context eglContext = EglBase.create().getEglBaseContext();
    private SurfaceTextureHelper mSurfaceTextureHelper;
    VideoFrame videoFrame;
    final StreamInput streamInput = new StreamInput();

    public BanubaProcessor (){
        mSurfaceTextureHelper = SurfaceTextureHelper.create("CaptureThread", eglContext, false);
        mPlayer = new Player();
    }
    // set a visual effect in the Banuba Player
    public void setEffect(String effect)
    {
        mPlayer.loadAsync("effects/" + effect);
        mPlayer.play();
    }
    // remove any applied effects
    public void removeEffect()
    {
        mPlayer.loadAsync("");
    }
    public void removePlayer()
    {
        // close the player when it's no longer needed
        mPlayer.close();
    }
    // method to initialize the frame output for video processing
    private VideoFrame initOutput() {
        final Handler handler = mSurfaceTextureHelper.getHandler();
        mFrameOutput = new FrameOutput((iOutput, framePixelBuffer) -> {
            handler.post(() -> {

                final JavaI420Buffer i420buffer = JavaI420Buffer.wrap(
                        framePixelBuffer.getWidth(),
                        framePixelBuffer.getHeight(),
                        framePixelBuffer.getPlane(0),
                        framePixelBuffer.getBytesPerRowOfPlane(0),
                        framePixelBuffer.getPlane(1),
                        framePixelBuffer.getBytesPerRowOfPlane(1),
                        framePixelBuffer.getPlane(2),
                        framePixelBuffer.getBytesPerRowOfPlane(2),
                        null);
                videoFrame = new VideoFrame(i420buffer, 0, System.nanoTime());
            });
        });
        mFrameOutput.setFormat(FramePixelBufferFormat.I420_BT601_FULL);
        
        handler.postDelayed(() -> {
            mFrameOutput.close();
        },2000);

        // attach the FrameOutput to the player for rendering
        mPlayer.use(mFrameOutput);

        // return the processed video frame
        return videoFrame;
    }
    // called whenever a new video frame is captured
    @Override
    public VideoFrame onFrameCaptured(VideoFrame videoFrame) {
        if(videoFrame != null) {
            // determine the camera orientation based on the rotation of the video frame
            final CameraOrientation cameraOrientation = CameraOrientation.values()[(videoFrame.getRotation() / 90) % 4];
            final FullImageData.Orientation orientation = new FullImageData.Orientation(cameraOrientation, true, 0);
            final VideoFrame.I420Buffer i420Buffer = videoFrame.getBuffer().toI420();
            // create FullImageData using the frame data and orientation
            final FullImageData fullImageData = new FullImageData(
                    new Size(i420Buffer.getWidth(), i420Buffer.getHeight()),
                    i420Buffer.getDataY(),
                    i420Buffer.getDataU(),
                    i420Buffer.getDataV(),
                    i420Buffer.getStrideY(),
                    i420Buffer.getStrideU(),
                    i420Buffer.getStrideV(),
                    1, 1, 1,
                    orientation);
            final FrameData frameData = Objects.requireNonNull(FrameData.create());
            frameData.addFullImg(fullImageData);
            i420Buffer.release();
            streamInput.push(frameData, videoFrame.getTimestampNs());
            // attach the StreamInput to the player for further processing
            mPlayer.use(streamInput);
            // return the processed video frame
            return initOutput();
        }
        return null;
    }
}
```

</TabItem>

</Tabs>

### Step 5: Use filters in the Meeting

- First, create an instance of `BanubaProcessor` class and pass it to the `applyVideoProcessor()` method of `VideoSDK` class.
- Next, use the `setEffect` method on the instance of `BanubaProcessor` class apply the desired effect.
- To apply video filters from the beginning of the meeting, you can call `setEffect` method in `onMeetingJoined` event.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">


```js title="MainActivity.kt"
private val meetingEventListener = object : MeetingEventListener {
    override fun onMeetingJoined() {
        val banubaProcessor = BanubaProcessor()
        VideoSDK.applyVideoProcessor(banubaProcessor)
        //here you can pass any effect that you want to apply
        banubaProcessor.setEffect("PineappleGlasses")
    }
}
```

</TabItem>

<TabItem value="Java">

```js title="MainActivity.java"
private final MeetingEventListener meetingEventListener = new MeetingEventListener() {
    @Override
    public void onMeetingJoined() {
        BanubaProcessor banubaProcessor = new BanubaProcessor();
        VideoSDK.applyVideoProcessor(banubaProcessor);
        //here you can pass any effect that you want to apply
        banubaProcessor.setEffect("PineappleGlasses");
    }
};
```

</TabItem>

</Tabs>

:::tip

Stuck anywhere? Check out this [Code Sample of Banuba Intergation with Android-SDK](https://github.com/videosdk-live/videosdk-rtc-android-sdk-banuba-example.git) on GitHub

:::


---

---
sidebar_label: Overview
pagination_label: Overview
---

# Video Processor - Android

VideoSDK allows you to add custom effects to your video stream before it's transmitted during video calls. This lets you enhance your video in creative ways or achieve specific functionalities.

### Understanding Video Processing

Video processing involves manipulating raw video data (frames) captured by your camera. You can create native processors to enhance video streams during meetings.


### The `VideoFrameProcessor` Interface

The `VideoFrameProcessor` interface defines a way for your code to interact with the video stream. It essentially lets you intercept each frame before it's sent and apply your processing logic.

#### Key Function: `onFrameCaptured`

This is the heart of video processing with VideoSDK. Whenever a new video frame is captured by your camera, the `onFrameCaptured` function is called. This function provides you with the raw frame data, allowing you to modify it as needed.

### How it Works:

1. **Implement the Interface:** Create a class that implements the `VideoFrameProcessor` interface. Within this class, define the `onFrameCaptured` function.

2. **Process the Frame:** In the `onFrameCaptured` function, access the raw video frame data. Apply your desired effects or manipulations to this data.

3. **Return the Processed Frame:** After processing the frame, return the modified version to VideoSDK. This processed frame will then be transmitted during the video call.

4. **Apply the Processor:** To apply a processor, pass an object of your class as a parameter to the `applyVideoProcessor()` method of the `VideoSDK` class.

5. **Remove the Processor:** To stop applying the selected video processor, use the `removeVideoProcessor()` method of the `VideoSDK` class.

## API Reference

The API references for all the methods utilized in this guide are provided below.

- [applyVideoProcessor()](/android/api/sdk-reference/videosdk-class/methods#applyvideoprocessor)
- [removeVideoProcessor()](/android/api/sdk-reference/videosdk-class/methods#removevideoprocessor)


---

---
title: Architecture of Real time communication API
hide_title: false
hide_table_of_contents: false
description: Architecture of Real time communication API is quite simple to understand before jumping directly to build application.
sidebar_label: Architecture
pagination_label: Architecture
keywords:
  - RTC API
  - RTC SDK
  - video API
  - audio rooms API
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: architecture
---

import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>

## Architecture

import Mermaid from '@theme/Mermaid';

<Mermaid chart={`sequenceDiagram Host->>App Server: Request for token; App Server->>Host: Received token; Host->>App Server: Request for meetingId; App Server->>VideoSDK Server: Request for meetingId; VideoSDK Server->>App Server: Sending meetingId; App Server->>Host: Received meetingId; Host->>Participants: Broadcast meetingId; Host->>App Server: Start Meeting; Participants-->>App Server: Join Meeting; Participants->>App Server: Request for token; App Server->>Participants: Received token; Participants->>App Server: Validate meetingId; Participants->>App Server: Leave Meeting; Host->>App Server: End Meeting;`}/>

## Terminology

### Meeting

A Meeting represents real-time audio, video, and/or screen-share session, and is the basic building block for media sharing among participants.

### Participants

Participants are the client applications that are connected to a Meeting and shares video & audio media with one another.

### Local Participant

Participant producing audio or video stream from the local client's media sources

### Streams

Streams are indiviual video & audio streams produced by the participants in the meeting

### Active Speaker

Active speaker represents the participant who is currently producing highest decibels audio stream (in other words speaking)

### Active presenter

Active presenter is the participant who is currently sharing his/her screen as a video stream

### Main participant

Main participant represents the client who shall be displayed on the main screen indicating that he/she is either presenting or speaking

---


---

---
---

import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>

---

---
sidebar_position: 1
sidebar_label: Combine Stream Start
hide_table_of_contents: true
---

# Start All Streams

import Method from '../../src/theme/RestApiMethodContainer'
import data from './data.json'
import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>
<Method
{...data.startCombineStream}
/>


---

---
sidebar_position: 1
sidebar_label: Combine Stream Stop
hide_table_of_contents: true
---

# Stop All streams

import Method from '../../src/theme/RestApiMethodContainer'
import data from './data.json'
import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>
<Method
{...data.stopCombineStream}
/>


---

---
sidebar_position: 1
sidebar_label: Create Room
hide_table_of_contents: true
---

# Create Room

import Method from '../../src/theme/RestApiMethodContainer'
import data from './data.json'
import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>
<Method
{...data.createRoom}
/>


---

---
sidebar_position: 1
sidebar_label: Fetch HLS Stream using hlsStreamId
hide_table_of_contents: true
---

# Fetch HLS Stream using `hlsStreamId`

import Method from '../../src/theme/RestApiMethodContainer'
import data from './data.json'
import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>
<Method
{...data.fetchHLSstreamUsingHLSstreamId}
/>


---

---
sidebar_position: 1
sidebar_label: Fetch HLS Streams
hide_table_of_contents: true
---

# Fetch Livestream

import Method from '../../src/theme/RestApiMethodContainer'
import data from './data.json'
import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>
<Method
{...data.fetchHLSstreams}
/>


---

---
sidebar_position: 1
sidebar_label: Fetch Livestream using livestreamId
hide_table_of_contents: true
---

# Fetch Livestream using `livestreamId`

import Method from '../../src/theme/RestApiMethodContainer'
import data from './data.json'
import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>
<Method
{...data.fetchLivestreamUsingLivestreamId}
/>


---

---
sidebar_position: 1
sidebar_label: Fetch Livestream
hide_table_of_contents: true
---

# Fetch Livestream

import Method from '../../src/theme/RestApiMethodContainer'
import data from './data.json'
import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>
<Method
{...data.fetchLivestreams}
/>


---

---
sidebar_position: 1
sidebar_label: Fetch Participants
hide_table_of_contents: true
---

# Fetch Participants

import Method from '../../src/theme/RestApiMethodContainer'
import data from './data.json'
import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>
<Method
{...data.fetchParticipants}
/>


---

---
sidebar_position: 1
sidebar_label: Fetch Recording using recordingId
hide_table_of_contents: true
---

# Fetch Recording using `recordingId`

import Method from '../../src/theme/RestApiMethodContainer'
import data from './data.json'
import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>
<Method
{...data.fetchRecordingUsingRecordingId}
/>


---

---
sidebar_position: 1
sidebar_label: Fetch Recording
hide_table_of_contents: true
---

# Fetch Recording

import Method from '../../src/theme/RestApiMethodContainer'
import data from './data.json'
import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>
<Method
{...data.fetchRecordings}
/>


---

---
sidebar_position: 3
sidebar_label: Fetch Room
hide_table_of_contents: true
---

# Fetch Room

import Method from '../../src/theme/RestApiMethodContainer'
import data from './data.json'
import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>
<Method
{...data.fetchRoom}
/>


---

---
sidebar_position: 1
sidebar_label: Fetch a Session
hide_table_of_contents: true
---

# Fetch a Session

import Method from '../../src/theme/RestApiMethodContainer'
import data from './data.json'
import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>
<Method
{...data.fetchSessionUsingSessionId}
/>


---

---
sidebar_position: 1
sidebar_label: Fetch Sessions
hide_table_of_contents: true
---

# Fetch Sessions

import Method from '../../src/theme/RestApiMethodContainer'
import data from './data.json'
import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>
<Method
{...data.fetchSessions}
/>


---

---
sidebar_position: 1
---

import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>

# Customise Interface

Cooming soon


---

---
sidebar_position: 1
---

import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>

# Embeded meeting

Coming Soon.

![Build a embeded meeting.](/img/Zujonow-whitelabel-desktop-min.jpg)


---

---
sidebar_position: 1
---

import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>

# Explore console

Coming Soon.


---

---
sidebar_position: 1
---

import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>

# What we offer

## Explore amazing features

Let's discover **Realtime SDK features in less than 5 minutes**.

### ✅ : Shipped

### 🚧 : Working on it

### ❌ : Not implemented

## Features

|                                                      | Embeded | SDK |
| ---------------------------------------------------- | ------- | --- |
| video & audio chat functionality                     | ✅      | ✅  |
| Customised interface for video & audio               | 🚧      | ✅  |
| Adaptive video & audio calling                       | ✅      | ✅  |
| Cross browser and device support                     | 🚧      | ✅  |
| Screen sharing                                       | ✅      | ✅  |
| Interactive Whiteboard                               | ✅      | ✅  |
| Auto switching on active speakers                    | ✅      | ✅  |
| Grid Layouts                                         | ✅      | ✅  |
| Participant List                                     | ✅      | ✅  |
| Raise Hand                                           | ✅      | ✅  |
| Text chat and file sharing                           | ✅      | ✅  |
| Cloud and local recording                            | ✅      | ✅  |
| Console analytics and operations                     | ✅      | ✅  |
| Compatible with JS, React, Electron, Vue and Angular | ✅      | ✅  |
| Compatible with React Native, Flutter                | 🚧      | ✅  |
| Compatible with native Android, IOS                  | 🚧      | 🚧  |


---

---
sidebar_position: 1
---

import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>

# Integrate SDK with mobile, tab and tv

## @videosdk.live/react-native-sdk

`@videosdk.live/react-native-sdk` is hybrid sdk for the react native. It inherits `js` and `react` sdk to provide better support and fast development in mobile devices.

![Build a React Native video chat app with @videosdk.live/react-native-sdk.](/img/Zujonow-whitelabel-mobile-landscape.jpg)


---

---
sidebar_position: 1
---

import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>

# What next?


---

---
title: Introduction to Real time communication API
hide_title: false
hide_table_of_contents: false
description: RTC SDK provides wide range of features to build your own custom video chat application without worrying about performance issues and scaling.
sidebar_label: Introduction
pagination_label: Introduction
keywords:
  - RTC API
  - RTC SDK
  - video API
  - audio rooms API
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: intro
---

import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>

# Introduction

Real-time comunication SDK is built with blend of webRTC and optimised UDP protocol. Our SDK helps developers to add real-time video & audio calls to any mobile app or web application.

With our `embeded-sdk`, you can embeded a video call widget in your web application. It supports 98% of the devices across all platforms and adaptive video calling for better quality calls with low latency. Developers can also customise `embeded-sdk` to make it more convenient for your application.

Our research team has worked hard to handled all the edge cases so you just have to focus on what matters.

![Embeded SDK Example to add video call widget in your web application](/img/Zujonow-whitelabel-min.jpg)

## Ways to start developing

### 1. Dashboard

Create or schedule meetings instantly using dashboard and try it out.

### 2. Embeded SDK

Best way to start is embeded a working video call widget in your app.

### 3. Programmable API

Programmable API enables opportunity to create and manage rooms directly from your backend server.

### 4. Custom Meetings Interface SDK

Our front-end sdk provides fine control to design custom user interface and experience specifically for your needs.


---

---
sidebar_position: 1
---

import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>

# Architecture


---

---
sidebar_position: 1
---

import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>

# Demos


---

---
sidebar_position: 1
---

import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>

# Device and Browser Support

## Browser Support

We support the following web browsers:

- Chrome 74 and above
- Safari 12.1 and above
- Firefox 78 ESR and above
- Microsoft Edge 74 and above.
- Electron 6 and above
- IOS Safari (in IOS 12.1 and later)
- 3rd-party browsers (such as Chrome) and in-app browsers (such as the Gmail app's built-in browser) using WKWebView, as of IOS 14
- Android Chrome, Firefox, Samsung Internet, and Chromium-based 3rd-party browsers

## Screen sharing

- To start a screen share, a user must be on desktop. A user can start a screen share from Chrome, Safari, or Firefox on desktop.
- To clarify, all browsers can view screen shares. A mobile user can see a screen share (but only a call participant on desktop can share their screen).

## Mobile support

- IOS 12.1 and later versions
- Android 5.0 and above with current security and platform updates


---

---
sidebar_position: 1
---

import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>

# Hippa Compliance for Healthcare

import Method from '../../../src/theme/HippaRedirection'

<Method/>


---

---
sidebar_position: 1
---

import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>

# Tutorials


---

---
sidebar_position: 1
sidebar_label: Start HLS Stream
hide_table_of_contents: true
---

# Start HLS Stream

import Method from '../../src/theme/RestApiMethodContainer'
import data from './data.json'
import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>
<Method
{...data.startHLSstream}
/>


---

---
sidebar_position: 1
sidebar_label: Start Livestream
hide_table_of_contents: true
---

# Start Livestream

import Method from '../../src/theme/RestApiMethodContainer'
import data from './data.json'
import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>
<Method
{...data.startLivestream}
/>


---

---
sidebar_position: 1
sidebar_label: Start Recording
hide_table_of_contents: true
---

# Start Recording

import Method from '../../src/theme/RestApiMethodContainer'
import data from './data.json'
import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>
<Method
{...data.startRecording}
/>


---

---
sidebar_position: 1
sidebar_label: Stop HLS Stream
hide_table_of_contents: true
---

# 

import Method from '../../src/theme/RestApiMethodContainer'
import data from './data.json'
import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>
<Method
{...data.stopHLSstream}
/>


---

---
sidebar_position: 1
sidebar_label: Stop Livestream
hide_table_of_contents: true
---

# Stop Livestream

import Method from '../../src/theme/RestApiMethodContainer'
import data from './data.json'
import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>
<Method
{...data.stopLivestream}
/>


---

---
sidebar_position: 1
sidebar_label: Stop Recording
hide_table_of_contents: true
---

# Stop Recording

import Method from '../../src/theme/RestApiMethodContainer'
import data from './data.json'
import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>
<Method
{...data.stopRecording}
/>


---

---
sidebar_position: 0
---

import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>

# Beginner Tutorial JavaScript

## Terminology

Let's start with the terms used in VideoSDK meeting Client SDK.

### Meeting

A Meeting represents real-time audio, video, and/or screen-share session, and is the basic building block for media sharing among participants. Supports upto 5,000 participants.

### Participants

Participants are the client applications that are connected to a Meeting and shares video & audio media with one another.

### Local Participant

Participant producing audio or video stream from the local client's media sources

### Streams

Streams are indiviual video & audio streams produced by the participants in the meeting

### Active Speaker

Active speaker represents the participant who is currently producing highest decibels audio stream (in other words speaking)

### Active presenter

Active presenter is the participant who is currently sharing his/her screen as a video stream

### Main participant

Main participant represents the client who shall be displayed on the main screen indicating that he/she is either presenting or speaking

---

## Installation

### Get an API key

Signup on the VideoSDK website to get a key pair for SDK authentication. Your **API Key** and **Secret** will be visible on the console dashboard.

### Integrate

Include this in your HTML file

```html title="index.html"
<script src="https://sdk.videosdk.live/js-sdk/0.1.6/videosdk.js"></script>
```

---

## Step 0: Access token generation (server-side code)

An access token is required to authenticate with the VideoSDK and make any API calls. You can generate one with the `API key` and `secret` mentioned in your developer portal at VideoSDK console.

## Generate access token (NodeJS)

```js {20} title="server.js"
const express = require("express");
const jwt = require("jsonwebtoken");
const cors = require("cors");
const request = require("request");

const app = express();
const port = 9000;
app.use(cors());
app.use(express.json());
app.use(express.urlencoded({ extended: true }));

app.get("/get-token", (req, res) => {
  const API_KEY = process.env.VIDEOSDK_API_KEY;
  const SECRET_KEY = process.env.VIDEOSDK_SECRET_KEY;
  const options = { expiresIn: "10m", algorithm: "HS256" };
  const payload = {
    apikey: API_KEY,
    permissions: ["allow_join", "allow_mod", "ask_join"], // Trigger permission.
  };
  const token = jwt.sign(payload, SECRET_KEY, options);
  res.json({ token });
});

app.listen(port, () => {
  console.log(`Example app listening at http://localhost:${port}`);
});
```

Available permissions are:

- `allow_join`: The participant will be permitted entry without request.
- `ask_join`: The participant will not be permitted entry without request.
- `allow_mod`: Allow participant to enable/disable other participant's mic/webcam.

This generated token must be sent in the `Authorization` header for all API calls. <br/>
And it should also be used with the `VideoSDK.config(token)` method.

## Step 1: Create or join meeting

Get a meeting id for new meeting or validate an existing meeting id to join a meeting.

### Create new meeting ID

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="curl"
groupId={"server-group-id"}
values={[
{label: 'cURL request creates meeting', value: 'curl'},
{label: 'NodeJS/JS', value: 'node'},
{label: 'Python', value: 'python'},
{label: 'Ruby', value: 'ruby'},
{label: 'RESULT', value: 'result'},
]}>
<TabItem value="curl">

```js
cURL -H "Content-Type: application/json" \
     -H "Authorization: $YOUR_JWT_TOKEN" \
     -XPOST \
     https://api.videosdk.live/v1/meetings
```

</TabItem>
<TabItem value="node">

```js
var request = require("request");

var options = {
  method: "POST",
  url: "https://api.videosdk.live/v1/meetings",
  headers: { authorization: `${YOUR_JWT_TOKEN}` },
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
```

</TabItem>
<TabItem value="python">

```python
import requests

url = "https://api.videosdk.live/v1/meetings"

headers = {'authorization': f'Bearer {YOUR_JWT_TOKEN}'}

response = requests.request("GET", url, headers=headers)

print(response.text)
```

</TabItem>
<TabItem value="ruby">

```ruby
require 'uri'
require 'net/http'

url = URI("https://api.videosdk.live/v1/meetings")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
http.verify_mode = OpenSSL::SSL::VERIFY_NONE

request = Net::HTTP::Get.new(url)
request["authorization"] = "Bearer #{YOUR_JWT_TOKEN}"

response = http.request(request)
puts response.read_body
```

</TabItem>
<TabItem value="result">

```js
{
  "meetingId":"jpkf-iool-64ox"
}
```

</TabItem>
</Tabs>

OR

### Validate existing meeting ID for joining

<Tabs
defaultValue="curl"
groupId={"server-group-id"}
values={[
{label: 'cURL request creates meeting', value: 'curl'},
{label: 'NodeJS/JS', value: 'node'},
{label: 'Python', value: 'python'},
{label: 'Ruby', value: 'ruby'},
{label: 'RESULT', value: 'result'},
]}>
<TabItem value="curl">

```js
cURL -H "Content-Type: application/json" \
     -H "Authorization: $YOUR_JWT_TOKEN" \
     -XPOST \
     https://api.videosdk.live/v1/meetings/${meetingId}
```

</TabItem>
<TabItem value="node">

```js
var request = require("request");

var options = {
  method: "POST",
  url: "https://api.videosdk.live/v1/meetings/${meetingId}",
  headers: { authorization: `${YOUR_JWT_TOKEN}` },
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
```

</TabItem>
<TabItem value="python">

```python
import requests

url = "https://api.videosdk.live/v1/meetings/${meetingId}"

headers = {'authorization': f'Bearer {YOUR_JWT_TOKEN}'}

response = requests.request("GET", url, headers=headers)

print(response.text)
```

</TabItem>
<TabItem value="ruby">

```ruby
require 'uri'
require 'net/http'

url = URI("https://api.videosdk.live/v1/meetings/${meetingId}")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
http.verify_mode = OpenSSL::SSL::VERIFY_NONE

request = Net::HTTP::Get.new(url)
request["authorization"] = "Bearer #{YOUR_JWT_TOKEN}"

response = http.request(request)
puts response.read_body
```

</TabItem>
<TabItem value="result">

```js
{
  "meetingId":"jpkf-iool-64ox"
}
```

</TabItem>
</Tabs>

## Step 2: Initialize meeting

To initialize meeting you need to provide the following parameters:

- `meetingId: string` from the previous step to specify which meeting to join in.
- `name: string` which will be displayed as username of participant in the meeting.
- `micEnabled: boolean` option to indicate if mic should be on while joining.
- `webcamEnabled: boolean` option to indicate if webcam should be on while joining.
- `maxResolution: "sd" | "hd"` defines the maximum available resolution for webcam video.

```javascript title="Intialize meeting instance"
const meeting = VideoSDK.initMeeting({
  meetingId, // required
  name, // required
  micEnabled, // optional, default: true
  webcamEnabled, // optional, default: true
  maxResolution, // optional, default: "hd"
});
```

The `meeting` object consists of:

- Properties:

  - `id: string`
  - `activeSpeakerId: string`
  - `activePresenterId: string`
  - `mainParticipantId: string`
  - `localParticipant: Participant`
  - `participants: Map<string, Participant>`
  - `messages: Array<{senderId: string, text: string, timestamp: number}>`

- Events:

  - `participant-joined`, `participant-left`
  - `speaker-changed`, `presenter-changed`
  - `main-participant-changed`
  - `entry-requested`, `entry-responded`
  - `recording-started`, `recording-stopped`
  - `stream-enabled`, `stream-disabled`
  - `chat-message`

- Methods:
  - `join()`, `leave()`
  - `muteMic()`, `unmuteMic()`
  - `disableWebcam()`, `enableWebcam()`
  - `disableScreenShare()`, `enableScreenShare()`
  - `on(eventType: string)`, `off(eventType: string)`
  - `respondEntry(participantId: string, decision: "allowed" | "denied")`
  - `startRecording(webhookUrl: string, , awsDirPath: string)`, `stopRecording()`
  - `sendChatMessage(text: string)`

## Step 3: Get local and remote participants

You can get the local streams and participant meta from `meeting.localParticipant`. And a `Map` of joined participants is always available via `meeting.participants`.

```javascript title="Access meeting participants"
const localParticipant = meeting.localParticipant;
const participants = meeting.participants;
```

Each `participant` object consists of:

- Properties:

  - `id: string`
  - `displayName: string`
  - `streams: Map<string, Stream>`

- Events:

  - `stream-enabled`
  - `stream-disabled`

- Methods:
  - `setQuality(quality: "low" | "med" | "high")`
  - `enableMic()`, `disableMic()`
  - `enableWebcam()`, `disableWebcam()`
  - `on(eventType: string)`, `off(eventType: string)`

## Step 4: Listen for entry request events

When participant asks for entry in a meeting that you are connected to, you will be notified via `entry-requested` and when you or any other participant's entry is responded, `entry-responded` will be fired.

```javascript title="Get request from user"
meeting.on("entry-requested", (participantId, name) => {
  setEntryRequests([...entryRequestsRef.current, { id: participantId, name }]);

  // you can open a dialog to respond with
  // decision "allowed" or "denied" with the following method
  meeting.respondEntry(participantId, decision);
});

meeting.on("entry-responded", (participantId, decision) => {
  // decision parameter will be: "allowed" or "denied"

  setEntryRequests(
    entryRequestsRef.current.filter((r) => r.id !== participantId)
  );
});
```

## Step 5: Listen for new & leaving participant events

When participant joins or leaves a meeting that you are connected to, you will be notified via `participant-joined` and `participant-left` events respectively.

```javascript "Listen on participant joined and left"
meeting.on("participant-joined", (participant) => {
  setParticipants(new Map(meeting.participants));
});

meeting.on("participant-left", (participant) => {
  setParticipants(new Map(meeting.participants));
});
```

## Step 6: Listen for audio/video stream events

When a participant from meeting enables or diables a audio/video stream, you will be notified via `stream-enabled` and `stream-disabled` events from the participant object.

```javascript title="Listen on stream enabled and disabled"
participant.on("stream-enabled", (stream) => {
  if (stream.kind === "video") {
    // play video track on a <video /> element
  } else if (stream.kind === "audio") {
    // play audio track on a <audio /> element
  } else if (stream.kind === "share") {
    // play screen sharing video track on a <video /> element
  }
});

participant.on("stream-disabled", (stream) => {
  if (stream.kind === "video") {
    // remove video track or the <video /> element
  } else if (stream.kind === "audio") {
    // remove audio track or the <audio /> element
  } else if (stream.kind === "share") {
    // remove screen sharing video track or the <video /> element
  }
});
```

Each `stream` object consists of:

- Properties:

  - `id: string`
  - `kind: string`
  - `codec: string`
  - `track: MediaStreamTrack`

- Methods:
  - `pause()`
  - `resume()`

### Note: Chrome Autoplay policy workaround

Chrome's autoplay policy does not allow audio autoplay unless user has interacted with the domain (click, tap, etc.) or the user's <a href="https://developers.google.com/web/updates/2017/09/autoplay-policy-changes#mei">Media engagement Index</a> threshold has been crossed. Thus, as a workaround before starting the meeting, user can either create a meeting join page or create a join meeting confirmation dialog by which we can perform a user click interaction to enable audio autoplay in chrome's newer versions.

## Step 7: Main screen video (optional)

When a participant who is currently presenting or speaking is changed in the meeting, you will be notified via `main-participant-changed` event.

```javascript title="Listen on main participant changed"
meeting.on("main-participant-changed", (participant) => {
  // show participant video stream on main screen
});
```

## Step 8: Join the meeting

After we set local participant, main-screen participant, other participants, participant event handlers and stream event handlers from the meeting, next step is to join the meeting by calling `meeting.join()`. This will trigger `participant-joined` event for all other participants.

```javascript title="Leave meeting"
meeting.join();
```

## Step 9: Utility methods & events (optional)

### Mute/Unmute mic

Toggle own mic with the `unmuteMic()` and `muteMic()` methods. Toggling mic will trigger `stream-enabled` and `stream-disabled` events for all other participants when enabling and disabling mic.

```javascript title="Mic methods"
// unmute/mute your own mic
meeting.unmuteMic();
meeting.muteMic();

// unmute/mute other participant's mic
participant.unmuteMic();
participant.muteMic();
```

### Enable/Disable Webcam

Toggle own webcam with the `enableWebcam()` and `disableWebcam()` methods. Toggling webcam will trigger `stream-enabled` and `stream-disabled` events for all other participants when enabling and disabling webcam.

```javascript title="Webcam methods"
// disable/enable your own webcam
meeting.enableWebcam();
meeting.disableWebcam();

// disable/enable other participant's webcam
participant.enableWebcam();
participant.disableWebcam();
```

### Enable/Disable Screen share

Share your screen with the `enableScreenShare()` method and stop sharing with `disableScreenShare()`. Toggling screen-share will trigger `stream-enabled` and `stream-disabled` events for all other participants when enabling and disabling screen-share.

```javascript title="Screen share methods"
meeting.enableScreenShare();
meeting.disableScreenShare();
```

### Start/Stop recording

Record the meeting session with `startRecording(webhookUrl, awsDirPath)` method and stop recording with `stopRecording()`. Toggling recording will trigger `recording-started` and `recording-stopped` events for all participants when starting and stopping recording respectively.

```javascript title="Start and stop recordings methods"
// The webhook will be called with the fileUrl as a POST request when the recording is processed.
meeting.startRecording(
  "https://your-app-server.com/api/recordings",
  "meetings/meeting-id"
);
meeting.stopRecording();

// ...

meeting.on("recording-started", () => {
  setRecordStatus("active");

  // 🔴 notify all users of recording start
});

meeting.on("recording-stopped", () => {
  setRecordStatus("inactive");

  // ⚫ notify all users of recording end
});
```

### In-meeting Chat

Send messages with the `sendChatMessage(text)` method and all other participants will be notified via `chat-message` event.

```javascript title="Send and receive chat message"
meeting.sendChatMessage("Hello world!");

// ...

meeting.on("chat-message", (data) => {
  setChatMessages([...meeting.messages]);

  const { senderId, text, timestamp } = data;

  // 📢 notify user or show in the chat window
});
```

### Active speaker event

The `speaker-changed` event will be fired whenever the loudest speaking participant changes.

```javascript title="Listen on active speaker changed"
meeting.on("speaker-changed", (participant) => {
  // indicate participant as speaking
});
```

### Active presenter event

The `presenter-changed` event will be fired whenever someone enables screen sharing.

```javascript title="Listen on presenter changed"
meeting.on("presenter-changed", (participant) => {
  // indicate participant as presenting screen
});
```

### Set participant video quality

Update the participant video quality based on use case to `"low" | "med" | "high"`.

```javascript title="Set quelity of receiving stream"
participant.setQuality("low");
```

### Start/Stop video

Share video link to play with `startVideo({ link })` method and stop video with `stopVideo()`. Toggling video will trigger `video-started` and `video-stopped` events for all participants when starting and stopping video respectively.
​

```javascript
// The webhook will be called with the fileUrl as a POST request when the video is processed.
meeting.startVideo({ link: "https://your-app-server.com/video/demo.mp4" });
meeting.stopVideo();
​
​
// Listening on start of the video stream.
meeting.on("video-started", ({ link, currentTime }) => {
  videoRef.current.src = link;
  videoRef.current.currentTime = currentTime;
});

// Listening to the stopped video stream.
meeting.on("video-stopped", () => {
  videoRef.current.pause();
  videoRef.current.src = null;
});
```

### Restream meeting on social media

Restream meeting on your favorite social media channels using RTMP key and url.

```javascript
// start livestreaming
meeting.startLivestream([
  {
    url: "rtmp://x.rtmp.youtube.com/live2/",
    streamKey: "abcd-h6a2-pqrs-vusv-prpf",
  },
]);
​
// stop livestreaming
meeting.stopLivestream();
```

## Leave the meeting

You can disconnect from the meeting with `meeting.leave()` method. This will trigger `participant-left` event for all other participants.

```javascript title="Leave meeting"
meeting.leave();
```


---

---
sidebar_position: 2
sidebar_label: Update Room
hide_table_of_contents: true
---

# Update Room

import Method from '../../src/theme/RestApiMethodContainer'
import data from './data.json'
import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>
<Method
{...data.updateRoom}
/>


---

---
title: Architecture of Real time communication API
hide_title: false
hide_table_of_contents: false
description: Architecture of Real time communication API is quite simple to understand before jumping directly to build application.
sidebar_label: Architecture
pagination_label: Architecture
keywords:
  - RTC API
  - RTC SDK
  - video API
  - audio rooms API
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: architecture
---

import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>

## Architecture

import Mermaid from '@theme/Mermaid';

<Mermaid chart={`sequenceDiagram Host->>App Server: Request for token; App Server->>Host: Received token; Host->>App Server: Request for meetingId; App Server->>VideoSDK Server: Request for meetingId; VideoSDK Server->>App Server: Sending meetingId; App Server->>Host: Received meetingId; Host->>Participants: Broadcast meetingId; Host->>App Server: Start Meeting; Participants-->>App Server: Join Meeting; Participants->>App Server: Request for token; App Server->>Participants: Received token; Participants->>App Server: Validate meetingId; Participants->>App Server: Leave Meeting; Host->>App Server: End Meeting;`}/>

## Terminology

### Meeting

A Meeting represents real-time audio, video, and/or screen-share session, and is the basic building block for media sharing among participants.

### Participants

Participants are the client applications that are connected to a Meeting and shares video & audio media with one another.

### Local Participant

Participant producing audio or video stream from the local client's media sources

### Streams

Streams are indiviual video & audio streams produced by the participants in the meeting

### Active Speaker

Active speaker represents the participant who is currently producing highest decibels audio stream (in other words speaking)

### Active presenter

Active presenter is the participant who is currently sharing his/her screen as a video stream

### Main participant

Main participant represents the client who shall be displayed on the main screen indicating that he/she is either presenting or speaking

---


---

---
sidebar_position: 1
title: "Authentication"
---

import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>

# Authentication - API

## Using an API to authenticate

The process of authentication is designed in such a way that it can be useful in both server and client side.

First of all, you have to install either of the SDK to generate token. Next step is to generate a `jsonwebtoken` in programming environment you are working with.

## Generate access token (NodeJS)

```js {20} title="server.js"
const express = require("express");
const jwt = require("jsonwebtoken");
const cors = require("cors");
const request = require("request");

const app = express();
const port = 9000;
app.use(cors());
app.use(express.json());
app.use(express.urlencoded({ extended: true }));

app.get("/get-token", (req, res) => {
  const API_KEY = process.env.VIDEOSDK_API_KEY;
  const SECRET_KEY = process.env.VIDEOSDK_SECRET_KEY;
  const options = { expiresIn: "10m", algorithm: "HS256" };
  const payload = {
    apikey: API_KEY,
    permissions: ["allow_join", "allow_mod", "ask_join"], // Trigger permission.
  };
  const token = jwt.sign(payload, SECRET_KEY, options);
  res.json({ token });
});

app.listen(port, () => {
  console.log(`Example app listening at http://localhost:${port}`);
});
```

Now, using this `token`. You can call API's at either client or server side. Refer [jwt.io](https://jwt.io/) for other programming languages.


---

---
sidebar_position: 1
sidebar_label: Create Meeting using API
---

import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>

# Create/Join Meeting using API

### Create meeting

Use the following Rest API to create new meeting.

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="curl"
groupId={"server-group-id"}
values={[
{label: 'cURL request creates meeting', value: 'curl'},
{label: 'NodeJS/JS', value: 'node'},
{label: 'Python', value: 'python'},
{label: 'Ruby', value: 'ruby'},
{label: 'RESULT', value: 'result'},
]}>
<TabItem value="curl">

```js
cURL -H "Content-Type: application/json" \
     -H "Authorization: $YOUR_JWT_TOKEN" \
     -d '{ "userMeetingId": "unicorn" }' \
     -XPOST \
     https://api.videosdk.live/v1/meetings
```

</TabItem>
<TabItem value="node">

```js
var request = require("node-fetch");

var options = {
  method: "POST",
  url: "https://api.videosdk.live/v1/meetings",
  headers: {
    authorization: `${YOUR_JWT_TOKEN}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({ userMeetingId: "unicorn" }),
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
```

</TabItem>
<TabItem value="python">

```python
import requests

url = "https://api.videosdk.live/v1/meetings"

headers = {'authorization': f'Bearer {YOUR_JWT_TOKEN}'}

response = requests.request("GET", url, headers=headers,json={"userMeetingId": "unicorn"})

print(response.text)
```

</TabItem>
<TabItem value="ruby">

```ruby
require 'uri'
require 'net/http'

url = URI("https://api.videosdk.live/v1/meetings")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
http.verify_mode = OpenSSL::SSL::VERIFY_NONE

request = Net::HTTP::Post.new(url, 'Content-Type' => 'application/json')
request.authorization = "Bearer #{YOUR_JWT_TOKEN}"
request.body = {userMeetingId: 'unicorn'}.to_json
response = http.request(request)
puts response.read_body
```

</TabItem>
<TabItem value="result">

```js
{
  "meetingId": "87i6-bvw8-dtn1",
  "userMeetingId": "unicorn",
  "userId": "5fa671e77b80d58c11cbca95",
  "createdAt": "2022-01-05T06:41:16.018Z",
  "updatedAt": "2022-01-05T06:41:16.018Z",
  "id": "61d53d8c964704379e7d927a"
}
```

</TabItem>
</Tabs>

### Validate existing meeting id

To validate existing meeting id, before joining use following API.
<Tabs
defaultValue="curl"
groupId={"server-group-id"}
values={[
{label: 'cURL request creates meeting', value: 'curl'},
{label: 'NodeJS/JS', value: 'node'},
{label: 'Python', value: 'python'},
{label: 'Ruby', value: 'ruby'},
{label: 'RESULT', value: 'result'},
]}>
<TabItem value="curl">

```js
cURL -H "Content-Type: application/json" \
     -H "Authorization: $YOUR_JWT_TOKEN" \
     -XPOST \
     https://api.videosdk.live/v1/meetings/${meetingId}
```

</TabItem>
<TabItem value="node">

```js
var request = require("request");

var options = {
  method: "POST",
  url: "https://api.videosdk.live/v1/meetings/${meetingId}",
  headers: { authorization: `${YOUR_JWT_TOKEN}` },
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
```

</TabItem>
<TabItem value="python">

```python
import requests

url = "https://api.videosdk.live/v1/meetings/${meetingId}"

headers = {'authorization': f'Bearer {YOUR_JWT_TOKEN}'}

response = requests.request("GET", url, headers=headers)

print(response.text)
```

</TabItem>
<TabItem value="ruby">

```ruby
require 'uri'
require 'net/http'

url = URI("https://api.videosdk.live/v1/meetings/${meetingId}")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
http.verify_mode = OpenSSL::SSL::VERIFY_NONE

request = Net::HTTP::Get.new(url)
request["authorization"] = "Bearer #{YOUR_JWT_TOKEN}"

response = http.request(request)
puts response.read_body
```

</TabItem>
<TabItem value="result">

```js
{
  "meetingId": "87i6-bvw8-dtn1",
  "userMeetingId": "unicorn",
  "userId": "5fa671e77b80d58c11cbca95",
  "createdAt": "2022-01-05T06:41:16.018Z",
  "updatedAt": "2022-01-05T06:41:16.018Z",
  "id": "61d53d8c964704379e7d927a"
}
```

</TabItem>
</Tabs>


---

---
sidebar_position: 1
sidebar_label: End Meeting Session
---

import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>

# End Meeting Session - API

Use the following Rest API to end a running session.

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="curl"
groupId={"server-group-id"}
values={[
{label: 'cURL request', value: 'curl'},
{label: 'NodeJS/JS', value: 'node'},
{label: 'Python', value: 'python'},
{label: 'Ruby', value: 'ruby'},
{label: 'RESULT', value: 'result'},
]}>
<TabItem value="curl">

```js
cURL -H "Content-Type: application/json" \
     -H "Authorization: $YOUR_JWT_TOKEN" \
     -XPOST \
     https://api.videosdk.live/v1/meeting-sessions/:id/end
```

</TabItem>
<TabItem value="node">

```js
var request = require("node-fetch");

var options = {
  method: "POST",
  url: "https://api.videosdk.live/v1/meeting-sessions/:id/end",
  headers: { authorization: `${YOUR_JWT_TOKEN}` },
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
```

</TabItem>
<TabItem value="python">

```python
import requests

url = "https://api.videosdk.live/v1/meeting-sessions/:id/end"

headers = {'authorization': f'Bearer {YOUR_JWT_TOKEN}'}

response = requests.request("POST", url, headers=headers)

print(response.text)
```

</TabItem>
<TabItem value="ruby">

```ruby
require 'uri'
require 'net/http'

url = URI("https://api.videosdk.live/v1/meeting-sessions/:id/end")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
http.verify_mode = OpenSSL::SSL::VERIFY_NONE

request = Net::HTTP::Get.new(url)
request["authorization"] = "Bearer #{YOUR_JWT_TOKEN}"

response = http.request(request)
puts response.read_body
```

</TabItem>

<TabItem value="result">

```js
{
    "id": "61adc697a239e84d0aaa7e15",
    "meetingId": "25af-rsr2-lk92",
    "start": "2021-12-06T08:15:19.121Z",
    "end": null,
    "participants": [
        {
            "participantId": "c7wgj9sd",
            "name": "John Doe",
            "timelog": [
                {
                    "start": "2021-12-06T08:15:20.565Z",
                    "end": "2021-12-06T08:15:54.246Z"
                }
            ]
        },
        {
            "participantId": "ofwb7db6",
            "name": "John Doe",
            "timelog": [
                {
                    "start": "2021-12-06T08:15:27.585Z",
                    "end": null
                }
            ]
        }
    ]
}
```

</TabItem>
</Tabs>

import MethodListGroup from '@theme/MethodListGroup';
import MethodListItemLabel from '@theme/MethodListItemLabel';
import MethodListHeading from '@theme/MethodListHeading';

### Request

<MethodListGroup>
    <MethodListGroup>
      <MethodListHeading heading="Path Parameters" />
      <MethodListItemLabel name="id" option={"session-id"} type={"string"} />
    </MethodListGroup>
</MethodListGroup>

### Response

<MethodListGroup>
  <MethodListItemLabel name="__response"  type={"object"} >
    <MethodListGroup>
    <MethodListHeading heading="Properties" />
          <MethodListItemLabel name="id"  type={"string"} />
          <MethodListItemLabel name="meetingId"  type={"string"} />
          <MethodListItemLabel name="start"  type={"date"} />
          <MethodListItemLabel name="end"  type={"date"} />
          <MethodListItemLabel name="participants" type={"Array<object>"} >
            <MethodListGroup>
              <MethodListItemLabel name="participantId"  type={"string"} />
              <MethodListItemLabel name="name"  type={"string"} />
               <MethodListItemLabel name="timelog" type={"Array<object>"} >
               <MethodListGroup>
                    <MethodListItemLabel name="start"  type={"date"} />
                    <MethodListItemLabel name="end"  type={"date"} />
                </MethodListGroup>
                </MethodListItemLabel>
            </MethodListGroup>
          </MethodListItemLabel>
    </MethodListGroup>
  </MethodListItemLabel>
</MethodListGroup>


---

---
sidebar_position: 1
title: "Get Meeting Details"
---

import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>

# Get Meeting Details - API

Use the following Rest API to get meeting details.

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="curl"
groupId={"server-group-id"}
values={[
{label: 'cURL request', value: 'curl'},
{label: 'NodeJS/JS', value: 'node'},
{label: 'Python', value: 'python'},
{label: 'Ruby', value: 'ruby'},
{label: 'RESULT', value: 'result'},
]}>
<TabItem value="curl">

```js

curl -L -X GET 'https://api.videosdk.live/v1/meetings/:id' \
-H 'Authorization: $YOUR_JWT_TOKEN'

```

</TabItem>
<TabItem value="node">

```js
var request = require("request");
var options = {
  method: "GET",
  url: "https://api.videosdk.live/v1/meetings/:id",
  headers: {
    Authorization: "$YOUR_JWT_TOKEN",
  },
};
request(options, function (error, response) {
  if (error) throw new Error(error);
  console.log(response.body);
});
```

</TabItem>
<TabItem value="python">

```python
import requests

url = "https://api.videosdk.live/v1/meetings/:id"

headers = {
  'Authorization': '$YOUR_JWT_TOKEN'
}

response = requests.request("GET", url, headers=headers)

print(response.text)

```

</TabItem>
<TabItem value="ruby">

```ruby
require "uri"
require "net/http"

url = URI("https://api.videosdk.live/v1/meetings/:id")

https = Net::HTTP.new(url.host, url.port)
https.use_ssl = true

request = Net::HTTP::Get.new(url)
request["Authorization"] = "$YOUR_JWT_TOKEN"

response = https.request(request)
puts response.read_body

```

</TabItem>
<TabItem value="result">

```js
{
    "meetingId": "yw3w-nfzh-9jl0",
    "userId": "5fa671e77b80d58c11cbca95",
    "createdAt": "2021-06-18T08:10:46.683Z",
    "updatedAt": "2021-06-18T08:10:46.683Z",
    "id": "60cc550656592b6a03d7a2d0"
}
```

</TabItem>
</Tabs>

import MethodListGroup from '@theme/MethodListGroup';
import MethodListItemLabel from '@theme/MethodListItemLabel';
import MethodListHeading from '@theme/MethodListHeading';

### Request

<MethodListGroup>
    <MethodListGroup>
      <MethodListHeading heading="Query Parameters" />
      <MethodListItemLabel name="id" option={"optional"} type={"string"} />
    </MethodListGroup>
</MethodListGroup>

### Response

<MethodListGroup>
  <MethodListItemLabel name="__response"  type={"object"} >
    <MethodListGroup>
      <MethodListHeading heading="Properties" />
      <MethodListItemLabel name="meetingId"  type={"string"} />
      <MethodListItemLabel name="userId"  type={"string"} />
      <MethodListItemLabel name="user" type={"object"} >
        <MethodListGroup>
          <MethodListItemLabel name="name"  type={"string"} />
          <MethodListItemLabel name="id"  type={"string"} />
        </MethodListGroup>
      </MethodListItemLabel>
      <MethodListItemLabel name="createdAt"  type={"date"} />
      <MethodListItemLabel name="updatedAt"  type={"date"} />
      <MethodListItemLabel name="id"  type={"string"} />
    </MethodListGroup>
  </MethodListItemLabel>
</MethodListGroup>


---

---
sidebar_position: 1
title: "Get Recording Details"
---

import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>

# Get Recording Details - API

Use the following Rest API to get recording details.

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="curl"
groupId={"server-group-id"}
values={[
{label: 'cURL request', value: 'curl'},
{label: 'NodeJS/JS', value: 'node'},
{label: 'Python', value: 'python'},
{label: 'Ruby', value: 'ruby'},
{label: 'RESULT', value: 'result'},
]}>
<TabItem value="curl">

```js

curl -L -X GET 'https://api.videosdk.live/v1/meeting-recordings/:id' \
-H 'Authorization: $YOUR_JWT_TOKEN'

```

</TabItem>
<TabItem value="node">

```js
var request = require("request");
var options = {
  method: "GET",
  url: "https://api.videosdk.live/v1/meeting-recordings/:id",
  headers: {
    Authorization: "$YOUR_JWT_TOKEN",
  },
};
request(options, function (error, response) {
  if (error) throw new Error(error);
  console.log(response.body);
});
```

</TabItem>
<TabItem value="python">

```python
import requests

url = "https://api.videosdk.live/v1/meeting-recordings/:id"

headers = {
  'Authorization': '$YOUR_JWT_TOKEN'
}

response = requests.request("GET", url, headers=headers)

print(response.text)

```

</TabItem>
<TabItem value="ruby">

```ruby
require "uri"
require "net/http"

url = URI("https://api.videosdk.live/v1/meeting-recordings/:id")

https = Net::HTTP.new(url.host, url.port)
https.use_ssl = true

request = Net::HTTP::Get.new(url)
request["Authorization"] = "$YOUR_JWT_TOKEN"

response = https.request(request)
puts response.read_body

```

</TabItem>
<TabItem value="result">

```js
{
  "userId": "5f7edbb14c938bcd42944517",
  "meetingId": "hv6a-uwrj-8jbd",
  "origFileId": "60df15dc1b5d6a3205573786",
  "jobId": "60df15df7433b02e7d06853a",
  "createdAt": "2021-07-02T13:34:23.768Z",
  "updatedAt": "2021-07-02T13:34:30.616Z",
  "fileId": "60df15e61b5d6a3205533289",
  "file": {
      "meta": {
          "resolution": {
              "width": 1280,
              "height": 720
          },
          "format": "mov,mp4,m4a,3gp,3g2,mj2",
          "duration": 3.561
      },
      "jobId": "60df15df7433b02e1d06653a",
      "filePath": "encoded/videos/60df15dc1b5d6a8205573286/720.mp4",
      "size": 613596,
      "type": "video",
      "createdAt": "2021-07-02T13:34:30.566Z",
      "updatedAt": "2021-07-02T13:34:30.566Z",
      "fileUrl": "https://cdn.videosdk.live/encoded/videos/60df15dc1b5d6a8205573286/720.mp4",
      "id": "60df15e61b5d6a3805573289"
  },
  "id": "60df15df7433b02e3d06653c"
}
```

</TabItem>
</Tabs>

import MethodListGroup from '@theme/MethodListGroup';
import MethodListItemLabel from '@theme/MethodListItemLabel';
import MethodListHeading from '@theme/MethodListHeading';

### Request

<MethodListGroup>
    <MethodListGroup>
      <MethodListHeading heading="Path Parameters" />
      <MethodListItemLabel name="id" option={"optional"} type={"string"} />
    </MethodListGroup>
</MethodListGroup>

### Response

<MethodListGroup>
  <MethodListItemLabel name="__response"  type={"object"} >
    <MethodListGroup>
      <MethodListHeading heading="Properties" />
          <MethodListItemLabel name="userId"  type={"string"} />
          <MethodListItemLabel name="meetingId"  type={"string"} />
          <MethodListItemLabel name="sessionId"  type={"string"} />
          <MethodListItemLabel name="origFileId"  type={"string"} />
          <MethodListItemLabel name="jobId"  type={"string"} />
          <MethodListItemLabel name="fileId"  type={"string"} />
          <MethodListItemLabel name="file" type={"object"} >
            <MethodListGroup>
                <MethodListItemLabel name="meta" type={"object"} >
                  <MethodListGroup>
                          <MethodListItemLabel name="resolution" type={"object"} >
                            <MethodListGroup>
                                <MethodListItemLabel name="width"  type={"number"} />
                                <MethodListItemLabel name="height"  type={"number"} />
                            </MethodListGroup>
                          </MethodListItemLabel>
                      <MethodListItemLabel name="format"  type={"string"} />
                      <MethodListItemLabel name="duration"  type={"number"} />
                  </MethodListGroup>
                </MethodListItemLabel>
              <MethodListItemLabel name="jobId"  type={"string"} />
              <MethodListItemLabel name="filePath"  type={"string"} />
              <MethodListItemLabel name="size"  type={"number"} />
              <MethodListItemLabel name="type"  type={"string"} />
              <MethodListItemLabel name="fileUrl"  type={"string"} />
              <MethodListItemLabel name="updatedAt"  type={"date"} />
              <MethodListItemLabel name="createdAt"  type={"date"} />
              <MethodListItemLabel name="id"  type={"string"} />
            </MethodListGroup>
          </MethodListItemLabel>
          <MethodListItemLabel name="createdAt"  type={"date"} />
          <MethodListItemLabel name="updatedAt"  type={"date"} />
          <MethodListItemLabel name="id"  type={"string"} />
    </MethodListGroup>
  </MethodListItemLabel>
</MethodListGroup>


---

---
sidebar_position: 1
sidebar_label: Get Session Details
---

import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>

# Get Session Details - API

Use the following Rest API to list session details.

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="curl"
groupId={"server-group-id"}
values={[
{label: 'cURL request', value: 'curl'},
{label: 'NodeJS/JS', value: 'node'},
{label: 'Python', value: 'python'},
{label: 'Ruby', value: 'ruby'},
{label: 'RESULT', value: 'result'},
]}>
<TabItem value="curl">

```js

curl -L -X GET 'https://api.videosdk.live/v1/meeting-sessions/:id' \
-H 'Authorization: $YOUR_JWT_TOKEN'

```

</TabItem>
<TabItem value="node">

```js
var request = require("request");
var options = {
  method: "GET",
  url: "https://api.videosdk.live/v1/meeting-sessions/:id",
  headers: {
    Authorization: "$YOUR_JWT_TOKEN",
  },
};
request(options, function (error, response) {
  if (error) throw new Error(error);
  console.log(response.body);
});
```

</TabItem>
<TabItem value="python">

```python
import requests

url = "https://api.videosdk.live/v1/meeting-sessions/:id"

headers = {
  'Authorization': '$YOUR_JWT_TOKEN'
}

response = requests.request("GET", url, headers=headers)

print(response.text)

```

</TabItem>
<TabItem value="ruby">

```ruby
require "uri"
require "net/http"

url = URI("https://api.videosdk.live/v1/meeting-sessions/:id")

https = Net::HTTP.new(url.host, url.port)
https.use_ssl = true

request = Net::HTTP::Get.new(url)
request["Authorization"] = "$YOUR_JWT_TOKEN"

response = https.request(request)
puts response.read_body

```

</TabItem>
<TabItem value="result">

```js
{
    "id": "616e79f7ba68c7768bfd18bf",
    "meetingId": "ywnm-eicr-d55x",
    "chatLink" : "https://cdn.videosdk.live/chats/hq3g-ny2g-kv8x-12348924f6213b0f00a9f7a6-6169bd856790717248e86cff.csv",
    "start": "2021-10-19T07:55:35.807Z",
    "end": "2021-10-19T07:55:39.941Z",
    "activeDuration": 0,
    "participants": [
        {
            "participantId": "wcrkkrf4",
            "name": "John Doe",
            "timelog": [
                {
                    "start": "2021-10-19T07:55:36.316Z",
                    "end": "2021-10-19T07:55:39.937Z"
                }
            ]
        }
    ]
}
```

</TabItem>
</Tabs>

import MethodListGroup from '@theme/MethodListGroup';
import MethodListItemLabel from '@theme/MethodListItemLabel';
import MethodListHeading from '@theme/MethodListHeading';

### Request

<MethodListGroup>
    <MethodListGroup>
      <MethodListHeading heading="Path Parameters" />
      <MethodListItemLabel name="id" option={"optional"} type={"string"} />
    </MethodListGroup>
</MethodListGroup>

### Response

<MethodListGroup>
  <MethodListItemLabel name="__response"  type={"object"} >
    <MethodListGroup>
    <MethodListHeading heading="Properties" />
          <MethodListItemLabel name="id"  type={"string"} />
          <MethodListItemLabel name="meetingId"  type={"string"} />
          <MethodListItemLabel name="chatLink" type={"string"} />
          <MethodListItemLabel name="start"  type={"date"} />
          <MethodListItemLabel name="end"  type={"date"} />
          <MethodListItemLabel name="activeDuration" type={"number"} >
          <MethodListItemLabel name="participants" type={"Array<object>"} />
            <MethodListGroup>
              <MethodListItemLabel name="participantId"  type={"string"} />
              <MethodListItemLabel name="name"  type={"string"} />
               <MethodListItemLabel name="timelog" type={"Array<object>"} />
               <MethodListGroup>
                    <MethodListItemLabel name="start"  type={"date"} />
                    <MethodListItemLabel name="end"  type={"date"} />
                </MethodListGroup>
            </MethodListGroup>
          </MethodListItemLabel>
    </MethodListGroup>
  </MethodListItemLabel>
</MethodListGroup>


---

---
sidebar_position: 1
---

import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>

# Customise Interface

Cooming soon


---

---
sidebar_position: 1
---

import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>

# Embeded meeting

Coming Soon.

![Build a embeded meeting.](/img/Zujonow-whitelabel-desktop-min.jpg)


---

---
sidebar_position: 1
---

import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>

# Explore console

Coming Soon.


---

---
sidebar_position: 1
---

import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>

# What we offer

## Explore amazing features

Let's discover **Realtime SDK features in less than 5 minutes**.

### ✅ : Shipped

### 🚧 : Working on it

### ❌ : Not implemented

## Features

|                                                      | Embeded | SDK |
| ---------------------------------------------------- | ------- | --- |
| video & audio chat functionality                     | ✅      | ✅  |
| Customised interface for video & audio               | 🚧      | ✅  |
| Adaptive video & audio calling                       | ✅      | ✅  |
| Cross browser and device support                     | 🚧      | ✅  |
| Screen sharing                                       | ✅      | ✅  |
| Interactive Whiteboard                               | ✅      | ✅  |
| Auto switching on active speakers                    | ✅      | ✅  |
| Grid Layouts                                         | ✅      | ✅  |
| Participant List                                     | ✅      | ✅  |
| Raise Hand                                           | ✅      | ✅  |
| Text chat and file sharing                           | ✅      | ✅  |
| Cloud and local recording                            | ✅      | ✅  |
| Console analytics and operations                     | ✅      | ✅  |
| Compatible with JS, React, Electron, Vue and Angular | ✅      | ✅  |
| Compatible with React Native, Flutter                | 🚧      | ✅  |
| Compatible with native Android, IOS                  | 🚧      | 🚧  |


---

---
sidebar_position: 1
---

import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>

# Integrate SDK with mobile, tab and tv

## @videosdk.live/react-native-sdk

`@videosdk.live/react-native-sdk` is hybrid sdk for the react native. It inherits `js` and `react` sdk to provide better support and fast development in mobile devices.

![Build a React Native video chat app with @videosdk.live/react-native-sdk.](/img/Zujonow-whitelabel-mobile-landscape.jpg)


---

---
sidebar_position: 1
---

import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>

# What next?


---

---
title: Introduction to Real time communication API
hide_title: false
hide_table_of_contents: false
description: RTC SDK provides wide range of features to build your own custom video chat application without worrying about performance issues and scaling.
sidebar_label: Introduction
pagination_label: Introduction
keywords:
  - RTC API
  - RTC SDK
  - video API
  - audio rooms API
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: intro
---

import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>

# Introduction

Real-time comunication SDK is built with blend of webRTC and optimised UDP protocol. Our SDK helps developers to add real-time video & audio calls to any mobile app or web application.

With our `embeded-sdk`, you can embeded a video call widget in your web application. It supports 98% of the devices across all platforms and adaptive video calling for better quality calls with low latency. Developers can also customise `embeded-sdk` to make it more convenient for your application.

Our research team has worked hard to handled all the edge cases so you just have to focus on what matters.

![Embeded SDK Example to add video call widget in your web application](/img/Zujonow-whitelabel-min.jpg)

## Ways to start developing

### 1. Dashboard

Create or schedule meetings instantly using dashboard and try it out.

### 2. Embeded SDK

Best way to start is embeded a working video call widget in your app.

### 3. Programmable API

Programmable API enables opportunity to create and manage rooms directly from your backend server.

### 4. Custom Meetings Interface SDK

Our front-end sdk provides fine control to design custom user interface and experience specifically for your needs.


---

---
sidebar_position: 1
---

import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>

# List Meetings - API

Use the following Rest API to list meetings.

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="curl"
groupId={"server-group-id"}
values={[
{label: 'cURL request', value: 'curl'},
{label: 'NodeJS/JS', value: 'node'},
{label: 'Python', value: 'python'},
{label: 'Ruby', value: 'ruby'},
{label: 'RESULT', value: 'result'},
]}>
<TabItem value="curl">

```js

curl -L -X GET 'https://api.videosdk.live/v1/meetings' \
-H 'Authorization: $YOUR_JWT_TOKEN'

```

</TabItem>
<TabItem value="node">

```js
var request = require("request");
var options = {
  method: "GET",
  url: "https://api.videosdk.live/v1/meetings",
  headers: {
    Authorization: "$YOUR_JWT_TOKEN",
  },
};
request(options, function (error, response) {
  if (error) throw new Error(error);
  console.log(response.body);
});
```

</TabItem>
<TabItem value="python">

```python
import requests

url = "https://api.videosdk.live/v1/meetings"

headers = {
  'Authorization': '$YOUR_JWT_TOKEN'
}

response = requests.request("GET", url, headers=headers)

print(response.text)

```

</TabItem>
<TabItem value="ruby">

```ruby
require "uri"
require "net/http"

url = URI("https://api.videosdk.live/v1/meetings")

https = Net::HTTP.new(url.host, url.port);
https.use_ssl = true

request = Net::HTTP::Get.new(url)
request["Authorization"] = "$YOUR_JWT_TOKEN"

response = https.request(request)
puts response.read_body

```

</TabItem>
<TabItem value="result">

```js
{
    "pageInfo": {
        "currentPage": 1,
        "perPage": 20,
        "lastPage": 4,
        "total": 65
    },
    "data": [
        {
            "meetingId": "yw3w-nfzh-9jl0",
            "userId": "5fa671e77b80d58c11cbca95",
            "createdAt": "2021-06-18T08:10:46.683Z",
            "updatedAt": "2021-06-18T08:10:46.683Z",
            "id": "60cc550656592b6a03d7a2d0"
        },
        ...
    ]
}
```

</TabItem>
</Tabs>

import MethodListGroup from '@theme/MethodListGroup';
import MethodListItemLabel from '@theme/MethodListItemLabel';
import MethodListHeading from '@theme/MethodListHeading';

### Request

<MethodListGroup>
    <MethodListGroup>
      <MethodListHeading heading="Query Parameters" />
      <MethodListItemLabel name="page" option={"optional"} type={"string"} />
      <MethodListItemLabel name="perPage" option={"optional"} type={"string"} />
    </MethodListGroup>
</MethodListGroup>

### Response

<MethodListGroup>
  <MethodListItemLabel name="__response"  type={"object"} >
    <MethodListGroup>
      <MethodListHeading heading="Properties" />
      <MethodListItemLabel name="pageInfo" type={"object"} >
        <MethodListGroup>
          <MethodListItemLabel name="currentPage"  type={"number"} />
          <MethodListItemLabel name="perPage"  type={"number"} />
          <MethodListItemLabel name="lastPage" type={"number"} />
        </MethodListGroup>
      </MethodListItemLabel>
      <MethodListItemLabel name="data" type={"Array<object>"} >
        <MethodListGroup>
          <MethodListItemLabel name="meetingId"  type={"string"} />
          <MethodListItemLabel name="userId"  type={"string"} />
          <MethodListItemLabel name="user" type={"object"} >
            <MethodListGroup>
              <MethodListItemLabel name="name"  type={"string"} />
              <MethodListItemLabel name="id"  type={"string"} />
            </MethodListGroup>
          </MethodListItemLabel>
          <MethodListItemLabel name="createdAt"  type={"date"} />
          <MethodListItemLabel name="updatedAt"  type={"date"} />
          <MethodListItemLabel name="id"  type={"string"} />
        </MethodListGroup>
      </MethodListItemLabel>
    </MethodListGroup>
  </MethodListItemLabel>
</MethodListGroup>


---

---
sidebar_position: 1
sidebar_label: List Meeting Sessions
---

import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>

# List Meeting Sessions - API

Use the following Rest API to list meeting sessions.

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="curl"
groupId={"server-group-id"}
values={[
{label: 'cURL request', value: 'curl'},
{label: 'NodeJS/JS', value: 'node'},
{label: 'Python', value: 'python'},
{label: 'Ruby', value: 'ruby'},
{label: 'RESULT', value: 'result'},
]}>
<TabItem value="curl">

```js

curl -L -X GET 'https://api.videosdk.live/v1/meeting-sessions' \
-H 'Authorization: $YOUR_JWT_TOKEN'

```

</TabItem>
<TabItem value="node">

```js
var request = require("request");
var options = {
  method: "GET",
  url: "https://api.videosdk.live/v1/meeting-sessions",
  headers: {
    Authorization: "$YOUR_JWT_TOKEN",
  },
};
request(options, function (error, response) {
  if (error) throw new Error(error);
  console.log(response.body);
});
```

</TabItem>
<TabItem value="python">

```python
import requests

url = "https://api.videosdk.live/v1/meeting-sessions"

headers = {
  'Authorization': '$YOUR_JWT_TOKEN'
}

response = requests.request("GET", url, headers=headers)

print(response.text)

```

</TabItem>
<TabItem value="ruby">

```ruby
require "uri"
require "net/http"

url = URI("https://api.videosdk.live/v1/meeting-sessions")

https = Net::HTTP.new(url.host, url.port);
https.use_ssl = true

request = Net::HTTP::Get.new(url)
request["Authorization"] = "$YOUR_JWT_TOKEN"

response = https.request(request)
puts response.read_body

```

</TabItem>
<TabItem value="result">

```js
{
   "pageInfo": {
        "currentPage": 1,
        "perPage": 20,
        "lastPage": 1,
        "total": 8
    },
    "data": [
        {
            "id": "616e79f7ba68c7768bfd18bf",
            "meetingId": "ywnm-eicr-d55x",
            "start": "2021-10-19T07:55:35.807Z",
            "end": "2021-10-19T07:55:39.941Z",
            "chatLink" : "https://cdn.videosdk.live/chats/hq3g-ny2g-kv8x-12348924f6213b0f00a9f7a6-6169bd856790717248e86cff.csv",
            "activeDuration": 0,
            "participants": [
                {
                    "participantId": "wcrkkrf4",
                    "name": "John Doe",
                    "timelog": [
                        {
                            "start": "2021-10-19T07:55:36.316Z",
                            "end": "2021-10-19T07:55:39.937Z"
                        }
                    ]
                }
            ]
}
```

</TabItem>
</Tabs>

import MethodListGroup from '@theme/MethodListGroup';
import MethodListItemLabel from '@theme/MethodListItemLabel';
import MethodListHeading from '@theme/MethodListHeading';

### Request

<MethodListGroup>
    <MethodListGroup>
      <MethodListHeading heading="Query Parameters" />
      <MethodListItemLabel name="page" option={"optional"} type={"string"} />
      <MethodListItemLabel name="perPage" option={"optional"} type={"string"} />
      <MethodListItemLabel name="meetingId" option={"optional"} type={"string"} />
    </MethodListGroup>
</MethodListGroup>

### Response

<MethodListGroup>
  <MethodListItemLabel name="__response"  type={"object"} >
    <MethodListGroup>
      <MethodListHeading heading="Properties" />
      <MethodListItemLabel name="pageInfo" type={"object"} >
        <MethodListGroup>
          <MethodListItemLabel name="currentPage"  type={"number"} />
          <MethodListItemLabel name="perPage"  type={"number"} />
          <MethodListItemLabel name="lastPage" type={"number"} />
        </MethodListGroup>
      </MethodListItemLabel>
      <MethodListItemLabel name="data" type={"Array<object>"} >
        <MethodListGroup>
          <MethodListItemLabel name="id"  type={"string"} />
          <MethodListItemLabel name="meetingId"  type={"string"} />
          <MethodListItemLabel name="chatLink" type={"string"} />
          <MethodListItemLabel name="start"  type={"date"} />
          <MethodListItemLabel name="end"  type={"date"} />
          <MethodListItemLabel name="activeDuration" type={"number"} >
          <MethodListItemLabel name="participants" type={"Array<object>"} />
            <MethodListGroup>
              <MethodListItemLabel name="participantId"  type={"string"} />
              <MethodListItemLabel name="name"  type={"string"} />
               <MethodListItemLabel name="timelog" type={"Array<object>"} />
               <MethodListGroup>
                    <MethodListItemLabel name="start"  type={"date"} />
                    <MethodListItemLabel name="end"  type={"date"} />
                </MethodListGroup>
            </MethodListGroup>
          </MethodListItemLabel>
        </MethodListGroup>
      </MethodListItemLabel>
    </MethodListGroup>

  </MethodListItemLabel>
</MethodListGroup>


---

---
sidebar_position: 1
---

import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>

# List Meeting Recordings - API

Use the following Rest API to list recordings.

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="curl"
groupId={"server-group-id"}
values={[
{label: 'cURL request', value: 'curl'},
{label: 'NodeJS/JS', value: 'node'},
{label: 'Python', value: 'python'},
{label: 'Ruby', value: 'ruby'},
{label: 'RESULT', value: 'result'},
]}>
<TabItem value="curl">

```js

curl -L -X GET 'https://api.videosdk.live/v1/meeting-recordings' \
-H 'Authorization: $YOUR_JWT_TOKEN'

```

</TabItem>
<TabItem value="node">

```js
var request = require("request");
var options = {
  method: "GET",
  url: "https://api.videosdk.live/v1/meeting-recordings",
  headers: {
    Authorization: "$YOUR_JWT_TOKEN",
  },
};
request(options, function (error, response) {
  if (error) throw new Error(error);
  console.log(response.body);
});
```

</TabItem>
<TabItem value="python">

```python
import requests

url = "https://api.videosdk.live/v1/meeting-recordings"

headers = {
  'Authorization': '$YOUR_JWT_TOKEN'
}

response = requests.request("GET", url, headers=headers)

print(response.text)

```

</TabItem>
<TabItem value="ruby">

```ruby
require "uri"
require "net/http"

url = URI("https://api.videosdk.live/v1/meeting-recordings")

https = Net::HTTP.new(url.host, url.port);
https.use_ssl = true

request = Net::HTTP::Get.new(url)
request["Authorization"] = "$YOUR_JWT_TOKEN"

response = https.request(request)
puts response.read_body

```

</TabItem>
<TabItem value="result">

```js
{
    "pageInfo": {
        "currentPage": 1,
        "perPage": 20,
        "lastPage": 1,
        "total": 20
    },
    "data": [
      {
            "userId": "5f7edbb14c938bcd42944517",
            "meetingId": "hv6a-uwrj-8jbd",
            "origFileId": "60df15dc1b5d6a3205573786",
            "jobId": "60df15df7433b02e7d06853a",
            "createdAt": "2021-07-02T13:34:23.768Z",
            "updatedAt": "2021-07-02T13:34:30.616Z",
            "fileId": "60df15e61b5d6a3205533289",
            "file": {
                "meta": {
                    "resolution": {
                        "width": 1280,
                        "height": 720
                    },
                    "format": "mov,mp4,m4a,3gp,3g2,mj2",
                    "duration": 3.561
                },
                "jobId": "60df15df7433b02e1d06653a",
                "filePath": "encoded/videos/60df15dc1b5d6a8205573286/720.mp4",
                "size": 613596,
                "type": "video",
                "createdAt": "2021-07-02T13:34:30.566Z",
                "updatedAt": "2021-07-02T13:34:30.566Z",
                "fileUrl": "https://cdn.videosdk.live/encoded/videos/60df15dc1b5d6a8205573286/720.mp4",
                "id": "60df15e61b5d6a3805573289"
            },
            "id": "60df15df7433b02e3d06653c"
        },
        {...}
    ]
}
```

</TabItem>
</Tabs>

import MethodListGroup from '@theme/MethodListGroup';
import MethodListItemLabel from '@theme/MethodListItemLabel';
import MethodListHeading from '@theme/MethodListHeading';

### Request

<MethodListGroup>
    <MethodListGroup>
      <MethodListHeading heading="Query Parameters" />
      <MethodListItemLabel name="page" option={"optional"} type={"string"} />
      <MethodListItemLabel name="perPage" option={"optional"} type={"string"} />
      <MethodListItemLabel name="meetingId" option={"optional"} type={"string"} />
      <MethodListItemLabel name="sessionId" option={"optional"} type={"string"} />
    </MethodListGroup>
</MethodListGroup>

### Response

<MethodListGroup>
  <MethodListItemLabel name="__response"  type={"object"} >
    <MethodListGroup>
      <MethodListHeading heading="Properties" />
      <MethodListItemLabel name="pageInfo" type={"object"} >
        <MethodListGroup>
          <MethodListItemLabel name="currentPage"  type={"number"} />
          <MethodListItemLabel name="perPage"  type={"number"} />
          <MethodListItemLabel name="lastPage" type={"number"} />
          <MethodListItemLabel name="total" type={"number"} />
        </MethodListGroup>
      </MethodListItemLabel>
      <MethodListItemLabel name="data" type={"Array<object>"} >
        <MethodListGroup>
          <MethodListItemLabel name="userId"  type={"string"} />
          <MethodListItemLabel name="meetingId"  type={"string"} />
          <MethodListItemLabel name="sessionId"  type={"string"} />
          <MethodListItemLabel name="origFileId"  type={"string"} />
          <MethodListItemLabel name="jobId"  type={"string"} />
          <MethodListItemLabel name="fileId"  type={"string"} />
          <MethodListItemLabel name="file" type={"object"} >
            <MethodListGroup>
                <MethodListItemLabel name="meta" type={"object"} >
                  <MethodListGroup>
                          <MethodListItemLabel name="resolution" type={"object"} >
                            <MethodListGroup>
                                <MethodListItemLabel name="width"  type={"number"} />
                                <MethodListItemLabel name="height"  type={"number"} />
                            </MethodListGroup>
                          </MethodListItemLabel>
                      <MethodListItemLabel name="format"  type={"string"} />
                      <MethodListItemLabel name="duration"  type={"number"} />
                  </MethodListGroup>
                </MethodListItemLabel>
              <MethodListItemLabel name="jobId"  type={"string"} />
              <MethodListItemLabel name="filePath"  type={"string"} />
              <MethodListItemLabel name="size"  type={"number"} />
              <MethodListItemLabel name="type"  type={"string"} />
              <MethodListItemLabel name="fileUrl"  type={"string"} />
              <MethodListItemLabel name="updatedAt"  type={"date"} />
              <MethodListItemLabel name="createdAt"  type={"date"} />
              <MethodListItemLabel name="id"  type={"string"} />
            </MethodListGroup>
          </MethodListItemLabel>
          <MethodListItemLabel name="createdAt"  type={"date"} />
          <MethodListItemLabel name="updatedAt"  type={"date"} />
          <MethodListItemLabel name="id"  type={"string"} />
        </MethodListGroup>
      </MethodListItemLabel>
    </MethodListGroup>
  </MethodListItemLabel>
</MethodListGroup>


---

---
sidebar_position: 1
sidebar_label: Remove Participant
---

import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>

# Remove Participant - API

Use the following Rest API to remove a participant from a running session.

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="curl"
groupId={"server-group-id"}
values={[
{label: 'cURL request', value: 'curl'},
{label: 'NodeJS/JS', value: 'node'},
{label: 'Python', value: 'python'},
{label: 'Ruby', value: 'ruby'},
{label: 'RESULT', value: 'result'},
]}>
<TabItem value="curl">

```js
cURL -H "Content-Type: application/json" \
     -H "Authorization: $YOUR_JWT_TOKEN" \
     -d '{"participantId": "<participant-id>"}' \
     -XPOST \
     https://api.videosdk.live/v1/meeting-sessions/:id/remove-participant
```

</TabItem>
<TabItem value="node">

```js
var request = require("node-fetch");

var options = {
  method: "POST",
  url: "https://api.videosdk.live/v1/meeting-sessions/:id/remove-participant",
  headers: { authorization: `${YOUR_JWT_TOKEN}` },
  body: JSON.stringify({ participantId: "<participant-id>" }),
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
```

</TabItem>
<TabItem value="python">

```python
import requests

url = "https://api.videosdk.live/v1/meeting-sessions/:id/remove-participant"

headers = {'authorization': f'Bearer {YOUR_JWT_TOKEN}'}

data = {"participantId": "<participant-id>"}

response = requests.request("POST", url, headers=headers, data=data)

print(response.text)
```

</TabItem>
<TabItem value="ruby">

```ruby
require 'uri'
require 'net/http'

url = URI("https://api.videosdk.live/v1/meeting-sessions/:id/remove-participant")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
http.verify_mode = OpenSSL::SSL::VERIFY_NONE

request = Net::HTTP::Get.new(url)
request["authorization"] = "Bearer #{YOUR_JWT_TOKEN}"
request.body = "{\"participantId\":\"<participant-id>\"}"

response = http.request(request)
puts response.read_body
```

</TabItem>

<TabItem value="result">

```js
{
    "id": "61adc697a239e84d0aaa7e15",
    "meetingId": "25af-rsr2-lk92",
    "start": "2021-12-06T08:15:19.121Z",
    "end": null,
    "participants": [
        {
            "participantId": "c7wgj9sd",
            "name": "John Dow",
            "timelog": [
                {
                    "start": "2021-12-06T08:15:20.565Z",
                    "end": null
                }
            ]
        },
        {
            "participantId": "ofwb7db6",
            "name": "John Dow",
            "timelog": [
                {
                    "start": "2021-12-06T08:15:27.585Z",
                    "end": null
                }
            ]
        }
    ]
}
```

</TabItem>
</Tabs>

import MethodListGroup from '@theme/MethodListGroup';
import MethodListItemLabel from '@theme/MethodListItemLabel';
import MethodListHeading from '@theme/MethodListHeading';

### Request

<MethodListGroup>
    <MethodListGroup>
      <MethodListHeading heading="Path Parameters" />
      <MethodListItemLabel name="id" option={"session-id"} type={"string"} />
    </MethodListGroup>
</MethodListGroup>

### Response

<MethodListGroup>
  <MethodListItemLabel name="__response"  type={"object"} >
    <MethodListGroup>
    <MethodListHeading heading="Properties" />
          <MethodListItemLabel name="id"  type={"string"} />
          <MethodListItemLabel name="meetingId"  type={"string"} />
          <MethodListItemLabel name="start"  type={"date"} />
          <MethodListItemLabel name="end"  type={"date"} />
          <MethodListItemLabel name="participants" type={"Array<object>"} >
            <MethodListGroup>
              <MethodListItemLabel name="participantId"  type={"string"} />
              <MethodListItemLabel name="name"  type={"string"} />
               <MethodListItemLabel name="timelog" type={"Array<object>"} >
               <MethodListGroup>
                    <MethodListItemLabel name="start"  type={"date"} />
                    <MethodListItemLabel name="end"  type={"date"} />
                </MethodListGroup>
                </MethodListItemLabel>
            </MethodListGroup>
          </MethodListItemLabel>
    </MethodListGroup>
  </MethodListItemLabel>
</MethodListGroup>


---

---
sidebar_position: 1
sidebar_label: Delete Recordings
---

import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>

# Delete Recordings - API

Use the following Rest API to delete recordings.

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="curl"
groupId={"server-group-id"}
values={[
{label: 'cURL request', value: 'curl'},
{label: 'NodeJS/JS', value: 'node'},
{label: 'Python', value: 'python'},
{label: 'Ruby', value: 'ruby'},
{label: 'RESULT', value: 'result'},
]}>
<TabItem value="curl">

```js

curl -L -X DELETE 'https://api.videosdk.live/v1/meeting-recordings/:id' \
-H 'Authorization: $YOUR_JWT_TOKEN'

```

</TabItem>
<TabItem value="node">

```js
var request = require("request");
var options = {
  method: "DELETE",
  url: "https://api.videosdk.live/v1/meeting-recordings/:id",
  headers: {
    Authorization: "$YOUR_JWT_TOKEN",
  },
};
request(options, function (error, response) {
  if (error) throw new Error(error);
  console.log(response.body);
});
```

</TabItem>
<TabItem value="python">

```python
import requests

url = "https://api.videosdk.live/v1/meeting-recordings/:id"

headers = {
  'Authorization': '$YOUR_JWT_TOKEN'
}

response = requests.request("DELETE", url, headers=headers)

print(response.text)

```

</TabItem>
<TabItem value="ruby">

```ruby
require "uri"
require "net/http"

url = URI("https://api.videosdk.live/v1/meeting-recordings/:id")

https = Net::HTTP.new(url.host, url.port)
https.use_ssl = true

request = Net::HTTP::Delete.new(url)
request["Authorization"] = "$YOUR_JWT_TOKEN"

response = https.request(request)
puts response.read_body

```

</TabItem>
<TabItem value="result">

```
"Room Recording deleted successfully"
```

</TabItem>
</Tabs>

import MethodListGroup from '@theme/MethodListGroup';
import MethodListItemLabel from '@theme/MethodListItemLabel';
import MethodListHeading from '@theme/MethodListHeading';

### Request

<MethodListGroup>
    <MethodListGroup>
      <MethodListHeading heading="Path Parameters" />
      <MethodListItemLabel name="id" option={"optional"} type={"string"} />
    </MethodListGroup>
</MethodListGroup>

### Response

<MethodListGroup>
  <MethodListItemLabel name="__response"  type={"object"} >
  </MethodListItemLabel>
</MethodListGroup>


---

---
sidebar_position: 1
---

import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>

# Architecture


---

---
sidebar_position: 1
---

import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>

# Demos


---

---
sidebar_position: 1
---

import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>

# Device and Browser Support

## Browser Support

We support the following web browsers:

- Chrome 74 and above
- Safari 12.1 and above
- Firefox 78 ESR and above
- Microsoft Edge 74 and above.
- Electron 6 and above
- IOS Safari (in IOS 12.1 and later)
- 3rd-party browsers (such as Chrome) and in-app browsers (such as the Gmail app's built-in browser) using WKWebView, as of IOS 14
- Android Chrome, Firefox, Samsung Internet, and Chromium-based 3rd-party browsers

## Screen sharing

- To start a screen share, a user must be on desktop. A user can start a screen share from Chrome, Safari, or Firefox on desktop.
- To clarify, all browsers can view screen shares. A mobile user can see a screen share (but only a call participant on desktop can share their screen).

## Mobile support

- IOS 12.1 and later versions
- Android 5.0 and above with current security and platform updates


---

---
sidebar_position: 1
---

# Hippa Compliance for Healthcare

import Method from '../../../../src/theme/HippaRedirection'
import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>
<Method/>


---

---
sidebar_position: 1
---

import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>

# Tutorials


---

---
sidebar_position: 0
---

import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>

# Beginner Tutorial JavaScript

## Terminology

Let's start with the terms used in VideoSDK meeting Client SDK.

### Meeting

A Meeting represents real-time audio, video, and/or screen-share session, and is the basic building block for media sharing among participants. Supports upto 5,000 participants.

### Participants

Participants are the client applications that are connected to a Meeting and shares video & audio media with one another.

### Local Participant

Participant producing audio or video stream from the local client's media sources

### Streams

Streams are indiviual video & audio streams produced by the participants in the meeting

### Active Speaker

Active speaker represents the participant who is currently producing highest decibels audio stream (in other words speaking)

### Active presenter

Active presenter is the participant who is currently sharing his/her screen as a video stream

### Main participant

Main participant represents the client who shall be displayed on the main screen indicating that he/she is either presenting or speaking

---

## Installation

### Get an API key

Signup on the VideoSDK website to get a key pair for SDK authentication. Your **API Key** and **Secret** will be visible on the console dashboard.

### Integrate

Include this in your HTML file

```html title="index.html"
<script src="https://sdk.videosdk.live/js-sdk/0.1.6/videosdk.js"></script>
```

---

## Step 0: Access token generation (server-side code)

An access token is required to authenticate with the VideoSDK and make any API calls. You can generate one with the `API key` and `secret` mentioned in your developer portal at VideoSDK console.

## Generate access token (NodeJS)

```js {20} title="server.js"
const express = require("express");
const jwt = require("jsonwebtoken");
const cors = require("cors");
const request = require("request");

const app = express();
const port = 9000;
app.use(cors());
app.use(express.json());
app.use(express.urlencoded({ extended: true }));

app.get("/get-token", (req, res) => {
  const API_KEY = process.env.VIDEOSDK_API_KEY;
  const SECRET_KEY = process.env.VIDEOSDK_SECRET_KEY;
  const options = { expiresIn: "10m", algorithm: "HS256" };
  const payload = {
    apikey: API_KEY,
    permissions: ["allow_join", "allow_mod", "ask_join"], // Trigger permission.
  };
  const token = jwt.sign(payload, SECRET_KEY, options);
  res.json({ token });
});

app.listen(port, () => {
  console.log(`Example app listening at http://localhost:${port}`);
});
```

Available permissions are:

- `allow_join`: The participant will be permitted entry without request.
- `ask_join`: The participant will not be permitted entry without request.
- `allow_mod`: Allow participant to enable/disable other participant's mic/webcam.

This generated token must be sent in the `Authorization` header for all API calls. <br/>
And it should also be used with the `VideoSDK.config(token)` method.

## Step 1: Create or join meeting

Get a meeting id for new meeting or validate an existing meeting id to join a meeting.

### Create new meeting ID

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="curl"
groupId={"server-group-id"}
values={[
{label: 'cURL request creates meeting', value: 'curl'},
{label: 'NodeJS/JS', value: 'node'},
{label: 'Python', value: 'python'},
{label: 'Ruby', value: 'ruby'},
{label: 'RESULT', value: 'result'},
]}>
<TabItem value="curl">

```js
cURL -H "Content-Type: application/json" \
     -H "Authorization: $YOUR_JWT_TOKEN" \
     -XPOST \
     https://api.videosdk.live/v1/meetings
```

</TabItem>
<TabItem value="node">

```js
var request = require("request");

var options = {
  method: "POST",
  url: "https://api.videosdk.live/v1/meetings",
  headers: { authorization: `${YOUR_JWT_TOKEN}` },
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
```

</TabItem>
<TabItem value="python">

```python
import requests

url = "https://api.videosdk.live/v1/meetings"

headers = {'authorization': f'Bearer {YOUR_JWT_TOKEN}'}

response = requests.request("GET", url, headers=headers)

print(response.text)
```

</TabItem>
<TabItem value="ruby">

```ruby
require 'uri'
require 'net/http'

url = URI("https://api.videosdk.live/v1/meetings")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
http.verify_mode = OpenSSL::SSL::VERIFY_NONE

request = Net::HTTP::Get.new(url)
request["authorization"] = "Bearer #{YOUR_JWT_TOKEN}"

response = http.request(request)
puts response.read_body
```

</TabItem>
<TabItem value="result">

```js
{
  "meetingId":"jpkf-iool-64ox"
}
```

</TabItem>
</Tabs>

OR

### Validate existing meeting ID for joining

<Tabs
defaultValue="curl"
groupId={"server-group-id"}
values={[
{label: 'cURL request creates meeting', value: 'curl'},
{label: 'NodeJS/JS', value: 'node'},
{label: 'Python', value: 'python'},
{label: 'Ruby', value: 'ruby'},
{label: 'RESULT', value: 'result'},
]}>
<TabItem value="curl">

```js
cURL -H "Content-Type: application/json" \
     -H "Authorization: $YOUR_JWT_TOKEN" \
     -XPOST \
     https://api.videosdk.live/v1/meetings/${meetingId}
```

</TabItem>
<TabItem value="node">

```js
var request = require("request");

var options = {
  method: "POST",
  url: "https://api.videosdk.live/v1/meetings/${meetingId}",
  headers: { authorization: `${YOUR_JWT_TOKEN}` },
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
```

</TabItem>
<TabItem value="python">

```python
import requests

url = "https://api.videosdk.live/v1/meetings/${meetingId}"

headers = {'authorization': f'Bearer {YOUR_JWT_TOKEN}'}

response = requests.request("GET", url, headers=headers)

print(response.text)
```

</TabItem>
<TabItem value="ruby">

```ruby
require 'uri'
require 'net/http'

url = URI("https://api.videosdk.live/v1/meetings/${meetingId}")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
http.verify_mode = OpenSSL::SSL::VERIFY_NONE

request = Net::HTTP::Get.new(url)
request["authorization"] = "Bearer #{YOUR_JWT_TOKEN}"

response = http.request(request)
puts response.read_body
```

</TabItem>
<TabItem value="result">

```js
{
  "meetingId":"jpkf-iool-64ox"
}
```

</TabItem>
</Tabs>

## Step 2: Initialize meeting

To initialize meeting you need to provide the following parameters:

- `meetingId: string` from the previous step to specify which meeting to join in.
- `name: string` which will be displayed as username of participant in the meeting.
- `micEnabled: boolean` option to indicate if mic should be on while joining.
- `webcamEnabled: boolean` option to indicate if webcam should be on while joining.
- `maxResolution: "sd" | "hd"` defines the maximum available resolution for webcam video.

```javascript title="Intialize meeting instance"
const meeting = VideoSDK.initMeeting({
  meetingId, // required
  name, // required
  micEnabled, // optional, default: true
  webcamEnabled, // optional, default: true
  maxResolution, // optional, default: "hd"
});
```

The `meeting` object consists of:

- Properties:

  - `id: string`
  - `activeSpeakerId: string`
  - `activePresenterId: string`
  - `mainParticipantId: string`
  - `localParticipant: Participant`
  - `participants: Map<string, Participant>`
  - `messages: Array<{senderId: string, text: string, timestamp: number}>`

- Events:

  - `participant-joined`, `participant-left`
  - `speaker-changed`, `presenter-changed`
  - `main-participant-changed`
  - `entry-requested`, `entry-responded`
  - `recording-started`, `recording-stopped`
  - `stream-enabled`, `stream-disabled`
  - `chat-message`

- Methods:
  - `join()`, `leave()`
  - `muteMic()`, `unmuteMic()`
  - `disableWebcam()`, `enableWebcam()`
  - `disableScreenShare()`, `enableScreenShare()`
  - `on(eventType: string)`, `off(eventType: string)`
  - `respondEntry(participantId: string, decision: "allowed" | "denied")`
  - `startRecording(webhookUrl: string, , awsDirPath: string)`, `stopRecording()`
  - `sendChatMessage(text: string)`

## Step 3: Get local and remote participants

You can get the local streams and participant meta from `meeting.localParticipant`. And a `Map` of joined participants is always available via `meeting.participants`.

```javascript title="Access meeting participants"
const localParticipant = meeting.localParticipant;
const participants = meeting.participants;
```

Each `participant` object consists of:

- Properties:

  - `id: string`
  - `displayName: string`
  - `streams: Map<string, Stream>`

- Events:

  - `stream-enabled`
  - `stream-disabled`

- Methods:
  - `setQuality(quality: "low" | "med" | "high")`
  - `enableMic()`, `disableMic()`
  - `enableWebcam()`, `disableWebcam()`
  - `on(eventType: string)`, `off(eventType: string)`

## Step 4: Listen for entry request events

When participant asks for entry in a meeting that you are connected to, you will be notified via `entry-requested` and when you or any other participant's entry is responded, `entry-responded` will be fired.

```javascript title="Get request from user"
meeting.on("entry-requested", (participantId, name) => {
  setEntryRequests([...entryRequestsRef.current, { id: participantId, name }]);

  // you can open a dialog to respond with
  // decision "allowed" or "denied" with the following method
  meeting.respondEntry(participantId, decision);
});

meeting.on("entry-responded", (participantId, decision) => {
  // decision parameter will be: "allowed" or "denied"

  setEntryRequests(
    entryRequestsRef.current.filter((r) => r.id !== participantId)
  );
});
```

## Step 5: Listen for new & leaving participant events

When participant joins or leaves a meeting that you are connected to, you will be notified via `participant-joined` and `participant-left` events respectively.

```javascript "Listen on participant joined and left"
meeting.on("participant-joined", (participant) => {
  setParticipants(new Map(meeting.participants));
});

meeting.on("participant-left", (participant) => {
  setParticipants(new Map(meeting.participants));
});
```

## Step 6: Listen for audio/video stream events

When a participant from meeting enables or diables a audio/video stream, you will be notified via `stream-enabled` and `stream-disabled` events from the participant object.

```javascript title="Listen on stream enabled and disabled"
participant.on("stream-enabled", (stream) => {
  if (stream.kind === "video") {
    // play video track on a <video /> element
  } else if (stream.kind === "audio") {
    // play audio track on a <audio /> element
  } else if (stream.kind === "share") {
    // play screen sharing video track on a <video /> element
  }
});

participant.on("stream-disabled", (stream) => {
  if (stream.kind === "video") {
    // remove video track or the <video /> element
  } else if (stream.kind === "audio") {
    // remove audio track or the <audio /> element
  } else if (stream.kind === "share") {
    // remove screen sharing video track or the <video /> element
  }
});
```

Each `stream` object consists of:

- Properties:

  - `id: string`
  - `kind: string`
  - `codec: string`
  - `track: MediaStreamTrack`

- Methods:
  - `pause()`
  - `resume()`

### Note: Chrome Autoplay policy workaround

Chrome's autoplay policy does not allow audio autoplay unless user has interacted with the domain (click, tap, etc.) or the user's <a href="https://developers.google.com/web/updates/2017/09/autoplay-policy-changes#mei">Media engagement Index</a> threshold has been crossed. Thus, as a workaround before starting the meeting, user can either create a meeting join page or create a join meeting confirmation dialog by which we can perform a user click interaction to enable audio autoplay in chrome's newer versions.

## Step 7: Main screen video (optional)

When a participant who is currently presenting or speaking is changed in the meeting, you will be notified via `main-participant-changed` event.

```javascript title="Listen on main participant changed"
meeting.on("main-participant-changed", (participant) => {
  // show participant video stream on main screen
});
```

## Step 8: Join the meeting

After we set local participant, main-screen participant, other participants, participant event handlers and stream event handlers from the meeting, next step is to join the meeting by calling `meeting.join()`. This will trigger `participant-joined` event for all other participants.

```javascript title="Leave meeting"
meeting.join();
```

## Step 9: Utility methods & events (optional)

### Mute/Unmute mic

Toggle own mic with the `unmuteMic()` and `muteMic()` methods. Toggling mic will trigger `stream-enabled` and `stream-disabled` events for all other participants when enabling and disabling mic.

```javascript title="Mic methods"
// unmute/mute your own mic
meeting.unmuteMic();
meeting.muteMic();

// unmute/mute other participant's mic
participant.unmuteMic();
participant.muteMic();
```

### Enable/Disable Webcam

Toggle own webcam with the `enableWebcam()` and `disableWebcam()` methods. Toggling webcam will trigger `stream-enabled` and `stream-disabled` events for all other participants when enabling and disabling webcam.

```javascript title="Webcam methods"
// disable/enable your own webcam
meeting.enableWebcam();
meeting.disableWebcam();

// disable/enable other participant's webcam
participant.enableWebcam();
participant.disableWebcam();
```

### Enable/Disable Screen share

Share your screen with the `enableScreenShare()` method and stop sharing with `disableScreenShare()`. Toggling screen-share will trigger `stream-enabled` and `stream-disabled` events for all other participants when enabling and disabling screen-share.

```javascript title="Screen share methods"
meeting.enableScreenShare();
meeting.disableScreenShare();
```

### Start/Stop recording

Record the meeting session with `startRecording(webhookUrl, awsDirPath)` method and stop recording with `stopRecording()`. Toggling recording will trigger `recording-started` and `recording-stopped` events for all participants when starting and stopping recording respectively.

```javascript title="Start and stop recordings methods"
// The webhook will be called with the fileUrl as a POST request when the recording is processed.
meeting.startRecording(
  "https://your-app-server.com/api/recordings",
  "meetings/meeting-id"
);
meeting.stopRecording();

// ...

meeting.on("recording-started", () => {
  setRecordStatus("active");

  // 🔴 notify all users of recording start
});

meeting.on("recording-stopped", () => {
  setRecordStatus("inactive");

  // ⚫ notify all users of recording end
});
```

### In-meeting Chat

Send messages with the `sendChatMessage(text)` method and all other participants will be notified via `chat-message` event.

```javascript title="Send and receive chat message"
meeting.sendChatMessage("Hello world!");

// ...

meeting.on("chat-message", (data) => {
  setChatMessages([...meeting.messages]);

  const { senderId, text, timestamp } = data;

  // 📢 notify user or show in the chat window
});
```

### Active speaker event

The `speaker-changed` event will be fired whenever the loudest speaking participant changes.

```javascript title="Listen on active speaker changed"
meeting.on("speaker-changed", (participant) => {
  // indicate participant as speaking
});
```

### Active presenter event

The `presenter-changed` event will be fired whenever someone enables screen sharing.

```javascript title="Listen on presenter changed"
meeting.on("presenter-changed", (participant) => {
  // indicate participant as presenting screen
});
```

### Set participant video quality

Update the participant video quality based on use case to `"low" | "med" | "high"`.

```javascript title="Set quelity of receiving stream"
participant.setQuality("low");
```

### Start/Stop video

Share video link to play with `startVideo({ link })` method and stop video with `stopVideo()`. Toggling video will trigger `video-started` and `video-stopped` events for all participants when starting and stopping video respectively.
​

```javascript
// The webhook will be called with the fileUrl as a POST request when the video is processed.
meeting.startVideo({ link: "https://your-app-server.com/video/demo.mp4" });
meeting.stopVideo();
​
​
// Listening on start of the video stream.
meeting.on("video-started", ({ link, currentTime }) => {
  videoRef.current.src = link;
  videoRef.current.currentTime = currentTime;
});

// Listening to the stopped video stream.
meeting.on("video-stopped", () => {
  videoRef.current.pause();
  videoRef.current.src = null;
});
```

### Restream meeting on social media

Restream meeting on your favorite social media channels using RTMP key and url.

```javascript
// start livestreaming
meeting.startLivestream([
  {
    url: "rtmp://x.rtmp.youtube.com/live2/",
    streamKey: "abcd-h6a2-pqrs-vusv-prpf",
  },
]);
​
// stop livestreaming
meeting.stopLivestream();
```

## Leave the meeting

You can disconnect from the meeting with `meeting.leave()` method. This will trigger `participant-left` event for all other participants.

```javascript title="Leave meeting"
meeting.leave();
```


---

---
title: Acquire Resource
sidebar_position: 1
sidebar_label: Acquire Resource
hide_table_of_contents: true
---

# Acquire Resource - Beta API

import Method from '../../../src/theme/RestApiMethodContainer'
import {acquireResource} from './data/acquire-resource.js'
import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>
<Method
{...acquireResource}
/>


---

---
title: Architecture of Real time communication API
hide_title: false
hide_table_of_contents: false
description: Architecture of Real time communication API is quite simple to understand before jumping directly to build application.
sidebar_label: Architecture
pagination_label: Architecture
keywords:
  - RTC API
  - RTC SDK
  - video API
  - audio rooms API
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: architecture
---

import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>

## Architecture

import Mermaid from '@theme/Mermaid';

<Mermaid chart={`sequenceDiagram Host->>App Server: Request for token; App Server->>Host: Received token; Host->>App Server: Request for meetingId; App Server->>VideoSDK Server: Request for meetingId; VideoSDK Server->>App Server: Sending meetingId; App Server->>Host: Received meetingId; Host->>Participants: Broadcast meetingId; Host->>App Server: Start Meeting; Participants-->>App Server: Join Meeting; Participants->>App Server: Request for token; App Server->>Participants: Received token; Participants->>App Server: Validate meetingId; Participants->>App Server: Leave Meeting; Host->>App Server: End Meeting;`}/>

## Terminology

### Meeting

A Meeting represents real-time audio, video, and/or screen-share session, and is the basic building block for media sharing among participants.

### Participants

Participants are the client applications that are connected to a Meeting and shares video & audio media with one another.

### Local Participant

Participant producing audio or video stream from the local client's media sources

### Streams

Streams are indiviual video & audio streams produced by the participants in the meeting

### Active Speaker

Active speaker represents the participant who is currently producing highest decibels audio stream (in other words speaking)

### Active presenter

Active presenter is the participant who is currently sharing his/her screen as a video stream

### Main participant

Main participant represents the client who shall be displayed on the main screen indicating that he/she is either presenting or speaking

---


---

---
title: Authentication
description: RTC SDK provides wide range of features to build your own custom video chat application without worrying about performance issues and scaling.
sidebar_label: Authentication
pagination_label: Authentication
keywords:
  - RTC API
  - RTC SDK
  - video API
  - audio rooms API
sidebar_position: 1
---

import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>

- The VideoSDK API uses authentication token to authenticate api requests.

- In REST APIs, token will be passed in header field called "Authorization".

- For Example:

import GenerateToken from '../../../src/theme/GenerateTokenContainer'
import data from './data/generate-token.json'

<GenerateToken
{...data}
/>

---

# How to generate authentication token ?

- In order to generate authentication token, you will need `API_KEY` and `SECRET`, which you can get them from [here](https://app.videosdk.live/api-keys).

- In payload, you will add your `apikey` and `permissions`.

  - `apikey`: You can get it from [here](https://app.videosdk.live/api-keys).
  - `permissions`: List of permissions that you want to allow.
    - `allow_join`
    - `allow_mod`
    - `ask_join`

- Then, you will sign this payload with your `SECRET` and jwt options.

- You can learn more, [here](https://jwt.io/introduction)


---

---
sidebar_position: 1
sidebar_label: Combine Stream Start
hide_table_of_contents: true
---

# Start All Streams - API

import Method from '../../../src/theme/RestApiMethodContainer'
import data from './data.json'
import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>
<Method
{...data.startCombineStream}
/>


---

---
sidebar_position: 1
sidebar_label: Combine Stream Stop
hide_table_of_contents: true
---

# Stop All streams - API

import Method from '../../../src/theme/RestApiMethodContainer'
import data from './data.json'
import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>
<Method
{...data.stopCombineStream}
/>


---

---
title: Create a Room
sidebar_position: 1
sidebar_label: Create a Room
hide_table_of_contents: true
---

# Create a Room - API

import Method from '../../../src/theme/RestApiMethodContainer'
import { createRoom } from './data/create-room.js'
import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>
<Method
{...createRoom}
/>


---

---
title: Deactivate a Room
sidebar_position: 5
sidebar_label: Deactivate a Room
hide_table_of_contents: true
---

# Deactivate a Room - API

import Method from '../../../src/theme/RestApiMethodContainer'
import data from './data/deactivate-room.json'
import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>
<Method
{...data.deactivateRoom}
/>


---

---
title: Delete An HLS - API
sidebar_position: 1
sidebar_label: Delete an HLS
hide_table_of_contents: true
---

#

import Method from '../../../src/theme/RestApiMethodContainer'
import data from './data/delete-hls.json'
import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>
<Method
{...data.deleteHls}
/>


---

---
title: Delete A Participant Recording
sidebar_position: 1
sidebar_label: Delete a Participant Recording
hide_table_of_contents: true
---

# Delete A Participant Recording - API

import Method from '../../../src/theme/RestApiMethodContainer'
import data from './data/delete-participant-recording.json'
import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>
<Method
{...data.deleteParticipantRecording}
/>


---

---
title: Delete A Recording
sidebar_position: 1
sidebar_label: Delete a Recording
hide_table_of_contents: true
---

# Delete A Recording - API

import Method from '../../../src/theme/RestApiMethodContainer'
import data from './data/delete-recording.json'
import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>
<Method
{...data.deleteRecording}
/>


---

---
title: Delete A Track Recording
sidebar_position: 1
sidebar_label: Delete a Track Recording
hide_table_of_contents: true
---

# Delete A Track Recording - API

import Method from '../../../src/theme/RestApiMethodContainer'
import data from './data/delete-track-recording.json'
import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>
<Method
{...data.deleteTrackRecording}
/>


---

---
title: End Session
sidebar_position: 1
sidebar_label: End Session
hide_table_of_contents: true
---

# End Session - API

import Method from '../../../src/theme/RestApiMethodContainer'
import data from './data/end-session.json'
import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>
<Method
{...data.endSession}
/>


---

---
title: Fetch A Merge Recording
sidebar_position: 1
sidebar_label: Fetch A Merge Recording
hide_table_of_contents: true
---

# Fetch A Merge Recording - API

import Method from '../../../src/theme/RestApiMethodContainer'
import { fetchAMergeRecording } from './data/fetch-a-merge-recording.js'

<Method
  {...fetchAMergeRecording}
/>


---

---
title: Fetch A Participant Recording
sidebar_position: 1
sidebar_label: Fetch a Participant Recording
hide_table_of_contents: true
---

# Fetch a Participant Recording - API

import Method from '../../../src/theme/RestApiMethodContainer'
import data from './data/fetch-a-participant-recording.json'

<Method
{...data.fetchAParticipantRecording}
/>


---

---
title: Fetch a Post Transcription & Summary
sidebar_position: 1
sidebar_label: Fetch a Post Transcription & Summary
hide_table_of_contents: true
---

# Fetch a Post Transcription & Summary - API

import Method from '../../../src/theme/RestApiMethodContainer'
import data from './data/fetch-a-post-transcription.json'

<Method
{...data.fetchPostTranscription}
/>


---

---
title: Fetch a Realtime Transcription
sidebar_position: 1
sidebar_label: Fetch a Realtime Transcription
hide_table_of_contents: true
---

# Fetch a Realtime Transcription - API

import Method from '../../../src/theme/RestApiMethodContainer'
import data from './data/fetch-a-realtime-transcription.json'

<Method
{...data.fetchRealtimeTranscription}
/>


---

---
title: Fetch A Resource
sidebar_position: 1
sidebar_label: Fetch a Resource
hide_table_of_contents: true
---

# Fetch a Resource - Beta API

import Method from '../../../src/theme/RestApiMethodContainer'
import data from './data/fetch-a-resource.json'

<Method
{...data.fetchAResource}
/>


---

---
title: Fetch A Track Recording
sidebar_position: 1
sidebar_label: Fetch a Track Recording
hide_table_of_contents: true
---

# Fetch a Track Recording - API

import Method from '../../../src/theme/RestApiMethodContainer'
import data from './data/fetch-a-track-recording.json'

<Method
{...data.fetchATrackRecording}
/>


---

---
title: Fetch Active HLS
sidebar_position: 1
sidebar_label: Fetch Active HLS
hide_table_of_contents: true
---

# Fetch Active HLS - API

import Method from '../../../src/theme/RestApiMethodContainer'
import data from './data/fetch-active-hls.json'
import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>
<Method
{...data.fetchActiveHLS}
/>


---

---
title: Fetch Active Participants
sidebar_position: 4
sidebar_label: Fetch Active Participants
hide_table_of_contents: true
---

# Fetch Active Participants - API

import Method from '../../../src/theme/RestApiMethodContainer'
import data from './data/fetch-active-participants.json'
import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>
<Method
{...data.fetchActiveParticipants}
/>


---

---
title: Fetch all HLS
sidebar_position: 1
sidebar_label: Fetch all HLS
hide_table_of_contents: true
---

# Fetch all HLS - API

import Method from '../../../src/theme/RestApiMethodContainer'
import data from './data/fetch-all-hls.json'
import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>
<Method
{...data.fetchAllHLS}
/>


---

---
title: Fetch All Merge Recordings
sidebar_position: 1
sidebar_label: Fetch All Merge Recordings
hide_table_of_contents: true
---

# Fetch All Merge Recordings - API

import Method from '../../../src/theme/RestApiMethodContainer'
import { fetchAllMergeRecordings } from './data/fetch-all-merge-recordings.js'

<Method
  {...fetchAllMergeRecordings}
/>


---

---
title: Fetch All Participant Recordings
sidebar_position: 1
sidebar_label: Fetch All Participant Recordings
hide_table_of_contents: true
---

# Fetch All Participant Recordings - API

import Method from '../../../src/theme/RestApiMethodContainer'
import data from './data/fetch-all-participant-recording.json'

<Method
{...data.fetchAllParticipantRecording}
/>


---

---
title: Fetch All Resources
sidebar_position: 1
sidebar_label: Fetch All Resources
hide_table_of_contents: true
---

# Fetch All Resources - Beta API

import Method from '../../../src/theme/RestApiMethodContainer'
import data from './data/fetch-all-resource.json'
import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>
<Method
{...data.fetchAllResources}
/>


---

---
title: Fetch Rooms
sidebar_position: 3
sidebar_label: Fetch Rooms
hide_table_of_contents: true
---

# Fetch Rooms - API

import Method from '../../../src/theme/RestApiMethodContainer'
import data from './data/fetch-all-room.json'
import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>
<Method
{...data.fetchAllRoom}
/>


---

---
title: Fetch all RTMP
sidebar_position: 1
sidebar_label: Fetch all RTMP
hide_table_of_contents: true
---

# Fetch all RTMP - API

import Method from '../../../src/theme/RestApiMethodContainer'
import data from './data/fetch-all-rtmp.json'
import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>
<Method
{...data.fetchAllRTMP}
/>


---

---
title: Fetch All Track Recordings
sidebar_position: 1
sidebar_label: Fetch All Track Recordings
hide_table_of_contents: true
---

# Fetch All Track Recordings - API

import Method from '../../../src/theme/RestApiMethodContainer'
import data from './data/fetch-all-track-recording.json'

<Method
{...data.fetchAllTrackRecording}
/>


---

---
title: Fetch an HLS Thumbnail - API
sidebar_position: 1
sidebar_label: Fetch an HLS Thumbnail
hide_table_of_contents: true
---

#

import Method from '../../../src/theme/RestApiMethodContainer'
import {fetchAnHlsThumbnail} from './data/fetch-an-hls-thumbnail.js'
import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>
<Method
{...fetchAnHlsThumbnail}
/>


---

---
title: Fetch an HLS
sidebar_position: 1
sidebar_label: Fetch an HLS
hide_table_of_contents: true
---

# Fetch an HLS - API

import Method from '../../../src/theme/RestApiMethodContainer'
import data from './data/fetch-an-hls.json'
import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>
<Method
{...data.fetchAnHLS}
/>


---

---
title: Fetch an RTMP
sidebar_position: 1
sidebar_label: Fetch an RTMP
hide_table_of_contents: true
---

# Fetch an RTMP - API

import Method from '../../../src/theme/RestApiMethodContainer'
import data from './data/fetch-an-rtmp.json'

<Method
{...data.fetchAnRTMP}
/>


---

---
sidebar_position: 1
sidebar_label: Fetch Participants
hide_table_of_contents: true
---

# Fetch Participants - API

import Method from '../../../src/theme/RestApiMethodContainer'
import data from './data/fetch-participants.json'

<Method
{...data.fetchParticipants}
/>


---

---
title: Fetch Post Transcriptions & Summary
sidebar_position: 1
sidebar_label: Fetch Post Transcriptions & Summary
hide_table_of_contents: true
---

# Fetch Post Transcriptions & Summary - API

import Method from '../../../src/theme/RestApiMethodContainer'
import data from './data/fetch-post-transcriptions.json'

<Method
{...data.fetchPostTranscriptions}
/>


---

---
title: Fetch Realtime Transcriptions
sidebar_position: 1
sidebar_label: Fetch Realtime Transcriptions
hide_table_of_contents: true
---

# Fetch Realtime Transcriptions - API

import Method from '../../../src/theme/RestApiMethodContainer'
import data from './data/fetch-realtime-transcriptions.json'

<Method
{...data.fetchRealtimeTranscriptions}
/>


---

---
title: Fetch A Recording
sidebar_position: 1
sidebar_label: Fetch a Recording
hide_table_of_contents: true
---

# Fetch a Recording - API

import Method from '../../../src/theme/RestApiMethodContainer'
import data from './data/fetch-recording-using-recordingId.json'

<Method
{...data.fetchRecordingUsingRecordingId}
/>


---

---
title: Fetch Recordings
sidebar_position: 1
sidebar_label: Fetch Recordings
hide_table_of_contents: true
---

# Fetch Recordings - API

import Method from '../../../src/theme/RestApiMethodContainer'
import data from './data/fetch-recordings.json'

<Method
{...data.fetchRecordings}
/>


---

---
title: Fetch a Room
sidebar_position: 3
sidebar_label: Fetch a Room
hide_table_of_contents: true
---

# Fetch a Room - API

import Method from '../../../src/theme/RestApiMethodContainer'
import data from './data/fetch-room.json'

<Method
{...data.fetchRoom}
/>


---

---
title: Fetch Participant Quality Stats
sidebar_position: 1
sidebar_label: Fetch Participant Quality Stats
hide_table_of_contents: true
---

# Fetch Participant Quality Stats - API

import Method from '../../../src/theme/RestApiMethodContainer'
import data from './data/fetch-session-peer-quality-stats.json'
import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>
<Method
{...data.fetchSessionPeerQualityStats}
/>


---

---
title: Fetch Session Quality Stats
sidebar_position: 1
sidebar_label: Fetch Session Quality Stats
hide_table_of_contents: true
---

# Fetch Session Quality Stats - API

import Method from '../../../src/theme/RestApiMethodContainer'
import data from './data/fetch-session-quality-stats.json'
import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>
<Method
{...data.fetchSessionQualityStats}
/>


---

---
title: Fetch a Session
sidebar_position: 1
sidebar_label: Fetch a Session
hide_table_of_contents: true
---

# Fetch a Session - API

import Method from '../../../src/theme/RestApiMethodContainer'
import data from './data/fetch-session-using-sessionid.json'

<Method
{...data.fetchSessionUsingSessionId}
/>


---

---
title: Fetch Sessions
sidebar_position: 1
sidebar_label: Fetch Sessions
hide_table_of_contents: true
---

# Fetch Sessions - API

import Method from '../../../src/theme/RestApiMethodContainer'
import data from './data/fetch-sessions.json'

<Method
{...data.fetchSessions}
/>


---

---
sidebar_position: 2
sidebar_label: Firebase Cloud Function
pagination_label: Firebase Cloud Function
title: Firebase Cloud Function
---

# Firebase Cloud Function - API

<div class="sdk-api-ref-only-h4">

Cloud Functions for Firebase is a serverless framework that lets you automatically run backend code in response to events triggered by Firebase features and HTTPS requests. There's no need to manage and scale your own servers.

Perform the following steps to create token and create room HTTP Triggers.

### Install Firebase CLI

Before initiating a cloud functions project we need to make use of the Firebase Command Line Client and to install the latest version use the following command.

```javascript
npm install -g firebase-tools
```

### Firebase Login

Login to your firebase account using following command.

```javascript
firebase login
```

### Firebase Initiate

Now go to project folder and initiate Firebase.

```javascript
firebase init functions
```

You’re being asked to select the Firebase project you would like to use for the Firebase Cloud Functions project. You can also select the entry [create a new project] if you would like to add a new Firebase project to your account.

The next question you’re being asked is “Do you want to install dependencies with npm now?”. As we would like to add all necessary dependencies you need to say “Y” here or simply hit return as “Y” is the default setting.

### Install Dependancies

You have to install express, jsonwebtoken, node-fetch and body-parser dependencies for the project.

```javascript
npm install express jsonwebtoken node-fetch body-parser
```

### Node Project File

Create index.js file

```javascript
const functions = require("firebase-functions");
const express = require("express");
const jwt = require("jsonwebtoken");
const bodyParser = require("body-parser");
const PORT = 3000;
const app = express();

app.use(bodyParser.json());

function generateToken() {
  const API_KEY = "$YOUR_API_KEY";
  const SECRET = "$YOUR_SECRET";

  const options = {
    expiresIn: "120m",
    algorithm: "HS256",
  };

  const payload = {
    apikey: API_KEY,
    permissions: [`allow_join`], // `ask_join` || `allow_mod`
  };

  const token = jwt.sign(payload, SECRET, options);

  return token;
}

app.get("/token", (req, res, next) => {
  // .... your verification
  const token = generateToken();
  res.json({ token: token });
});

app.post("/room", async (req, res, next) => {
  const { meetingId } = req.body;
  // .... your verification

  const token = generateToken();
  const options = {
    method: "POST",
    headers: {
      Authorization: token,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({
      region: "in001",
      customRoomId: meetingId,
      webhook: "see example",
    }),
  };

  const url = `https://api.videosdk.live/v2/rooms`;
  const response = await fetch(url, options);
  const data = await response.json();

  res.json(data);
});

app.listen(PORT, () => {
  console.info("Server is running on PORT:", PORT);
});

exports.app = functions.https.onRequest(app);
```

### Firebase Deploy

To try out the function we now need to deploy our project to Firebase. Therefore we’re making use of the Firebase CLI again:

```javascript
firebase deploy --only functions
```

If the deployment has been completed successfully and you get back the function URL which now can be used to trigger the execution of the Cloud Function. now you can use this url to create room or token.

</div>


---

---
sidebar_position: 1
---

import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>

# Customise Interface

Cooming soon


---

---
sidebar_position: 1
---

import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>

# Embeded meeting

Coming Soon.

![Build a embeded meeting.](/img/Zujonow-whitelabel-desktop-min.jpg)


---

---
sidebar_position: 1
---

import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>

# Explore console

Coming Soon.


---

---
sidebar_position: 1
---

import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>

# What we offer

## Explore amazing features

Let's discover **Realtime SDK features in less than 5 minutes**.

### ✅ : Shipped

### 🚧 : Working on it

### ❌ : Not implemented

## Features

|                                                      | Embeded | SDK |
| ---------------------------------------------------- | ------- | --- |
| video & audio chat functionality                     | ✅      | ✅  |
| Customised interface for video & audio               | 🚧      | ✅  |
| Adaptive video & audio calling                       | ✅      | ✅  |
| Cross browser and device support                     | 🚧      | ✅  |
| Screen sharing                                       | ✅      | ✅  |
| Interactive Whiteboard                               | ✅      | ✅  |
| Auto switching on active speakers                    | ✅      | ✅  |
| Grid Layouts                                         | ✅      | ✅  |
| Participant List                                     | ✅      | ✅  |
| Raise Hand                                           | ✅      | ✅  |
| Text chat and file sharing                           | ✅      | ✅  |
| Cloud and local recording                            | ✅      | ✅  |
| Console analytics and operations                     | ✅      | ✅  |
| Compatible with JS, React, Electron, Vue and Angular | ✅      | ✅  |
| Compatible with React Native, Flutter                | 🚧      | ✅  |
| Compatible with native Android, IOS                  | 🚧      | 🚧  |


---

---
sidebar_position: 1
---

import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>

# Integrate SDK with mobile, tab and tv

## @videosdk.live/react-native-sdk

`@videosdk.live/react-native-sdk` is hybrid sdk for the react native. It inherits `js` and `react` sdk to provide better support and fast development in mobile devices.

![Build a React Native video chat app with @videosdk.live/react-native-sdk.](/img/Zujonow-whitelabel-mobile-landscape.jpg)


---

---
sidebar_position: 1
---

import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>

# What next?


---

---
title: Introduction to Real time communication API
hide_title: true
hide_table_of_contents: true
description: RTC SDK provides wide range of features to build your own custom video chat application without worrying about performance issues and scaling.
sidebar_label: Introduction
pagination_label: Introduction
keywords:
  - RTC API
  - RTC SDK
  - video API
  - audio rooms API
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: intro
---

import CodeBlock from "@theme/CodeBlock";

<div id="tailwind">
<div class="row">
<div class="col col--6">
<br />
<h2> API Reference </h2>
<div >
VideoSDK provides REST APIs for RealTime Communication, which includes APIs for Rooms, Sessions, Recordings, RTMP and HLS.
</div>
</div>
<div class="col col--6">
<br /> <br /> <br />
<div>
 <div className="bg-[#333A47] rounded-t-lg pt-4 pb-4 pl-3 flex lg:flex-row flex-col align-middle">
  <div className="flex-1 text-sm font-bold text-white-1">BASE URL</div>
  </div>
  <div className="method_code_block">
   <div className="pt-4 pl-4 pr-4 pb-2 bg-[#252a34] rounded-b-lg flex flex-col align-middle">
    <p className="mb-2">
              <span className="text-[#7D8EAD] text-sm font-bold max-w-min hover:text-white-100">
                {"https://api.videosdk.live"}
              </span>
    </p>
    </div>
</div>
</div>

</div>
</div>

<hr />
<br />
<div class="row">
<div class="col col--6">
<h2> Authentication </h2>
<div >
The VideoSDK API uses access token to authenticate api requests.
In REST APIs, token will be passed in a header field called `Authorization`.

In order to generate authentication token, you will need `API_KEY` and `SECRET`, which you can get them from [here](https://app.videosdk.live/api-keys).

In payload, you have to add your `apikey`, `permissions`, `version` and `role`.

If you are concerned with security and want to generate token only for v2 API access, then you need to provide `version` and `role`.

- `apikey`(**Mandatory**): You can get it from [here](https://app.videosdk.live/api-keys).

- `permissions`(**Mandatory**): Based on provided permission, participant will join the meeting accordingly.

  Available permissions are:

  - **`allow_join`**: The participant is **allowed to join** the meeting directly.
  - **`ask_join`**: The participant requires to **ask for permission to join** the meeting.
  - **`allow_mod`**: The participant is **allowed to toggle** webcam & mic of other participants.

- **`version`(optional)**: For accessing the [v2 API](/api-reference/realtime-communication/intro), you need to provide `2` as the version value.

  - For passing `roomId`, `participantId` or `roles` parameters in payload, it is essential to set the version value to `2`.

- **`roomId`(optional)**: To provide customised access control, you can make the token applicable to a particular room by including the `roomId` in the payload.

- **`participantId`(optional)**: You can include the `participantId` in the payload to limit the token's access to a particular participant.

- **`roles`(optional)**:

  - **`crawler`**: This role is only for accessing [v2 API](/api-reference/realtime-communication/intro), you can not use this token for running the `Meeting`/`Room`.
  - **`rtc`**: This role is only allow for running the `Meeting` / `Room`, you can not use [server-side APIs](/api-reference/realtime-communication/intro).

Then, you will sign this payload with your `SECRET`and jwt options.

</div>
</div>
<div class="col col--6">

import GenerateToken from '../../../src/theme/GenerateTokenContainer'

<br /><br />
<GenerateToken/>

</div>
</div>
</div>

---

import RestApiEndpointContainer from "../../../src/theme/RestApiEndpointContainer.js"
import endpointList from "./endpointList.json"

<RestApiEndpointContainer endpointSections={endpointList}/>


---

---
title: Merge Participant Recordings
sidebar_position: 1
sidebar_label: Merge Participant Recordings
hide_table_of_contents: true
---

# Merge Participant Recordings - API

import Method from '../../../src/theme/RestApiMethodContainer'
import { mergeRecording } from './data/merge-recording.js'

<Method
  {...mergeRecording}
/>


---

---
title: Release Resource
sidebar_position: 1
sidebar_label: Release Resource
hide_table_of_contents: true
---

# Release Resource - Beta API

import Method from '../../../src/theme/RestApiMethodContainer'
import {releaseResource} from './data/release-resource.js'

<Method
{...releaseResource}
/>


---

---
title: Remove Participant
sidebar_position: 1
sidebar_label: Remove Participant
hide_table_of_contents: true
---

# Remove Participant - API

import Method from '../../../src/theme/RestApiMethodContainer'
import data from './data/remove-participant.json'

<Method
{...data.removeParticipant}
/>


---

---
sidebar_position: 1
---

import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>

# Architecture


---

---
sidebar_position: 1
---

import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>

# Demos


---

---
sidebar_position: 1
---

import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>

# Device and Browser Support

## Browser Support

We support the following web browsers:

- Chrome 74 and above
- Safari 12.1 and above
- Firefox 78 ESR and above
- Microsoft Edge 74 and above.
- Electron 6 and above
- IOS Safari (in IOS 12.1 and later)
- 3rd-party browsers (such as Chrome) and in-app browsers (such as the Gmail app's built-in browser) using WKWebView, as of IOS 14
- Android Chrome, Firefox, Samsung Internet, and Chromium-based 3rd-party browsers

## Screen sharing

- To start a screen share, a user must be on desktop. A user can start a screen share from Chrome, Safari, or Firefox on desktop.
- To clarify, all browsers can view screen shares. A mobile user can see a screen share (but only a call participant on desktop can share their screen).

## Mobile support

- IOS 12.1 and later versions
- Android 5.0 and above with current security and platform updates


---

---
sidebar_position: 1
---

# Hippa Compliance for Healthcare

import Method from '../../../../src/theme/HippaRedirection'
import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>
<Method/>


---

---
sidebar_position: 1
---

import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>

# Tutorials


---

---
title: Start HLS Stream
sidebar_position: 1
sidebar_label: Start HLS
hide_table_of_contents: true
---

# Start HLS Stream - API

import Method from '../../../src/theme/RestApiMethodContainer'
import {startHLSstream} from './data/start-hls.js'

<Method
{...startHLSstream}
/>


---

---
title: Start Livestream
sidebar_position: 1
sidebar_label: Start RTMP
hide_table_of_contents: true
---

# Start Livestream - API

import Method from '../../../src/theme/RestApiMethodContainer'
import {startLivestream} from './data/start-livestream.js'

<Method
{...startLivestream}
/>


---

---
title: Start Multiple HLS Stream
sidebar_position: 1
sidebar_label: Start Multiple HLS
hide_table_of_contents: true
---

# Start Multiple HLS Stream - API

import Method from '../../../src/theme/RestApiMethodContainer'
import {startMultiHLSstream} from './data/start-multi-hls.js'

<Method
{...startMultiHLSstream}
/>


---

---
title: Start Multiple Recording
sidebar_position: 1
sidebar_label: Start Multiple Recording
hide_table_of_contents: true
---

# Start Multiple Recording - API

import Method from '../../../src/theme/RestApiMethodContainer'
import {startMultiRecording} from './data/start-multi-recording.js'

<Method
{...startMultiRecording}
/>


---

---
title: Start Multiple Livestream
sidebar_position: 1
sidebar_label: Start Multiple RTMP
hide_table_of_contents: true
---

# Start Multiple Livestream - API

import Method from '../../../src/theme/RestApiMethodContainer'
import {startMultiLivestream} from './data/start-multi-rtmp.js'

<Method
{...startMultiLivestream}
/>


---

---
title: Start Participant Recording
sidebar_position: 1
sidebar_label: Start Participant Recording
hide_table_of_contents: true
---

# Start Participant Recording - API

import Method from '../../../src/theme/RestApiMethodContainer'
import {startParticipantRecording} from './data/start-participant-recording.js'

<Method
{...startParticipantRecording}
/>


---

---
title: Start a Realtime Transcription
sidebar_position: 1
sidebar_label: Start Realtime Transcription
hide_table_of_contents: true
---

# Start a Realtime Transcription - API

import Method from '../../../src/theme/RestApiMethodContainer'
import {startRealtimeTranscription} from './data/start-realtime-transcriptions.json'

<Method
{...startRealtimeTranscription}
/>


---

---
title: Start Recording
sidebar_position: 1
sidebar_label: Start Recording
hide_table_of_contents: true
---

# Start Recording - API

import Method from '../../../src/theme/RestApiMethodContainer'
import {startRecording} from './data/start-recording.js'

<Method
{...startRecording}
/>


---

---
title: Start Track Recording
sidebar_position: 1
sidebar_label: Start Track Recording
hide_table_of_contents: true
---

# Start Track Recording - API

import Method from '../../../src/theme/RestApiMethodContainer'
import {startTrackRecording} from './data/start-track-recording.js'

<Method
{...startTrackRecording}
/>


---

---
title: Stop HLS Stream
sidebar_position: 1
sidebar_label: Stop HLS
hide_table_of_contents: true
---

# Stop HLS Stream - API

import Method from '../../../src/theme/RestApiMethodContainer'
import data from './data/stop-hls.json'

<Method
{...data.stopHLSstream}
/>


---

---
title: Stop Livestream
sidebar_position: 1
sidebar_label: Stop RTMP
hide_table_of_contents: true
---

# Stop Livestream - API

import Method from '../../../src/theme/RestApiMethodContainer'
import data from './data/stop-livestream.json'

<Method
{...data.stopLivestream}
/>


---

---
title: Stop Multiple HLS Stream
sidebar_position: 1
sidebar_label: Stop Multiple HLS
hide_table_of_contents: true
---

# Stop Multiple HLS Stream - API

import Method from '../../../src/theme/RestApiMethodContainer'
import data from './data/stop-multi-hls.json'

<Method
{...data.stopMultiHLSstream}
/>


---

---
title: Stop Multiple Recording
sidebar_position: 1
sidebar_label: Stop Multiple Recording
hide_table_of_contents: true
---

# Stop Multiple Recording - API

import Method from '../../../src/theme/RestApiMethodContainer'
import data from './data/stop-multi-recording.json'

<Method
{...data.stopMultiRecording}
/>


---

---
title: Stop Multiple Livestream
sidebar_position: 1
sidebar_label: Stop Multiple RTMP
hide_table_of_contents: true
---

# Stop Multiple Livestream - API

import Method from '../../../src/theme/RestApiMethodContainer'
import data from './data/stop-multi-rtmp.json'

<Method
{...data.stopMultiLivestream}
/>


---

---
sidebar_position: 1
sidebar_label: Stop Participant Recording
hide_table_of_contents: true
---

# Stop Participant Recording - API

import Method from '../../../src/theme/RestApiMethodContainer'
import data from './data/stop-participant-recording.json'

<Method
{...data.stopParticipantRecording}
/>


---

---
title: Stop a Realtime Transcription
sidebar_position: 1
sidebar_label: Stop Realtime Transcription
hide_table_of_contents: true
---

# Stop Realtime Transcription - API

import Method from '../../../src/theme/RestApiMethodContainer'
import {stopRealtimeTranscription} from './data/stop-realtime-transcriptions'

<Method
{...stopRealtimeTranscription}
/>


---

---
sidebar_position: 1
sidebar_label: Stop Recording
hide_table_of_contents: true
---

# Stop Recording - API

import Method from '../../../src/theme/RestApiMethodContainer'
import data from './data/stop-recording.json'

<Method
{...data.stopRecording}
/>


---

---
sidebar_position: 1
sidebar_label: Stop Track Recording
hide_table_of_contents: true
---

# Stop Track Recording - API

import Method from '../../../src/theme/RestApiMethodContainer'
import data from './data/stop-track-recording.json'

<Method
{...data.stopTrackRecording}
/>


---

---
sidebar_position: 0
---

import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>

# Beginner Tutorial JavaScript

## Terminology

Let's start with the terms used in VideoSDK meeting Client SDK.

### Meeting

A Meeting represents real-time audio, video, and/or screen-share session, and is the basic building block for media sharing among participants. Supports upto 5,000 participants.

### Participants

Participants are the client applications that are connected to a Meeting and shares video & audio media with one another.

### Local Participant

Participant producing audio or video stream from the local client's media sources

### Streams

Streams are indiviual video & audio streams produced by the participants in the meeting

### Active Speaker

Active speaker represents the participant who is currently producing highest decibels audio stream (in other words speaking)

### Active presenter

Active presenter is the participant who is currently sharing his/her screen as a video stream

### Main participant

Main participant represents the client who shall be displayed on the main screen indicating that he/she is either presenting or speaking

---

## Installation

### Get an API key

Signup on the VideoSDK website to get a key pair for SDK authentication. Your **API Key** and **Secret** will be visible on the console dashboard.

### Integrate

Include this in your HTML file

```html title="index.html"
<script src="https://sdk.videosdk.live/js-sdk/0.1.6/videosdk.js"></script>
```

---

## Step 0: Access token generation (server-side code)

An access token is required to authenticate with the VideoSDK and make any API calls. You can generate one with the `API key` and `secret` mentioned in your developer portal at VideoSDK console.

## Generate access token (NodeJS)

```js {20} title="server.js"
const express = require("express");
const jwt = require("jsonwebtoken");
const cors = require("cors");
const request = require("request");

const app = express();
const port = 9000;
app.use(cors());
app.use(express.json());
app.use(express.urlencoded({ extended: true }));

app.get("/get-token", (req, res) => {
  const API_KEY = process.env.VIDEOSDK_API_KEY;
  const SECRET_KEY = process.env.VIDEOSDK_SECRET_KEY;
  const options = { expiresIn: "10m", algorithm: "HS256" };
  const payload = {
    apikey: API_KEY,
    permissions: ["allow_join", "allow_mod", "ask_join"], // Trigger permission.
  };
  const token = jwt.sign(payload, SECRET_KEY, options);
  res.json({ token });
});

app.listen(port, () => {
  console.log(`Example app listening at http://localhost:${port}`);
});
```

Available permissions are:

- `allow_join`: The participant will be permitted entry without request.
- `ask_join`: The participant will not be permitted entry without request.
- `allow_mod`: Allow participant to enable/disable other participant's mic/webcam.

This generated token must be sent in the `Authorization` header for all API calls. <br/>
And it should also be used with the `VideoSDK.config(token)` method.

## Step 1: Create or join meeting

Get a meeting id for new meeting or validate an existing meeting id to join a meeting.

### Create new meeting ID

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="curl"
groupId={"server-group-id"}
values={[
{label: 'cURL request creates meeting', value: 'curl'},
{label: 'NodeJS/JS', value: 'node'},
{label: 'Python', value: 'python'},
{label: 'Ruby', value: 'ruby'},
{label: 'RESULT', value: 'result'},
]}>
<TabItem value="curl">

```js
cURL -H "Content-Type: application/json" \
     -H "Authorization: $YOUR_JWT_TOKEN" \
     -XPOST \
     https://api.videosdk.live/v1/meetings
```

</TabItem>
<TabItem value="node">

```js
var request = require("request");

var options = {
  method: "POST",
  url: "https://api.videosdk.live/v1/meetings",
  headers: { authorization: `${YOUR_JWT_TOKEN}` },
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
```

</TabItem>
<TabItem value="python">

```python
import requests

url = "https://api.videosdk.live/v1/meetings"

headers = {'authorization': f'Bearer {YOUR_JWT_TOKEN}'}

response = requests.request("GET", url, headers=headers)

print(response.text)
```

</TabItem>
<TabItem value="ruby">

```ruby
require 'uri'
require 'net/http'

url = URI("https://api.videosdk.live/v1/meetings")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
http.verify_mode = OpenSSL::SSL::VERIFY_NONE

request = Net::HTTP::Get.new(url)
request["authorization"] = "Bearer #{YOUR_JWT_TOKEN}"

response = http.request(request)
puts response.read_body
```

</TabItem>
<TabItem value="result">

```js
{
  "meetingId":"jpkf-iool-64ox"
}
```

</TabItem>
</Tabs>

OR

### Validate existing meeting ID for joining

<Tabs
defaultValue="curl"
groupId={"server-group-id"}
values={[
{label: 'cURL request creates meeting', value: 'curl'},
{label: 'NodeJS/JS', value: 'node'},
{label: 'Python', value: 'python'},
{label: 'Ruby', value: 'ruby'},
{label: 'RESULT', value: 'result'},
]}>
<TabItem value="curl">

```js
cURL -H "Content-Type: application/json" \
     -H "Authorization: $YOUR_JWT_TOKEN" \
     -XPOST \
     https://api.videosdk.live/v1/meetings/${meetingId}
```

</TabItem>
<TabItem value="node">

```js
var request = require("request");

var options = {
  method: "POST",
  url: "https://api.videosdk.live/v1/meetings/${meetingId}",
  headers: { authorization: `${YOUR_JWT_TOKEN}` },
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
```

</TabItem>
<TabItem value="python">

```python
import requests

url = "https://api.videosdk.live/v1/meetings/${meetingId}"

headers = {'authorization': f'Bearer {YOUR_JWT_TOKEN}'}

response = requests.request("GET", url, headers=headers)

print(response.text)
```

</TabItem>
<TabItem value="ruby">

```ruby
require 'uri'
require 'net/http'

url = URI("https://api.videosdk.live/v1/meetings/${meetingId}")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
http.verify_mode = OpenSSL::SSL::VERIFY_NONE

request = Net::HTTP::Get.new(url)
request["authorization"] = "Bearer #{YOUR_JWT_TOKEN}"

response = http.request(request)
puts response.read_body
```

</TabItem>
<TabItem value="result">

```js
{
  "meetingId":"jpkf-iool-64ox"
}
```

</TabItem>
</Tabs>

## Step 2: Initialize meeting

To initialize meeting you need to provide the following parameters:

- `meetingId: string` from the previous step to specify which meeting to join in.
- `name: string` which will be displayed as username of participant in the meeting.
- `micEnabled: boolean` option to indicate if mic should be on while joining.
- `webcamEnabled: boolean` option to indicate if webcam should be on while joining.
- `maxResolution: "sd" | "hd"` defines the maximum available resolution for webcam video.

```javascript title="Intialize meeting instance"
const meeting = VideoSDK.initMeeting({
  meetingId, // required
  name, // required
  micEnabled, // optional, default: true
  webcamEnabled, // optional, default: true
  maxResolution, // optional, default: "hd"
});
```

The `meeting` object consists of:

- Properties:

  - `id: string`
  - `activeSpeakerId: string`
  - `activePresenterId: string`
  - `mainParticipantId: string`
  - `localParticipant: Participant`
  - `participants: Map<string, Participant>`
  - `messages: Array<{senderId: string, text: string, timestamp: number}>`

- Events:

  - `participant-joined`, `participant-left`
  - `speaker-changed`, `presenter-changed`
  - `main-participant-changed`
  - `entry-requested`, `entry-responded`
  - `recording-started`, `recording-stopped`
  - `stream-enabled`, `stream-disabled`
  - `chat-message`

- Methods:
  - `join()`, `leave()`
  - `muteMic()`, `unmuteMic()`
  - `disableWebcam()`, `enableWebcam()`
  - `disableScreenShare()`, `enableScreenShare()`
  - `on(eventType: string)`, `off(eventType: string)`
  - `respondEntry(participantId: string, decision: "allowed" | "denied")`
  - `startRecording(webhookUrl: string, , awsDirPath: string)`, `stopRecording()`
  - `sendChatMessage(text: string)`

## Step 3: Get local and remote participants

You can get the local streams and participant meta from `meeting.localParticipant`. And a `Map` of joined participants is always available via `meeting.participants`.

```javascript title="Access meeting participants"
const localParticipant = meeting.localParticipant;
const participants = meeting.participants;
```

Each `participant` object consists of:

- Properties:

  - `id: string`
  - `displayName: string`
  - `streams: Map<string, Stream>`

- Events:

  - `stream-enabled`
  - `stream-disabled`

- Methods:
  - `setQuality(quality: "low" | "med" | "high")`
  - `enableMic()`, `disableMic()`
  - `enableWebcam()`, `disableWebcam()`
  - `on(eventType: string)`, `off(eventType: string)`

## Step 4: Listen for entry request events

When participant asks for entry in a meeting that you are connected to, you will be notified via `entry-requested` and when you or any other participant's entry is responded, `entry-responded` will be fired.

```javascript title="Get request from user"
meeting.on("entry-requested", (participantId, name) => {
  setEntryRequests([...entryRequestsRef.current, { id: participantId, name }]);

  // you can open a dialog to respond with
  // decision "allowed" or "denied" with the following method
  meeting.respondEntry(participantId, decision);
});

meeting.on("entry-responded", (participantId, decision) => {
  // decision parameter will be: "allowed" or "denied"

  setEntryRequests(
    entryRequestsRef.current.filter((r) => r.id !== participantId)
  );
});
```

## Step 5: Listen for new & leaving participant events

When participant joins or leaves a meeting that you are connected to, you will be notified via `participant-joined` and `participant-left` events respectively.

```javascript "Listen on participant joined and left"
meeting.on("participant-joined", (participant) => {
  setParticipants(new Map(meeting.participants));
});

meeting.on("participant-left", (participant) => {
  setParticipants(new Map(meeting.participants));
});
```

## Step 6: Listen for audio/video stream events

When a participant from meeting enables or diables a audio/video stream, you will be notified via `stream-enabled` and `stream-disabled` events from the participant object.

```javascript title="Listen on stream enabled and disabled"
participant.on("stream-enabled", (stream) => {
  if (stream.kind === "video") {
    // play video track on a <video /> element
  } else if (stream.kind === "audio") {
    // play audio track on a <audio /> element
  } else if (stream.kind === "share") {
    // play screen sharing video track on a <video /> element
  }
});

participant.on("stream-disabled", (stream) => {
  if (stream.kind === "video") {
    // remove video track or the <video /> element
  } else if (stream.kind === "audio") {
    // remove audio track or the <audio /> element
  } else if (stream.kind === "share") {
    // remove screen sharing video track or the <video /> element
  }
});
```

Each `stream` object consists of:

- Properties:

  - `id: string`
  - `kind: string`
  - `codec: string`
  - `track: MediaStreamTrack`

- Methods:
  - `pause()`
  - `resume()`

### Note: Chrome Autoplay policy workaround

Chrome's autoplay policy does not allow audio autoplay unless user has interacted with the domain (click, tap, etc.) or the user's <a href="https://developers.google.com/web/updates/2017/09/autoplay-policy-changes#mei">Media engagement Index</a> threshold has been crossed. Thus, as a workaround before starting the meeting, user can either create a meeting join page or create a join meeting confirmation dialog by which we can perform a user click interaction to enable audio autoplay in chrome's newer versions.

## Step 7: Main screen video (optional)

When a participant who is currently presenting or speaking is changed in the meeting, you will be notified via `main-participant-changed` event.

```javascript title="Listen on main participant changed"
meeting.on("main-participant-changed", (participant) => {
  // show participant video stream on main screen
});
```

## Step 8: Join the meeting

After we set local participant, main-screen participant, other participants, participant event handlers and stream event handlers from the meeting, next step is to join the meeting by calling `meeting.join()`. This will trigger `participant-joined` event for all other participants.

```javascript title="Leave meeting"
meeting.join();
```

## Step 9: Utility methods & events (optional)

### Mute/Unmute mic

Toggle own mic with the `unmuteMic()` and `muteMic()` methods. Toggling mic will trigger `stream-enabled` and `stream-disabled` events for all other participants when enabling and disabling mic.

```javascript title="Mic methods"
// unmute/mute your own mic
meeting.unmuteMic();
meeting.muteMic();

// unmute/mute other participant's mic
participant.unmuteMic();
participant.muteMic();
```

### Enable/Disable Webcam

Toggle own webcam with the `enableWebcam()` and `disableWebcam()` methods. Toggling webcam will trigger `stream-enabled` and `stream-disabled` events for all other participants when enabling and disabling webcam.

```javascript title="Webcam methods"
// disable/enable your own webcam
meeting.enableWebcam();
meeting.disableWebcam();

// disable/enable other participant's webcam
participant.enableWebcam();
participant.disableWebcam();
```

### Enable/Disable Screen share

Share your screen with the `enableScreenShare()` method and stop sharing with `disableScreenShare()`. Toggling screen-share will trigger `stream-enabled` and `stream-disabled` events for all other participants when enabling and disabling screen-share.

```javascript title="Screen share methods"
meeting.enableScreenShare();
meeting.disableScreenShare();
```

### Start/Stop recording

Record the meeting session with `startRecording(webhookUrl, awsDirPath)` method and stop recording with `stopRecording()`. Toggling recording will trigger `recording-started` and `recording-stopped` events for all participants when starting and stopping recording respectively.

```javascript title="Start and stop recordings methods"
// The webhook will be called with the fileUrl as a POST request when the recording is processed.
meeting.startRecording(
  "https://your-app-server.com/api/recordings",
  "meetings/meeting-id"
);
meeting.stopRecording();

// ...

meeting.on("recording-started", () => {
  setRecordStatus("active");

  // 🔴 notify all users of recording start
});

meeting.on("recording-stopped", () => {
  setRecordStatus("inactive");

  // ⚫ notify all users of recording end
});
```

### In-meeting Chat

Send messages with the `sendChatMessage(text)` method and all other participants will be notified via `chat-message` event.

```javascript title="Send and receive chat message"
meeting.sendChatMessage("Hello world!");

// ...

meeting.on("chat-message", (data) => {
  setChatMessages([...meeting.messages]);

  const { senderId, text, timestamp } = data;

  // 📢 notify user or show in the chat window
});
```

### Active speaker event

The `speaker-changed` event will be fired whenever the loudest speaking participant changes.

```javascript title="Listen on active speaker changed"
meeting.on("speaker-changed", (participant) => {
  // indicate participant as speaking
});
```

### Active presenter event

The `presenter-changed` event will be fired whenever someone enables screen sharing.

```javascript title="Listen on presenter changed"
meeting.on("presenter-changed", (participant) => {
  // indicate participant as presenting screen
});
```

### Set participant video quality

Update the participant video quality based on use case to `"low" | "med" | "high"`.

```javascript title="Set quelity of receiving stream"
participant.setQuality("low");
```

### Start/Stop video

Share video link to play with `startVideo({ link })` method and stop video with `stopVideo()`. Toggling video will trigger `video-started` and `video-stopped` events for all participants when starting and stopping video respectively.
​

```javascript
// The webhook will be called with the fileUrl as a POST request when the video is processed.
meeting.startVideo({ link: "https://your-app-server.com/video/demo.mp4" });
meeting.stopVideo();
​
​
// Listening on start of the video stream.
meeting.on("video-started", ({ link, currentTime }) => {
  videoRef.current.src = link;
  videoRef.current.currentTime = currentTime;
});

// Listening to the stopped video stream.
meeting.on("video-stopped", () => {
  videoRef.current.pause();
  videoRef.current.src = null;
});
```

### Restream meeting on social media

Restream meeting on your favorite social media channels using RTMP key and url.

```javascript
// start livestreaming
meeting.startLivestream([
  {
    url: "rtmp://x.rtmp.youtube.com/live2/",
    streamKey: "abcd-h6a2-pqrs-vusv-prpf",
  },
]);
​
// stop livestreaming
meeting.stopLivestream();
```

## Leave the meeting

You can disconnect from the meeting with `meeting.leave()` method. This will trigger `participant-left` event for all other participants.

```javascript title="Leave meeting"
meeting.leave();
```


---

---
sidebar_position: 2
sidebar_label: Update a Room
hide_table_of_contents: true
---

# Update a Room - API

import Method from '../../../src/theme/RestApiMethodContainer'
import data from './data/update-room.json'
import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>
<Method
{...data.updateRoom}
/>


---

---
sidebar_position: 2
sidebar_label: Webhooks List
pagination_label: Webhooks List
title: Webhooks List
---

# Webhooks List - API

<div class="sdk-api-ref-only-h4">

---

### participant-joined

- This webhook is called when new participant join the meeting with following payload.

#### Example

```javascript
{
	"webhookType": "participant-joined",
	"data": {
        "meetingId": "jvsg-8rjn-j304",
        "sessionId": "613731342f27f56e4fc4b6d0",
        "participantId": "fkd74h",
        "participantName": "John",
    },
}
```

---

### participant-left

- This webhook is called when participant left the meeting with following payload

#### Example

```javascript
{
	"webhookType": "participant-left",
	"data": {
        "meetingId": "jvsg-8rjn-j304",
        "sessionId": "613731342f27f56e4fc4b6d0",
        "participantId": "fkd74h",
        "participantName": "John",
    },
}
```

---

### session-started

- This webhook is called when new meeting session is successfully started

#### Example

```javascript
{
    "webhookType": "session-started",
    "data": {
        "sessionId": "613731342f27f56e4fc4b6d0",
        "meetingId": "jvsg-8rjn-j304",
        "start": "2022-07-05T15:55:35.047+00:00",
    },
}
```

---

### session-ended

- This webhook is called when all participants lefts and meeting session is closed

#### Example

```javascript
{
    "webhookType": "session-ended",
    "data": {
        "sessionId": "613731342f27f56e4fc4b6d0",
        "meetingId": "jvsg-8rjn-j304",
        "start": "2022-07-05T15:55:35.047+00:00",
        "end": "2022-07-05T15:60:35.047+00:00",
    },
}
```

---

### recording-starting

- A "Recording Starting" webhook is triggered when the recording process for a meeting is initiated.

#### Example

```javascript
{
    "webhookType": "recording-starting",
    "data": {
        "meetingId": "jvsg-8rjn-j304",
        "sessionId": "613731342f27f56e4fc4b6d0",
    },
}
```

---

### recording-started

- Recording started webhook will be received when successfully recording is started in meeting

#### Example

```javascript
{
    "webhookType": "recording-started",
    "data": {
        "meetingId": "jvsg-8rjn-j304",
        "sessionId": "613731342f27f56e4fc4b6d0",
    },
}
```

---

### recording-stopping

- A "Recording Stopping" webhook is triggered when the recording end process for a meeting is initiated.

#### Example

```javascript
{
    "webhookType": "recording-stopping",
    "data": {
        "meetingId": "jvsg-8rjn-j304",
        "sessionId": "613731342f27f56e4fc4b6d0",
    },
}
```

---

### recording-stopped

- Recording stopped webhook will be received when recording is successfully stopped in meeting.

#### Example

```javascript
{
    "webhookType": "recording-stopped",
    "data": {
        "meetingId": "jvsg-8rjn-j304",
        "sessionId": "613731342f27f56e4fc4b6d0",
        "filePath" : "/encoded/videos/62d148951a1eb20029fc9b05.mp4",
        "fileUrl" : "https://cdn.videosdk.live/encoded/videos/62d148951a1eb20029fc9b05.mp4",

    },
}
```

---

### recording-failed

- A "Recording Failed" webhook is generated when the recording process encounters an interruption or issue during either the starting or stopping phases.

#### Example

```javascript
{
    "webhookType": "recording-failed",
    "data": {
        "meetingId": "jvsg-8rjn-j304",
        "sessionId": "613731342f27f56e4fc4b6d0",
    },
}
```

---

### participant-track-recording-starting

- A "Participant Track Recording Starting" webhook is triggered when the track recording process for a participant is initiated.

#### Example

```javascript
{
    "webhookType": "participant-track-recording-starting",
    "data": {
        "meetingId": "jvsg-8rjn-j304",
        "sessionId": "613731342f27f56e4fc4b6d0",
        "participantId": "abcd",
        "kind": "audio",
    },
}
```

---

### participant-track-recording-started

- Participant Track Recording started webhook will be received when successfully track recording is started in meeting

#### Example

```javascript
{
    "webhookType": "participant-track-recording-started",
    "data": {
        "meetingId": "jvsg-8rjn-j304",
        "sessionId": "613731342f27f56e4fc4b6d0",
        "participantId": "abcd",
        "kind": "audio",
    },
}
```

---

### participant-track-recording-stopping

- A "Participant Track Recording Stopping" webhook is triggered when the track recording end process for a participant is initiated.

#### Example

```javascript
{
    "webhookType": "participant-track-recording-stopping",
    "data": {
        "meetingId": "jvsg-8rjn-j304",
        "sessionId": "613731342f27f56e4fc4b6d0",
        "participantId": "abcd",
        "kind": "audio",
    },
}
```

---

### participant-track-recording-stopped

- Participant Track Recording stopped webhook will be received when track recording is successfully stopped in meeting.

#### Example

```javascript
{
    "webhookType": "participant-track-recording-stopped",
    "data": {
        "meetingId": "jvsg-8rjn-j304",
        "sessionId": "613731342f27f56e4fc4b6d0",
        "participantId": "abcd",
        "kind": "audio",
        "fileDetails" : [
            {
                "filePath" : "/encoded/videos/62d148951a1eb20029fc9b05.mp4",
                "fileUrl" : "https://cdn.videosdk.live/encoded/videos/62d148951a1eb20029fc9b05.mp4",
            }
        ]
    },
}
```

---

### participant-track-recording-failed

- A "Participant Track Recording Failed" webhook is generated when the track recording process encounters an interruption or issue during either the starting or stopping phases.

#### Example

```javascript
{
    "webhookType": "participant-track-recording-failed",
    "data": {
        "meetingId": "jvsg-8rjn-j304",
        "sessionId": "613731342f27f56e4fc4b6d0",
        "participantId": "abcd",
        "kind": "audio",
    },
}
```

---

### participant-recording-starting

- A "Participant Recording Starting" webhook is triggered when the participant recording process for a participant is initiated.

#### Example

```javascript
{
    "webhookType": "participant-recording-starting",
    "data": {
        "meetingId": "jvsg-8rjn-j304",
        "sessionId": "613731342f27f56e4fc4b6d0",
        "participantId": "abcd",
        "fileFormat": "webm",
    },
}
```

---

### participant-recording-started

- Participant Recording started webhook will be received when successfully participant recording is started in meeting

#### Example

```javascript
{
    "webhookType": "participant-recording-started",
    "data": {
        "meetingId": "jvsg-8rjn-j304",
        "sessionId": "613731342f27f56e4fc4b6d0",
        "participantId": "abcd",
        "fileFormat": "webm",
    },
}
```

---

### participant-recording-stopping

- A "Participant Recording Stopping" webhook is triggered when the participant recording end process for a participant is initiated.

#### Example

```javascript
{
    "webhookType": "participant-recording-stopping",
    "data": {
        "meetingId": "jvsg-8rjn-j304",
        "sessionId": "613731342f27f56e4fc4b6d0",
        "participantId": "abcd",
        "fileFormat": "webm",
    },
}
```

---

### participant-recording-stopped

- Participant Recording stopped webhook will be received when participant recording is successfully stopped in meeting.

#### Example

```javascript
{
    "webhookType": "participant-recording-stopped",
    "data": {
        "meetingId": "jvsg-8rjn-j304",
        "sessionId": "613731342f27f56e4fc4b6d0",
        "participantId": "abcd",
        "fileDetails" : [
            {
                "filePath" : "/encoded/videos/62d148951a1eb20029fc9b05.mp4",
                "fileUrl" : "https://cdn.videosdk.live/encoded/videos/62d148951a1eb20029fc9b05.mp4",
            }
        ]
    },
}
```

---

### participant-recording-failed

- A "Participant Recording Failed" webhook is generated when the participant recording process encounters an interruption or issue during either the starting or stopping phases.

#### Example

```javascript
{
    "webhookType": "participant-recording-failed",
    "data": {
        "meetingId": "jvsg-8rjn-j304",
        "sessionId": "613731342f27f56e4fc4b6d0",
        "participantId": "abcd",
    },
}
```

---

### merge-recording-completed

- A "Merge Recording Completed" webhook is triggered when the participant recordings have been successfully merged.

#### Example

```javascript
{
    "webhookType": "merge-recording-completed",
    "data": {
        "id": "bf37fabb-6e34-418b-bc29-97f053fc6cfe",
        "meetingId": "jvsg-8rjn-j304",
        "sessionId": "613731342f27f56e4fc4b6d0",
    },
}
```

---

### merge-recording-failed

- A "Merge Recording Failed" webhook is triggered when the merge operation fails due to any issue during processing (e.g., missing recordings, sync issues, internal error, etc.).

#### Example

```javascript
{
    "webhookType": "merge-recording-failed",
    "data": {
        "id": "bf37fabb-6e34-418b-bc29-97f053fc6cfe",
        "meetingId": "jvsg-8rjn-j304",
        "sessionId": "613731342f27f56e4fc4b6d0",
        "message?": "error message, if any"
    },
}
```

---

### transcription-started

- You will receive a `transcription-started` webhook when the post transcription or realtime transcription is started successfully. This webhook will be triggered against the `webhookUrl` provided during the start transcription API call.

#### Example

```javascript
{
    "webhookType": "transcription-started",
    "data": {
        "id": "40b0a4ed-9842-40c9-a288-e4b1bf98a90a",
        "type": "realtime",
        "meetingId": "jvsg-8rjn-j304",
        "sessionId": "621497578bea0d0404c35c4c"
    },
}
```

---

### transcription-stopped

- You will receive a `transcription-stopped` webhook when the post transcription or realtime transcription is stopped successfully. This webhook will be triggered against the `webhookUrl` provided during the start transcription API call.

#### Example

```javascript
{
    "webhookType": "transcription-stopped",
    "data": {
        "id": "40b0a4ed-9842-40c9-a288-e4b1bf98a90a",
        "type": "realtime",
        "meetingId": "jvsg-8rjn-j304",
        "sessionId": "621497578bea0d0404c35c4c"
    },
}
```

---

### transcription-failed

- You will receive a `transcription-failed` webhook when the post transcription or realtime transcription process encounters an interruption or issue during either the starting or stopping phases. This webhook will be triggered against the `webhookUrl` provided during the start transcription API call.

#### Example

```javascript
{
    "webhookType": "transcription-failed",
    "data": {
        "id": "40b0a4ed-9842-40c9-a288-e4b1bf98a90a",
        "type": "realtime",
        "meetingId": "jvsg-8rjn-j304",
        "sessionId": "621497578bea0d0404c35c4c"
    },
}
```

---

### livestream-starting

- A "Livestream Starting" webhook is triggered when the livestreaming process for a meeting is initiated.

#### Example

```javascript
{
    "webhookType": "livestream-starting",
    "data": {
        "meetingId": "jvsg-8rjn-j304",
        "sessionId": "613731342f27f56e4fc4b6d0",
    },
}
```

---

### livestream-started

- When you use live-streaming in our meeting service you will receive this webhook when livestream is successfully started.

#### Example

```javascript
{
    "webhookType": "livestream-started",
    "data": {
        "meetingId": "jvsg-8rjn-j304",
        "sessionId": "613731342f27f56e4fc4b6d0",
    },
}
```

---

### livestream-stopping

- A "Livestream Stopping" webhook is triggered when the livestream end process for a meeting is initiated.

#### Example

```javascript
{
    "webhookType": "livestream-stopping",
    "data": {
        "meetingId": "jvsg-8rjn-j304",
        "sessionId": "613731342f27f56e4fc4b6d0",
    },
}
```

---

### livestream-stopped

- When live-stream is stopped in meeting this webhook is fired with following payload

#### Example

```javascript
{
    "webhookType": "livestream-stopped",
    "data": {
        "meetingId": "jvsg-8rjn-j304",
        "sessionId": "613731342f27f56e4fc4b6d0",
    },
}
```

---

### livestream-failed

- A "Livestream Failed" webhook is generated when the livestream process encounters an interruption or issue during either the starting or stopping phases.

#### Example

```javascript
{
    "webhookType": "livestream-failed",
    "data": {
        "meetingId": "jvsg-8rjn-j304",
        "sessionId": "613731342f27f56e4fc4b6d0",
    },
}
```

---

### hls-starting

- An "HLS Starting" webhook is generated when the HLS (HTTP Live Streaming) process for a meeting is initiated.

#### Example

```javascript
{
    "webhookType": "hls-starting",
    "data": {
        "meetingId": "jvsg-8rjn-j304",
        "sessionId": "613731342f27f56e4fc4b6d0",
    },
}
```

---

### hls-started

- When you use HTTP live streaming (HLS) in a meeting, this event will be fired when encoding of HLS has started.

#### Example

```javascript
{
    "webhookType": "hls-started",
    "data": {
        "meetingId": "jvsg-8rjn-j304",
        "sessionId": "613731342f27f56e4fc4b6d0",
        "playbackHlsUrl": "https://cdn.videosdk.live/meetings-hls/b8a770ef-d713-4a27-9ab7-e5a0b724caaf/index.m3u8"
    },
}
```

---

### hls-playable

- When you start HTTP live streaming (HLS) in a meeting, this event will be fired when HLS is in a playable state. So, now you can embed `playbackHlsUrl` in the HLS player.

- On hls-playable you get `playbackHlsUrl` and `livestreamUrl`.
  - `playbackHlsUrl` - Live HLS with playback support
  - `livestreamUrl` - Live HLS without playback support

:::note
`downstreamUrl` is now depecated. Use `playbackHlsUrl` or `livestreamUrl` in place of `downstreamUrl`
:::

#### Example

```javascript
{
    "webhookType": "hls-playable",
    "data": {
        "meetingId": "jvsg-8rjn-j304",
        "sessionId": "613731342f27f56e4fc4b6d0",
        "playbackHlsUrl": "https://cdn.videosdk.live/meetings-hls/b8a770ef-d713-4a27-9ab7-e5a0b724caaf/index.m3u8"
    },
}
```

---

### hls-stopping

- An "HLS Stopping" webhook is generated when the HLS (HTTP Live Streaming) end process for a meeting is initiated.

#### Example

```javascript
{
    "webhookType": "hls-stopping",
    "data": {
        "meetingId": "jvsg-8rjn-j304",
        "sessionId": "613731342f27f56e4fc4b6d0",
    },
}
```

---

### hls-stopped

- This event is fired when you stop a http live streaming in meeting it has following payload

#### Example

```javascript
{
    "webhookType": "hls-stopped",
    "data": {
        "meetingId": "jvsg-8rjn-j304",
        "sessionId": "613731342f27f56e4fc4b6d0",
    },
}
```

---

### hls-failed

- An "HLS Failed" webhook is generated when the HLS (HTTP Live Streaming) process encounters an interruption or issue during either the starting or stopping phases.

#### Example

```javascript
{
    "webhookType": "hls-failed",
    "data": {
        "meetingId": "jvsg-8rjn-j304",
        "sessionId": "613731342f27f56e4fc4b6d0",
    },
}
```

---

### resource-acquired

- Resource acquired webhook will be received when resource is successfully acquired and ready for composition.

#### Example

```javascript
{
    "webhookType": "resource-acquired",
    "data": {
        "id": "abcdef9879288c1f48339f64",
        "type": "recording",
    },
}
```

---

</div>


---

---
title: Validate a Room
sidebar_position: 4
sidebar_label: Validate a Room
hide_table_of_contents: true
---

# Validate a Room - API

import Method from '../../../src/theme/RestApiMethodContainer'
import data from './data/validate-room.json'

<Method
{...data.validateRoom}
/>


---

---
sidebar_position: 2
sidebar_label: Webhook Verification
pagination_label: Webhook Verification
title: Webhook Verification
---

# Webhook Verification - API

VideoSdk signs the webhook events it sends to your endpoints by including a signature in each event’s `videosdk-signature` header. This allows you to verify that the events were sent by VideoSdk and not by a third party. You can verify signatures by following these steps.

![webhook-verification.png](https://cdn.videosdk.live/website-resources/docs-resources/webhook-verification.png)

## Public key

Our RSA public key is available at [https://api.videosdk.live/v2/public/rsa-public-key](https://api.videosdk.live/v2/public/rsa-public-key). You can obtain it by making a GET request to this endpoint.

## Verification

Every request will have a custom `videosdk-signature` header. This header is a signature that is based on the "RSA-SHA256" hash of the request body. You can calculate the signature on your own and compare it with the value given in the header. If the two values are equal, you can safely consider that this request originated from VideoSdk.

### Sample code

<div>

import WebhookVerification from '../../../src/theme/WebhookVerificationContainer'

<WebhookVerification/>

</div>


---

---
title: Android - Migration Guide From Twilio Video to Video SDK
description: Explore the seamless transition from Twilio to Video SDK for android with our comprehensive migration guide. Elevate your video communication with expert insights and step-by-step instructions.
keywords:
  - Twilio to Video SDK migration guide for Android
  - Twilio to Video SDK migration guide
  - Twilio to Video SDK migration tutorial
slug: migration-guide-from-twilio-to-videosdk-android-sdk
# authors:
#   - name: Joel Marcey
#     title: Co-creator of Docusaurus 1
#     url: https://github.com/JoelMarcey
#     image_url: https://github.com/JoelMarcey.png
#   - name: Sébastien Lorber
#     title: Docusaurus maintainer
#     url: https://sebastienlorber.com
#     image_url: https://github.com/slorber.png
tags: [Migration Guide, Twilio, Android]
hide_table_of_contents: false
---

<!-- truncate -->

## Overview

**Welcome to the Twilio-to-VideoSDK Migration Guide for Android!**

As you navigate the transition from Twilio to VideoSDK, this guide serves as a roadmap for your smooth and efficient migration. We understand that transitioning to a new platform can be difficult, but fear not! This guide is designed to provide a simple and insightful comparison of key components, making the process clear and accessible even if you're new to both platforms.

We have created a guide to ensure a seamless migration experience. We'll use the well-known Twilio Quickstart sample application as a starting point, providing you with familiar basics and a solid context. You can easily access the code of the sample application here: [https://github.com/twilio/video-quickstart-android/tree/master/quickstartKotlin](https://github.com/twilio/video-quickstart-android/tree/master/quickstartKotlin)

Throughout this guide, we'll provide you with the knowledge and resources you need to successfully migrate your Android app to VideoSDK. Let's begin your journey to a richer and more engaging communication experience!

## Concept

1.  **Meeting / Room:**
    - This is like a virtual place where people can have real-time conversations using voice, video, and screen sharing.
    - Think of it as a virtual room where participants interact.
    - Each meeting or room has a unique ID (meetingId or roomId).
2.  **Participant:**
    - Both VideoSDK and Twilio Video includes the concepts of **Participant.**
    - There are two types:
      - **Local Participant:** This is you on your device. You control your own audio and video.
      - **Remote Participant:** This is someone else in the meeting. They receive your audio and video and can send their own.
3.  **MediaStream & Track:**
    - **MediaStream:** Think of it as a bundle of audio and video tracks that are shared in real-time between participants.
    - **Track:** This is like a continuous flow of audio or video. For example, your video feed from the camera is a video track, and the audio from the microphone is an audio track.
4.  **Session:**
    - A session is like a specific instance of an ongoing meeting or room.
    - Imagine a meeting happening right now as a session.
    - Each session has its own ID (sessionId).

If you want to learn about this concept in depth you can refer this guide [Concept and Architecture](https://docs.videosdk.live/android/guide/video-and-audio-calling-api-sdk/concept-and-architecture)

## VideoSDK Setup

### API Key

In Twilio you have to create API key manually(using CLI or from Dashboard), in VideoSDK the default API key is automatically created in [VideoSDK dashboard](https://app.videosdk.live).

### Token

In Twilio, you can generate a token using CLI or the Twilio helper library in the backend environment.

For VideoSDK, there are two ways to generate a token. You can [generate it from the VideoSDK Dashboard](https://docs.videosdk.live/android/guide/video-and-audio-calling-api-sdk/authentication-and-token#1-generating-token-from-dashboard) or [in your backend](https://docs.videosdk.live/android/guide/video-and-audio-calling-api-sdk/authentication-and-token#2-generating-token-in-your-backend).

In Twilio, you need to provide a different token for each participant, which can be complex during development. In VideoSDK, it is optional to specify the same token for different participants. You can also restrict a specific token for a specific meetingID or participantID.

## **Room Creation**

Before integration, create a room using the [REST API Rooms resource](https://docs.videosdk.live/api-reference/realtime-communication/create-room). Refer to the docs for details.

```js
cURL -XPOST https://api.videosdk.live/v2/rooms \
		 -H 'Authorization: $VIDEOSDK_TOKEN' \
		 -H 'Content-Type: application/json'
```

## Step 1 : Integrate Video SDK

```js title="settings.gradle"
dependencyResolutionManagement{
  repositories {
    // ...
    google()
    mavenCentral()
    maven { url "https://maven.aliyun.com/repository/jcenter" }
  }
}
```

- Add the following dependency in your app's `app/build.gradle`.

```js title="app/build.gradle"
dependencies {
    ...
//    implementation <strong>"com.twilio:audioswitch:1.1.8"
//    implementation <strong>"com.twilio:video-android:7.6.4"
    implementation "live.videosdk:rtc-android-sdk:0.1.25"
}
```

On the top right of your Android studio, click Sync Now after making these changes.

## Step 2 : Connect to a room

- In Twilio, You can initiate a connection to a video room using **`video.connect()`**. This method sets up a connection by specifying the room name, access token, and optionally including local audio, video, and data tracks.

- In VideoSDK, the process begins with setting up the SDK by initializing it and providing authentication through a token. After that you can initialize the meeting with required params such as `meetingId`, `participantName`, `micEnabled`, `webcamEnabled` and [more](https://docs.videosdk.live/android/api/sdk-reference/initMeeting). To join the meeting/room, you can simply call the **`meeting.join()`** method.

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Twilio"
groupId={"Twilio"}
values={[{label: 'Twilio', value: 'Twilio'},]}>

<TabItem value="Twilio">

```js
private fun connectToRoom() {
    room = connect(this, accessToken, roomListener) {
        roomName("<Room-Name>")
        audioTracks(listOf(localAudioTrack))
        videoTracks(listOf(localVideoTrack))
        preferAudioCodecs(listOf(audioCodec))
        preferVideoCodecs(listOf(videoCodec))
        encodingParameters(encodingParameters)
        enableAutomaticSubscription(enableAutomaticSubscription)
    }
}
```

</TabItem>

</Tabs>

<Tabs
defaultValue="VideoSDK"
groupId={"VideoSDK"}
values={[{label: 'VideoSDK', value: 'VideoSDK'}]}>

<TabItem value="VideoSDK">

```js
private fun connectToRoom() {

	// 1. Initialize VideoSDK
    VideoSDK.initialize(applicationContext);

	// 2. Configuration VideoSDK with Token
    VideoSDK.config(VIDEOSDK_ACCESS_TOKEN);

    var meetingId:String = "<Meeting-Id>";

    // 3. Initialize VideoSDK Meeting
    meeting = VideoSDK.initMeeting(
        this@VideoActivity, meetingId, "John",
        true, true ,null, null, false, null, null)

    // 4. Join VideoSDK Meeting
    meeting!!.join();

}
```

</TabItem>

</Tabs>

## Step 3: Handle Room Events

- In both Twilio and VideoSDK, you can utilize event listeners attached to the room or meeting object to capture crucial moments during a video conference. This listener include the meeting being connected or disconnected and participants joining or leaving the meeting events.

<Tabs
defaultValue="Twilio"
groupId={"Twilio"}
values={[{label: 'Twilio', value: 'Twilio'},]}>

<TabItem value="Twilio">

```js
private val roomListener = object : Room.Listener {
  override fun onConnected(room: Room) {}

  override fun onDisconnected(room: Room, e: TwilioException?) {}

  override fun onParticipantConnected(room: Room, participant: RemoteParticipant) {}

  override fun onParticipantDisconnected(room: Room, participant: RemoteParticipant) {}
}
```

</TabItem>

</Tabs>

<Tabs
defaultValue="VideoSDK"
groupId={"VideoSDK"}
values={[{label: 'VideoSDK', value: 'VideoSDK'}]}>

<TabItem value="VideoSDK">

```js
private val meetingEventListener: MeetingEventListener = object : MeetingEventListener() {
    override fun onMeetingJoined() {}

    override fun onMeetingLeft() {}

    override fun onParticipantJoined(participant: Participant) {}

    override fun onParticipantLeft(participant: Participant) {}
}
```

</TabItem>

</Tabs>

- Below is a list of all Twilio events and VideoSDK’s equivalents.

| **Twillio Event**           | **VideoSDK event**        |
| --------------------------- | ------------------------- |
| onConnected()               | onMeetingJoined()         |
| onDisconnected()            | onMeetingLeft()           |
| onParticipantConnected()    | onParticipantJoined()     |
| onParticipantDisconnected() | onParticipantLeft()       |
| onDominantSpeakerChanged()  | onSpeakerChanged()        |
| onRecordingStarted()        | onRecordingStateChanged() |
| onRecordingStopped()        | onRecordingStateChanged() |

## Step 4 : Set up local media

### Capture local media

- In Twilio, to capture local participant's audio data, you need to create a `LocalAudioTrack`, and for video, you add a `LocalVideoTrack` with an associated `VideoCapturer`.

- In VideoSDK, capturing tracks for a local participant is more straightforward. The Android SDK automatically captures both audio and video when you set `micEnabled` and `webCamEnabled` to `true` in the `initMeeting()` method. There's no need for explicit track creation; the SDK handles it automatically based on the provided configuration.

### Render local participant’s video

- Twilio provides a `VideoView` component to display participants' video feeds.

  - To display the video from the local participant, you have to link the `LocalVideoTrack` to the `VideoView` using the `addSink` method: **`localVideoTrack.addSink(localVideoView)`**.
  - If you want to stop displaying the local participant's video in the `VideoView`, you can remove the track using **`localVideoTrack.removeSink(localVideoView)`**.

- Similarly, VideoSDK offers a [VideoView](https://docs.videosdk.live/android/guide/video-and-audio-calling-api-sdk/render-media/display-video/understand-videoView-component) component to display participants' video stream.

  - To display the local participant's video, you have to add the track to the `VideoView` using the `addTrack` method: **`localVideoView.addTrack(track)`**.
  - When you want to stop displaying the local participant's video in the `VideoView`, you can remove the track using **`localVideoView.removeTrack()`** method.

- In Twilio , `LocalVideoTrack` is used to render a local participant’s video. However, VideoSDK have events `onStreamEnabled` and `onStreamDisabled` in `ParticipantEventListener` from which you can get track of audio, video.

  - **onStreamEnabled()** - `onStreamEnabled()` is a callback which gets triggered whenever a participant's video, audio or screen share stream is enabled.
  - **onStreamDisabled()** - `onStreamDisabled()` is a callback which gets triggered whenever a participant's video, audio or screen share stream is disabled.


<Tabs
defaultValue="Twilio - XML File"
groupId={"Twilio"}
values={[{label: 'Twilio - XML File', value: 'Twilio - XML File'},{label: 'Twilio - Kotlin File', value: 'Twilio - Kotlin File'},]}>

<TabItem value="Twilio - XML File">

```js
<com.twilio.video.VideoView
   android:id="@+id/localVideoView"
   android:layout_width="wrap_content"
   android:layout_height="wrap_content"
/>
```

</TabItem>

<TabItem value="Twilio - Kotlin File">

```js
private var localVideoTrack: LocalVideoTrack = //...

private fun addLocalParticipantVideo() {
    with(localVideoTrack){
        this?.addSink(localVideoView)
    }
}

private fun removeLocalParticipantVideo(){
    with(localVideoTrack) {
        this?.removeSink(localVideoView)
    }
}
```

</TabItem>

</Tabs>


<Tabs
defaultValue="VideoSDK - XML File"
groupId={"VideoSDK"}
values={[{label: 'VideoSDK - XML File', value: 'VideoSDK - XML File'},{label: 'VideoSDK - Kotlin File', value: 'VideoSDK - Kotlin File'},]}>

<TabItem value="VideoSDK - XML File">

```js
<live.videosdk.rtc.android.VideoView
   android:id="@+id/localVideoView"
   android:layout_width="wrap_content"
   android:layout_height="wrap_content"
/>
```

</TabItem>

<TabItem value="VideoSDK - Kotlin File">

```js
private fun setLocalListeners() {
  meeting!!.localParticipant.addEventListener(object : ParticipantEventListener() {
      override fun onStreamEnabled(stream: Stream) {
          if (stream.kind.equals("video", ignoreCase = true)) {
              val track = stream.track as VideoTrack
              localVideoView.addTrack(track)
          }
      }

      override fun onStreamDisabled(stream: Stream) {
          if (stream.kind.equals("video", ignoreCase = true)) {
              localVideoView.removeTrack()
          }
      }
  })
}
```

</TabItem>

</Tabs>

## Step 5 : Working with Remote Participants

### Get Connected Participants

- In Twilio , you can get the all the connected remote participants through `getRemoteParticipants()` method of `Room` class.

- Similarly, In VideoSDK you can get all the connected participant using `getParticipants()` method of `Meeting` class.

<Tabs
defaultValue="Twilio"
groupId={"Twilio"}
values={[{label: 'Twilio', value: 'Twilio'},]}>

<TabItem value="Twilio">

```js
// Get the first participant from the room
val participant = room.remoteParticipants[0]
Log.i("RemoteParticipants", participant.identity + " is in the room.")
```

</TabItem>

</Tabs>

<Tabs
defaultValue="VideoSDK"
groupId={"VideoSDK"}
values={[{label: 'VideoSDK', value: 'VideoSDK'}]}>

<TabItem value="VideoSDK">

```js
// Get the first participant from the meeting
val participant = meeting!!.participants[0]
Log.i("RemoteParticipants", participant.displayName + " is in the room.")
```

</TabItem>

</Tabs>

### Display a Remote Participant's Video

- In Twilio, you receive events `onVideoTrackSubscribed` and `onVideoTrackUnsubscribed` whenever a remote participant enabled or disabled their webcam. These events notify you when a participant starts or stops sharing their video.

- Similarly, in VideoSDK, you have `onStreamEnabled` and `onStreamDisabled` events. These events serve a similar purpose for both local and remote participants, triggered whenever participant enabled or disabled their webcam respectively.


<Tabs
defaultValue="Twilio"
groupId={"Twilio"}
values={[{label: 'Twilio', value: 'Twilio'},]}>

<TabItem value="Twilio">

```js
private fun roomListener(): Room.Listener? {
  return object : Room.Listener {
      override fun onParticipantConnected(room: Room, participant: RemoteParticipant) {
          participant.setListener(remoteParticipantListener())
      }
  }
}

private fun remoteParticipantListener(): RemoteParticipant.Listener? {
  return object : RemoteParticipant.Listener {
      override fun onVideoTrackSubscribed(
          participant: RemoteParticipant,
          remoteVideoTrackPublication: RemoteVideoTrackPublication,
          remoteVideoTrack: RemoteVideoTrack)
      {
          remoteVideoTrack.addSink(participantVideoView)
      }


      override fun onVideoTrackUnsubscribed(
          remoteParticipant: RemoteParticipant,
          remoteVideoTrackPublication: RemoteVideoTrackPublication,
          remoteVideoTrack: RemoteVideoTrack)
      {
          remoteVideoTrack.removeSink(participantVideoView)
      }
  }
}
```

</TabItem>

</Tabs>

<Tabs
defaultValue="VideoSDK"
groupId={"VideoSDK"}
values={[{label: 'VideoSDK', value: 'VideoSDK'}]}>

<TabItem value="VideoSDK">

```js
private val meetingEventListener: MeetingEventListener = object : MeetingEventListener() {
    override fun onParticipantJoined(participant: Participant) {
        participant.addEventListener(participantEventListener)
    }
}

private val participantEventListener: ParticipantEventListener =
  object : ParticipantEventListener() {
    override fun onStreamEnabled(stream: Stream) {
        if (stream.kind.equals("video", ignoreCase = true)) {
            val track = stream.track as VideoTrack
            participantVideoView.addTrack(track)
        }
    }

    override fun onStreamDisabled(stream: Stream) {
        if (stream.kind.equals("video", ignoreCase = true)) {
            val track: VideoTrack = stream.track as VideoTrack
            participantVideoView.removeTrack()
        }
    }
  }
```

</TabItem>

</Tabs>

## Features

### Toggle Mic of Local participant

- In Twilio, you can **mute/unmute** your LocalAudioTracks (microphone) by the setting `enable` property to `true/false`.
- In VideoSDK, you can **mute/unmute** Local participant’s microphone through `muteMic()` and `unmuteMic()` method of `Meeting` object.

<Tabs
defaultValue="Twilio"
groupId={"Twilio"}
values={[{label: 'Twilio', value: 'Twilio'},]}>

<TabItem value="Twilio">

```js
private fun muteClickListener(): View.OnClickListener {
    return View.OnClickListener {
        localAudioTrack?.let {
            val enable = !it.isEnabled
            it.enable(enable)
        } 
    }
}
```

</TabItem>

</Tabs>

<Tabs
defaultValue="VideoSDK"
groupId={"VideoSDK"}
values={[{label: 'VideoSDK', value: 'VideoSDK'}]}>

<TabItem value="VideoSDK">

```js
private fun muteClickListener(): View.OnClickListener {
    return View.OnClickListener {
        if(micEnabled){
            meeting!!.muteMic()
        } else {
            meeting!!.unmuteMic()
        }
        micEnabled=!micEnabled
    }
}
```

</TabItem>

</Tabs>

### Toggle Webcam of Local participant

- In Twilio, you can **enable/disable** your LocalVideoTracks (WebCam) by the setting enable property to `true/false`.
- In VideoSDK, you can **enable/disable** Local participant’s WebCam by calling `enableWebcam()` and `disableWebcam()` method of `Meeting` object.


<Tabs
defaultValue="Twilio"
groupId={"Twilio"}
values={[{label: 'Twilio', value: 'Twilio'},]}>

<TabItem value="Twilio">

```js
private fun localVideoClickListener(): View.OnClickListener {
    return View.OnClickListener { 
        localVideoTrack?.let {
            val enable = !it.isEnabled
            it.enable(enable)
        }  
    }
}
```

</TabItem>

</Tabs>

<Tabs
defaultValue="VideoSDK"
groupId={"VideoSDK"}
values={[{label: 'VideoSDK', value: 'VideoSDK'}]}>

<TabItem value="VideoSDK">

```js
private fun localVideoClickListener(): View.OnClickListener {
    return View.OnClickListener {
        if (webcamEnabled) {
            meeting!!.disableWebcam()
        } else {
            meeting!!.enableWebcam()
        }
        webcamEnabled=!webcamEnabled
    }
}
```

</TabItem>

</Tabs>

### Disconnect from a Room

- In Twilio, you have the ability to disconnect from a room in which you are currently participating. Other Participants will receive a `onParticipantDisconnected` event.
- In VideoSDK, you can also disconnect from a room you are currently participating in. Other Participants will receive a `onParticipantLeft` event, while the local participant will receive a `onMeetingLeft` event.

<Tabs
defaultValue="Twilio"
groupId={"Twilio"}
values={[{label: 'Twilio', value: 'Twilio'},]}>

<TabItem value="Twilio">

```js
private fun roomListener(): Room.Listener? {
  return object : Room.Listener {
      override fun onDisconnected(room: Room, e: TwilioException?) {
          Log.d(TAG, "Disconnected from " + room.name)
      }
  }
}

// To disconnect from a Room
room?.disconnect();
```

</TabItem>

</Tabs>

<Tabs
defaultValue="VideoSDK"
groupId={"VideoSDK"}
values={[{label: 'VideoSDK', value: 'VideoSDK'}]}>

<TabItem value="VideoSDK">

```js
private val meetingEventListener: MeetingEventListener = object : MeetingEventListener() {
    override fun onMeetingLeft() {}
}

// To leave the meeting without removing all the participant
// you need to call leave() of the Meeting class.
meeting?.leave();


// To leave the meeting by removing all the participant
// you need to call end() of the Meeting class.
meeting?.end();
```

</TabItem>

</Tabs>

## Conclusion

As you conclude this migration journey, you've successfully adapted your application from Twilio to VideoSDK. The [developed project](https://github.com/videosdk-live/migration-to-X/tree/main/Twilio/android-quickstart) showcases the implementation of VideoSDK in action, emphasizing its simplicity and efficiency.

Key Takeaways:

- Automatic API key generation streamlines the setup process.
- Token generation is simplified, offering flexibility for participants.
- Granular control over participant tokens enhances security.
- Global scalability and minimal latency ensure a seamless user experience.

Feel free to explore the developed project's codebase for a hands-on understanding of VideoSDK integration. As you transition, VideoSDK empowers your application with robust real-time communication features, providing a foundation for future scalability and innovation.

## Contact Us

For any further assistance, questions, or community engagement, we welcome you to join our [Discord channel](https://discord.com/invite/Gpmj6eCq5u). Connect with fellow developers, share insights, and stay updated on the latest developments.

If you require developer support or need personalized assistance, you can schedule a session with our team through our [Developer Support portal](https://bookings.videosdk.live/#/customer/discovery). We are here to ensure a smooth integration and address any queries you may have. Your success with VideoSDK is our priority.


---

---
title: iOS - Migration Guide From Twilio Video to Video SDK
description: Explore the seamless transition from Twilio to Video SDK for iOS with our comprehensive migration guide. Elevate your video communication with expert insights and step-by-step instructions.
keywords:
  - Twilio to Video SDK migration guide for iOS
  - Twilio to Video SDK migration guide
  - Twilio to Video SDK migration tutorial
slug: migration-guide-from-twilio-to-videosdk-ios-sdk
# authors:
#   - name: Joel Marcey
#     title: Co-creator of Docusaurus 1
#     url: https://github.com/JoelMarcey
#     image_url: https://github.com/JoelMarcey.png
tags: [Migration Guide, Twilio, iOS]
hide_table_of_contents: false
---

<!-- truncate -->

## Overview

This migration guide provides a seamless transition from Twilio to VideoSDK, offering a simplified and intuitive comparison of key elements. Whether you're already familiar with Twilio or new to both platforms, this guide ensures a smooth migration process.

We're here to help you switch from Twilio to VideoSDK. We'll use the Twilio Quickstart sample app as a starting point. You can find the code for the sample app here: [https://github.com/twilio/video-quickstart-ios](https://github.com/twilio/video-quickstart-ios)

## Concept

1.  **Meeting / Room:**
    - This is like a virtual place where people can have real-time conversations using voice, video, and screen sharing.
    - Think of it as a virtual room where participants interact.
    - Each meeting or room has a unique ID (meetingId or roomId).
2.  **Participant:**
    - Both VideoSDK and Twilio Video includes the concepts of **Participant.**
    - There are two types:
      - **Local Participant:** This is you on your device. You control your own audio and video.
      - **Remote Participant:** This is someone else in the meeting. They receive your audio and video and can send their own.
3.  **MediaStream & Track:**
    - **MediaStream:** Think of it as a bundle of audio and video tracks that are shared in real-time between participants.
    - **Track:** This is like a continuous flow of audio or video. For example, your video feed from the camera is a video track, and the audio from the microphone is an audio track.
4.  **Session:**
    - A session is like a specific instance of an ongoing meeting or room.
    - Imagine a meeting happening right now as a session.
    - Each session has its own ID (sessionId).

If you want to learn about this concept in depth you can refer this guide [Concept and Architecture](https://docs.videosdk.live/javascript/guide/video-and-audio-calling-api-sdk/concept-and-architecture)

## VideoSDK Setup

### API Key

In Twilio you have to create API key manually(using CLI or from Dashboard), in VideoSDK the default API key is automatically created in [VideoSDK dashboard](https://app.videosdk.live).

### Token

In Twilio, you can generate a token using CLI or the Twilio helper library in the backend environment.

For VideoSDK, there are two ways to generate a token. You can [generate it from the VideoSDK Dashboard](https://docs.videosdk.live/javascript/guide/video-and-audio-calling-api-sdk/authentication-and-token#1-generating-token-from-dashboard) or [in your backend](https://docs.videosdk.live/javascript/guide/video-and-audio-calling-api-sdk/authentication-and-token#2-generating-token-in-your-backend).

In Twilio, you need to provide a different token for each participant, which can be complex during development. In VideoSDK, it is optional to specify the same token for different participants. You can also restrict a specific token for a specific meetingID or participantID.

## Room Creation

Before integration, create a room using the [REST API Rooms resource](https://docs.videosdk.live/api-reference/realtime-communication/create-room). Refer to the docs for details.

```jsx
cURL -XPOST <https://api.videosdk.live/v2/rooms> \\
		 -H 'Authorization: $VIDEOSDK_TOKEN' \\
		 -H 'Content-Type: application/json'
```

## Step 1 : Integrate Video SDK

There is two ways to implement the VideoSDK dependency into your application:

1. **SPM (Swift Package Manager):**

   - Select **File** → **Add Package** Dependencies and search below url and press **Add Package** button.

   ```js
   https://github.com/videosdk-live/videosdk-rtc-ios-spm
   ```

2. **Cocoa pods:**

   - You can add the dependency in the podfile.

   ```js
   use_frameworks!

   target 'VideoSDK_Example' do

   	// write below line for adding the dependency of VideoSDK
   	pod 'VideoSDKRTC', :git => 'https://github.com/videosdk-live/videosdk-rtc-ios-sdk.git'

   end
   ```

   run `pod install` command in terminal at location of the application to install the dependency in the application.

## Step 2 : Connect to a room

- In Twilio, You can initiate a connection to a video room using `TwilioVideoSDK.connect()`. This method sets up a connection by specifying the connection options and delegate of the meeting.
- In VideoSDK, the process begins with setting up the SDK by initializing it and providing authentication through a token. After that you can initialize the meeting with required params such as `meetingId`, `participantId`, `participantName`,  `micEnabled`,  `webcamEnabled` and more. To join the meeting/room, you can simply call the `meeting.join()` method.


import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Twilio"
groupId={"Twilio"}
values={[{label: 'Twilio', value: 'Twilio'},]}>

<TabItem value="Twilio">

```js
@IBAction func createARoom(sender: AnyObject) {
    let connectOptions = ConnectOptions(token: accessToken) { (builder) in
        builder.roomName = "my-room"
    }
    room = TwilioVideoSDK.connect(options: connectOptions, delegate: self)
}

// MARK: RoomDelegate

func roomDidConnect(room: Room) {
    print("Did connect to Room")

    if let localParticipant = room.localParticipant {
        print("Local identity \(localParticipant.identity)")

        // Set the delegate of the local particiant to receive callbacks
        localParticipant.delegate = self
    }
}
```

</TabItem>

</Tabs>

<Tabs
defaultValue="VideoSDK"
groupId={"VideoSDK"}
values={[{label: 'VideoSDK', value: 'VideoSDK'}]}>

<TabItem value="VideoSDK">

```js
private var meeting: Meeting?

override func viewDidLoad() {
    super.viewDidLoad()

    // Configure authentication token got earlier
    VideoSDK.config(token: VIDEOSDK_ACCESS_TOKEN)

    // create a new meeting instance
    meeting = VideoSDK.initMeeting(
        meetingId: meetingId, // required
        participantName: participantName, // required
        micEnabled: <flag-to-enable-mic>, // optional, default: true
        webcamEnabled: <flag-to-enalbe-camera> // optional, default: true
    )

	// join
	meeting?.join();
}
```

</TabItem>

</Tabs>

## Step 3 : Handle Connected Participants

- In both Twilio and VideoSDK, you can utilise event listeners attached to the room or meeting object to capture crucial moments during a video conference. This listener include the meeting being connected or disconnected and participants joining or leaving the meeting events.


<Tabs
defaultValue="Twilio"
groupId={"Twilio"}
values={[{label: 'Twilio', value: 'Twilio'},]}>

<TabItem value="Twilio">

```js
// MARK: RoomDelegate

func roomDidConnect(room: Room) { ... }

func participantDidConnect(room: Room, participant: RemoteParticipant) { ... }

func participantDidDisconnect(room: Room, participant: RemoteParticipant) { ... }

func roomDidDisconnect(room: Room, error: Error?) { ... }
```

</TabItem>

</Tabs>

<Tabs
defaultValue="VideoSDK"
groupId={"VideoSDK"}
values={[{label: 'VideoSDK', value: 'VideoSDK'}]}>

<TabItem value="VideoSDK">

```js
// MARK: - MeetingEventListener [RoomDelegate]

extension YourViewController: MeetingEventListener {
    // [roomDidConnect]
    func onMeetingJoined() { ... }

    // [roomDidDisconnect]
    func onMeetingLeft() { ... }

    // [participantDidConnect]
    func onParticipantJoined(_ participant: Participant) { ... }

    // [participantDidDisconnect]
    func onParticipantLeft(_ participant: Participant) { ... }
}
```

</TabItem>

</Tabs>


#### Mapping Twilio’s events to VideoSDK

Below is a list of all Twilio events used in this demo and VideoSDK’s equivalents.

| Twilio Events            | VideoSDK Events                                                                                                    |
| ------------------------ | ------------------------------------------------------------------------------------------------------------------ |
| roomDidConnect()         | [onMeetingJoined()](https://docs.videosdk.live/ios/api/sdk-reference/meeting-class/events#onmeetingjoined)         |
| roomDidDisconnect()      | [onMeetingLeft()](https://docs.videosdk.live/ios/api/sdk-reference/meeting-class/events#onmeetingleft)             |
| participantDidConnect()  | [onParticipantJoined()](https://docs.videosdk.live/ios/api/sdk-reference/meeting-class/events#onparticipantjoined) |
| participantDidDisconnect | [onParticipantLeft()](https://docs.videosdk.live/ios/api/sdk-reference/meeting-class/events#onparticipantleft)     |

## Step 4 : Set up local media

### Capture local media

- In Twilio, to capture local participant's audio data, you need to provide track for audio and video while connecting the meeting.
- In VideoSDK, capturing tracks for a local participant is more straightforward. The iOS SDK automatically captures both audio and video when you set `micEnabled` and `webCamEnabled`to `true` in the `initMeeting()` method. There's no need for explicit track creation; the SDK handles it automatically based on the provided configuration.

### Render local participant’s video

- Twilio provides a `LocalVideoTrack` component to display participants' video feeds.
  - To display the video from the local participant, you have to link the `LocalVideoTrack` to the `TVIVideoView` using the `addRenderer` method: `videoTrack.addRenderer(renderer)`.
- Similarly, VideoSDK offers a VideoView component to display participants' video stream.
  - To display the local participant's video, you have to add the track to the `RTCMTLVideoView` using the add method: `videotrack.add(videoView)`.
  - When you want to stop displaying the local participant's video in the `RTCMTLVideoView`, you can remove the track using `videotrack.remove(videoView)` method.
- In Twilio , `LocalVideoTrack` is used to render a local participant’s video. However, VideoSDK have events `onStreamEnabled` and `onStreamDisabled` in `ParticipantEventListener` from which you can get track of audio, video.
  - onStreamEnabled() - `onStreamEnabled()` is a callback which gets triggered whenever a participant's video, audio or screen share stream is enabled.
  - onStreamDisabled() - `onStreamDisabled()` is a callback which gets triggered whenever a participant's video, audio or screen share stream is disabled.

<Tabs
defaultValue="Twilio"
groupId={"Twilio"}
values={[{label: 'Twilio', value: 'Twilio'},]}>

<TabItem value="Twilio">

```js
// Use CameraSource to produce video from the device's front camera.

if let camera = CameraSource(delegate: self),
    let videoTrack = LocalVideoTrack(source: camera) {

    // VideoView is a VideoRenderer and can be added to any VideoTrack.
    let renderer = VideoView(frame: view.bounds)

if let camera = TVICameraCapturer(source: .frontCamera),
    let videoTrack = TVILocalVideoTrack(capturer: camera) {

    // TVIVideoView is a TVIVideoRenderer and can be added to any TVIVideoTrack.
    let renderer = TVIVideoView(frame: view.bounds)

    // Add renderer to the video track
    videoTrack.addRenderer(renderer)

    self.localVideoTrack = videoTrack
    self.camera = camera
    self.view.addSubview(renderer)
} else {
    print("Couldn't create CameraCapturer or LocalVideoTrack")
}
```

</TabItem>

</Tabs>

<Tabs
defaultValue="VideoSDK"
groupId={"VideoSDK"}
values={[{label: 'VideoSDK', value: 'VideoSDK'}]}>

<TabItem value="VideoSDK">

```js
// MARK: - ParticipantEventListener

extension YourViewController: ParticipantEventListener {
    /// Participant has enabled mic, video or screenshare
    func onStreamEnabled(_ stream: MediaStream, forParticipant participant: Participant) {
        if stream.kind == .state(value: .video)  {
            // show stream in cell
            if let cell = self.cellForParticipant(participant) {
                cell.updateView(forStream: stream, enabled: true)
            }
        } else { ... }
    }

    /// Participant has disabled mic, video or screenshare
    func onStreamDisabled(_ stream: MediaStream, forParticipant participant: Participant) {
		if stream.kind == .state(value: .video) {
	        // hide stream in cell
	        if let cell = self.cellForParticipant(participant) {
	            cell.updateView(forStream: stream, enabled: false)
            }
        } else { ... }
    }
}
```

</TabItem>

</Tabs>


## Step 5 : Working with Remote Participants

### Get Connected Participants

- In Twilio, you can get the all the connected remote participants through `remoteParticipants` property of `Room` class.
- Similarly, In VideoSDK you can get all the connected participant using  `participants` property of `Meeting` class.

<Tabs
defaultValue="Twilio"
groupId={"Twilio"}
values={[{label: 'Twilio', value: 'Twilio'},]}>

<TabItem value="Twilio">

```js
// MARK: RoomDelegate

func roomDidConnect(room: Room) {
    //...
    // Connected participants already in the room
    print("Number of connected Participants \(room.remoteParticipants.count)")

    // Set the delegate of the remote participants to receive callbacks
    for remoteParticipant in room.remoteParticipants {
        remoteParticipant.delegate = self
    }
}
```

</TabItem>

</Tabs>

<Tabs
defaultValue="VideoSDK"
groupId={"VideoSDK"}
values={[{label: 'VideoSDK', value: 'VideoSDK'}]}>

<TabItem value="VideoSDK">

```js
// Get the first participant from the meeting
let participant = meeting.participants.first?.value;
print("(participant.displayName) is in the room.");
```

</TabItem>

</Tabs>


### Display a Remote Participant's Video

- In Twilio, you receive events `didSubscribeToVideoTrack` whenever a remote participant enabled their webcam. These events notify you when a participant starts sharing their video.
- Similarly, in VideoSDK, you have `onStreamEnabled` and `onStreamDisabled` events. These events serve a similar purpose for both local and remote participants, triggered whenever participant enabled or disabled their webcam respectively.

<Tabs
defaultValue="Twilio"
groupId={"Twilio"}
values={[{label: 'Twilio', value: 'Twilio'},]}>

<TabItem value="Twilio">

```js
// MARK: RemoteParticipantDelegate

/*
 * In the Participant Delegate, we can respond when the Participant adds a Video
 * Track by rendering it on screen.
 */
func didSubscribeToVideoTrack(videoTrack: RemoteVideoTrack,
                              publication: RemoteVideoTrackPublication,
                              participant: RemoteParticipant) {

    print("Participant \(participant.identity) added a video track.")

    if let remoteView = VideoView.init(frame: self.view.bounds,
                                       delegate:self) {

        videoTrack.addRenderer(remoteView)
        self.view.addSubview(remoteView)
        self.remoteView = remoteView
    }
}

// MARK: VideoViewDelegate

// Lastly, we can subscribe to important events on the VideoView
func videoViewDimensionsDidChange(view: VideoView, dimensions: CMVideoDimensions) {
    print("The dimensions of the video track changed to: \(dimensions.width)x\(dimensions.height)")
    self.view.setNeedsLayout()
}
```

</TabItem>

</Tabs>

<Tabs
defaultValue="VideoSDK"
groupId={"VideoSDK"}
values={[{label: 'VideoSDK', value: 'VideoSDK'}]}>

<TabItem value="VideoSDK">

```js
// MARK: - MeetingEventListener

extension YourViewController: MeetingEventListener {
    func onParticipantJoined(_ participant: Participant) {
        // add listener
        participant.addEventListener(self)
     }
}

// MARK: - ParticipantEventListener

extension YourViewController: ParticipantEventListener {

    /// Participant has enabled mic, video or screenshare
    func onStreamEnabled(_ stream: MediaStream, forParticipant participant: Participant) {
        if stream.kind == .state(value: .video)  {
            // show stream in cell
            if let cell = self.cellForParticipant(participant) {
                cell.updateView(forStream: stream, enabled: true)
            }
        } else {
            if let cell = self.cellForParticipant(participant) {
                cell.updateView(forStream: stream, enabled: true)
            }
        }
    }

    /// Participant has disabled mic, video or screenshare
    func onStreamDisabled(_ stream: MediaStream, forParticipant participant: Participant) {
        if stream.kind == .state(value: .video) {
	          // hide stream in cell
	          if let cell = self.cellForParticipant(participant) {
	              cell.updateView(forStream: stream, enabled: false)
            }
        } else {
            if let cell = self.cellForParticipant(participant) {
                cell.updateView(forStream: stream, enabled: false)
            }
        }
    }
}
```

</TabItem>

</Tabs>


### Disconnect from a Room

- In Twilio, you have the ability to disconnect from a room in which you are currently participating. Other Participants will receive a `participantDisconnected` event.
- In VideoSDK, you can also disconnect from a room you are currently participating in. Other Participants will receive a `onParticipantLeft` event, while the local participant will receive a `onMeetingLeft` event.

<Tabs
defaultValue="Twilio"
groupId={"Twilio"}
values={[{label: 'Twilio', value: 'Twilio'},]}>

<TabItem value="Twilio">

```js
// To disconnect from a Room, we call:
room?.disconnect()

// This results in a callback to RoomDelegate#roomDidDisconnect(room: Room, error: Error?)

// MARK: RoomDelegate
func roomDidDisconnect(room: Room, error: Error?) {
    print("Disconnected from room \(room.name)")
}
```

</TabItem>

</Tabs>

<Tabs
defaultValue="VideoSDK"
groupId={"VideoSDK"}
values={[{label: 'VideoSDK', value: 'VideoSDK'}]}>

<TabItem value="VideoSDK">

```js
// MARK: - MeetingEventListener [RoomDelegate]

extension YourViewController: MeetingEventListener {

    // event after meeting?.end()
    func onMeetingLeft() { ... }

	// event after meeting?.leave()
    func onParticipantLeft(_ participant: Participant) { ... }
}

// To leave the meeting without removing all the participant
// you need to call leave() of the Meeting class.
meeting?.leave()


// To leave the meeting by removing all the participant
// you need to call end() of the Meeting class.
meeting?.end();
```

</TabItem>

</Tabs>


## Conclusion

As you conclude this migration journey, you've successfully adapted your application from Twilio to VideoSDK.

Feel free to explore the developed project's codebase for a hands-on understanding of VideoSDK integration. As you transition, VideoSDK empowers your application with robust real-time communication features, providing a foundation for future scalability and innovation.

## Contact Us

For any further assistance, questions, or community engagement, we welcome you to join our [Discord channel](https://discord.com/invite/Gpmj6eCq5u). Connect with fellow developers, share insights, and stay updated on the latest developments.

If you require developer support or need personalized assistance, you can schedule a session with our team through our [Developer Support portal](https://bookings.videosdk.live/#/customer/discovery). We are here to ensure a smooth integration and address any queries you may have. Your success with VideoSDK is our priority.


---

---
title: JavaScript - Migration Guide From Twilio Video to Video SDK
description: Explore the seamless transition from Twilio to Video SDK for javascript with our comprehensive migration guide. Elevate your video communication with expert insights and step-by-step instructions.
keywords:
  - Twilio to Video SDK migration guide for Javascript
  - Twilio to Video SDK migration guide
  - Twilio to Video SDK migration tutorial
slug: migration-guide-from-twilio-to-videosdk-js-sdk
# authors:
#   - name: Joel Marcey
#     title: Co-creator of Docusaurus 1
#     url: https://github.com/JoelMarcey
#     image_url: https://github.com/JoelMarcey.png
tags: [Migration Guide, Twilio, JavaScript]
hide_table_of_contents: false
---

<!-- truncate -->

## Overview

**Welcome to your smooth transition to VideoSDK with JavaScript!**

This comprehensive guide empowers you to seamlessly migrate from Twilio to VideoSDK in Javascript. We understand that adapting to new technology can be challenging, which is why we've designed this guide to be clear, concise, and informative.

We've created a straightforward comparison of Twilio and VideoSDK elements, making it easy to identify key differences and understand their corresponding counterparts. Whether you're a seasoned Twilio user or new to both platforms, this guide caters to your level of expertise, ensuring a smooth learning curve.

This migration guide provides a seamless transition from Twilio to VideoSDK, offering a simplified and intuitive comparison of key elements. Whether you're already familiar with Twilio or new to both platforms, this guide ensures a smooth migration process.

## Getting Started

To facilitate the transition, we'll leverage the familiar Twilio Quickstart sample app as a starting point. You can find the code for the app readily available here:[https://github.com/twilio/video-quickstart-js](https://github.com/twilio/video-quickstart-js)

## Concept

1.  **Meeting / Room:**
    - This is like a virtual place where people can have real-time conversations using voice, video, and screen sharing.
    - Think of it as a virtual room where participants interact.
    - Each meeting or room has a unique ID (meetingId or roomId).
2.  **Participant:**
    - Both VideoSDK and Twilio Video includes the concepts of **Participant.**
    - There are two types:
      - **Local Participant:** This is you on your device. You control your own audio and video.
      - **Remote Participant:** This is someone else in the meeting. They receive your audio and video and can send their own.
3.  **MediaStream & Track:**
    - **MediaStream:** Think of it as a bundle of audio and video tracks that are shared in real-time between participants.
    - **Track:** This is like a continuous flow of audio or video. For example, your video feed from the camera is a video track, and the audio from the microphone is an audio track.
4.  **Session:**
    - A session is like a specific instance of an ongoing meeting or room.
    - Imagine a meeting happening right now as a session.
    - Each session has its own ID (sessionId).

If you want to learn about this concept in depth you can refer this guide [Concept and Architecture](https://docs.videosdk.live/javascript/guide/video-and-audio-calling-api-sdk/concept-and-architecture)

## VideoSDK Setup

### API Key

In Twilio you have to create API key manually(using CLI or from Dashboard), in VideoSDK the default API key is automatically created in [VideoSDK dashboard](https://app.videosdk.live).

### Token

In Twilio, you can generate a token using CLI or the Twilio helper library in the backend environment.

For VideoSDK, there are two ways to generate a token. You can [generate it from the VideoSDK Dashboard](https://docs.videosdk.live/javascript/guide/video-and-audio-calling-api-sdk/authentication-and-token#1-generating-token-from-dashboard) or [in your backend](https://docs.videosdk.live/javascript/guide/video-and-audio-calling-api-sdk/authentication-and-token#2-generating-token-in-your-backend).

In Twilio, you need to provide a different token for each participant, which can be complex during development. In VideoSDK, it is optional to specify the same token for different participants. You can also restrict a specific token for a specific meetingID or participantID.

## Installation

You can install the VidoeSDK library using [NPM](https://www.npmjs.com/).

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="npm"
groupId={"server-group-id"}
values={[
{label: 'NPM', value: 'npm'},
{label: 'Yarn', value: 'yarn'},
]}>
<TabItem value="npm">

```js
npm install @videosdk.live/js-sdk
```

</TabItem>
<TabItem value="yarn">

```js
yarn add @videosdk.live/js-sdk
```

</TabItem>
</Tabs>

You can also include it in your application using our CDN.

```jsx
<script src="<https://sdk.videosdk.live/js-sdk/0.2.6/videosdk.js>"></script>
```

Using this method, VideoSDK will set a browser global:

```jsx
const VideoSDK = window.VideoSDK;
```

## Room Creation

Before integration, create a room using the [REST API Rooms resource](https://docs.videosdk.live/api-reference/realtime-communication/create-room). Refer to the docs for details.

```jsx
cURL -XPOST <https://api.videosdk.live/v2/rooms> \\
		 -H 'Authorization: $VIDEOSDK_TOKEN' \\
		 -H 'Content-Type: application/json'
```

## Step 1 : Connect to a Room

- In Twilio, you can connect to a room using the `video.connect()` method, which accepts the `token` and `connectOptions` as parameters.
- In VideoSDK, you need to first configure the token using `VideoSDK.config('TOKEN')`, and then initialize VideoSDK using the `initMeeting` method, which accepts parameters such as the meetingId and participant name. You can refer to other parameters from this [reference](https://docs.videosdk.live/javascript/api/sdk-reference/initMeeting#initmeeting).
- When joining and leaving a room, the Twilio Local Participant receives the `connected` and `disconnected` events of the room.
- On the other hand, the VideoSDK Local Participant receives the `meeting-joined` and `meeting-left` events of the meeting when joining and leaving the room.

<Tabs
defaultValue="Twilio"
groupId={"Twilio"}
values={[{label: 'Twilio', value: 'Twilio'},]}>

<TabItem value="Twilio">

```js
const video = Twilio.Video;
function initializeMeeting() {
  connect("$TOKEN", { name: "my-new-room" }).then(
    (room) => {
      console.log(`Successfully joined a Room: ${room}`);
      room.on("connected", (participant) => {
        console.log(`Local Participant Joined Successfully`);
      });
      room.on("disconnected", (participant) => {
        console.log(`Local Participant Left the Room`);
      });
    },
    (error) => {
      console.error(`Unable to connect to Room: ${error.message}`);
    }
  );
}
```

</TabItem>

</Tabs>

<Tabs
defaultValue="VideoSDK"
groupId={"VideoSDK"}
values={[{label: 'VideoSDK', value: 'VideoSDK'}]}>

<TabItem value="VideoSDK">

```js
let meeting = null; // Declare global variable

function initializeMeeting() {
  window.VideoSDK.config("$TOKEN");

  let meetingId = "abcd-efgh-ijkl"; // You can replace the meetingId

  meeting = window.VideoSDK.initMeeting({
    meetingId: meetingId, // required
    name: "The Migrator", // required
    micEnabled: true, // optional, default: true
    webcamEnabled: true, // optional, default: true
  });

  meeting.join();

  meeting.on("meeting-joined", () => {
    console.log(`Local Participant Joined Successfully`);
  });

  meeting.on("meeting-left", () => {
    console.log(`Local Participant Left the Room`);
  });
}
```

</TabItem>

</Tabs>

## Step 2 : Render Local Participant

- In Twilio and VideoSDK, you can access the localParticipant by using `room.localParticipant` and `meeting.localParticipant` respectively.
- To get the MediaStream in VideoSDK, listen for the `stream-enabled` event of the Participant class and set the audio and video tracks accordingly.
- In the code snippet below, we have defined the magic functions `createVideoElement`, `createAudioElement`, and `setTrack` to help render the Local and Remote Participants easily.
- VideoSDK automatically detaches the MediaStream Tracks when you leave the meeting. Additionally, you can pause and resume the participant stream using the [pause()](https://docs.videosdk.live/javascript/api/sdk-reference/stream-class/methods#pause) and [resume()](https://docs.videosdk.live/javascript/api/sdk-reference/stream-class/methods#resume) methods of the [Stream](https://docs.videosdk.live/javascript/api/sdk-reference/stream-class/introduction) Class.

<Tabs
defaultValue="Twilio"
groupId={"Twilio"}
values={[{label: 'Twilio', value: 'Twilio'},]}>

<TabItem value="Twilio">

```js
function setupParticipantContainer(participant, room) {
  const { identity, sid } = participant;

  // Add a container for the Participant's media.
  const $container =
    $(`<div class="participant" data-identity="${identity}" id="${sid}">
    <audio autoplay ${
      participant === room.localParticipant ? "muted" : ""
    } style="opacity: 0"></audio>
    <video autoplay muted playsinline style="opacity: 0"></video>
  </div>`);

  // Add the Participant's container to the DOM.
  $participants.append($container);
}

function participantConnected(participant, room) {
  // Set up the Participant's media container.
  setupParticipantContainer(participant, room);

  // Handle the TrackPublications already published by the Participant.
  participant.tracks.forEach((publication) => {
    trackPublished(publication, participant);
  });

  // Handle theTrackPublications that will be published by the Participant later.
  participant.on("trackPublished", (publication) => {
    trackPublished(publication, participant);
  });
}

function trackPublished(publication, participant) {
  // If the TrackPublication is already subscribed to, then attach the Track to the DOM.
  if (publication.track) {
    attachTrack(publication.track, participant);
  }

  // Once the TrackPublication is subscribed to, attach the Track to the DOM.
  publication.on("subscribed", (track) => {
    attachTrack(track, participant);
  });

  // Once the TrackPublication is unsubscribed from, detach the Track from the DOM.
  publication.on("unsubscribed", (track) => {
    detachTrack(track, participant);
  });
}

function attachTrack(track, participant) {
  // Attach the Participant's Track to the thumbnail.
  const $media = $(`div#${participant.sid} > ${track.kind}`, $participants);
  $media.css("opacity", "");
  track.attach($media.get(0));

  // If the attached Track is a VideoTrack that is published by the active
  // Participant, then attach it to the main video as well.
  if (track.kind === "video" && participant === activeParticipant) {
    track.attach($activeVideo.get(0));
    $activeVideo.css("opacity", "");
  }
}

function detachTrack(track, participant) {
  // Detach the Participant's Track from the thumbnail.
  const $media = $(`div#${participant.sid} > ${track.kind}`, $participants);
  const mediaEl = $media.get(0);
  $media.css("opacity", "0");
  track.detach(mediaEl);
  mediaEl.srcObject = null;

  // If the detached Track is a VideoTrack that is published by the active
  // Participant, then detach it from the main video as well.
  if (track.kind === "video" && participant === activeParticipant) {
    const activeVideoEl = $activeVideo.get(0);
    track.detach(activeVideoEl);
    activeVideoEl.srcObject = null;
    $activeVideo.css("opacity", "0");
  }
}
```

</TabItem>

</Tabs>

<Tabs
defaultValue="VideoSDK"
groupId={"VideoSDK"}
values={[{label: 'VideoSDK', value: 'VideoSDK'}]}>

<TabItem value="VideoSDK">

```js
function initializeMeeting() {
  // ...

  // Handle the LocalParticipant's media.
  // participantConnected(room.localParticipant, room);

  // creating local participant
  createLocalParticipant();

  // setting local participant stream
  meeting.localParticipant.on("stream-enabled", (stream) => {
    setTrack(stream, null, meeting.localParticipant, true);
  });

  // ...
}

// creating video element
function createVideoElement(pId, name) {
  let videoFrame = document.createElement("div");
  videoFrame.setAttribute("id", `f-${pId}`);

  //create video
  let videoElement = document.createElement("video");
  videoElement.classList.add("video-frame");
  videoElement.setAttribute("id", `v-${pId}`);
  videoElement.setAttribute("playsinline", true);
  videoElement.setAttribute("width", "300");
  videoFrame.appendChild(videoElement);

  let displayName = document.createElement("div");
  displayName.innerHTML = `Name : ${name}`;

  videoFrame.appendChild(displayName);
  return videoFrame;
}

// creating audio element
function createAudioElement(pId) {
  let audioElement = document.createElement("audio");
  audioElement.setAttribute("autoPlay", "false");
  audioElement.setAttribute("playsInline", "true");
  audioElement.setAttribute("controls", "false");
  audioElement.setAttribute("id", `a-${pId}`);
  audioElement.style.display = "none";
  return audioElement;
}

// creating local participant
function createLocalParticipant() {
  let localParticipant = createVideoElement(
    meeting.localParticipant.id,
    meeting.localParticipant.displayName
  );
  videoContainer.appendChild(localParticipant);
}

// setting media track
function setTrack(stream, audioElement, participant, isLocal) {
  if (stream.kind == "video") {
    isWebCamOn = true;
    const mediaStream = new MediaStream();
    mediaStream.addTrack(stream.track);
    let videoElm = document.getElementById(`v-${participant.id}`);
    videoElm.srcObject = mediaStream;
    videoElm
      .play()
      .catch((error) =>
        console.error("videoElem.current.play() failed", error)
      );
  }
  if (stream.kind == "audio") {
    if (isLocal) {
      isMicOn = true;
    } else {
      const mediaStream = new MediaStream();
      mediaStream.addTrack(stream.track);
      audioElement.srcObject = mediaStream;
      audioElement
        .play()
        .catch((error) => console.error("audioElem.play() failed", error));
    }
  }
}
```

</TabItem>

</Tabs>

## Step 3 : Handle Connected Participants

- To receive notifications when a remote participant joins or leaves a call in Twilio, you can use the `participantConnected` and `participantDisconnected` events of the room.
- Similarly, in VideoSDK, you can use the `participant-joined` and `participant-left` events of the meeting to be notified when a remote participant joins or leaves the call.
- In addition, the `stream-enabled` event of the Participant class is used to manage the media track of a specific participant by associating it with the appropriate video or audio element.

<Tabs
defaultValue="Twilio"
groupId={"Twilio"}
values={[{label: 'Twilio', value: 'Twilio'},]}>

<TabItem value="Twilio">

```js
function initializeMeeting() {
  // ...

  // Subscribe to the media published by RemoteParticipants already in the Room.
  room.participants.forEach((participant) => {
    participantConnected(participant, room);
  });

  // Subscribe to the media published by RemoteParticipants joining the Room later.
  room.on("participantConnected", (participant) => {
    participantConnected(participant, room);
  });

  // Handle a disconnected RemoteParticipant.
  room.on("participantDisconnected", (participant) => {
    participantDisconnected(participant, room);
  });
}

function participantDisconnected(participant, room) {
  // Remove the Participant's media container.
  $(`div#${participant.sid}`, $participants).remove();
}
```

</TabItem>

</Tabs>

<Tabs
defaultValue="VideoSDK"
groupId={"VideoSDK"}
values={[{label: 'VideoSDK', value: 'VideoSDK'}]}>

<TabItem value="VideoSDK">

```js
function initializeMeeting() {
  // ...

  // participant joined
  meeting.on("participant-joined", (participant) => {
    let videoElement = createVideoElement(
      participant.id,
      participant.displayName
    );
    let audioElement = createAudioElement(participant.id);

    participant.on("stream-enabled", (stream) => {
      setTrack(stream, audioElement, participant, false);
    });
    videoContainer.appendChild(videoElement);
    videoContainer.appendChild(audioElement);
  });

  // participants left
  meeting.on("participant-left", (participant) => {
    let vElement = document.getElementById(`f-${participant.id}`);
    vElement.remove(vElement);

    let aElement = document.getElementById(`a-${participant.id}`);
    aElement.remove(aElement);
  });

  // ...
}
```

</TabItem>

</Tabs>

#### Mapping Twilio’s events to VideoSDK

Below is a list of all Twilio events used in this demo and VideoSDK’s equivalents.

| Twilio Events           | VideoSDK Events                                                                                                       |
| ----------------------- | --------------------------------------------------------------------------------------------------------------------- |
| participantConnected    | [participant-joined](https://docs.videosdk.live/javascript/api/sdk-reference/meeting-class/events#participant-joined) |
| participantDisconnected | [participant-left](https://docs.videosdk.live/javascript/api/sdk-reference/meeting-class/events#participant-left)     |
| connected               | [meeting-joined](https://docs.videosdk.live/javascript/api/sdk-reference/meeting-class/events#meeting-joined)         |
| disconnected            | [meeting-left](https://docs.videosdk.live/javascript/api/sdk-reference/meeting-class/events#meeting-left)             |
| dominantSpeakerChanged  | [speaker-changed](https://docs.videosdk.live/javascript/api/sdk-reference/meeting-class/events#speaker-changed)       |

## Step 4 : Mute and UnMute Your Local Media

- In Twilio, you can mute or unmute your LocalAudioTracks (microphone) and LocalVideoTracks (camera) by calling the disable or enable method.
- In VideoSDK, you can use the `muteMic` function for the microphone and the `disableWebcam` function for the camera.

<Tabs
defaultValue="Twilio"
groupId={"Twilio"}
values={[{label: 'Twilio', value: 'Twilio'},]}>

<TabItem value="Twilio">

```js
room.localParticipant.audioTracks.forEach((publication) => {
  publication.track.disable(); // Disable Mic in Meeting
  publication.track.enable(); // Enable Mic in Meeting
});

room.localParticipant.videoTracks.forEach((publication) => {
  publication.track.disable(); // Disable Webcam in Meeting
  publication.track.enable(); // Enable Webcam in Meeting
});
```

</TabItem>

</Tabs>

<Tabs
defaultValue="VideoSDK"
groupId={"VideoSDK"}
values={[{label: 'VideoSDK', value: 'VideoSDK'}]}>

<TabItem value="VideoSDK">

```js
meeting.muteMic(); // Disable Mic in Meeting

meeting.unmuteMic(); // Enable Mic in Meeting

meeting.disableWebcam(); // Disable Webcam in Meeting

meeting.enableWebcam(); // Enable Webcam in Meeting
```

</TabItem>

</Tabs>

## Step 5 : Disconnect from a Room

- In Twilio, you have the ability to disconnect from a Room in which you are currently participating. Other Participants will receive a `participantDisconnected` event.
- In VideoSDK, you can also disconnect from a Room you are currently participating in. Other Participants will receive a `participant-left` event, while the local participant will receive a `meeting-left` event.

<Tabs
defaultValue="Twilio"
groupId={"Twilio"}
values={[{label: 'Twilio', value: 'Twilio'},]}>

<TabItem value="Twilio">

```js
room.on("disconnected", (room) => {
  // Detach the local media elements
  room.localParticipant.tracks.forEach((publication) => {
    const attachedElements = publication.track.detach();
    attachedElements.forEach((element) => element.remove());
  });
});

// To disconnect from a Room
room.disconnect();
```

</TabItem>

</Tabs>

<Tabs
defaultValue="VideoSDK"
groupId={"VideoSDK"}
values={[{label: 'VideoSDK', value: 'VideoSDK'}]}>

<TabItem value="VideoSDK">

```js
meeting.on("meeting-left", () => {
  //Meeting Left
});

// To leave the meeting without removing all the participant
// you need to call leave() which is the part of the meeting object.
meeting?.leave();

// To leave the meeting by removing all the participant
// you need to call end() which is the part of the meeting object.
meeting?.end();
```

</TabItem>

</Tabs>

## Conclusion

As you conclude this migration journey, you've successfully adapted your application from Twilio to VideoSDK. The [developed project](https://github.com/videosdk-live/migration-to-X/tree/main/Twilio/js-quickstart) showcases the implementation of VideoSDK in action, emphasizing its simplicity and efficiency.

Key Takeaways:

- Automatic API key generation streamlines the setup process.
- Token generation is simplified, offering flexibility for participants.
- Granular control over participant tokens enhances security.
- Global scalability and minimal latency ensure a seamless user experience.

Feel free to explore the developed project's codebase for a hands-on understanding of VideoSDK integration. As you transition, VideoSDK empowers your application with robust real-time communication features, providing a foundation for future scalability and innovation.

## Contact Us

For any further assistance, questions, or community engagement, we welcome you to join our [Discord channel](https://discord.com/invite/Gpmj6eCq5u). Connect with fellow developers, share insights, and stay updated on the latest developments.

If you require developer support or need personalized assistance, you can schedule a session with our team through our [Developer Support portal](https://bookings.videosdk.live/#/customer/discovery). We are here to ensure a smooth integration and address any queries you may have. Your success with VideoSDK is our priority.


---

---
title: React - Migration Guide From Twilio Video to Video SDK
description: Easily migrate from Twilio to VideoSDK on React. Our guide provides concise steps for seamless integration, enhancing your app's video capabilities effortlessly.
keywords:
  - Guide From Twilio to Video SDK for React
  - guide from twilio to video sdk for react
  - twilio to video sdk tutorial
slug: migration-guide-from-twilio-to-videosdk-web-edition
# authors:
#   - name: Joel Marcey
#     title: Co-creator of Docusaurus 1
#     url: https://github.com/JoelMarcey
#     image_url: https://github.com/JoelMarcey.png
#   - name: Sébastien Lorber
#     title: Docusaurus maintainer
#     url: https://sebastienlorber.com
#     image_url: https://github.com/slorber.png
tags: [Migration Guide, Twilio, React]
hide_table_of_contents: false
---

<!-- truncate -->

## Overview

**Welcome to the Twilio-to-VideoSDK Migration Guide for React!**

This guide is your trusted companion as you navigate the transition from Twilio to VideoSDK for your React apps. We understand that migrating to a new platform can be difficult, so we've designed this comprehensive guide to ensure a smooth and successful journey.

Through step-by-step instructions, we'll equip you with the knowledge and resources you need to effectively transfer your real-time communication capabilities. We'll explore key concepts, explore setup differences, walk you through the installation process, and guide you through the necessary code adjustments.

By the end of this guide, you'll feel confident leveraging VideoSDK's power and flexibility to enhance your React apps and captivate your audience with seamless video and audio experiences.

So, embrace the future of communication, and let's get started!

## Concepts

1.  **Meeting / Room:**
    - This is like a virtual place where people can have real-time conversations using voice, video, and screen sharing.
    - Think of it as a virtual room where participants interact.
    - Each meeting or room has a unique ID (meetingId or roomId).
2.  **Participant:**
    - Both VideoSDK and Twilio Video includes the concepts of **Participant.**
    - There are two types:
      - **Local Participant:** This is you on your device. You control your own audio and video.
      - **Remote Participant:** This is someone else in the meeting. They receive your audio and video and can send their own.
3.  **MediaStream & Track:**
    - **MediaStream:** Think of it as a bundle of audio and video tracks that are shared in real-time between participants.
    - **Track:** This is like a continuous flow of audio or video. For example, your video feed from the camera is a video track, and the audio from the microphone is an audio track.
4.  **Session:**
    - A session is like a specific instance of an ongoing meeting or room.
    - Imagine a meeting happening right now as a session.
    - Each session has its own ID (sessionId).

If you want to learn about this concept in depth you can refer this guide [Concept and Architecture](https://docs.videosdk.live/react/guide/video-and-audio-calling-api-sdk/concept-and-architecture)

## VideoSDK Setup

### API Key

- In Twilio, you manually create an API key using CLI or the dashboard.
- In VideoSDK, the default API key is automatically generated in the VideoSDK dashboard.

### Token

- In Twilio, tokens can be generated via CLI (complex) or the Twilio helper library integrated into the backend.
- In VideoSDK, you can [Generate token from VidoeSDK Dashboard](/javascript/guide/video-and-audio-calling-api-sdk/authentication-and-token#1-generating-token-from-dashboard) itself or [Generate a token in your backend](/javascript/guide/video-and-audio-calling-api-sdk/authentication-and-token#2-generating-token-in-your-backend).

## Installation

You can install the VidoeSDK library using NPM.

```js
npm install "@videosdk.live/react-sdk"
//or
yarn add "@videosdk.live/react-sdk"
```

For rendering participant video install `react-player`

```js
npm install "react-player"
```

You can remove the Twilio SDK from your project by uninstalling the package.

```js
npm uninstall twilio-video
```

Or, if using the Twilio CDN, remove the script tag from `index.html`.

## Room Creation

Before integration, create a room using the [REST API Rooms resource](https://docs.videosdk.live/api-reference/realtime-communication/create-room). Refer to the docs for details.

```jsx
cURL -XPOST <https://api.videosdk.live/v2/rooms> \\
		 -H 'Authorization: $VIDEOSDK_TOKEN' \\
		 -H 'Content-Type: application/json'
```

## Step 1 : Initialization a room

- Replace Twilio's `connect` method with VideoSDK's `MeetingProvider` from `@videosdk.live/react-sdk`.

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Twilio"
groupId={"Twilio"}
values={[{label: 'Twilio', value: 'Twilio'},]}>

<TabItem value="Twilio">

```js
const VideoChat = () => {
  //...

  const handleSubmit = useCallback(
    async (event) => {
      event.preventDefault();
      setConnecting(true);
       const data = await fetch("/video/token", {
         method: "POST",
         body: JSON.stringify({
           identity: username,
           room: roomName,
         }),
         headers: {
           "Content-Type": "application/json",
         },
       }).then((res) => res.json());
       Video.connect(data.token, {
         name: roomName,
       })
        .then((room) => {
          setConnecting(false);
          setRoom(room);
        })
        .catch((err) => {
          console.error(err);
          setConnecting(false);
        });
    },
    [roomName, username]
  );

};
```

</TabItem>

</Tabs>

<Tabs
defaultValue="VideoSDK"
groupId={"VideoSDK"}
values={[{label: 'VideoSDK', value: 'VideoSDK'}]}>

<TabItem value="VideoSDK">

```js
import { MeetingProvider } from "@videosdk.live/react-sdk";

const VideoChat = () => {
  //...

  const token = "YOUR_GENERATED_TOKEN";
  return (
    <MeetingProvider
      config={{
        meetingId: "YOUR_GENERATED_MEETINGID",
        micEnabled: true,
        webcamEnabled: true,
        name: "The Migrator",
      }}
      token={token}
    >
      <MeetingConsumer>
        {() => <Room meetingId={meetingId} onMeetingLeave={onMeetingLeave} />}
      </MeetingConsumer>
    </MeetingProvider>
  );

};
```

</TabItem>

</Tabs>

Let’s explore `MeetingProvider`, `MeetingConsumer`, `useMeeting()`, `useParticipant()` methods for further example.

- `MeetingProvider`: It is Context Provider. It accepts value `config` and `token` as props. The Provider component accepts a value prop to be passed to consuming components that are descendants of this Provider. One Provider can be connected to many consumers. Providers can be nested to override values deeper within the tree.
- `MeetingConsumer`: It is Context Consumer. All consumers that are descendants of a Provider will re-render whenever the Provider’s value prop changes.
- `useMeeting`: It is meeting react hook API for meeting. It includes all the information related to meeting such as join, leave, enable/disable mic or webcam etc.
- `useParticipant`: It is participant hook API. useParticipant hook is responsible to handle all the events and props related to one particular participant such as name, webcamStream, micStream etc.

## Step 2 : Rendering Remote and Local Participants

- In Twilio, the local participant is accessed through `room.localParticipant`, whereas in VideoSDK, the equivalent is retrieved using `meeting.localParticipant`.
- When it comes to retrieving the list of participants, Twilio utilizes room.participants, while VideoSDK employs `meeting.participants`.

<Tabs
defaultValue="Twilio"
groupId={"Twilio"}
values={[{label: 'Twilio', value: 'Twilio'},]}>

<TabItem value="Twilio">

```js
const Room = ({ roomName, token, handleLogout }) => {
  const [room, setRoom] = useState(null);
  const [participants, setParticipants] = useState([]);

  const remoteParticipants = participants.map(participant => (
    <Participant key={participant.sid} participant={participant} />
  ));

  return (
    <div className="room">
      <h2>Room: {roomName}</h2>
      <button onClick={handleLogout}>Log out</button>
      <div className="local-participant">
        {room ? (
          <Participant
               key={room.localParticipant.sid}
               participant={room.localParticipant}
           />
        ) : (
          ''
        )}
      </div>
      <h3>Remote Participants</h3>
      <div className="remote-participants">{remoteParticipants}</div>
    </div>
  );
};
```

</TabItem>

</Tabs>

<Tabs
defaultValue="VideoSDK"
groupId={"VideoSDK"}
values={[{label: 'VideoSDK', value: 'VideoSDK'}]}>

<TabItem value="VideoSDK">

```js
import { useMeeting } from "@videosdk.live/react-sdk";

const Room = ({ meetingId, onMeetingLeave }) => {
  const [joined, setJoined] = useState(null);
  const { join } = useMeeting();
  const { participants, localParticipant } = useMeeting({
    onMeetingJoined: () => {
      setJoined("JOINED");
    },
    onMeetingLeft: () => {
      onMeetingLeave();
    },
  });
  const joinMeeting = () => {
    setJoined("JOINING");
    join();
  };

  const remoteParticipants = Array.from(participants.values())
    .filter((participant) => localParticipant.id !== participant.id)
    .map((participant) => (
      <Participant key={participant.id} participant={participant.id} />
    ));

  return (
    <div>
      <h3>Meeting Id: {meetingId}</h3>
      {joined && joined == "JOINED" ? (
        <div>
          {/* Render Controls */}
          <div className="local-participant">
            <Participant
              key={localParticipant.id}
              participant={localParticipant.id}
            />
          </div>
          <h3>Remote Participants</h3>
          <div className="remote-participants">{remoteParticipants}</div>
        </div>
      ) : joined && joined == "JOINING" ? (
        <p>Joining the meeting...</p>
      ) : (
        <button onClick={joinMeeting}>Join</button>
      )}
    </div>
  );
};
```

</TabItem>

</Tabs>

#### Mapping Twilio’s events to VideoSDK

Below is a list of all Twilio events used in this demo and VideoSDK’s equivalents.

| Twilio Events           | VideoSDK Events                                                                                                    |
| ----------------------- | ------------------------------------------------------------------------------------------------------------------ |
| participantConnected    | [onParticipantJoined()](https://docs.videosdk.live/react/api/sdk-reference/use-meeting/events#onparticipantjoined) |
| participantDisconnected | [onParticipantLeft()](https://docs.videosdk.live/react/api/sdk-reference/use-meeting/events#onparticipantleft)     |
| connected               | [onMeetingJoined()](https://docs.videosdk.live/react/api/sdk-reference/use-meeting/events#onmeetingjoined)         |
| disconnected            | [onMeetingLeft()](https://docs.videosdk.live/react/api/sdk-reference/use-meeting/events#onmeetingleft)             |
| dominantSpeakerChanged  | [onSpeakerChanged()](https://docs.videosdk.live/react/api/sdk-reference/use-meeting/events#onspeakerchanged)       |

## Step 3: Rendering Audio & Video Of Participant

- In Twilio, the rendering of audio and video involves setting tracks in the `useState` through the use of subscribe and unsubscribe methods.
- In VideoSDK, the process differs. We retrieve the `webcamStream` and `micStream` from `useParticipant()`. Subsequently, the `micStream` is passed using a reference in the audio component, while the `webcamStreamUrl` is passed to `ReactPlayer` for video rendering.

<Tabs
defaultValue="Twilio"
groupId={"Twilio"}
values={[{label: 'Twilio', value: 'Twilio'},]}>

<TabItem value="Twilio">

```js
const Participant = ({ participant }) => {
  const [videoTracks, setVideoTracks] = useState([]);
  const [audioTracks, setAudioTracks] = useState([]);

  const videoRef = useRef();

  const trackpubsToTracks = (trackMap) =>
    Array.from(trackMap.values())
      .map((publication) => publication.track)
      .filter((track) => track !== null);

  useEffect(() => {
    setVideoTracks(trackpubsToTracks(participant.videoTracks));
    setAudioTracks(trackpubsToTracks(participant.audioTracks));

    const trackSubscribed = (track) => {
      if (track.kind === "video") {
        setVideoTracks((videoTracks) => [...videoTracks, track]);
      } else if (track.kind === "audio") {
        setAudioTracks((audioTracks) => [...audioTracks, track]);
      }
    };

    const trackUnsubscribed = (track) => {
      if (track.kind === "video") {
        setVideoTracks((videoTracks) => videoTracks.filter((v) => v !== track));
      } else if (track.kind === "audio") {
        setAudioTracks((audioTracks) => audioTracks.filter((a) => a !== track));
      }
    };

    participant.on("trackSubscribed", trackSubscribed);
    participant.on("trackUnsubscribed", trackUnsubscribed);

    return () => {
      setVideoTracks([]);
      setAudioTracks([]);
      participant.removeAllListeners();
    };
  }, [participant]);

  useEffect(() => {
    const videoTrack = videoTracks[0];
    if (videoTrack) {
      videoTrack.attach(videoRef.current);
      return () => {
        videoTrack.detach();
      };
    }
  }, [videoTracks]);

  useEffect(() => {
    const audioTrack = audioTracks[0];
    if (audioTrack) {
      audioTrack.attach(audioRef.current);
      return () => {
        audioTrack.detach();
      };
    }
  }, [audioTracks]);

  return (
    <div className="participant">
      {<h3>{participant.identity}</h3>
      <video ref={videoRef} autoPlay={true} />
      <audio ref={audioRef} autoPlay={true} muted={true} />}
    </div>
  );
};
```

</TabItem>

</Tabs>

<Tabs
defaultValue="VideoSDK"
groupId={"VideoSDK"}
values={[{label: 'VideoSDK', value: 'VideoSDK'}]}>

<TabItem value="VideoSDK">

```js
import ReactPlayer from "react-player";
import { useParticipant } from "@videosdk.live/react-sdk";

const Participant = ({ participant }) => {;
  const audioRef = useRef();

  const { webcamStream, micStream, webcamOn, micOn, isLocal, displayName } =
    useParticipant(participant.participantId);

  const videoStream = useMemo(() => {
    if (webcamOn && webcamStream) {
      const mediaStream = new MediaStream();
      mediaStream.addTrack(webcamStream.track);
      return mediaStream;
    }
  }, [webcamStream, webcamOn]);

  useEffect(() => {
    if (audioRef.current) {
      if (micOn && micStream) {
        const mediaStream = new MediaStream();
        mediaStream.addTrack(micStream.track);

        audioRef.current.srcObject = mediaStream;
        audioRef.current
          .play()
          .catch((error) =>
            console.error("videoElem.current.play() failed", error)
          );
      } else {
        audioRef.current.srcObject = null;
      }
    }
  }, [micStream, micOn]);

  return (
    <div className="participant">
      <audio ref={audioRef} autoPlay muted={isLocal} />
      {webcamOn && (
        <ReactPlayer
          //
          playsinline // extremely crucial prop
          pip={false}
          light={false}
          controls={false}
          muted={true}
          playing={true}
          //
          url={videoStream}
          //
          height={"200px"}
          width={"300px"}
          onError={(err) => {
            console.log(err, "participant video error");
          }}
        />
      )}
    </div>
  );
};
```

</TabItem>

</Tabs>

## Step 4: Implement Meeting Controls

- The implementation of additional controls, such as toggling the microphone and webcam, is achieved through methods provided by `useMeeting()` in VideoSDK.

<!-- <Tabs
defaultValue="Twilio"
groupId={"Twilio"}
values={[{label: 'Twilio', value: 'Twilio'},]}>

<TabItem value="Twilio">

```js

```

</TabItem>

</Tabs> -->

<Tabs
defaultValue="VideoSDK"
groupId={"VideoSDK"}
values={[{label: 'VideoSDK', value: 'VideoSDK'}]}>

<TabItem value="VideoSDK">

```js
function Controls(props) {
  //..
  const { toggleMic, toggleWebcam } = useMeeting();
  return (
    <div>
      <button onClick={() => toggleMic()}>toggleMic</button>
      <button onClick={() => toggleWebcam()}>toggleWebcam</button>
    </div>
  );
}
```

</TabItem>

</Tabs>

## Step 5 : Disconnect from a Room

- To exit a meeting, Twilio uses `room.disconnect()`, while VideoSDK utilizes `meeting.leave()`.

<Tabs
defaultValue="Twilio"
groupId={"Twilio"}
values={[{label: 'Twilio', value: 'Twilio'},]}>

<TabItem value="Twilio">

```js
function Controls(props) {
  //..
  const [room, setRoom] = useState(null);
  const handleLogout = useCallback(() => {
    setRoom((prevRoom) => {
      if (prevRoom) {
        prevRoom.localParticipant.tracks.forEach((trackPub) => {
          trackPub.track.stop();
        });
        prevRoom.disconnect();
      }
      return null;
    });
  }, []);

  return (
      <button onClick={handleLogout}>Log out</button>
  );
}
```

</TabItem>

</Tabs>

<Tabs
defaultValue="VideoSDK"
groupId={"VideoSDK"}
values={[{label: 'VideoSDK', value: 'VideoSDK'}]}>

<TabItem value="VideoSDK">

```js
function Controls(props) {
  //..

  const { leave } = useMeeting();
  return (
    <div>
      <button onClick={() => leave()}>Leave</button>
    </div>
  );
}
```

</TabItem>

</Tabs>

## Conclusion

As you conclude this migration journey, you've successfully adapted your application from Twilio to VideoSDK. The [developed project](https://github.com/videosdk-live/migration-to-X/tree/main/Twilio/react-quickstart) showcases the implementation of VideoSDK in action, emphasizing its simplicity and efficiency.

Key Takeaways:

- Automatic API key generation streamlines the setup process.
- Token generation is simplified, offering flexibility for participants.
- Granular control over participant tokens enhances security.
- Global scalability and minimal latency ensure a seamless user experience.

Feel free to explore the developed project's codebase for a hands-on understanding of VideoSDK integration. As you transition, VideoSDK empowers your application with robust real-time communication features, providing a foundation for future scalability and innovation.

## Contact Us

For any further assistance, questions, or community engagement, we welcome you to join our [Discord channel](https://discord.com/invite/Gpmj6eCq5u). Connect with fellow developers, share insights, and stay updated on the latest developments.

If you require developer support or need personalized assistance, you can schedule a session with our team through our [Developer Support portal](https://bookings.videosdk.live/#/customer/discovery). We are here to ensure a smooth integration and address any queries you may have. Your success with VideoSDK is our priority.


---

---
title: Twilio to Video SDK Migration Guide
description: Explore a smooth transition from VideoSDK to Twilio for enhanced video capabilities. Discover the seamless migration process and unlock a new level of video communication with our comprehensive guide..
keywords:
  - Overview
slug: twilio-to-videosdk-migration-guide
# authors:
#   - name: Joel Marcey
#     title: Co-creator of Docusaurus 1
#     url: https://github.com/JoelMarcey
#     image_url: https://github.com/JoelMarcey.png
#   - name: Sébastien Lorber
#     title: Docusaurus maintainer
#     url: https://sebastienlorber.com
#     image_url: https://github.com/slorber.png
tags: [Migration Guide, Twilio, Overview]
hide_table_of_contents: false
---

<!-- truncate -->

## **Greetings, Twilio Developers!**

We're thrilled to welcome you on your journey from Twilio Video to VideoSDK! As you begin your migration, prepare to embrace a world of exciting possibilities.

VideoSDK offers a global infrastructure for seamless video and audio communication around the world, while its unwavering commitment to classic call quality provides reliability, scalability, and robust security. Bring your projects to life with a variety of features including audio, video, screen sharing, chat, and participatory moderation.

The Video SDK integrates seamlessly into your existing workflow with the ease of [REST API](https://docs.videosdk.live/api-reference/realtime-communication/intro) and [Webhooks](https://docs.videosdk.live/api-reference/realtime-communication/user-webhooks), ensuring a smooth transition while maintaining flexibility and extensibility.

Please explore the resources in this guide and feel free to contact our support team with any questions or concerns.

### **Migration Guide**

We are committed to making this migration process as easy and efficient as possible. This step-by-step guide will serve as your roadmap, providing comprehensive instructions and valuable insights to ensure a successful transition.

import SupportSDKList from '../src/theme/SupportedSDKListContainer'

<SupportSDKList  />

### **Feature Map Comparison**

VideoSDK not only matches but surpasses Twilio Video with additional features. This migration is not just a transfer; It's an upgrade to a world of enhanced possibilities. Elevate your applications effortlessly!

:::info
Select the appropriate icon ✅ to access the documentation, denoted by an (a), applicable across all platforms.
:::

import SupportFeatureList from '../src/theme/SupportedFeatureListContainer'

<SupportFeatureList  />

We are excited to welcome you to the VideoSDK community and look forward to empowering your projects with the future of video communication.

import Footer from '../src/theme/TutorialsFooterContainer'

<Footer/>


---

---
title: How to enable post transcription and summary in VideoSDK
description: Explore how to enable transcription and summary post recordings using the transcription API to enhance accessibility and usability of recordings.
keywords:
  - Videosdk Transcription
  - Videosdk Summary
slug: transcription-and-summary
hide_table_of_contents: false
---
<!-- truncate -->

## Overview

Transcription API empowers developers to convert spoken language into written text automatically. In this tutorial, we'll delve into how to effectively utilize a Transcription API to transcribe meeting recordings. We'll explore two distinct methods for initiating transcription: enabling transcription via the start recording API and enabling transcription via auto-configuration while creating a meetingId using API.

This feature is currently in BETA.

## Prerequisites

Before diving into the Transcription API, ensure you have:

- Basic knowledge of REST APIs.
- Understanding of JSON formatting.
- An [Auth Token](https://docs.videosdk.live/react/guide/video-and-audio-calling-api-sdk/authentication-and-token) for the Transcription API.

## Step 1: Understand the workflow

Before enabling transcription and summary features in VideoSDK, it's important to understand the basic workflow. Transcription and summarization occur after recording, meaning that recording is a necessary step before these features can be used. To activate the transcription and summary APIs, you must first start recording using either the Start Recording API or by auto config recording within the Create MeetingId API.
To use transcription, recordings needs to be stored in VideoSDK Cloud

![transcription_workflow.png](https://cdn.videosdk.live/website-resources/docs-resources/transcription_workflow.png)

## Step 2: Choosing Your Method

There are two primary methods for initiating transcription

- via the [start recording API](https://docs.videosdk.live/api-reference/realtime-communication/start-recording#config)
- via auto configuration while [creating a meeting API](https://docs.videosdk.live/api-reference/realtime-communication/create-room#autoStartConfig)

Choose the method that best fits your use case.

#### Option 1: Enabling Transcription via Recording API

In this method, transcription is enabled by including a transcription object with the property enabled set to true in the start recording API request. Below is an example implementation in Node.js:

Request

```js
import fetch from "node-fetch";
const options = {
  method: "POST",
  headers: {
    Authorization: "YOUR_TOKEN",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    roomId: "room-id",
    transcription: {
      enabled: true,
      summary: {
        enabled: true,
      },
    },
  }),
};
const url = `https://api.videosdk.live/v2/recordings/start`;
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
```

Response

```js
"Recording started successfully";
```

Replace **`room-id`** with the ID of your meeting or room and **`YOUR_TOKEN` with your auth token**.

Additionally, you can enable summary feature by setting the **`enabled`** property to **`true`** within the summary object.

#### Option 2: Enabling Transcription via Auto Configuration while creating meeting using API

If you prefer transcription to be enabled by default when creating a meeting, you can configure this during the meeting creation process. Here's an example implementation in Node.js:

Request

```js
import fetch from 'node-fetch';
const options = {
	method: "POST",
	headers: {
		"Authorization": "$YOUR_TOKEN",
		"Content-Type": "application/json",
	},
	body: JSON.stringify({
				"autoStartConfig" : {
					"recording":
						"transcription": {
							"enabled": true
              "summary": {
                "enabled": true
						  },
					}
				}
			}),
};
const url= `https://api.videosdk.live/v2/rooms`;
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
```

Response

```js
{
  "roomId": "abc-xyzw-lmno",
  "disabled": false,
  "createdAt": "2024-02-27T04:49:11.024Z",
  "updatedAt": "2024-02-27T04:49:11.024Z",
  "id": "623d49c760a18e699abcc8a4",
  "links": {
    "get_room": "https://api.videosdk.live/v2/rooms/abc-xyzw-lmno",
    "get_session": "https://api.videosdk.live/v2/sessions/"
  }
```

Replace **`"YOUR_TOKEN"`** with your authentication token and set the summary object's **`enabled`** property to **`true`** if you wish to utilize the summary feature.

In this method, recording will automatically start with transcription enabled when initiating a session with a specified Meeting ID or Room ID.

## Step 3: Conducting a Meeting

You can initiate a meeting using any of our SDKs (Prebuilt, React, React Native, JS, Flutter, Android, iOS).

- Option 1: If you opt to enable transcription via the recording API, pass the transcription object as described in Step 2. The recording will commence with the transcription feature enabled.
- Option 2: If you prefer enabling the transcription feature during meeting creation using the API, the recording will automatically begin with transcription enabled when initiating your meeting.

## Step 4: Retrieving Transcription and Summary

After the recording concludes and transcription was enabled for that recording or meeting, you can retrieve the transcription and summary using the API.

To retrieve the transcription of a meeting, make a GET request to the Transcription API endpoint with the meeting ID. Below is an example using Node.js:

Request

```js
import fetch from "node-fetch";
const options = {
  method: "GET",
  headers: {
    Authorization: "$YOUR_TOKEN",
    "Content-Type": "application/json",
  },
};
const roomId = "room-id";
const url = `https://api.videosdk.live/ai/v1/post-transcriptions?roomId=${roomId}`;
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
```

Response

```js
{
    "pageInfo": {
        "currentPage": 1,
        "perPage": 20,
        "lastPage": 1,
        "total": 1
    },
    "transcriptions": [
        {
            "id": "transcription-id",
            "status": "completed",
						"roomId": "room-id",
						"sessionId": "session-id",
            "recordingId": "recording-id",
            "filePath": "https://cdn.videosdk.live/encoded/videos/dummy.mp4",
            "transcriptionFilePaths": {
                "json": "https://cdn.videosdk.live/transcriptions/dummy/dummy.json",
                "srt": "https://cdn.videosdk.live/transcriptions/dummy/dummy.srt",
                "txt": "https://cdn.videosdk.live/transcriptions/dummy/dummy.txt",
                "tsv": "https://cdn.videosdk.live/transcriptions/dummy/dummy.tsv",
                "vtt": "https://cdn.videosdk.live/transcriptions/dummy/dummy.vtt"
            },
            "summarizedFilePaths": {
                "txt": "https://cdn.videosdk.live/transcriptions/dummy/dummy-summary.txt"
            },
            "userStorage": null,
            "start": "2024-02-27T16:00:36.828Z",
            "end": "2024-02-27T16:01:46.939Z"
        }
    ]
}
```

Replace **`'YOUR_AUTH_TOKEN'`** with your authentication token and **`'room-id'`** with the ID of your meeting or room.

Here, you will receive `transcriptionFilePaths` object containing paths of the transcribed files with various formats such as json, srt, txt, tsv, vtt.

Additionally, if you have enabled summary feature, you will receive a `summarizedFilePaths` object containing path of the summarized text file.

## Conclusion

In this tutorial, you've learned how to enable transcription for meetings using the Transcription API. By following the steps outlined above, you can easily integrate transcription capabilities into your applications and retrieve transcribed text and summaries for your meetings. Transcription can greatly enhance the accessibility and usability of your meeting recordings, making them more searchable and comprehensible. Experiment with these methods and explore further possibilities to unlock the full potential of transcription in your applications and enhance the efficiency and productivity of your meetings.


---

---
title: Unlock Insights with VideoSDK's Session Analytics Dashboard
description: Unlock valuable insights and optimize your sessions with our comprehensive session analysis tutorial. Explore participant insights, understand call health, and analyze session statistics for enhanced performance indicators.
keywords:
  - videosdk session analytics
slug: videosdk-session-analytics-dashboard
tags: [Session Analytics]
hide_table_of_contents: false
---

<!-- truncate -->

## Unleash Insights with VideoSDK's Session Analytics

Welcome to the world of actionable insights and empowered decision-making. VideoSDK's session analytics dashboard is your gateway to understanding, optimizing, and elevating every aspect of your sessions.

## Accessing Analytics Made Easy

Navigating through session data is a breeze with VideoSDK. Simply head to your session page at https://app.videosdk.live/meetings/sessions, where a treasure trove of session information awaits.

### How to Access Analytics? 

Open Session Analytics effortlessly by following these steps:

1. **Click on Meeting-ID:**
    - Directly access analytics by clicking on the meeting-ID within the session table.
2. **Hover and Click View Analytics:**
    - Hover over a specific meeting row to reveal the **View Analytics** button in the Actions Column.
    - Click on **View Analytics** to open the Session Overview sidebar, unlocking a wealth of insights.

![Access Analytics](https://cdn.videosdk.live/website-resources/docs-resources/access_analytics.png)

---

There are three tabs available within the session analytics view:

## **1. Session Overview**

This tab provides an overview of the session, including its duration and participant details. You can explore individual participant statistics to understand their session performance better.

## **2. Errors**

In this tab, you can find information about any errors encountered during the session. It helps you identify and address issues like network problems or technical glitches promptly.

## **3. Session Stats**

Explore data and metrics sent and received by participants to measure performance of the session in this tab. It offers insights into data exchange among participants, including metrics on jitter, RTT, and packet loss, resolutions, and fps aiding in assessing communication efficiency.

Let's dive deeper into each of these tabs to gain a better understanding of session analytics.

# Session Overview

The session overview page is your compass in the sea of data. Here's what you'll uncover:

- **Meeting ID:** Unique identifier for the meeting in the format of `abcd-efgh-ijkl`.
- **Session ID:** Unique identifier for each session, uniquely identified by its `sessionId`.
- **Session Status:** Indicates if the session is ongoing or ended.
- **Session Initiating Time:** Time taken by the first participant to establish the connection.
- **Start and End Time:** Marks the start and end of the session.
- **Total Unique Participants Joined:** Total number of unique participants in the session.
- **Total Session Duration:** Overall duration of the session from start to end.
- **Total Participant Minutes:** A sum of all participant duration.
- **Recording, HLS, RTMP:** Additional services used in the session.

### Participant Table List

- **Participant ID:** Unique identifier for each participant.
- **Participant Name:** Personalized identification for each participant.
- **Join Time:** Time taken by the participant to establish connection.
- **Duration:** Total time spent by this participant in the session.

### Efficient Session Management with Actions

Enhance your session management with streamlined actions:

- **Kick Out Participants:** Effortlessly remove/kickout participants from ongoing sessions.
- **Detailed Participant Analytics:**
- Hover over a specific participant row to reveal the `View Stats` button at the end of the row.
- Click on `View Stats` to open the Participant Overview sidebar.
    
![View Stats](https://cdn.videosdk.live/website-resources/docs-resources/view_stats.png)

## Explore Participant Insights

Discover valuable participant data that provides a clear view of engagement and experience:

- **Participant ID:** Unique identifier for each participant.
- **Participant Name:** Personalized identification for better interaction.
- **Joined At:** Indicates the precise moment when participant connects to the session.
- **Left At:** Indicates the precise moment when participant left the session.
- **Total Duration:** Total duration of participant within that session.
- **Joining Time:** Time taken by the this participant to establish the connection.
- **Location:** Approx. geographic location from where the participant joined.
- **Platform:** Specifies whether participants are using a desktop or mobile device.
- **Device Info:** Offers details regarding the participant's device.
- **OS:** Provides information about the participant's OS.
- **Browser:** Provides specifics about the participant's browser
- **SDK Version:** Indicates the version of the SDK used by participants.

### Understanding Participant Call Health

We've developed call health to offer a rapid assessment of participant performance during calls. This feature highlights the performance of audio, video, and screen sharing audio-video separately. We've utilized color theory, with green indicating good performance, orange for moderate, and red for poor performance, to enhance clarity. For detailed insights, simply hover over the bars

![Participant Call Health](https://cdn.videosdk.live/website-resources/docs-resources/participant_call_health.png)

## Participant Session Stats

Dive into Participant Session Stats for valuable insights into your session experience! With just a click on `View Session Stats` at the bottom of the page, unlock a treasure trove of data crucial for understanding audio and video experiences.

Within this section, you can observe quality metrics for the selected participant, comparing them to others. Additionally, the `Sessions Stats` covers quality stats comparison for every participant. Keep reading to explore more about Session Stats.

**Visualizing Session Performance from Both Sides**

This section provides a two-sided view of your session's metrics.

- **Left Side: Sender Participant Graph** This section displays graphs representing the metrics sent by the sender participant. Here, you can see how the various factors impacted the data you transmitted.
- **Right Side: Receiver Participant Graph** On the right side, you'll find a dropdown menu where you can select a specific participant. Choosing a receiver will display graphs showcasing the metrics **received by that participant**. This allows you to compare the sending experience (left side) with the receiving experience (right side) for different participants.

![VideoSDK Jitter Graph](https://cdn.videosdk.live/website-resources/docs-resources/video_jitter_graph.png)

**See How Your Session Performed**

These metrics give you a clear picture of your session's quality. Understanding them helps you spot any issues and keep things running smoothly. Let's dive into what each metric means!

**Jitter:** Imagine your internet connection like a bumpy road. Jitter is how much those bumps cause your signal to bounce around. Less jitter means a smoother ride for your data (audio and video, threshold ≤ 30ms).

**RTT (Latency):** This is how long it takes for data to travel between you and the server you're connected to. Think of it like the time it takes for a message to get delivered – a lower RTT means a faster delivery (affects both audio and video, threshold ≤ 300ms).

**Bitrate:** This measures the amount of data flowing through your connection per second. Imagine it like the width of a water pipe – a higher bitrate allows for more data to flow, which can be good for high-quality audio/video or fast downloads.

**Packet Loss:** Think of data traveling in tiny packets. Packet loss is when some of those packets get dropped along the way. More packet loss means information might be missing, affecting things like audio/video quality or lag in games (threshold ≤ 5%).

**Resolution:** This refers to the sharpness and detail of an image or video. Think of it like the number of pixels on your screen – a higher resolution means a crisper picture (**Video Only**).

**FPS (Frames Per Second):** This measures how many images (frames) are displayed on your screen every second. Imagine it like a flipbook – a higher FPS creates a smoother and more fluid animation or video experience (**Video Only**).

![VideoSDK FPS Graph](https://cdn.videosdk.live/website-resources/docs-resources/video_fps_graph.png)

![VideoSDK Resolution Graph](https://cdn.videosdk.live/website-resources/docs-resources/video_resolution_graph.png)

---

# **Investigate Session Errors**

Get to the root of smoother sessions by addressing errors directly. Use the Errors tab to explore details of errors encountered during your session. Note: Session errors are visible with JS SDK v0.0.82 or higher, React SDK v0.1.85 or higher, and React Native v0.1.6 or newer versions.

- **Participant Name & ID:** Quickly identify the participant associated with each error for swift resolution.
- **Error Types:** Understand the different types of errors encountered, such as network issues or connection disruptions.
- **Detailed Descriptions:** Access clear explanations of errors to take actionable steps towards solution.

![VideoSDK Error Details](https://cdn.videosdk.live/website-resources/docs-resources/error_new.png)

# **Analyse Session Stats**

Similar to `Participant Session Stats`, this tab covers quality statistics sent by individual participants. You can select any participant to compare effectively with others.

Choose a sender participant from the dropdown menu on the left and select a recipient on the right to compare data over different time frames. This allows you to identify and explore issues within specific durations.

This tab covers the same metrics as covered in the `participant session stats`: Jitter, RTT (Latency), Bitrate, Packet-loss, Resolution (Video only), and FPS (Video only).

![VideoSDK Session Stats](https://cdn.videosdk.live/website-resources/docs-resources/session_stats.png)


## Conclusion

This tutorial offers a comprehensive overview of Session Analytics, empowering you to maximize its potential. Dive deep into call performance, audio-video quality, participant insights, common errors, and their resolutions through detailed analytics. Your feedback is invaluable in shaping our products to suit your needs better, so please take a moment to leave your thoughts at the bottom of the session overview tab.

Stay tuned for exciting updates in Session Analytics, including a Session Timeline view, enhanced error coverage spanning SDK and infrastructure, and much more. We're committed to continuously improving your experience and providing valuable insights for your sessions.

---

---
title: Understanding Usage Quota Limits on VideoSDK Plans
description: Explore VideoSDK quota limits and subscription plans. Learn how to optimize usage and choose the right plan for your video development needs.
keywords:
  - videosdk plans, videosdk quota, videosdk limit
slug: quota-limit-and-plan
tags: [Videosdk Plans, Videosdk Quota, Videosdk Limit]
hide_table_of_contents: false
---

<!-- truncate -->

In this documentation, you will find detailed information about the quotas associated with each plan, including usage limits for various features and functionalities. Understanding these quotas will help you optimize your usage, selecting the best pricing plan and make the most of your VideoSDK experience.

## How VideoSDK limits concurrent usage quota

VideoSDK's approach to limiting usage focuses on concurrent usage rather than overall usage. Concurrent usage refers to the number of participants or requests that can be hosted or processed simultaneously. 

For example, if there's a limit of 50 concurrent participants per organization, users can run multiple calls (sessions) simultaneously, with a maximum of 50 participants across all sessions combined.

## How to view my current plan’s quota limits?

To view the current quota limits on your organization, simply navigate to the [VideoSDK Dashboard](https://app.videosdk.live/), go to your Profile section, and click on the Billing tab.

## Free Plan

Since, we’ve designed Free Plan for developers who are just exploring, we’ve kept the limits that would get you started without a hitch.

Organisations on Free Plan have the following limits on concurrent usage:

| Feature | Concurrent Limit |
| --- | --- |
| Participants in Video Calls | 50 concurrent participants |
| Viewers in Live Streams | 100 concurrent viewers |
| Recording Request | 1 concurrent request at a time |
| HLS Encoding Request | 1 concurrent request at a time |
| RTMP-Out Request | 1 concurrent request at a time |

 
### How to increase my limits?

To increase your limits, simply upgrade your plan by providing billing details and credit card information.

## Pay-as-you-Go Plan

We've increased participant limits for this paid plan. This way, it won't significantly impact users heavily involved in production or integration.

Organisations on Pay-as-you-Go have the following limits on concurrent usage:

| Feature | Concurrent Limit |
| --- | --- |
| Participants in Video Calls | 100 concurrent participants |
| Viewers in Live Streams | 500 concurrent viewers |
| Recording Request | 5 concurrent request at a time |
| HLS Encoding Request | 5 concurrent request at a time |
| RTMP-Out Request | 5 concurrent request at a time |

### How to increase my limits?

To increase your limits further more, simply get in touch with us. [Contact us](https://www.videosdk.live/contact) directly or reach out via email at [support@videosdk.live](mailto:support@videosdk.live), and we'll handle the rest gladly.

## Enterprise Plan

For Enterprise users, all limits are tailored to the specific needs. Customised limits ensure optimal performance for your unique requirements.

To get started as an Enterprise user, simply get in touch with us, explain your requirements and use case, and we’ll customise the quota and limits according to your needs.

## Examples to understand concurrent limits

**Example #1**

Let's say you're using video callings (RTC) in your organization on the Free Plan. In this scenario, you can concurrently host up to 50 participants. However, the number of calls (sessions) you initiate is unrestricted.

To simplify, you can run multiple sessions simultaneously, but concurrently, you can only accommodate a maximum of 50 participants across all sessions. If a 51st participant attempts to join, they won't be able to access the session until you upgrade your plan to increase your participant limits.

**Example #2**

Let’s say you're using live streaming in your organization on the Free Plan. In this setup, you can concurrently host up to 100 viewers joining the sessions. While you have the flexibility to host multiple live streaming sessions, the number of viewers joining session concurrently is restricted.

**Example #3**

Lets say you’re using video callings (RTC) in your organization on the Pay-as-you-Go Plan and you're hosting 5 concurrent calls (sessions), all of which are being recorded. Now, when you initiate the 6th call (session) and request recording, VideoSDK will not process your recording request. Instead, it will throw an error because you've reached your recording request limit.

If you have any questions regarding quota limits and pricing plan, post in our [Discord community](https://discord.com/invite/Qfm8j4YAUJ), [contact us](https://www.videosdk.live/contact) directly, or reach out to us on [support@videosdk.live](mailto:support@videosdk.live).

---

---
title: Custom Tracks
hide_title: true
hide_table_of_contents: false
description: Custom Video Track features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Custom Tracks
pagination_label: Custom Tracks
keywords:
  - Camera on
  - Camera off
  - Webcam on
  - Webcam off
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
---

## Custom Video Track - Flutter

- You can create a Video Track using `createCameraVideoTrack()` method of `VideoSDK` class.
- This method can be used to create video track using different encoding parameters, camera facing mode, and optimization mode.

### Parameters

- **cameraId**:

  - type: `String`
  - required: `false`
  - It will be the id of the camera from which the video should be captured.

- **encoderConfig**:

  - type: `CustomTrackVideoConfig`
  - required: `false`
  - default: `h360p_w640p`
  - You can chose from the below mentioned list of values for the encoder config.

| Encoder Config | Resolution | Frame Rate |   Bitrate    |
| -------------- | :--------: | :--------: | :----------: |
| h90p_w160p     |   160x90   |   15 fps   |  60000 kbps  |
| h180p_w320p    |  320x180   |   15 fps   | 120000 kbps  |
| h216p_w384p    |  384x216   |   15 fps   | 180000 kbps  |
| h360p_w640p    |  640x360   |   20 fps   | 300000 kbps  |
| h540p_w960p    |  960x540   |   25 fps   | 600000 kbps  |
| h720p_w1280p   |  1280x720  |   30 fps   | 2000000 kbps |
| h1080p_w1920p  | 1920x1080  |   30 fps   | 3000000 kbps |
| h1440p_w2560p  | 2560x1440  |   30 fps   | 5000000 kbps |
| h2160p_w3840p  | 3840x2160  |   30 fps   | 8000000 kbps |
| h120p_w160p    |  160x120   |   15 fps   |  80000 kbps  |
| h180p_w240p    |  240x180   |   15 fps   | 100000 kbps  |
| h240p_w320p    |  320x240   |   15 fps   | 150000 kbps  |
| h360p_w480p    |  480x360   |   20 fps   | 225000 kbps  |
| h480p_w640p    |  640x480   |   25 fps   | 300000 kbps  |
| h540p_w720p    |  720x540   |   30 fps   | 450000 kbps  |
| h720p_w960p    |  960x720   |   30 fps   | 1500000 kbps |
| h1080p_w1440p  | 1440x1080  |   30 fps   | 2500000 kbps |
| h1440p_w1920p  | 1920x1440  |   30 fps   | 3500000 kbps |

:::note

Above mentioned encoder configurations are valid for both, landscape as well as portrait mode.

:::

- **facingMode**:

  - type: `FacingMode`
  - required: `false`
  - Allowed values : `FacingMode.front` | `FacingMode.environment`
  - It will specify whether to use front or back camera for the video track.

- **multiStream**

  - type: `boolean`
  - required: `false`
  - default: `true`
  - It will specify if the stream should send multiple resolution layers or single resolution layer.

:::caution
MultiStream functionality is not supported in the Firefox browser. VideoSDK will only send one stream for Firefox browsers.
:::

:::info

- To learn more about optimizations and best practices for using custom video tracks, [follow this guide](/flutter/guide/video-and-audio-calling-api-sdk/render-media/optimize-video-track).
- This parameter is only available from `v1.0.9`.

:::

#### Returns

- `Future<CustomTrack?>`

### Example

```javascript
CustomTrack? videoTrack = await VideoSDK.createCameraVideoTrack(
      encoderConfig: CustomVideoTrackConfig.h1440p_w1920p,
      multiStream: false,
      facingMode:"user",
    );
```

## Custom Audio Track - Flutter

- You can create a Audio Track using `createMicrophoneAudioTrack()` method of `VideoSDK` class.
- This method can be used to create audio track using different encoding parameters and noise cancellation configuration.

### Parameters

- **microphoneId**:

  - type: `String`
  - required: `false`
  - It will be the id of the mic from which the audio should be captured.

- **encoderConfig**:

  - type: `CustomTrackAudioConfig`
  - required: `false`
  - default: `speech_standard`
  - You can chose from the below mentioned list of values for the encoder config.

| Encoder Config      | Bitrate  | Auto Gain | Echo Cancellation | Noise Suppression |
| ------------------- | :------: | :-------: | :---------------: | :---------------: |
| speech_low_quality  | 16 kbps  |   TRUE    |       TRUE        |       TRUE        |
| speech_standard     | 24 kbps  |   TRUE    |       TRUE        |       TRUE        |
| music_standard      | 32 kbps  |   FALSE   |       FALSE       |       FALSE       |
| standard_stereo     | 64 kbps  |   FALSE   |       FALSE       |       FALSE       |
| high_quality        | 128 kbps |   FALSE   |       FALSE       |       FALSE       |
| high_quality_stereo | 192 kbps |   FALSE   |       FALSE       |       FALSE       |

- **noiseConfig**

  - **echoCancellation**

    - type: `boolean`
    - required: `false`
    - If `true` echo cancellation will turned on else it would be turned off.

  - **autoGainControl**

    - type: `boolean`
    - required: `false`
    - If `true` auto gain will turned on else it would be turned off.

  - **noiseSuppression**
    - type: `boolean`
    - required: `false`
    - If `true` noise suppression will turned on else it would be turned off.

#### Returns

- `Future<CustomTrack?>`

### Example

```javascript
CustomTrack? audioTrack = await VideoSDK.createMicrophoneAudioTrack(
        encoderConfig: CustomAudioTrackConfig.high_quality);
```


---

---
sidebar_position: 2
sidebar_label: Meeting Error Codes
pagination_label: Meeting Error Codes
title: Meeting Error Codes
---

# Meeting Error Codes - Flutter

If you encounter any of the errors listed below, refer to the [Developer Experience Guide](../../guide/best-practices/developer-experience.md#listen-for-error-events), which offers recommended solutions based on common error categories.

import ServerErrorCodes from '../../../mdx/\_server-error-codes.mdx'
import SDKErrorCodes from '../../data/\_sdk-error-codes.mdx'

<ServerErrorCodes />

<SDKErrorCodes/>

---

---
title: Participant Class Events
sidebar_position: 1
sidebar_label: Events
pagination_label: Participant Class Events
---

# Participant Class Events - Flutter

<div class="sdk-api-ref-only-h4">

---

### streamEnabled

- This event will be emitted when any [participant](introduction) starts consuming or producing stream of any type.

#### Example

```javascript
room.localParticipant.on(Events.streamEnabled, (Stream stream){
  // do something
});
```

---

### streamDisabled

- This event will be emitted when any [participant](introduction) stops consuming or producing stream of any type.

#### Example

```javascript
room.localParticipant.on(Events.streamDisabled, (Stream stream){
  // do something
});
```

---

### streamPaused

- This event will be emitted when any [participant](introduction) pauses consuming or producing stream of any type.

#### Example

```javascript
room.localParticipant.on(Events.streamPaused, (Stream stream){
  // do something
});
```

---

### streamResumed

- This event will be emitted when any [participant](introduction) resumes consuming or producing stream of any type.

#### Example

```javascript
room.localParticipant.on(Events.streamResumed, (Stream stream){
  // do something
});
```

---

### videoQualityChanged

- `videoQualityChanged` is a callback which gets triggered whenever a participant's video quality changes.

- `currentQuality` and `prevQuality` can have values `HIGH` | `MEDIUM` | `LOW`.

#### Example

```js
participant.on(Events.videoQualityChanged, (data) {
  String currentQuality = data["currentQuality"];
  String prevQuality = data["prevQuality"];
});
```

---

</div>


---

---
title: Video SDK Participant Class
sidebar_position: 1
sidebar_label: Introduction
pagination_label: Video SDK Participant Class
---

# Video SDK Participant Class - Flutter

<div id="tailwind" class="sdk-api-ref">

## Introduction

`Participant` class includes all the properties, methods and events related to the participants joined in a particular room.

## Participant Properties

<div class="row">
<div class="col col--4 margin-bottom--sm" >

- [id](properties#id)

</div>
<div class="col col--4 margin-bottom--sm" >

- [displayName](properties#displayname)

</div>
<div class="col col--4 margin-bottom--sm" >

- [isLocal](properties#islocal)

</div>
<div class="col col--4 margin-bottom--sm" >

- [pinState](properties#pinstate)

</div>

<div class="col col--4 margin-bottom--sm" >

- [mode](properties#mode)

</div>
<div class="col col--4 margin-bottom--sm" >

- [streams](properties#streams)

</div>
<div class="col col--4 margin-bottom--sm" >

- [metaData](properties#metadata)

</div>
</div>

## Participant Methods

<div class="row">
<div class="col col--4 margin-bottom--sm" >

- [enableCam](methods#enablecam)

</div>
<div class="col col--4 margin-bottom--sm" >

- [disableCam](methods#disablecam)

</div>
<div class="col col--4 margin-bottom--sm" >

- [unmuteMic](methods#unmutemic)

</div>
<div class="col col--4 margin-bottom--sm" >

- [muteMic](methods#mutemic)

</div>
<div class="col col--4 margin-bottom--sm" >

- [setQuality](methods#setquality)

</div>
<div class="col col--4 margin-bottom--sm" >

- [pin](methods#pin)

</div>
<div class="col col--4 margin-bottom--sm" >

- [unpin](methods#unpin)

</div>
<div class="col col--4 margin-bottom--sm" >

- [setViewPort](methods#setviewport)

</div>
<div class="col col--4 margin-bottom--sm" >

- [remove](methods#remove)

</div>
<div class="col col--4 margin-bottom--sm" >

- [on](methods#on)

</div>
<div class="col col--4 margin-bottom--sm" >

- [getVideoStats](methods#getvideostats)

</div>
<div class="col col--4 margin-bottom--sm" >

- [getAudioStats](methods#getaudiostats)

</div>
<div class="col col--4 margin-bottom--sm" >

- [getShareStats](methods#getsharestats)

</div>
</div>

## Participant Events

<div class="row">
<div class="col col--4 margin-bottom--sm" >

- [streamEnabled](events#streamenabled)

</div>
<div class="col col--4 margin-bottom--sm" >

- [streamDisabled](events#streamdisabled)

</div>
<div class="col col--4 margin-bottom--sm" >

- [streamPaused](events#streampaused)

</div>
<div class="col col--4 margin-bottom--sm" >

- [streamResumed](events#streamresumed)

</div>
</div>
</div>


---

---
title: Participant Class Methods
sidebar_position: 1
sidebar_label: Methods
pagination_label: Participant Class Methods
---

# Participant Class Methods - Flutter

<div class="sdk-api-ref-only-h4">

### enableCam()

- `enableCam()` is used to enable participant's camera.

#### Events associated with `enableCam()`:

- First the participant will get a callback on [cameraRequested](../room-class/events#camerarequested) and once the participant accepts the request, camera device will be enabled.
- Every Participant will receive a `streamEnabled` event with `stream` object.

#### Returns

- _`void`_

#### Example

```js
participant.enableCam();
```

---

### disableCam()

- `disableCam()` is used to disable participant camera.

#### Events associated with `disableCam()`:

- Every Participant will receive a `streamDisabled` event with `stream` object.

#### Returns

- _`void`_

#### Example

```js
participant.disableCam();
```

---

### unmuteMic()

- `unmuteMic()` is used to enable participant microphone.

#### Events associated with `unmuteMic()`:

- First the participant will get a callback on [micRequested](../room-class/events#micrequested) and once the participant accepts the request, mic will be enabled.
- Every Participant will receive a `streamEnabled` event with `stream` object.

#### Returns

- _`void`_

#### Example

```js
participant.unmuteMic();
```

---

### muteMic()

- `muteMic()` is used to disable participant microphone.

#### Events associated with `muteMic()`:

- Every Participant will receive a `streamDisabled` event with `stream` object.

#### Returns

- _`void`_

#### Example

```js
participant.muteMic();
```

---

### setQuality()

- It is used to set the quality of the participant's video stream.

#### Parameters

- **quality**: `"low"`|| `"med"` | `"high"`

#### Returns

- _`void`_

#### Example

```js
participant.setQuality("high");
```

---

### pin()

- It is used to set pin state of the participant. You can use it to pin the screen share, camera or both of the participant. It accepts a optional parameter of type `PinType`. Default PinType is `SHARE_AND_CAM`

#### Parameters

- **pinType**: `PinType.SHARE_AND_CAM` | `PinType.CAM` | `PinType.SHARE`

#### Returns

- _`void`_

#### Example

```js
participant.pin(PinType.CAM);
```

---

### unpin()

- It is used to unpin participant. You can use it to unpin the screen share, camera or both of the participant. It accepts a optional parameter of type `PinType`. Default PinType is `SHARE_AND_CAM`

#### Parameters

- **pinType**: `PinType.SHARE_AND_CAM` | `PinType.CAM` | `PinType.SHARE`

#### Returns

- _`void`_

#### Example

```js
participant.unpin(PinType.CAM);
```

---

### setViewPort()

- `setViewPort()` is used to set the quality of the participant's video stream based on the viewport height and width.

#### Parameters

- **width**: int
- **height**: int

#### Returns

- `void`

#### Example

```js
participant.setViewPort(480, 360);
```

---

### remove()

- It is used to remove participant from the room.

#### Returns

- _`void`_

#### Example

```js
participant.remove();
```

---

### on()

- It is used to listen [`Participant`](introduction) related events.

#### Parameters

- event

  - type: [`Events`](events)
  - This will specify the event to be listened.

- eventHandler
  - type: [`Function`](https://api.dart.dev/stable/2.15.1/dart-core/Function-class.html)
  - This will be invoked whenever, specified event occurred.

#### Returns

- _`void`_

#### Example

```js
participant.on(Events.streamEnabled, (Stream stream){
    // do something
});
```

### getVideoStats()

- `getVideoStats()` will return an `List<dynamic>?` which will contain details regarding the participant's critical video metrics such as **Jitter**, **Packet Loss** etc.

#### Returns

- `object`
  - `jitter` : It represents the distortion in the stream.
  - `bitrate` : It represents the bitrate of the stream which is being transmitted.
  - `totalPackets` : It represents the total packet count which were transmitted for that particiular stream.
  - `packetsLost` : It represents the total packets lost during the transimission of the stream.
  - `rtt` : It represents the time between the stream being reached to client from the server in milliseconds(ms).
  - `codec`: It represents the codec used for the stream.
  - `network`: It represents the network used to transmit the stream
  - `size`: It is object containing the height, width and frame rate of the stream.

:::note

getVideoStats() will return the metrics for the participant at that given point of time and not average data of the complete meeting.

To view the metrics for the complete meeting using the stats API documented [here](/api-reference/realtime-communication/fetch-session-quality-stats).

:::

:::info
If you are getting `rtt` greater than 300ms, try using a different region which is nearest to your user. To know more about changing region [visit here](/api-reference/realtime-communication/create-room).
:::

---

### getAudioStats()

- `getAudioStats()` will return an `List<dynamic>?` which will contain details regarding the participant's critical audio metrics such as **Jitter**, **Packet Loss** etc.

#### Returns

- `List`
  - `jitter` : It represents the distortion in the stream.
  - `bitrate` : It represents the bitrate of the stream which is being transmitted.
  - `totalPackets` : It represents the total packet count which were transmitted for that particiular stream.
  - `packetsLost` : It represents the total packets lost during the transimission of the stream.
  - `rtt` : It represents the time between the stream being reached to client from the server in milliseconds(ms).
  - `codec`: It represents the codec used for the stream.
  - `network`: It represents the network used to transmit the stream

:::note

getAudioStats() will return the metrics for the participant at that given point of time and not average data of the complete meeting.

To view the metrics for the complete meeting using the stats API documented [here](/api-reference/realtime-communication/fetch-session-quality-stats).

:::

:::info

If you are getting `rtt` greater than 300ms, try using a different region which is nearest to your user. To know more about changing region [visit here](/api-reference/realtime-communication/create-room).

:::

### getShareStats()

- `getShareStats()` will return an `List<dynamic>?` which will contain details regarding the participant's critical video metrics such as **Jitter**, **Packet Loss** etc.

#### Returns

- `List`
  - `jitter` : It represents the distortion in the stream.
  - `bitrate` : It represents the bitrate of the stream which is being transmitted.
  - `totalPackets` : It represents the total packet count which were transmitted for that particiular stream.
  - `packetsLost` : It represents the total packets lost during the transimission of the stream.
  - `rtt` : It represents the time between the stream being reached to client from the server in milliseconds(ms).
  - `codec`: It represents the codec used for the stream.
  - `network`: It represents the network used to transmit the stream
  - `size`: It is object containing the height, width and frame rate of the stream.

:::note

getShareStats() will return the metrics for the participant at that given point of time and not average data of the complete meeting.

To view the metrics for the complete meeting using the stats API documented [here](/api-reference/realtime-communication/fetch-session-quality-stats).

:::

:::info

If you are getting `rtt` greater than 300ms, try using a different region which is nearest to your user. To know more about changing region [visit here](/api-reference/realtime-communication/create-room).

:::

</div>


---

---
title: Participant Class Properties
sidebar_position: 1
sidebar_label: Properties
pagination_label: Participant Class Properties
---

# Participant Class Properties - Flutter

<div class="sdk-api-ref-only-h4">

### id

- type: [`String`](https://api.flutter.dev/flutter/dart-core/String-class.html)

- Unique id of the participant, who has joined the room.

---

### displayName

- type: [`String`](https://api.flutter.dev/flutter/dart-core/String-class.html)

- It will be the `displayName` of the participant, who has joined the room.

---

### isLocal

- type: [`bool`](https://api.flutter.dev/flutter/dart-core/bool-class.html)

- It will represents whether the participant is [`LocalParticipant`](../room-class/properties#localparticipant)(You) or not. If it is true, then participant is [`LocalParticipant`](../room-class/properties#localparticipant) otherwise RemoteParticipant.

---

### streams

- type: [`Map<String, Stream>`](https://api.flutter.dev/flutter/dart-core/Map-class.html)

- It will represents the stream for that particular participant who has joined the room. Stream could be `audio` , `video` or `share`.

---

### pinState

- type: `ParticipantPinState`

- It will represents the current pin state of the participant. It has properties `cam` and `share` of type boolean.

---

### mode

- type: `Mode`

- It will represents the participants current mode.

---

### metaData

- type: `Map<String,dynamic>`

- It will represents the additional information, that you have passed in [`createRoom()`](../videosdk-class/methods.md).

</div>


---

---
title: Video SDK PubSub Class
sidebar_position: 1
sidebar_label: Introduction
pagination_label: Video SDK PubSub Class
---

# Video SDK PubSub Class - Flutter

<div class="sdk-api-ref">

## Introduction

PubSub class provides the methods to implement Publisher-Subscriber feature in your Flutter Application.

## PubSub Methods

<div class="row">

<div class="col col--4 margin-bottom--sm" >

- [publish](methods#publish)

</div>
<div class="col col--4 margin-bottom--sm" >

- [subscribe](methods#subscribe)

</div>

<div class="col col--4 margin-bottom--sm" >

- [unsubscribe](methods#unsubscribe)

</div>
</div>
</div>


---

---
sidebar_position: 1
sidebar_label: Methods
pagination_label: PubSub Class Methods
title: PubSub Class Methods
---

# PubSub Class Methods - Flutter

<div class="sdk-api-ref-only-h4">

### publish()

- `publish()` is used to publish messages on a specified topic in the room.

#### Parameters

- topic

  - type: [`String`](https://api.dart.dev/stable/2.15.1/dart-core/String-class.html)
  - This is the name of the topic, for which message will be published.

- message

  - type: [`String`](https://api.dart.dev/stable/2.15.1/dart-core/String-class.html)
  - This is the actual message.

- options
  - type: [`PubSubPublishOptions`](pubsub-publish-options-class)
  - This specifies the options for publish.

- payload
  - type: `Map<String,dynamic>`
  - If you need to include additional information along with a message, you can pass here as `Map<String, dynamic>`. This is optional parameter.


#### Returns

- _`Future<void>`_

#### Example

```js
// Publishing message
room.pubSub
    .publish(
      "CHAT",
      "Hii",
      const PubSubPublishOptions(persist: true),
    );
```

---

### subscribe()

- `subscribe()` is used to subscribe a particular topic to get all the messages of that particular topic in the room.

#### Parameters

- topic:

  - type: [`String`](https://api.dart.dev/stable/2.15.1/dart-core/String-class.html)
  - Participants can listen to messages on that particular topic.

- messageHandler:

  - type: [`Function(PubSubMessage)`](pubsub-message-class)
  - This function will be called, whenever pubsub message received.

#### Returns

- [_`Future<PubSubMessages>`_](pubsub-message-class)

#### Example

```js
// Subscribing 'CHAT' Topic

void handleMessage(PubSubMessage pubsubMessage) {
  print(pubsubMessage.message);
}

void subscribePubSubTopic() async {
  PubSubMessages pubsubMessages =
      room.pubSub.subscribe("CHAT", handleMessage);

  // do something
}

subscribePubSubTopic();
```

---

### unsubscribe()

- `unsubscribe()` is used to unsubscribe a particular topic on which you have subscribed priviously.

#### Parameters

- topic:

  - type: [`String`](https://api.dart.dev/stable/2.15.1/dart-core/String-class.html)
  - This is the name of the topic to be unsubscribed.

- messageHandler:

  - type: [`Function(PubSubMessage)`](https://api.dart.dev/stable/2.15.1/dart-core/Function-class.html)
  - This is the message handler to be unsubscribed.

#### Returns

- _`Future<void>`_

#### Example

```js
// Unsubscribing 'CHAT' topic
room.pubSub.unsubscribe("CHAT", handleMessage);
```

</div>


---

---
sidebar_position: 1
sidebar_label: PubSubMessage Class
pagination_label: PubSubMessage Class
title: PubSubMessage Class
---

# PubSubMessage Class - Flutter

<div class="sdk-api-ref-only-h4">

## Properties

### id

- type: [`String`](https://api.dart.dev/stable/2.15.1/dart-core/String-class.html)

- Unique id of the pubsub message.

---

### message

- type: [`String`](https://api.dart.dev/stable/2.15.1/dart-core/String-class.html)

- Message that has been published on the specific topic.

---

### topic

- type: [`String`](https://api.dart.dev/stable/2.15.1/dart-core/String-class.html)

- Name of the topic.

---

### senderId

- type: [`String`](https://api.dart.dev/stable/2.15.1/dart-core/String-class.html)

- This is the id of the participant, who has sent this pubsub message.

---

### senderName

- type: [`String`](https://api.dart.dev/stable/2.15.1/dart-core/String-class.html)

- This is the name of the participant, who has sent this pubsub message.

---

### timestamp

- type: [`DateTime`](https://api.dart.dev/stable/2.15.1/dart-core/DateTime-class.html)

- Timestamp of when a message has been published.

---

### payload

- type: `Map<String,dynamic>`

- This is the data that you have send with message.

</div>


---

---
sidebar_position: 1
sidebar_label: PubSubPublishOptions Class
pagination_label: PubSubPublishOptions Class
title: PubSubPublishOptions Class
---

# PubSubPublishOptions Class - Flutter

<div class="sdk-api-ref-only-h4">

## Properties

### persist

- type: [`bool`](https://api.dart.dev/stable/2.15.1/dart-core/bool-class.html)

- defaultValue: `false`

- This property specifies whether to store messages on server for upcoming participants.

- If the value of this property is true, then server will store pubsub messages for the upcoming participants.

---

### sendOnly

- type: `List<String>`

- If you want to send a message to specific participants, you can pass their respective `participantId` here. If you don't provide any IDs, the message will be sent to all participants by default.

:::note
Make sure that participantId present in the array must be subscribe to that specific topic.
:::

</div>


---

---
title: Room Class Events
sidebar_position: 1
sidebar_label: Events
pagination_label: Room Class Events
---

# Room Class Events - Flutter

<div class="sdk-api-ref-only-h4">

---

### roomJoined

- This event will be emitted when a [localParticipant](properties#localparticipant) successfully joined the room.

#### Example

```javascript
room.on(Events.roomJoined, (){
  // do something
});
```

---

### roomLeft

- This event will be emitted when a [localParticipant](properties#localparticipant) left the room.

#### Example

```javascript
room.on(Events.roomLeft, () {
  // do something
});
```

---

### participantJoined

- This event will be emitted when a new [participant](../participant-class/introduction) joined the room.

#### Event handler parameters

- **participant**: [Participant](../participant-class/introduction)

#### Example

```javascript
room.on(Events.participantJoined, (participant) {
  // do something
});
```

---

### participantLeft

- This event will be emitted when a joined [participant](../participant-class/introduction) left the room.

#### Event handler parameters

- **participant**: [Participant](../participant-class/introduction)

#### Example

```javascript
room.on(Events.participantLeft, (participant) {
  // do something
});
```

---

### speakerChanged

- This event will be emitted when a active speaker changed.
- If you want to know which participant is actively speaking, then this event will be used.
- If no participant is actively speaking, then this event will pass `null` as an event handler parameter.

#### Event handler parameters

- **activeSpeakerId**: String?

#### Example

```javascript
room.on(Events.speakerChanged, (activeSpeakerId) {
  // do something
});
```

---

### presenterChanged

- This event will be emitted when any [participant](../participant-class/introduction) starts or stops screen sharing.
- It will pass `participantId` as an event handler parameter.
- If a participant stops screen-sharing, then this event will pass `null` as en event handler parameter.

#### Event handler parameters

- **activePresenterId**: String?

#### Example

```javascript
room.on(Events.presenterChanged, (activePresenterId) {
  // do something
});
```

---

### pinStateChanged

- This event will be emitted when any [participant](../participant-class/introduction) pin state gets changed.
- It will pass `participantId`, `state`, and `pinnedBy` as `Map<String, dynamic>` as an event handler parameter.

#### Event handler parameters

- **data**: `Map{'<'}String{','} dynamic>`\{**participantId**:String{','} **state**:Map{'<'}String{','} dynamic>, **pinnedBy**:String}

#### Example

```javascript
room.on(Events.pinStateChanged, (data) {
  // do something
});
```

### participantModeChanged

This event is triggered when a participant's mode is updated.

It passes `data` as an event callback parameter, which includes the following:

- **`SEND_AND_RECV`**: Both audio and video streams will be produced and consumed.

- **`SIGNALLING_ONLY`**: Both audio and video streams will not be produced or consumed. It is used solely for signaling.

- **`RECV_ONLY`**: Both audio and video streams will be consumed without producing any.

#### Event handler parameters

- **data**: `Map<String, dynamic>`\{**participantId**:String, **mode**:String}

import CautionMessage from '@site/src/theme/CautionMessage';


<CautionMessage sdk="Flutter SDK" version="v1.3.0" />

#### Example

```javascript
room.on(Events.participantModeChanged, (data) {
  // do something
});
```

---

### entryRequested

- This event will be emitted when a new [participant](../participant-class/introduction), who is trying to join the room, is having permission **`ask_join`** in token.
- This event will only be emitted to the [participants](properties#participants) in the room, who is having the permission **`allow_join`** in token.
- This event will pass following parameters as an event parameters, `participantId` and `name` of the new participant who is trying to join the room, `allow()` and `deny()` to take required actions.

#### Event handler parameters

- **data**: `Map<String, dynamic>`\{ **"allow"**: Function; **"deny"**: Function; **"name"**: String; **"participantId"**: String }
  - **allow**: Function
  - **deny**: Function
  - **name**: String
  - **participantId**: String

#### Example

```javascript
room.on(Events.entryRequested, (data){
  String? participantId = data["participantId"];
  String? name = data["name"];

  Function allow = data["allow"];
  Function deny = data["deny"];

  print("$name requested to join the room.");

  // If you want to allow the entry request
  allow();

  // if you want to deny the entry request
  deny();
});
```

---

### entryResponded

- This event will be emitted when the `join()` request is responded.
- This event will be emitted to the [participants](properties#participants) in the room, who is having the permission **`allow_join`** in token.
- This event will be also emitted to the [participant](../participant-class/introduction), who requested to join the room.

#### Event handler parameters

- **participantId**: _String_
- **decision**: _"allowed"_ | _"denied"_

#### Example

```javascript
room.on(Events.entryResponded, (participantId, decision) {
  // participantId will be id of participant, who requested to join room

  if (decision === "allowed") {
    // entry allowed
  } else {
    // entry denied
  }
});
```

---

### cameraRequested

- This event will be emitted to the participant `B` when any other participant `A` requests to enable camera of participant `B`.
- On accepting the request, camera of participant `B` will be enabled.

#### Event handler parameters

- **data**: `Map<String, dynamic>`\{ **accept**: Function; **participantId**: String; **reject**: Function }
  - **accept**: Function
  - **participantId**: String
  - **reject**: Function

#### Example

```javascript
room.on(Events.cameraRequested, (data) {
  String? participantId = data["participantId"];

  Function accept = data["accept"];
  Function reject = data["deny"];

  // participantId, will be the id of participant who requested to enable camera

  // if accept request
  accept();

  // if reject request
  reject();
});
```

---

### micRequested

- This event will be emitted to the participant `B` when any other participant `A` requests to enable mic of participant `B`.
- On accepting the request, mic of participant `B` will be enabled.

#### Event handler parameters

- **data**: Map{'<'}String{','} dynamic>\{ **accept**: Function; **participantId**: String; **reject**: Function }
  - **accept**: Function
  - **participantId**: String
  - **reject**: Function

#### Example

```javascript
room.on(Events.micRequested, (data) {
  String participantId = data["participantId"];

  Function accept = data["accept"];
  Function reject = data["reject"];

  // participantId, will be the id of participant who requested to enable camera

  // if accept request
  accept();

  // if reject request
  reject();
});
```

---

### recordingStarted

_`This event will be deprecated soon`_

- This event will be emitted when recording of the room is started.

#### Example

```javascript
room.on(Events.recordingStarted, () {
  // do something
});
```

---

### recordingStopped

_`This event will be deprecated soon`_

- This event will be emitted when recording of the room is stopped.

#### Example

```javascript
room.on(Events.recordingStopped, () {
  // do something
});
```

---

### recordingStateChanged

- This event will be emitted when the meeting's recording status changed.

#### Event callback parameters

- **status**: String

`status` has following values

- `RECORDING_STARTING` - Recording is in starting phase and hasn't started yet.
- `RECORDING_STARTED` - Recording has started successfully.
- `RECORDING_STOPPING` - Recording is in stopping phase and hasn't stopped yet.
- `RECORDING_STOPPED` - Recording has stopped successfully.

#### Example

```javascript
room.on(Events.recordingStateChanged, (String status) {
  log("Meeting recording status : $status");
});
```

---

### liveStreamStarted

_`This event will be deprecated soon`_

- This event will be emitted when `RTMP` live stream of the room is started.

#### Example

```javascript
room.on(Events.liveStreamStarted, () {
  // do something
});
```

---

### liveStreamStopped

_`This event will be deprecated soon`_

- This event will be emitted when `RTMP` live stream of the room is stopped.

#### Example

```javascript
room.on(Events.liveStreamStopped, () {
  // do something
});
```

---

### livestreamStateChanged

- This event will be emitted when the meeting's livestream status changed.

#### Event callback parameters

- **status**: String

`status` has following values

- `LIVESTREAM_STARTING` - Livestream is in starting phase and hasn't started yet.
- `LIVESTREAM_STARTED` - Livestream has started successfully.
- `LIVESTREAM_STOPPING` - Livestream is in stopping phase and hasn't stopped yet.
- `LIVESTREAM_STOPPED` - Livestream has stopped successfully.

#### Example

```javascript
room.on(Events.liveStreamStateChanged, (String status) {
  log("Meeting live streaming status : $status");
});
```

---

### hlsStateChanged

- This event will be emitted when the meeting's HLS(Http Livestreaming) status changed.

#### Event callback parameters

- **data**: \{ **status**: String , **playbackHlsUrl**: String , **livestreamUrl**: String }
  - **status**: String
  - **playbackHlsUrl**: String _`will receive this property only in HLS_STARTED status`_
  - **livestreamUrl**: String _`will receive this property only in HLS_STARTED status`_

`status` has following values

- `HLS_STARTING` - Hls is in starting phase and hasn't started yet.
- `HLS_STARTED` - Hls has started successfully.
- `HLS_PLAYABLE` - Hls has started can be played now, it will return `playbaclHlsUrl` and `livestreamUrl`.
- `HLS_STOPPING` - Hls is in stopping phase and hasn't stopped yet.
- `HLS_STOPPED` - Hls has stopped successfully.

:::note
`downstreamUrl` is now depecated. Use `playbackHlsUrl` or `livestreamUrl` in place of `downstreamUrl`
:::

#### Example

```javascript
room.on(Events.hlsStateChanged, (Map<String, dynamic> data) {
    toastMsg("Meeting HLS status : ${data['status']}");
    if (data['status'] == "HLS_PLAYABLE"){
     // [data] : { status: String,  playbackHlsUrl: String, livestreamUrl: String  }
     log("PLAYBACKHLS URL -- " + data['playbackHlsUrl']);
    }
});
```

---

### hlsStarted

_`This event will be deprecated soon`_

- This event will be emitted when `HLS` of the meeting is started.

#### Event callback parameters

- **playbackHlsUrl**: String
- **livestreamUrl**: String

#### Example

```javascript
room.on(Events.hlsStarted, (String playbackHlsUrl, String livestreamUrl) => {
  //
});
```

---

### hlsStopped

_`This event will be deprecated soon`_

- This event will be emitted when `HLS` of the meeting is stopped.

#### Example

```javascript
room.on(Events.hlsStopped, () => {
  //
});
```

---

---

### transcriptionStateChanged

- This event will be triggered whenever state of realtime transcription is changed.

#### Event callback parameters

- **data**: \{ **status**: String, **id**: String }
  - **status**: String
  - **id**: String

`status` has following values

- `TRANSCRIPTION_STARTING` - Realtime Transcription is in starting phase and hasn't started yet.
- `TRANSCRIPTION_STARTED` - Realtime Transcription has started successfully.
- `TRANSCRIPTION_STOPPING` - Realtime Transcription is in stopping phase and hasn't stopped yet.
- `TRANSCRIPTION_STOPPED` - Realtime Transcription has stopped successfully.

#### Example

```javascript
room.on(Events.transcriptionStateChanged, (Map<String, dynamic> data) {
    //Status can be :: TRANSCRIPTION_STARTING
    //Status can be :: TRANSCRIPTION_STARTED
    //Status can be :: TRANSCRIPTION_STOPPING
    //Status can be :: TRANSCRIPTION_STOPPED
  log("Meeting transcription status : ${data['status']}");
});
```

---

### transcriptionText

- This event will be emitted when text for running realtime transcription received.

#### Example

```javascript
room.on(Events.transcriptionText, (TranscriptionText data) {
  var participantId = data.participantId;
  var participantName = data.participantName;
  var text = data.text;
  var timestamp = data.timestamp;
  var type = data.type;
  print(
        "Meeting Transcription started. Participant name: $participantName , Participant Id $participantId ");

});
```

---

### error

- This event will be emitted when and error occurs in the room.

#### Example

```javascript
room.on(Events.error, (error) {
  log("VIDEOSDK ERROR :: " +
      error['code'].toString() +
      "  :: " +
      error['name'].toString() +
      " :: " +
      error['message'].toString());
});
```

---

### whiteboardStarted

- This event will be emitted when a whiteboard session is succesfully started.
-  It returns a `URL` that can be used to render the whiteboard in the app or in a web view.

#### Example

```javascript
room.on(Events.whiteboardStarted, (url) {
  // do something
});
```

---

### whiteboardStopped

- This event will be emitted when a whiteboard session succesfully ends.

#### Example

```javascript
room.on(Events.whiteboardStopped, () {
  // do something
});
```

---

### roomStateChanged

- This event is triggered whenever the room's state changes. 
- The current state of the room is passed as a callback parameter.
- All available states are `connecting`, `connected`, `failed`, `disconnected`, `closing`, `closed`.

#### Event callback parameters

- **state**: `RoomState`

#### Example

```javascript
room.on(Events.roomStateChanged, (RoomState state) {
    switch (state) {
      case RoomState.connecting:
        print('Meeting is Connecting');
        break;
      case RoomState.connected:
        print('Meeting is Connected');
        break;
      case RoomState.disconnected:
        print('Meeting connection disconnected abruptly');
        break;
      case RoomState.failed:
        print('Meeting connection failed');
        break;
      case RoomState.closing:
        print('Meeting is closing');
        break;
      case RoomState.closed:
        print('Meeting connection closed');
        break;
      default:
        print('default');
    }
});
```

---



</div>


---

---
title: Room class for Flutter SDK.
hide_title: true
hide_table_of_contents: false
description: VideoSDK Room Class provides features to implement custom room layout in your application.
sidebar_label: Example
pagination_label: Room Class Example
keywords:
  - RTC Flutter
  - Room Class
  - Video API
  - Video Conferencing
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: room-class-example
---

import NoIndex from '../../../../mdx/\_no-index.mdx';

<NoIndex/>

# Room Class Example - Flutter

```js title="Play with room instance"
// Join the room
room?.join();

// Get local participants
room?.localParticipant;

// Get remote participants
room?.participants;

// Adding event listner
room.on(Events.participantJoined, (Participant participant) {
  print("new participant => $participant");
  },
);
```


---

---
sidebar_position: 1
sidebar_label: Introduction
pagination_label: Intro to Video SDK Room Class
title: Video SDK Room Class
---

# Video SDK Room Class- Flutter

<div id="tailwind" class="sdk-api-ref">

## Introduction

The `Room` class includes properties, methods and events for managing a VideoSDK Room, participants, video, audio and share streams, messaging and UI customization.

import LinksGrid from '../../../../src/theme/LinksGrid'
import properties from '../data/properties.json'
import methods from '../data/methods.json'
import events from '../data/events.json'

## Room Properties

<div class="row">

<div class="col col--4 margin-bottom--sm" >

- [id](./properties#id)

</div>
<div class="col col--4 margin-bottom--sm" >

- [activeSpeakerId](./properties#activespeakerid)

</div>
<div class="col col--4 margin-bottom--sm" >

- [activePresenterId](./properties#activepresenterid)

</div>

<div class="col col--4 margin-bottom--sm" >

- [camEnabled](./properties#camenabled)

</div>

<div class="col col--4 margin-bottom--sm" >

- [selectedCamId](./properties#selectedcam)

</div>

<div class="col col--4 margin-bottom--sm" >

- [selectedCam](./properties#selectedcamid)

</div>

<div class="col col--4 margin-bottom--sm" >

- [micEnabled](./properties#micenabled)

</div>

<div class="col col--4 margin-bottom--sm" >

- [hlsState](./properties#hlsstate)

</div>

<div class="col col--4 margin-bottom--sm" >

- [livestreamState](./properties#livestreamstate)

</div>

<div class="col col--4 margin-bottom--sm" >

- [recordingState](./properties#recordingstate)

</div>

<div class="col col--4 margin-bottom--sm" >

- [hlsDownstreamUrl](./properties#hlsdownstreamurl)

</div>

<div class="col col--4 margin-bottom--sm" >

- [selectedMicId](./properties#selectedmicid)

</div>

<div class="col col--4 margin-bottom--sm" >

- [selectedMic](./properties#selectedmic)

</div>

<div class="col col--4 margin-bottom--sm" >

- [localParticipant](./properties#localparticipant)

</div>
<div class="col col--4 margin-bottom--sm" >

- [participants](./properties#participants)

</div>
<div class="col col--4 margin-bottom--sm" >

- [pinnedParticipants](./properties#pinnedparticipants)

</div>
<div class="col col--4 margin-bottom--sm" >

- [pubSub](./properties#pubsub)

</div>

<div class="col col--4 margin-bottom--sm" >

- [selectedSpeakerId](./properties#selectedspeakerid)

</div>
<div class="col col--4 margin-bottom--sm" >

- [selectedSpeaker](./properties#selectedspeaker)

</div>

</div>

## Room Methods

<div class="row">
<div class="col col--4 margin-bottom--sm" >

- [join](./methods#join)

</div>
<div class="col col--4 margin-bottom--sm" >

- [leave](./methods#leave)

</div>
<div class="col col--4 margin-bottom--sm" >

- [end](./methods#end)

</div>
<div class="col col--4 margin-bottom--sm" >

- [enableCam](./methods#enablecam)

</div>
<div class="col col--4 margin-bottom--sm" >

- [disableCam](./methods#disablecam)

</div>
<div class="col col--4 margin-bottom--sm" >

- [unmuteMic](./methods#unmutemic)

</div>
<div class="col col--4 margin-bottom--sm" >

- [muteMic](./methods#mutemic)

</div>
<div class="col col--4 margin-bottom--sm" >

- [getScreenShareSources](./methods#getscreensharesources)

</div>
<div class="col col--4 margin-bottom--sm" >

- [enableScreenShare](./methods#enablescreenshare)

</div>
<div class="col col--4 margin-bottom--sm" >

- [disableScreenShare](./methods#disablescreenshare)

</div>

<div class="col col--4 margin-bottom--sm" >

- [changeMode](./methods#changemode)

</div>
<div class="col col--4 margin-bottom--sm" >

- [startRecording](./methods#startrecording)

</div>
<div class="col col--4 margin-bottom--sm" >

- [stopRecording](./methods#stoprecording)

</div>
<div class="col col--4 margin-bottom--sm" >

- [startLivestream](./methods#startlivestream)

</div>
<div class="col col--4 margin-bottom--sm" >

- [stopLivestream](./methods#stoplivestream)

</div>
<div class="col col--4 margin-bottom--sm" >

- [startHls](./methods#starthls)

</div>
<div class="col col--4 margin-bottom--sm" >

- [stopHls](./methods#stophls)

</div>
<div class="col col--4 margin-bottom--sm" >

- [startTranscription](./methods#starttranscription)

</div>
<div class="col col--4 margin-bottom--sm" >

- [stopTranscription](./methods#stoptranscription)

</div>
<div class="col col--4 margin-bottom--sm" >

- [startWhiteboard](./methods#startwhiteboard)

</div>
<div class="col col--4 margin-bottom--sm" >

- [stopWhiteboard](./methods#stopwhiteboard)

</div>
<div class="col col--4 margin-bottom--sm" >

- [getCameras](./methods#getcameras)

</div>
<div class="col col--4 margin-bottom--sm" >

- [changeCam](./methods#changecam)

</div>
<div class="col col--4 margin-bottom--sm" >

- [getAudioOutputDevices](./methods#getaudiooutputdevices)

</div>
<div class="col col--4 margin-bottom--sm" >

- [switchAudioDevice](./methods#switchaudiodevice)

</div>
<div class="col col--4 margin-bottom--sm" >

- [getMics](./methods#getmics)

</div>
<div class="col col--4 margin-bottom--sm" >

- [changeMic](./methods#changemic)

</div>
<div class="col col--4 margin-bottom--sm" >

- [on](./methods#on)

</div>
</div>

## Room Events

<div class="row">

<div class="col col--4 margin-bottom--sm" >

- [roomJoined](./events#roomjoined)

</div>
<div class="col col--4 margin-bottom--sm" >

- [roomLeft](./events#roomleft)

</div>
<div class="col col--4 margin-bottom--sm" >

- [participantJoined](./events#participantjoined)

</div>
<div class="col col--4 margin-bottom--sm" >

- [participantLeft](./events#participantleft)

</div>
<div class="col col--4 margin-bottom--sm" >

- [speakerChanged](./events#speakerchanged)

</div>
<div class="col col--4 margin-bottom--sm" >

- [presenterChanged](./events#presenterchanged)

</div>
<div class="col col--4 margin-bottom--sm" >

- [participantModeChanged](./events#participantmodechanged)

</div>
<div class="col col--4 margin-bottom--sm" >

- [pinStateChanged](./events#pinstatechanged)

</div>
<div class="col col--4 margin-bottom--sm" >

- [entryRequested](./events#entryrequested)

</div>
<div class="col col--4 margin-bottom--sm" >

- [entryResponded](./events#entryresponded)

</div>
<div class="col col--4 margin-bottom--sm" >

- [cameraRequested](./events#camerarequested)

</div>
<div class="col col--4 margin-bottom--sm" >

- [micRequested](./events#micrequested)

</div>
<div class="col col--4 margin-bottom--sm" >

- [recordingStarted](./events#recordingstarted)

</div>
<div class="col col--4 margin-bottom--sm" >

- [recordingStopped](./events#recordingstopped)

</div>

<div class="col col--4 margin-bottom--sm" >

- [livestreamStarted](./events#livestreamstarted)

</div>
<div class="col col--4 margin-bottom--sm" >

- [livestreamStopped](./events#livestreamstopped)

</div>

<div class="col col--4 margin-bottom--sm" >

- [transcriptionStateChanged](./events#transcriptionstatechanged)

</div>

<div class="col col--4 margin-bottom--sm" >

- [transcriptionText](./events#transcriptiontext)

</div>

<div class="col col--4 margin-bottom--sm" >

- [whiteboardStarted](./events#whiteboardstarted)

</div>
<div class="col col--4 margin-bottom--sm" >

- [whiteboardStopped](./events#whiteboardstopped)

</div>

<div class="col col--4 margin-bottom--sm" >

- [error](./events#error)

</div>

</div>

</div>


---

---
sidebar_position: 1
sidebar_label: Methods
pagination_label: Room Class Methods
title: Room Class Methods
---

# Room Class Methods - Flutter

<div class="sdk-api-ref-only-h4">

### join()

- After creating the instance of VideoSDK Room, you can join VideoSDK Room by calling `join()` method.

#### Events associated with `join()`:

- Local Participant will receive a [`roomJoined`](events#roomjoined) event, when successfully joined.
- Remote Participant will receive a [`participantJoined`](events#participantjoined) event with the newly joined [`Participant`](../participant-class/introduction) object from the event handler.

#### Participant having `ask_join` permission inside token

- If a token contains the permission `ask_join`, then the participant will not join the room directly after calling `join()`, but an event will be emitted to the participant having the permission `allow_join` called [`entryRequested`](events#entryrequested).

- After the decision from the remote participant, an event will be emitted to participant called [`entryResponded`](events#entryresponded). This event will contain the decision made by the remote participant.

#### Participant having `allow_join` permission inside token

- If a token containing the permission `allow_join`, then the participant will join the room directly after calling `join()`.

#### Returns

- _`void`_

---

### leave()

- It is used to leave the current running room session.

#### Events associated with `leave()`:

- Local participant will receive a [`roomLeft`](events#roomleft) event.
- All remote participants will receive a [`participantLeft`](events#participantleft) event with `participantId` string from the event handler.

#### Returns

- _`void`_

---

### end()

- It is used to end the current running room session.
- By calling `end()`, all joined [participants](properties#participants) including [localParticipant](properties#localparticipant) of that session will leave the room.

#### Events associated with `end()`:

- All [participants](properties#participants) and [localParticipant](properties#localparticipant), will receive [`roomLeft`](events#roomleft) event.

#### Returns

- _`void`_

---

### enableCam()

- It is used to enable camera device.
- [`streamEnabled`](../participant-class/events#streamenabled) event will be emitted with [`stream`](../stream-class/introduction) object from the event handler, inside that [participant](../participant-class/introduction) object.

#### Returns

- _`void`_

---

### disableCam()

- It is used to disable camera device.
- [`streamDisabled`](../participant-class/events#streamdisabled) event will be emitted with [`stream`](../stream-class/introduction) object from the event handler, inside that [participant](../participant-class/introduction) object.

#### Returns

- _`void`_

---

### unmuteMic()

- It is used to enable microphone device.
- [`streamEnabled`](../participant-class/events#streamenabled) event will be emitted with [`stream`](../stream-class/introduction) object from the event handler, inside that [participant](../participant-class/introduction) object.

#### Returns

- _`void`_

---

### muteMic()

- It is used to disable microphone device.
- [`streamDisabled`](../participant-class/events#streamdisabled) event will be emitted with [`stream`](../stream-class/introduction) object from the event handler, inside that [participant](../participant-class/introduction) object.

#### Returns

- _`void`_

---

### getScreenShareSources()

- It will return all available screens and opened windows.
- This method only supports desktop apps.

#### Returns

- `Future<List<DesktopCapturerSource>>`

#### Example

```javascript
meeting.getScreenShareSources().then((value) => print("Sources : $value"));
```

---

### enableScreenShare()

- it is used to enable screen-sharing.
- [`streamEnabled`](../participant-class/events#streamenabled) event will be emitted with [`stream`](../stream-class/introduction) object from the event handler, inside that [participant](../participant-class/introduction) object.
- [presenterChanged](./events#presenterchanged) will also receive a callback with the `presenterId`.

#### Parameters

- **source**:
  - type : `DesktopCapturerSource`
  - required : false
  - It will specify selected screenShare source for desktop apps.

#### Returns

- _`void`_

---

### disableScreenShare()

- It is used to disable screen-sharing.
- [`streamDisabled`](../participant-class/events#streamdisabled) event will be emitted with [`stream`](../stream-class/introduction) object from the event handler, inside that [participant](../participant-class/introduction) object.
- [presenterChanged](./events#presenterchanged) will also receive a callback with the `null`.

#### Returns

- _`void`_

---

### changeMode()

- **`SEND_AND_RECV`**: Both audio and video streams will be produced and consumed.

- **`SIGNALLING_ONLY`**: Audio and video streams will not be produced or consumed. It is used solely for signaling.

- **`RECV_ONLY`**: Only audio and video streams will be consumed without producing any.

import CautionMessage from '@site/src/theme/CautionMessage';

<CautionMessage sdk="Flutter SDK" version="v1.3.0" />

- [`participantModeChange`](./events#participantmodechanged) event will be emitted with `participantId` and `mode` of the participant

#### Parameters

- **requestedMode**: `Mode.SEND_AND_RECV` | `Mode.SIGNALLING_ONLY` | `Mode.RECV_ONLY`

#### Returns

- _`void`_

#### Example

```javascript
room.changeMode(Mode.SEND_AND_RECV);
```

---

### startRecording()

- It is used to start room recording.
- All [participants](properties#participants) and [localParticipant](properties#localparticipant), will receive [`recordingStarted`](events#recordingstarted) event.

- `webhookUrl` will be triggered when the recording is completed and stored into server. Read more about webhooks [here](https://en.wikipedia.org/wiki/Webhook).

#### Parameters

- **webhookUrl**: String

- **awsDirPath**: String

- **config**:

  - **layout**:
    - **type**: _"GRID"_ | _"SPOTLIGHT"_ | _"SIDEBAR"_
    - **priority**: _"SPEAKER"_ | _"PIN"_
    - **gridSize**: Number _\`max 4\`_
  - **theme**: _"DARK"_ | _"LIGHT"_ | _"DEFAULT"_
  - **mode**: _"video-and-audio"_ | _"audio"_
  - **quality**: _"low"_ | _"med"_ | _"high"_
  - **orientation**: _"landscape"_ | _"portrait"_

- **postTranscriptionConfig**:
  - **PostTranscriptionConfig.enabled**: Boolean
  - **PostTranscriptionConfig.summaryConfig**:
    - **SummaryConfig.enabled**: Boolean
    - **SummaryConfig.prompt**: String
  - **PostTranscriptionConfig.modelId**: String

#### Returns

- _`void`_

#### Example

```javascript
const String webhookUrl = "https://webhook.your-api-server.com";

Map<String, dynamic> config = {
  'layout': {
    'type': 'GRID',
    'priority': 'SPEAKER',
    'gridSize': 4,
  },
  'theme': "LIGHT",
  "mode": "video-and-audio",
};

PostTranscriptionConfig postTranscriptionConfig = PostTranscriptionConfig(
  enabled: true,
  modelId: "raman_v1",
  summaryConfig: SummaryConfig(
    enabled: true,
    prompt: "Write summary in sections like Title, Agenda, Speakers, Action Items, Outlines, Notes and Summary"
  ),
);

room.startRecording(
  webhookUrl: webhookUrl,
  config: config,
  postTranscriptionConfig: postTranscriptionConfig
);
```

---

### stopRecording()

- It is used to stop room recording.
- All [participants](properties#participants) and [localParticipant](properties#localparticipant), will receive [`recordingStopped`](events#recordingstopped) event.

#### Returns

- _`void`_

#### Example

```javascript
room.stopRecording();
```

---

### startLivestream()

- It is used to start room livestreaming.
- You will be able to start livestream the room to another platforms such as Youtube, Facebook, etc. that supports [`rtmp`](https://en.wikipedia.org/wiki/Real-Time_Messaging_Protocol) streaming.
- All [participants](properties#participants) and [localParticipant](properties#localparticipant), will receive [`liveStreamStarted`](events#livestreamstarted) event.

#### Parameters

- **outputs**: `List<Map<String, String>>` \[\{ **url**: String, **streamKey**: String }]

- **config**:

  - **layout**:
    - **type**: _"GRID"_ | _"SPOTLIGHT"_ | _"SIDEBAR"_
    - **priority**: _"SPEAKER"_ | _"PIN"_
    - **gridSize**: Number _\`max 4\`_
  - **theme**: _"DARK"_ | _"LIGHT"_ | _"DEFAULT"_

- **postTranscriptionConfig**:
  - **PostTranscriptionConfig.enabled**: Boolean
  - **PostTranscriptionConfig.summaryConfig**:
    - **SummaryConfig.enabled**: Boolean
    - **SummaryConfig.prompt**: String
  - **PostTranscriptionConfig.modelId**: String

#### Returns

- _`void`_

#### Example

```javascript
var outputs = [
  {
    url: "rtmp://a.rtmp.youtube.com/live2",
    streamKey: "<STREAM_KEY>",
  },
  {
    url: "rtmps://",
    streamKey: "<STREAM_KEY>",
  },
];
var liveStreamConfig =  {
  'layout': {
    'type': 'GRID',
    'priority': 'SPEAKER',
    'gridSize': 4,
  },
  'theme': "LIGHT",
};
PostTranscriptionConfig postTranscriptionConfig = PostTranscriptionConfig(
  enabled: true,
  modelId: "raman_v1",
  summaryConfig: SummaryConfig(
    enabled: true,
    prompt: "Write summary in sections like Title, Agenda, Speakers, Action Items, Outlines, Notes and Summary"
  ),
);
room.startLivestream(outputs, config: livestreamConfig, postTranscriptionConfig: postTranscriptionConfig);
```

---

### stopLivestream()

- It is used to stop room livestreaming.
- All [participants](properties#participants) and [localParticipant](properties#localparticipant), will receive [`livestreamStopped`](events#livestreamstopped) event.

#### Returns

- _`void`_

#### Example

```javascript
room.stopLivestream();
```

---

### startHls()

- It is used to start HLS.
- All [participants](properties#participants) and [localParticipant](properties#localparticipant), will receive [`hlsStarted`](events#hlsstarted) event with the `playbackHlsUrl` and `livestreamUrl` of the HLS feed.
  - `playbackHlsUrl` - Live HLS with playback support
  - `livestreamUrl` - Live HLS without playback support

:::note
`downstreamUrl` is now depecated. Use `playbackHlsUrl` or `livestreamUrl` in place of `downstreamUrl`
:::

#### Parameters

- **config**:

  - **layout**:
    - **type**: _"GRID"_ | _"SPOTLIGHT"_ | _"SIDEBAR"_
    - **priority**: _"SPEAKER"_ | _"PIN"_
    - **gridSize**: Number _\`max 25\`_
  - **theme**: _"DARK"_ | _"LIGHT"_ | _"DEFAULT"_
  - **mode**: _"video-and-audio"_ | _"audio"_
  - **quality**: _"low"_ | _"med"_ | _"high"_
  - **oreintation**: _"landscape"_ | _"portrait"_

- **postTranscriptionConfig**:
  - **PostTranscriptionConfig.enabled**: Boolean
  - **PostTranscriptionConfig.summaryConfig**:
    - **SummaryConfig.enabled**: Boolean
    - **SummaryConfig.prompt**: String
  - **PostTranscriptionConfig.modelId**: String

#### Returns

- _`void`_

#### Example

```javascript

Map<String, dynamic> config = {
  'layout': {
    'type': 'GRID',
    'priority': 'SPEAKER',
    'gridSize': 4,
  },
  'theme': "LIGHT",
  "mode": "video-and-audio"
};

PostTranscriptionConfig postTranscriptionConfig = PostTranscriptionConfig(
  enabled: true,
  modelId: "raman_v1",
  summaryConfig: SummaryConfig(
    enabled: true,
    prompt: "Write summary in sections like Title, Agenda, Speakers, Action Items, Outlines, Notes and Summary"
  ),
);
room.startHls(config: config, postTranscriptionConfig: postTranscriptionConfig);
```

---

### stopHls()

- It is used to stop HLS.
- All [participants](properties#participants) and [localParticipant](properties#localparticipant), will receive [`hlsStopped`](events#hlsstopped) event.

#### Returns

- _`void`_

#### Example

```javascript
room.stopHls();
```

---

### startTranscription()

- It is used to start realtime transcription.

- All [participants](properties#participants) and [localParticipant](properties#localparticipant), will receive [`TRANSCRIPTION_STARTING`](./events.md#transcriptionstatechanged) event state and [`transcription-text`](./events.md#transcriptiontext) event.

#### Parameters

#### 1. transcriptionConfig

- type : `TranscriptionConfig`

- required : `false`

- This specifies the configurations for realtime transcription. You can specify following properties.
  - `TranscriptionConfig.webhookUrl`: Webhooks will be triggered when the state of realtime transcription is changed. Read more about webhooks [here](https://en.wikipedia.org/wiki/Webhook)
  - `TranscriptionConfig.summaryConfig`:
    - `SummaryConfig.enabled`: Indicates whether realtime transcription summary generation is enabled. Summary will be available after realtime transcription stopped. Default: `false`
    - `SummaryConfig.prompt`: provides guidelines or instructions for generating a custom summary based on the realtime transcription content.

#### Returns

- _`void`_

#### Example

```javascript
TranscriptionConfig transcriptionConfig = TranscriptionConfig(
    webhookUrl: "https://webhook.your-api-server.com",
    summaryConfig: SummaryConfig(
        enabled: true,
        prompt:
            "Write summary in sections like Title, Agenda, Speakers, Action Items, Outlines, Notes and Summary"));

room.startTranscription(transcriptionConfig: transcriptionConfig);
```

---

### stopTranscription()

- It is used to stop realtime transcription.
- All [participants](../participant-class/introduction.md) and [localParticipant](../participant-class/introduction.md), will receive [`TRANSCRIPTION_STOPPING`](./events.md#transcriptionstatechanged) event state.

#### Returns

- _`void`_

#### Example

```javascript
room.stopTranscription();
```

---

### startWhiteboard()

- It is used to initialize a whiteboard session.

#### Returns

- _`void`_

#### Example

```javascript
room.startWhiteboard();
```

---

### stopWhiteboard()

- It is used to end a whiteboard session.

#### Returns

- _`void`_

#### Example

```javascript
room.stopWhiteboard();
```

---

:::danger
The `getCameras()` method has been completely removed starting from version 1.2.0. Please use [`VideoSDK.getVideoDevices()`](../videosdk-class/methods#getvideodevices) instead.
:::

### getCameras()

- It will return all connected camera devices.

#### Returns

- List< [`MediaDeviceInfo`](https://api.flutter.dev/flutter/dart-html/MediaDeviceInfo-class.html) >

#### Example

```javascript
List<MediaDeviceInfo> cams = room.getCameras();
print(cams);
```

---

### changeCam()

- It is used to change the camera device.
- If multiple camera devices are connected, by using `changeCam()`, one can change the camera device with camera device id.
- You can get list of connected video devices using [`VideoSDK.getVideoDevices()`](../videosdk-class/methods#getvideodevices)

#### Parameters

- **device**: VideoDeviceInfo

#### Returns

- _`void`_

#### Example

```javascript
room.changeCam(device);
```

---

:::danger
The `getAudioOutputDevices()` method has been completely removed starting from version 1.2.0. Please use [`VideoSDK.getAudioDevices()`](../videosdk-class/methods#getaudiodevices) instead.
:::

### getAudioOutputDevices()

- It will return all the available audio output devices.

:::note

For iOS devices:

- `EARPIECE` is not supported whenever `WIRED_HEADSET` or `BLUETOOTH` device is connected.
- `WIRED_HEADSET` and `BLUETOOTH` devices are not supported simultaneously. Priority is given to the most recently connected device.

:::

#### Returns

- List< [`MediaDeviceInfo`](https://api.flutter.dev/flutter/dart-html/MediaDeviceInfo-class.html) >

#### Example

```javascript
List<MediaDeviceInfo> audioOutputDevices = room.getAudioOutputDevices();
print(audioOutputDevices);
```

---

### switchAudioDevice()

- It is used to change the audio output device.
- You can get list of connected audio output devices using [`VideoSDK.getAudioDevices()`](../videosdk-class/methods#getaudiodevices)

#### Parameters

- **device**: AudioDeviceInfo

#### Returns

- _`void`_

#### Example

```javascript
room.switchAudioDevice(device);
```

---

:::danger
The `getMics()` method has been completely removed starting from version 1.2.0. Please use [`VideoSDK.getAudioDevices()`](../videosdk-class/methods#getaudiodevices) instead.
:::

### getMics()

- It will return all the available audio input devices.

#### Returns

- List< [`MediaDeviceInfo`](https://api.flutter.dev/flutter/dart-html/MediaDeviceInfo-class.html) >

#### Example

```javascript
List<MediaDeviceInfo> audioInputDevices = room.getMics();
print(audioInputDevices);
```

---

### changeMic()

- It is used to change the audio input device.
- You can get list of connected audio input devices using [`VideoSDK.getAudioDevices()`](../videosdk-class/methods#getaudiodevices)

#### Parameters

- **device**: AudioDeviceInfo

#### Returns

- _`void`_

:::info

- The `changeMic()` method is not supported on Mobile Applications.

:::

#### Example

```javascript
room.changeMic(device);
```

---

### on()

- It is used to listen [`Room`](introduction) related events. - It is used to listen [`Room`](introduction) related events.

#### Parameters

- event

  - type: [`Events`](events)
  - This will specify the event to be listened.

- eventHandler
  - type: [`Function`](https://api.dart.dev/stable/2.15.1/dart-core/Function-class.html)
  - This will be invoked whenever, specified event occurred.

#### Returns

- _`void`_

#### Example

```js
room.on(Events.roomJoined, () {
  // do something
});
```

</div>


---

---
sidebar_position: 1
sidebar_label: Properties
pagination_label: Room Class Properties
title: Room Class Properties
---

# Room Class Properties - Flutter

<div class="sdk-api-ref-only-h4">

### id

- type: [`String`](https://api.dart.dev/stable/2.15.1/dart-core/String-class.html)

- Unique id of the room where the participant has joined.

---

### activeSpeakerId

- type: [`String?`](https://api.dart.dev/stable/2.15.1/dart-core/String-class.html)

- It will be the `id` of the participant who is actively speaking in the room. If no participant is speaking, at that time value of `activeSpeakerId` will be `null`.

---

### activePresenterId

- type: [`String?`](https://api.dart.dev/stable/2.15.1/dart-core/String-class.html)

- It will be the `id` of the participant who started `Presenting` / `Screen sharing` in the room. If no participant is sharing the screen, at that time value of `activePresenterId` will be `null`.

---

### camEnabled

- type: [`bool`](https://api.dart.dev/stable/2.15.1/dart-core/bool-class.html)
- It indicates if camera device is enabled or not.

---

### selectedCamId

- type: [`String?`](https://api.dart.dev/stable/2.15.1/dart-core/String-class.html)
- It will be the `id` of camera device, which is currently selected. 
---

### selectedCam

- type: `VideoDeviceInfo`
- It will be the object of the camera device, which is currently selected. 
---

### micEnabled

- type: [`bool`](https://api.dart.dev/stable/2.15.1/dart-core/bool-class.html)
- It indicates if microphone device is enabled or not.

---

### selectedMicId

- type: [`String?`](https://api.dart.dev/stable/2.15.1/dart-core/String-class.html)
- It will be the `id` of microphone, which is currently selected.

---

### selectedMic

- type: `AudioDeviceInfo`
- It will be the object of the microphone device, which is currently selected.

---

### localParticipant

- type: [Participant](../participant-class/introduction)

- It will be the instance of [Participant](../participant-class/introduction) class for the local participant(You) who joined the room.

---

### participants

- type: [`Map`](https://api.dart.dev/stable/2.15.1/dart-core/Map-class.html) of [`String`](https://api.dart.dev/stable/2.15.1/dart-core/String-class.html) and [Participant](../participant-class/introduction)

- `Map<String, Participant>`

  - Map{'<'}`participantId`, [Participant](../participant-class/introduction)>

- It will contain all joined participants in the room except the `localParticipant`.

- This will be the [`Map`](https://api.dart.dev/stable/2.15.1/dart-core/Map-class.html) what will container all participants attached with the key as id of that participant.

```javascript
String remoteParticipantId = "ajf897";

Participant? remoteParticipant = room.participants[remoteParticipantId];
```

---

### pinnedParticipants

- type: [`Map`](https://api.dart.dev/stable/2.15.1/dart-core/Map-class.html) of [`String`](https://api.dart.dev/stable/2.15.1/dart-core/String-class.html) and `ParticipantPinState`

- `Map<String, ParticipantPinState>`

  - Map{'<'}`participantId`, `ParticipantPinState`>

- It will contain all participants who are pinned in the room.

- This will be the [`Map`](https://api.dart.dev/stable/2.15.1/dart-core/Map-class.html) which will contain all participant who are currently pinned's pin state attached with the key as id of that

---

### hlsState

- type: String

- It will return the state of HLS for the room.

---

### liveStreamState

- type: String

- It will return the state of Live stream for the room.

---

### recordingState

- type: String

- It will return the state of Recording for the room.

---

### hlsDownstreamUrl

- type: String?

- It will return the downstream URL for the ongoing HLS of the room if any.

---

### pubSub

- type: [`PubSub`](../pubsub-class/introduction)
- It is used to enable Publisher-Subscriber feature in [`room`](introduction) class.

Learn more about `PubSub`, [here](../pubsub-class/introduction)

---

### selectedSpeakerId

- type: [`String?`](https://api.dart.dev/stable/2.15.1/dart-core/String-class.html)
- It will be the `id` of the speaker, which is currently selected.

---

### selectedSpeaker

- type: `AudioDeviceInfo`
- It will be the object of the speaker device, which is currently selected.

---

</div>


---

---
title: Installation Steps for RTC Flutter SDK
hide_title: false
hide_table_of_contents: false
description: RTC Flutter SDK provides client for almost all Android and IOS devices. it takes less amount of cpu and memory.
sidebar_label: Setup
pagination_label: Setup
keywords:
  - RTC FLUTTER
  - FLUTTER SDK
  - DART SDK
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: setup
---

# Setup - Flutter

Flutter SDK is client for real-time communication for android and ios devices. It inherits the same terminology as all other SDKs does.

## Minimum OS/SDK versions

Android: minSdkVersion >= 23

<!-- ### IOS: > 11 -->

## Use this package as a library

### Step 1: Add this package in your flutter project

Run this command:

```js
flutter pub add videosdk
```

This will add a line like this to your package's pubspec.yaml (and run an implicit flutter pub get):

```js
dependencies:
  videosdk: ^1.0.0
```

Alternatively, your editor might support or flutter pub get. Check the docs for your editor to learn more.

### Step 2: Import it

Now in your Dart code, you can use:

```js
import "package:videosdk/videosdk.dart";
```


---

---
title: Video SDK Stream Class
sidebar_position: 1
sidebar_label: Introduction
pagination_label: Video SDK Stream Class
---

# Video SDK Stream Class - Flutter

<div class="sdk-api-ref">

## Introduction

Stream class is responsible for handling audio, video and screen sharing streams.

Stream class defines instance of audio, video and shared screen stream of participants.

## Stream Properties

<div class="row">
<div class="col col--4 margin-bottom--sm" >

- [id](properties#id)

</div><div class="col col--4 margin-bottom--sm" >

- [kind](properties#kind)

</div><div class="col col--4 margin-bottom--sm" >

- [track](properties#track)

</div><div class="col col--4 margin-bottom--sm" >

- [renderer](properties#renderer)

</div>
</div>
</div>


---

---
title: Stream Class Properties
sidebar_position: 1
sidebar_label: Properties
pagination_label: Stream Class Properties
---

# Stream Class Properties - Flutter

<div class="sdk-api-ref-only-h4">

### id

- type: `String`

- Represents the id for that stream .

---

### kind

- type: `String?`

- `kind` represents the type of stream which could be `audio` | `video` or `share` .

---

### renderer

- type: `RTCVideoRenderer?`

- This is a renderer, which is passed to RTCVideoView widget.

---

### track

- type: `Consumer`

- It represents a single media track within a stream.

- You can call `pause()` method to pause MediaStreamTrack. And you can also call `resume()` method to resume MediaStreamTrack. [Learn more](../../../guide/video-and-audio-calling-api-sdk/features/pause-resume-video-stream)

</div>


---

---
title: Terminology - Video SDK Documentation
hide_title: true
hide_table_of_contents: false
description: Video SDK enables the opportunity to integrate native IOS, Android & Web SDKs to add live video & audio conferencing to your applications.
sidebar_label: Terminology
pagination_label: Terminology
keywords:
  - audio calling
  - video calling
  - real-time communication
  - collaboration
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: terminology
---

import Terminology from '../../../mdx/introduction/\_terminology.mdx';

<Terminology title="Terms related to VideoSDK - Flutter" />


---

---
sidebar_position: 1
sidebar_label: Events
pagination_label: VideoSDK Class Events
title: VideoSDK Class Events
---

# VideoSDK Class Events - Flutter

<div class="sdk-api-ref-only-h4">

<!-- ### mediaDevices

- type: [`Map<MediaDeviceType, List<MediaDeviceInfo>>`](https://api.dart.dev/stable/2.15.1/dart-core/Map-class.html)

- It contains all the connected media devices i.e. Video Devices, Audio Devices.

- This will be the [`Map`](https://api.dart.dev/stable/2.15.1/dart-core/Map-class.html) of `MediaDeviceType` and [`List<MediaDeviceInfo>`](https://api.flutter.dev/flutter/dart-html/MediaDeviceInfo-class.html).

```javascript
// Audio Devices
List<MediaDeviceInfo> audioDevices = VideoSDK.mediaDevices[MediaDeviceType.audioInput];

// Video Devices
List<MediaDeviceInfo> videoDevices = VideoSDK.mediaDevices[MediaDeviceType.videoInput];
```

--- -->

### deviceChanged

- `deviceChanged` event is emitted whenever any media devices, such as a camera, microphone or speaker is connected to or removed from the device.

:::info

- The `deviceChanged` event is not supported in macOS applications.

:::

#### Example

```js
VideoSDK.on(Events.deviceChanged, (devices) {
  print("device changed ${devices}");
});
```

:::info
Ensure that media permissions are granted on the device; otherwise, this event will not return the list of devices.
:::

---

### error

- This event will be emitted when and error occurs in the VideoSDK methods.

#### Example

```javascript
VideoSDK.on(Events.error, (error) {
  log("VIDEOSDK ERROR :: " +
      error['code'].toString() +
      "  :: " +
      error['name'].toString() +
      " :: " +
      error['message'].toString());
});
```


</div>


---

---
sidebar_position: 2
sidebar_label: Introduction
pagination_label: VideoSDK Class
title: VideoSDK Class
---

# VideoSDK Class - Flutter

<div div id="tailwind" class="sdk-api-ref">

## Introduction

VideoSDK Class is a core class of SDK that provides methods to create and configure [`VideoSDK Room`](../room-class/introduction).

import LinksGrid from '../../../../src/theme/LinksGrid'

<!-- ## VideoSDK Class Properties

<div class="row">

<div class="col col--4 margin-bottom--sm" >

- [mediaDevices](./properties#mediadevices)

</div>

</div> -->

## VideoSDK Class Methods

<div class="row">

<div class="col col--4 margin-bottom--sm" >

- [createRoom](./methods#createroom)

</div>

<!-- <div class="col col--4 margin-bottom--sm" >

- [loadMediaDevices](./methods#loadmediadevices)

</div> -->

<div class="col col--4 margin-bottom--sm" >

- [getDevices](./methods#getdevices)

</div>

<div class="col col--4 margin-bottom--sm" >

- [getVideoDevices](./methods#getvideodevices)

</div>

<div class="col col--4 margin-bottom--sm" >

- [getAudioDevices](./methods#getaudiodevices)

</div>

<div class="col col--4 margin-bottom--sm" >

- [checkPermissions](./methods#checkpermissions)

</div>

<div class="col col--4 margin-bottom--sm" >

- [requestPermissions](./methods#requestpermissions)

</div>

<div class="col col--4 margin-bottom--sm" >

- [checkBluetoothPermission](./methods#checkbluetoothpermission)

</div>

<div class="col col--4 margin-bottom--sm" >

- [requestBluetoothPermission](./methods#requestbluetoothpermission)

</div>

<div class="col col--4 margin-bottom--sm" >

- [on](./methods#on)

</div>

<div class="col col--4 margin-bottom--sm" >

- [createCameraVideoTrack](./methods#createcameravideotrack)

</div>

<div class="col col--4 margin-bottom--sm" >

- [createMicrophoneAudioTrack](./methods#createmicrophoneaudiotrack)

</div>

<div class="col col--4 margin-bottom--sm" >

- [applyVideoProcessor](./methods#applyvideoprocessor)

</div>

<div class="col col--4 margin-bottom--sm" >

- [removeVideoProcessor](./methods#removevideoprocessor)

</div>

</div>

## VideoSDK Class Events

<div class="row">

<div class="col col--4 margin-bottom--sm" >

- [deviceChanged](./events#devicechanged)

</div>

<div class="col col--4 margin-bottom--sm" >

- [error](./events#error)

</div>

</div>

## VideoSDK Native Android Methods

<div class="row">

<div class="col col--4 margin-bottom--sm" >

- [getInstance](./native-android-methods.md#getinstance)

</div>

<div class="col col--4 margin-bottom--sm" >

- [registerVideoProcessor](./native-android-methods.md#registervideoprocessor)

</div>

</div>

## VideoSDK Native iOS Methods

<div class="row">

<div class="col col--4 margin-bottom--sm" >

- [getInstance](./native-ios-methods.md#getinstance)

</div>

<div class="col col--4 margin-bottom--sm" >

- [registerVideoProcessor](./native-ios-methods.md#registervideoprocessor)

</div>

</div>

</div>


---

---
sidebar_position: 1
sidebar_label: Methods
pagination_label: VideoSDK Class Methods
title: VideoSDK Class Methods
---

# VideoSDK Class Methods - Flutter

<div class="sdk-api-ref-only-h4">

### createRoom()

- This method is provided by SDK to build instance of [`VideoSDK Room`](../room-class/introduction) based on given configuration.

#### Parameters

- roomId

  - type: [`String`](https://api.dart.dev/stable/2.15.1/dart-core/String-class.html)
  - `REQUIRED`
  - Id of the Room to be created.

- token

  - type: [`String`](https://api.dart.dev/stable/2.15.1/dart-core/String-class.html)
  - `REQUIRED`
  - Sets AuthToken, which is used for authentication purposes.

- displayName

  - type: [`String`](https://api.dart.dev/stable/2.15.1/dart-core/String-class.html)
  - `REQUIRED`
  - Sets name of the LocalParticipant to be displayed.

- notification

  - type: [`NotificationInfo`]
  - `OPTIONAL`
  - Sets configuration for the notification, that will be shown, while screen-sharing.

- micEnabled

  - type: [`bool`](https://api.dart.dev/stable/2.15.1/dart-core/bool-class.html)
  - `OPTIONAL`
  - Whether `mic` of the participant will be `on`, while joining the room. If it is set to `false`, then mic of that participant will be `disabled` by default, but can be `enabled` or `disabled` later.
  - Default value of `micEnabled` is true.

- camEnabled

  - type: [`bool`](https://api.dart.dev/stable/2.15.1/dart-core/bool-class.html)
  - `OPTIONAL`
  - Whether `camera` of the participant will be `on`, while joining the room. If it is set to `false`, then camera of that participant will be `disabled` by default, but can be `enabled` or `disabled`
  - Default value of `camEnabled` is true.

- multiStream

  - type: [`bool`](https://api.dart.dev/stable/2.15.1/dart-core/bool-class.html)
  - `OPTIONAL`
  - Default value is `true`.
  - It will specify if the stream should send multiple resolution layers or single resolution.

- participantId

  - type: [`String`](https://api.dart.dev/stable/2.15.1/dart-core/String-class.html)
  - `OPTIONAL`
  - Unique Id of the participant. If not passed then SDK will create an Id by itself and will use that id.

- maxResolution

  - type: [`String`](https://api.dart.dev/stable/2.15.1/dart-core/String-class.html)
  - `OPTIONAL`
  - Sets the maximum upload resolution of that participant's camera video stream.

- defaultCameraIndex

  - type: [`int`](https://api.dart.dev/stable/2.15.1/dart-core/int-class.html)
  - `OPTIONAL`
  - Sets camera, which will be used by default, while joining the VideoSDK Room.
  - Default value of `defaultCameraIndex` is `0`.

- customCameraVideoTrack

  - type: `CustomTrack`
  - `OPTIONAL`
  - Set the initial custom video track using different encoding parameters, camera facing mode, and optimization mode.

- customMicrophoneAudioTrack

  - type: `CustomTrack`
  - `OPTIONAL`
  - Set the initial custom audio track using different encoding parameters and optimization mode.

- mode

  - type: `Mode`
  - `OPTIONAL`
  - Set the participant mode i.e. `SEND_AND_RECV` or `SIGNALLING_ONLY`.
  - Default value is `SEND_AND_RECV`.

- metaData

  - type: `Map<String,dynamic>`
  - `OPTIONAL`
  - If you want to provide additional details about a user joining a meeting, such as their profile image, you can pass that information in this parameter.

- debugMode

  - type: `Boolean`
  - `OPTIONAL`
  - If you want to enable users to view detailed error logs generated by our SDK directly on the VideoSDK's dashboard, set this parameter to true. 

---

#### Returns

- _[`Room`](../room-class/introduction)_

#### Example

```js

CustomTrack? videoTrack = await VideoSDK.createCameraVideoTrack(
  encoderConfig: CustomVideoTrackConfig.h1440p_w1920p,
  multiStream: false,
);

//Creating Custom Audio Track
CustomTrack? audioTrack = await VideoSDK.createMicrophoneAudioTrack(
    encoderConfig: CustomAudioTrackConfig.high_quality);

// Create VideoSDK Room
Room room = VideoSDK.createRoom(
  roomId: "<ROOM-ID>",
  token: "<TOKEN>",
  displayName: "<DISPLAY-NAME>",
  micEnabled: false,
  camEnabled: false,
  maxResolution: 'hd',
  multiStream: false,
  defaultCameraIndex: 1, // Front Camera
  customCameraVideoTrack: videoTrack, // custom video track :: optional
  customMicrophoneAudioTrack: audioTrack, // custom audio track :: optional
  notification: const NotificationInfo(
    title: "Video SDK",
    message: "Video SDK is sharing screen in the room",
    icon: "notification_share",
  ),
  metaData: {},
  debugMode: true
);
```

---

<!-- ### loadMediaDevices()

- This method is used to load or refresh MediaDevices i.e. Audio Devices and Video Devices.

#### Returns

- _`Future<Map<MediaDeviceType, List<MediaDeviceInfo>>>`_

#### Example

```js
Map<MediaDeviceType, List<MediaDeviceInfo>> mediaDevices = await VideoSDK.loadMediaDevices();
```

--- -->

### getDevices()

- The `getDevices()` method returns a list of the currently available media input and output devices, such as microphones, cameras, headsets, and so forth. The method returns a list of `DeviceInfo` objects describing the devices.

- `DeviceInfo` class has four properties :

  1. `DeviceInfo.deviceId`

     - Returns a string that is an identifier for the represented device, persisted across sessions.

  2. `DeviceInfo.kind`

     - Returns an enumerated value that is either `videoinput` , `audiooutput` or `audioinput`.

  3. `DeviceInfo.label`

     - Returns a string describing this device (for example `BLUETOOTH`).

  4. `DeviceInfo.groupId`

     - Returns a string describing this group in which the device belongs (Two devices have the same groupId if they belong to the same physical device; for example, a monitor with both a built-in camera and microphone).

:::note

For iOS devices:

- `EARPIECE` is not supported whenever `WIRED_HEADSET` or `BLUETOOTH` device is connected.
- `WIRED_HEADSET` and `BLUETOOTH` devices are not supported simultaneously. Priority is given to the most recently connected device.

:::

#### Returns

- `Future<List<DeviceInfo>?>`

#### Example

```js
import 'package:videosdk/videosdk.dart';

void getDeviceList() async {
  try {
    List<DeviceInfo>? devices = await VideoSDK.getDevices();
  } catch (ex) {
    print("Error in getDevices ");
  }
}
```

---

### getVideoDevices()

- The `getVideoDevices` method returns a list of currently available video devices. The method returns a list of `VideoDeviceInfo` objects describing the video devices.

- `VideoDeviceInfo` class has four properties :

  1. `VideoDeviceInfo.deviceId`

     - Returns a string that is an identifier for the represented device, persisted across sessions.

  2. `VideoDeviceInfo.kind`

     - Returns an enumerated value that is `videoinput`.

  3. `VideoDeviceInfo.label`

     - Returns a string describing this device (for example `BLUETOOTH`).

  4. `VideoDeviceInfo.groupId`

     - Returns a string describing this group in which the device belongs (Two devices have the same groupId if they belong to the same physical device; for example, a monitor with both a built-in camera and microphone).

#### Returns

- `Future<List<VideoDeviceInfo>?>`

#### Example

```js
import 'package:videosdk/videosdk.dart';

void getVideoDeviceList() async {
  try {
    List<VideoDeviceInfo>? videoDevices = await VideoSDK.getVideoDevices();
  } catch (ex) {
    print("Error in getVideoDevices");
  }
}
```

---

### getAudioDevices()

- The `getAudioDevices` method returns a list of currently available audio devices. The method returns a list of `AudioDeviceInfo` objects describing the audio devices.

- `AudioDeviceInfo` class has four properties :

  1. `AudioDeviceInfo.deviceId`

     - Returns a string that is an identifier for the represented device, persisted across sessions.

  2. `AudioDeviceInfo.kind`

     - Returns an enumerated value that is `audioinput` or `audiooutput`.

  3. `AudioDeviceInfo.label`

     - Returns a string describing this device (for example `BLUETOOTH`).

  4. `AudioDeviceInfo.groupId`

     - Returns a string describing this group in which the device belongs (Two devices have the same groupId if they belong to the same physical device; for example, a monitor with both a built-in camera and microphone).

:::note

For iOS devices:

- `EARPIECE` is not supported whenever `WIRED_HEADSET` or `BLUETOOTH` device is connected.
- `WIRED_HEADSET` and `BLUETOOTH` devices are not supported simultaneously. Priority is given to the most recently connected device.

:::

#### Returns

- `Future<List<AudioDeviceInfo>?>`

#### Example

```js
import 'package:videosdk/videosdk.dart';
import 'dart:io';

List<AudioDeviceInfo> audioInputDevices = [];
List<AudioDeviceInfo> audioOutputDevices = [];

void getAudioDeviceList() async {
  try {
    // This function returns only `audiooutput` devices when executed on mobile platforms.
    List<AudioDeviceInfo>? audioDevices = await VideoSDK.getAudioDevices();
    for (AudioDeviceInfo device in audioDevices!) {
      // For Mobile Applications
      // Note: Changing the audioDevice using `switchAudioDevice()` will affect both the microphone and the speaker.
      if (!kIsWeb) {
        if (Platform.isAndroid || Platform.isIOS) {
          audioOutputDevices.add(device);
        }
      } else {
        // For Web and Desktop Applications
        // The input and output devices must be filtered separately to switch the respective device.
          if (device.kind == 'audioinput') {
            audioInputDevices.add(device);
          } else {
            audioOutputDevices.add(device);
          }
        }
      }
    }
  catch (ex) {
    print("Error in getAudioDevices ");
  }
}
```

---

### requestPermissions()

- The `requestPermissions()` method prompts the user for permission to access camera and microphone devices. It returns a `Map<String, bool>` object, where the keys in the map can be `'audio'` for the microphone and `'video'` for the camera.
- To enable requesting of microphone and camera permissions on iOS devices, add the following to your `Podfile`:

```js
post_install do |installer|
  installer.pods_project.targets.each do |target|
    flutter_additional_ios_build_settings(target)
    target.build_configurations.each do |config|
    //Add this into your podfile
      config.build_settings['GCC_PREPROCESSOR_DEFINITIONS'] ||= [
        'PERMISSION_CAMERA=1',
        'PERMISSION_MICROPHONE=1',
      ]
    end
  end
end
```

#### Parameters

- `Permissions`
  - A `Permissions` specifying the specific kinds of media, that you want to request.
  - `Optional`
  - Allowed Values : `audio` ,`video`,`audio_video`
  - Default : `audio_video`

#### Returns

- `Future<Map<String, bool>>`

:::info

- `requestPermissions()` method is not supported on Desktop Applications and Firefox Browser.

:::

#### Example

```js
import 'package:videosdk/videosdk.dart';

void requestMediaPermissions() async {
  try {
      //By default both audio and video permissions will be requested.
      Map<String, bool> reqPermissions = await VideoSDK.requestPermissions();
      //For requesting just audio permission.
      Map<String, bool> reqAudioPermissions = await VideoSDK.requestPermissions(Permissions.audio);
      //For requesting just video permission.
      Map<String, bool> reqVideoPermissions = await VideoSDK.requestPermissions(Permissions.video);
      //For requesting both audio and video permissions.
      Map<String, bool> reqAudioVideoPermissions = await VideoSDK.requestPermissions(Permissions.audio_video);

      print("Request Permissions ${reqAudioVideoPermissions['audio']} ${reqAudioVideoPermissions['video']} ");
  } catch (ex) {
    print("Error in requestPermission ");
  }
}
```

:::tip
`requestPermissions()` will throw an UnsupportedError when the Platform doesn't support permission request functionality.
:::

---

### checkPermissions()

- The `checkPermission()` method checks for permission to access camera and microphone devices. It returns a `Map<String, bool>` object, where the keys in the map can be `'audio'` for the microphone and `'video'` for the camera.
- To enable checking of microphone and camera permissions on iOS devices, add the following to your `Podfile`:

```js
post_install do |installer|
  installer.pods_project.targets.each do |target|
    flutter_additional_ios_build_settings(target)
    target.build_configurations.each do |config|
    //Add this into your podfile
      config.build_settings['GCC_PREPROCESSOR_DEFINITIONS'] ||= [
        'PERMISSION_CAMERA=1',
        'PERMISSION_MICROPHONE=1',
      ]
    end
  end
end
```

#### Parameters

- `Permissions`
  - A `Permissions` specifying the types of media to check.
  - `Optional`
  - Allowed Values : `audio` ,`video`,`audio_video`
  - Default : `audio_video`

#### Returns

- `Future<Map<String, bool>>`

:::info

- `checkPermissions()` method is not supported on Desktop Applications and Firefox Browser.

:::

#### Example

```js
import 'package:videosdk/videosdk.dart';

void checkMediaPermissions() async {
  try {
      //By default both audio and video permissions will be checked.
      Map<String, bool> checkPermissions = await VideoSDK.checkPermissions();
      //For checking just audio permission.
      Map<String, bool> checkAudioPermissions = await VideoSDK.checkPermissions(Permissions.audio);
      //For checking just video permission.
      Map<String, bool> checkVideoPermissions = await VideoSDK.checkPermissions(Permissions.video);
      //For checking both audio and video permissions.
      Map<String, bool> checkAudioVideoPermissions = await VideoSDK.checkPermissions(Permissions.audio_video);

      print("Check Permissions ${checkAudioVideoPermissions['audio']} ${checkAudioVideoPermissions['video']} ");
  } catch (ex) {
    print("Error in checkPermission ");
  }
}
```

:::tip
`checkPermissions()` will throw an UnsupportedError when the Platform doesn't support permission check functionality.
:::

---

### checkBluetoothPermission()

- The `checkBluetoothPermission` method checks if the application has permission to access Bluetooth on the device. It returns a boolean value indicating whether Bluetooth permission is granted or not.

#### Returns

- `Future<bool>`

:::info

- `checkBluetoothPermission()` method is only supported on Android devices running Android 12 or later.
  :::

#### Example

```js
import 'package:videosdk/videosdk.dart';

void checkBluetooth() async {
  try {
      bool bluetoothPerm = await VideoSDK.checkBluetoothPermission();
  } catch (ex) {
    print("Error in checkBluetoothPermission ");
  }
}
```

:::tip
`checkBluetoothPermission()` will throw an UnsupportedError when the Platform doesn't support bluetooth permission check functionality.
:::

---

### requestBluetoothPermission()

- The `requestBluetoothPermission()` method requests permission to access Bluetooth on the device. It returns a boolean value indicating whether the permission request was successful or not.

#### Returns

- `Future<bool>`

:::info

- `requestBluetoothPermission()` method is only supported on Android devices running Android 12 or later.

:::

#### Example

```js
import 'package:videosdk/videosdk.dart';

void requestBluetooth() async {
  try {
      bool bluetoothPerm = await VideoSDK.requestBluetoothPermission();
  } catch (ex) {
    print("Error in requestBluetoothPermission ");
  }
}
```

:::tip
`requestBluetoothPermission()` will throw an UnsupportedError when the Platform doesn't support bluetooth permission request functionality.
:::

---

### on()

- It is used to listen to `VideoSDK` related events and perform actions based on those events.

#### Parameters

- event

  - type: [`Events`](events)
  - This will specify the event to be listened. It defines which particular event from the VideoSDK class you are subscribing to.

- eventHandler
  - type: [`Function`](https://api.dart.dev/stable/2.15.1/dart-core/Function-class.html)
  - This will be invoked whenever the specified event occurs. The function is executed with relevant data whenever the event is triggered.

#### Returns

- _`void`_

#### Example

```js
VideoSDK.on(Events.deviceChanged, () {
  // do something
});
```

---

### createCameraVideoTrack

- You can create a Video Track using `createCameraVideoTrack()` method of `VideoSDK` class.
- This method can be used to create video track using different encoding parameters, camera facing mode, and optimization mode.

#### Parameters

- **cameraId**:

  - type: `String`
  - required: `false`
  - It will be the id of the camera from which the video should be captured.

- **encoderConfig**:

  - type: `CustomVideoTrackConfig`
  - required: `false`
  - default: `h360p_w640p`
  - Allowed values : `h90p_w160p` | `h180p_w320p` | `h216p_w384p` | `h360p_w640p` | `h540p_w960p` | `h720p_w1280p` | `h1080p_w1920p` | `h1440p_w2560p` | `h2160p_w3840p` | `h120p_w160p` | `h180p_w240p` | `h240p_w320p` | `h360p_w480p` | `h480p_w640p` | `h540p_w720p` | `h720p_w960p` | `h1080p_w1440p` | `h1440p_w1920p`
  - It will be the encoderConfigs you can want to use for the Video Track.

:::note

Above mentioned encoder configurations are valid for both, landscape as well as portrait mode.

:::

- **facingMode**:

  - type: `FacingMode`
  - required: `false`
  - Allowed values : `FacingMode.front` | `FacingMode.environment`
  - It will specify whether to use front or back camera for the video track.

- **multiStream**

  - type: `boolean`
  - required: `false`
  - default: true
  - It will specify if the stream should send multiple resolution layers or single resolution layer.

  :::info

  - For meetings with fewer than or equal to four participants, setting `multiStream:false` is regarded as best practice.
  - This parameter is only available from `v1.0.9`.

  :::

#### Returns

- `Future<CustomTrack?>`

#### Example

```javascript
CustomTrack? videoTrack = await VideoSDK.createCameraVideoTrack(
      encoderConfig: CustomVideoTrackConfig.h1440p_w1920p,
      multiStream: false,
      facingMode:"user",
    );
```

---

### createMicrophoneAudioTrack

- You can create a Audio Track using `createMicrophoneAudioTrack()` method of `VideoSDK` class.
- This method can be used to create audio track using different encoding parameters and noise cancellation configuration.

#### Parameters

- **microphoneId**:

  - type: `String`
  - required: `false`
  - It will be the id of the mic from which the audio should be captured.

- **encoderConfig**:

  - type: `CustomTrackAudioConfig`
  - required: `false`
  - default: `speech_standard`
  - Allowed values : `speech_low_quality` | `speech_standard` | `music_standard` | `standard_stereo` | `high_quality` | `high_quality_stereo`
  - It will be the encoder configuration you want to use for Audio Track.

- **noiseConfig**

  - **echoCancellation**

    - type: `boolean`
    - required: `false`
    - If `true` echo cancellation will turned on else it would be turned off.

  - **autoGainControl**

    - type: `boolean`
    - required: `false`
    - If `true` auto gain will turned on else it would be turned off.

  - **noiseSuppression**
    - type: `boolean`
    - required: `false`
    - If `true` noise suppression will turned on else it would be turned off.

#### Returns

- `Future<CustomTrack?>`

#### Example

```javascript
CustomTrack? audioTrack = await VideoSDK.createMicrophoneAudioTrack(
        encoderConfig: CustomAudioTrackConfig.high_quality);
```

### applyVideoProcessor

- This method enables the application of a video processor to incorporate effects into the video stream. It takes the name of a processor that was registered during initialization. 

:::info 

Only processors that have been registered during app initialization are available for use during the meeting. To learn how to register your own cutom video processor, check out this guide, for [Android](../../../guide/video-and-audio-calling-api-sdk/video-processor/android-setup.md) and  for [iOS](../../../guide/video-and-audio-calling-api-sdk/video-processor/ios-setup.md)

:::

#### Parameters

- **videoProcessorName**:

  - type: `String`
  - required: `true`
  - The name of the processor whose effect you wish to apply.
  
#### Returns

- `void`

#### Example

```javascript
VideoSDK.applyVideoProcessor(videoProcessorName: "VirtualBGProcessor");
```

### removeVideoProcessor

- This method removes a previously applied video processor from the video stream. This allows users to disable specific effects or revert to the original video state.
- The `removeVideoProcessor` method will remove the effect of the currently active video processor.
  
#### Returns

- `void`

#### Example

```javascript
VideoSDK.removeVideoProcessor();
```

</div>


---

---
sidebar_position: 1
sidebar_label: Native Android methods
pagination_label: VideoSDK Class Native Android Methods
title: VideoSDK Class Native Android Methods
---

# VideoSDK Class Native Android Methods - Flutter

<div class="sdk-api-ref-only-h4">

### getInstance()

- This method is used to get an instance of the `VideoSDK` class.


#### Returns

- `VideoSDK` instance

#### Example

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js "
val videoSDK = VideoSDK.getInstance()
```

</TabItem>

<TabItem value="Java">

```js "
VideoSDK videoSDK = VideoSDK.getInstance();
```

</TabItem>

</Tabs>

---

### registerVideoProcessor()

- This method is used to register your custom video processor during app initialization. It takes a string representing the unique processor name along with an instance of your processor to complete the registration. 

#### Parameters

- customVideoProcessorName

  - type: `String`
  - required: `true`
  - The name of the processor whose effect you wish to apply.

- customVideoProcessorInstance

  - required: `true`
  - The instance of the processor whose effect you wish to apply.


#### Returns

- `void`

#### Example

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js
val customVideoProcessor = CustomVideoProcessor()
val videoSDK = VideoSDK.getInstance()
videoSDK.registerVideoProcessor("customVideoProcessorName", customVideoProcessor)
```

</TabItem>

<TabItem value="Java">

```js 
CustomVideoProcessor customVideoProcessor = new CustomVideoProcessor();
VideoSDK videoSDK = VideoSDK.getInstance();
videoSDK.registerVideoProcessor("customVideoProcessorName", customVideoProcessor);
```

</TabItem>

</Tabs>

</div>


---

---
sidebar_position: 1
sidebar_label: Native iOS methods
pagination_label: VideoSDK Class Native iOS Methods
title: VideoSDK Class Native iOS Methods
---

# VideoSDK Class Native iOS Methods - Flutter

<div class="sdk-api-ref-only-h4">

### getInstance()

- This method is used to get an instance of the `VideoSDK` class.


#### Returns

- `VideoSDK` instance

#### Example

<Tabs
defaultValue="Swift"
groupId={"language"}
values={[{label: 'Swift', value: 'Swift'},]}>

<TabItem value="Swift">

```js "
let videoSDK = VideoSDK.getInstance
```
</TabItem>

</Tabs>

---

### registerVideoProcessor()

- This method is used to register your custom video processor during app initialization. It takes a string representing the unique processor name along with an instance of your processor to complete the registration. 

#### Parameters

- videoProcessorName

  - type: `String`
  - required: `true`
  - The name of the processor whose effect you wish to apply.

- videoProcessor

  - required: `true`
  - The instance of the processor whose effect you wish to apply.


#### Returns

- `void`

#### Example

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Swift"
groupId={"language"}
values={[{label: 'Swift', value: 'Swift'},]}>

<TabItem value="Swift">

```js title="AppDelegate.swift"
let customVideoProcessor = CustomVideoProcessor()
let videoSDK = VideoSDK.getInstance
videoSDK.registerVideoProcessor(videoProcessorName: "customVideoProcessorName", videoProcessor: customVideoProcessor)
```

</TabItem>

</Tabs>

</div>


---

---
title: VideoSDKMediaEffects Plugin
hide_title: true
hide_table_of_contents: false
description: The VideoSDKMediaEffects plugin enhances video applications by providing advanced media effects, including virtual backgrounds.
sidebar_label: VideoSDKMediaEffects Plugin
pagination_label: VideoSDKMediaEffects Plugin
keywords:
  - Apply Virtual Background
  - Remove Virtual Background
  - Change Virtual Background
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
---

# VideoSDKMediaEffects Plugin - Flutter

<div id="tailwind" class="sdk-api-ref">

## Introduction

The `VideoSDKMediaEffects` plugin enhances video applications with advanced media effects, including virtual backgrounds. Seamlessly integrating with your video SDK, it supports real-time processing and is optimized for Android and iOS devices, making it essential for adding professional-grade effects to mobile apps.

:::info

- The Virtual Background methods from the `VideoSDKMediaEffects` plugin are supported only on Android and iOS devices.
- The Virtual Background feature in VideoSDK can be utilized regardless of the meeting environment, including the pre-call screen.

:::

## VideoSDKMediaEffects Plugin Methods

<div class="sdk-api-ref-only-h4">

### applyVirtualBackground()

- This method allows users to dynamically apply virtual background to their video stream during a live session.

#### Parameters

- backgroundSource

  - type: [`Uri`](https://api.dart.dev/stable/3.4.4/dart-core/Uri-class.html)
  - `REQUIRED`
  - It specifies the URI of the background image to be used for the virtual background effect.

#### Returns

- _`void`_

#### Example

```js
Uri backgroundImageURI = Uri.parse("https://cdn.videosdk.live/virtual-background/cloud.jpeg");
VideosdkMediaEffects.applyVirtualBackground(backgroundSource: backgroundImageURI);
```
---

### changeVirtualBackground()

- This method allows users to easily switch their virtual background to a new image, enabling dynamic customization and enhancing the video experience.

#### Parameters

- backgroundSource

  - type: [`Uri`](https://api.dart.dev/stable/3.4.4/dart-core/Uri-class.html)
  - `REQUIRED`
  - It specifies the URI of the new background image that user wants to switch to, for virtual background effect.

#### Returns

- _`void`_

#### Example

```js
Uri newBackgroundImageURI = Uri.parse("https://cdn.videosdk.live/virtual-background/san-fran.jpeg");
VideosdkMediaEffects.changeVirtualBackground(backgroundSource: newBackgroundImageURI);
```
---

### removeVirtualBackground()

- This method provides users with a convenient way to revert their video background to its original state, removing any previously applied virtual background.

#### Returns

- _`void`_

#### Example

```js
VideosdkMediaEffects.removeVirtualBackground();
```


</div>
</div>


---

### 5.Errors associated with Media

These errors involve media access, device availability, or permission-related issues affecting camera, microphone, and screen sharing.

### Device permission-related errors
| Type                                      | Code  | Message                                          |
|-------------------------------------------|-------|--------------------------------------------------|
| ERROR_CAMERA_ACCESS_UNAVAILABLE          | 3005  | Camera access unavailable: Please ensure your device is compatible and that you're on a secure website (https://).                |
| ERROR_MICROPHONE_ACCESS_UNAVAILABLE      | 3006  | Microphone access unavailable: Please ensure your device is compatible and that you're on a secure website (https://).             |
| ERROR_CAMERA_ACCESS_DENIED_OR_DISMISSED      | 3007  | Camera access was denied or dismissed. To proceed, kindly grant access manually through your device/browser settings.. |
| ERROR_MICROPHONE_ACCESS_DENIED_OR_DISMISSED      | 3008  | Microphone access was denied or dismissed. To proceed, kindly grant access through your device/browser settings. |
| ERROR_CAMERA_PERMISSION_DENIED_BY_OS     | 3009  | Camera permission denied by OS system settings. Please check the system settings and grant permission for this browser. |
| ERROR_MICROPHONE_PERMISSION_DENIED_BY_OS | 3010  | Microphone permission denied by OS system settings. Please check the system settings and grant permission for this browser. |
| ERROR_SCREENSHARE_PERMISSION_DENIED  | 3014  | Screen sharing permission was denied. To enable screen sharing, please try again and grant the necessary permissions. |

### Device-related errors
| Type                        | Code  | Message                                          |
|-----------------------------|-------|--------------------------------------------------|
| ERROR_CAMERA_IN_USE          | 3003  | The camera is being used by another application. Please close any programs utilizing the camera, such as video conferencing tools, screen recording software, or other browsers. Restart your browser and attempt again. |
| ERROR_MICROPHONE_IN_USE      | 3004  | The microphone is being used by another application. Please close any programs utilizing the microphone, such as video conferencing tools, screen recording software, or other browsers. Restart your browser and attempt again. |
| ERROR_STARTING_VIDEO      | 3011  | Something went wrong, and the webCam could not be enabled. Please try again. |
| ERROR_STARTING_AUDIO      | 3012  | Something went wrong, and the microphone could not be enabled. Please try again. |
| ERROR_STARTING_SCREENSHARE      | 3013  | Something went wrong, and the screenshare could not be enabled. Please try again. |
| ERROR_CAMERA_DEVICE_INCOMPATIBLE       | 3019  | Camera device cannot produce video: Unable to produce video stream. Please ensure your device is compatible. |
| ERROR_MICROPHONE_DEVICE_INCOMPATIBLE   | 3020  | Microphone device cannot produce audio: Unable to produce audio stream. Please ensure your device is compatible. |
| ERROR_SCREENSHARE_NOT_SUPPORTED  | 3015  | Screenshare not supported: Unable to generate a screenshare stream. Please ensure your device/browser is compatible. |

### 6.Errors associated with Track

These errors occur when there are issues with video or audio tracks, such as disconnections or invalid custom tracks.

| Type                        | Code  | Message                                          |
|-----------------------------|-------|--------------------------------------------------|
| ERROR_CREATING_VIDEO_TRACK      | 3017  | An error occurred while creating the video track. Please try again. |
| ERROR_CREATING_AUDIO_TRACK      | 3018  | An error occurred while creating the audio track. Please try again. |
| ERROR_CUSTOM_VIDEO_TRACK_DISPOSED      | 3001  | The provided custom video track has been disposed of, and is now in an ended state. Reverting to the default video track. |
| ERROR_CUSTOM_AUDIO_TRACK_DISPOSED      | 3002  | The provided custom audio track has been disposed of, and is now in an ended state. Reverting to the default audio track. |


### 7.Errors associated with Actions

Below error is triggered when an action is attempted before joining a meeting.

| Type                        | Code  | Message                                          |
|-----------------------------|-------|--------------------------------------------------|
| ERROR_ACTION_PERFORMED_BEFORE_MEETING_JOINED     | 3022  | Oops! Something went wrong. The room was in a connecting state, and during that time, an action encountered an issue. Please try again after joining a meeting. |
| ERROR_JOINING_MEETING     | 3023  | Something went wrong. The meeting could not be joined. Please try again. |
| ERROR_CHANGING_MODE     | 3021  | Something went wrong, and the mode could not be changed. Please try again. |
| ERROR_STARTING_FOREGROUND_SERVICE | 3016 | An error occurred while initializing the foreground service, preventing screenshare from being enabled. Please try again. |


---

---
sidebar_label: App Size Optimization
pagination_label: App Size Optimization
---

# App Size Optimization - Flutter

This guide is designed to help developers optimize app size, enhancing performance and efficiency across different devices. By following these best practices, you can reduce load times, minimize storage requirements, and deliver a more seamless experience to users, all while preserving essential functionality.

### Deliver Leaner Apps with App Bundles

Using Android App Bundles (AAB) is an effective way to optimize the size of your application, making it lighter and more efficient for users to download and install. App Bundles allow Google Play to dynamically generate APKs tailored to each device, so users only download the resources and code relevant to their specific configuration. This approach reduces app size significantly, leading to faster installs and conserving storage space on users’ devices.

Recommended Practices:

- `Enable App Bundles`: Configure your build to use the App Bundle format instead of APKs. This will allow Google Play to optimize your app for each device type automatically.

- `Organize Resources by Device Type`: Ensure that resources (like images and layouts) are organized by device type (such as screen density or language) to maximize the benefits of App Bundles.

- `Test Modularization`: If your app contains large, optional features, use dynamic feature modules to let users download them on demand. This reduces the initial download size and provides features only as needed.

- `Monitor Size Reductions`: Regularly analyze your app size to see where the most savings occur, and make sure that App Bundle optimizations are effectively reducing your app size across different device configurations.

### Optimize Libraries for a Leaner App Experience

Managing dependencies carefully is essential for minimizing app size and improving performance. Every library or dependency included in your app adds to its overall size, so it’s crucial to only incorporate what’s necessary. Optimizing dependencies helps streamline your app, reduce load times, and enhance maintainability.

Recommended Practices:

- `Use Only Essential Libraries`: Review all libraries and dependencies, removing any that are not critical to your app’s functionality. This helps avoid unnecessary bloat.

- `Leverage Lightweight Alternatives`: Whenever possible, choose lightweight libraries or modularized versions of larger ones. For example, opt for a specific feature module rather than including an entire library.

- `Monitor Library Updates`: Regularly update your dependencies to take advantage of any optimizations or size reductions made by the library maintainers. Newer versions are often more efficient.

- `Minimize Native Libraries`: If your app uses native libraries, ensure they’re essential and compatible across platforms, as they can significantly increase app size.

- `Analyze Dependency Tree`: Use tools like Gradle’s dependency analyzer to identify unnecessary or redundant dependencies, ensuring your app’s dependency tree is as lean as possible.


### Optimize with ProGuard

ProGuard is a powerful tool for shrinking, optimizing, and obfuscating your code, which can significantly reduce your app's size and improve performance. By removing unused code and reducing the size of classes, fields, and methods, ProGuard helps to minimize the footprint of your app without sacrificing functionality. Additionally, ProGuard’s obfuscation feature enhances security by making reverse engineering more difficult. You can refer to the official [documentation](https://developer.android.com/build/shrink-code) for more information.

Recommended Practices:

- `Enable ProGuard`: To enable ProGuard in your project, ensure that your `proguard-rules.pro` file is properly configured, and add the following lines to your `build.gradle` file:

```js title="build.gradle"
buildTypes {
    release {
        minifyEnabled true
        proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'
    }
}
```

- `Customize ProGuard Rules`: Carefully review and customize ProGuard rules in the proguard-rules.pro file to avoid stripping essential code. For example, to keep a specific class, add:

```js
-keep class com.example.myapp.MyClass { *; }
```

---

---
sidebar_label: Developer Experience Guidelines
pagination_label: Developer Experience Guidelines
---

# Developer Experience Guidelines - Flutter

This section provides best practices for creating a smooth and efficient development process when working with VideoSDK. From handling errors gracefully to managing resources and event subscriptions, these guidelines help developers build more reliable and maintainable applications. Following these practices can simplify troubleshooting, prevent common pitfalls, and improve overall application performance.

### Initiate Key Features After Meeting Join Event

To provide a seamless and reliable meeting experience, initiate specific features **only** after the [roomJoined](https://docs.videosdk.live/flutter/api/sdk-reference/room-class/events#roomjoined) event has been triggered.

- **Trigger Key Actions After Joining the Meeting** : Initiating crucial actions after the `roomJoined` event helps avoid errors and optimizes the meeting setup, ensuring a smoother experience for participants. If your application utilizes any of the following features or you want to perform any action as soon as meeting joins, it's recommended to call them only after the meeting has successfully started:

    - `Chat Subscription`: To enable in-meeting chat functionality, subscribe to the chat topic after the `roomJoined` event is triggered. This ensures that messages are reliably received by participants.

    <br/>
    <div style={{textAlign: 'center'}}>

    <img src="https://cdn.videosdk.live/docs/best-practices/mobile/flutter_chat_correct_incorrect_code.png" />

    </div>

    - `Device Management`: If you need users to use specific audio or video devices when the meeting is first joined, you can utilize the custom track. Pass the `cameraId` to the [createCameraVideoTrack()](https://docs.videosdk.live/flutter/api/sdk-reference/custom-tracks#custom-video-track---flutter) method for video, and the `microphoneId` to the [createMicrophoneAudioTrack()](https://docs.videosdk.live/flutter/api/sdk-reference/custom-tracks#custom-audio-track---flutter) method for audio. Once the track is created, provide it to the [createRoom()](https://docs.videosdk.live/flutter/api/sdk-reference/videosdk-class/methods#createroom) method.

    - `Recording and Transcription`: To automatically start recording or transcription as soon as the meeting begins, configure the `autoStartConfig` in the `createMeeting` API. For detailed information, refer to the documentation [here](https://docs.videosdk.live/api-reference/realtime-communication/create-room#autoCloseConfig).

### Dispose Custom Tracks When Necessary

Proper disposal of custom tracks is essential for managing system resources and ensuring a smooth experience. In most scenarios, tracks are automatically disposed of by the SDK, ensuring efficient resource management. However, in specific cases outlined below, you will need to dispose of custom tracks explicitly:

1. **When Enabling/Disabling the Camera on a Precall Screen**:
    - If your application includes a precall screen and you want to ensure that the device's camera is not used when the camera is disabled, you must dispose of the custom video track. Otherwise, the device’s camera will continue to be used even when the camera is off.
    - Additionally, remember to create a new track when the user enables the camera again.
    - If you don’t need to manage the camera's usage on the device level (i.e., you’re okay with the camera being used whether it’s enabled or disabled), you can skip this step.
    - Here's how you can manage customTrack on a precall screen :

    <br/>
    ```js
    class _JoinScreenState extends State<JoinScreen> with WidgetsBindingObserver {
        bool isCameraOn = false;
        CustomTrack? cameraTrack;
        // Renderer to display the camera video feed
        RTCVideoRenderer? cameraRenderer;

        @override
        Widget build(BuildContext context) {
            // Build the UI components for the join screen
            //...
        }

        void toggleCamera() async {
            if (isCameraOn)
            {
                cameraTrack?.dispose(); // Dispose of cameraTrack
                setState(() {
                    cameraRenderer = null;
                    cameraTrack = null;
                    isCameraOn = false;
                });
            }
            else {
                // Create a new camera track and renderer
                CustomTrack? track = await VideoSDK.createCameraVideoTrack(
                    // passes deviceId of the user's selected device
                    cameraId: selectedVideoDevice?.deviceId
                );
                RTCVideoRenderer render = RTCVideoRenderer();
                await render.initialize();
                render.setSrcObject(
                    stream: track?.mediaStream, // Set the media stream from the camera track
                    trackId: track?.mediaStream.getVideoTracks().first.id // Set the video track ID
                );
                setState(() {
                    cameraTrack = track;
                    cameraRenderer = render;
                    isCameraOn = true;
                });
            }
        }
    }
    ```

### Listen for Error Events

Listening to error events enables your application to handle unexpected issues efficiently, providing users with clear feedback and potential solutions. Error codes pinpoint specific problems, whether from configuration settings, account restrictions, permission limitations, or device constraints. Here are recommended solutions based on common error categories:

1. [Errors associated with Organization](../../api/sdk-reference/error-codes.md#1-errors-associated-with-organization): If you encounter errors related to your organization (e.g., account status or participant limits), reach out to support at support@videosdk.live or reach out to us on [Discord](https://discord.com/invite/Qfm8j4YAUJ) for assistance.

2. [Errors associated with Token](../../api/sdk-reference/error-codes#2-errors-associated-with-token): For errors related to authentication tokens, ensure the token is valid and hasn’t expired, then try the request again.

3. [Errors associated with Meeting and Participant](../../api/sdk-reference/error-codes#3-errors-associated-with-meeting-and-participant): Check that meetingId and participantId are correctly passed and valid. Also, ensure each participant has a unique participantId to avoid duplicate entries.

4. [Errors associated with Add-on Service](../../api/sdk-reference/error-codes#4-errors-associated-with-add-on-service): If you encounter errors with add-on services (such as recording or streaming), try restarting the service after receiving a failure event. For example, if a `START_RECORDING_FAILED` error event occurs, attempt to call the `startRecording()` method again. If you're using webhooks, you can also retry on [recording-failed](https://docs.videosdk.live/api-reference/realtime-communication/user-webhooks#recording-failed) hook.

5. [Errors associated with Media](../../api/sdk-reference/error-codes#5errors-associated-with-media): Inform the user about media access issues, such as microphone or camera permissions. Design the UI to clearly indicate what is preventing the mic or camera from enabling, helping the user understand the problem.

6. [Errors associated with Track](../../api/sdk-reference/error-codes#6errors-associated-with-track): Ensure that the track you’ve created and passed to enable the mic or camera methods meets the required specifications.

7. [Errors associated with Actions](../../api/sdk-reference/error-codes#7errors-associated-with-actions): If you need to perform actions as soon as a meeting joins, only initiate them after receiving the [roomJoined](https://docs.videosdk.live/android/api/sdk-reference/meeting-class/meeting-event-listener-class#onmeetingjoined) event, otherwise it will not work well.

- Here's how to listen for the error event:

```js
import 'dart:developer';

import 'package:flutter/material.dart';
import 'package:videosdk/videosdk.dart';

class MeetingScreen extends StatefulWidget {
  //Existing configuration
}

class _MeetingScreenState extends State<MeetingScreen> {
  late Room room;

  @override
  void initState() {
    //Existing configuration
    
    setupVideoSDKEventListener();
    setupRoomEventListener();
  }

  @override
  Widget build(BuildContext context) {
    return YourMeetingWidget();
  }

  void setupVideoSDKEventListener() {
    VideoSDK.on(Events.error, (error) {
      log("VIDEOSDK ERROR :: ${error['code']}  :: ${error['name']} :: ${error['message']}");
    });
  }

  void setupRoomEventListener() {
    room.on(Events.error, (error) {
      log("VIDEOSDK ERROR :: ${error['code']}  :: ${error['name']} :: ${error['message']}");
    });
  }
}
```

---

---
sidebar_label: Handle Large Rooms
pagination_label: Handle Large Rooms
---

# Handle Large Rooms - Flutter

Managing large meetings requires specific strategies to ensure performance, stability, and a seamless user experience. This section provides best practices for optimizing VideoSDK applications to handle high participant volumes effectively. By implementing these recommendations, you can reduce lag, maintain video and audio quality, and provide a smooth experience even in large rooms.

### User Interface Optimization

When hosting large meetings, an optimized UI helps manage participant visibility and ensures smooth performance.

Recommended Practices:

- `Limit Visible Participants`: Display only a limited number of participants on screen at any given time, adapting the view based on screen size. Use pagination to allow users to browse or switch between additional participants seamlessly. For example, you could display only users whose video stream is enabled, or you could choose to display all active speakers. This approach helps manage screen space efficiently, ensuring that the most relevant participants are visible without overwhelming the interface.
- `Prioritize Active Speakers`: Ensure all active speakers are displayed on the screen to highlight who is currently talking, helping participants stay engaged and aware of ongoing discussions. To identify which participant is speaking, you can use the [speakerChanged](https://docs.videosdk.live/flutter/api/sdk-reference/room-class/events#speakerchanged) event.

### Optimizing Media Streams 

In large video calls, it’s important to manage media streams effectively to optimize system resources while maintaining a smooth user experience. 

Recommended Practices:

- `Pause Streams for Non-Visible Participants`: To optimize performance, pause the video and/or audio streams of participants who are not currently visible on the screen. This reduces unnecessary resource consumption.
- `Resume Streams When Visible`: Once a participant comes into view, resume their stream to provide an uninterrupted experience as they appear on the screen.

For detailed setup instructions on how to achieve this, check out our in-depth documentation [here](https://docs.videosdk.live/flutter/guide/video-and-audio-calling-api-sdk/render-media/layout-and-grid-management#grid-with-pagination).

### Media Stream Quality Adjustment

In large meetings, managing media stream quality is essential to balance performance and user experience. 

Recommended Practices:

- `High Quality for Active Speakers`: For all active speakers, set the video stream quality to a higher level using the setQuality method (e.g., `setQuality("high")`). This ensures that participants will receive higher-quality video for active speakers, providing a clearer and more engaging experience.
- `Lower Quality for Non-Speaking Participants`: For other participants who are not actively speaking, set their video stream quality to a lower level (e.g., `setQuality("low")`). This helps conserve bandwidth and system resources while maintaining overall meeting performance.

Checkout the documentation for `setQuality()` method [here](https://docs.videosdk.live/flutter/api/sdk-reference/participant-class/methods#setquality) 

---

---
sidebar_label: User Experience Guidelines
pagination_label: User Experience Guidelines
---

# User Experience Guidelines - Flutter

This guide aims to help developers optimize the user experience and functionality of video conferencing applications with VideoSDK. By following these best practices, you can create smoother interactions, minimize common issues, and deliver a more reliable experience for users.

Here are our recommended best practices to enhance the user experience in your application:

| **Section**                          | **Description**                                                                                                                                                      |
|--------------------------------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| [Configure Precall for Effortless Meeting Join](#configure-precall-for-effortless-meeting-join) | Users may enter meetings unprepared due to device or connection issues. A Precall setup can help them configure devices and settings beforehand for a smooth start. |
| [Listen Key Events for Optimal User Experience](#listen-key-events-for-optimal-user-experience) | Users can feel lost without real-time updates on meeting status, events, and errors. Event monitoring and notifications keep them informed and engaged.              |
| [Handling Media Devices](#handling-media-devices)                                             | Users may want to change their audio or video setup mid-meeting but struggle to manage device controls. Providing easy device switching enhances control and flexibility. |
| [Monitoring Real-Time Participant Statistics](#monitoring-real-time-participant-statistics)   | Poor video or audio quality without real-time feedback leaves users frustrated. Real-time stats let them assess connection quality and troubleshoot issues actively.    |

### Configure Precall for Effortless Meeting Join

A Precall step is crucial for ensuring users are set up correctly and have no device before joining a meeting. This step allows users to configure their devices and settings before entering a meeting, leading to a smoother experience and minimizing technical issues once the call begins.

Recommended Practices:

- `Request Permissions`: Prompt users to grant microphone, and camera permissions before entering the meeting, ensuring seamless access to their devices.
- `Device Selection`: Allow users to select their preferred camera, and microphone giving them control over their setup from the start.
- `Entry Preferences`: Provide options to join with the microphone and camera either on or off, letting users choose their level of engagement upon entry.
- `Camera Preview`: Show a live camera preview, allowing users to adjust angles and lighting to ensure they appear clearly and professionally.
- `Virtual Backgrounds`: Allow users to choose from different virtual backgrounds or enter with a virtual background enabled, enhancing privacy and creating a more polished appearance.

For detailed setup instructions on each of these features, check out our in-depth documentation [here](https://docs.videosdk.live/flutter/guide/video-and-audio-calling-api-sdk/setup-call/precall).

<div style={{textAlign: 'center'}}>

<img height="400" src="https://cdn.videosdk.live/docs/best-practices/mobile/mobile_precall.gif" />

</div>

### Monitor Key Events for Optimal User Experience

Listening for crucial events is vital for providing users with a responsive and engaging experience in your application. By effectively managing state changes and user notifications, you can keep participants informed and enhance their overall experience during meetings.

Recommended Practices:

- `Monitor State Change Events`: Listen for state change events, such as `Events.recordingStateChanged`, and notify users promptly about these transitions. Keeping users informed helps them understand the current state of the meeting.

<div style={{textAlign: 'center'}}>

<img height="400" src="https://cdn.videosdk.live/docs/best-practices/mobile/mobile_meeting_state.jpg" />

</div>

- `UI Handling on Event Trigger`: Update the user interface only in response to specific events. For instance, display that the meeting is recording only when the `recordingStateChanged` event with the status `RECORDING_STARTED` is received, rather than when the record button is clicked. This ensures users receive accurate and timely updates.

<div style={{textAlign: 'center'}}>

<img height="400" src="https://cdn.videosdk.live/docs/best-practices/mobile/mobile_recording.gif" />

</div>

- `Notify Participants of Join/Leave Events`: Keep users informed about participant activity by notifying them when someone joins or leaves the meeting. This fosters a sense of presence and awareness of who is currently available to engage.
- `Listen for Error Events`: It is crucial to monitor error events and notify users promptly when issues arise. Clear communication about errors can help users troubleshoot and address problems quickly, minimizing disruptions to the meeting.


### Handling Media Devices

Providing seamless control over devices enhances user convenience and allows participants to adjust their setup for the best meeting experience. Proper device management within the UI also helps users stay informed about their current settings and troubleshoot issues effectively.

Recommended Practices:

- `Allow Device Switching`: Provide users with the option to switch between available microphone, and camera devices during the meeting. This flexibility is essential, especially if users want to adjust their setup mid-call.
- `Display Selected Devices`: Ensure the UI shows users which microphone, and camera devices are currently selected. Clear device labeling in the interface can reduce confusion and help users verify their setup at a glance.

<div style={{textAlign: 'center'}}>

<img height="400" src="https://cdn.videosdk.live/docs/best-practices/mobile/mobile_audio_selected_device.jpg" />

</div>

### Monitoring Real-Time Participant Statistics

Providing real-time insights into stream quality allows participants to monitor and optimize their connection for the best experience. With detailed metrics on video, audio, and screen sharing, users can assess and troubleshoot quality issues, ensuring smooth and uninterrupted meetings. To display these statistics, you can use the [getVideoStats()](https://docs.videosdk.live/flutter/api/sdk-reference/participant-class/methods#getvideostats), [getAudioStats()](https://docs.videosdk.live/flutter/api/sdk-reference/participant-class/methods#getaudiostats), and [getShareStats()](https://docs.videosdk.live/flutter/api/sdk-reference/participant-class/methods#getsharestats) methods.

import ReactPlayer from 'react-player'

<div style={{textAlign: 'center'}}>

<ReactPlayer autoplay muted loop playing url='https://cdn.videosdk.live/docs/best-practices/mobile/mobile_call-stats.mp4' width={"100%"}/>

</div>

<br/>



---

---
sidebar_label: Face Match API (BETA)
pagination_label: Face Match API (BETA)
---

# Face Match API (BETA)

import FaceMatchApi from '../../../mdx/\_api-face-match.mdx';

<FaceMatchApi/>


---

---
sidebar_label: Face Spoof Detection API (BETA)
pagination_label: Face Spoof Detection API (BETA)
---

# Face Spoof Detection (BETA)

import FaceSpoofDetection from '../../../mdx/\_api-spoof-detection.mdx';

<FaceSpoofDetection/>


---

---
sidebar_label: Number of Face Detection API (BETA)
pagination_label: Number of Face Detection API (BETA)
---

# Number of Face Detection (BETA)

import NoOfFaceDetectionApi from '../../../mdx/\_api-number-of-face-detection.mdx';

<NoOfFaceDetectionApi/>


---

---
sidebar_label: OCR API (BETA)
pagination_label: OCR API (BETA)
---

# OCR API (BETA)

import OcrApi from '../../../mdx/\_api-ocr.mdx';

<OcrApi/>


---

---
title: Customized Live Stream
sidebar_position: 1
sidebar_label: Customized Live Stream
hide_table_of_contents: false
---

# Customized Live Stream - Flutter

VideoSDK is a platform that offers a range of video streaming tools and solutions for content creators, publishers, and developers.

### Custom Template

- Custom template is template for live stream, which allows users to add real-time graphics to their streams.
- With custom templates, users can create unique and engaging video experiences by overlaying graphics, text, images, and animations onto their live streams. These graphics can be customized to match the branding.
- Custom templates enable users to create engaging video content with real-time graphics, with live scoreboards, social media feeds, and other customizations, users can easily create unique and visually appealing streams that stands out from the crowd.

:::note

Custom templates can be used with recordings and RTMP service provided by VideoSDK as well.

:::

### What you can do with Custom Template

Using a custom template, you may create a variety of various modes. Here are a few of the more well-known modes that you can create.

- **`PK Host:`** Host can organise player vs player battle. Below image is example of gaming battle.

- **`Watermark:`** Host can add & update watermark anywhere in the template. In below image we have added VideoSDK watermark on top right side of the screen.

- **`News Mode:`** Host can add dynamic text in lower third banner. in below image we have added some sample text in bottom left of the screen.

![Mobile Custom Template](https://cdn.videosdk.live/website-resources/docs-resources/mobile_custom_template.png)

### Custom template with VideoSDK

In this section, we will discuss how Custom Templates work with VideoSDK.

- **`Host`**: The host is responsible for starting the live streaming by passing the `templateURL`. The `templateURL` is the URL of the hosted template webpage. The host is also responsible for managing the template, such as changing text, logos, and switching template layout, among other things.

- **`VideoSDK Template Engine`** : The VideoSDK Template Engine accepts and opens the templateURL in the browser. It listens to all the events performed by the Host and enables customization of the template according to the Host's preferences.

- **`Viewer`**: The viewer can stream the content. They can watch the live stream with the added real-time graphics, which makes for a unique and engaging viewing experience.

![custom template](https://cdn.videosdk.live/website-resources/docs-resources/custom_template.png)

### Understanding Template URL

The template URL is the webpage that VideoSDK Template Engine will open while composing the live stream.

The template URL will appear as shown below.

![template url](https://cdn.videosdk.live/website-resources/docs-resources/custom_template_url.png)

The Template URL consists of two parts:

- Your actual page URL, which will look something like `https://example.com/videosdk-template`.
- Query parameters, which will allow the VideoSDK Template Engine to join the meeting when the URL is opened. There are a total of three query parameters:
  - `token`: This will be your token, which will be used to join the meeting.
  - `meetingId`: This will be the meeting ID that will be joined by the VideoSDK Template Engine.
  - `participantId`: This will be the participant ID of the VideoSDK Template Engine, which should be passed while joining the template engine in your template so that the tempalte engine participant is not visible to other participants. **This parameter will be added by the** **VideoSDK**.

:::info

Above mentioned query parameters are mandatory. Apart from these parameters, you can pass any other extra parameters which are required according to your use-case.

:::

### **Creating Template**

**`Step 1:`** Create a new React App using the below command

```js
npx create-react-app videosdk-custom-template
```

:::note

You can use VideoSDK's React or JavaScript SDK to create custom template. Following is the example of building custom template with React SDK.

:::

**`Step 2:`** Install the VideoSDK using the below-mentioned npm command.

Make sure you are in your react app directory before you run this command.

```js
npm install "@videosdk.live/react-sdk"

//For the Participants Video
npm install "react-player"
```

###### App Architecture

![template architechture](https://cdn.videosdk.live/website-resources/docs-resources/custom_template_arch.png)

###### Structure of the Project

```jsx title="Project Structure"
   root
   ├── node_modules
   ├── public
   ├── src
   │    ├── components
   │          ├── MeetingContainer.js
   │          ├── ParticipantsAudioPlayer.js
   │          ├── ParticipantsView.js
   │          ├── Notification.js
   │    ├── icons
   │    ├── App.js
   │    ├── index.js
   ├── package.json
   .
```

**`Step 3:`** Next we will fetch the query parameters, from the URL which we will later use to initialize the meeting

```js title=App.js
function App() {
  const { meetingId, token, participantId } = useMemo(() => {
    //highlight-start
    const location = window.location;

    const urlParams = new URLSearchParams(location.search);

    const paramKeys = {
      meetingId: "meetingId",
      token: "token",
      participantId: "participantId",
    };

    Object.keys(paramKeys).forEach((key) => {
      paramKeys[key] = urlParams.get(key)
        ? decodeURIComponent(urlParams.get(key))
        : null;
    });

    return paramKeys;
    //highlight-end
  }, []);
}
```

**`Step 4:`** Now we will initialize the meeting with the parameters we extracted from the URL. Make sure `joinWithoutUserInteraction` is specified, so that the template engine is able to join directly into the meeting, on the page load.

```js title=App.js
function App(){
//highlight-next-line
...

return meetingId && token && participantId ? (
  <div>
    <MeetingProvider
      //highlight-start
      config={{
        meetingId,
        micEnabled: false,
        webcamEnabled: false,
        name: "recorder",
        participantId,
      }}
      token={token}
      joinWithoutUserInteraction
      //highlight-end
    >
      {/* We will create this in upcoming steps */}
      <MeetingContainer />
    </MeetingProvider>
  </div>
) : null;

}
```

**`Step 5:`** Let us create the `MeetingContainer` which will render the meeting view for us.

- It will also listen to the PubSub messages from the `CHANGE_BACKGROUND` topic, which will change the background color of the meeting.
- It will have `Notification` component which will show any messages share by Host

:::note

We will be using the PubSub mechanism to communicate with the template. You can learn more about [PubSub from here](../video-and-audio-calling-api-sdk/collaboration-in-meeting/pubsub).

:::

```js title=MeetingContainer.js
import { Constants, useMeeting, usePubSub } from "@videosdk.live/react-sdk";
import { Notification } from "./Notification";
import { ParticipantsAudioPlayer } from "./ParticipantsAudioPlayer";
import { ParticipantView } from "./ParticipantView";

export const MeetingContainer = () => {
  const { isMeetingJoined, participants, localParticipant } = useMeeting();
  //highlight-next-line
  const { messages } = usePubSub("CHANGE_BACKGROUND");

  const remoteSpeakers = [...participants.values()].filter((participant) => {
    return participant.mode == Constants.modes.SEND_AND_RECV && !participant.local;
  });

  return isMeetingJoined ? (
    <div
      style={{
        display: "flex",
        flexDirection: "column",
        height: "100vh",
        //highlight-start
        backgroundColor:
          messages.length > 0
            ? messages.at(messages.length - 1).message
            : "#fff",
        //highlight-end
      }}
    >
      //highlight-next-line
      <ParticipantsAudioPlayer />
      <div
        style={{
          display: "grid",
          gridTemplateColumns: remoteSpeakers?.length > 1 ? "1fr 1fr" : "1fr",
          flex: 1,
          maxHeight: `100vh`,
          overflowY: "auto",
          gap: "20px",
          padding: "20px",
          alignItems: "center",
          justifyItems: "center",
        }}
      >
        {[...remoteSpeakers].map((participant) => {
          return (
            //highlight-start
            <ParticipantView
              key={participant.id}
              participantId={participant.id}
            />
            //highlight-end
          );
        })}
      </div>
      //highlight-next-line
      <Notification />
    </div>
  ) : (
    <div
      style={{
        display: "flex",
        justifyContent: "center",
        alignItems: "center",
        height: "100vh",
      }}
    >
      <div class="loader"></div>
    </div>
  );
};
```

**`Step 6:`** Let us create the `ParticipantView` and `ParticipantsAudioPlayer` which will render the video and audio of the participants respectively.

```js title=ParticipantView.js
import { useParticipant } from "@videosdk.live/react-sdk";
import { useMemo } from "react";
import ReactPlayer from "react-player";
import MicOffIcon from "../icons/MicOffIcon";

export const ParticipantView = (props) => {
  const { webcamStream, webcamOn, displayName, micOn } = useParticipant(
    props.participantId
  );

  const videoStream = useMemo(() => {
    if (webcamOn && webcamStream) {
      const mediaStream = new MediaStream();
      mediaStream.addTrack(webcamStream.track);
      return mediaStream;
    }
  }, [webcamStream, webcamOn]);

  return (
    <div
      style={{
        width: "100%",
        height: "400px",
        maxWidth: "600px",
        display: "flex",
        flex: 1,
        alignItems: "center",
        justifyContent: "center",
        position: "relative",
        backgroundColor: "#1A1C22",
        borderRadius: "10px",
        overflow: "hidden",
      }}
      class="video-cover"
    >
      {webcamOn && webcamStream ? (
        <ReactPlayer
          //
          playsinline // extremely crucial prop
          pip={false}
          light={false}
          controls={false}
          muted={true}
          playing={true}
          //
          url={videoStream}
          //
          height={"100%"}
          width={"100%"}
          onError={(err) => {
            console.log(err, "participant video error");
          }}
        />
      ) : (
        <div
          style={{
            fontSize: "50px",
            color: "#fff",
          }}
        >
          {String(displayName).charAt(0).toUpperCase()}
        </div>
      )}
      <div
        style={{
          position: "absolute",
          left: "10px",
          bottom: "10px",
          backgroundColor: "#050A0E",
          color: "#fff",
          padding: "4px",
          borderRadius: "4px",
          alignItems: "center",
          justifyItems: "center",
          display: "flex",
        }}
      >
        {displayName}{" "}
        {!micOn && <MicOffIcon fillcolor="#fff" height="18" width="18" />}
      </div>
    </div>
  );
};
```

```js title=ParticipantsAudioPlayer.js
import { useMeeting, useParticipant } from "@videosdk.live/react-sdk";
import { useEffect, useRef } from "react";

const ParticipantAudio = ({ participantId }) => {
  const { micOn, micStream, isLocal } = useParticipant(participantId);
  const audioPlayer = useRef();

  useEffect(() => {
    if (!isLocal && audioPlayer.current && micOn && micStream) {
      const mediaStream = new MediaStream();
      mediaStream.addTrack(micStream.track);

      audioPlayer.current.srcObject = mediaStream;
      audioPlayer.current.play().catch((err) => {});
    } else {
      audioPlayer.current.srcObject = null;
    }
  }, [micStream, micOn, isLocal, participantId]);

  return <audio autoPlay playsInline controls={false} ref={audioPlayer} />;
};

export const ParticipantsAudioPlayer = () => {
  const mMeeting = useMeeting();

  const participants = mMeeting?.participants;

  return participants ? (
    [...participants.keys()].map((participantId) => (
      <ParticipantAudio
        key={`participant_audio_${participantId}`}
        participantId={participantId}
      />
    ))
  ) : (
    <></>
  );
};
```

**`Step 7:`** Let us create the `Notification` component which will listen to PubSub messages for the topic `SIGNALLING_ONLY_MESSAGE` and show a notification on the lower left corner.

```js title=Notification.js
import { usePubSub } from "@videosdk.live/react-sdk";
import { useEffect, useRef, useState } from "react";

export const Notification = () => {
  const timeoutRef = useRef(null);
  const handleChatMessage = (msg) => {
    if (timeoutRef.current) {
      clearTimeout(timeoutRef.current);
    }
    setMessage(msg);
    timeoutRef.current = setTimeout(() => {
      setMessage(null);
    }, 3200);
  };
  const [message, setMessage] = useState(null);
  const { publish } = usePubSub("SIGNALLING_ONLY_MESSAGE", {
    onMessageReceived: handleChatMessage,
  });
  useEffect(() => {
    return () => {
      if (timeoutRef.current) {
        clearTimeout(timeoutRef.current);
      }
    };
  }, []);
  return message ? (
    <div
      style={{
        backgroundColor: "#232830",
        padding: "10px",
        textAlign: "center",
        color: "#fff",
        position: "absolute",
        bottom: "50px",
        left: "30px",
        borderRadius: "10px",
        animation: "fadein 0.5s",
      }}
    >
      <strong>
        {message.senderName} says {message.message}
      </strong>
    </div>
  ) : null;
};
```

:::note

For the CSS stylings and animations used in the project, please [refer to this file](https://github.com/videosdk-live/quickstart/blob/main/react-custom-template-manager/src/index.css).

:::

**`Step 9:`** Once tested, you can deploy it using your backend or host it on services like [firebase](https://www.geeksforgeeks.org/how-to-deploy-react-project-on-firebase/) or vercel.

:::tip

You can checkout the github repository for sample custom template we just [created here](https://github.com/videosdk-live/videosdk-custom-recording-template-react-example).

:::

### Setup Livestream Using Custom Template

- To use Custom Template, you will need Host and Viewer setup from where the host will start the livestream and viewer can watch them.

![Flutter Custom Template Example](https://cdn.videosdk.live/website-resources/docs-resources/flutter_custom_template.png)

- You can clone this example and run it on your system.

```bash
git clone https://github.com/videosdk-live/quickstart.git
```

- The cloned example will have a directory `flutter-custom-template-manager` which has to runned.

```js
cd flutter-custom-template-manager
flutter pub get
flutter run
```

- To use the custom template which we just deployed, we will call the [Start HLS API](https://docs.videosdk.live/api-reference/realtime-communication/start-hlsStream) instead of the `startHls` method from the `Room` class. This code has already been added in the example you cloned.

```js
void startHls() async {
  //Update your Custom Template URL here if you have deployed your own, if not deployed you can use this template from our URL.
    //highlight-start
  String templateUrl =
      'https://lab.videosdk.live/react-custom-template-demo?meetingId=${widget.room.id}&token=${token}';
  //highlight-end
  final body = utf8.encode(
    json.encode(
      <String, dynamic>{
        "roomId": widget.room.id,
        "templateUrl": templateUrl,
        "config":{
            "orientation":"portrait",
        },
      },
    ),
  );
  final http.Response httpResponse = await http.post(
    Uri.parse('https://api.videosdk.live/v2/hls/start'),
    headers: {
      'Authorization': token,
      'Content-Type': "application/json",
    },
    body: body,
  );
  log("response ${json.decode(httpResponse.body)}"); // result will have playbackHlsUrl and livestreamUrl
}

ElevatedButton(
  onPressed: () => startHls(),
  child: Text("Start HLS")
)
```

- This example has two option on the Host side which will allow them to change the background and send the messages to the viewer.

- Let's give this example a test run.

import ReactPlayer from 'react-player'

<div style={{textAlign: 'center'}}>

<ReactPlayer autoplay muted loop playing controls url="https://cdn.videosdk.live/website-resources/docs-resources/flutter_custom_template_video.mp4" height="500px" width={"100%"} />

</div>

### API Reference

The API references for all the methods utilized in this guide are provided below.

- [Start HLS API](/api-reference/realtime-communication/start-hlsStream)
- [Events.hlsStateChanged](/flutter/api/sdk-reference/room-class/events#hlsstatechanged)


---

---
title: Display Attendees Count - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: Interactive Livestream features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Display Attendees Count
pagination_label: Display Attendees Count
keywords:
  - Start HLS meeting
  - Stop HLS meeting
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: display-attendees-count
---

# Display Attendees Count - Flutter

In this guide, we will see how you can display the number of attendees in realtime.

:::note
Before going forward in this guide, do make sure all the attendees join the meeting with mode as `SIGNALLING_ONLY`
:::

import CautionMessage from '@site/src/theme/CautionMessage';

<CautionMessage sdk="Flutter SDK" version="v1.3.0" />

**`Step 1:`** We will get the `participants` from the `Room` object. and filter the `SIGNALLING_ONLY` participants from it. We will also added the `participantJoined`, `participantLeft` and `participantModeChanged` listerners to keep the list of attendees updated.

```js
import 'package:flutter/material.dart';
import 'package:videosdk/videosdk.dart';

class ViewerScreen extends StatefulWidget {
  ...
}

class _ViewerScreenState extends State<ViewerScreen> {
  late Room room;

  Map<String, Participant> _attendees = {};

  @override
  void initState() {
    //highlight-next-line
    ...

    updateAttendees();

    setupRoomEventListener();
  }

  @override
  Widget build(BuildContext context) {
    return YourMeetingWidget();
  }

  //highlight-start
  void updateAttendees(){
    Map<String, Participant> attendees = {};
    if(room.localParticipant.mode == Mode.SIGNALLING_ONLY);
    attendees.putIfAbsent(
        room.localParticipant.id, () => room.localParticipant);
    room.participants.values.forEach((participant) {
      if (participant.mode == Mode.SIGNALLING_ONLY) {
        attendees.putIfAbsent(participant.id, () => participant);
      }
    });
    setState(()=>_attendees = attendees);
  }
  //highlight-end

  void setupRoomEventListener() {
    room.on(Events.roomJoined, () {
      //highlight-start
      updateAttendees();
      //highlight-end
    });

    room.on(Events.participantModeChanged, (Map<String, dynamic> data){
      //highlight-start
      updateAttendees()
      //highlight-end
    });

    room.on(Events.participantJoined, (Participant participant) {
      //highlight-start
      updateAttendees();
      //highlight-end
    });


    room.on(Events.participantLeft, (String participantId) {
      //highlight-start
      updateAttendees();
      //highlight-end
    });
  }
}
```

**`Step 2:`** With all the participants, we will filter out participants who have joined as a `SIGNALLING_ONLY` and then display that count.

```js
import 'package:flutter/material.dart';
import 'package:videosdk/videosdk.dart';

class ViewerScreen extends StatefulWidget {
  ...
}

class _ViewerScreenState extends State<ViewerScreen> {
  late Room room;

  Map<String, Participant> attendees = {};

  @override
  void initState() {
    //highlight-next-line
    ...

    attendees.putIfAbsent(
        room.localParticipant.id, () => room.localParticipant);
    room.participants.values.forEach((participant) {
      if (participant.mode == Mode.SIGNALLING_ONLY) {
        attendees.putIfAbsent(participant.id, () => participant);
      }
    });

    setupRoomEventListener();
  }

  //higlight-start
  @override
  Widget build(BuildContext context) {
    return Text("Total attendees :: ${attendees.length}");
  }
  //higlight-end

  void setupRoomEventListener() {
    //highlight-next-line
    ...
  }
}
```

## API Reference

The API references for all the methods utilized in this guide are provided below.

- [participants](/flutter/api/sdk-reference/room-class/properties#participants)


---

---
title: Invite Guest on Stage - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: Interactive Livestream features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Invite Guest on Stage
pagination_label: Invite Guest on Stage
keywords:
  - Start HLS meeting
  - Stop HLS meeting
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: invite-guest-on-stage
---

# Invite Guest on Stage - Flutter

In this guide, we will see how you can request a viewer to join your livestream by using the `changeMode()`.

:::note
Before going forward in this guide, do make sure all the attendees join the meeting with mode as `SIGNALLING_ONLY` and the host joins with mode as `SEND_AND_RECV`
:::

import CautionMessage from '@site/src/theme/CautionMessage';

<CautionMessage sdk="Flutter SDK" version="v1.3.0" />

Let's first have a look at how we will be using the `PubSub` mechanism to acheive the requesting and switching of the participant's mode.

![invite-guest-pubsub](https://cdn.videosdk.live/website-resources/docs-resources/invite_guest_pubsub.png)

### Step 1: Loading Viewer List

The host will see a list of participants who have joined as `SIGNALLING_ONLY` along with a button that, when selected, will invite that user to join the livestream.

```js
import 'package:flutter/material.dart';
import 'package:videosdk/videosdk.dart';

class SpeakerScreen extends StatefulWidget {
  ...
}

class _SpeakerScreenState extends State<SpeakerScreen> {
  late Room room;

  Map<String, Participant> _attendees = {};

  @override
  void initState() {
    //highlight-next-line
    ...

    updateAttendees();

    setupRoomEventListener();
  }

  @override
  Widget build(BuildContext context) {
    return Column(
      children:[
        //highlight-start
        //button which will show viewers list
        ElevatedButton(
            onPressed: () {
              showDialog(
                  context: context,
                  builder: (context) => AlertDialog(
                        content: ListView.builder(
                            itemCount: viewers.values.length,
                            itemBuilder: (builderContext, index) {
                              return Padding(
                                padding: const EdgeInsets.all(8.0),
                                child: Row(
                                  children: [
                                    Expanded(
                                        child: Text(viewers.values
                                            .elementAt(index)
                                            .displayName)),
                                    ElevatedButton(
                                        onPressed: () {

                                        },
                                        child: Text("Invite on Stage")),
                                  ],
                                ),
                              );
                            }),
                      ));
            },
            child: const Text("Invite Viewer on Stage"),
          ),
        //highlight-end
        ...
      ]
    );
  }

  //highlight-start
  void updateAttendees(){
    Map<String, Participant> attendees = {};
    if(room.localParticipant.mode == Mode.SIGNALLING_ONLY);
    attendees.putIfAbsent(
        room.localParticipant.id, () => room.localParticipant);
    room.participants.values.forEach((participant) {
      if (participant.mode == Mode.SIGNALLING_ONLY) {
        attendees.putIfAbsent(participant.id, () => participant);
      }
    });
    setState(()=>_attendees = attendees);
  }
  //highlight-end

  void setupRoomEventListener() {
    room.on(Events.roomJoined, () {
      //highlight-start
      updateAttendees();
      //highlight-end
    });

    room.on(Events.participantModeChanged, (Map<String, dynamic> data){
      //highlight-start
      updateAttendees()
      //highlight-end
    });

    room.on(Events.participantJoined, (Participant participant) {
      //highlight-start
      updateAttendees();
      //highlight-end
    });


    room.on(Events.participantLeft, (String participantId) {
      //highlight-start
      updateAttendees();
      //highlight-end
    });
  }
}
```

<img src="https://cdn.videosdk.live/website-resources/docs-resources/flutter_invite_guest_viewer_list.png" width="350" />

### Step 2: Requesting a Viewer to Join Livestream

We have a Viewer list ready. Now, let us handle the click event for the Join Livestream button.

We will be using `CHANGE_MODE_$participantId` as the topic for PubSub.

```js
import 'package:flutter/material.dart';
import 'package:videosdk/videosdk.dart';

class SpeakerScreen extends StatefulWidget {
  ...
}

class _SpeakerScreenState extends State<SpeakerScreen> {
  late Room room;

  Map<String, Participant> _attendees = {};

  @override
  void initState() {
    //highlight-next-line
    ...
  }

  @override
  Widget build(BuildContext context) {
    return Column(
      children:[
        ElevatedButton(
          onPressed: () {
            showDialog(
              context: context,
              builder: (context) => AlertDialog(
                  content: ListView.builder(
                      itemCount: viewers.values.length,
                      itemBuilder: (builderContext, index) {
                        return Padding(
                          padding: const EdgeInsets.all(8.0),
                          child: Row(
                            children: [
                              Expanded(
                                  child: Text(viewers.values
                                      .elementAt(index)
                                      .displayName)),
                              ElevatedButton(
                                  onPressed: () {
                                  //highlight-start
                                  //Publish the message on CHANGE_MODE_$participantId to join
                                  widget.room.pubSub.publish(
                                        "CHANGE_MODE_${viewers.values.elementAt(index).id}",
                                        "SIGNALLING_ONLY");
                                  //highlight-end
                                  },
                                  child: Text("Invite on Stage")),
                            ],
                          ),
                        );
                      }),
                  ));
          },
          child: const Text("Invite Viewer on Stage"),
        ),
        ...
      ]
    );
  }

  void updateAttendees(){
    //highlight-next-line
    ...
  }

  void setupRoomEventListener() {
  //highlight-next-line
    ...
  }
}
```

### Step 3: Showing Viewer Request Dialog

After implementing the Host requesting viewer to join the livestream, let's display the viewer's request dialogue and switch the `SIGNALLING_ONLY` mode to `SEND_AND_RECV`.

```js
import 'package:flutter/material.dart';
import 'package:flutter/services.dart';
import 'package:videosdk/videosdk.dart';
import './livestream_player.dart';

class ILSViewerView extends StatefulWidget {
  final Room room;
  //highlight-next-line
  ...
}

class _ILSViewerViewState extends State<ILSViewerView> {

  @override
  void initState() {
    super.initState();

    //highlight-start
    //subscribe to the change mode reequest topic
    widget.room.pubSub.subscribe(
        "CHANGE_MODE_${widget.room.localParticipant.id}",
        changeModeRequestHandler);
        //highlight-end
  }

  //highlight-start
  //show dialog to accept or reject when change mode requested by speaker
  void changeModeRequestHandler(PubSubMessage message) {
    if (mounted) {
      showDialog(
          context: this.context,
          builder: (context) {
            return AlertDialog(
              actions: [
                ElevatedButton(
                  onPressed: () {
                    widget.room.changeMode(Mode.SEND_AND_RECV);
                    Navigator.of(context).pop();
                  },
                  child: const Text("Accept"),
                ),
                ElevatedButton(
                  onPressed: () {
                    Navigator.of(context).pop();
                  },
                  child: const Text("Reject"),
                )
              ],
              content:
                  Text("${message.senderName} requestd you to join livestream"),
            );
          });
    }
  }
  //highlight-end

  @override
  Widget build(BuildContext context) {
    return YourViewerWidget;
  }

  //highlight-start
  @override
  void dispose() {
    widget.room.pubSub.unsubscribe(
        "CHANGE_MODE_${widget.room.localParticipant.id}",
        changeModeRequestHandler);
    super.dispose();
  }
  //highlight-start
}

```

<img src="https://cdn.videosdk.live/website-resources/docs-resources/flutter_invite_guest_join_request.png" width="350" />

### Step 4: Pin the participant

We need to pin the participant so that he/she can appears on the livestream. To achieve this, we will listen to the callback on the `participantModeChanged` of `Room` object. Here, we are already calling the `updateAttendees()` which we will update to pin only the `SEND_AND_RECV` mode participants.

```js
import 'package:flutter/material.dart';
import 'package:videosdk/videosdk.dart';

class SpeakerScreen extends StatefulWidget {
  ...
}

class _SpeakerScreenState extends State<SpeakerScreen> {
  late Room room;

  Map<String, Participant> _attendees = {};

  @override
  void initState() {
    //highlight-next-line
    ...
  }

  @override
  Widget build(BuildContext context) {
    return Column(
      children:[
        //highlight-next-line
        ...
      ]
    );
  }

  void updateAttendees(){
    Map<String, Participant> attendees = {};
    //highlight-start
    //we will pin localparticiant if mode is SEND_AND_RECV
    if(room.localParticipant.mode == Mode.SIGNALLING_ONLY);{
      attendees.putIfAbsent(
          room.localParticipant.id, () => room.localParticipant);
      room.localParticipant.unpin();
    }else{
      room.localParticipant.pin();
    }
      //highlight-end
    room.participants.values.forEach((participant) {
      if (participant.mode == Mode.SIGNALLING_ONLY) {
        attendees.putIfAbsent(participant.id, () => participant);
        //highlight-next-line
        participant.unpin();
      }
    });
    setState(()=>_attendees = attendees);
  }

}
```

import ReactPlayer from 'react-player'

<div style={{textAlign: 'center'}}>

<ReactPlayer autoplay muted loop playing controls url="https://cdn.videosdk.live/website-resources/docs-resources/flutter_invite_guest_video.mp4" height="500px" width={"100%"} />

</div>

## API Reference

The API references for all the methods utilized in this guide are provided below.

- [Room](/flutter/api/sdk-reference/room-class/introduction)
- [PubSub](/flutter/api/sdk-reference/pubsub-class/introduction)
- [changeMode](/flutter/api/sdk-reference/room-class/methods#changemode)


---

---
title: Manage On-Screen Participants - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: Interactive Livestream features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Manage On-Screen Participants
pagination_label: Manage On-Screen Participants
keywords:
  - Start HLS meeting
  - Stop HLS meeting
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: manage-on-screen-participants
---

# Manage On-Screen Participants - Flutter

It is important that only the necessary person are present on the screen when livestream is on. To handle this, we will be using the `pin` and `unpin` methods of the `Participant` object.

:::note
To ensure only the hosts/speakers are shown in the grid, you should use the `SPOTLIGHT` layout and `pin` as the priority when starting the interactive livestream.
:::

Let us first explore two methods that we will be using to manage on-screen participats.

### `pin()`

With these method you can pin any participant's Camera, Screen Share or both. This can be useful to identify the participants based on which you can perform rendering participant grid.

### `unpin()`

With these methods you can unpin any participant's Camera, Screen Share or both. This can be useful to reset pin state of the participant.

import CautionMessage from '@site/src/theme/CautionMessage';

<CautionMessage sdk="Flutter SDK" version="v1.3.0" />

### Managing On-Screen Participants

1. If you want to pin all the hosts/speakers automatically, you can do it by listenting to the `Events.roomJoined` callback and `Events.participantModeChanged`, where you can `pin` and `unpin` based on the mode.

```js
import 'package:flutter/material.dart';
import 'package:videosdk/videosdk.dart';

class MeetingScreen extends StatefulWidget {
  ...
}

class _MeetingScreenState extends State<MeetingScreen> {
  late Room room;

  @override
  void initState() {
    //highlight-next-line
    ...

    setupRoomEventListener();
  }

  @override
  Widget build(BuildContext context) {
    return YourMeetingWidget();
  }

  //highlight-start
  void setupRoomEventListener() {
    room.on(Events.roomJoined, () {
      //highlight-start
      //We will pin the participant if mode is SEND_AND_RECV
      if(room.localParticipant.mode == Mode.SEND_AND_RECV){
        room.localParticipant.pin();
      }
      //highlight-end
    });

    room.on(Events.participantModeChanged, (Map<String, dynamic> data){
      //highlight-start
      //We will pin the participant if mode is SEND_AND_RECV else unpin him
      if (data['participantId'] == room.localParticipant.id) {
        if (room.localParticipant.mode == Constants.modes.SEND_AND_RECV) {
          room.localParticipant.pin();
        } else {
          room.localParticipant.unpin();
        }
      }
      //highlight-end
    });
  }
  //highlight-end
}
```

2. When rendering the participant grid on the Speaker side, make sure to show only the participants who are in `SEND_AND_RECV` mode. You can filter the participants as shown in below examples.

```js
import 'package:flutter/material.dart';
import 'package:videosdk/videosdk.dart';

class MeetingScreen extends StatefulWidget {
  ...
}

class _MeetingScreenState extends State<MeetingScreen> {
  late Room room;

  Map<String, Participant> _speakers = {};

  @override
  void initState() {
    //highlight-next-line
    ...

    updateSpekers();

    setupRoomEventListener();
  }

  @override
  Widget build(BuildContext context) {
    return YourMeetingWidget();
  }

  //highlight-start
  void updateSpeakers(){
    Map<String, Participant> speakers = {};
    if(room.localParticipant.mode == Mode.SEND_AND_RECV);
    speakers.putIfAbsent(
        room.localParticipant.id, () => room.localParticipant);
    room.participants.values.forEach((participant) {
      if (participant.mode == Mode.SEND_AND_RECV) {
        speakers.putIfAbsent(participant.id, () => participant);
      }
    });
    setState(()=>_speakers = speakers);
  }
  //highlight-end

  void setupRoomEventListener() {
    room.on(Events.roomJoined, () {
      //highlight-start
      updateSpeakers();
      //highlight-end
    });

    room.on(Events.participantModeChanged, (Map<String, dynamic> data){
      //highlight-start
      updateSpeakers()
      //highlight-end
    });

    room.on(Events.participantJoined, (Participant participant) {
      //highlight-start
      updateSpeakers();
      //highlight-end
    });


    room.on(Events.participantLeft, (String participantId) {
      //highlight-start
      updateSpeakers();
      //highlight-end
    });
  }
}
```

## API Reference

The API references for all the methods utilized in this guide are provided below.

- [pin](/flutter/api/sdk-reference/participant-class/methods#pin)
- [unpin](/flutter/api/sdk-reference/participant-class/methods#unpin)
- [participants](/flutter/api/sdk-reference/room-class/properties#participants)


---

---
title: Manage Roles - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: Interactive Livestream features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Manage Roles
pagination_label: Manage Roles
keywords:
  - Start HLS meeting
  - Stop HLS meeting
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: manage-roles
---

# Manage Roles - Flutter

## Roles with VideoSDK

When doing interactive live streaming maintaining the role of users is quite important. To help manage these roles better, VideoSDK allows a participant with two types of modes:

**`1. SEND_AND_RECV`** When a participant is joining with mode set to `SEND_AND_RECV`, we will be able to **publish and consume the media** of other participants and also interact with them using the features like chat, poll etc.

**`2. SIGNALLING_ONLY`** When a participant is joining with mode set to `SIGNALLING_ONLY`, that participant is **not allowed to publish or consume any media** from other participants. Although they can interact with other participants using chat, polls etc.

import CautionMessage from '@site/src/theme/CautionMessage';

<CautionMessage sdk="Flutter SDK" version="v1.3.0" />

![manage-roles](https://cdn.videosdk.live/website-resources/docs-resources/meeting_modes.jpg)

## When to use the Roles?

##### 1. Simple Adaptive Streaming

- Simple Adaptive Streaming (SAS) is a type of livestreaming that requires minimal interaction between the host and viewers.

- It is particularly useful for events with a large number of viewers who prefer not to engage with the host.

- In SAS, each speaker attends a VideoSDK meeting in `SEND_AND_RECV` mode, while viewers can simply watch the livestream using the `playbackHlsUrl` or `livestreamUrl`. Unlike the speakers, viewers do not need to join the meeting in `SEND_AND_RECV` or `SIGNALLING_ONLY` mode. This allows for a seamless streaming experience without any unnecessary interruptions or distractions.
  - `playbackHlsUrl` - Live HLS with playback support
  - `livestreamUrl` - Live HLS without playback support

:::note
`downstreamUrl` is now depecated. Use `playbackHlsUrl` or `livestreamUrl` in place of `downstreamUrl`
:::

import ReactPlayer from 'react-player'

<div style={{textAlign: 'center'}}>

<ReactPlayer autoplay muted loop playing controls url="https://cdn.videosdk.live/website-resources/docs-resources/react_simple_ils.mp4" height="500px" width={"100%"} />

</div>

##### 2. Adaptive Streaming with increased engagement

- If you're looking to increase engagement with your audience during a live streaming event, consider using Adaptive Streaming technology. With this approach, you can incorporate interactive features such as polls and conversations, and give viewers the ability to join and leave the livestream as the host decides.

- To set this up, have all speakers join as `SEND_AND_RECV` mode participants, while the audience joins as `SIGNALLING_ONLY` mode participants. This way, everyone can participate in the interactive elements of the live stream and create a more dynamic and engaging experience for all.

<div style={{textAlign: 'center'}}>

<ReactPlayer autoplay muted loop playing controls url="https://cdn.videosdk.live/website-resources/docs-resources/react_livestream_interaction_1.mp4" height="500px" width={"100%"} />

</div>

## Using roles

The mode of the participants is set during the creating the room.

```js
import 'package:flutter/material.dart';
import 'package:videosdk/videosdk.dart';

class MeetingScreen extends StatefulWidget {
  final String meetingId;
  final String token;

  const MeetingScreen(
      {super.key, required this.meetingId, required this.token});

  @override
  State<MeetingScreen> createState() => _MeetingScreenState();
}

class _MeetingScreenState extends State<MeetingScreen> {
  late Room _room;

  Mode? localParticipantMode;

  @override
  void initState() {
    //Creating a new Room based on the passed meetingId and token from the Joining Screen
    // create room
    _room = VideoSDK.createRoom(
      roomId: widget.meetingId,
      token: widget.token,
      displayName: "John Doe",
      micEnabled: true,
      camEnabled: true,
      defaultCameraIndex:
          1, // Index of MediaDevices will be used to set default camera
      //highlight-next-line
      mode: Mode.SEND_AND_RECV, // or Mode.SIGNALLING_ONLY
    );

    _room.join();

    setRoomEventListener();

    super.initState();
  }

  @override
  Widget build(BuildContext context) {
    return  SafeArea(
      child: Scaffold(
        backgroundColor: Colors.black,
        //highlight-start
        //Show Speaker view if mode is SEND_AND_RECV else show Viewer View
        body: localParticipantMode != null
            ? localParticipantMode == Mode.SEND_AND_RECV
                ? ILSSpeakerView(room: _room)
                : localParticipantMode == Mode.SIGNALLING_ONLY
                    ? ILSViewerView(room: _room)
                    : null
            : const Center(
                child: Text("Joining...")),
                //highlight-end
      ),
    );
  }

  void setRoomEventListener(){
    _room.on(Events.roomJoined, (){
      setState(()=>localParticipantMode = _room.localParticipant.mode);
    });

    _room.on(Events.participantModeChanged, (Map<String, dynamic> data){
      if(data['participantId']){
        setState(()=>localParticipantMode = _room.localParticipant.mode);
      }
    });
  }
}
```

## Getting Participant Mode

You can identify the participants role by using `mode` property from `Participant` object.

```js
import 'package:flutter/material.dart';
import 'package:videosdk/videosdk.dart';

class ParticipantTile extends StatefulWidget {
  final Participant participant;
  const ParticipantTile({super.key, required this.participant});

  @override
  State<ParticipantTile> createState() => _ParticipantTileState();
}

class _ParticipantTileState extends State<ParticipantTile> {

  @override
  Widget build(BuildContext context) {
    //highlight-next-line
    return Text("${widget.participant.displayName} is in ${widget.participant.mode.name}");
  }
}
```

## Changing Participant's Mode

Let's say you are hosting a livestream and you want one of your viewer to join the livestream with you. In this case you can change the mode of the participant using the `changeMode()` of the `Room` object.

```js
import 'package:flutter/material.dart';
import 'package:videosdk/videosdk.dart';

class MeetingScreen extends StatefulWidget {
  ...
}

class _MeetingScreenState extends State<MeetingScreen> {
  late Room _room;

  @override
  void initState() {
    //highlight-next-line
    ...
  }

  @override
  Widget build(BuildContext context) {
    return Column(
      children:[
        ElevatedButton(
          onPressed:(){
            //highlight-next-line
            _room.changeMode(Mode.SIGNALLING_ONLY);
          },
          child: const Text("Change Mode to Viewer"),
        ),
        ElevatedButton(
          onPressed:(){
            //highlight-next-line
            _room.changeMode(Mode.SEND_AND_RECV);
          },
          child: const Text("Change Mode to Speaker"),
        ),
      ]
    );
  }
}
```

## API Reference

The API references for all the methods utilized in this guide are provided below.

- [createRoom](/flutter/api/sdk-reference/videosdk-class/methods#createroom)
- [Room](/flutter/api/sdk-reference/room-class/introduction)
- [Participant](/flutter/api/sdk-reference/participant-class/introduction)
- [changeMode](/flutter/api/sdk-reference/room-class/methods#changemode)


---

---
title: Interactive Livestream - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: Interactive Livestream features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Overview
pagination_label: Overview
keywords:
  - Start HLS meeting
  - Stop HLS meeting
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: overview
---

# Interactive Livestream (HLS) - Flutter

### What is Interactive Livestream (HLS)?

Interactive live streaming (HLS) refers to a type of live streaming where viewers can actively engage with the content being streamed and with other viewers in real-time.

In an interactive live stream (HLS), viewers can take part in a variety of activities like live polling, Q&A sessions, and even sending virtual gifts to the content creator or each other.

### What is Adaptive Live Streaming?

Livestream experience is important while undertaking interactive live streaming in order to increase audience. To do this, the livestream should be able to respond to the viewer's network bandwidth, and change the stream's resolution as necessary. Therefore, adaptive live streaming refers to a feed that automatically adjusts to a lower or higher resolution dependent on the user's preferences.

### What is Latency?

Latency is the delay between capturing video content and its playback. Key factors that affecting latency :

- **Buffering**: Balance buffer size for smoother playback against latency.
- **Network Conditions**: Efficient servers and network health contribute to lower latency.

Standard HLS has a latency around 5-6 seconds.

### HLS Architecture of VideoSDK

<center>

![VideoSDK HLS](https://cdn.videosdk.live/website-resources/docs-resources/mobile_hls.png)

</center>

When a host starts the interactive live stream, VideoSDK will use a deafult theme or user specified template to compose and encode a live stream which will be delivered to the viewers through a `M3U8` video file which can be played directly on the viewer end which will adapt to the viewer's network bandwidth.

When using VideoSDK for interactive live stream, you get multiple types of URLs which you can use based on your requirements.

**`1. Standard Streaming:`** This type of streaming is where the user is not allowed to go back in the live and can just stream it.

**`2. Rolling Playback:`** This type of streaming is where the user is allowed to do rewind and do a playback of the complete stream.

**`3. VoD Playback`** With this, users can playback the complete live stream on demand whenever needed.

### Using HLS with VideoSDK

You can use HLS with VideoSDK in two different ways.

#### 1. Simple Adaptive Streaming

When we talk about simple adaptive streaming, we imply that there is hardly any interaction between the hosts and the viewers.

These livestreams are helpful when there are a lot of viewers, and they don't want to engage with the host. In this scenario, every presenter attends a VideoSDK meeting, while every viewer only watches the livestream.

import ReactPlayer from 'react-player'

<div style={{textAlign: 'center'}}>

<ReactPlayer autoplay muted loop playing controls url="https://cdn.videosdk.live/website-resources/docs-resources/react_simple_ils.mp4" height="500px" width={"100%"} />

</div>

#### 2. Adaptive Streaming with increased engagement

When you want to communicate with your audience by enabling polls, conversations, and the ability for viewers to join and leave the livestream based on the host's decision, adaptive streaming with enhanced engagement will be the best fit for you.

In this scenario, both the host and the viewer will have to join a VideoSDK meeting with different roles. To learn more about the roles [follow these guide.](../handling-participants/manage-roles)

<div style={{textAlign: 'center'}}>

<ReactPlayer autoplay muted loop playing controls url="https://cdn.videosdk.live/website-resources/docs-resources/react_livestream_interaction_2.mp4" height="500px" width={"100%"} />

</div>


---

---
title: Setup HLS Player | Video SDK
hide_title: true
hide_table_of_contents: false
description: Using VideoSDK to do the interactive livestreaming.
sidebar_label: Setup HLS Player
pagination_label: Setup HLS Player
keywords:
  - audio calling
  - video calling
  - real-time communication
  - interactive live streaming
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: setup-hls-player
---

# Setup HLS Player - Flutter

In this guide, we will create a new Component which will be responsible for playing the HLS stream.
Before starting this guide, make sure you have a VideoSDK meetings setup allowing you to join the room. To learn more about setting up a VideoSDK meeting, follow this quick start guide.

To play the HLS stream we will be using the [flutter_vlc_player](https://pub.dev/packages/flutter_vlc_player) library.

### `1. Setup Component with HLS events`

**`Step 1:`** Let us first start by creating the new `StatefulWidget` named `HlsScreen` which will listen to all the HLS related events and play the HLS stream whenever available.

```js
import 'package:flutter/material.dart';
import 'package:videosdk/videosdk.dart';

class HlsScreen extends StatefulWidget {
  final Room room;
  const HlsScreen({super.key, required this.room});

  @override
  State<HlsScreen> createState() => _HlsScreenState();
}

class _HlsScreenState extends State<HlsScreen> {
  //highlight-start
  //Declare state of the HLS and the playbackHlsUrl
  String hlsState = "HLS_STOPPED";
  String? playbackHlsUrl;
  //highlight-end

  @override
  void initState() {
    super.initState();
    //highlight-start
    //initialize the state from the room object
    hlsState = widget.room.hlsState;
    playbackHlsUrl = widget.room.hlsPlaybackHlsUrl;
    //highlight-end

    //setup hlsStateChanged event listener
    setMeetingEventListener();
  }

  @override
  Widget build(BuildContext context) {
    return Column(
      mainAxisAlignment: MainAxisAlignment.center,
      children: [
      ],
    );
  }

  //highlight-start
  // listening to meeting events
  void setMeetingEventListener() {
    widget.room.on(
      Events.hlsStateChanged,
      (Map<String, dynamic> data) {
        String status = data['status'];
        if (mounted) {
          setState(() {
            hlsState = status;
            //we will update the downstream URL if the HLS state is HLS_PLAYABLE and HLS_STOPPED
            if (status == "HLS_PLAYABLE" || status == "HLS_STOPPED") {
              playbackHlsUrl = data['playbackHlsUrl'];
            }
          });
        }
      },
    );
  }
  //highlight-end
}
```

**`Step 2:`** Now let's add the placeholder that will be shown when there is no active HLS. For these, we will use the `playbackHlsUrl` identify if there is an active HLS.

```js
import 'package:flutter/material.dart';
import 'package:videosdk/videosdk.dart';
import './livestream_player.dart';

class HlsScreen extends StatefulWidget {
  final Room room;
  //highlight-next-line
  ...
}

class _HlsScreenState extends State<HlsScreen> {
  String hlsState = "HLS_STOPPED";
  String? playbackHlsUrl;

  @override
  void initState() {
    //highlight-next-line
    ...
  }

  @override
  Widget build(BuildContext context) {
    return Column(
      mainAxisAlignment: MainAxisAlignment.center,
      children: [
        //Render the text placeholder if downstream url is null
        playbackHlsUrl != null
              ? LivestreamPlayer(playbackHlsUrl: playbackHlsUrl!)
              : const Text("Host has not started the HLS"),
      ],
    );
  }

  // listening to meeting events
  void setMeetingEventListener() {
    //highlight-next-line
    ...
  }
}
```

### `2. Playing HLS stream`

**`Step 1:`** We will be using the [flutter_vlc_player](https://pub.dev/packages/flutter_vlc_player) library to play the HLS stream. So let's start by installing the library.

```bash
flutter pub add flutter_vlc_player
```

**`Step 2:`** Next we will be `StatefulWidget` named `LivestreamPlayer` which will play our livestream from the provided `playbackHlsUrl`.

```js
import 'package:flutter/material.dart';
import 'package:flutter_vlc_player/flutter_vlc_player.dart';

class LivestreamPlayer extends StatefulWidget {
  final String playbackHlsUrl;
  const LivestreamPlayer({
    Key? key,
    required this.playbackHlsUrl,
  }) : super(key: key);

  @override
  LivestreamPlayerState createState() => LivestreamPlayerState();
}

class LivestreamPlayerState extends State<LivestreamPlayer>
    with AutomaticKeepAliveClientMixin {
  late VlcPlayerController _controller;

  @override
  bool get wantKeepAlive => true;

  @override
  void initState() {
    super.initState();
    //highlight-start
    //initialize the player with playbackHlsUrl
    _controller = VlcPlayerController.network(widget.playbackHlsUrl,
        options: VlcPlayerOptions());
    //highlight-end
  }

  @override
  void dispose() async {
    _controller.dispose();
    super.dispose();
  }

  @override
  Widget build(BuildContext context) {
    super.build(context);
    //highlight-start
    //return the VlcPlayer Widget
    return VlcPlayer(
      controller: _controller,
      aspectRatio: 9 / 16,
      placeholder: const Center(child: CircularProgressIndicator()),
    );
    //highlight-end
  }
}

```

With this, the player is setup to play the HLS.

<img src="https://cdn.videosdk.live/website-resources/docs-resources/flutter_ils_viewer_view.png" width="250"/>

## API Reference

The API references for all the methods utilized in this guide are provided below.

- [startHls](/flutter/api/sdk-reference/room-class/methods#starthls)
- [stopHls](/flutter/api/sdk-reference/room-class/methods#stophls)
- [Events.hlsStateChanged](/flutter/api/sdk-reference/room-class/events#hlsstatechanged)


---

---
title: Start HLS | Video SDK
hide_title: true
hide_table_of_contents: false
description: Using VideoSDK to do the interactive livestreaming.
sidebar_label: Start HLS
pagination_label: Start HLS
keywords:
  - audio calling
  - video calling
  - real-time communication
  - interactive live streaming
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: start-hls
---

# Start HLS - Flutter

Before starting the HLS, the prequisite steps require you to have a VideoSDK Meeting running which you want to use for interactive livestream. To learn more about setting up a interactive live streaming, you can follow the steps [here in the quick start guide.](/flutter/guide/video-and-audio-calling-api-sdk/quick-start-ils)

import CautionMessage from '@site/src/theme/CautionMessage';

<CautionMessage sdk="Flutter SDK" version="v1.3.0" />


## Starting HLS

`startHls()` can be used to start a interactive livestream of the meeting which can be accessed from the `Room` object. This method accepts one parameter:

- `config (optional)`: This parameter will define how the livestream layout should look like.

```js
Map<String, dynamic> config = {
  // highlight-next-line
  // Layout Configuration
  "layout": {
    "type": "GRID", // "SPOTLIGHT" | "SIDEBAR",  Default : "GRID"
    "priority": "SPEAKER", // "PIN", Default : "SPEAKER"
    "gridSize": 4, // MAX : 4
  },

  // highlight-next-line
  // Theme of recording
  "theme": "DARK", //  "LIGHT" | "DEFAULT"

  // highlight-next-line
  // `mode` is used to either record video & audio both or only audio.
  "mode": "video-and-audio", // "audio", Default : "video-and-audio"

  // highlight-next-line
  // Quality of recording and is only applicable to `video-and-audio` type mode.
  "quality": "high", // "low" | "med",  Default : "med"

  //highlight-start
  // This mode refers to orientation of recording.
  // landscape : Record the meeting in horizontally
  // portrait : Record the meeting in vertically (Best for mobile view)
  //highlight-end
  "orientation": "landscape", // "portrait",  Default : "landscape"
};

room.startHls(config: config);
```

:::note
If you want only the SEND_AND_RECV participants to be seen in the livestream, you can `pin` all the participants in the SEND_AND_RECV mode and start the livestream with the `SPOTLIGHT` layout and `PIN` as the `PRIORITY`.
:::

### Example

```js
import 'package:flutter/material.dart';
import 'package:videosdk/videosdk.dart';

class MeetingScreen extends StatefulWidget {
  ...
}

class _MeetingScreenState extends State<MeetingScreen> {
  late Room _room;

  @override
  void initState() {
    //highlight-next-line
    ...
  }

  @override
  Widget build(BuildContext context) {
    return Column(
      children:[
        //highlight-start
        ElevatedButton(
          onPressed:(){
            Map<String, dynamic> config = {
              "layout": {
                "type": "GRID",
                "priority": "SPEAKER",
                "gridSize": 4,
              },
              "theme": "DARK",
              "mode": "video-and-audio",
              "quality": "high",
              "orientation": "portrait",
            };
            _room.startHls(config: config);
          },
          child: const Text("Start HLS"),
        ),
    //highlight-end
      ]
    );
  }
}
```

## Understanding Layouts

##### 1. GRID Layout

This layout is default layout if no participants are pinned, it will look same as a normal meeting grid layout, when any participant is pinned that participant will be moved on top of the main screen grid above all non pinned participants

While screenshare as well the main view will contain only screenshare media but the side panel view of participant grid will maintain same order of pinned and unpinned participants.

|                       Grid                        |                     Grid with Screenshare                     |
| :-----------------------------------------------: | :-----------------------------------------------------------: |
| ![prebuilt-grid](/img/prebuilt/prebuilt-grid.png) | ![prebuilt-grid-share](/img/prebuilt/prebuilt-grid-share.png) |

##### 2. SIDEBAR Layout

This layout will have one main screen view and other sidebar grid layout. Only pinned participant will be visible in this layout, all unpinned participants will not be visible in this layout. If more than one participant is pinned then the first participant who was pinned will appear in main screen layout and all other remaining pinned particiapants will be visible in sidebar.

If any pinned participant started screenshare then the screenshare media will be visible in main screen layout and all other pinned participants webcam view will be visible in sidebar

|                         Sidebar                         |                      Sidebar with Screenshare                       |
| :-----------------------------------------------------: | :-----------------------------------------------------------------: |
| ![prebuilt-sidebar](/img/prebuilt/prebuilt-sidebar.png) | ![prebuilt-sidebar-share](/img/prebuilt/prebuilt-sidebar-share.png) |

##### 3. SPOTLIGHT Layout

This layout will only contain main screen layout, multiple pinned participants will be visible in main screen view. Same as `SIDEBAR` layout only pinned participants will be visible in main screen.

If any pinned participant started screenshare then only screenshare view will be visible in main screen, no webcam view will be visible when any pinned participant started screenshare.

|                          Spotlight                          |                       Spotlight with Screenshare                        |
| :---------------------------------------------------------: | :---------------------------------------------------------------------: |
| ![prebuilt-spotlight](/img/prebuilt/prebuilt-spotlight.png) | ![prebuilt-spotlight-share](/img/prebuilt/prebuilt-spotlight-share.png) |

## Event associated with HLS

- **hlsStateChanged** - Whenever meeting HLS state changes, then `hlsStateChanged` event will trigger.

- You can get the `playbackHlsUrl` and ` livestreamUrl` of the HLS to play it on the Viewer side when the state changes to `HLS_PLAYABLE`
  - `playbackHlsUrl` - Live HLS with playback support
  - `livestreamUrl` - Live HLS without playback support

:::note
`downstreamUrl` is now depecated. Use `playbackHlsUrl` or `livestreamUrl` in place of `downstreamUrl`
:::

```js
import 'package:flutter/material.dart';
import 'package:videosdk/videosdk.dart';

class MeetingScreen extends StatefulWidget {
  ...
}

class _MeetingScreenState extends State<MeetingScreen> {
  late Room room;

  @override
  void initState() {
    //highlight-next-line
    ...

    setupRoomEventListener();
  }

  @override
  Widget build(BuildContext context) {
    return YourMeetingWidget();
  }

  //highlight-start
  void setupRoomEventListener() {
    room.on(Events.hlsStateChanged, (Map<String, dynamic> data) {
      //Status can be :: HLS_STARTING
      //Status can be :: HLS_STARTED
      //Status can be :: HLS_PLAYABLE
      //Status can be :: HLS_STOPPING
      //Status can be :: HLS_STOPPED
      log("Meeting HLS status : ${data['status']}");
      if (data['status'] == "HLS_PLAYABLE")
        log("PLAYBACKHLS URL -- " + data['playbackHlsUrl']);
    });
  }
  //highlight-end
}
```

## Custom Template

With VideoSDK, you can also use your own custom designed layout template to livestream the meetings. In order to use the custom template, you need to create a template for which you can [follow this guide](/react/guide/interactive-live-streaming/custom-template). Once you have setup the template, you can use the [REST API to start](/api-reference/realtime-communication/start-livestream) the livestream with the `templateURL` parameter.

## API Reference

The API references for all the methods utilized in this guide are provided below.

- [startHls](/flutter/api/sdk-reference/room-class/methods#starthls)
- [stopHls](/flutter/api/sdk-reference/room-class/methods#stophls)
- [Events.hlsStateChanged](/flutter/api/sdk-reference/room-class/events#hlsstatechanged)


---

---
title: Stop HLS | Video SDK
hide_title: true
hide_table_of_contents: false
description: Using VideoSDK to do the interactive livestreaming.
sidebar_label: Stop HLS
pagination_label: Stop HLS
keywords:
  - audio calling
  - video calling
  - real-time communication
  - interactive live streaming
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: stop-hls
---

# Stop HLS - Flutter

This could refer to stopping the transmission of an ongoing HLS stream, which would mean the stream is no longer available to viewers.

## Stopping HLS

`stopHls()` can be used to stop a interactive livestream of the meeting which can be accessed from the `Room` object.

### Example

```js
import 'package:flutter/material.dart';
import 'package:videosdk/videosdk.dart';

class MeetingScreen extends StatefulWidget {
  ...
}

class _MeetingScreenState extends State<MeetingScreen> {
  late Room _room;

  @override
  void initState() {
    //highlight-next-line
    ...
  }

  @override
  Widget build(BuildContext context) {
    return Column(
      children:[
        //highlight-start
        ElevatedButton(
          onPressed:(){
            _room.stopHls();
          },
          child: const Text("Stop HLS"),
        ),
    //highlight-end
      ]
    );
  }
}
```

## Event associated with HLS

- **hlsStateChanged** - Whenever meeting HLS state changes, then `hlsStateChanged` event will trigger.

- You will get `HLS_STOPPING` and `HLS_STOPPED` status on calling `stopHls()`.

```js
import 'package:flutter/material.dart';
import 'package:videosdk/videosdk.dart';

class MeetingScreen extends StatefulWidget {
  ...
}

class _MeetingScreenState extends State<MeetingScreen> {
  late Room room;

  @override
  void initState() {
    //highlight-next-line
    ...

    setupRoomEventListener();
  }

  @override
  Widget build(BuildContext context) {
    return YourMeetingWidget();
  }

  //highlight-start
  void setupRoomEventListener() {
    room.on(Events.hlsStateChanged, (Map<String, dynamic> data) {
      //Status can be :: HLS_STARTING
      //Status can be :: HLS_STARTED
      //Status can be :: HLS_PLAYABLE
      //Status can be :: HLS_STOPPING
      //Status can be :: HLS_STOPPED
      log("Meeting HLS status : ${data['status']}");
      if (data['status'] == "HLS_STOPPING")
        log("HLS Stopping");
      if (data['status'] == "HLS_STOPPED")
        log("HLS Stopped");
    });
  }
  //highlight-end
}
```

## Custom Template

With VideoSDK, you can also use your own custom designed layout template to livestream the meetings. In order to use the custom template, you need to create a template for which you can [follow this guide](/react/guide/interactive-live-streaming/custom-template). Once you have setup the template, you can use the [REST API to start](/api-reference/realtime-communication/start-livestream) the livestream with the `templateURL` parameter.

## API Reference

The API references for all the methods utilized in this guide are provided below.

- [startHls](/flutter/api/sdk-reference/room-class/methods#starthls)
- [stopHls](/flutter/api/sdk-reference/room-class/methods#stophls)
- [Events.hlsStateChanged](/flutter/api/sdk-reference/room-class/events#hlsstatechanged)


---

---
title: Chat messages with PubSub - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: PubSub features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Chat using PubSub
pagination_label: Chat using PubSub
keywords:
  - Start Livestream meeting
  - Stop Livestream meeting
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: chat-using-pubsub
---

# Chat using PubSub - Flutter

For the communication or any kind of messaging in between the participants, VideoSDK provides `pubSub` which use Publish-Subsciribe mechanism and can be used to develope wide varitey of functionalities. For example, participants could use it to send chat messages to each other, share files or other media, or even trigger actions like muting or unmuting audio or video.

Now we will see, how we can use PubSub to implement Chat functionality. If you are not familiar with the PubSub mechanism, you can [follow this guide](/flutter/guide/video-and-audio-calling-api-sdk/collaboration-in-meeting/pubsub).

## Implementing Chat

1. First step in creating a group chat is choosing the topic which all the participants will publish and subscribe to send and receive the messages. We will be using `CHAT` as the topic for this one. So let us lets create a message input and send button to publish the messages using the `pubSub` from the `Room` object.

```js
import 'package:flutter/material.dart';
import 'package:videosdk/videosdk.dart';

class ChatView extends StatefulWidget {
  final Room room;
  ...
}

class _ChatViewState extends State<ChatView> {

  final msgTextController = TextEditingController();


  @override
  void initState() {
    //highlight-next-line
    ...
  }

  @override
  Widget build(BuildContext context) {
    return Column(
      children:[
        //highlight-start
        Row(
          children: [
            Expanded(
              child: TextField(
                style: TextStyle(
                  fontSize:16,
                  fontWeight: FontWeight.w500,
                ),
                controller: msgTextController,
                onChanged: (value) => setState(() {
                  msgTextController.text;
                }),
                decoration: const InputDecoration(
                  hintText: "Write your message",
                  border: InputBorder.none,
                ),
              ),
            ),
            ElevatedButton(
              onPressed:(){
                if(!msgTextController.text.trim().isEmpty){
                  widget.room.pubSub
                        .publish(
                          "CHAT",
                          msgTextController.text,
                          const PubSubPublishOptions(
                              persist: true),
                        )
                        .then(
                            (value) => msgTextController.clear())
                }
              },
              child: const Text("Send Message"),
            ),
          ],
        ),
    //highlight-end
      ]
    );
  }

}
```

2. Final step in the group chat would be to display the messages others send. For this will use the `messages` and display all the messages by subscribing to the topic `CHAT`.

```js
import 'package:flutter/material.dart';
import 'package:videosdk/videosdk.dart';

class ChatView extends StatefulWidget {
  final Room room;
  ...
}

class _ChatViewState extends State<ChatView> {

  // PubSubMessages
  PubSubMessages? messages;

  @override
  void initState() {
    //highlight-next-line
    ...

    //highlight-start
    // Subscribing 'CHAT' Topic
    widget.meeting.pubSub
      .subscribe("CHAT", messageHandler)
      .then((value) => setState((() => messages = value)));
    //highlight-end
  }

  //highlight-start
  //Handler which will be called when new mesasge is received
  void messageHandler(PubSubMessage message) {
    setState(() => messages!.messages.add(message));
  }
  //highlight-end

  @override
  Widget build(BuildContext context) {
    return Column(
      children:[
        //highlight-start
        Expanded(
          child: messages == null
              ? const Center(child: CircularProgressIndicator())
              : SingleChildScrollView(
                  reverse: true,
                  child: Column(
                    children: messages!.messages
                        .map(
                          (message) => Text(
                            message.message
                          ),
                        )
                        .toList(),
                  ),
                ),
        ),

        ...
        //Send Message code Here
    //highlight-end
      ]
    );
  }

  @override
  void dispose() {
    //highlight-start
    // Unsubscribe
    widget.room.pubSub.unsubscribe("CHAT", messageHandler);
    //highlight-end
    super.dispose();
  }
}
```

### Displaying Latest Message Notificaiton

You may want to show the notification to the user when new message arrives. So lets continue our example and add alert for the new images.

```js
import 'package:flutter/material.dart';
import 'package:videosdk/videosdk.dart';

class ChatView extends StatefulWidget {
  final Room room;
  ...
}

class _ChatViewState extends State<ChatView> {

  @override
  void initState() {
    //highlight-next-line
    ...
  }

  //highlight-start
  //Handler which will be called when new mesasge is received
  void messageHandler(PubSubMessage message) {
    //Show snackbar on new message
    if(context.mounted){
      ScaffoldMessenger.of(context).showSnackBar(SnackBar(
        content: Text(
          message.message,
          overflow: TextOverflow.fade,
        ),
      ));
    }
    setState(() => messages!.messages.add(message));
  }
  //highlight-end

  @override
  Widget build(BuildContext context) {
    return Column(
      children:[
        //highlight-start
        ...
         //highlight-end
      ]
    );
  }

  @override
  void dispose() {
    //highlight-next-line
    ...
  }
}
```

## Downloading Chat Messages

All the messages from the PubSub which where published with `persist : true` and can be downloaded as an `.csv` file. This file will be available in the VideoSDK dashboard as well as throught the [Sessions API](/api-reference/realtime-communication/fetch-session-using-sessionid).

## API Reference

The API references for all the methods and events utilised in this guide are provided below.

- [pubSub](/flutter/api/sdk-reference/pubsub-class/introduction)


---

---
title: Notify Attendees with PubSub - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: PubSub features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Notify Attendees in Realtime
pagination_label: Notify Attendees in Realtime
keywords:
  - Start Livestream meeting
  - Stop Livestream meeting
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: notify-attendees
---

# Notify Attendees in Realtime - Flutter

When doing livestream, you may want to broadcast message to all the viewers at once.

Let us see, how we can use PubSub to implement this functionality. If you are not familiar with the PubSub mechanism you can [follow this guide](/flutter/guide/video-and-audio-calling-api-sdk/collaboration-in-meeting/pubsub).

### Notifying Attendees

1. We will be creating a button and text input to take the message input and we will publish a message to the topic `NOTIFY_ATTENDEES`

```js
import 'package:flutter/material.dart';
import 'package:videosdk/videosdk.dart';

class NotifyView extends StatefulWidget {
  final Room room;
  ...
}

class _NotifyViewState extends State<NotifyView> {

  final msgTextController = TextEditingController();


  @override
  void initState() {
    //highlight-next-line
    ...
  }

  @override
  Widget build(BuildContext context) {
    return Column(
      children:[
        //highlight-start
        Row(
          children: [
            Expanded(
              child: TextField(
                style: TextStyle(
                  fontSize:16,
                  fontWeight: FontWeight.w500,
                ),
                controller: msgTextController,
                onChanged: (value) => setState(() {
                  msgTextController.text;
                }),
                decoration: const InputDecoration(
                  hintText: "Write your message",
                  border: InputBorder.none,
                ),
              ),
            ),
            ElevatedButton(
              onPressed:(){
                if(!msgTextController.text.trim().isEmpty){
                  widget.room.pubSub
                        .publish(
                          "NOTIFY_ATTENDEES",
                          msgTextController.text,
                          const PubSubPublishOptions(
                              persist: true),
                        )
                        .then(
                            (value) => msgTextController.clear())
                }
              },
              child: const Text("Notify Attendees"),
            ),
          ],
        ),
    //highlight-end
      ]
    );
  }

}
```

2. Now let us show an alert to all the viewers displaying the message posted by the speaker.

```js
import 'package:flutter/material.dart';
import 'package:videosdk/videosdk.dart';

class ViewerView extends StatefulWidget {
  final Room room;
  ...
}

class _ViewerViewState extends State<ViewerView> {

  @override
  void initState() {
    //highlight-next-line
    ...

    //highlight-start
    // Subscribing 'NOTIFY_ATTENDEES' Topic
    widget.meeting.pubSub
      .subscribe("NOTIFY_ATTENDEES", messageHandler);
    //highlight-end
  }

  //highlight-start
  //Handler which will be called when new mesasge is
  //These is where we will show the message
  void messageHandler(PubSubMessage message) {
    if(context.mounted && widget.room.localParticipant.mode == MOde.SIGNALLING_ONLY){
      ScaffoldMessenger.of(context).showSnackBar(SnackBar(
        content: Text(
          message.message,
          overflow: TextOverflow.fade,
        ),
      ));
    }
  }
  //highlight-end

  @override
  Widget build(BuildContext context) {
    return Column(
      children:[
        //highlight-next-line
        ...
      ]
    );
  }

  @override
  void dispose() {
    //highlight-start
    // Unsubscribe
    widget.room.pubSub.unsubscribe("NOTIFY_ATTENDEES", messageHandler);
    //highlight-end
    super.dispose();
  }
}
```

### API Reference

The API references for all the methods and events utilized in this guide are provided below.

- [PubSub](/flutter/api/sdk-reference/pubsub-class/introduction)


---

---
title: Raise Hand with PubSub - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: PubSub features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Raise Hand
pagination_label: Raise Hand
keywords:
  - Start Livestream meeting
  - Stop Livestream meeting
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: raise-hand
---

# Raise Hand - Flutter

Let us see, how we can use PubSub to implement Raise hand functionality. If you are not familiar with the PubSub mechanism you can [follow this guide](/flutter/guide/video-and-audio-calling-api-sdk/collaboration-in-meeting/pubsub).

### Implementing Raise Hand

1. We will be creating a button when clicked, we will publish a message it the topic `RAISE_HAND`

```js
import 'package:flutter/material.dart';
import 'package:videosdk/videosdk.dart';

class NotifyView extends StatefulWidget {
  final Room room;
  ...
}

class _NotifyViewState extends State<NotifyView> {

  final msgTextController = TextEditingController();


  @override
  void initState() {
    //highlight-next-line
    ...
  }

  @override
  Widget build(BuildContext context) {
    return Column(
      children:[
        //highlight-start
        ElevatedButton(
          onPressed:(){
            widget.room.pubSub
                  .publish(
                    "RAISE_HAND",
                    "Raised Hand",
                    const PubSubPublishOptions(
                        persist: true),
                  );
          },
          child: const Text("Raise Hand"),
        ),
    //highlight-end
      ],
    );
  }

}
```

2. Now let us show an alert to all the speakers showing who raised the hand.

```js
import 'package:flutter/material.dart';
import 'package:videosdk/videosdk.dart';

class SpeakerView extends StatefulWidget {
  final Room room;
  ...
}

class _SpeakerViewState extends State<SpeakerView> {

  @override
  void initState() {
    //highlight-next-line
    ...

    //highlight-start
    // Subscribing 'RAISE_HAND' Topic
    widget.meeting.pubSub
      .subscribe("RAISE_HAND", messageHandler);
    //highlight-end
  }

  //highlight-start
  //Handler which will be called when new mesasge is
  //These is where we will show the message
  void messageHandler(PubSubMessage message) {
    if(context.mounted && widget.room.localParticipant.mode == Mode.SEND_AND_RECV){
      ScaffoldMessenger.of(context).showSnackBar(SnackBar(
        content: Text(
          "${message.senderName} raised hand",
          overflow: TextOverflow.fade,
        ),
      ));
    }
  }
  //highlight-end

  @override
  Widget build(BuildContext context) {
    return Column(
      children:[
        //highlight-next-line
        ...
      ]
    );
  }

  @override
  void dispose() {
    //highlight-start
    // Unsubscribe
    widget.room.pubSub.unsubscribe("RAISE_HAND", messageHandler);
    //highlight-end
    super.dispose();
  }

}
```

### API Reference

The API references for all the methods and events utilized in this guide are provided below.

- [PubSub](/flutter/api/sdk-reference/pubsub-class/introduction)


---

---
sidebar_label: Overview
pagination_label: Overview
---

# Overview of SIP with VideoSDK - Flutter

import SipConnect from '../../../mdx/\_sip-connect.mdx';
import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>

<SipConnect title="SIP Connect with VideoSDK - Android"/>


---

---
sidebar_label: Quick Start
pagination_label: Quick Start
---

# Build a SIP Integration: VideoSDK & Twilio for Inbound Outbound Calls! Step-by-Step

import SipQuickStart from '../../../mdx/\_sip-connect-quick-start.mdx';

<SipQuickStart/>


---

---
title: SIP Connect
hide_title: false
hide_table_of_contents: false
description: Interactive Livestream features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: SIP Connect
pagination_label: SIP Connect
keywords:
  - SIP connect
  - PSTN connect
  - sip videosdk
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: sip-connect
---
# SIP Connect - Flutter

import SipConnect from '../../mdx/\_sip-connect.mdx';
import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>

<SipConnect title="SIP Connect with VideoSDK - Flutter"/>


---

---
title: Authentication in Video & Audio Calling SDK
hide_title: true
hide_table_of_contents: false
description: This guide will explain authentication and token flow for video & audio calling SDK.
sidebar_label: Authentication and Tokens
pagination_label: Authentication and Tokens
keywords:
  - authentication audio calling
  - authentication video calling
  - authentication real-time communication
  - tokens
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: authentication-and-tokens
---

import ServerSetup from '../../../mdx/introduction/\_server-setup.mdx';

<ServerSetup title="Authentication and Tokens for VideoSDK - Flutter" />


---

---
title: Chat messages with PubSub - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: PubSub features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Chat using PubSub
pagination_label: Chat using PubSub
keywords:
  - Start Livestream meeting
  - Stop Livestream meeting
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: chat-using-pubsub
---

# Chat using PubSub - Flutter

For the communication or any kind of messaging in between the participants, VideoSDK provides `pubSub` which use Publish-Subsciribe mechanism and can be used to develope wide varitey of functionalities. For example, participants could use it to send chat messages to each other, share files or other media, or even trigger actions like muting or unmuting audio or video.

Now we will see, how we can use PubSub to implement Chat functionality. If you are not familiar with the PubSub mechanism, you can [follow this guide](./pubsub).

## Implementing Chat

### `Group Chat`

1. First step in creating a group chat is choosing the topic which all the participants will publish and subscribe to send and receive the messages. We will be using `CHAT` as the topic for this one. So let us lets create a message input and send button to publish the messages using the `pubSub` from the `Room` object.

```js
import 'package:flutter/material.dart';
import 'package:videosdk/videosdk.dart';

class ChatView extends StatefulWidget {
  final Room room;
  ...
}

class _ChatViewState extends State<ChatView> {

  final msgTextController = TextEditingController();


  @override
  void initState() {
    //highlight-next-line
    ...

    //highlight-start
    // Subscribing 'CHAT' Topic
    widget.meeting.pubSub
      .subscribe("CHAT", messageHandler)
      .then((value) => setState((() => messages = value)));
    //highlight-end
  }

  //highlight-start
  //Handler which will be called when new mesasge is received
  void messageHandler(PubSubMessage message) {
    setState(() => messages!.messages.add(message));
  }
  //highlight-end

  @override
  Widget build(BuildContext context) {
    return Column(
      children:[
        //highlight-start
        Row(
          children: [
            Expanded(
              child: TextField(
                style: TextStyle(
                  fontSize:16,
                  fontWeight: FontWeight.w500,
                ),
                controller: msgTextController,
                onChanged: (value) => setState(() {
                  msgTextController.text;
                }),
                decoration: const InputDecoration(
                  hintText: "Write your message",
                  border: InputBorder.none,
                ),
              ),
            ),
            ElevatedButton(
              onPressed:(){
                if(!msgTextController.text.trim().isEmpty){
                  widget.room.pubSub
                        .publish(
                          "CHAT",
                          msgTextController.text,
                          const PubSubPublishOptions(
                              persist: true),
                        )
                        .then(
                            (value) => msgTextController.clear())
                }
              },
              child: const Text("Send Message"),
            ),
          ],
        ),
    //highlight-end
      ]
    );
  }

}
```

2. Final step in the group chat would be to display the messages others send. For this will use the `messages` and display all the messages by subscribing to the topic `CHAT`.

```js
import 'package:flutter/material.dart';
import 'package:videosdk/videosdk.dart';

class ChatView extends StatefulWidget {
  final Room room;
  ...
}

class _ChatViewState extends State<ChatView> {

  // PubSubMessages
  PubSubMessages? messages;

  @override
  void initState() {
    //highlight-next-line
    ...

    //highlight-start
    // Subscribing 'CHAT' Topic
    widget.meeting.pubSub
      .subscribe("CHAT", messageHandler)
      .then((value) => setState((() => messages = value)));
    //highlight-end
  }

  //highlight-start
  //Handler which will be called when new mesasge is received
  void messageHandler(PubSubMessage message) {
    setState(() => messages!.messages.add(message));
  }
  //highlight-end

  @override
  Widget build(BuildContext context) {
    return Column(
      children:[
        //highlight-start
        Expanded(
          child: messages == null
              ? const Center(child: CircularProgressIndicator())
              : SingleChildScrollView(
                  reverse: true,
                  child: Column(
                    children: messages!.messages
                        .map(
                          (message) => Text(
                            message.message
                          ),
                        )
                        .toList(),
                  ),
                ),
        ),

        ...
        //Send Message code Here
    //highlight-end
      ]
    );
  }

  @override
  void dispose() {
    //highlight-start
    // Unsubscribe
    widget.room.pubSub.unsubscribe("CHAT", messageHandler);
    //highlight-end
    super.dispose();
  }
}
```

### `Private Chat`

In the above example, if you want to convert into the private chat between two participants, then all you have to do is pass `sendOnly` parameter in `PubSubPublishOptions`.

```js
import 'package:flutter/material.dart';
import 'package:videosdk/videosdk.dart';

class ChatView extends StatefulWidget {
  final Room room;
  ...
}

class _ChatViewState extends State<ChatView> {

  //...

  @override
  Widget build(BuildContext context) {
    return Column(
      children:[
        Row(
          children: [
            Expanded(
              child: TextField(
                style: TextStyle(
                  fontSize:16,
                  fontWeight: FontWeight.w500,
                ),
                controller: msgTextController,
                onChanged: (value) => setState(() {
                  msgTextController.text;
                }),
                decoration: const InputDecoration(
                  hintText: "Write your message",
                  border: InputBorder.none,
                ),
              ),
            ),
            ElevatedButton(
              onPressed:(){
                if(!msgTextController.text.trim().isEmpty){
                  //highlight-start
                  // Pass the participantId of the participant to whom you want to send the message.
                  widget.room.pubSub
                        .publish(
                          "CHAT",
                          msgTextController.text,
                          const PubSubPublishOptions(
                            persist: true, sendOnly: ["xyz"]),
                        )
                        .then(
                            (value) => msgTextController.clear())
                  //highlight-end
                }
              },
              child: const Text("Send Message"),
            ),
          ],
        ),
      ]
    );
  }

}
```

### Displaying Latest Message Notificaiton

You may want to show the notification to the user when new message arrives. So lets continue our example and add alert for the new images.

```js
import 'package:flutter/material.dart';
import 'package:videosdk/videosdk.dart';

class ChatView extends StatefulWidget {
  final Room room;
  ...
}

class _ChatViewState extends State<ChatView> {

  @override
  void initState() {
    //highlight-next-line
    ...
  }

  //highlight-start
  //Handler which will be called when new mesasge is received
  void messageHandler(PubSubMessage message) {
    //Show snackbar on new message
    if(context.mounted){
      ScaffoldMessenger.of(context).showSnackBar(SnackBar(
        content: Text(
          message.message,
          overflow: TextOverflow.fade,
        ),
      ));
    }
    setState(() => messages!.messages.add(message));
  }
  //highlight-end

  @override
  Widget build(BuildContext context) {
    return Column(
      children:[
        //highlight-start
        ...
         //highlight-end
      ]
    );
  }

  @override
  void dispose() {
    //highlight-next-line
    ...
  }
}
```

## Downloading Chat Messages

All the messages from the PubSub which where published with `persist : true` and can be downloaded as an `.csv` file. This file will be available in the VideoSDK dashboard as well as throught the [Sessions API](/api-reference/realtime-communication/fetch-session-using-sessionid).

## API Reference

The API references for all the methods and events utilised in this guide are provided below.

- [pubSub](/flutter/api/sdk-reference/pubsub-class/introduction)


---

---
title: PubSub - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: PubSub features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: PubSub
pagination_label: PubSub
keywords:
  - Start Livestream meeting
  - Stop Livestream meeting
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: pubsub
---

# PubSub - Flutter

PubSub is a short acronym for Publish-Subscribe mechanism. This mechanism is used to send and recieve messages from a particular topic. As the name suggests, for someone to send a message, they have to specify the topic and the message which should be published and for someone to receive a message, they should be subscribed to that topic.

Here is a visual to better understand publish-subscribe mechanism.

![pubsub](/img/pubsub.png)

## PubSub

In order to use PubSub in meeting, VideoSDK provides a hook `usePubSub` which allows you to subscribe to any topic and publish to any topic allowing to pass on messages and instructions during the meeting easily.

### `publish()`

- This method is used for publishing message of specific topic.
- This method can be accessed from the `pubSub` from the `Room`.
- This method will accept following parameters as input:
  - `topic`: This will be the topic where the message will be published.
  - `message`: This will be the actual message to be published. It has to be in `String` format.
  - `options`: This is an object of `PubSubPublishOptions` which specifies the options for publish. `PubSubPublishOptions` has 2 properties. 
    - `persist` : `persist` offered the option of keeping the message around for the duration of the session. When `persist` is set to `true`, that message will be retained for upcoming participants and will be available in [VideoSDK Session Dashboard](https://app.videosdk.live/meetings/sessions) with `.CSV` format after completion of session.
    - `sendOnly`: If you want to send a message to specific participants, you can pass their respective `participantId` in form of `List<String>`. If you don't provide any IDs, the message will be sent to all participants by default. This is optional parameter.
  - `payload`: If you need to include additional information along with a message, you can pass here as `Map<String, dynamic>`. This is optional parameter.


```js
import 'package:flutter/material.dart';
import 'package:videosdk/videosdk.dart';

class MeetingScreen extends StatefulWidget {
  ...
}

class _MeetingScreenState extends State<MeetingScreen> {
  late Room _room;

  @override
  void initState() {
    //highlight-next-line
    ...
  }

  @override
  Widget build(BuildContext context) {
    return Column(
      children:[
        //highlight-start
        //These will publish "Hello World!" on the "CHAT" topic
        ElevatedButton(
          onPressed:(){
            _room.pubSub.publish("CHAT", "Hello World!")
          },
          child: const Text("Send Message"),
        ),
    //highlight-end
      ]
    );
  }
}
```

## Receiving the messages

- All the previous messages for the particular topic can be recieved by subscribing to the topic.
- To subscribe to a specific topic, use can use the `subscribe()` method which will return the `Future<PubSubMessages>` and accepts the `topic` to be subscribed and a `callback function` which will be called when ever any new message is received.

- `PubSubMessages` contains the `messages` as a list of `PubSubMessage` which will contain following properties:
  - `senderId`: This represents the `participantId` of the participant who send the message.
  - `senderName`: This represents the `displayName` of the participant who send the message.
  - `message`: This will be the acatual message that was send.
  - `timestamp`: This wil the timestamp for when the message was published.
  - `topic`: This will be the name of the topic message was published to.
  - `payload`: This will be the data that you have send with message.

## Example

```js
import 'package:flutter/material.dart';
import 'package:videosdk/videosdk.dart';

class ChatView extends StatefulWidget {
  final Room room;
  ...
}

class _ChatViewState extends State<ChatView> {

  // PubSubMessages
  PubSubMessages? messages;

  @override
  void initState() {
    //highlight-next-line
    ...

    //highlight-start
    // Subscribing 'CHAT' Topic
    widget.meeting.pubSub
      .subscribe("CHAT", messageHandler)
      .then((value) => setState((() => messages = value)));
    //highlight-end
  }

  //highlight-start
  //Handler which will be called when new mesasge is received
  void messageHandler(PubSubMessage message) {
    setState(() => messages!.messages.add(message));
  }
  //highlight-end

  @override
  Widget build(BuildContext context) {
    return Column(
      children:[
        //highlight-start
        Expanded(
          child: messages == null
              ? const Center(child: CircularProgressIndicator())
              : SingleChildScrollView(
                  reverse: true,
                  child: Column(
                    children: messages!.messages
                        .map(
                          (message) => Text(
                            message.message
                          ),
                        )
                        .toList(),
                  ),
                ),
        ),
    //highlight-end
      ]
    );
  }

  @override
  void dispose() {
    //highlight-start
    // Unsubscribe
    widget.room.pubSub.unsubscribe("CHAT", messageHandler);
    //highlight-end
    super.dispose();
  }
}
```

## Applications of PubSub

PubSub is a very powerful mechanism which can be used to do alot of things which can make your meeting experience much more interactive. Some of the most common usecase that we have come across for the PubSub during a meeting are listed below:

1. [`Chat`](./chat-using-pubsub): You can utilise this to develop various Chat features, such as Private Chat and Group Chat. You can follow our chat [integration guide here](./chat-using-pubsub).
2. `Raise Hand`: You can allow attendees to raise their hands at any time during the meeting, informing everyone else that someone has done so.
3. `Layout Switching`: You can change the meeting's layout for every participant at once during the meeting, such as from Grid layout to Spotlight or Grid Layout to Sidebar Layout, etc.
4. `Whiteboard`: You can develop an interactive whiteboard functionality that is completely functional.
5. `Poll`: You may make polls, let users respond to them, and display the results at the end of a poll.
6. `Question Answer Session`: You can also design interactive functionality that is question-and-answer based.

## Downloading PubSub Messages

All the messages from the PubSub which were published with `persist : true` and can be downloaded as an `.csv` file. This file will be available in the VideoSDK dashboard as well as throught the [Sessions API](/api-reference/realtime-communication/fetch-session-using-sessionid).

## API Reference

The API references for all the methods and events utilised in this guide are provided below.

- [pubSub](/flutter/api/sdk-reference/pubsub-class/introduction)


---

---
title: Render Whiteboard - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: Whiteboard is a digital canvas that allows users to collaborate in real-time by drawing, writing, and sharing ideas visually, making it ideal for brainstorming, presentations, and teamwork.
sidebar_label: Render Whiteboard
pagination_label: Render Whiteboard
keywords:
  - Start Livestream meeting
  - Stop Livestream meeting
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg2
sidebar_position: 1
slug: render-whiteboard
---

# Render Whiteboard - Flutter

This guide explains how to dynamically render a whiteboard in your flutter application.

## Install Dependencies

- For platforms other than web, the whiteboard is rendered using a `WebView` component. You can install the necessary dependency for the same with the following command:

```js
$ flutter pub add webview_flutter
```

## Render the Whiteboard

- A whiteboard is dynamically rendered during a meeting based on whether the user is on a web or a non-web platform.
- For Web Platforms:
    - For web platforms, an `iframe` element is used to display the whiteboard. The iframe is registered dynamically through `HtmlElementView`.
- For Non-Web Platforms:
    - For non-web platforms, a `WebView` component is used. The `URL` for the whiteboard is loaded into the WebView using a `WebViewController` when the whiteboard is started.

```js
import 'package:flutter/foundation.dart';
import 'package:flutter/material.dart';
import 'package:videosdk/videosdk.dart';
import 'package:webview_flutter/webview_flutter.dart';
import 'dart:html' as html;
import 'dart:ui_web' as ui;

class MeetingScreen extends StatefulWidget {
  @override
  State<StatefulWidget> createState() => _MeetingScreenState();
  //Existing configuration
}

class _MeetingScreenState extends State<MeetingScreen> {
  late Room _room;
  bool isWhiteboardOn = false;
  late WebViewController controller;
  late html.IFrameElement iframeElement;

  @override
  void initState() {
    super.initState();
    //highlight-next-line
    setupRoomEventListener();
  }

  @override
  Widget build(BuildContext context) {
    return Column(children: [
      //highlight-start
      ElevatedButton(
        child: Text(
          isWhiteboardOn ? 'Stop Whiteboard' : 'Start Whiteboard',
        ),
        onPressed: () {
          if (isWhiteboardOn) {
            _room.stopWhiteboard();
          } else {
            _room.startWhiteboard();
          }
        },
      ),
      //highlight-end

      if (isWhiteboardOn)
        //highlight-start
        SizedBox(
          height: 300,
          width: 350,
          child: !kIsWeb
              ? WebViewWidget(
                  controller: controller,
                )
              : HtmlElementView(
                  viewType: 'iframeElement',
                ),
        ),
        //highlight-end
    ]);
  }

  void setupRoomEventListener() {
    //highlight-start
    _room.on(Events.whiteboardStarted, (url) {
      print("Whiteboard Started, url: $url");

      if (kIsWeb) {
        // Register the iframe dynamically for the web
        ui.platformViewRegistry.registerViewFactory(
          'iframeElement',
          (int viewId) => html.IFrameElement()
            ..src = url
            ..style.border = 'none'
            ..style.width = '100%'
            ..style.height = '100%',
        );
      }

      if (!kIsWeb) {
        controller = WebViewController()
          ..setJavaScriptMode(JavaScriptMode.unrestricted)
          ..loadRequest(
            Uri.parse(url),
          );
      } else {
        iframeElement = html.IFrameElement()
          ..src = url
          ..style.border = 'none'
          ..width = '100%'
          ..height = '100%';
      }

      setState(() {
        isWhiteboardOn = true;
      });
    });

    _room.on(Events.whiteboardStopped, () {
      print("Whiteboard stopped.");

      setState(() {
        isWhiteboardOn = false;
      });
    });

    //highlight-end
  }
}
```

---

---
title: Whiteboard - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: Whiteboard is a digital canvas that allows users to collaborate in real-time by drawing, writing, and sharing ideas visually, making it ideal for brainstorming, presentations, and teamwork.
sidebar_label: Start/Stop Whiteboard
pagination_label: Start/Stop Whiteboard
keywords:
  - Start Livestream meeting
  - Stop Livestream meeting
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg2
sidebar_position: 1
slug: whiteboard
---

# Whiteboard - Flutter

The Whiteboard is an interactive, shared canvas that enables users to collaborate in real-time within your Flutter application. It allows multiple participants to draw, write, and add annotations simultaneously, making it ideal for meetings, presentations, brainstorming sessions, and other collaborative activities.

This documentation will guide you on how to start and stop the whiteboard, and handle the necessary events to ensure a smooth user experience.

## `startWhiteboard()`

- To start the whiteboard session, you can call the `startWhiteboard()` method of the `Room` class, which initializes the whiteboard and makes it available for user interaction.

### Events associated with startWhiteboard

- All participants will receive the `Events.whiteboardStarted` event when the whiteboard is successfully started. This event includes a URL that can be used to render the whiteboard for interaction within the app.
- It can be subscribed to, using the `Room` object.
- The whiteboard URL can be displayed using either a `WebView` component or an `iframe` element, depending on the platform, allowing participants to interact seamlessly within the app. For detailed instructions on rendering the whiteboard, refer to this [guide](/flutter/guide/video-and-audio-calling-api-sdk/collaboration-in-meeting/render-whiteboard).


```javascript
import 'package:flutter/material.dart';
import 'package:videosdk/videosdk.dart';

class MeetingScreen extends StatefulWidget {
  //Existing configuration
}

class _MeetingScreenState extends State<MeetingScreen> {
  late Room _room;

  @override
  void initState() {
    //highlight-next-line
    setupRoomEventListener();
  }

  @override
  Widget build(BuildContext context) {
    return Column(children: [
      //highlight-start
      ElevatedButton(
        onPressed: () {
          _room.startWhiteboard();
        },
        child: const Text("Start Whiteboard"),
      ),
      //highlight-end
    ]);
  }

  void setupRoomEventListener() {
    //highlight-start
    _room.on(Events.whiteboardStarted, (url) {
      print("Whiteboard Started. Whiteboard url: $url");
    });
    //highlight-end
  }
}
```

## `stopWhiteboard()`

- To end the whiteboard session, you can call the `stopWhiteboard()` method of the `Room` class, which terminates the active whiteboard and cleans up any resources associated with it.

### Events associated with stopWhiteboard

- All participants will receive the `Events.whiteboardStopped` event when the whiteboard session is successfully terminated. This event signals that the whiteboard is no longer available for interaction within the app.
- It can be subscribed to, using the `Room` object.


```javascript
import 'package:flutter/material.dart';
import 'package:videosdk/videosdk.dart';

class MeetingScreen extends StatefulWidget {
  //Existing configuration
}

class _MeetingScreenState extends State<MeetingScreen> {
  late Room _room;

  @override
  void initState() {
    //highlight-next-line
    setupRoomEventListener();
  }

  @override
  Widget build(BuildContext context) {
    return Column(children: [
      //highlight-start
      ElevatedButton(
        onPressed: () {
          _room.stopWhiteboard();
        },
        child: const Text("Stop Whiteboard"),
      ),
      //highlight-end
    ]);
  }

  void setupRoomEventListener() {
    //highlight-start
    _room.on(Events.whiteboardStopped, (url) {
      print("Whiteboard Stopped");
    });
    //highlight-end
  }
}
```

## API Reference

- [startWhiteboard()](/flutter/api/sdk-reference/room-class/methods#startwhiteboard)
- [stopWhiteboard()](/flutter/api/sdk-reference/room-class/methods#stopwhiteboard)
- [whiteboardStarted](/flutter/api/sdk-reference/room-class/events#whiteboardstarted)
- [whiteboardStopped](/flutter/api/sdk-reference/room-class/events#whiteboardstopped)


---

---
sidebar_label: Concept And Architecture
pagination_label: Concept And Architecture
---

# Concept and Architecture - Flutter

Before diving into the concept, let's understand the VideoSDK, VideoSDK is a software development kit that offers tools and APIs for creating apps that are based on video and audio. It typically includes features such as video and audio calls, chat, cloud recording, simulcasting (RTMP), interactive live streaming (HLS), and many more across a wide range of platforms and devices.

## Concepts

![img.png](../../../static/img/room-concept.png)

### `1. Meeting / Room`

- Meeting or Room objects in the VideoSDK provide a virtual place for participants to interact and engage in real-time voice, video, and screen-sharing sessions. The object is in charge of handling media streams and participant communication.

- Meeting or Room can be uniquely identified by `meetingId` or `roomId`.

### `2. Participant`

- Participant is a VideoSDK object that represents each user/client in the meeting or room and allows them to share audio/video assets.

- `2.1 Local Participant` :
  The local participant is the one that runs on the user's device. The local participant has control over their own media streams, including the ability to start and stop audio and video.

  - The local participant in a meeting/room can also connect with other participants by transmitting and receiving audio and video streams, exchanging chat messages, and more.

- `2.2 Remote Participant` :
  The remote participant receives audio and video streams from the local participant and other remote participants and also has the ability to exchange audio, video, and chat messages with the local participant.

- Each participant in VideoSDK can be uniquely identified by `participantId`.

### `3. MediaStream & Track`

- A mediastream is a collection of audio & video tracks that can be transmitted between participants in real-time.

- A track is a continuous flow of audio or video data and can be thought of as a stream of media frames.

- A mediastream can contain multiple tracks. One video track for the video feed from the camera and one audio track for the audio feed from the microphone. These tracks can be transmitted between participants in VideoSDK Meeting / Room.

### `4. Events / Notifications`

- Events / Notifications can be used to inform users about various activities happening in a Meeting / Room, including participant join/leave and new messages. They can also be used to alert users about any SDK-level errors that occur during a call.

---

### `5. Session`

- A Session is the instance of an ongoing meeting/room which has one or more participants in it. A single room or meeting can have multiple sessions.
- Each session can be uniquely identified by `sessionId`.

![img.png](../../../static/img/meeting-session.jpg)

---

![img.png](../../../static/img/recording-hls-rtmp.png)

### `6. Cloud Recording`

- Cloud recording in VideoSDK refers to the process of recording audio or video content and storing it on a remote server or VideoSDK server.

### `7. Simulcasting (RTMP)`

- RTMP is a popular protocol for live streaming video content from a VideoSDK to platforms such as YouTube, Twitch, Facebook, and others.
- By providing the platform-specific `stream key` and `stream URL`, the VideoSDK can connect to the platform's RTMP server and transmit the live video stream.

### `8. Http Live Streaming (HLS)`

- Interactive live streaming (HLS) refers to a type of live streaming where viewers can actively engage with the content being streamed and with other viewers in real-time.

- In an interactive live stream (HLS), viewers can take part in a variety of activities like live polling, Q&A sessions, and even sending virtual gifts to the content creator or each other.

## Architecture

This diagram demonstrates end-to-end flow to implement video & audio calls, record calls, and go live on social media.

![Video-sdk-architecture!](/img/video-sdk-archietecture.svg)


---

---
title: Mute All Participants | Video SDK
hide_title: true
hide_table_of_contents: false
description: Video SDK and Audio SDK, developers need to implement a token server. This requires efforts on both the front-end and backend.
sidebar_label: Mute All Participants
pagination_label: Mute All Participants
keywords:
  - audio calling
  - video calling
  - real-time communication
  - collaboration
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: mute-all-participants
---

# Mute All Participants - Flutter

If you are the host or moderator of a video conference, you may want to mute all the participants at once. This can be useful in various scenarios, such as when you want to deliver a presentation or when there is background noise that is causing distractions.

- To achieve this, you have to iterate over the list of participants from the `Room` object and call `muteMic` method on each `Participant` object.

```javascript
import 'package:flutter/material.dart';
import 'package:videosdk/videosdk.dart';

class MeetingScreen extends StatefulWidget {
  ...
}

class _MeetingScreenState extends State<MeetingScreen> {
  late Room _room;

  @override
  void initState() {
    ...
  }

  @override
  Widget build(BuildContext context) {
    return Column(
      children:[
        ElevatedButton(
          child: Text("Mute all participants"),
          onPressed: () => {
            _room.participants.values.forEach((participant) {
              participant.muteMic();
            });
        }),
      ]
    );
  }
}
```

:::note
Participant who will be muting other participants should have permission **`allow_mod`** passed in the token. To know more about permissions [**visit here**](/react-native/guide/video-and-audio-calling-api-sdk/authentication-and-token).
:::

### API Reference

The API references for all the methods and events utilised in this guide are provided below.

- [muteMic()](/flutter/api/sdk-reference/participant-class/methods#mutemic)


---

---
title: Toggle Remote Participant Media | Video SDK
hide_title: true
hide_table_of_contents: false
description: Video SDK and Audio SDK, developers need to implement a token server. This requires efforts on both the front-end and backend.
sidebar_label: Toggle Remote Participant Media
pagination_label: Toggle Remote Participant Media
keywords:
  - audio calling
  - video calling
  - real-time communication
  - collaboration
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: remote-participant-media
---

# Toggle Remote Participant Media - Flutter

When hosting a meeting, it's important that the host of the meeting should be able to request someone's Mic or Camera to be turned on or should be able to turn them off.

:::note
Participant who will be controlling other participant's mic and camera should have permission **`allow_mod`** passed in the token. To know more about permissions [**visit here**](/flutter/guide/video-and-audio-calling-api-sdk/authentication-and-tokens).
:::

Before we discuss the methods and events associated with this functionality, here is how the flow would look like.

![img1](/img/toggle-remote-media.png)

## Methods

### `unmuteMic()`

- If you wish to turn **on** the microphone of a participant, you will be calling the `unmuteMic()` on the `Participant` object.

- When this method is called, the participant whose microphone is requested will receive the `Events.micRequested` event with the `participantId` of the participant who requested it and two callback functions `accept` and `reject` which should be called based on decision made by the user.

- **Example:** Meeting is running with **Participant A** and **Participant B**. Now **Participant A** wants to unmute Mic of **Participant B**, so **Participant A** will use `unmuteMic()` function to request **Participant B**, after that **Participant B** recieve the `Events.micRequested` event, from there user can either accept or reject the incoming request.

### `enableCam()`

- If you wish to turn **on** the camera of a participant, you will be calling the `enableCam()` from the `useParticipant` hook.

- When this method is called, the participant whose camera is requested will receive the `Events.cameraRequested` event with the `participantId` of the participant who requested it and two callback functions `accept` and `reject` which should be called based on decision made by the user.

- **Example:** Meeting is running with **Participant A** and **Participant B**. Now **Participant A** wants to Enable Cam of **Participant B**, so **Participant A** will use `enableCam()` function to request **Participant B**, after that **Participant B** recieve the `Events.cameraRequested` event, from there user can either accept or reject the incoming request.

### `muteMic()`

- If you wish to turn **off** the microphone of a participant, you will be calling the `muteMic()` on the `Participant` object.
- This will disable the microphone of the participant.

### `disableCam()`

- If you wish to turn **off** the camera of a participant, you will be calling the `disableCam()` on the `Participant` object.
- This will disable the camera of the participant.

#### Example

```js
import 'package:flutter/material.dart';
import 'package:videosdk/videosdk.dart';

class ParticipantTile extends StatefulWidget {
  final Participant participant;
  const ParticipantTile({super.key, required this.participant});

  @override
  State<ParticipantTile> createState() => _ParticipantTileState();
}

class _ParticipantTileState extends State<ParticipantTile> {

  @override
  Widget build(BuildContext context) {
    return Column(
      children: [
        ElevatedButton(
          child: Text("Enable Mic"),
          onPressed: () => {
            widget.participant.unmuteMic();
        }),
        ElevatedButton(
          child: Text("Disable Mic"),
          onPressed: () => {
            widget.participant.muteMic();
        }),
        ElevatedButton(
          child: Text("Enable Cam"),
          onPressed: () => {
            widget.participant.enableCam();
        }),
        ElevatedButton(
          child: Text("Disable Cam"),
          onPressed: () => {
            widget.participant.disableCam();
        }),
      ],
    );
  }
}
```

## Events

### `camemaRequested`

This event will be emitted to the `Participant B` when any other `Participant A` requests to enable webcam of that participant (`Participant B`). This event handler will receieve following three arguments in the `Map<String, dynamic>`:

- `accept()` - Callback function to accept the request.
- `reject()` - Callback function to reject the request.
- `participantId` - ParticipantId of the requesting participant

### `micRequested`

This event will be emitted to the `Participant B` when any other `Participant A` requests to enable mic of that participant (`Participant B`). This event handler will receieve following three arguments in the `Map<String, dynamic>`:

- `accept()` - Callback function to accept the request.
- `reject()` - Callback function to reject the request.
- `participantId` - ParticipantId of the requesting participant

###### Usage

```js
import 'package:flutter/material.dart';
import 'package:videosdk/videosdk.dart';

class MeetingScreen extends StatefulWidget {
  ...
}

class _MeetingScreenState extends State<MeetingScreen> {
  late Room room;

  @override
  void initState() {
    //highlight-next-line
    ...

    setupRoomEventListener();
  }

  @override
  Widget build(BuildContext context) {
    return YourMeetingWidget();
  }

  //highlight-start
  void setupRoomEventListener() {
    //Event for mic request
    room.on(Events.micRequested, (_data_) {
      log("_data => $_data");
      dynamic accept = _data['accept'];
      dynamic reject = _data['reject'];

      log("accept => $accept reject => $reject");

      // Mic Request Dialog
      showDialog(
        context: navigatorKey.currentContext!,
        builder: (context) => AlertDialog(
          title: const Text("Mic requested?"),
          content: const Text("Do you want to turn on your mic? "),
          actions: [
            TextButton(
              onPressed: () {
                reject();

                Navigator.of(context).pop();
              },
              child: const Text("Reject"),
            ),
            TextButton(
              onPressed: () {
                accept();

                Navigator.of(context).pop();
              },
              child: const Text("Accept"),
            ),
          ],
        ),
      );
    });

    // Called when camera is requested
    room.on(Events.cameraRequested, (_data) {
      log("_data => $_data");
      dynamic accept = _data['accept'];
      dynamic reject = _data['reject'];

      log("accept => $accept reject => $reject");

      // camera Request Dialog
      showDialog(
        context: navigatorKey.currentContext!,
        builder: (context) => AlertDialog(
          title: const Text("Camera requested?"),
          content: const Text("Do you want to turn on your Camera? "),
          actions: [
            TextButton(
              onPressed: () {
                reject();

                Navigator.of(context).pop();
              },
              child: const Text("Reject"),
            ),
            TextButton(
              onPressed: () {
                accept();

                Navigator.of(context).pop();
              },
              child: const Text("Accept"),
            ),
          ],
        ),
      );
    });
  }
  //highlight-end
}
```

import ReactPlayer from 'react-player'

<div style={{textAlign: 'center'}}>

<ReactPlayer autoplay muted loop playing url='/video/toggle-media.mp4' width={"100%"}/>

</div>

## API Reference

The API references for all the methods and events utilised in this guide are provided below.

- [unmuteMic()](/flutter/api/sdk-reference/participant-class/methods#unmutemic)
- [muteMic()](/flutter/api/sdk-reference/participant-class/methods#mutemic)
- [enableCam()](/flutter/api/sdk-reference/participant-class/methods#enablecam)
- [disableCam()](/flutter/api/sdk-reference/participant-class/methods#disablecam)
- [Events.cameraRequested](/flutter/api/sdk-reference/room-class/events#camerarequested)
- [Events.micRequested](/flutter/api/sdk-reference/room-class/events#micrequested)


---

---
title: Remove participant from the meeting - React JS SDK
hide_title: false
hide_table_of_contents: false
description: Remove a participant or a peer from the meeting while it is still in progress. It helps in meeting moderation.
sidebar_label: Remove Participant
pagination_label: Remove Participant
keywords:
  - remove participant
  - block participant
  - react js
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: remove-participant
---

# Remove Participant - Flutter

This feature in a meeting allows the meeting host or organizer to remove a participant from the meeting. This can be helpful in situations where a participant is causing a disturbance, is behaving inappropriately, or is not following meeting guidelines.

VideoSDK provide three ways to remove participant from meeting.

1. [Using SDK](#1-using-sdk)
2. [Using VideoSDK Dashboard](#2-using-videosdk-dashboard)
3. [Using Rest API](#3-using-rest-api)

## 1. Using SDK

### `remove()`

Remove participant allows removing participant while session is on-going. This can be helpful when moderation in particular meeting is required.

```js
import 'package:flutter/material.dart';
import 'package:videosdk/videosdk.dart';

class ParticipantTile extends StatefulWidget {
  final Participant participant;
  const ParticipantTile({super.key, required this.participant});

  @override
  State<ParticipantTile> createState() => _ParticipantTileState();
}

class _ParticipantTileState extends State<ParticipantTile> {

  @override
  Widget build(BuildContext context) {
    return ElevatedButton(
      child: Text("Remove ${widget.participant.displayName}"),
      onPressed: () => {
        widget.participant.remove();
    });
  }
}
```

### Events associated with remove

Following callbacks are received when a participant is removed from the meeting.

- Participant who was removed from the meeting will receive a callback on[`roomLeft`](/flutter/api/sdk-reference/room-class/events#roomleft) on `Room` object.
- All other [remote participants](../concept-and-architecture#2-participant) will receive a callback [`participantLeft`](/flutter/api/sdk-reference/room-class/events#participantleft) with `participantId`.

## 2. Using VideoSDK Dashboard

- You can go the session page on [VideoSDK Dashboard](https://app.videosdk.live/meetings/sessions) and select the meeting you can to remove a participant from.
- And then from the participants list you can remove any participant you want.

import ReactPlayer from 'react-player'

<div style={{textAlign: 'center'}}>

<ReactPlayer autoplay muted loop playing url='/video/kickout-user.mp4' width={"100%"}/>

</div>

## 3. Using Rest API

- You can also remove the particular participant from the meeting [using the REST API](/api-reference/realtime-communication/remove-participant).
- To use this method, you should have the `sessionId` of the meeting and `participantId` of the participant who is supposed to be removed.

## API Reference

The API references for all the methods and events utilised in this guide are provided below.

- [remove()](/flutter/api/sdk-reference/participant-class/methods#remove)
- [Events.roomLeft](/flutter/api/sdk-reference/room-class/events#roomleft)
- [Events.participantLeft](/flutter/api/sdk-reference/room-class/events#participantleft)


---

---
title: Share your Screen Video & Audio Call - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: Share your Screen features quick integrate in Flutter IOS with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Flutter iOS Screen Share
pagination_label: Flutter iOS Screen Share
keywords:
  - Start Screen share
  - Stop Screen share
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: flutter-ios-screen-share
---

# Share screen - Flutter iOS

iOS requires you to add an Broadcast Upload Extension to capture the screen to the device.

:::note

Flutter iOS screenshare is available from the SDK version 1.0.5 and above and the deployment target for iOS app should be **iOS 14 or newer**
:::

## Create Broadcast Upload Extension in iOS

### Step 1 : Open Target

Open your project with xcode, select **File > New > Target** in menu bar.

![IOS Screen Share](/img/ios-screenshare/step1-xcode.png)

### Step 2 : Select Target

Choose **Broadcast Upload Extension**, and click next.

![IOS Screen Share](/img/ios-screenshare/step2-xcode.png)

### Step 3 : Configure Broadcast Upload Extension

Enter extensions name in **Product Name** field, choose team from dropdown, Uncheck include UI extension field and click finish.

![IOS Screen Share](/img/ios-screenshare/step3-xcode.png)

### Step 4 : Activate Extension scheme

You will be prompted **Activate "Your-Extension-name" scheme?** pop-up, click activate.

![IOS Screen Share](/img/ios-screenshare/step4-xcode.png)

Now, broadcast folder will appear in xcode left side bar.

![IOS Screen Share](/img/ios-screenshare/step5-xcode.png)

### Step 5 : Add External file in Created Extension

Open [videosdk-rtc-flutter-sdk-example](https://github.com/videosdk-live/videosdk-rtc-flutter-sdk-example/tree/main/ios/FlutterBroadcast), Copy `SampleUploader.swift`, `SocketConnection.swift`, `DarwinNotificationCenter.swift`, and `Atomic.swift` files to your extension's folder and make sure they're added to the target.

### Step 6 : Update `SampleHandler.swift` file

Open [SampleHandler.swift](https://github.com/videosdk-live/videosdk-rtc-flutter-sdk-example/blob/main/ios/FlutterBroadcast/SampleHandler.swift) and Copy `SampleHandler.swift` file content and paste it to your extensions `SampleHandler.swift` file.

### Step 7 : Add Capability in App

In Xcode, go to **YourappName > Signing & Capabilities**. and click on **+Capability** to configure app group.

![IOS Screen Share](/img/ios-screenshare/step8-xcode.png)

Select **App Groups** from list

![IOS Screen Share](/img/ios-screenshare/step9-xcode.png)

After that, you have to select or add generated app group id which you have created before.

![IOS Screen Share](/img/ios-screenshare/step10-xcode.png)

### Step 8 : Add Capability in Extension

Go to **Your-Extension-Name > Signing & Capabilities** and configure **App Group** functionality which we had perform in previous steps. (Group id should be same for both targets)

![IOS Screen Share](/img/ios-screenshare/step11-xcode.png)

### Step 9 : Add App Group Id in Extension File

Go to extensions `SampleHandler.swift` file and paste your group Id in `appGroupIdentifier` constant.

![IOS Screen Share](/img/ios-screenshare/step12-xcode.png)

### Step 10 : Update App level info.plist file

1.  Add a new key **RTCScreenSharingExtension** in Info.plist with the extension's Bundle Identifier as the value.
2.  Add a new key **RTCAppGroupIdentifier** in Info.plist with the extension's App groups Id as the value.

**Note** : For extension's Bundle Identifier, go to **TARGETS > Your-Extension-Name > Signing & Capabilities** .

![IOS Screen Share](/img/ios-screenshare/step13-xcode.png)

:::note

You can also check out extension [example code](https://github.com/videosdk-live/videosdk-rtc-flutter-sdk-example/tree/main/ios/FlutterBroadcast) on github
:::

## Enable Screen Share

- In order to start screen-sharing just call `room.enableScreenShare()` method.

```js
ElevatedButton(
    child: Text("Start ScreenSharing"),
    onPressed: () {
        room.enableScreenShare();
    },
),
```

![IOS Screen Share](/img/ios-screenshare/step23-xcode.png)

After clicking **Start Broadcast** button, we wiil be able to get the screen stream in session.

## Disable Screen Share

By using `room.disableScreenShare()` function, a participant can stop publishing screen stream to other participants.

```js
ElevatedButton(
    child: Text("Stop ScreenSharing"),
    onPressed: () {
        room.disableScreenShare();
    },
),
```


---

---
title: Camera Controls Video & Audio Call - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: Camera Controls features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Camera Controls
pagination_label: Camera Controls
keywords:
  - Camera on
  - Camera off
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: camera-controls
---

import NoIndex from '../../../../mdx/\_no-index.mdx';

<NoIndex/>

# Camera Controls - Flutter

Whenever any participant wants to start/stop broadcasting their video to other participant in a room, they can simply do it with VideoSDK Room.

This guide will provide an overview of how to implement enable, disable and switch camera features in a room.

1. **Enable Camera** - By using `enableCam()` function, a participant can publish camera stream to other participants.
2. **Disable Camera** - By using `disableCam()` function, a participant can stop publishing camera stream to other participants.
3. **Switch Camera** - By using `changeCam()` function, a participant can stream from front / rear camera during the room.This function is only applicable for Mobile devices.

### Enable, Disable And Switch Camera

```js
ElevatedButton(
  onPressed: room.disableCam,
  child: Text("disable camera"),
),
ElevatedButton(
  onPressed: room.enableCam,
  child: Text("enable camera"),
),
ElevatedButton(
  onPressed:  () {
    room.changeCam("<device>")
  },
  child: Text("changeCam"),
),
```

### Events

**Events associated with `enableWebcam()`:**

- [`streamEnabled`](../../../api/sdk-reference/participant-class/events.md#streamenabled) event will be emitted with [`stream`](../../../api/sdk-reference/stream-class/introduction.md) object from the event callback, inside that [participant](../../../api/sdk-reference/participant-class/introduction.md) object.

**Events associated with `disableWebcam()`:**

- [`streamDisabled`](../../../api/sdk-reference/participant-class/events.md#streamdisabled) event will be emitted with [`stream`](../../../api/sdk-reference/stream-class/introduction.md) object from the event callback, inside that [participant](../../../api/sdk-reference/participant-class/introduction.md) object.

```js
participant.on(Events.streamEnabled, (Stream stream){
  if (stream.kind === "video") {
    //particiapnt turned on video
    //Render Participant video logic here
  }
});
participant.on(Events.streamDisabled, (Stream stream){
  if (stream.kind === "video") {
    //particiapnt turned off video
    //remove Participant video logic here
  }
});
```


---

---
title: Custom Participant ID - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: Custom participant id features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Custom Participant ID
pagination_label: Custom Participant ID
keywords:
  - custom participant id
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: custom-participant-id
---

import NoIndex from '../../../../mdx/\_no-index.mdx';

<NoIndex/>

# Custom Participant ID - Flutter

- Whenever any participant joins room, it is assigned a new unique participant id every time.

- To assign an unique participant id manually to local participant, specify participant id while creating Room using `createRoom()` method.

```js
createRoom(
    .
    .
    participantId: "abcd-efgh-ijkl", // custom participant id
),
```


---

---
title: Custom Audio Track
hide_title: false
hide_table_of_contents: false
description: Custom Audio Track features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Custom Audio Track
pagination_label: Custom Audio Track
keywords:
  - Camera on
  - Camera off
  - Webcam on
  - Webcam off
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
---

import NoIndex from '../../../../../mdx/\_no-index.mdx';

<NoIndex/>

# Custom Audio Track - Flutter

We have introduced the ability to pass a custom Audio track for the Audio of the participants. This feature can be used to add custom layers like background noise removal, echo cancellation, etc. on audio and send it to other participants.

## Creating a Custom Audio Track

- You can create a Audio Track using `createMicrophoneAudioTrack()` method of `VideoSDK` class.
- This method can be used to create audio track using different encoding parameters and noise cancellation configuration.

### Parameters

- **microphoneId**:

  - type: `String`
  - required: `false`
  - It will be the id of the mic from which the audio should be captured.

- **encoderConfig**:

  - type: `CustomTrackAudioConfig`
  - required: `false`
  - default: `speech_standard`
  - Allowed values : `speech_low_quality` | `speech_standard` | `music_standard` | `standard_stereo` | `high_quality` | `high_quality_stereo`
  - It will be the encoder configuration you want to use for Audio Track.

- **noiseConfig**

  - **echoCancellation**

    - type: `boolean`
    - required: `false`
    - If `true` echo cancellation will turned on else it would be turned off.

  - **autoGainControl**

    - type: `boolean`
    - required: `false`
    - If `true` auto gain will turned on else it would be turned off.

  - **noiseSuppression**
    - type: `boolean`
    - required: `false`
    - If `true` noise suppression will turned on else it would be turned off.

#### Returns

- `Future<CustomTrack?>`

### Example

```javascript
CustomTrack? audioTrack = await VideoSDK.createMicrophoneAudioTrack(
        encoderConfig: CustomAudioTrackConfig.high_quality);
```

## Using Custom Audio Track

### Custom Track while initializing the meeting

If you are passing `micEnabled: true` in the `createRoom` and want to use custom tracks from start of the meeting, you can pass custom track in the `createRoom` as shown below.

```javascript
CustomTrack? audioTrack = await VideoSDK.createMicrophoneAudioTrack(
        encoderConfig: CustomAudioTrackConfig.high_quality);

Room room = VideoSDK.createRoom(
      roomId: widget.meetingId,
      token: widget.token,
      displayName: widget.displayName,
      micEnabled: widget.micEnabled,
      camEnabled: widget.camEnabled,
      maxResolution: 'hd',
      defaultCameraIndex: 1,
      multiStream: false,

      // Pass the custom track here
      customMicrophoneAudioTrack: audioTrack, // custom audio track :: optional
      notification: const NotificationInfo(
        title: "Video SDK",
        message: "Video SDK is sharing screen in the meeting",
        icon: "notification_share", // drawable icon name
      ),
    );
```

### Custom Track with `unmuteMic()`

In order to switch tracks during the meeting, you have to pass the `CustomTrack` in the `room.unmuteMic()` method.

:::note

Make sure to call `muteMic()` before you create a new track as it may lead to unexpected behavior.

:::

```javascript
CustomTrack? audioTrack = await VideoSDK.createMicrophoneAudioTrack(
        encoderConfig: CustomAudioTrackConfig.high_quality);

room.unmuteMic(customTrack);
```


---

---
title: Custom Video Track
hide_title: false
hide_table_of_contents: false
description: Custom Video Track features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Custom Video Track
pagination_label: Custom Video Track
keywords:
  - Camera on
  - Camera off
  - Webcam on
  - Webcam off
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
---

import NoIndex from '../../../../../mdx/\_no-index.mdx';

<NoIndex/>

# Custom Video Track - Flutter

We have introduced the ability to pass a custom video track for the video of the participants. This feature can be used to add custom video encoder config, and background removal & video filter from external SDK(e.g., [Banuba](https://www.banuba.com/)) and send it to other participants.

## Creating a Custom Video Track

- You can create a Video Track using `createCameraVideoTrack()` method of `VideoSDK` class.
- This method can be used to create video track using different encoding parameters, camera facing mode, and optimization mode.

### Parameters

- **cameraId**:

  - type: `String`
  - required: `false`
  - It will be the id of the camera from which the video should be captured.

- **encoderConfig**:

  - type: `CustomVideoTrackConfig`
  - required: `false`
  - default: `h360p_w640p`
  - Allowed values : `h90p_w160p` | `h180p_w320p` | `h216p_w384p` | `h360p_w640p` | `h540p_w960p` | `h720p_w1280p` | `h1080p_w1920p` | `h1440p_w2560p` | `h2160p_w3840p` | `h120p_w160p` | `h180p_w240p` | `h240p_w320p` | `h360p_w480p` | `h480p_w640p` | `h540p_w720p` | `h720p_w960p` | `h1080p_w1440p` | `h1440p_w1920p`
  - It will be the encoderConfigs you can want to use for the Video Track.

:::note

Above mentioned encoder configurations are valid for both, landscape as well as portrait mode.

:::

- **facingMode**:

  - type: `FacingMode`
  - required: `false`
  - Allowed values : `FacingMode.front` | `FacingMode.environment`
  - It will specify whether to use front or back camera for the video track.

- **multiStream**

  - type: `boolean`
  - required: `false`
  - default: true
  - It will specify if the stream should send multiple resolution layers or single resolution layer.

  :::info

  - For meetings with fewer than or equal to four participants, setting `multiStream:false` is regarded as best practice.
  - This parameter is only available from `v1.0.9`.

  :::

#### Returns

- `Future<CustomTrack?>`

### Example

```javascript
CustomTrack? videoTrack = await VideoSDK.createCameraVideoTrack(
      encoderConfig: CustomVideoTrackConfig.h1440p_w1920p,
      multiStream: false,
      facingMode:"user",
    );
```

## Using Custom Video Track

### Custom Track while initializing the meeting

If you are passing `webcamEnabled: true` in the `createRoom` and want to use custom tracks from start of the meeting, you can pass custom track in the `createRoom` params as shown below.

```javascript
CustomTrack? videoTrack = await VideoSDK.createCameraVideoTrack(
      encoderConfig: CustomVideoTrackConfig.h1440p_w1920p,
      multiStream: false,
      facingMode:"user",
    );

Room room = VideoSDK.createRoom(
      roomId: widget.meetingId,
      token: widget.token,
      displayName: widget.displayName,
      micEnabled: widget.micEnabled,
      camEnabled: widget.camEnabled,
      maxResolution: 'hd',
      defaultCameraIndex: 1,
      multiStream: false,

      // Pass the custom track here
      customCameraVideoTrack: videoTrack, // custom video track :: optional
      notification: const NotificationInfo(
        title: "Video SDK",
        message: "Video SDK is sharing screen in the meeting",
        icon: "notification_share", // drawable icon name
      ),
    );
```

### Custom Track with `enableCam()`

In order to switch tracks during the meeting, you have to pass the `CustomTrack` in the `room.enableCam()` method.

:::note

Make sure to call `disableCam()` before you create a new track as it may lead to unexpected behavior.

:::

```javascript
CustomTrack? track = await VideoSDK.createCameraVideoTrack(
  facingMode: "environment",
  encoderConfig: CustomVideoTrackConfig.h1440p_w1920p,
  multiStream: true,
);
room.enableCam(track);
```


---

---
title: Entry - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: Entry features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Entry Request-Response
pagination_label: Entry Request-Response
keywords:
  - entry request response
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: entry-request-response
---

import NoIndex from '../../../../mdx/\_no-index.mdx';

<NoIndex/>

# Entry Request-Response - Flutter

- When anyone joins room, he/she will request for joining room and that request will get either accepted or denied by host.

## Entry Request

- When anyone asks for joining in your room, `Events.entryRequested` event is triggered with data having

  - `participantId` - This is the Id of participant, who have requested for joining room
  - `name` - This is the name of the participant.
  - `allow()` - Call this method if you want to allow that participant
  - `deny()` - Call this method if you want to deny that participant

```js
room.on(Events.entryRequested, (data) {
  var participantId = data['participantId'];
  var name = data["name"];
  var allow = data["allow"];
  var deny = data["deny"];

  showDialog(
    context: context,
    builder: (context) => AlertDialog(
      title: const Text("Join Request"),
      content: Text("Do you want to allow $name to join room?"),
      actions: [
        TextButton(
          child: const Text("Deny"),
          onPressed: () {
            deny();
            Navigator.of(context).pop();
          },
        ),
        TextButton(
          child: const Text("Allow"),
          onPressed: () {
            allow();
            Navigator.of(context).pop();
          },
        ),
      ],
    ),
  );
});
```

## Entry Respond

- If you have requested for joining room, `Events.entryResponded` is triggered when host accept or deny room.

  - `decision` - This will tell you, if you are allowed to join or not

```js
room.on(Events.entryResponded, (data) {
  var decision = data['decision'];
  if (id == room.localParticipant.id) {
    if (decision == 'allowed') {
      print("Allowed to join the room.");
    } else {
      print("Denied to join the room.");
    }
  }
});
```


---

---
sidebar_label: Error Event
pagination_label: Error Event
---

import NoIndex from '../../../../mdx/\_no-index.mdx';

<NoIndex/>

# Error Event - Flutter

This event is helpful for development level troubleshooting while integrating SDK.

Whenever any invalid configuration provided or server/network errors arise, this event will trigger with a specific error code and message.

This event can ease your development process.

We have depicted a specific error name with code and message in the below table.

| Error Name                            | Code | Message                                                                                                                     |
| ------------------------------------- | ---- | --------------------------------------------------------------------------------------------------------------------------- |
| **INVALID_API_KEY**                   | 4001 | `apikey` provided in the token is empty or invalid, please verify it on the dashboard.                                      |
| **INVALID_TOKEN**                     | 4002 | `token` is empty or invalid or might have expired.                                                                          |
| **INVALID_MEETING_ID**                | 4003 | `meetingId` is empty or invalid, please verify it or generate new meetingId using the API.                                  |
| **INVALID_PARTICIPANT_ID**            | 4004 | `participantId` is empty or invalid, it shouldn't contain any whitespaces.                                                  |
| **DUPLICATE_PARTICIPANT**             | 4005 | Leaving meeting, since this `participantId` joined from another device.                                                     |
| **ACCOUNT_DEACTIVATED**               | 4006 | It seems your account is deactivated by VideoSDK for some reason, you can reach out to us at `support@videosdk.live`.       |
| **ACCOUNT_DISCONTINUED**              | 4007 | _Server will respond you with specific message._                                                                            |
| **INVALID_PERMISSIONS**               | 4008 | `permissions` provided in the token are invalid, please don't use `allow_join` or `allow_mod` with `ask_join`.              |
| **MAX_PARTICIPANT_REACHED**           | 4009 | You have reached max participant limit in a meeting to increase contact at support@videosdk.live :)                          |
| **MAX_PARTICIPANT_REACHED**            | 4009 | You have reached max participant limit in a meeting.                                                                         |
| **MAX_SPEAKER_REACHED**               | 4010 | You have reached max speaker limit in a meeting.                                                                            |
| **START_RECORDING_FAILED**            | 4011 | Recording start request failed due to an unknown error.                                                                     |
| **STOP_RECORDING_FAILED**             | 4012 | Recording stop request failed due to an unknown error.                                                                      |
| **START_LIVESTREAM_FAILED**           | 4013 | Livestream start request failed due to an unknown error.                                                                    |
| **STOP_LIVESTREAM_FAILED**            | 4014 | Livestream stop request failed due to an unknown error.                                                                     |
| **INVALID_LIVESTREAM_CONFIG**         | 4015 | Livestream 'outputs' configuration provided was invalid.                                                                    |
| **START_HLS_FAILED**                  | 4016 | HLS start request failed due to an unknown error.                                                                           |
| **STOP_HLS_FAILED**                   | 4017 | HLS stop request failed due to an unknown error.                                                                            |
| **PREV_RECORDING_PROCESSING**         | 4018 | Previous recording session is being processed, please try again after few seconds!                                          |
| **PREV_RTMP_RECORDING_PROCESSING**    | 4019 | Previous RTMP recording session is being processed, please try again after few seconds!                                     |
| **PREV_HLS_STREAMING_PROCESSING**     | 4020 | Previous HLS streaming session is being processed, please try again after few seconds!                                      |
| **MAX_SPEAKER_LIMIT_REACHED_ON_ORGANIZATION**    | 4026 | You have reached max speaker limit on organization. To increase contact at support@videosdk.live".                                                               |
| **MAX_VIEWER_LIMIT_REACHED_ON_ORGANIZATION**    | 4027 | You have reached max viewer limit on organization. To increase contact at support@videosdk.live".                                                               |
| **MAX_RECORDING_LIMIT_REACHED_ON_ORGANIZATION**    | 4028 | You have reached max limit of recording on organization. To increase contact at support@videosdk.live.                                                               |
| **MAX_HLS_LIMIT_REACHED_ON_ORGANIZATION**    | 4029 | You have reached max limit of hls on organization. To increase contact at support@videosdk.live.                                                               |
| **MAX_LIVESTREAM_LIMIT_REACHED_ON_ORGANIZATION**    | 4030 | You have reached max limit of livestream on organization. To increase contact at support@videosdk.live.                                                               |
| **RECORDING_FAILED**                  | 5001 | Recording stopped due to an unknown error.                                                                                  |
| **LIVESTREAM_FAILED**                 | 5002 | Livestream stopped due to an unknown error.                                                                                 |
| **HLS_FAILED**                        | 5003 | HLS stopped due to an unknown error.                                                                                        |
| **RECORDING_DURATION_LIMIT_REACHED**  | 5004 | Recording has been automatically stopped by the system, due to max duration limit of 2 hours reached for a single Recording |
| **LIVESTREAM_DURATION_LIMIT_REACHED** | 5005 | Livestream has been automatically stopped by the system, due to max duration limit of 2 hours reached for a single RTMP     |
| **HLS_DURATION_LIMIT_REACHED**        | 5006 | Hls has been automatically stopped by the system, due to max duration limit of 2 hours reached for a single HLS             |
| **ERROR_STARTING_VIDEO**              | 3011 | Some error occured during starting the video                                                                                |
| **ERROR_STARTING_AUDIO**              | 3012 | Some error occured during starting the audio.                                                                               |
| **ERROR_STARTING_SCREENSHARE**        | 3013 | Some error occured during starting the screen share.                                                                        |

### Event Code

You can get all the error codes from `VideoSDKErrors` which is a `Map<int, Map<String, String>>` containing all the errors.

```js

//add listener for the error events.
_meeting.on(Events.error, (error) {
  log("VIDEOSDK ERROR :: " +
      error['code'].toString() +
      "  :: " +
      error['name'].toString() +
      " :: " +
      error['message'].toString());
});
```


---

---
title: RTMP Live Social Media Video & Audio Call - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: RTMP Live Social Media features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Go Live On Social Media
pagination_label: Go Live On Social Media
keywords:
  - Facebook Live
  - Youtube Live
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: go-live-social-media
---

import NoIndex from '../../../../mdx/\_no-index.mdx';

<NoIndex/>

# Go Live On Social Media - Flutter

This feature allows participant to broadcast room on various social media platforms such as Facebook or Youtube.
This guide will provide an overview of how participant can start and stop broadcasting room.

1. **Start LiveStream** - By using `startLivestream()` function, a participant can start broadcasting room on various platforms by provding url and stream keys as an argument.

### Parameters

- **outputs**

  - type: `Array`
  - required: `true`
  - It will the array of object containing the url and stream keys.

- **config**:
  - type: `Object`
    - **config**:
      - **layout**:
        - **type**: _"GRID"_ | _"SPOTLIGHT"_ | _"SIDEBAR"_
        - **priority**: _"SPEAKER"_ | _"PIN"_
        - **gridSize**: Number _\`max 4\`_
      - **theme**: _"DARK"_ | _"LIGHT"_ | _"DEFAULT"_
  - required: `false`
  - It will be config for the layout of the recording you can to use.

2. **Stop LiveStream** - By using `stopLivestream()` function, a participant can stop broadcasting on all platforms.

### Start And Stop Live Stream

```js
// Start Live Stream
room.startLivestream([
  {
    url: "rtmp://a.rtmp.youtube.com/live2",
    streamKey: "streamKey1",
  },
], config: {
  'layout': {
    'type': 'GRID',
    'priority': 'SPEAKER',
    'gridSize': 4,
  },
  'theme': "LIGHT",
});

// Stop Live Stream
room?.stopLivestream();
```

### Events

1. **livestreamStateChanged** - Whenever broadcasting of meeting started / stopped, `livestreamStateChanged` event will trigger.

```js
room.on(Events.liveStreamStateChanged, (String status) {

  //Status can have values:
  // LIVESTREAM_STARTING -- Live Stream is starting
  // LIVESTREAM_STARTED -- Live Stream has started
  // LIVESTREAM_STOPPING -- Live Stream is stopping
  // LIVESTREAM_STOPPED -- Live Stream has stopped

  toastMsg("Meeting live streaming status : $status");
});
```


---

---
title: Leave End Room Video & Audio Call - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: Leave or End Room features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Leave or End Room
pagination_label: Leave or End Room
keywords:
  - Exit Room
  - Leave Room
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: leave-end-room
---

import NoIndex from '../../../../mdx/\_no-index.mdx';

<NoIndex/>

# Leave or End Room - Flutter

Whenever participant wishes to end their communication in the room, they can simply leave the room.

This guide will provide an overview of how to implement leave or end feature in VideoSDK rooms.

1. **Leave** - By using `leave()` function, only a participant will leave/exit the room, the rest of the room will continue with other participants.
2. **End** - By using `end()` function, room will end for each and every participant. So, use this function according to your use cases.

### Leave And End Room

```js
// Leave the room
room.leave();

// End Room Session
room.end();
```

### Events

**Events associated with `leave()`:**

- Local participant will receive a [`roomLeft`](../../../api/sdk-reference/room-class/events.md#roomleft) event.
- All remote participants will receive a [`participantLeft`](../../../api/sdk-reference/room-class/events.md#participantleft) event with `participantId`.

**Event associated with `end()`:**

- All [participants](../../../api/sdk-reference/participant-class/introduction.md) and [localParticipant](../../../api/sdk-reference/participant-class/introduction.md), will be emitted with [`roomLeft`](../../../api/sdk-reference/room-class/events.md#roomleft) event.

```js
room.on(Events.roomLeft, () => {
  //room Left
});

room.on(Events.participantLeft, (participant) => {
  //Participant Left the room
});
```


---

---
title: Manage Participants Video & Audio Call - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: Manage Participants features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Manage Participants
pagination_label: Manage Participants
keywords:
  - Exit Room
  - Leave Room
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: manage-participants
---

import NoIndex from '../../../../mdx/\_no-index.mdx';

<NoIndex/>

# Manage Participants - Flutter

## 1. Local Participant (self)

Local participant is used to consume your video & audio streams.
it contains information about local participant such as displayName, id, quality and streams Map.

You can access localParticipant from the [room object](./start-join-room#2-initialization).

### Participant object properties

| Property Name | Type          | Description                                         |
| ------------- | ------------- | --------------------------------------------------- |
| id            | string        | Unique id of the participant.                       |
| displayName   | string        | The name you define during the room initialization. |
| local         | boolean       | Indicates the participant is local or not.          |
| quality       | string        | Indicates the participant streams quality.          |
| Streams       | Map of Stream | Returns Video & Audio Streams.                      |

### Stream Object properties

| Property Name | Type   | Description        |
| ------------- | ------ | ------------------ |
| id            | string | Unique id          |
| codec         | string | Video/Audio codec. |
| kind          | string | Stream Kind.       |
| track         | string | MediaStreamTrack   |

## 2. Other Participants (Except You)

Other participants Map is used to get all the participants (except you) in the room at any given time.

Other participants Map contains same properties as [LocalParticipant](/flutter/guide/video-and-audio-calling-api-sdk/features/manage-participants#participant-object-properties).

### ParticipantTile

```js title=participant_tile.dart
import 'package:flutter/material.dart';
import 'package:videosdk/videosdk.dart';
import '../../utils/toast.dart';

class ParticipantTile extends StatefulWidget {
  final Participant participant;
  final bool isLocalParticipant;
  const ParticipantTile({
    Key? key,
    required this.participant,
    this.isLocalParticipant = false,
    }): super(key: key);

  @override
  State<ParticipantTile> createState() => _ParticipantTileState();
}

class _ParticipantTileState extends State<ParticipantTile> {
  Stream? shareStream;
  Stream? videoStream;
  Stream? audioStream;
  String? quality;

  @override
  void initState() {
    _initStreamListeners();
    super.initState();
  }

  @override
  Widget build(BuildContext context) {
    return Container(
        margin: const EdgeInsets.all(4.0),
        decoration: BoxDecoration(
          color: Theme.of(context).backgroundColor.withOpacity(1),
          border: Border.all(color: Colors.white38),
        ),
        child: AspectRatio(
          aspectRatio: 1,
          child: Padding(
            padding: const EdgeInsets.all(4.0),
            child: Stack(
              children: [
                videoStream != null
                    ? RTCVideoView(
                        videoStream?.renderer as RTCVideoRenderer,
                        objectFit:
                            RTCVideoViewObjectFit.RTCVideoViewObjectFitCover,
                      )
                    : const Center(
                        child: Icon(
                          Icons.person,
                          size: 180.0,
                          color: Color.fromARGB(140, 255, 255, 255),
                        ),
                      ),
                Positioned(
                  bottom: 0,
                  left: 0,
                  child: FittedBox(
                    fit: BoxFit.scaleDown,
                    child: Container(
                      padding: const EdgeInsets.all(2.0),
                      decoration: BoxDecoration(
                        color: Theme.of(context).backgroundColor.withOpacity(0.2),
                        border: Border.all(color: Colors.white24),
                        borderRadius: BorderRadius.circular(4.0),
                      ),
                      child: Text(
                        widget.participant.displayName,
                        textAlign: TextAlign.center,
                        style: const TextStyle(
                          color: Colors.white,
                          fontSize: 10.0,
                        ),
                      ),
                    ),
                  ),
                ),
                Positioned(
                  top: 0,
                  left: 0,
                  child: InkWell(
                    child: Container(
                      padding: const EdgeInsets.all(4),
                      decoration: BoxDecoration(
                        shape: BoxShape.circle,
                        color: audioStream != null
                            ? Theme.of(context).backgroundColor
                            : Colors.red,
                      ),
                      child: Icon(
                        audioStream != null ? Icons.mic : Icons.mic_off,
                        size: 16,
                      ),
                    ),
                    onTap: widget.isLocalParticipant
                        ? null
                        : () => audioStream != null
                              ? widget.participant.unmuteMic()
                              : widget.participant.muteMic(),
                  ),
                ),
                Positioned(
                  top: 0,
                  right: 0,
                  child: InkWell(
                    child: Container(
                      padding: const EdgeInsets.all(4),
                      decoration: BoxDecoration(
                        shape: BoxShape.circle,
                        color: videoStream != null
                            ? Theme.of(context).backgroundColor
                            : Colors.red,
                      ),
                      child: Icon(
                        videoStream != null
                            ? Icons.videocam
                            : Icons.videocam_off,
                        size: 16,
                      ),
                    ),
                    onTap: widget.isLocalParticipant
                        ? null
                        : () => videoStream != null
                                  ? widget.participant.disableCam()
                                  : widget.participant.enableCam(),
                  ),
                ),
                if (!widget.isLocalParticipant)
                  Positioned(
                    bottom: 0,
                    right: 0,
                    child: InkWell(
                      child: Container(
                        padding: const EdgeInsets.all(4),
                        decoration: const BoxDecoration(
                          shape: BoxShape.circle,
                          color: Colors.red,
                        ),
                        child: const Icon(
                          Icons.logout,
                          size: 16,
                        ),
                      ),
                      onTap: () {
                        showDialog(
                            context: context,
                            builder: (context) => AlertDialog(
                                  title: const Text("Are you sure ?"),
                                  actions: [
                                    TextButton(
                                      child: const Text("Yes"),
                                      onPressed: () {
                                        widget.participant.remove();
                                        toastMsg("Participant removed");
                                        Navigator.of(context).pop();
                                      },
                                    ),
                                    TextButton(
                                      child: const Text("No"),
                                      onPressed: () => Navigator.of(context).pop(),
                                    )
                                  ],
                                ));
                      },
                    ),
                  ),
              ],
            ),
          ),
        ),
    );
  }

  _initStreamListeners() {
    widget.participant.on(Events.streamEnabled, (Stream _stream) {
      setState(() {
        if (_stream.kind == 'video') {
          videoStream = _stream;
        } else if (_stream.kind == 'audio') {
          audioStream = _stream;
        } else if (_stream.kind == 'share') {
          shareStream = _stream;
        }
      });
    });

    widget.participant.on(Events.streamDisabled, (Stream _stream) {
      setState(() {
        if (_stream.kind == 'video' && videoStream?.id == _stream.id) {
          videoStream = null;
        } else if (_stream.kind == 'audio' && audioStream?.id == _stream.id) {
          audioStream = null;
        } else if (_stream.kind == 'share' && shareStream?.id == _stream.id) {
          shareStream = null;
        }
      });
    });
  }
}
```

```js title=participant_grid_view.dart
import 'dart:developer';
import 'package:flutter/material.dart';
import 'package:videosdk/videosdk.dart';
import 'participant_tile.dart';

class ParticipantGridView extends StatefulWidget {
  final Room room;
  const ParticipantGridView({
    Key? key,
    required this.room,
  }) : super(key: key);

  @override
  State<ParticipantGridView> createState() => _ParticipantGridViewState();
}

class _ParticipantGridViewState extends State<ParticipantGridView> {
  String? activeSpeakerId;
  Participant? localParticipant;
  Map<String, Participant> participants = {};

  @override
  void initState() {
    // Initialize participants
    localParticipant = widget.room.localParticipant;
    participants = widget.room.participants;

    // Setting room event listeners
    setRoomListeners(widget.room);
    super.initState();
  }

  @override
  Widget build(BuildContext context) {
    return GridView.count(
      crossAxisCount: 2,
      children: [
        ParticipantTile(
          participant: localParticipant!,
          isLocalParticipant: true,
        ),
        ...participants.values
            .map((participant) => ParticipantTile(participant: participant))
            .toList()
      ],
    );
  }

  void setRoomListeners(Room _room_) {
    // Called when participant joined room
    _room.on(
      Events.participantJoined,
      (Participant participant) {
        final newParticipants = participants;
        newParticipants[participant.id] = participant;
        setState(() {
          participants = newParticipants;
        });
      },
    );

    // Called when participant left room
    _room.on(
      Events.participantLeft,
      (participantId) {
        final newParticipants = participants;

        newParticipants.remove(participantId);
        setState(() {
          participants = newParticipants;
        });
      },
    );

    // Called when speaker is changed
    _room.on(Events.speakerChanged, (_activeSpeakerId) {
      setState(() {
        activeSpeakerId = _activeSpeakerId;
      });
    });
  }
}
```

## 3. Participant Related Events

1. **participantJoined** - Whenever any new participant join the room, `participantJoined` event will trigger. For example, the room is running with **Alice** and **Bob**, then **Eve** join that room, after that `participantJoined` event trigger and return the [participant object](/flutter/guide/video-and-audio-calling-api-sdk/features/manage-participants#participant-object-properties).

2. **participantLeft** - Whenever any participant leave/exit the room, `participantLeft` event will trigger.For example, the room is running with **Alice** and **Bob**, then **Bob** leave that room, after that `participantLeft` event trigger and return the [participant object](/flutter/guide/video-and-audio-calling-api-sdk/features/manage-participants#participant-object-properties)

3. **speakerChanged** - Whenever any participant starts actively speaking in room, `speakerChanged` event will trigger and return the speaker `participantId`.

4. **presenterChanged** - Whenever any participant present/screenshare their screen/window in room, `presenterChanged` event will trigger and return the presenter `participantId`.

5. **streamEnabled** - Whenever any participant enabled mic/camera in room, `streamEnabled` event will trigger and return `Stream`.

6. **streamDisabled** - Whenever any participant disabled mic/camera in room, `streamDisabled` event will trigger and return `Stream`.

```js
// Adding event listner
room.on(Events.participantJoined, (Participant participant) {
  print("new participant => $participant");
  },
);

room.on(Events.participantLeft, (Participant participant) {
  print("new participant => $participant");
  },
);

room.on(Events.presenterChanged, (activePresenterId) {
  print("presenter changed => $activePresenterId");
  },
);
```


---

---
title: Mic Controls Video & Audio Call - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: Mic Controls features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Mic Controls
pagination_label: Mic Controls
keywords:
  - Mic on
  - Mic off
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: mic-controls
---

import NoIndex from '../../../../mdx/\_no-index.mdx';

<NoIndex/>

# Mic Controls - Flutter

Whenever any participant wants to start / stop broadcasting their audio to other participant in room, they can simply do it with VideoSDK room.

This guide will provide an overview of how to use enable and disable Mic in a room.

1. **Enable Mic** - By using `unmuteMic()` function, a participant can publish audio to other participants.
2. **Disable Mic** - By using `muteMic()` function, a participant can stop publishing audio to other participants.
3. **Change Mic** - By using `changeMic()` function, a participant can change mic.

### Enable, Disable, Change Mic

```js
ElevatedButton(
  onPressed: room.unmuteMic,
  child: Text("unmuteMic"),
),
ElevatedButton(
  onPressed: room.muteMic,
  child: Text("muteMic"),
),

// changeMic() method is coming soon in flutter.
```

### Events

**Events associated with `unmuteMic()`:**

- [`streamEnabled`](../../../api/sdk-reference/participant-class/events.md#streamenabled) event will be emitted with [`stream`](../../../api/sdk-reference/stream-class/introduction.md) object from the event callback, inside that [participant](../../../api/sdk-reference/participant-class/introduction.md) object.

**Events associated with `muteMic()`:**

- [`streamDisabled`](../../../api/sdk-reference/participant-class/events.md#streamdisabled) event will be emitted with [`stream`](../../../api/sdk-reference/stream-class/introduction.md) object from the event callback, inside that [participant](../../../api/sdk-reference/participant-class/introduction.md) object.

```js
participant.on(Events.streamEnabled, (Stream stream){
  if (stream.kind === "audio") {
    //particiapnt turned on audio
  }
});
participant.on(Events.streamDisabled, (Stream stream){
  if (stream.kind === "audio") {
    //particiapnt turned off audio
  }
});
```


---

---
title: Pause/Resume Video Stream - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: Pause/Resume Video Stream features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Pause/Resume Video Stream
pagination_label: Pause/Resume Video Stream
keywords:
  - pause/resume video stream
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: pause-resume-video-stream
---

import NoIndex from '../../../../mdx/\_no-index.mdx';

<NoIndex/>

# Participant Video Stream - Flutter

- Using this feature, you can pause/resume participant's video stream.

## Pause video stream

- `pause()` method is used to pause videostream of a participant.

```js
ElevatedButton(
  child: Text("Pause Video"),
  onPressed: () {
    List<Stream> streams = participant.streams.where((e) => e.kind == 'video').toList();

    if(streams.length != 0){
      Stream videoStream = streams[0];
      videoStream.track.pause();
    }
  }
),
```

## Resume video stream

- `resume()` method is used to resume videostream of a participant.

```js
ElevatedButton(
  child: Text("Resume Video"),
  onPressed: () {
    List<Stream> streams = participant.streams.where((e) => e.kind == 'video').toList();

    if(streams.length != 0){
      Stream videoStream = streams[0];
      videoStream.track.resume();
    }
  }
),

```

## Events

**Event associated with `pause()`:**

- [`streamPaused`](../../../api/sdk-reference/participant-class/events.md#streampaused) event will be emitted with [`stream`](../../../api/sdk-reference/stream-class/introduction.md) object from the event callback, inside that [participant](../../../api/sdk-reference/participant-class/introduction.md) object.

**Event associated with `resume()`:**

- [`streamResumed`](../../../api/sdk-reference/participant-class/events.md#streamresumed) event will be emitted with [`stream`](../../../api/sdk-reference/stream-class/introduction.md) object from the event callback, inside that [participant](../../../api/sdk-reference/participant-class/introduction.md) object.

```js
participant.on(Events.streamPaused, (Stream stream){
  if (stream.kind === "video") {
    //particiapnt video stream paused
  }
});
participant.on(Events.streamResumed, (Stream stream){
  if (stream.kind === "video") {
    //particiapnt video stream resumed
  }
});
```


---

---
sidebar_label: Send Message using PubSub
pagination_label: PubSub
---

import NoIndex from '../../../../mdx/\_no-index.mdx';

<NoIndex/>

# PubSub - Flutter

PubSub feature allows the participant to send and receive messages of the topics which he has subscribed.

## Methods

### publish()

This method is use for publishing message of specific topic.

#### Syntax

```js
  Future<void> publish(
    String topic,
    String message,
    [PubSubPublishOptions options]
  )
```

| Parameter Name | Type                 | Description                                                                                                                                       |
| -------------- | -------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------- |
| topic          | String               | This should be the topic for which you are publishing a message.                                                                                  |
| message        | String               | This is the actual message, which will be published to participants, who had subscribed to a particular topic.                                    |
| options        | PubSubPublishOptions | This is an object of PubSubPublishOptions, which provides an option, such as `persist`, which persists message history for upcoming participants. |

#### Example

```js
  // publish()
  ElevatedButton(
    onPressed: () async {
      // Publish a message
      await room.pubSub.publish(
        "CHAT", // Topic
        "Hello from Flutter!", // Message Content
        const PubSubPublishOptions(
          "persist": true // Stores the message in server for future participants
        ),
      );

      print("Message published");
    },
    child: Text("Publish"),
  ),
```

<br />

### subscribe()

This method is used to subscribe for particular topic. This method returns a list of messages which were sent earlier.

#### Syntax

```js
  Future<PubSubMessages> subscribe(
    String topic,
    Function(PubSubMessage) messageHandler,
  )
```

| Parameter Name | Type   | Description                                                                 |
| -------------- | ------ | --------------------------------------------------------------------------- |
| topic          | String | This should be the topic to be subscribed.                                  |
| messageHandler | String | This is a handler function, which will be called when new message received. |

#### Example

```js
  // subscribe()
  ElevatedButton(
    onPressed: () async {
      // Subscribe 'CHAT' topic and get persisted messages
      var messages = await room.pubSub.subscribe("CHAT", messageHandler);

      // Printing message list
      print("Messages: ${messages.messages.map((msg) => msg.message).join(" ")}");
    },
    child: Text("Subscribe"),
  ),

  // Message Handler
  void messageHandler(msg){
    // Do something
    print("New message received: $msg");
  }
```

### unsubscribe()

This method is used to unsubscribe the message topic.

#### Syntax

```js
  Future<void> unsubscribe(
    String topic,
    Function(PubSubMessage) messageHandler,
  )
```

| Parameter Name | Type   | Description                                                    |
| -------------- | ------ | -------------------------------------------------------------- |
| topic          | String | This should be the topic to be unsubscribed.                   |
| messageHandler | String | This is a handler function, which was passed in `subscribe()`. |

#### Example

```js
  // unsubscribe
  ElevatedButton(
    onPressed: () {
      // Unsubscribe 'CHAT' topic
      await room.pubSub.unSubscribe("CHAT", messageHandler);
    },
    child: Text("UnSubscribe"),
  ),
```

## Sample Code

```js
import 'package:flutter/material.dart';
import 'package:videosdk/videosdk.dart';

// ChatScreen
class ChatScreen extends StatefulWidget {
  final Room room;
  const ChatScreen({required this.room});

  @override
  _ChatScreenState createState() => _ChatScreenState();
}

class _ChatScreenState extends State<ChatScreen> {
  @override
  void initState() {
    super.initState();

    widget.room.pubSub.subscribe("CHAT", messageHandler)
      .then((messages) =>
          print("Subscribed to chat: ${messages.messages.map((msg) => msg.message).join(" ")}"));
  }

  @override
  Widget build(BuildContext context) {
    final room = widget.room;
    return Scaffold(
      appBar: AppBar(title: const Text("PubSub Sample Code")),
      body: Center(
        child: ElevatedButton(
          child: const Text("Send Hello !"),
          // Publish Hello message
          onPressed: () => room.pubSub.publish(
            "CHAT",
            "Hello",
            const PubSubPublishOptions(persist: true),
          ),
        ),
      ),
    );
  }

  // Handle incoming messages
  void messageHandler(PubSubMessage message) {
    print("New message: ${message.message}");
  }

  @override
  void dispose() {
    // Unsubscribe
    widget.room.pubSub.unsubscribe("CHAT", messageHandler);
    super.dispose();
  }
}

```


---

---
title: Record Room Video & Audio Call - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: Record Room features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Record Room
pagination_label: Record Room
keywords:
  - Start Recording Room
  - Stop Recording Room
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: recording-room
---

import NoIndex from '../../../../mdx/\_no-index.mdx';

<NoIndex/>

# Record Room - Flutter

Record room allows participants to record video & audio during the room. The recording files are available in developer dashboard.
Any participant can start / stop recording any time during the room.

This guide will provide an overview of how to implement start and stop Room Recording.

1. **Start Recording** - By using `startRecording()` function, a participant can start room recording.

### Parameters

- **webhookUrl**:

  - type: `String`
  - required: `false`
  - It will be webhook url where you want to get teh status of the recording.

- **awsDirPath**:

  - type: `String`
  - required: `false`
  - It will be path for your AWS storage specifing where to store the recording file.

- **config**:

  - type: `Object`
    - **config**:
      - **layout**:
        - **type**: _"GRID"_ | _"SPOTLIGHT"_ | _"SIDEBAR"_
        - **priority**: _"SPEAKER"_ | _"PIN"_
        - **gridSize**: Number _\`max 4\`_
      - **theme**: _"DARK"_ | _"LIGHT"_ | _"DEFAULT"_
      - **mode**: _"video-and-audio"_ | _"audio"_
      - **quality**: _"low"_ | _"med"_ | _"high"_
      - **orientation**: _"landscape"_ | _"portrait"_
  - required: `false`
  - It will be config for the layout of the recording you can to use.

2. **Stop Recording** - By using `stopRecording()` function, a participant can stop room recording.

### Start And Stop Recording

```js
// Start Recording
room.startRecording(config: {
  'layout': {
    'type': 'GRID',
    'priority': 'SPEAKER',
    'gridSize': 4,
  },
  'theme': "LIGHT",
  "mode": "video-and-audio".
  'quality':'high'
});

// Stop Recording
room.stopRecording(),
```

### Events

- **recordingStateChanged** - Whenever meeting recording state changes, then `recordingStateChanged` event will trigger.

```js
room.on(Events.recordginStateChanged, (String status) {

  // Status can have values -
  // RECORDING_STARTING -- Recording is starting
  // RECORDING_STARTED -- Recording is started
  // RECORDING_STOPPING -- Recording is stopping
  // RECORDING_STOPPED -- Recording is stopped

  toastMsg("Meeting recording status : $status");
});
```


---

---
title: Remove Participant - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: Remove Participant features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Remove Participant
pagination_label: Remove Participant
keywords:
  - remove participant
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: remove-participant
---

import NoIndex from '../../../../mdx/\_no-index.mdx';

<NoIndex/>

# Remove Participant - Flutter

- Whenever any participant (having privileges) wants to remove other participant in room, he/she can do it with this feature.

- `Participant` class provides the `remove()` method to remove participant from the room.

```js
ElevatedButton(
    child: Text("Remove Participant"),
    onPressed: () {
        participant.remove();
    },
),
```

:::note
To remove any participant, you must have appropriate permissions
:::


---

---
title: Share your Screen Video & Audio Call - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: Share your Screen features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Share Your Screen
pagination_label: Share Your Screen
keywords:
  - Start Screen share
  - Stop Screen share
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: screenshare
---

import NoIndex from '../../../../mdx/\_no-index.mdx';

<NoIndex/>

# Share Your Screen - Flutter

- Whenever any participant wants to share a complete screen of mobile, they can simply do it with VideoSDK Room.

- This guide will provide an overview of how to enable or disable Screen Share in a room.

## Enable Screen Share

- `Room` class provides the method to enable screen-sharing.

- In order to start screen-sharing just call `room.enableScreenShare()` method.

```js
ElevatedButton(
    child: Text("Start ScreenSharing"),
    onPressed: () {
        room.enableScreenShare();
    },
),
```

:::caution

For Flutter iOS Screen Share feature, you need to follow this guide [Flutter iOS Screen Share](../extras/flutter-ios-screen-share)
:::

### Customise notification

- When a presenter starts screen share, presenter will receive a notification with a pre-defined title and messages.

- You can Customise those title, message and icon as per your requirements using `NotificationInfo` class and passed to `createRoom()` method.

```js
VideoSDK.createRoom(
    .
    .
    notification: const NotificationInfo(
        title: "Video SDK",
        message: "Video SDK is sharing screen in the room",
        icon: "notification_share", // drawable icon name
    ),
),
```

## Disable Screen Share

By using `room.disableScreenShare()` function, a participant can stop publishing screen stream to other participants.

```js
ElevatedButton(
    child: Text("Stop ScreenSharing"),
    onPressed: () {
        room.disableScreenShare();
    },
),
```

## Display Screen Share Stream

#### Local Participant

When a Local participant share the screen, `streamEnabled` Event on the `Participant` is triggered with the `Stream` which can be added to a `RTCVideoView`.

```js
room.localParticipant.on(Events.streamEnabled, (Stream _stream) {
    if (_stream.kind == 'share') {
        screenShareStream = _stream;
      }
    });
```

#### Other Participants

When other participant(Except you) share their screen, `presenterChanged` Event on the `Participant` is triggered with the `participantId` of the screen share.

```js
room.on(Events.presenterChanged, (_activePresenterId) {
    Participant? activePresenterParticipant = room.participants[_activePresenterId];

    Stream? _stream = activePresenterParticipant?
                        .streams.values
                        .singleWhere((e) => e.kind == "share");

    remoteParticipantShareStream = _stream;
});
```


---

---
title: Set Video Quality - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: Set Video Quality features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Set Video Quality
pagination_label: Set Video Quality
keywords:
  - set video quality
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: set-video-quality
---

import NoIndex from '../../../../mdx/\_no-index.mdx';

<NoIndex/>

# Set Video Quality - Flutter

- Set Video Quality feature allows participants to set other participant's video quality during the room.

- `Participant` class provides the `setQuality()` method to set participant's video quality.

```js
ElevatedButton(
    child: Text("Set High Quality"),
    onPressed: () {
        // Set Video Quality

        // High Quality
        participant.setQuality('high');

        // Medium Quality
        participant.setQuality('med');

        // Low Quality
        participant.setQuality('low');

    },
),
```


---

---
title: Set Viewport
hide_title: false
hide_table_of_contents: false
sidebar_label: Set Viewport
pagination_label: Set Viewport
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: set-viewport
---

import NoIndex from '../../../../mdx/\_no-index.mdx';

<NoIndex/>

# Set Viewport - Flutter

When you are working with Video Calling, video quality is the most important part of communication. When a participant is shown on the screen, consuming multiple high quality although not required, will result in more memory and CPU usage of the device, eventually degrading quality.

The way to optimize around these situation is to consume the video quality which is required to fit the view of a particular participant, resulting in better quality, less usage of network bandwidth and providing a better experience.

Viewport is the size of window or visible area in which video for the participant is shown. We can optimize the consuming video quality based on the viewport size of the participant. For example if the viewport size of a particular participant view is `480x360`, VideoSDK will download a `480x360` stream. If a participant on screen is present in bigger size, VideoSDK will provide a higher quality video for that particular participant only.

import ReactPlayer from 'react-player'

<div style={{textAlign: 'center'}}>

<ReactPlayer autoplay muted loop playing url='/img/viewport_illustration.mp4' width={"100%"}/>

</div>

### setViewPort()

`setViewPort()` can be used to achieve the best optimization of the video. This method is called with the `width` and `height` of the participant view on the `Participant` object and VideoSDK will handle the rest.

##### Parameters

- `width`

  - type: `int`
  - Width of the participant view for which the quliaty of video is to be adjusted.

- `height`
  - type: `int`
  - Height of the participant view for which the quliaty of video is to be adjusted.

### Example

```js
class ParticipantTile extends StatefulWidget {
  final Participant participant;
  final bool isLocalParticipant;
  const ParticipantTile(
      {Key? key, required this.participant, this.isLocalParticipant = false})
      : super(key: key);

  @override
  State<ParticipantTile> createState() => _ParticipantTileState();
}

class _ParticipantTileState extends State<ParticipantTile> {
  //create a widgetKey which can be used to refer the Video container
  GlobalKey _widgetKey = GlobalKey();

  @override
  Widget build(BuildContext context) {
    return Container(
        key: _widgetKey, //assign key to reference this view
        child: <Your Widget Here for Displaying participant>
    );
  }

  //call this method whenever the widget height of width gets changed.
  //it can be during stream enabled, stream resume, etc
  onViewPortChange() {
    try {
      //get the renderbox
      final RenderBox renderBox =
          _widgetKey.currentContext?.findRenderObject() as RenderBox;
      _widgetKey.currentContext?.size;

      //Get Size of the renderbox
      final Size size = renderBox.size;

      //apply setViewPort on the participant with height and width of view
      widget.participant.setViewPort(size.width, size.height);
    } catch (exception) {
      log("Unable to set Viewport $exception");
    }
  }
}
```


---

---
title: Speaker Indication Video & Audio Call - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: Speaker Indication features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Speaker Indication
pagination_label: Speaker Indication
keywords:
  - Active Speaker
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: speaker-indication
---

import NoIndex from '../../../../mdx/\_no-index.mdx';

<NoIndex/>

# Speaker Indication - Flutter

Speaker indication feature in VideoSDK let you know, which participant in a room is active speaker.

Whenever any participant speaks in room, `speakerChanged` event will trigger.

For example, the room is running with **Alice** and **Bob**. Whenever any of them speaks, `speakerChanged` event will trigger and return the speaker `participantId`.

We can access `speakerChanged` event through [room object](./start-join-room#2-initialization).

### speakerChanged Event

```js
room.on(Events.speakerChanged, (activeSpeakerId) {
  print("participantId => $activeSpeakerId");
});
```


---

---
title: Start join Room Video & Audio Call - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: Start or join Room features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Start or Join Room
pagination_label: Start or Join Room
keywords:
  - Join audio calling
  - Join video calling
  - Join real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: start-join-room
---

import NoIndex from '../../../../mdx/\_no-index.mdx';

<NoIndex/>

# Start or Join Room - Flutter

<div style={{display:'flex',flexDirection:'row',alignItems:'stretch',}}>
<div style={{}}>
<p>After the successful installation of VideoSDK, the next step is to integrate VideoSDK features with your webApp/MobileApp.</p>

<p>To Communicate with other participant's audio or video call, you will need to join the room.</p>

<p>This guide will provide an overview of how to configure, initialize and join a VideoSDK room.</p>

</div>
<div>
<img src="/img/gif/new-meeting.gif"/>
</div>

</div>

## 1. Configuration

To configure a room, you will need [generated token](/flutter/guide/video-and-audio-calling-api-sdk/server-setup) and [roomId](/api-reference/realtime-communication/create-room), we had discussed in [Server Setup](/flutter/guide/video-and-audio-calling-api-sdk/server-setup).
This code snippet calls API from local server

**Scenario 1** - Suppose you **don't have** any roomId, you can simply generate roomId by invoking `create-room` API.

**Scenario 2** - Suppose you **have** roomId, now you don't have to call `create-room` API to generate roomId, instead you can call `validate-room` API to validate roomId.

**Token generation API is necessary for both scenario.**

```js
import 'dart:convert';
import 'package:http/http.dart' as http; // For API Calling, you need to add third party package "http"
import 'package:videosdk/videosdk.dart';

// States Defined in Stateful Component.
String? roomId;
String? token;

void _getRoomIdAndToken() async {
    final LOCAL_SERVER_URL = dotenv.env['LOCAL_SERVER_URL'];

    // Calling get-token API.
    final Uri tokenUrl = Uri.parse('$LOCAL_SERVER_URL/get-token');
    final http.Response tokenResponse = await http.get(tokenUrl);

    final dynamic _token = json.decode(tokenResponse.body)['token'];

    // Calling create-room API.
    final Uri roomIdUrl =
        Uri.parse('$LOCAL_SERVER_URL/create-room/');

    final http.Response roomIdResponse =
        await http.post(roomIdUrl, body: {"token": _token});

    final _roomId = json.decode(roomIdResponse.body)['roomId'];

    // Setting into states of stateful widget
    setState(() {
      token = _token;
      roomId = _roomId;
    });
  }

  // This API is for validate the room id
  // Not require to call this API after create room API

dynamic validateRoom(token, roomId) async {
    final String LOCAL_SERVER_URL = dotenv.env['LOCAL_SERVER_URL'];
    final Uri validateRoomUrl =
        Uri.parse('$LOCAL_SERVER_URL/validate-room/$roomId');
    final http.Response validateRoomResponse =
        await http.post(validateRoomUrl, body: {"token": token});
    final _roomId = json.decode(validateRoomResponse.body)['roomId'];
    if (_roomId != null) {
      return _roomId;
    } else {
      return null;
    }
  }

```

## 2. Initialization

<div style={{display:'flex',flexDirection:'row',alignItems:'stretch',}}>
<div style={{}}>
<p>
After configuration, you will have to Initialize 
<p>
room by providing name, roomId, micEnabled, camEnabled & maxResolution.
</p>
</p>

</div>
<div>
<img src="/img/gif/add-participant.gif"/>
</div>

</div>

```js
import 'package:flutter/material.dart';
import 'package:videosdk/videosdk.dart';

class MyApp extends StatelessWidget {
  final Room = VideoSDK.createRoom(
    roomId: "<Id-of-Room>",
    displayName: "<Name-of-participant>",
    micEnabled: "<Flag-to-enable-mic>",
    camEnabled: "<Flag-to-enable-cam>",
    token: "<Authentication-token>",
    notification: const NotificationInfo(
      title: "Video SDK",
      message: "Video SDK is sharing screen",
      icon: "notification_share",
    ),
  );
    @override
    Widget build(BuildContext context) {
        return return Container(); // Returning widget
    }
}
```

## 3. Join

<div style={{display:'flex',flexDirection:'row',alignItems:'stretch',}}>
<div style={{}}>
<p>
After configuration & initialization, the third step is to call join() to join a room.
</p>

<p>
After joining, you will be able to Manage Participant in a room.
</p>

</div>
<div>
<img src="/img/gif/join-meeting.gif"/>
</div>

</div>

```js
// Join the room
room?.join();
```

## Events

Following events are emitted on the `room` when it is successfully joined.

- Local Participant will receive a [`roomJoined`](../../../api/sdk-reference/room-class/events.md#roomjoined) event when successfully joined.
- Remote Participant will receive a [`participantJoined`](../../../api/sdk-reference/room-class/events.md#participantjoined) event with the newly joined [`Participant`](../../../api/sdk-reference/participant-class/introduction.md) object from the event callback.

```js
room.on(Events.roomJoined, () => {
  print("Room Joined Successfully");
});

room.on(Events.participantJoined, (participant) => {
  print("New Participant Joined");
});
```


---

---
sidebar_label: Switch Audio Output (BETA)
pagination_label: Switch Audio Output (BETA)
---

import NoIndex from '../../../../mdx/\_no-index.mdx';

<NoIndex/>

# Switch Audio Output (BETA) - Flutter

This feature will help yout to switch audio output device during the session.

## Get Connected Device List

This method will help you to list down all possible connected audio devices.

To get the list of all available audio output devices, use the `getAudioOutputDevices()`, which will return a list of `MediaDeviceInfo`.

`MediaDeviceInfo` will contain the `deviceId` and `label` of the particular audio output device.

```js

ElevatedButton(
  child: Text("Get Output Device"),
  onPressed: () => {
    List<MediaDeviceInfo> outputDevice = meeting.getAudioOutputDevices()
    log(outputDevice);
  }),
```

## Switch Audio to Another Device

This method will help you to switch specific audio output device.

```js
// Pass the MediaDeviceInfo object to which the audio is to be switched.
meeting.switchAudioOutput(mediaDeviceInfo);
```

:::note

`EARPIECE` is not supported whenever `WIRED_HEADSET` or `BLUETOOTH` device is connected
:::

To check the implementation of switch audio device in detail, check out the [Flutter Code Sample](https://github.com/videosdk-live/videosdk-rtc-flutter-sdk-example)


---

---
title: Toggle Participant Media
hide_title: false
hide_table_of_contents: false
description: Camera Controls features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Toggle Participant Media
pagination_label: Toggle Participant Media
keywords:
  - Camera on
  - Camera off
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: toggle-participant-media
---

import NoIndex from '../../../../mdx/\_no-index.mdx';

<NoIndex/>

# Toggle Participant Media - Flutter

Control other participant's camera and mic.
For better idea, let's understand this with a real case scenario

**Scenario 1 (Online Class)** - In this scenario, the lecturer(Local Participant) will control the student's(Other Participant) camera and mic as per his/her needs.

**Scenario 2 (Online Events)** - In this scenario, the event hosts will control the audience camera and mic when someone wants to speak.

This guide will provide an overview of how to control other participant camera and mic in a room.

1. **Enable camera of Participant** - By using `enableCam()` function, a `cameraRequested` event will trigger on requested participant side.

   **Example** : Room is running with **User A** and **User B**. Now **User A** wants to Enable camera of **User B**, so **User A** will use `enableCam()` function to request **User B**, after that **User B** receive the `cameraRequested` event, from there user can either accept or reject the incoming request.

2. **Disable camera of Participant** - By using `disableCam()` function, camera of that participant will be turned off.

   **Example** : **User A** wants to Disable camera of **User B**, so **User A** will use `disableCam()` function to Disable it without any request.

3. **Unmute Mic of Participant** - By using `unmuteMic()` function, a `micRequested` event will trigger on requested participant side.

   **Example** : Room is running with **User A** and **User B**. Now **User A** wants to Enable Mic of **User B**, so **User A** will use `unmuteMic()` function to request **User B**, after that **User B** will receive the `micRequested` event, from there user can either accept or reject the incoming request.

4. **Mute Mic of Participant** - By using `muteMic()` function, Mic of that participant will disable.

   **Example** : **User A** wants to Disable Mic of **User B**, so **User A** will use `mute()` function to Disable it without any request.

:::note

To achieve this feature, you need to pass `allow_join` persmission while genearting token for room initialization. After that you will be able to access participant media methods.

[How to apply permission while generating token?](/flutter/guide/video-and-audio-calling-api-sdk/server-setup)

:::

### Request Media Methods

```js
const participants = room.participants;
const participant = participants.get("<participant-id>");

// This will emit an event called "cameraRequested" to that particular participant
participant.enableCam();

// This will directly disable camera of particular participant
participant.disableCam();

// This will emit an event called "micRequested" to that particular participant
participant.unmuteMic();

// This will directly disable mic of particular participant
participant.muteMic();
```

### Manage Requested Media Events

1. **cameraRequested** - This event will be emitted to the participant `B` when any other participant `A` requests to enable camera of that participant `B`. This event handler will receive following three arguments:

   - `accept()` - Callback function to accept the request.
   - `reject()` - Callback function to reject the request.

<div style={{height: "10px"}}></div>

2. **micRequested** - This event will be emitted to the participant `B` when any other participant `A` requests to enable mic of that participant `B`. This event handler will receieve following three arguments:

   - `accept()` - Callback function to accept the request.
   - `reject()` - Callback function to reject the request.

```js
// Handle camera Requested
widget.room.on(Events.cameraRequested, ({ accept, reject }) {
    // callback function to accept the request
    accept();

    // callback function to reject the request
    reject();
}, );

// Handle Mic Requested
widget.room.on(Events.micRequested, ({ accept, reject }) {
     // callback function to accept the request
    accept();

    // callback function to reject the request
    reject();
}, );
```


---

---
title: Integrate Flutter SDK - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: Build customizable real-time video & audio calling applications in Flutter SDK with Video SDK add live Video & Audio conferencing to your applications.
sidebar_label: Integrate Flutter SDK
pagination_label: Integrate Flutter SDK
keywords:
  - flutter sdk
  - dart sdk
  - javascript sdk
  - sky sdk
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: flutter-sdk
---

# Getting Started - Flutter SDK

Flutter SDK is natively written SDK using Dart. It is compatible with iOS, Android, Web and Desktop (MacOS, Windows) apps.

## SDK Compatibility

| Android and iOS  | Web (Beta)           | Desktop (Beta) | Safari              | 
|------------------|----------------|---------------------------|---------------------|
| <center> :white_check_mark: </center>| <center> :white_check_mark: </center>| <center> :white_check_mark: </center> | <center> :x: </center>| 

## Installing Flutter SDK

Flutter SDK is client for real-time communication for android and ios devices. It inherits the same terminology as all other SDKs does.

### Step 1: Add this package in your flutter project

VideoSDK flutter SDK canbe added using the following command:

```bash
flutter pub add videosdk
```

This will add a line like this to your package's pubspec.yaml (and run an implicit flutter pub get):

```
dependencies:
  videosdk: ^1.1.x
```

### Step 2: Android Setup

VideoSDK requires you to add following permissions to your app so that it can access the audio and video from the device.

Ensure the following permission is present in your Android Manifest file, located in `<project root>/android/app/src/main/AndroidManifest.xml`:

```xml
<uses-feature android:name="android.hardware.camera" />
<uses-feature android:name="android.hardware.camera.autofocus" />
<uses-permission android:name="android.permission.CAMERA" />
<uses-permission android:name="android.permission.RECORD_AUDIO" />
<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
<uses-permission android:name="android.permission.CHANGE_NETWORK_STATE" />
<uses-permission android:name="android.permission.MODIFY_AUDIO_SETTINGS" />
<uses-permission android:name="android.permission.INTERNET"/>
<uses-permission android:name="android.permission.FOREGROUND_SERVICE"/>
<uses-permission android:name="android.permission.WAKE_LOCK" />
```

If you need to use a Bluetooth device, please add:

```xml
<uses-permission android:name="android.permission.BLUETOOTH" />
<uses-permission android:name="android.permission.BLUETOOTH_ADMIN" />
```

Also you will need to set your build settings to Java 8, because official WebRTC jar now uses static methods in `EglBase` interface. Just add this to your app level `build.gradle`:

```js
android {
    //...
    compileOptions {
        sourceCompatibility JavaVersion.VERSION_1_8
        targetCompatibility JavaVersion.VERSION_1_8
    }
}
```

###### Update the minimumSdkVersion for android

If necessary, in the same `build.gradle` you will need to increase `minSdkVersion` of `defaultConfig` up to `23` (currently default Flutter generator set it to `16`).

If necessary, in the same `build.gradle` you will need to increase `compileSdkVersion` and `targetSdkVersion` up to `31` (currently default Flutter generator set it to `30`).

### Step 3: iOS Setup

VideoSDK requires you to add following permissions to your app so that it can access the audio and video from the device.

Add the following entry to your `Info.plist` file, located at `<project root>/ios/Runner/Info.plist`:

```xml
<key>NSCameraUsageDescription</key>
<string>$(PRODUCT_NAME) Camera Usage!</string>
<key>NSMicrophoneUsageDescription</key>
<string>$(PRODUCT_NAME) Microphone Usage!</string>
```

##### Modify the Podfile 

###### Update Minimum Platform Version

Set the minimum iOS platform version to `13.0` in your Podfile:

```js title="Podfile"
platform: ios, "13.0";
```

###### Enable Static Linking

Replace `use_frameworks!` with `use_frameworks! :linkage => :static` in your Podfile to enable static linking for Video SDK integration.

Find the line:
```js title="Podfile"
use_frameworks!
```

Replace it with:
```js title="Podfile"
use_frameworks! :linkage => :static
```

###### Enable Requesting Media Permissions

To enable requesting of microphone and camera permissions add the following to your Podfile:

```js title="Podfile"
post_install do |installer|
  installer.pods_project.targets.each do |target|
    flutter_additional_ios_build_settings(target)
    target.build_configurations.each do |config|
    //Add this into your podfile
      config.build_settings['GCC_PREPROCESSOR_DEFINITIONS'] ||= [
        'PERMISSION_CAMERA=1',
        'PERMISSION_MICROPHONE=1',
      ]
    end
  end
end
```


### Step 4: MacOS Setup

VideoSDK requires you to add following permissions to your app so that it can access the audio and video from the device.

1. Add the following entry to your `Info.plist` file, located at `<project root>/macos/Runner/Info.plist`:

```xml
<key>NSCameraUsageDescription</key>
<string>$(PRODUCT_NAME) Camera Usage!</string>
<key>NSMicrophoneUsageDescription</key>
<string>$(PRODUCT_NAME) Microphone Usage!</string>
```

2. Add the following entry to your `DebugProfile.entitlements` file, located in `<project root>/macos/Runner/DebugProfile.entitlements`:

```xml
<key>com.apple.security.network.client</key>
<true/>
<key>com.apple.security.device.camera</key>
<true/>
<key>com.apple.security.device.microphone</key>
<true/>
```

3. Add the following entry to your `Release.entitlements` file, located in `<project root>/macos/Runner/Release.entitlements`:

```xml
<key>com.apple.security.network.server</key>
<true/>
<key>com.apple.security.network.client</key>
<true/>
<key>com.apple.security.device.camera</key>
<true/>
<key>com.apple.security.device.microphone</key>
<true/>
```

### Step 5: Import it

Now in your Dart code, you can use:

```js
import "package:videosdk/videosdk.dart";
```

:::note

Check out official example of Flutter SDK implementation: [videosdk-rtc-flutter-sdk-example](https://github.com/videosdk-live/videosdk-rtc-flutter-sdk-example)

:::


---

---
title: Cloud Proxy - JavaScript | Secure and Manage Streaming Traffic | Video SDK
hide_title: true
hide_table_of_contents: false
description: Leverage Video SDK's Cloud Proxy to securely manage and optimize your video streaming traffic. Ideal for enhancing performance and securing data.
sidebar_label: Cloud Proxy
pagination_label: Cloud Proxy
keywords:
  - cloud proxy
  - secure streaming
  - video SDK security
  - traffic management
image: img/videosdklive-thumbnail.jpg
sidebar_position: 2
slug: cloud-proxy
---

# Cloud Proxy - Flutter

import CloudProxy from '../../../../mdx/\_cloud-proxy.mdx';

<CloudProxy/>

## Implementation

```js
Room room = VideoSDK.createRoom(
  roomId: "<ROOM-ID>",
  token: "<TOKEN>",
  displayName: "<DISPLAY-NAME>",
  preferredProtocol: PreferredProtocol.UDP_ONLY,
  signalingBaseUrl: "proxy.yourwebsite.com"
);
```

### Parameters

- preferredProtocol:
  - UDP_OVER_TCP (default): Initially the server attempts to establish a connection using UDP, if that fails it automatically switches to TCP protocol.
  - UDP_ONLY: Force UDP protocol
  - TCP_ONLY: Force TCP protocol
- signalingBaseUrl: Proxy URL to origin signaling and media.

## API Reference

The API references for all the methods and events utilized in this guide are provided below.

- [createRoom](/flutter/api/sdk-reference/videosdk-class/methods#createroom)


---

---
title: Geo Fencing - JavaScript | Location based Restrictions | Video SDK
hide_title: true
hide_table_of_contents: false
description: Implement geographic content restrictions with Video SDK's Geo Fencing feature. Essential for compliance and tailored content delivery based on user location.
sidebar_label: Geo Fencing
pagination_label: Geo Fencing
keywords:
- geo fencing
- geographic restrictions
- location based restrictions
- regional access
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: geo-fencing
---

# Geo Fencing - Flutter

import GeoFencing from '../../../../mdx/\_geo-fencing.mdx';

<GeoFencing/>

---

---
title: Geo IP Restriction - JavaScript | Location Based Access Control | Video SDK
hide_title: true
hide_table_of_contents: false
description: Utilize Video SDK’s Geo IP Restriction to enforce access based on user geography. This feature is crucial for adhering to location-specific regulations and ensuring content is appropriately localized.
sidebar_label: Geo IP Restriction
pagination_label: Geo IP Restriction
keywords:
- geo ip restriction
- geographic access control
- location based security
- regional compliance
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: geo-ip-restriction
---

# Geo IP Restrictions  - Flutter

import GeoIpRestriction from '../../../../mdx/\_geo-ip-restriction.mdx';

<GeoIpRestriction/>

---

---
title: Error Events | Video SDK
hide_title: true
hide_table_of_contents: false
description: Video SDK and Audio SDK, developers need to implement a token server. This requires efforts on both the front-end and backend.
sidebar_label: Error Events
pagination_label: Error Events
keywords:
  - audio calling
  - video calling
  - real-time communication
  - collaboration
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: error-events
---

# Error Events - Flutter 

VideoSDK provides the `error` event which informs you about any error happening during the meeting.

### Events.error

- This event is triggered whenever an invalid configuration is provided or server/network errors arise. In such cases, the event will trigger with a specific error code and message.
- It is particularly useful for development-level troubleshooting during SDK integration.
- It can be subscribed to using the `VideoSDK` and the `Room` object for errors from the respective methods.
- Both `VideoSDK` and `Room` objects emit different errors. Users need to set up listeners for errors from both objects to ensure comprehensive error handling and troubleshooting.

### Example

Here is an example demonstrating the usage of the event mentioned on this page.

```javascript
import 'dart:developer';

import 'package:flutter/material.dart';
import 'package:videosdk/videosdk.dart';

class MeetingScreen extends StatefulWidget {
  //Existing configuration
}

class _MeetingScreenState extends State<MeetingScreen> {
  late Room room;

  @override
  void initState() {
    //highlight-next-line
    //Existing configuration
    
    setupVideoSDKEventListener();
    setupRoomEventListener();
  }

  @override
  Widget build(BuildContext context) {
    return YourMeetingWidget();
  }

  //highlight-start
  void setupVideoSDKEventListener() {
    VideoSDK.on(Events.error, (error) {
      log("VIDEOSDK ERROR :: ${error['code']}  :: ${error['name']} :: ${error['message']}");
    });
  }

  void setupRoomEventListener() {
    room.on(Events.error, (error) {
      log("VIDEOSDK ERROR :: ${error['code']}  :: ${error['name']} :: ${error['message']}");
    });
  }
  //highlight-end
}
```

### Error Codes

We have depicted a specific constant with code and message in the below table.

import ServerErrorCodes from '../../../../mdx/\_server-error-codes.mdx'
import SDKErrorCodes from '../../../data/\_sdk-error-codes.mdx'

<ServerErrorCodes />

<SDKErrorCodes/>

### API Reference

The API references for all the methods and events utilized in this guide are provided below.

- [Room class Events.error](/flutter/api/sdk-reference/room-class/events#error)
- [VideoSDK class Events.error](/flutter/api/sdk-reference/videosdk-class/events#error)




---

---
title: HLS Events | Video SDK
hide_title: true
hide_table_of_contents: false
description: Video SDK and Audio SDK, developers need to implement a token server. This requires efforts on both the front-end and backend.
sidebar_label: HLS Events
pagination_label: HLS Events
keywords:
  - audio calling
  - video calling
  - real-time communication
  - collaboration
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: hls-events
---

# HLS Events - Flutter 

VideoSDK provides the `hlsStateChanged` event, which informs you about the current state of HLS for the meeting.

### Events.hlsStateChanged

- This event is triggered when the HLS status of the meeting changes.
- It can be subscribed to using the `Room` Object.

:::note
`downstreamUrl` is now depecated. Use `playbackHlsUrl` or `livestreamUrl` in place of `downstreamUrl`
:::

### Example

Here is an example demonstrating the usage of the event mentioned on this page.

```javascript
import 'dart:developer';
import 'package:flutter/material.dart';
import 'package:videosdk/videosdk.dart';

class MeetingScreen extends StatefulWidget {
  //Existing configuration
}

class _MeetingScreenState extends State<MeetingScreen> {
  late Room room;

  @override
  void initState() {
    //highlight-next-line
    //Existing configuration

    setupRoomEventListener();
  }

  @override
  Widget build(BuildContext context) {
    return YourMeetingWidget();
  }

  //highlight-start
  void setupRoomEventListener() {
    room.on(Events.hlsStateChanged, (Map<String, dynamic> data) {
      //Status can be :: HLS_STARTING
      //Status can be :: HLS_STARTED
      //Status can be :: HLS_PLAYABLE
      //Status can be :: HLS_STOPPING
      //Status can be :: HLS_STOPPED
      log("Meeting HLS status : ${data['status']}");
      if (data['status'] == "HLS_PLAYABLE") {
        log("PLAYBACKHLS URL --  ${data['playbackHlsUrl']}");
      }
    });
  }
  //highlight-end
}
```

### API Reference

The API references for all the methods and events utilized in this guide are provided below.

- [Events.hlsStateChanged](/flutter/api/sdk-reference/room-class/events#hlsstatechanged)


---

---
title: Media Events | Video SDK
hide_title: true
hide_table_of_contents: false
description: Video SDK and Audio SDK, developers need to implement a token server. This requires efforts on both the front-end and backend.
sidebar_label: Media Events
pagination_label: Media Events
keywords:
  - audio calling
  - video calling
  - real-time communication
  - collaboration
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: media-events
---

# Media Events - Flutter 

VideoSDK offers various events that can be monitored to obtain information about the media status of participants in the meeting.

Here are the events specifically related to the stream:

### Events.streamEnabled

- This event is triggered whenever a participant's video, audio or screen share stream is enabled.
- It can be subscribed to using the `Participant` object.

### Events.streamDisabled

- This event is triggered whenever a participant's video, audio or screen share stream is disabled.
- It can be subscribed to using the `Participant` object.

### Events.streamPause

- This event is triggered whenever a participant's video, audio or screen share stream is paused.
- It can be subscribed to using the `Participant` object.

### Events.streamResumed

- This event is triggered whenever a participant's video, audio or screen share stream is resumed.
- It can be subscribed to using the `Participant` object.

### Example

Here is an example demonstrating the usage of all the events mentioned on this page.

```js
import 'package:flutter/material.dart';
import 'package:videosdk/videosdk.dart';

class ParticipantTile extends StatefulWidget {
  final Participant participant;
  //Existing congiguration
}

class _ParticipantTileState extends State<ParticipantTile> {
  @override
  void initState() {
    //highlight-next-line
    //Existing congiguration

    setupParticipantEventListener();
  }

  @override
  Widget build(BuildContext context) {
    return YourParticipantTileWidget();
  }

  //highlight-start
  void setupParticipantEventListener() {
    widget.participant.on(Events.streamEnabled, (Stream stream) {
      if (stream.kind == "video") {
        // Participant turned on video
      } else if (stream.kind == "audio") {
        // Participant turned on audio
      } else if (stream.kind == "share") {
        // Participant started screenshare
      }
    });

    widget.participant.on(Events.streamDisabled, (Stream stream) {
      if (stream.kind == "video") {
        // Participant turned off video
      } else if (stream.kind == "audio") {
        // Participant turned off audio
      } else if (stream.kind == "share") {
        // Participant stopped screenshare
      }
    });

    widget.participant.on(Events.streamPaused, (Stream stream) {
      if (stream.kind == "video") {
        // Participant video pause
      } else if (stream.kind == "audio") {
        // Participant audio pause
      } else if (stream.kind == "share") {
        // Participant screenshare paused
      }
    });

    widget.participant.on(Events.streamResumed, (Stream stream) {
      if (stream.kind == "video") {
        // Participant video resume
      } else if (stream.kind == "audio") {
        // Participant audio resume
      } else if (stream.kind == "share") {
        // Participant screenshare resumed
      }
    });
  }
  //highlight-end
}
```

### API Reference

The API references for all the methods and events utilized in this guide are provided below.

- [Events.streamEnabled](/flutter/api/sdk-reference/participant-class/events#streamenabled)
- [Events.streamDisabled](/flutter/api/sdk-reference/participant-class/events#streamdisabled)
- [Events.streamPaused](/flutter/api/sdk-reference/participant-class/events#streampaused)
- [Events.streamResumed](/flutter/api/sdk-reference/participant-class/events#streamresumed)


---

---
title: Participant Events | Video SDK
hide_title: true
hide_table_of_contents: false
description: Video SDK and Audio SDK, developers need to implement a token server. This requires efforts on both the front-end and backend.
sidebar_label: Participant Events
pagination_label: Participant Events
keywords:
  - audio calling
  - video calling
  - real-time communication
  - collaboration
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: participant-events
---

# Participant Events - Flutter 

VideoSDK provides various events that can be utilized to gather information about the participants in the meeting.

Here are the events specifically related to the participant:

### Events.participantJoined

- This event is triggered when someone joins the meeting, returning the `Participant` object as parameter.
- It can be subscribed to using the `Room` object.

### Events.participantLeft

- This event is triggered when someone leaves the meeting.
- It can be subscribed to using the `Room` object.

### Events.cameraRequested

- This event is triggered for participant `B`, when another participant, `A` requests to enable their webcam.
- Upon accepting the request, participant `B`'s webcam will be enabled.
- It can be subscribed to using the `Room` object.

### Events.micRequested

- This event is triggered for participant `B`, when another participant, `A` requests to enable their mic.
- Upon accepting the request, participant `B`'s mic will be enabled.
- It can be subscribed to using the `Room` object.

### Example

Here is an example demonstrating the usage of all the events mentioned on this page.

```js
import 'package:flutter/material.dart';
import 'package:videosdk/videosdk.dart';

class MeetingScreen extends StatefulWidget {
  //Existing configuration
}

class _MeetingScreenState extends State<MeetingScreen> {
  late Room _room;

  @override
  void initState() {
    //highlight-next-line
    //Existing configuration

    setupRoomEventListener();
  }

  @override
  Widget build(BuildContext context) {
    return YourMeetingWidget();
  }

  //highlight-start
  void setupRoomEventListener() {
    _room.on(Events.participantJoined, (Participant participant) {
      // New Participant joined the room
    });

    _room.on(Events.participantLeft, (String participantId) {
      // Participant left the room
    });

    _room.on(Events.cameraRequested, (data) {
      String? participantId = data["participantId"];

      Function accept = data["accept"];
      Function reject = data["deny"];

      // participantId, will be the id of participant who requested to enable camera

      // if the request is accepted
      accept();

      // if the request is rejected
      reject();
    });

    _room.on(Events.micRequested, (data) {
      String participantId = data["participantId"];

      Function accept = data["accept"];
      Function reject = data["reject"];

      // participantId, will be the id of participant who requested to enable camera

      // if the request is accepted
      accept();

      // if the request is rejected
      reject();
    });
  }
  //highlight-end
}
```

### API Reference

The API references for all the methods and events utilized in this guide are provided below.

- [Events.participantJoined](/flutter/api/sdk-reference/room-class/events#participantjoined)
- [Events.participantLeft](/flutter/api/sdk-reference/room-class/events#participantleft)
- [Events.cameraRequested](/flutter/api/sdk-reference/room-class/events#camerarequested)
- [Events.micRequested](/flutter/api/sdk-reference/room-class/events#micrequested)


---

---
title: Recording Events | Video SDK
hide_title: true
hide_table_of_contents: false
description: Video SDK and Audio SDK, developers need to implement a token server. This requires efforts on both the front-end and backend.
sidebar_label: Recording Events
pagination_label: Recording Events
keywords:
  - audio calling
  - video calling
  - real-time communication
  - collaboration
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: recording-events
---

# Recording Events - Flutter 

VideoSDK provides the `recordingStateChanged` event, which notifies you of the current state of recording for the meeting.

### Events.recordingStateChanged

- This event is triggered when the recording status of the meeting changes. 
- It can be subscribed to using the `Room` object.

### Example

Here is an example demonstrating the usage of the event mentioned on this page.

```javascript
import 'dart:developer';
import 'package:flutter/material.dart';
import 'package:videosdk/videosdk.dart';

class MeetingScreen extends StatefulWidget {
  //Existing configuration
}

class _MeetingScreenState extends State<MeetingScreen> {
  late Room room;

  @override
  void initState() {
    //highlight-next-line
    //Existing configuration

    setupRoomEventListener();
  }

  @override
  Widget build(BuildContext context) {
    return YourMeetingWidget();
  }

  //highlight-start
  void setupRoomEventListener() {
    room.on(Events.recordingStateChanged, (String status) {
      //Status can be :: RECORDING_STARTING
      //Status can be :: RECORDING_STARTED
      //Status can be :: RECORDING_STOPPING
      //Status can be :: RECORDING_STOPPED
      log("Meeting Recording status : $status");
    });
  }
  //highlight-end
}
```

### API Reference

The API references for all the methods and events utilized in this guide are provided below.

- [Events.recordingStateChanged](/flutter/api/sdk-reference/room-class/events#recordingstatechanged)


---

---
title: Room Connection Events | Video SDK
hide_title: true
hide_table_of_contents: false
sidebar_label: Room Connection Events
pagination_label: Room Connection Events
keywords:
  - audio calling
  - video calling
  - real-time communication
  - collaboration
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: room-connection-events
---

# Room Connection Events - Flutter

VideoSDK provides `Events.roomStateChanged` event which will notify you of the current connection state of the room.

### Events.roomStateChanged

- This event is triggered whenever the room's state changes. 
- The current state of the room is passed as a callback parameter.
- All available states are `connecting`, `connected`, `failed`, `disconnected`, `closing`, `closed`.
- It can be subscribed to using the `Room` object.

### Example

Here is the usage of the event mentioned in this page.

```js
import 'package:flutter/material.dart';
import 'package:videosdk/videosdk.dart';

class MeetingScreen extends StatefulWidget {
  //Existing configuration
}

class _MeetingScreenState extends State<MeetingScreen> {
  late Room room;

  @override
  void initState() {
    //highlight-next-line
    //Existing configuration

    setupRoomEventListener();
  }

  @override
  Widget build(BuildContext context) {
    return YourMeetingWidget();
  }

  //highlight-start
  void setupRoomEventListener() {
    room.on(Events.roomStateChanged, (RoomState state) {
        switch (state) {
          case RoomState.connecting:
            print('Meeting is Connecting');
            break;
          case RoomState.connected:
            print('Meeting is Connected');
            break;
          case RoomState.disconnected:
            print('Meeting connection disconnected abruptly');
            break;
          case RoomState.failed:
            print('Meeting connection failed');
            break;
          case RoomState.closing:
            print('Meeting is closing');
            break;
          case RoomState.closed:
            print('Meeting connection closed');
            break;
          default:
            print('default');
        }
    });
  //highlight-end
}
```

### API Reference

The API references for all the methods and events utilized in this guide are provided below.

- [Events.roomStateChanged](/flutter/api/sdk-reference/room-class/events#roomStateChanged)

---

---
title: Room Events | Video SDK
hide_title: true
hide_table_of_contents: false
description: Video SDK and Audio SDK, developers need to implement a token server. This requires efforts on both the front-end and backend.
sidebar_label: Room Events
pagination_label: Room Events
keywords:
  - audio calling
  - video calling
  - real-time communication
  - collaboration
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: room-events
---

# Room Events - Flutter 

VideoSDK provides several types of events that can be listened to in order to determine the current state of the room.

Here are the events specifically related to the room:

### Events.roomJoined

- This event is triggered when the room is successfully joined.
- It can be subscribed to using the `Room` object.

### Events.roomLeft

- This event is triggered when the room is left.
- It can be subscribed to using the `Room` object.

### Events.speakerChanged

- This event is triggered when there is a change in the active speaker during the meeting.
- It can be subscribed to using the `Room` object.

### Events.presenterChanged

- This event is triggered when there is a change in the presenter during the meeting.
- It can be subscribed to using the `Room` object.

### Example

Here is an example demonstrating the usage of all the events mentioned on this page.

```js
import 'package:flutter/material.dart';
import 'package:videosdk/videosdk.dart';

class MeetingScreen extends StatefulWidget {
  //Existing configuration
}

class _MeetingScreenState extends State<MeetingScreen> {
  late Room room;

  @override
  void initState() {
    //highlight-next-line
    //Existing configuration

    setupRoomEventListener();
  }

  @override
  Widget build(BuildContext context) {
    return YourMeetingWidget();
  }

  //highlight-start
  void setupRoomEventListener() {
    room.on(Events.roomJoined, () {
      //Room Joined successfully
    });

    room.on(Events.roomLeft, (String? error) {
      //Room Left

      if (error != null) {
        // Room left with error
      }
    });

    room.on(Events.speakerChanged, (String? activeSpeakerId) {
      //Room active speaker has changed
      //Participant ID of current active speaker is activeSpeakerId
    });

    room.on(Events.presenterChanged, (String? presenterId) {
      //Room screen presenter has changed
      //Participant ID of current presenter is presenterId
    });
  }
  //highlight-end
}
```

### API Reference

The API references for all the methods and events utilized in this guide are provided below.

- [Events.roomJoined](/flutter/api/sdk-reference/room-class/events#roomjoined)
- [Events.roomLeft](/flutter/api/sdk-reference/room-class/events#roomleft)
- [Events.speakerChanged](/flutter/api/sdk-reference/room-class/events#speakerchanged)
- [Events.presenterChanged](/flutter/api/sdk-reference/room-class/events#presenterchanged)


---

---
title: RTMP Events | Video SDK
hide_title: true
hide_table_of_contents: false
description: Video SDK and Audio SDK, developers need to implement a token server. This requires efforts on both the front-end and backend.
sidebar_label: RTMP Events
pagination_label: RTMP Events
keywords:
  - audio calling
  - video calling
  - real-time communication
  - collaboration
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: rtmp-events
---

# RTMP Events - Flutter 

VideoSDK provides the `livestreamStateChanged` event, which informs you about the current state of the livestream for the meeting.

### Events.livestreamStateChanged

- This event is triggered when the livestream status of the meeting changes.
- It can be subscribed to using the `Room` object.

### Example

Here is an example demonstrating the usage of the event mentioned on this page.

```javascript
import 'dart:developer';
import 'package:flutter/material.dart';
import 'package:videosdk/videosdk.dart';

class MeetingScreen extends StatefulWidget {
  //Existing configuration
}

class _MeetingScreenState extends State<MeetingScreen> {
  late Room room;

  @override
  void initState() {
    //highlight-next-line
    //Existing configuration

    setupRoomEventListener();
  }

  @override
  Widget build(BuildContext context) {
    return YourMeetingWidget();
  }

  //highlight-start
  void setupRoomEventListener() {
    room.on(Events.liveStreamStateChanged, (String status) {
      //Status can be :: LIVESTREAM_STARTING
      //Status can be :: LIVESTREAM_STARTED
      //Status can be :: LIVESTREAM_STOPPING
      //Status can be :: LIVESTREAM_STOPPED
      log("Meeting Livestream status : $status");
    });
  }
  //highlight-end
}
```

### API Reference

The API references for all the methods and events utilized in this guide are provided below.

- [Events.liveStreamStateChanged](/flutter/api/sdk-reference/room-class/events#livestreamstatechanged)


---

---
title: Get Started with Video & Audio Call - Video SDK Documentation
hide_title: true
hide_table_of_contents: false
description: Video SDK enables the opportunity to integrate native IOS, Android & Web SDKs to add live video & audio conferencing to your applications.
sidebar_label: Getting Started
pagination_label: Getting Started
keywords:
  - audio calling
  - video calling
  - real-time communication
  - collaboration
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: getting-started
---

import Mermaid from '@theme/Mermaid';
import GettingStarted from '../../../mdx/introduction/\_getting-started.mdx';

<GettingStarted title="Get Started with Flutter" />

import NoIndex from '../../../mdx/\_no-index.mdx';

<NoIndex/>

## Steps

import Card from '@theme/Card';

<div class="container guide-steps-block">
  <div class="row ">
    <div class="col col--6">
      <Card heading="1. Get your API key and Secret" link="/flutter/guide/video-and-audio-calling-api-sdk/signup-and-create-api" description="Generate your API key and Secret from Video SDK." />
    </div>
     <div class="col col--6">
      <Card heading="2. Client Setup for Flutter" link="/flutter/guide/video-and-audio-calling-api-sdk/flutter-sdk" description="Easy to integrate SDK with cross-channel support." />
    </div>
  </div>
  <div class="row ">
   <div class="col col--6" >
      <Card heading="3. Authentication and Tokens" link="/flutter/guide/video-and-audio-calling-api-sdk/server-setup" description="Setup secured server authentication and authorization."  />
    </div>
    <div class="col col--6">
      <Card heading="4. Start a Audio / Video Call" link="/flutter/guide/video-and-audio-calling-api-sdk/quick-start" description="Get started with step by step guide of integrating Video SDK." />
    </div>
  </div>
  <div class="row ">
   <div class="col col--6" >
      <Card heading="5. Basic Features" link="/flutter/guide/video-and-audio-calling-api-sdk/features/start-join-room" description="Explore basic features such as join, leave and customise sessions."  />
    </div>
    <div class="col col--6">
      <Card heading="6. Advanced Features" link="/flutter/guide/video-and-audio-calling-api-sdk/features/error-event" description="Explore advanced features such as screen sharing, recording and live streaming." />
    </div>
  </div>
</div>

## Architecture

This diagram demonstrates end-to-end flow to implement video & audio calling, record calls and go-live on social media.

![Video-sdk-architecture!](/img/video-sdk-archietecture.svg)


---

---
title: Active Speaker Indication | Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: Speaker Indication features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Active Speaker Indication
pagination_label: Active Speaker Indication
keywords:
  - Active Speaker
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: active-speaker-indication
---

# Active Speaker Indication - Flutter

Active Speaker indication feature in VideoSDK let you know, which participant in a meeting is active speaker. This feature can be particularly useful in larger meetings or webinars, where there may be many participants and it can be difficult to tell who is speaking.

Whenever any participant speaks in meeting, `speakerChanged` event will trigger with the participant id of the active speaker.

For example, the meeting is running with **Alice** and **Bob**. Whenever any of them speaks, `speakerChanged` event will trigger and return the speaker `participantId`.

### Event

```js
import 'package:flutter/material.dart';
import 'package:videosdk/videosdk.dart';

class MeetingScreen extends StatefulWidget {
  ...
}

class _MeetingScreenState extends State<MeetingScreen> {
  late Room room;

  @override
  void initState() {
    //highlight-next-line
    ...

    setupRoomEventListener();
  }

  @override
  Widget build(BuildContext context) {
    return YourMeetingWidget();
  }

  //highlight-start
  void setupRoomEventListener() {

    room.on(Events.speakerChanged, (String? activeSpeakerId) {
      //Room active speaker has changed
      //Participant ID of current active speaker is activeSpeakerId
    });
  }
  //highlight-end
}
```

### API Reference

The API references for all the methods and events utilised in this guide are provided below.

- [speakerChanged](/flutter/api/sdk-reference/room-class/events#speakerchanged)


---

---
title: Change Input Device | Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: Change Input Device features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Change Audio Input Device
pagination_label: Change Audio Input Device
keywords:
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: change-audio-input-device
---

# Change Audio Input Device - Flutter

During the meeting at any point a participant wishes to switch his/her input audio device, it can be done using the below mentioned methods.

:::important
This feature is only available on the **Web** and **Desktop**; if you want to use it on **Mobile**, please refer [this guide](./change-audio-output-device.md).
:::

### `getAudioDevices()`

- The `getAudioDevices()` method will help you to list down all possible connected audio input devices which will return a list of `AudioDeviceInfo` objects.

- The `AudioDeviceInfo` object will contain the `deviceId` , `kind` , `groupId` and `label` for the device.

### `changeMic()`

- After selecting the desired device, you can switch the audio input by passing the corresponding `AudioDeviceInfo` object as a parameter to the `changeMic()` method.

#### Example

```js
import 'dart:io';

import 'package:flutter/foundation.dart';
import 'package:flutter/material.dart';
import 'package:videosdk/videosdk.dart';

class MeetingScreen extends StatefulWidget {
  const MeetingScreen({Key? key}) : super(key: key);

  @override
  _MeetingScreenState createState() => _MeetingScreenState();
}

class _MeetingScreenState extends State<MeetingScreen> {
  late Room _room;
  List<AudioDeviceInfo>? mics = [];

  @override
  void initState() {
    super.initState();
    fetchMics();
  }

  void fetchMics() async {
    List<AudioDeviceInfo>? audioDevices = await VideoSDK.getAudioDevices();
    if (kIsWeb || Platform.isMacOS || Platform.isWindows) {
      for (AudioDeviceInfo device in audioDevices!) {
        if (device.kind == 'audioinput') {
          mics?.add(device);
        }
      }
    }
    setState(() {});
  }

  @override
  Widget build(BuildContext context) {
    return Column(children: [
      ElevatedButton(
          child: Text("Change Input Device"),
          onPressed: () => {
                showDialog(
                  context: context,
                  builder: (context) => AlertDialog(
                    title: const Text("Select Audio Device"),
                    content: Column(
                      mainAxisAlignment: MainAxisAlignment.center,
                      mainAxisSize: MainAxisSize.min,
                      children: <Widget>[
                        SingleChildScrollView(
                          reverse: true,
                          //highlight-start
                          child: mics != null && mics!.isNotEmpty
                              ? Column(
                                  children: mics!
                                      .map(
                                        (device) => ElevatedButton(
                                          child: Text(device.label),
                                          onPressed: () {
                                            _room.changeMic(device);
                                            Navigator.pop(context);
                                          },
                                        ),
                                      )
                                      .toList(),
                                )
                              : const Text("No Microphone Devices found."),
                          //highlight-end
                        )
                      ],
                    ),
                  ),
                )
              }),
    ]);
  }
}
``` 

## API Reference

The API references for all the methods and events utilized in this guide are provided below.

- [getAudioDevices()](/flutter/api/sdk-reference/videosdk-class/methods#getaudiodevices)
- [changeMic()](/flutter/api/sdk-reference/room-class/methods#changemic)


---

---
title: Change Audio Output Device | Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: Change Audio Output Device features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Change Audio Output Device
pagination_label: Change Audio Output Device
keywords:
  - Active Speaker
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: change-audio-output-device
---

# Change Audio Output Device - Flutter

During the meeting at any point a participant wishes to switch his/her output audio like from headphones to speaker, it can be done using the below mentioned methods.

:::important
This feature works for input and output device on **Mobile** apps, and for output device on **Web** and **Desktop** apps.
:::


### `getAudioDevices()`

- The `getAudioDevices()` method will help you to list down all possible connected audio output devices which will return a list of `AudioDeviceInfo` objects.

- The `AudioDeviceInfo` object will contain the `deviceId` , `kind` , `groupId` and `label` for the device.

### `switchAudioDevice()`

- After selecting the desired device, you can switch the audio output by passing the corresponding `AudioDeviceInfo` object as a parameter to the `switchAudioDevice()` method.

```js
import 'package:flutter/material.dart';
import 'package:videosdk/videosdk.dart';

class MeetingScreen extends StatefulWidget {
  const MeetingScreen({Key? key}) : super(key: key);

  @override
  _MeetingScreenState createState() => _MeetingScreenState();
}

class _MeetingScreenState extends State<MeetingScreen> {
  late Room _room;
  List<AudioDeviceInfo>? speakers = [];

  @override
  void initState() {
    super.initState();
    fetchSpeakers();
  }

  void fetchSpeakers() async {
    List<AudioDeviceInfo>? audioDevices = await VideoSDK.getAudioDevices();
      for (AudioDeviceInfo device in audioDevices!) {
        if (device.kind == 'audiooutput') {
          speakers?.add(device);
        }
      }
    setState(() {});
  }

  @override
  Widget build(BuildContext context) {
    return Column(children: [
      ElevatedButton(
          child: const Text("Change Audio Device"),
          onPressed: () => {
                showDialog(
                  context: context,
                  builder: (context) => AlertDialog(
                    title: const Text("Select Audio Device"),
                    content: Column(
                      mainAxisAlignment: MainAxisAlignment.center,
                      mainAxisSize: MainAxisSize.min,
                      children: <Widget>[
                        SingleChildScrollView(
                          reverse: true,
                          child: speakers != null && speakers!.isNotEmpty
                              ? Column(
                                  children: speakers!
                                      .map(
                                        (device) => ElevatedButton(
                                          child: Text(device.label),
                                          onPressed: () {
                                            _room.switchAudioDevice(device);
                                            Navigator.pop(context);
                                          },
                                        ),
                                      )
                                      .toList(),
                                )
                              : const Text("No Speaker Devices found."),
                        )
                      ],
                    ),
                  ),
                )
              }),
    ]);
  }
}
```

:::note

For iOS devices:
- `EARPIECE` is not supported whenever `WIRED_HEADSET` or `BLUETOOTH` device is connected.
- `WIRED_HEADSET` and `BLUETOOTH` devices are not supported simultaneously. Priority is given to the most recently connected device.

:::

### API Reference

The API references for all the methods and events utilised in this guide are provided below.

- [getAudioDevices()](/flutter/api/sdk-reference/videosdk-class/methods#getaudiodevices)
- [switchAudioDevice()](/flutter/api/sdk-reference/room-class/methods#switchaudiodevice)


---

---
title: Change Video Input Device | Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: Change Video Input Device features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Change Video Input Device
pagination_label: Change Video Input Device
keywords:
  - Active Speaker
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: change-video-input-device
---

# Change Video Input Device - Flutter

During the meeting at any point a participant wishes to switch his/her input video device, it can be done using the below mentioned methods.

### `getVideoDevices()` 

- This method of the `VideoSDK` class will give you the list of all the available cameras which can be shown in a list.

- This method will return an array of `VideoDeviceInfo` which will contain the `deviceId` , `label` , `kind` and `groupId` of the camera input devices.

### `changeCam()`

- After selecting the desired device, you can switch the camera input by passing the corresponding `VideoDeviceInfo` object as a parameter to the `changeCam()` method.

#### Example

```js
import 'package:flutter/material.dart';
import 'package:videosdk/videosdk.dart';

class MeetingScreen extends StatefulWidget {
  const MeetingScreen({Key? key}) : super(key: key);

  @override
  _MeetingScreenState createState() => _MeetingScreenState();
}

class _MeetingScreenState extends State<MeetingScreen> {
  late Room _room;
  List<VideoDeviceInfo>? cameras = [];

  @override
  void initState() {
    super.initState(); 
    fetchCameras();
  }

  void fetchCameras() async {
    cameras = await VideoSDK.getVideoDevices();
    setState(() {});  
  }

  @override
  Widget build(BuildContext context) {
    return Column(
      children: [
        ElevatedButton(
          child: const Text("Change Camera"),
          onPressed: () {
            showDialog(
              context: context,
              builder: (context) => AlertDialog(
                title: const Text("Select Camera Device"),
                content: Column(
                  mainAxisAlignment: MainAxisAlignment.center,
                  mainAxisSize: MainAxisSize.min,
                  children: <Widget>[
                    SingleChildScrollView(
                      reverse: true,
                      //highlight-start
                      child: cameras != null && cameras!.isNotEmpty
                          ? Column(
                              children: cameras!.map(
                                (device) => ElevatedButton(
                                  child: Text(device.label),
                                  onPressed: () {
                                    _room.changeCam(device);
                                    Navigator.pop(context);
                                  },
                                ),
                              ).toList(),
                            )
                          : const Text("No Camera Devices found."),
                      //highlight-end
                    ),
                  ],
                ),
              ),
            );
          },
        ),
      ],
    );
  }
}
``` 

### API Reference

The API references for all the methods and events utilised in this guide are provided below.

- [getVideoDevices](/flutter/api/sdk-reference/videosdk-class/methods#getvideodevices)
- [changeCam()](/flutter/api/sdk-reference/room-class/methods#changecam)


---

---
title: Mute / Unmute Mic | Video SDK
hide_title: true
hide_table_of_contents: false
description: Mic Controls features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Mute / Unmute Mic
pagination_label: Mute / Unmute Mic
keywords:
  - audio calling
  - video calling
  - real-time communication
  - collaboration
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: mute-unmute-mic
---

# Mute / Unmute Mic - Flutter

Muting and Unmuting your microphone refers to turning your microphone off and on, respectively.

When you mute your microphone, you prevent any sound from your microphone from being transmitted to other meeting participants, while unmuting it allows others to hear you.

### `unmuteMic()`

- By using `unmuteMic()` function of `Room` object, local participant can publish audio to other participants.

  - You can call this method when the local participant is not broadcasting any audio to others.

- You can pass customised audio track in `unmuteMic()` by using [Custom Audio Track](/flutter/guide/video-and-audio-calling-api-sdk/render-media/optimize-audio-track).

- Audio stream of the participant can be accessed from the `streams` property of `Participant` object.

### `muteMic()`

- By using `muteMic()` function of `Room` object, local participant can stop publish audio to other participants.

- You can call this method when the local participant is broadcasting any audio to others.

#### Example

```jsx
import 'package:flutter/material.dart';
import 'package:videosdk/videosdk.dart';

class MeetingScreen extends StatefulWidget {
  ...
}

class _MeetingScreenState extends State<MeetingScreen> {
  late Room _room;

  @override
  void initState() {
    //highlight-next-line
    ...
  }

  @override
  Widget build(BuildContext context) {
    return Column(
      children:[
        //highlight-start
        ElevatedButton(
          onPressed:(){
            _room.unmuteMic();
          },
          child: const Text("Unmute Mic"),
        ),
        ElevatedButton(
          onPressed:(){
            _room.muteMic();
          },
          child: const Text("Mute Mic"),
        ),
    //highlight-end
      ]
    );
  }
}
```

### Getting Participant Mic Status

- You can get the **local participant's** media status by going through the `stream` Map of the `Participant` object.
- If `stream` contains a value where `kind` is `audio` then the participant's microphone is active else it is disabled.

```js
import 'package:flutter/material.dart';
import 'package:videosdk/videosdk.dart';

class ParticipantTile extends StatefulWidget {
  final Participant participant;
  const ParticipantTile({super.key, required this.participant});

  @override
  State<ParticipantTile> createState() => _ParticipantTileState();
}

class _ParticipantTileState extends State<ParticipantTile> {
  Stream? audioStream;

  @override
  void initState() {
    //highlight-start
    // initial video stream for the participant
    //Check if camera stream is already present
    widget.participant.streams.forEach((key, Stream stream) {
      setState(() {
        if (stream.kind == 'audio') {
          audioStream = stream;
        }
      });
    });
    //highlight-end

    _initStreamListeners();
    super.initState();
  }

  //highlight-start
  //Change state according to the events received
  _initStreamListeners() {
    widget.participant.on(Events.streamEnabled, (Stream stream) {
      if (stream.kind == 'audio') {
        setState(() => audioStream = stream);
      }
    });

    widget.participant.on(Events.streamDisabled, (Stream stream) {
      if (stream.kind == 'audio') {
        setState(() => audioStream = null);
      }
    });
  }
  //highlight-end

  @override
  Widget build(BuildContext context) {
    return Padding(
      padding: const EdgeInsets.all(8.0),
      child: Text("Current Mic status of ${widget.participant.displayName} is ${audioStream !=null ? "Active": "Disable"}")
    );
  }
}
```

### Events associated with unmuteMic

- Every Participant will receive a callback on [`Events.streamEnabled`](/flutter/api/sdk-reference/participant-class/events#streamenabled) of the [`Participant`](/flutter/api/sdk-reference/participant-class/introduction) object with `Stream` object.

### Events associated with muteMic

- Every Participant will receive a callback on [`Events.streamDisabled`](/flutter/api/sdk-reference/participant-class/events#streamdisabled) of the [`Participant`](/flutter/api/sdk-reference/participant-class/introduction) object with `Stream` object.

```js
import 'package:flutter/material.dart';
import 'package:videosdk/videosdk.dart';

class ParticipantTile extends StatefulWidget {
  final Participant participant;
  ...
}

class _ParticipantTileState extends State<ParticipantTile> {

  @override
  void initState() {
    ...

    //highlight-next-line
    _initStreamListeners();
    super.initState();
  }

  //highlight-start
  //Change state according to the events received
  _initStreamListeners() {
    widget.participant.on(Events.streamEnabled, (Stream stream) {
      if (stream.kind == 'audio') {
        //Mic Turned On
      }
    });

    widget.participant.on(Events.streamDisabled, (Stream stream) {
      if (stream.kind == 'audio') {
        //Mic Turned Off
      }
    });
  }
  //highlight-end

  @override
  Widget build(BuildContext context) {
    return YourParticipantWidget();
  }
}
```

### API Reference

The API references for all the methods and events utilised in this guide are provided below.

- [unmuteMic()](/flutter/api/sdk-reference/room-class/methods#unmutemic)
- [muteMic()](/flutter/api/sdk-reference/room-class/methods#mutemic)
- [Events.streamEnabled](/flutter/api/sdk-reference/participant-class/events#streamenabled)
- [Events.streamDisabled](/flutter/api/sdk-reference/participant-class/events#streamdisabled)


---

---
title: On / Off Camera | Video SDK
hide_title: true
hide_table_of_contents: false
description: Camera Controls features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: On / Off Camera
pagination_label: On / Off Camera
keywords:
  - audio calling
  - video calling
  - real-time communication
  - collaboration
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: on-off-camera
---

# On / Off Camera - Flutter

Any participant can turn on or off his camera in the meeting using below methods.

### `enableCam()`

- By using `enableCam()` function of `Room` object, local participant can publish video to other participants.

- You can call this method when the local participant is not broadcasting any video to others.

- You can pass customised video track in `enableCam()` by using [Custom Video Track](/flutter/guide/video-and-audio-calling-api-sdk/render-media/optimize-video-track).

- Video stream of the participant can be accessed from the `streams` property of `Participant` object.

### `disableCam()`

- By using `disableCam()` function of `Room` object, local participant can stop publish video to other participants.

- You can call this method when the local participant is broadcasting any video to others.

#### Example

```jsx
import 'package:flutter/material.dart';
import 'package:videosdk/videosdk.dart';

class MeetingScreen extends StatefulWidget {
  ...
}

class _MeetingScreenState extends State<MeetingScreen> {
  late Room _room;

  @override
  void initState() {
    //highlight-next-line
    ...
  }

  @override
  Widget build(BuildContext context) {
    return Column(
      children:[
        //highlight-start
        ElevatedButton(
          onPressed:(){
            _room.enableCam();
          },
          child: const Text("Enable Camera"),
        ),
        ElevatedButton(
          onPressed:(){
            _room.disableCam();
          },
          child: const Text("Disable Camera"),
        ),
    //highlight-end
      ]
    );
  }
}
```

:::note
To learn, how to render video in the meeting, follow this detailed [guide](/flutter/guide/video-and-audio-calling-api-sdk/render-media/display-video#2-rendering-video).
:::

### Getting Participant Camera Status

- You can get the **local participant's** media status by going through the `stream` Map of the `Participant` object.
- If `stream` contains a value where `kind` is `video` then the participant's camera is active else it is disabled.

```js
import 'package:flutter/material.dart';
import 'package:videosdk/videosdk.dart';

class ParticipantTile extends StatefulWidget {
  final Participant participant;
  const ParticipantTile({super.key, required this.participant});

  @override
  State<ParticipantTile> createState() => _ParticipantTileState();
}

class _ParticipantTileState extends State<ParticipantTile> {
  Stream? videoStream;

  @override
  void initState() {
    //highlight-start
    // initial video stream for the participant
    //Check if camera stream is already present
    widget.participant.streams.forEach((key, Stream stream) {
      setState(() {
        if (stream.kind == 'video') {
          videoStream = stream;
        }
      });
    });
    //highlight-end

    _initStreamListeners();
    super.initState();
  }

  //highlight-start
  //Change state according to the events received
  _initStreamListeners() {
    widget.participant.on(Events.streamEnabled, (Stream stream) {
      if (stream.kind == 'video') {
        setState(() => videoStream = stream);
      }
    });

    widget.participant.on(Events.streamDisabled, (Stream stream) {
      if (stream.kind == 'video') {
        setState(() => videoStream = null);
      }
    });
  }
  //highlight-end

  @override
  Widget build(BuildContext context) {
    return Padding(
      padding: const EdgeInsets.all(8.0),
      child: Text("Current Camera status of ${widget.participant.displayName} is ${videoStream !=null ? "Active": "Disable"}")
    );
  }
}
```

### Events associated with enableCam

- Every Participant will receive a callback on [`Events.streamEnabled`](/flutter/api/sdk-reference/participant-class/events#streamenabled) of the [`Participant`](/flutter/api/sdk-reference/participant-class/introduction) object with `Stream` object.

### Events associated with disableCam

- Every Participant will receive a callback on [`Events.streamDisabled`](/flutter/api/sdk-reference/participant-class/events#streamdisabled) of the [`Participant`](/flutter/api/sdk-reference/participant-class/introduction) object with `Stream` object.

```js
import 'package:flutter/material.dart';
import 'package:videosdk/videosdk.dart';

class ParticipantTile extends StatefulWidget {
  final Participant participant;
  ...
}

class _ParticipantTileState extends State<ParticipantTile> {

  @override
  void initState() {
    ...

    //highlight-next-line
    _initStreamListeners();
    super.initState();
  }

  //highlight-start
  //Change state according to the events received
  _initStreamListeners() {
    widget.participant.on(Events.streamEnabled, (Stream stream) {
      if (stream.kind == 'video') {
        //Camera Turned On
      }
    });

    widget.participant.on(Events.streamDisabled, (Stream stream) {
      if (stream.kind == 'video') {
        //Camera Turned Off
      }
    });
  }
  //highlight-end

  @override
  Widget build(BuildContext context) {
    return YourParticipantWidget();
  }
}
```

### API Reference

The API references for all the methods and events utilised in this guide are provided below.

- [enableCam()](/flutter/api/sdk-reference/room-class/methods#enablecam)
- [disableCam()](/flutter/api/sdk-reference/room-class/methods#disablecam)
- [Events.streamEnabled](/flutter/api/sdk-reference/participant-class/events#streamenabled)
- [Events.streamDisabled](/flutter/api/sdk-reference/participant-class/events#streamdisabled)


---

---
title: Screen Share for Desktop apps| Video SDK
hide_title: true
hide_table_of_contents: false
description: Share your Screen features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Screen Share for Desktop apps
pagination_label: Screen Share for Desktop apps
keywords:
  - audio calling
  - video calling
  - real-time communication
  - collaboration
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: screen-share-desktop
---

# Screen Share for Desktop apps - Flutter

Screen sharing in a meeting is the process of sharing your device screen with other participants in the meeting. It allows everyone in the meeting to see exactly what you are seeing on your screen, which can be helpful for presentations, demonstrations, or collaborations.

### `getScreenShareSources()`

- `getScreenShareSources()` method will help you to list down all available screens and opened windows.

- This method will return a list of `DesktopCapturerSource` objects which will contain the `name`, `thumbnail` and `type` for the source.

#### Example

```javascript
meeting.getScreenShareSources().then((value) => print("Sources : $value"));
```

### `enableScreenShare()`

- By using `enableScreenShare()` function of `Room` object, local participant can share his/her screen or window to other participants.

- `enableScreenShare()` will take the `DesktopCapturerSource` object as parameter to which you want to share the particular source(screen or window).

- Screen Share stream of the participant can be accessed from the `streams` property of `Participant` object.

### `disableScreenShare()`

- By using `disableScreenShare()` function of `Room` object, local participant can stop sharing his/her screen or window to other participants.

### Example

#### Step 1 : Create source selection dialogue

- Create dialog box for selecting a screen or window to share during a meeting. It retrieves the available sources using `getScreenShareSources()` method, allows the user to select a source, and provides buttons to share or cancel the selection.

```jsx title="screen_select_dialog.dart"
import 'package:flutter/material.dart';
import 'package:videosdk_webrtc/flutter_webrtc.dart';
import 'package:videosdk/videosdk.dart';
import 'tab_widget.dart';

// ignore: must_be_immutable
class ScreenSelectDialog extends Dialog {
  ScreenSelectDialog({Key? key, required this.room}) : super(key: key) {
    // get all available screen sources
    //highlight-next-line
    room.getScreenShareSources().then((value) => _setSources(value));
  }

  void _setSources(List<DesktopCapturerSource> source) {
    _sources = source;
    _stateSetter?.call(() {});
  }

  List<DesktopCapturerSource> _sources = [];
  SourceType _sourceType = SourceType.Screen;
  DesktopCapturerSource? _selected_source;
  StateSetter? _stateSetter;
  final Room room;

  void _share(context) async {
    // close the dialog and pass the selected source back to the caller.
    //highlight-next-line
    Navigator.pop<DesktopCapturerSource>(context, _selected_source);
  }

  void _cancel(context) async {
    // close the dialog and pass null as selected source back to the caller
    //highlight-next-line
    Navigator.pop<DesktopCapturerSource>(context, null);
  }

  @override
  Widget build(BuildContext context) {
    return Material(
      type: MaterialType.transparency,
      child: Center(
          child: Container(
        width: 640,
        height: 560,
        color: Colors.white,
        child: Column(
          children: <Widget>[
            Padding(
              padding: const EdgeInsets.all(10),
              child: Stack(
                children: <Widget>[
                  const Align(
                    alignment: Alignment.topLeft,
                    child: Text(
                      'Choose what to share',
                      style: TextStyle(fontSize: 16, color: Colors.black87),
                    ),
                  ),
                  Align(
                    alignment: Alignment.topRight,
                    child: InkWell(
                      child: const Icon(Icons.close),
                      onTap: () => _cancel(context),
                    ),
                  ),
                ],
              ),
            ),
            Expanded(
              flex: 1,
              child: Container(
                width: double.infinity,
                padding: const EdgeInsets.all(10),
                child: StatefulBuilder(
                  builder: (context, setState) {
                    if (context.mounted) {
                      _stateSetter = setState;
                    }
                    return TabWidget(sources: _sources,onSourceChange: onSourceChange,);
                  },
                ),
              ),
            ),
            SizedBox(
              width: double.infinity,
              child: ButtonBar(
                children: <Widget>[
                  MaterialButton(
                    child: const Text(
                      'Cancel',
                      style: TextStyle(color: Colors.black54),
                    ),
                    onPressed: () {
                      _cancel(context);
                    },
                  ),
                  MaterialButton(
                    color: Theme.of(context).primaryColor,
                    child: const Text(
                      'Share',
                    ),
                    onPressed: () {
                      _share(context);
                    },
                  ),
                ],
              ),
            ),
          ],
        ),
      )),
    );
  }
}
```

```jsx title="tab_widget.dart"
import 'package:flutter/material.dart';
import 'package:videosdk_webrtc/flutter_webrtc.dart';
import 'thumbnail_widget.dart';

class TabWidget extends StatefulWidget {
  const TabWidget({
    Key? key,
    required List<DesktopCapturerSource> sources,
    required this.onSourceChange
  }) : _sources = sources, super(key: key);

  final List<DesktopCapturerSource> _sources;
  final ValueChanged<DesktopCapturerSource?> onSourceChange;

  @override
  State<TabWidget> createState() => _TabWidgetState();
}

class _TabWidgetState extends State<TabWidget> {
  SourceType _sourceType = SourceType.Screen;

  DesktopCapturerSource? _selectedSource;

  @override
  Widget build(BuildContext context) {
    return DefaultTabController(
      length: 2,
      child: Column(
        children: <Widget>[
          Container(
            constraints:
                const BoxConstraints.expand(height: 24),
            child: TabBar(
                onTap: (value) => _sourceType = value == 0
                    ? SourceType.Screen
                    : SourceType.Window,
                tabs: const [
                  Tab(
                      child: Text(
                    'Entire Screen',
                    style: TextStyle(color: Colors.black54),
                  )),
                  Tab(
                      child: Text(
                    'Window',
                    style: TextStyle(color: Colors.black54),
                  )),
                ]),
          ),
          const SizedBox(
            height: 2,
          ),
          Expanded(
            child: TabBarView(children: [
              Align(
                  alignment: Alignment.center,
                  child: GridView.count(
                    crossAxisSpacing: 8,
                    crossAxisCount: 2,
                    children: widget._sources
                        .asMap()
                        .entries
                        .where((element) =>
                            element.value.type ==
                            SourceType.Screen)
                        .map((e) => ThumbnailWidget(
                              onTap: (source) {
                                if (context.mounted) {
                                  setState(() {
                                    _selectedSource = source;
                                    widget.onSourceChange(_selectedSource);
                                  });
                                }
                              },
                              source: e.value,
                              selected: _selectedSource?.id ==
                                 e.value.id,
                            ))
                        .toList(),
                  )),
              Align(
                  alignment: Alignment.center,
                  child: GridView.count(
                    crossAxisSpacing: 8,
                    crossAxisCount: 3,
                    children: widget._sources
                        .asMap()
                        .entries
                        .where((element) =>
                            element.value.type ==
                            SourceType.Window)
                        .map((e) => ThumbnailWidget(
                              onTap: (source) {
                                if (context.mounted) {
                                  setState(() {
                                    _selectedSource = source;
                                    widget.onSourceChange(_selectedSource);
                                  });
                                }
                              },
                              source: e.value,
                              selected: _selectedSource?.id ==
                                  e.value.id,
                            ))
                        .toList(),
                  )),
            ]),
          )
        ],
      ),
    );
  }
}
```

```jsx title="thumbnail_widget.dart"
import 'package:flutter/material.dart';
import 'package:videosdk_webrtc/flutter_webrtc.dart';

class ThumbnailWidget extends StatefulWidget {
  const ThumbnailWidget(
      {Key? key,
      required this.source,
      required this.selected,
      required this.onTap})
      : super(key: key);
  final DesktopCapturerSource source;
  final bool selected;
  final Function(DesktopCapturerSource) onTap;

  @override
  _ThumbnailWidgetState createState() => _ThumbnailWidgetState();
}

class _ThumbnailWidgetState extends State<ThumbnailWidget> {
  @override
  Widget build(BuildContext context) {
    return Column(
      children: [
        Expanded(
            child: Container(
          decoration: widget.selected
              ? BoxDecoration(
                  border: Border.all(width: 2, color: Colors.blueAccent))
              : null,
          child: InkWell(
            onTap: () {
              widget.onTap(widget.source);
            },
            child: widget.source.thumbnail != null
                ? Image.memory(
                    widget.source.thumbnail!,
                    gaplessPlayback: true,
                    alignment: Alignment.center,
                  )
                : Container(),
          ),
        )),
        Text(
          widget.source.name,
          style: TextStyle(
              fontSize: 12,
              color: Colors.black87,
              fontWeight:
                  widget.selected ? FontWeight.bold : FontWeight.normal),
        ),
      ],
    );
  }
}
```

- `ScreenSelectDialog` will look like this :

<center>

<img src='https://cdn.videosdk.live/website-resources/docs-resources/flutter_screenshare_desktop_img.png' />

</center>

#### Step 2 : Pass selected source to `enableScreenShare()` method

- Show the screen sharing source selection dialogue that we created in step 1 and start screenShare by using the `_room.enableScreenShare()` method with the chosen source.

```jsx title="meeting_screen.dart"
import 'package:flutter/material.dart';
import 'package:videosdk/videosdk.dart';
import 'screen_select_dialog.dart';

class MeetingScreen extends StatefulWidget {
  ...
}

class _MeetingScreenState extends State<MeetingScreen> {
  late Room _room;

  @override
  void initState() {
    //highlight-next-line
    ...
  }

  @override
  Widget build(BuildContext context) {
    return Column(
      children:[
        //highlight-start
        ElevatedButton(
          onPressed:(){
            // check platform and start screenShare with selected source
            if (!kIsWeb && (Platform.isWindows || Platform.isMacOS)) {
                selectScreenSourceDialog(context).then((value) => {
                    if (value != null)
                      {_room.enableScreenShare(value)}
                });
            }
          },
          child: const Text("Enable Screen Share"),
        ),
        ElevatedButton(
          onPressed:(){
            _room.disableScreenShare();
          },
          child: const Text("Disable Screen Share"),
        ),
    //highlight-end
      ]
    );
  }

  Future<DesktopCapturerSource?> selectScreenSourceDialog(
      BuildContext context) async {
    // return selected source which is returned from the dialog
    //highlight-start
    final source = await showDialog<DesktopCapturerSource>(
      context: context,
      builder: (context) => ScreenSelectDialog(
        room: _room,
      ),
    );
    return source;
    //highlight-end
  }
}
```

#### Output

import ReactPlayer from 'react-player'

<div style={{textAlign: 'center'}}>

<ReactPlayer muted controls autoplay loop playing url="https://cdn.videosdk.live/website-resources/docs-resources/flutter_screenShare_desktop_video.mp4" height="500px" width={"100%"} />

</div>

<br/>

:::note

If you do not pass a `DesktopCapturerSource` object to the `enableScreenShare()` method, by default SDK will choose your entire screen to share.

:::

### Rendering Screen Share Stream

1. To render the screenshare, you will need the `participantId` who is presenting the screen, which can be found from the `presenterId` property of `Room` object.

We will listen for the `Events.presenterChanged` on `Room` object to check if some other participant starts screen share, `Events.streamEnabled` and `Events.streamDisabled` on the `localParticipant`'s object to identify if the local participant is presenting or not.

```js title="meeting_screen.dart"
import 'package:flutter/material.dart';
import 'package:videosdk/videosdk.dart';
import './screen_share_view.dart';

class MeetingScreen extends StatefulWidget {
  final String meetingId;
  final String token;

  const MeetingScreen(
      {super.key, required this.meetingId, required this.token});

  @override
  State<MeetingScreen> createState() => _MeetingScreenState();
}

class _MeetingScreenState extends State<MeetingScreen> {
  late Room _room;
  String? _presenterId;


  @override
  void initState() {
    // create room
    _room = VideoSDK.createRoom(
      roomId: widget.meetingId,
      token: widget.token,
      displayName: "John Doe",
      micEnabled: true,
      camEnabled: true,
      defaultCameraIndex:
          1, // Index of MediaDevices will be used to set default camera
    );

    setMeetingEventListener();

    // Join room
    _room.join();

    super.initState();
  }

  // listening to meeting events
  void setMeetingEventListener() {
    _room.on(Events.roomLeft, () {
      participants.clear();
      Navigator.popUntil(context, ModalRoute.withName('/'));
    });
    //highlight-start
    //Listening if remote participant starts presenting
    _room.on(Events.presenterChanged, (String? presenterId) {
      setState(() => {_presenterId = presenterId});
    });

    //Listening if local participant starts presenting
    _room.localParticipant.on(Events.streamEnabled, (Stream stream) {
      if (stream.kind == "share") {
        setState(() => {_presenterId = _room.localParticipant.id});
      }
    });

    _room.localParticipant.on(Events.streamDisabled, (Stream stream) {
      if (stream.kind == "share") {
        setState(() => {_presenterId = null});
      }
    });
    //highlight-end
  }

  // onbackButton pressed leave the room
  Future<bool> _onWillPop() async {
    _room.leave();
    return true;
  }

  @override
  Widget build(BuildContext context) {
    return WillPopScope(
      onWillPop: () => _onWillPop(),
      child: Scaffold(
        appBar: AppBar(
          title: const Text('VideoSDK QuickStart'),
        ),
        body: Padding(
          padding: const EdgeInsets.all(8.0),
          child: Column(
            children: [
              Text(widget.meetingId),
              //highlight-start
              //we will render the screenshare view if the presenterId is not null
              if (_presenterId != null)
                ScreenShareView(
                  participant: _presenterId == _room.localParticipant.id
                      ? _room.localParticipant
                      : _room.participants[_presenterId],
                ),
                //highlight-end
              ElevatedButton(
                  onPressed: () {
                    if (_presenterId != null) {
                      _room.disableScreenShare();
                    } else {
                      _room.enableScreenShare();
                    }
                  },
                  child: const Text('Toggle Screnshare')),
            ],
          ),
        ),
      ),
    );
  }
}

```

2. Now that we know if there is an active presenter, let us get the screen share stream from the `Participant` object and render it.

```js title="screen_share_view.dart"
import 'package:flutter/material.dart';
import 'package:videosdk/videosdk.dart';

class ScreenShareView extends StatelessWidget {
  final Participant? participant;

  ScreenShareView({super.key, required this.participant}) {
    //highlight-start
  //intialize the shareStream
    participant?.streams.forEach((key, value) {
      if (value.kind == "share") {
        shareStream = value;
      }
    });
    //highlight-end
  }
  Stream? shareStream;

  @override
  Widget build(BuildContext context) {
    return Container(
      color: Colors.grey.shade800,
      height: 300,
      width: 200,
      //highlight-start
      //show the screen share stream
      child: shareStream != null
          ? RTCVideoView(
              shareStream?.renderer as RTCVideoRenderer,
              objectFit: RTCVideoViewObjectFit.RTCVideoViewObjectFitCover,
            )
          : null,
          //highlight-end
    );
  }
}
```

### Events associated with enableScreenShare

- Every Participant will receive a callback on [`Events.streamEnabled`](/flutter/api/sdk-reference/participant-class/events#streamenabled) of the [`Participant`](/flutter/api/sdk-reference/participant-class/introduction) object with `Stream` object.

- Every Remote Participant will receive [`Events.presenterChanged`](/flutter/api/sdk-reference/room-class/events#presenterchanged) callback on the [`Room`](/flutter/api/sdk-reference/room-class/introduction) object with the participantId as `presenterId` who started the screen share.

### Events associated with disableScreenShare

- Every Participant will receive a callback on [`Events.streamDisabled`](/flutter/api/sdk-reference/participant-class/events#streamdisabled) of the [`Participant`](/flutter/api/sdk-reference/participant-class/introduction) object with `Stream` object.

- Every Remote Participant will receive [`Events.presenterChanged`](/flutter/api/sdk-reference/room-class/events#presenterchanged) callback on the [`Room`](/flutter/api/sdk-reference/room-class/introduction) object with the `presenterId` as `null`.

```js
import 'package:flutter/material.dart';
import 'package:videosdk/videosdk.dart';

class ParticipantTile extends StatefulWidget {
  final Participant participant;
  ...
}

class _ParticipantTileState extends State<ParticipantTile> {

  @override
  void initState() {
    ...

    //highlight-next-line
    _initStreamListeners();
    super.initState();
  }

  //highlight-start
  //Change state according to the events received
  _initStreamListeners() {
    widget.participant.on(Events.streamEnabled, (Stream stream) {
      if (stream.kind == 'share') {
        //Screen share Turned On
      }
    });

    widget.participant.on(Events.streamDisabled, (Stream stream) {
      if (stream.kind == 'share') {
        //Screen Share Turned Off
      }
    });
  }
  //highlight-end

  @override
  Widget build(BuildContext context) {
    return YourParticipantWidget();
  }
}

class MeetingScreen extends StatefulWidget {
  ...
}

class _MeetingScreenState extends State<MeetingScreen> {
  late Room room;

  @override
  void initState() {
    //highlight-next-line
    ...

    setupRoomEventListener();
  }

  @override
  Widget build(BuildContext context) {
    return YourMeetingWidget();
  }

  //highlight-start
  void setupRoomEventListener() {

    room.on(Events.presenterChanged, (String? presenterId) {
      //Room screen presenter has changed
      //Participant ID of current presenter is presenterId
    });
  }
  //highlight-end
}
```

### API Reference

The API references for all the methods and events utilised in this guide are provided below.

- [enableScreenShare()](/flutter/api/sdk-reference/room-class/methods#enablescreenshare)
- [disableScreenShare()](/flutter/api/sdk-reference/room-class/methods#disablescreenshare)
- [Events.streamEnabled](/flutter/api/sdk-reference/participant-class/events#streamenabled)
- [Events.streamDisabled](/flutter/api/sdk-reference/participant-class/events#streamdisabled)


---

---
title: Screen Share | Video SDK
hide_title: true
hide_table_of_contents: false
description: Share your Screen features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Screen Share
pagination_label: Screen Share
keywords:
  - audio calling
  - video calling
  - real-time communication
  - collaboration
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: screen-share
---

# Screen Share - Flutter

Screen sharing in a meeting is the process of sharing your device screen with other participants in the meeting. It allows everyone in the meeting to see exactly what you are seeing on your screen, which can be helpful for presentations, demonstrations, or collaborations.

### Screen Share feature Compatibility

| Android and iOS app                   | Web                                   | Desktop app                           | Safari browser         |
| ------------------------------------- | ------------------------------------- | ------------------------------------- | ---------------------- |
| <center> :white_check_mark: </center> | <center> :white_check_mark: </center> | <center> :white_check_mark: </center> | <center> :x: </center> |

### `enableScreenShare()`

- By using `enableScreenShare()` function of `Room` object, local participant can share his/her screen or window to other participants.

- Screen Share stream of the participant can be accessed from the `streams` property of `Participant` object.

- To enable Screenshare in Android devices, you need to provide the following permissions in `AndroidManifest.xml`

```js title="AndroidManifest.xml"
<uses-permission android:name="android.permission.FOREGROUND_SERVICE" />
//For Android devices versioned 14 and above.
<uses-permission android:name="android.permission.FOREGROUND_SERVICE_MEDIA_PROJECTION" />
```

### `disableScreenShare()`

- By using `disableScreenShare()` function of `Room` object, local participant can stop sharing his/her screen or window to other participants.

```jsx
import 'package:flutter/material.dart';
import 'package:videosdk/videosdk.dart';

class MeetingScreen extends StatefulWidget {
  ...
}

class _MeetingScreenState extends State<MeetingScreen> {
  late Room _room;

  @override
  void initState() {
    //highlight-next-line
    ...
  }

  @override
  Widget build(BuildContext context) {
    return Column(
      children:[
        //highlight-start
        ElevatedButton(
          onPressed:(){
            _room.enableScreenShare();
          },
          child: const Text("Enable Screen Share"),
        ),
        ElevatedButton(
          onPressed:(){
            _room.disableScreenShare();
          },
          child: const Text("Disable Screen Share"),
        ),
    //highlight-end
      ]
    );
  }
}
```

### iOS Setup

:::note

For Flutter iOS Screen Share feature, you need to follow this guide [Flutter iOS Screen Share](/flutter/guide/video-and-audio-calling-api-sdk/extras/flutter-ios-screen-share)

:::

### Rendering Screen Share Stream

1. To render the screenshare, you will need the `participantId` who is presenting the screen, which can be found from the `presenterId` property of `Room` object.

We will listen for the `Events.presenterChanged` on `Room` object to check if some other participant starts screen share, `Events.streamEnabled` and `Events.streamDisabled` on the `localParticipant`'s object to identify if the local participant is presenting or not.

```js title="meeting_screen.dart"
import 'package:flutter/material.dart';
import 'package:videosdk/videosdk.dart';
import './screen_share_view.dart';

class MeetingScreen extends StatefulWidget {
  final String meetingId;
  final String token;

  const MeetingScreen(
      {super.key, required this.meetingId, required this.token});

  @override
  State<MeetingScreen> createState() => _MeetingScreenState();
}

class _MeetingScreenState extends State<MeetingScreen> {
  late Room _room;
  String? _presenterId;


  @override
  void initState() {
    // create room
    _room = VideoSDK.createRoom(
      roomId: widget.meetingId,
      token: widget.token,
      displayName: "John Doe",
      micEnabled: true,
      camEnabled: true,
      defaultCameraIndex:
          1, // Index of MediaDevices will be used to set default camera
    );

    setMeetingEventListener();

    // Join room
    _room.join();

    super.initState();
  }

  // listening to meeting events
  void setMeetingEventListener() {
    _room.on(Events.roomLeft, () {
      participants.clear();
      Navigator.popUntil(context, ModalRoute.withName('/'));
    });
    //highlight-start
    //Listening if remote participant starts presenting
    _room.on(Events.presenterChanged, (String? presenterId) {
      setState(() => {_presenterId = presenterId});
    });

    //Listening if local participant starts presenting
    _room.localParticipant.on(Events.streamEnabled, (Stream stream) {
      if (stream.kind == "share") {
        setState(() => {_presenterId = _room.localParticipant.id});
      }
    });

    _room.localParticipant.on(Events.streamDisabled, (Stream stream) {
      if (stream.kind == "share") {
        setState(() => {_presenterId = null});
      }
    });
    //highlight-end
  }

  // onbackButton pressed leave the room
  Future<bool> _onWillPop() async {
    _room.leave();
    return true;
  }

  @override
  Widget build(BuildContext context) {
    return WillPopScope(
      onWillPop: () => _onWillPop(),
      child: Scaffold(
        appBar: AppBar(
          title: const Text('VideoSDK QuickStart'),
        ),
        body: Padding(
          padding: const EdgeInsets.all(8.0),
          child: Column(
            children: [
              Text(widget.meetingId),
              //highlight-start
              //we will render the screenshare view if the presenterId is not null
              if (_presenterId != null)
                ScreenShareView(
                  participant: _presenterId == _room.localParticipant.id
                      ? _room.localParticipant
                      : _room.participants[_presenterId],
                ),
                //highlight-end
              ElevatedButton(
                  onPressed: () {
                    if (_presenterId != null) {
                      _room.disableScreenShare();
                    } else {
                      _room.enableScreenShare();
                    }
                  },
                  child: const Text('Toggle Screnshare')),
            ],
          ),
        ),
      ),
    );
  }
}

```

2. Now that we know if there is an active presenter, let us get the screen share stream from the `Participant` object and render it.

```js title="screen_share_view.dart"
import 'package:flutter/material.dart';
import 'package:videosdk/videosdk.dart';

class ScreenShareView extends StatelessWidget {
  final Participant? participant;

  ScreenShareView({super.key, required this.participant}) {
    //highlight-start
  //intialize the shareStream
    participant?.streams.forEach((key, value) {
      if (value.kind == "share") {
        shareStream = value;
      }
    });
    //highlight-end
  }
  Stream? shareStream;

  @override
  Widget build(BuildContext context) {
    return Container(
      color: Colors.grey.shade800,
      height: 300,
      width: 200,
      //highlight-start
      //show the screen share stream
      child: shareStream != null
          ? RTCVideoView(
              shareStream?.renderer as RTCVideoRenderer,
              objectFit: RTCVideoViewObjectFit.RTCVideoViewObjectFitCover,
            )
          : null,
          //highlight-end
    );
  }
}
```

### Events associated with enableScreenShare

- Every Participant will receive a callback on [`Events.streamEnabled`](/flutter/api/sdk-reference/participant-class/events#streamenabled) of the [`Participant`](/flutter/api/sdk-reference/participant-class/introduction) object with `Stream` object.

- Every Remote Participant will receive [`Events.presenterChanged`](/flutter/api/sdk-reference/room-class/events#presenterchanged) callback on the [`Room`](/flutter/api/sdk-reference/room-class/introduction) object with the participantId as `presenterId` who started the screen share.

### Events associated with disableScreenShare

- Every Participant will receive a callback on [`Events.streamDisabled`](/flutter/api/sdk-reference/participant-class/events#streamdisabled) of the [`Participant`](/flutter/api/sdk-reference/participant-class/introduction) object with `Stream` object.

- Every Remote Participant will receive [`Events.presenterChanged`](/flutter/api/sdk-reference/room-class/events#presenterchanged) callback on the [`Room`](/flutter/api/sdk-reference/room-class/introduction) object with the `presenterId` as `null`.

```js
import 'package:flutter/material.dart';
import 'package:videosdk/videosdk.dart';

class ParticipantTile extends StatefulWidget {
  final Participant participant;
  ...
}

class _ParticipantTileState extends State<ParticipantTile> {

  @override
  void initState() {
    ...

    //highlight-next-line
    _initStreamListeners();
    super.initState();
  }

  //highlight-start
  //Change state according to the events received
  _initStreamListeners() {
    widget.participant.on(Events.streamEnabled, (Stream stream) {
      if (stream.kind == 'share') {
        //Screen share Turned On
      }
    });

    widget.participant.on(Events.streamDisabled, (Stream stream) {
      if (stream.kind == 'share') {
        //Screen Share Turned Off
      }
    });
  }
  //highlight-end

  @override
  Widget build(BuildContext context) {
    return YourParticipantWidget();
  }
}

class MeetingScreen extends StatefulWidget {
  ...
}

class _MeetingScreenState extends State<MeetingScreen> {
  late Room room;

  @override
  void initState() {
    //highlight-next-line
    ...

    setupRoomEventListener();
  }

  @override
  Widget build(BuildContext context) {
    return YourMeetingWidget();
  }

  //highlight-start
  void setupRoomEventListener() {

    room.on(Events.presenterChanged, (String? presenterId) {
      //Room screen presenter has changed
      //Participant ID of current presenter is presenterId
    });
  }
  //highlight-end
}
```

### API Reference

The API references for all the methods and events utilised in this guide are provided below.

- [enableScreenShare()](/flutter/api/sdk-reference/room-class/methods#enablescreenshare)
- [disableScreenShare()](/flutter/api/sdk-reference/room-class/methods#disablescreenshare)
- [Events.streamEnabled](/flutter/api/sdk-reference/participant-class/events#streamenabled)
- [Events.streamDisabled](/flutter/api/sdk-reference/participant-class/events#streamdisabled)


---

---
sidebar_label: Known Issues
pagination_label: Known Issues
---

# Known Issues - Flutter

### Issue: Camera Not Working with MultiStream (v1.3.1)

When multiStream is set to `true`, the camera functionality will not work. By default, multiStream is enabled.

#### Solution 

- Please pass multiStream: false in createRoom() method, your camera works as expected.

```js 
_room = VideoSDK.createRoom(
    roomId: widget.meetingId,
    token: widget.token,
    displayName: "John Doe",
    micEnabled: micEnabled,
    camEnabled: camEnabled,
    multiStream: false, // Disable multiStream to fix camera issue
    defaultCameraIndex: kIsWeb ? 0 : 1
);
```


This page will let you updated with Flutter SDK known issues with better solution.

### Issue : `iOS: webrtc/webrtc.h file not found.`

#### Solution

**Add below script to end of pod file.**

```
post_install do |installer|
  installer.pods_project.targets.each do |target|
    flutter_additional_ios_build_settings(target)
    target.build_configurations.each do |build_configuration|
      build_configuration.build_settings['EXCLUDED_ARCHS[sdk=iphonesimulator*]'] = 'arm64 i386'
    end
  end
end
```


---

---
title: Custom Template
sidebar_position: 1
sidebar_label: Custom Template
hide_table_of_contents: false
---

import CustomTemplate from '../../../../mdx/\_custom-template.mdx';

<CustomTemplate title="Custom Template With LiveStreaming"/>


---

---
title: Interactive Livestream - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: Interactive Livestream features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Interactive Livestream (HLS)
pagination_label: Interactive Livestream (HLS)
keywords:
  - Start HLS meeting
  - Stop HLS meeting
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: interactive-livestream
---

# Interactive Livestream (HLS) - Flutter

Interactive live streaming (HLS) refers to a type of live streaming where viewers can actively engage with the content being streamed and with other viewers in real-time.

In an interactive live stream (HLS), viewers can take part in a variety of activities like live polling, Q&A sessions, and even sending virtual gifts to the content creator or each other.

<center>

![Screen Share with Audio](https://cdn.videosdk.live/website-resources/docs-resources/mobile_hls.png)

</center>

VideoSDK also allows you to configure the interactive livestream layouts in numerous ways like by simply setting different prebuilt layouts in the configuration or by providing your own custom template to do the livestream according to your layout choice.

This guide will provide an overview of how to implement start and stop Livestreaming.

### `startHls()`

`startHls()` can be used to start a interactive livestream of the meeting which can be accessed from the `Room` object. This method accepts two parameters:

- `1. config (optional)`: This parameter will define how the livestream layout should look like.

- `2. transcription (optional)`: This parameter lets you start post transcription for the Livestreaming.

  ```js
  Map<String, dynamic> config = {
    // highlight-next-line
    // Layout Configuration
    "layout": {
      "type": "GRID", // "SPOTLIGHT" | "SIDEBAR",  Default : "GRID"
      "priority": "SPEAKER", // "PIN", Default : "SPEAKER"
      "gridSize": 4, // MAX : 4
    },

    // highlight-next-line
    // Theme of recording
    "theme": "DARK", //  "LIGHT" | "DEFAULT"

    // highlight-next-line
    // `mode` is used to either record video & audio both or only audio.
    "mode": "video-and-audio", // "audio", Default : "video-and-audio"

    // highlight-next-line
    // Quality of recording and is only applicable to `video-and-audio` type mode.
    "quality": "high", // "low" | "med",  Default : "med"

    //highlight-start
    // This mode refers to orientation of recording.
    // landscape : Record the meeting in horizontally
    // portrait : Record the meeting in vertically (Best for mobile view)
    //highlight-end
    "orientation": "landscape", // "portrait",  Default : "landscape"
  };

  // highlight-next-line
  // Post Transcription Configuration
  Map<String, dynamic> transcription = {
    "enabled": true, // Enables post transcription
    "summary": {
      "enabled": true,  // Enables summary generation
       // Guides summary generation
      "prompt":
          "Write summary in sections like Title, Agenda, Speakers, Action Items, Outlines, Notes and Summary",
    }
  };

  room.startHls(config: config, transcription: transcription);
  ```

### `stopHls()`

- `stopHls()` is used to stop the meeting livestream which can be accessed from the `Room` object.

#### Example

```js
import 'package:flutter/material.dart';
import 'package:videosdk/videosdk.dart';

class MeetingScreen extends StatefulWidget {
  ...
}

class _MeetingScreenState extends State<MeetingScreen> {
  late Room _room;

  @override
  void initState() {
    //highlight-next-line
    ...
  }

  @override
  Widget build(BuildContext context) {
    return Column(
      children:[
        //highlight-start
        ElevatedButton(
          onPressed:(){
            Map<String, dynamic> config = {
              "layout": {
                "type": "GRID",
                "priority": "SPEAKER",
                "gridSize": 4,
              },
              "theme": "DARK",
              "mode": "video-and-audio",
              "quality": "high",
              "orientation": "portrait",
            };

            Map<String, dynamic> transcription = {
              "enabled": true,
              "summary": {
                "enabled": true,
                "prompt":
                    "Write summary in sections like Title, Agenda, Speakers, Action Items, Outlines, Notes and Summary",
              }
            };
            _room.startHls(config: config, transcription: transcription);
          },
          child: const Text("Start HLS"),
        ),
        ElevatedButton(
          onPressed:(){
            _room.stopHls();
          },
          child: const Text("Stop HLS"),
        ),
    //highlight-end
      ]
    );
  }
}
```

:::tip
If you want to learn more about the Interactive Livestream and how you can implement it in your own platform, you can checkout this [guide](/flutter/guide/interactive-live-streaming/integrate-hls/overview).
:::

### Event associated with HLS

- **hlsStateChanged** - Whenever meeting HLS state changes, then `hlsStateChanged` event will trigger.

- You can get the `playbackHlsUrl` and `livestreamUrl` of the HLS to play it on the Viewer side when the state changes to `HLS_PLAYABLE`
  - `playbackHlsUrl` - Live HLS with playback support
  - `livestreamUrl` - Live HLS without playback support

:::note
`downstreamUrl` is now depecated. Use `playbackHlsUrl` or `livestreamUrl` in place of `downstreamUrl`
:::

```js
import 'package:flutter/material.dart';
import 'package:videosdk/videosdk.dart';

class MeetingScreen extends StatefulWidget {
  ...
}

class _MeetingScreenState extends State<MeetingScreen> {
  late Room room;

  @override
  void initState() {
    //highlight-next-line
    ...

    setupRoomEventListener();
  }

  @override
  Widget build(BuildContext context) {
    return YourMeetingWidget();
  }

  //highlight-start
  void setupRoomEventListener() {
    room.on(Events.hlsStateChanged, (Map<String, dynamic> data) {
      //Status can be :: HLS_STARTING
      //Status can be :: HLS_STARTED
      //Status can be :: HLS_PLAYABLE
      //Status can be :: HLS_STOPPING
      //Status can be :: HLS_STOPPED
      log("Meeting HLS status : ${data['status']}");
      if (data['status'] == "HLS_PLAYABLE")
        log("PLAYBACKHLS URL -- " + data['playbackHlsUrl']);
    });
  }
  //highlight-end
}
```

## API Reference

The API references for all the methods utilized in this guide are provided below.

- [startHls](/flutter/api/sdk-reference/room-class/methods#starthls)
- [stopHls](/flutter/api/sdk-reference/room-class/methods#stophls)
- [Events.hlsStateChanged](/flutter/api/sdk-reference/room-class/events#hlsstatechanged)


---

---
title: RTMP Livestream - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: RTMP Livestream features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: RTMP Livestream
pagination_label: RTMP Livestream
keywords:
  - Start Livestream meeting
  - Stop Livestream meeting
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: rtmp-livestream
---

# RTMP Livestream - Flutter

RTMP is a popular protocol for live streaming video content from a VideoSDK to platforms such as YouTube, Twitch, Facebook, and others.

By providing the platform-specific stream key and stream URL, the VideoSDK can connect to the platform's RTMP server and transmit the live video stream.

VideoSDK allows you to livestream your meeting to platform which support RTMP ingestion just by providing the platform-specific stream key and stream URL, we can connect to the platform's RTMP server and transmit the live video stream.

VideoSDK also allows you to configure the livestream layouts in numerous ways like by simply setting different prebuilt layouts in the configuration or by providing your own custom template to do the livestream according to your layout choice.

This guide will provide an overview of how to implement start and stop RTMP Livestreaming.

### `startLivestream()`

`startLivestream()` can be used to start a RTMP livestream of the meeting which can be accessed from the `Room` object. This method accepts three parameters:

- `1. outputs`: This parameter accepts an array of objects which contains the RTMP `url` and `streamKey` of the platforms you want to start the livestream.

- `2. config (optional)`: This parameter will define how the livestream layout should look like.

- `3. transcription (optional)`: This parameter lets you start post transcription for the recording.

  ```js
  var outputs = [
    {
      url: "rtmp://a.rtmp.youtube.com/live2",
      streamKey: "<STREAM_KEY>",
    },
    {
      url: "rtmps://",
      streamKey: "<STREAM_KEY>",
    },
  ];
  Map<String, dynamic> config = {
    // highlight-next-line
    // Layout Configuration
    layout: {
      type: "GRID", // "SPOTLIGHT" | "SIDEBAR",  Default : "GRID"
      priority: "SPEAKER", // "PIN", Default : "SPEAKER"
      gridSize: 4, // MAX : 4
    },

    // highlight-next-line
    // Theme of livestream
    theme: "DARK", //  "LIGHT" | "DEFAULT"
  };

  // highlight-next-line
  // Post Transcription Configuration
  Map<String, dynamic> transcription = {
    "enabled": true, // Enables post transcription
    "summary": {
      "enabled": true,  // Enables summary generation
       // Guides summary generation
      "prompt":
          "Write summary in sections like Title, Agenda, Speakers, Action Items, Outlines, Notes and Summary",
    }
  };

  room.startLivestream(outputs, config: config, transcription: transcription);
  ```

### `stopLivestream()`

- `stopLivestream()` is used to stop the meeting livestream which can be accessed from the `Room` object.

#### Example

```js
import 'package:flutter/material.dart';
import 'package:videosdk/videosdk.dart';

class MeetingScreen extends StatefulWidget {
  ...
}

class _MeetingScreenState extends State<MeetingScreen> {
  late Room _room;

  @override
  void initState() {
    //highlight-next-line
    ...
  }

  @override
  Widget build(BuildContext context) {
    return Column(
      children:[
        //highlight-start
        ElevatedButton(
          onPressed:(){
            var outputs = [
              {
                url: "rtmp://a.rtmp.youtube.com/live2",
                streamKey: "<STREAM_KEY>",
              },
              {
                url: "rtmps://",
                streamKey: "<STREAM_KEY>",
              },
            ];
            var liveStreamConfig =  {
              'layout': {
                'type': 'GRID',
                'priority': 'SPEAKER',
                'gridSize': 4,
              },
              'theme': "LIGHT",
            };
            room.startLivestream(outputs, config: livestreamConfig);
          },
          child: const Text("Start Livestream"),
        ),
        ElevatedButton(
          onPressed:(){
            _room.stopLivestream();
          },
          child: const Text("Stop Livestream"),
        ),
    //highlight-end
      ]
    );
  }
}
```

### Event associated with Livestream

- **livestreamStateChanged** - Whenever meeting livestream state changes, then `livestreamStateChanged` event will trigger.

```js
import 'package:flutter/material.dart';
import 'package:videosdk/videosdk.dart';

class MeetingScreen extends StatefulWidget {
  ...
}

class _MeetingScreenState extends State<MeetingScreen> {
  late Room room;

  @override
  void initState() {
    //highlight-next-line
    ...

    setupRoomEventListener();
  }

  @override
  Widget build(BuildContext context) {
    return YourMeetingWidget();
  }

  //highlight-start
  void setupRoomEventListener() {
    room.on(Events.livestreamStateChanged, (String status) {
      //Status can be :: LIVESTREAM_STARTING
      //Status can be :: LIVESTREAM_STARTED
      //Status can be :: LIVESTREAM_STOPPING
      //Status can be :: LIVESTREAM_STOPPED
      log("Meeting Livestream status : $status");
    });
  }
  //highlight-end
}
```

## API Reference

The API references for all the methods utilized in this guide are provided below.

- [startLivestream](/flutter/api/sdk-reference/room-class/methods#startlivestream)
- [stopLivestream](/flutter/api/sdk-reference/room-class/methods#stoplivestream)
- [Events.livestreamStateChanged](/flutter/api/sdk-reference/room-class/events#livestreamstatechanged)


---

---
sidebar_label: Migration Notes
pagination_label: Migration Notes
---

import NoIndex from '../../../mdx/\_no-index.mdx';

<NoIndex/>

# Migration Notes - Flutter

This page will guide you to migrate from previous version of Flutter SDK.

## Migration to v1.0.0 from v0.0.14

1. We have renamed `Meeting` class to `Room` class.

2. Import `package:videosdk/videosdk.dart` instead of `package:videosdk/rtc.dart`.

   For Example:

   ```js title=v0.0.14
   import "package:videosdk/rtc.dart";
   ```

   ```js title=v1.0.0
   import "package:videosdk/videosdk.dart";
   ```

3. Replace MeetingBuilder with [`VideoSDK.createRoom()`](../../api/sdk-reference/videosdk-class/methods#createroom) and [`join()`](../../api/sdk-reference/room-class/methods#join).

   For Example:

   ```js title=v0.0.14
   // MeetingBuilder
   MeetingBuilder(
      meetingId: '<MEETING_ID>',
      token: '<TOKEN>',
      displayName: '<DISPLAY_NAME>',
      micEnabled: true,
      webcamEnabled: true,
      maxResolution: 'hd',
      notification: const NotificationInfo(
         title: "Video SDK",
         message: "Video SDK is sharing screen in the meeting",
         icon: "notification_share",
      ),
      builder: (_meeting){
         // Do Something
      }
   ),

   ```

   ```js title=v1.0.0
   // Creating VideoSDK Room
   Room room = VideoSDK.createRoom(
      roomId: '<ROOM_ID>',
      token: '<TOKEN>',
      displayName: '<DISPLAY_NAME>',
      micEnabled: true,
      camEnabled: true,
      maxResolution: 'hd',
      notification: const NotificationInfo(
         title: "Video SDK",
         message: "Video SDK is sharing screen in the meeting",
         icon: "notification_share",
      ),
   );

   // Joining VideoSDK Room
   room.join();

   ```

4. Change event `Events.meetingJoined` to [`Events.roomJoined`](../../api/sdk-reference/room-class/events#roomjoined).

   For Example:

   ```js title=v0.0.14
   meeting.on(Events.meetingJoined, (){
      // Do Something
   })
   ```

   ```js title=v1.0.0
   room.on(Events.roomJoined, (){
      // Do Something
   })
   ```

5. Change event `Events.meetingLeft` to [`Events.roomLeft`](../../api/sdk-reference/room-class/events#roomleft).

   For Example:

   ```js title=v0.0.14
   meeting.on(Events.meetingLeft, (){
      // Do Something
   })
   ```

   ```js title=v1.0.0
   room.on(Events.roomLeft, (){
      // Do Something
   })
   ```

6. Change event `Events.webcamRequested` to [`Events.cameraRequested`](../../api/sdk-reference/room-class/events#camerarequested).

   For Example:

   ```js title=v0.0.14
   meeting.on(Events.webcamRequested, (){
      // Do Something
   })
   ```

   ```js title=v1.0.0
   room.on(Events.cameraRequested, (){
      // Do Something
   })
   ```

7. Change `enableMic()` method to [`unmuteMic()`](../../api/sdk-reference/participant-class/methods#unmutemic) method of [`Participant Class`](../../api/sdk-reference/participant-class/introduction).

   For Example:

   ```js title=v0.0.14
   participant.enableMic();
   ```

   ```js title=v1.0.0
   participant.unmuteMic();
   ```

8. Change `disableMic()` method to [`muteMic()`](../../api/sdk-reference/participant-class/methods#mutemic) method of [`Participant Class`](../../api/sdk-reference/participant-class/introduction).

   For Example:

   ```js title=v0.0.14
   participant.disableMic();
   ```

   ```js title=v1.0.0
   participant.muteMic();
   ```

9. Change `enableWebcam()` method to [`enableCam()`](../../api/sdk-reference/participant-class/methods#enablecam) method of [`Participant class`](../../api/sdk-reference/participant-class/introduction).

   For Example:

   ```js title=v0.0.14
   participant.enableWebcam();
   ```

   ```js title=v1.0.0
   participant.enableCam();
   ```

10. Change `disableWebcam()` method to [`disableCam()`](../../api/sdk-reference/participant-class/methods#disablecam) method of [`Participant class`](../../api/sdk-reference/participant-class/introduction).

For Example:

```js title=v0.0.14
participant.disableWebcam();
```

```js title=v1.0.0
participant.disableCam();
```

11. Change `enableWebcam()` method to [`enableCam()`](../../api/sdk-reference/room-class/methods#enablecam) method of [`Room class`](../../api/sdk-reference/room-class/introduction).

For Example:

```js title=v0.0.14
meeting.enableWebcam();
```

```js title=v1.0.0
room.enableCam();
```

12. Change `disableWebcam()` method to [`disableCam()`](../../api/sdk-reference/room-class/methods#disablecam) method of [`Room class`](../../api/sdk-reference/room-class/introduction).

For Example:

```js title=v0.0.14
meeting.disableWebcam();
```

```js title=v1.0.0
room.disableCam();
```

13. Change `getWebcams()` method to [`getCameras()`](../../api/sdk-reference/room-class/methods#getcameras) method of [`Room class`](../../api/sdk-reference/room-class/introduction).

For Example:

```js title=v0.0.14
meeting.getWebcams();
```

```js title=v1.0.0
room.getCameras();
```

14. Change `changeWebcam()` method to [`changeCam()`](../../api/sdk-reference/room-class/methods#changecam) method of [`Room class`](../../api/sdk-reference/room-class/introduction).

For Example:

```js title=v0.0.14
meeting.changeWebcam(deviceId);
```

```js title=v1.0.0
room.changeCam(deviceId);
```

15. Change `selectedWebcamId` property to [`selectedCamId`](../../api/sdk-reference/room-class/properties#selectedcamid) on [`Room class`](../../api/sdk-reference/room-class/introduction).

For Example:

```js title=v0.0.14
String webCamId = meeting.selectedWebcamId;
```

```js title=v1.0.0
String webCamId = meeting.selectedCamId;
```

---


---

---
title: Quick Start With Interactive Live Streaming | VideoSDK Flutter
hide_title: true
hide_table_of_contents: false
description: Learn how to quickly integrate interactive live streaming features using VideoSDK's flutter SDK. Step-by-step guide for implementing real-time video & audio streaming in mobile applications with code examples.
sidebar_label: Start With Interactive Live Streaming
pagination_label: Start With Interactive Live Streaming
keywords:
  - flutter sdk
  - live streaming api
  - webrtc streaming
  - interactive livestream
  - video streaming
  - audio streaming
  - real-time communication
  - video conferencing
  - streaming tutorial
  - mobile sdk
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: quick-start-flutter-ils
---

# Quick Start for Interactive Live Streaming in Flutter

import ReactPlayer from 'react-player'

**VideoSDK** empowers you to seamlessly integrate **interactive live streaming** features into your React Native application in minutes. While built for LiveStream, the SDK is easily adaptable for live streaming with support for up to **100 hosts/co-hosts** and **2,000 viewers** in **real-time**. Perfect for social use cases, this guide will walk you through integrating live streaming into your app.

:::info
For standard live streaming with 6-7 second latency and playback support, follow this [documentation](./quick-start-ils.md).
:::

## Prerequisites

Before proceeding, ensure that your development environment meets the following requirements:

- Video SDK Developer Account (Not having one, follow **[Video SDK Dashboard](https://app.videosdk.live/)**)
- Basic understanding of Flutter
- **[Flutter VideoSDK](https://pub.dev/packages/videosdk)**
- Have Flutter installed on your system.

## Getting Started with the Code!

Follow the steps to create the environment necessary to add video calls into your app. Also you can find the code sample for [quickstart here](https://github.com/videosdk-live/quickstart/tree/main/interactive-live-streaming/flutter-ils).

## Create new Flutter app

Create a new Flutter App using the below command.

```bash
$ flutter create videosdk_flutter_quickstart_ils
```

## Install Video SDK

Install the VideoSDK using the below-mentioned npm command. Make sure you are in your flutter app directory before you run this command.

```bash
$ flutter pub add videosdk

//run this command to add http library to perform network call to generate roomId
$ flutter pub add http

```

## Structure of the project

Your project structure should look like this.

```jsx title="Project Structure"
  root
  ├── android
  ├── ios
  ├── lib
       ├── api_call.dart
       ├── ils_screen.dart
       ├── ils_view.dart
       ├── join_screen.dart
       ├── main.dart
       ├── liveStream_Controls.dart
       ├── participant_tile.dart
  ├── .env
```

We are going to create following flutter widgets JoinScreen, ILSScreen, liveStream_Controls, ParticipantTile, ILSView for the quickstart app which will cover both Host and Audience part of the app.

## App Structure

App widget will contain **JoinScreen** and **ILSScreen** screens. ILSScreen will render the **ILSView** which consist of views based on the participants mode. ILSView will have **liveStreamControls** and both view will use **ParticipantTile** which will be conditionally rendered based on the modes.

<center>
<img height="500" alt="ViewAudience" src="https://cdn.videosdk.live/website-resources/docs-resources/flutter_ils_qs_overview.png"/>
</center>

# Configure Project

## For Android

- Update the /android/app/src/main/AndroidManifest.xml for the permissions we will be using to implement the audio and video features.

```xml title="AndroidManifest.xml"
<uses-feature android:name="android.hardware.camera" />
<uses-feature android:name="android.hardware.camera.autofocus" />
<uses-permission android:name="android.permission.CAMERA" />
<uses-permission android:name="android.permission.RECORD_AUDIO" />
<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
<uses-permission android:name="android.permission.CHANGE_NETWORK_STATE" />
<uses-permission android:name="android.permission.MODIFY_AUDIO_SETTINGS" />
<uses-permission android:name="android.permission.INTERNET"/>
```

Also you will need to set your build settings to Java 8 because the official WebRTC jar now uses static methods in EglBase interface. Just add this to your app-level /android/app/build.gradle.

```
android {
    //...
    compileOptions {
        sourceCompatibility JavaVersion.VERSION_1_8
        targetCompatibility JavaVersion.VERSION_1_8
    }
}
```

- If necessary, in the same build.gradle you will need to increase minSdkVersion of defaultConfig up to 23 (currently default Flutter generator set it to 16).
- If necessary, in the same build.gradle you will need to increase compileSdkVersion and targetSdkVersion up to 31 (currently default Flutter generator set it to 30).

## For iOS

- Add the following entries which allow your app to access the camera and microphone to your /ios/Runner/Info.plist file :

```xml title="info.plist"
<key>NSCameraUsageDescription</key>
<string>$(PRODUCT_NAME) Camera Usage!</string>
<key>NSMicrophoneUsageDescription</key>
<string>$(PRODUCT_NAME) Microphone Usage!</string>
```

- Uncomment the following line to define a global platform for your project in /ios/Podfile :

```x title="Podfile"
# platform :ios, '11.0'
```

## Step 1: Get started with api_call.dart

Before jumping to anything else, you will write a function to generate a unique liveStreamId. You will require auth token, you can generate it using either by using [videosdk-rtc-api-server-examples](https://github.com/videosdk-live/videosdk-rtc-api-server-examples) or generate it from the [Video SDK Dashboard](https://app.videosdk.live/api-keys) for development.

- Use the **`Token`** (which you have generated from Video Sdk Dashboard) in the .env file along with that also add the **`API`** Key for creating a room.

```x title=".env"
AUTH_TOKEN= <Enter your Generated Auth Token here!>
```

```js title="api_call.dart"
import 'dart:convert';
import 'package:flutter_dotenv/flutter_dotenv.dart';
import 'package:http/http.dart' as http;

//Auth token we will use to generate a liveStream and connect to it
String token = dotenv.env['AUTH_TOKEN']!;
// API call to create livestream
Future<String> createLivestream() async {

  final Uri getlivestreamIdUrl = Uri.parse('https://api.videosdk.live/v2/rooms');
  final http.Response liveStreamIdResponse =
      await http.post(getlivestreamIdUrl, headers: {
    "Authorization": token,
  });

  if (liveStreamIdResponse.statusCode != 200) {
    throw Exception(json.decode(liveStreamIdResponse.body)["error"]);
  }
  var liveStreamID = json.decode(liveStreamIdResponse.body)['roomId'];
  return liveStreamID;
}

```

Before proceeding, let's understand the two modes of a Live Stream:

#### 1. SEND_AND_RECV (For Host or Co-host):

- Designed primarily for the Host or Co-host.
- Allows sending and receiving media.
- Hosts can broadcast their audio/video and interact directly with the audience.

#### 2. RECV_ONLY (For Audience):

- Tailored for the Audience.
- Enables receiving media shared by the Host.
- Audience members can view and listen but cannot share their own media.

<div style={{textAlign: 'center'}}>
<img
  src="https://cdn.videosdk.live/website-resources/docs-resources/ils_mode_demonstration-compressed.jpg"
  alt="ILS Mode Demonstration"
  width="550"
  height="450"
/>
</div>

## Step 2: Initialize and Join the Livestream

Let's create join_screen.dart file in lib directory and create JoinScreen StatelessWidget.

The JoinScreen will consist of:

- **`Create livestream Button`**- This button will create a new livestream for Host and join it with mode CONFERENCE.
- **`livestream ID TextField`** - This text field will contain the livestream ID, you want to join.
- **`Join Livestream as Host Button`** - This button allows the user to join an existing Live Stream using the provided livestreamId with the `SEND_AND_RECV` mode, enabling full host privileges.
- **`Join livestream as Audience Button`** -Enables the user to join an existing Live Stream using the provided livestream with the `RECV_ONLY` mode, allowing view-only access.

```js title="join_screen.dart"
import 'package:flutter/material.dart';
import 'package:videosdk_hls_flutter_example/flutter%20-hls/api_call.dart';
import 'package:videosdk_hls_flutter_example/flutter%20-hls/ils_screen.dart';

import 'package:videosdk/videosdk.dart';

class JoinScreen extends StatelessWidget {
  final _livestreamIdController = TextEditingController();

  JoinScreen({super.key});

  //Creates new livestream Id and joins it in CONFERNCE mode.
  void onCreateButtonPressed(BuildContext context) async {
    // call api to create livestream and navigate to ILSScreen with livestreamId,token and mode
    await createLivestream().then((liveStreamId) {
      if (!context.mounted) return;
      Navigator.of(context).push(
        MaterialPageRoute(
          builder: (context) => ILSScreen(
            liveStreamId: liveStreamId,
            token: token,
            mode: Mode.SEND_AND_RECV,
          ),
        ),
      );
    });
  }

  //Join the provided livestream with given Mode and livestreamId
  void onJoinButtonPressed(BuildContext context, Mode mode) {
    // check livestream  id is not null or invaild
    // if livestream id is vaild then navigate to ILSScreen with livestreamId, token and mode
    String liveStreamId = _livestreamIdController.text;
    var re = RegExp("\\w{4}\\-\\w{4}\\-\\w{4}");
    if (liveStreamId.isNotEmpty && re.hasMatch(liveStreamId)) {
      _livestreamIdController.clear();
      Navigator.of(context).push(
        MaterialPageRoute(
          builder: (context) => ILSScreen(
            liveStreamId: liveStreamId,
            token: token,
            mode: mode,
          ),
        ),
      );
    } else {
      ScaffoldMessenger.of(context).showSnackBar(const SnackBar(
        content: Text("Please enter valid livestream id"),
      ));
    }
  }

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      backgroundColor: Colors.black,
      appBar: AppBar(
        title: const Text('VideoSDK ILS QuickStart'),
      ),
      body: Padding(
        padding: const EdgeInsets.all(12.0),
        child: Column(
          mainAxisAlignment: MainAxisAlignment.center,
          children: [
            //Creating a new livestream
            ElevatedButton(
              onPressed: () => onCreateButtonPressed(context),
              child: const Text('Create LiveStream'),
            ),
            const SizedBox(height: 40),
            TextField(
              style: const TextStyle(color: Colors.white),
              decoration: const InputDecoration(
                hintText: 'Enter LiveStream Id',
                border: OutlineInputBorder(),
                hintStyle: TextStyle(color: Colors.white),
              ),
              controller: _livestreamIdController,
            ),
            //Joining the livestream as host
            ElevatedButton(
              onPressed: () => onJoinButtonPressed(context, Mode.SEND_AND_RECV),
              child: const Text('Join livestream as Host'),
            ),
            //Joining the livestream as Audience
            ElevatedButton(
              onPressed: () => onJoinButtonPressed(context, Mode.RECV_ONLY),
              child: const Text('Join livestream as Audience'),
            ),
          ],
        ),
      ),
    );
  }
}

```

Update the app entry to JoinScreen from the main.dart file.

```js title="main.dart"
import 'package:flutter/material.dart';
import 'package:flutter_dotenv/flutter_dotenv.dart';

import 'constants/colors.dart';
import 'navigator_key.dart';
import 'screens/splash_screen.dart';

void main() async {
  // Run Flutter App
  WidgetsFlutterBinding.ensureInitialized();
  await dotenv.load(fileName: ".env");
  runApp(const MyApp());
}

class MyApp extends StatelessWidget {
  const MyApp({Key? key}) : super(key: key);

  @override
  Widget build(BuildContext context) {
    // Material App
    return MaterialApp(
      debugShowCheckedModeBanner: false,
      title: 'VideoSDK Flutter Example',
      theme: ThemeData.dark().copyWith(
        appBarTheme: const AppBarTheme().copyWith(
          color: primaryColor,
        ),
        primaryColor: primaryColor,
        scaffoldBackgroundColor: secondaryColor,
      ),
      home: const JoinScreen(),
      navigatorKey: navigatorKey,
    );
  }
}


```

## Output For JoinScreen

<center>
<img height="500" alt="ViewAudience" src="https://cdn.videosdk.live/website-resources/docs-resources/flutter_ils_qs_join_screen.jpg"/>
</center>

## Step 3: Creating the ILSScreen

Let's create ils_screen.dart file and create ILSScreen StatefulWidget which will take the liveStreamId, token and mode of the participant in the constructor.

We will create a new room using the createRoom method and render the ILSView based on the passed participant mode.

```js title="ils_screen.dart"
import 'package:flutter/material.dart';
import 'package:videosdk/videosdk.dart';
import 'package:videosdk_hls_flutter_example/flutter%20-hls/ils_view.dart';
import 'package:videosdk_hls_flutter_example/flutter%20-hls/join_screen.dart';

class ILSScreen extends StatefulWidget {
  final String liveStreamId;
  final String token;
  final Mode mode;

  const ILSScreen(
      {super.key,
      required this.liveStreamId,
      required this.token,
      required this.mode});

  @override
  State<ILSScreen> createState() => _ILSScreenState();
}

class _ILSScreenState extends State<ILSScreen> {
  late Room _room;
  bool isJoined = false;
  Mode? localParticipantMode;

  @override
  void initState() {
    // create room when widget loads
    _room = VideoSDK.createRoom(
      roomId: widget.liveStreamId,
      token: widget.token,
      displayName: "John Doe",
      micEnabled: true,
      camEnabled: true,
      defaultCameraIndex:
          1, // Index of MediaDevices will be used to set default camera
      mode: widget.mode,
    );
    localParticipantMode = widget.mode;
    // setting the event listener for join and leave events
    setLivestreamEventListener();

    // Joining room
    _room.join();

    super.initState();
  }

  // listening to room events
  void setLivestreamEventListener() {
    _room.on(Events.roomJoined, () {
      if (widget.mode == Mode.SEND_AND_RECV) {
        _room.localParticipant.pin();
      }
      setState(() {
        localParticipantMode = _room.localParticipant.mode;
        isJoined = true;
      });
    });

    //Handling navigation when livestream is left
    _room.on(Events.roomLeft, () {
      Navigator.pushAndRemoveUntil(
        context,
        MaterialPageRoute(builder: (context) => JoinScreen()),
        (route) => false, // Removes all previous routes
      );
    });
  }

  // onbackButton pressed leave the room
  Future<bool> _onWillPop() async {
    _room.leave();
    return true;
  }

  @override
  Widget build(BuildContext context) {
    return WillPopScope(
      onWillPop: () => _onWillPop(),
      child: Scaffold(
        backgroundColor: Colors.black,
        appBar: AppBar(
          title: const Text('VideoSDK ILS QuickStart'),
        ),
        //Showing the Host or Audience View based on the mode
        body: isJoined
            ? ILSView(room: _room, bar: false, mode: widget.mode)
            : const Center(
                child: Text(
                  "Joining...",
                  style: TextStyle(color: Colors.white),
                ),
              ),
      ),
    );
  }
}
```

## Step 4: Implementing View for Host/Audience

Let's create the **`ILSView`** which will show the **`livestreamControls`** and the **`ParticipantTile`** in grid.

1.  Let us start off by creating the StatefulWidget named ParticipantTile in participant_tile.dart file. It will consist the participant tile grid where all participant with `SEND_AND_RECV` mode will get rendered.

```js title="participant_tile.dart"
import 'package:flutter/material.dart';
import 'package:videosdk/videosdk.dart';

class ParticipantTile extends StatefulWidget {
  final Participant participant;

  const ParticipantTile({
    Key? key,
    required this.participant,
  }) : super(key: key);

  @override
  State<ParticipantTile> createState() => _ParticipantTileState();
}

class _ParticipantTileState extends State<ParticipantTile> {
  Stream? videoStream;

  @override
  void initState() {
    // initial video stream for the participant
    widget.participant.streams.forEach((key, Stream stream) {
      setState(() {
        if (stream.kind == 'video') {
          videoStream = stream;
        }
      });
    });
    _initStreamListeners();
    super.initState();
  }

  @override
  void setState(fn) {
    if (mounted) {
      super.setState(fn);
    }
  }

  _initStreamListeners() {
    widget.participant.on(Events.streamEnabled, (Stream stream) {
      if (stream.kind == 'video') {
        setState(() => videoStream = stream);
      }
    });

    widget.participant.on(Events.streamDisabled, (Stream stream) {
      if (stream.kind == 'video') {
        setState(() => videoStream = null);
      }
    });
  }

  @override
  Widget build(BuildContext context) {
    // Check if participant mode is SEND_AND_RECEIVE
    if (widget.participant.mode != Mode.SEND_AND_RECV) {
      return const Center(
        child: Padding(
          padding: EdgeInsets.all(8.0),
          child: Text(
            'No participant in Host mode',
            style: TextStyle(
              color: Colors.white,
              fontSize: 16,
            ),
          ),
        ),
      );
    }

    return Padding(
      padding: const EdgeInsets.all(8.0),
      child: videoStream != null
          ? RTCVideoView(
              videoStream?.renderer as RTCVideoRenderer,
              objectFit: RTCVideoViewObjectFit.RTCVideoViewObjectFitCover,
            )
          : Container(
              color: Colors.grey.shade800,
              child: const Center(
                child: Icon(
                  Icons.person,
                  size: 100,
                ),
              ),
            ),
    );
  }
}
```

2.  Next let us add the StatelessWidget named LivestreamControls in the livestream_controls.dart file. This widget will accept the callback handlers for all the livestream control buttons and the current HLS state of the livestream.

```js title="livestream_controls.dart"
import 'package:flutter/material.dart';
import 'package:videosdk/videosdk.dart';

class LivestreamControls extends StatefulWidget {
  final Mode mode;
  final void Function()? onToggleMicButtonPressed;
  final void Function()? onToggleCameraButtonPressed;
  final void Function()? onChangeModeButtonPressed;

  LivestreamControls({
    super.key,
    required this.mode,
    this.onToggleMicButtonPressed,
    this.onToggleCameraButtonPressed,
    this.onChangeModeButtonPressed,
  });

  @override
  State<LivestreamControls> createState() => _LivestreamControlsState();
}

class _LivestreamControlsState extends State<LivestreamControls> {
  @override
  Widget build(BuildContext context) {
    return Row(
      mainAxisAlignment: MainAxisAlignment.center,
      children: [
        if (widget.mode == Mode.SEND_AND_RECV) ...[
          ElevatedButton(
            onPressed: widget.onToggleMicButtonPressed,
            child: const Text('Toggle Mic'),
          ),
          const SizedBox(width: 10),
          ElevatedButton(
            onPressed: widget.onToggleCameraButtonPressed,
            child: const Text('Toggle Cam'),
          ),
          ElevatedButton(
            onPressed: widget.onChangeModeButtonPressed,
            child: const Text('Audience'),
          ),
        ] else if (widget.mode == Mode.RECV_ONLY) ...[
          ElevatedButton(
            onPressed: widget.onChangeModeButtonPressed,
            child: const Text('Host/Speaker'),
          ),
        ]
      ],
    );
  }
}
```

3. Lets finally put all these widget in the StatefulWidget named ILSView in ils_view.dart file. This widget will listen to the participantJoined and participantLeft events. It will render the participants and the livestream controls like leave, toggle mic, webcam and Mode.

```js title="ils_view.dart"
import 'package:flutter/material.dart';
import 'package:flutter/services.dart';
import 'package:videosdk/videosdk.dart';

import 'package:videosdk_hls_flutter_example/flutter%20-hls/livestream_control.dart';
import 'package:videosdk_hls_flutter_example/flutter%20-hls/praticipant_tile.dart';

class ILSView extends StatefulWidget {
  final Room room;
  final Mode mode;
  final bool bar;
  const ILSView(
      {super.key, required this.room, required this.bar, required this.mode});

  @override
  State<ILSView> createState() => _ILSViewState();
}

class _ILSViewState extends State<ILSView> {
  var micEnabled = true;
  var camEnabled = true;

  Map<String, Participant> participants = {};
  Mode? localMode;
  @override
  void initState() {
    super.initState();
    localMode = widget.mode;
    //Setting up the event listeners and initializing the participants and hls state
    setlivestreamEventListener();
    participants.putIfAbsent(
        widget.room.localParticipant.id, () => widget.room.localParticipant);
    //filtering the CONFERENCE participants to be shown in the grid
    widget.room.participants.values.forEach((participant) {
      if (participant.mode == Mode.SEND_AND_RECV) {
        participants.putIfAbsent(participant.id, () => participant);
      }
    });
  }

  @override
  Widget build(BuildContext context) {
    return Padding(
      padding: const EdgeInsets.all(8.0),
      child: Column(
        children: [
          Row(
            children: [
              Expanded(
                child: Text(
                  widget.room.id,
                  style: const TextStyle(
                    color: Colors.white,
                    fontWeight: FontWeight.bold,
                    fontSize: 15,
                  ),
                ),
              ),
              ElevatedButton(
                onPressed: () => {
                  Clipboard.setData(ClipboardData(text: widget.room.id)),
                  ScaffoldMessenger.of(context).showSnackBar(
                    const SnackBar(
                      content: Text("Livestream Id Copied"),
                    ),
                  ),
                },
                child: const Text("Copy Livestream Id"),
              ),
              const SizedBox(width: 10),
              ElevatedButton(
                onPressed: () => widget.room.leave(),
                style: ElevatedButton.styleFrom(
                  backgroundColor: Colors.red,
                ),
                child: const Text("Leave"),
              ),
            ],
          ),
          Expanded(
            child:  ParticipantTile(
              participant: widget.room.localParticipant,
            ),
          ),
          _buildLivestreamControls(),
        ],
      ),
    );
  }

  Widget _buildLivestreamControls() {
    if (localMode == Mode.SEND_AND_RECV) {
      return LivestreamControls(
        mode: Mode.SEND_AND_RECV,
        onToggleMicButtonPressed: () {
          micEnabled ? widget.room.muteMic() : widget.room.unmuteMic();
          micEnabled = !micEnabled;
        },
        onToggleCameraButtonPressed: () {
          camEnabled ? widget.room.disableCam() : widget.room.enableCam();
          camEnabled = !camEnabled;
        },
        onChangeModeButtonPressed: () {
          widget.room.changeMode(Mode.RECV_ONLY);
          setState(() {
            localMode = Mode.RECV_ONLY;
          });
        },
      );
    } else if (localMode == Mode.RECV_ONLY) {
      return Column(
        children: [
          LivestreamControls(
            mode: Mode.RECV_ONLY,
            onToggleMicButtonPressed: () {
              micEnabled ? widget.room.muteMic() : widget.room.unmuteMic();
              micEnabled = !micEnabled;
            },
            onToggleCameraButtonPressed: () {
              camEnabled ? widget.room.disableCam() : widget.room.enableCam();
              camEnabled = !camEnabled;
            },
            onChangeModeButtonPressed: () {
              widget.room.changeMode(Mode.SEND_AND_RECV);
              setState(() {
                localMode = Mode.SEND_AND_RECV;
              });
            },
          ),
        ],
      );
    } else {
      // Default controls
      return LivestreamControls(
        mode: Mode.RECV_ONLY,
        onToggleMicButtonPressed: () {
          micEnabled ? widget.room.muteMic() : widget.room.unmuteMic();
          micEnabled = !micEnabled;
        },
        onToggleCameraButtonPressed: () {
          camEnabled ? widget.room.disableCam() : widget.room.enableCam();
          camEnabled = !camEnabled;
        },
        onChangeModeButtonPressed: () {
          widget.room.changeMode(Mode.RECV_ONLY);
        },
      );
    }
  }

  // listening to room events for participants join, left and hls state changes
  void setlivestreamEventListener() {
    widget.room.on(
      Events.participantJoined,
      (Participant participant) {
        //Adding only Conference participant to show in grid
        if (participant.mode == Mode.SEND_AND_RECV) {
          setState(
            () => participants.putIfAbsent(participant.id, () => participant),
          );
        }
      },
    );
    widget.room.on(Events.participantModeChanged, () {});
    widget.room.on(Events.participantLeft, (String participantId) {
      if (participants.containsKey(participantId)) {
        setState(
          () => participants.remove(participantId),
        );
      }
    });
  }
}
```

## Output of Host View

<center>
<img height="500" alt="ViewAudience" src="https://cdn.videosdk.live/website-resources/docs-resources/flutter_ils_qs_host_view.jpg"/>
</center>
## Output of Audience View
<center>
<img height="500" alt="ViewAudience" src="https://cdn.videosdk.live/website-resources/docs-resources/flutter_ils_qs_audience_view.jpg"/>
</center>

# Run and Test

Now to run and test, make sure that you have added the **Token** in .env file and also **API** key.

Your app should look like this after the implementation.

<div style={{textAlign: 'center'}}>

<ReactPlayer autoplay muted loop playing controls url='https://cdn.videosdk.live/website-resources/docs-resources/flutter_ils_qs_screen_recording.mov' height="560px" width={"100%"}/>

</div>

:::tip
You can checkout the complete [quick start example here](https://github.com/videosdk-live/quickstart/tree/main/interactive-live-streaming/flutter-ils).
:::


---

---
title: Quick Start With Http Live Streaming(HLS)
hide_title: true
hide_table_of_contents: false
description: Video SDK enables the opportunity to integrate native IOS, Android & Web SDKs to add live video & audio conferencing to your applications.
sidebar_label: Start With Http Live Streaming(HLS)
pagination_label: Start With Http Live Streaming(HLS)
keywords:
  - audio calling
  - video calling
  - real-time communication
  - collaboration
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: quick-start-ils
---

# Quick Start for Http Live Streaming(HLS) in Flutter

import ReactPlayer from 'react-player'

<ReactPlayer controls url="https://www.youtube.com/watch?v=83HVyk9oezU" height="500px" width={"100%"} />

VideoSDK enables you to embed the livestreaming experience into your Flutter application in minutes.

In this quickstart, we are going to explore interactive livestreaming feature of Video SDK. We will go through step by step guide of integrating interactive livestreaming with Flutter Video SDK.

:::info

For low-latency interactive live streaming (under 100ms), follow this [documentation](./quick-start-flutter-ils.md).
:::

## Prerequisites

Before proceeding, ensure that your development environment meets the following requirements:

- Video SDK Developer Account (Not having one, follow **[Video SDK Dashboard](https://app.videosdk.live/)**)
- The basic understanding of Flutter.
- **[Flutter Video SDK](https://pub.dev/packages/videosdk)**
- Have Flutter installed on your device.

:::important

One should have a VideoSDK account to generate token.
Visit VideoSDK **[dashboard](https://app.videosdk.live/api-keys)** to generate token

:::

## Getting Started with the Code!

Follow the steps to create the environment necessary to add video calls into your app. Also you can find the code sample for [quickstart here](https://github.com/videosdk-live/quickstart/tree/main/flutter-hls).

import CautionMessage from '@site/src/theme/CautionMessage';

<CautionMessage sdk="Flutter SDK" version="v1.3.0" />

### Create a new Flutter project.

Create a new Flutter App using the below command.

```bash
$ flutter create videosdk_flutter_quickstart_ils
```

### Install Video SDK

Install the VideoSDK using the below-mentioned flutter command. Make sure you are in your flutter app directory before you run this command.

```js
$ flutter pub add videosdk

//run this command to add http library to perform network call to generate roomId
$ flutter pub add http

//run this command to add flutter_vlc_player library to play HLS stream in your app
$ flutter pub add flutter_vlc_player
```

### Structure of the project

Your project structure should look like this.

```js title="Project Structure"
root
├── android
├── ios
├── lib
     ├── api_call.dart
     ├── ils_screen.dart
     ├── ils_speaker_view.dart
     ├── ils_viewer_view.dart
     ├── join_screen.dart
     ├── livestream_player.dart
     ├── main.dart
     ├── meeting_controls.dart
     ├── participant_tile.dart
```

We are going to create following flutter widgets JoinScreen, ILSScreen, ILSSpeakerView, MeetingControls, ParticipantTile, ILSViewerView, LivestreamPlayer for the quickstart app which will cover both speaker and viewer part of the app.

### App Structure

App widget will contain `JoinScreen` and `ILSScreen` screens. `ILSScreen` will render the `ILSSpeakerView` or `ILSViewerView` based on the participants mode. `ILSSpeakerView` will have `MeetingControls` and `ParticipantTile`

<div style={{textAlign: 'center'}}>

![VideoSDK Flutter ILS Quick Start Architecture](https://cdn.videosdk.live/website-resources/docs-resources/flutter_ils_arch.png)

</div>

### Configure Project

#### For Android

- Update the `/android/app/src/main/AndroidManifest.xml` for the permissions we will be using to implement the audio and video features.

```js title="AndroidManifest.xml"
<uses-feature android:name="android.hardware.camera" />
<uses-feature android:name="android.hardware.camera.autofocus" />
<uses-permission android:name="android.permission.CAMERA" />
<uses-permission android:name="android.permission.RECORD_AUDIO" />
<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
<uses-permission android:name="android.permission.CHANGE_NETWORK_STATE" />
<uses-permission android:name="android.permission.MODIFY_AUDIO_SETTINGS" />
<uses-permission android:name="android.permission.INTERNET"/>
```

- Also you will need to set your build settings to Java 8 because the official WebRTC jar now uses static methods in `EglBase` interface. Just add this to your app-level `/android/app/build.gradle`.

```js
android {
    //...
    compileOptions {
        sourceCompatibility JavaVersion.VERSION_1_8
        targetCompatibility JavaVersion.VERSION_1_8
    }
}
```

- If necessary, in the same `build.gradle` you will need to increase `minSdkVersion` of `defaultConfig` up to `23` (currently default Flutter generator set it to `16`).

- If necessary, in the same `build.gradle` you will need to increase `compileSdkVersion` and `targetSdkVersion` up to `31` (currently default Flutter generator set it to `30`).

#### For iOS

- Add the following entries which allow your app to access the camera and microphone to your `/ios/Runner/Info.plist` file :

```xml
<key>NSCameraUsageDescription</key>
<string>$(PRODUCT_NAME) Camera Usage!</string>
<key>NSMicrophoneUsageDescription</key>
<string>$(PRODUCT_NAME) Microphone Usage!</string>
```

- Uncomment the following line to define a global platform for your project in `/ios/Podfile` :

```js title="Podfile"
# platform :ios, '11.0'
```

### Step 1: Get started with api_call.dart

Before jumping to anything else, you will write a function to generate a unique meetingId. You will require auth token, you can generate it using either by using [videosdk-rtc-api-server-examples](https://github.com/videosdk-live/videosdk-rtc-api-server-examples) or generate it from the [Video SDK Dashboard](https://app.videosdk.live/api-keys) for development.

```js title="api_call.dart"
import 'dart:convert';
import 'package:http/http.dart' as http;

//Auth token we will use to generate a meeting and connect to it
//highlight-next-line
String token = "<Generated-from-dashboard>";

// API call to create meeting
Future<String> createMeeting() async {
  final http.Response httpResponse = await http.post(
    Uri.parse("https://api.videosdk.live/v2/rooms"),
    headers: {'Authorization': token},
  );

//Destructuring the roomId from the response
//highlight-next-line
  return json.decode(httpResponse.body)['roomId'];
}
```

### Step 2 : Creating the JoinScreen

Let's create `join_screen.dart` file in `lib` directory and create JoinScreen `StatelessWidget`.

The JoinScreen will consist of:

- **Create Meeting Button** - This button will create a new meeting for speaker and join it with mode `SEND_AND_RECV`.
- **Meeting ID TextField** - This text field will contain the meeting ID, you want to join.
- **Join Meeting as Host Button** - This button will join the meeting in `SEND_AND_RECV` mode for the speakers, which you have provided.
- **Join Meeting as Viewer Button** - This button will join the meeting in `SIGNALLING_ONLY` mode for the viewers, which you have provided.

```js title="join_screen.dart"
import 'package:flutter/material.dart';
import 'api_call.dart';
import 'ils_screen.dart';
import 'package:videosdk/videosdk.dart';

class JoinScreen extends StatelessWidget {
  final _meetingIdController = TextEditingController();

  JoinScreen({super.key});

  //highlight-start
  //Creates new Meeting Id and joins it in CONFERNCE mode.
  void onCreateButtonPressed(BuildContext context) async {
    // call api to create meeting and navigate to ILSScreen with meetingId,token and mode
    await createMeeting().then((meetingId) {
      if (!context.mounted) return;
      Navigator.of(context).push(
        MaterialPageRoute(
          builder: (context) => ILSScreen(
            meetingId: meetingId,
            token: token,
            mode: Mode.SEND_AND_RECV,
          ),
        ),
      );
    });
  }
  //highlight-end

  //highlight-start
  //Join the provided meeting with given Mode and meetingId
  void onJoinButtonPressed(BuildContext context, Mode mode) {
    // check meeting id is not null or invaild
    // if meeting id is vaild then navigate to ILSScreen with meetingId, token and mode
    String meetingId = _meetingIdController.text;
    var re = RegExp("\\w{4}\\-\\w{4}\\-\\w{4}");
    if (meetingId.isNotEmpty && re.hasMatch(meetingId)) {
      _meetingIdController.clear();
      Navigator.of(context).push(
        MaterialPageRoute(
          builder: (context) => ILSScreen(
            meetingId: meetingId,
            token: token,
            mode: mode,
          ),
        ),
      );
    } else {
      ScaffoldMessenger.of(context).showSnackBar(const SnackBar(
        content: Text("Please enter valid meeting id"),
      ));
    }
  }
  //highlight-end

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      backgroundColor: Colors.black,
      appBar: AppBar(
        title: const Text('VideoSDK ILS QuickStart'),
      ),
      body: Padding(
        padding: const EdgeInsets.all(12.0),
        child: Column(
          mainAxisAlignment: MainAxisAlignment.center,
          children: [
            //Creating a new meeting
            ElevatedButton(
              onPressed: () => onCreateButtonPressed(context),
              child: const Text('Create Meeting'),
            ),
            const SizedBox(height: 40),
            TextField(
              style: const TextStyle(color: Colors.white),
              decoration: const InputDecoration(
                hintText: 'Enter Meeting Id',
                border: OutlineInputBorder(),
                hintStyle: TextStyle(color: Colors.white),
              ),
              controller: _meetingIdController,
            ),
            //Joining the meeting as host
            ElevatedButton(
              onPressed: () => onJoinButtonPressed(context, Mode.SEND_AND_RECV),
              child: const Text('Join Meeting as Host'),
            ),
            //Joining the meeting as viewer
            ElevatedButton(
              onPressed: () => onJoinButtonPressed(context, Mode.SIGNALLING_ONLY),
              child: const Text('Join Meeting as Viewer'),
            ),
          ],
        ),
      ),
    );
  }
}
```

- Update the app entry to `JoinScreen` from the `main.dart` file.

```js title="main.dart"
import 'package:flutter/material.dart';
//highlight-next-line
import 'join_screen.dart';

void main() {
  runApp(const MyApp());
}

class MyApp extends StatelessWidget {
  const MyApp({super.key});

  // This widget is the root of your application.
  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      title: 'VideoSDK QuickStart',
      theme: ThemeData(
        primarySwatch: Colors.blue,
      ),
      //highlight-next-line
      home: JoinScreen(),
    );
  }
}
```

#### Output

<img src="https://cdn.videosdk.live/website-resources/docs-resources/flutter_ils_joining.png" width="250"/>

### Step 3 : Creating the ILSScreen

Let's create `ils_screen.dart` file and create ILSScreen `StatefulWidget` which will take the `meetingId`, `token` and `mode` of the participant in the constructor.

We will create a new room using the `createRoom` method and render the `ILSSpeakerView` or `ILSViewerView` based on the passed participant `mode`.

```js title="ils_screen.dart"
import 'package:flutter/material.dart';
import 'package:videosdk/videosdk.dart';
import './ils_speaker_view.dart';
import './ils_viewer_view.dart';

class ILSScreen extends StatefulWidget {
  final String meetingId;
  final String token;
  final Mode mode;

  const ILSScreen(
      {super.key,
      required this.meetingId,
      required this.token,
      required this.mode});

  @override
  State<ILSScreen> createState() => _ILSScreenState();
}

class _ILSScreenState extends State<ILSScreen> {
  late Room _room;
  bool isJoined = false;

  @override
  void initState() {
    //highlight-start
    // create room when widget loads
    _room = VideoSDK.createRoom(
      roomId: widget.meetingId,
      token: widget.token,
      displayName: "John Doe",
      micEnabled: true,
      camEnabled: true,
      defaultCameraIndex:
          1, // Index of MediaDevices will be used to set default camera
      mode: widget.mode,
    );

    // setting the event listener for join and leave events
    setMeetingEventListener();

    // Joining room
    _room.join();
    //highlight-end

    super.initState();
  }

  // listening to room events
  void setMeetingEventListener() {
    //highlight-start
    //Setting the joining flag to true when meeting is joined
    _room.on(Events.roomJoined, () {
      if (widget.mode == Mode.SEND_AND_RECV) {
        _room.localParticipant.pin();
      }
      setState(() {
        isJoined = true;
      });
    });

    //Handling navigation when meeting is left
    _room.on(Events.roomLeft, () {
      Navigator.popUntil(context, ModalRoute.withName('/'));
    });
    //highlight-end
  }

  // onbackButton pressed leave the room
  Future<bool> _onWillPop() async {
    _room.leave();
    return true;
  }

  @override
  Widget build(BuildContext context) {
    return WillPopScope(
      onWillPop: () => _onWillPop(),
      child: Scaffold(
        backgroundColor: Colors.black,
        appBar: AppBar(
          title: const Text('VideoSDK ILS QuickStart'),
        ),
        //highlight-start
        //Showing the Speaker or Viewer View based on the mode
        body: isJoined
            ? widget.mode == Mode.SEND_AND_RECV
                ? ILSSpeakerView(room: _room)
                : widget.mode == Mode.SIGNALLING_ONLY
                    ? ILSViewerView(room: _room)
                    : null
            : const Center(
                  child: Text("Joining...",
                      style: TextStyle(color: Colors.white),
                    ),
                  ),
        //highlight-end
      ),
    );
  }
}

```

### Step 4 : Implementing Speaker View

Let's create the `ILSSpeakerView` which will show the `MeetingControls` and the `ParticipantTile` in grid.

1. Let us start off by creating the `StatefulWidget` named `ParticipantTile` in `participant_tile.dart` file. It will consist of `RTCVideoView` which will show participant's video stream.

```js title="participant_tile.dart"
import 'package:flutter/material.dart';
import 'package:videosdk/videosdk.dart';

class ParticipantTile extends StatefulWidget {
  final Participant participant;
  const ParticipantTile({super.key, required this.participant});

  @override
  State<ParticipantTile> createState() => _ParticipantTileState();
}

class _ParticipantTileState extends State<ParticipantTile> {
  Stream? videoStream;

  @override
  void initState() {
    // initialze video stream for the participant if they are present
    widget.participant.streams.forEach((key, Stream stream) {
      setState(() {
        if (stream.kind == 'video') {
          videoStream = stream;
        }
      });
    });
    _initStreamListeners();
    super.initState();
  }

  //highlight-start
  //Event listener for the video stream of the participant
  _initStreamListeners() {
    widget.participant.on(Events.streamEnabled, (Stream stream) {
      if (stream.kind == 'video') {
        setState(() => videoStream = stream);
      }
    });

    widget.participant.on(Events.streamDisabled, (Stream stream) {
      if (stream.kind == 'video') {
        setState(() => videoStream = null);
      }
    });
  }
  //highlight-end

  @override
  Widget build(BuildContext context) {
    return Padding(
      padding: const EdgeInsets.all(8.0),
      //Rending the Video Stream of the participant
      child: videoStream != null
          ? RTCVideoView(
              videoStream?.renderer as RTCVideoRenderer,
              objectFit: RTCVideoViewObjectFit.RTCVideoViewObjectFitCover,
            )
          : Container(
              color: Colors.grey.shade800,
              child: const Center(
                child: Icon(
                  Icons.person,
                  size: 100,
                ),
              ),
            ),
    );
  }
}
```

2. Next let us add the `StatelessWidget` named `MeetingControls` in the `meeting_controls.dart` file. This widget will accept the callback handlers for all the meeting control buttons and the current HLS state of the meeting.

```js title="meeting_controls.dart"
import 'package:flutter/material.dart';

class MeetingControls extends StatelessWidget {
  final String hlsState;
  final void Function() onToggleMicButtonPressed;
  final void Function() onToggleCameraButtonPressed;
  final void Function() onHLSButtonPressed;

  const MeetingControls(
      {super.key,
      required this.hlsState,
      required this.onToggleMicButtonPressed,
      required this.onToggleCameraButtonPressed,
      required this.onHLSButtonPressed});

  @override
  Widget build(BuildContext context) {
    return Wrap(
      children: [
        ElevatedButton(
          onPressed: onToggleMicButtonPressed,
            child: const Text('Toggle Mic')),
        const SizedBox(width: 10),
        ElevatedButton(
            onPressed: onToggleCameraButtonPressed,
            child: const Text('Toggle WebCam')),
        const SizedBox(width: 10),
        ElevatedButton(
            onPressed: onHLSButtonPressed,
            child: Text(hlsState == "HLS_STOPPED"
                ? 'Start HLS'
                : hlsState == "HLS_STARTING"
                    ? "Starting HLS"
                    : hlsState == "HLS_STARTED" || hlsState == "HLS_PLAYABLE"
                        ? "Stop HLS"
                        : hlsState == "HLS_STOPPING"
                            ? "Stopping HLS"
                            : "Start HLS")),
      ],
    );
  }
}
```

3. Lets finally put all these widget in the `StatefulWidget` named `ILSSpeakerView` in `ils_speaker_view.dart` file. This widget will listen to the `hlsStateChanged`, `participantJoined` and `participantLeft` events. It will render the participants and the meeting controls like leave, toggle mic and webcam as well as start and stop HLS.

```js title="ils_speaker_view.dart"
import 'package:flutter/material.dart';
import 'package:videosdk/videosdk.dart';
import 'package:videosdk_flutter_quickstart/meeting_controls.dart';
import 'package:videosdk_flutter_quickstart/participant_tile.dart';

class ILSSpeakerView extends StatefulWidget {
  final Room room;
  const ILSSpeakerView({super.key, required this.room});

  @override
  State<ILSSpeakerView> createState() => _ILSSpeakerViewState();
}

class _ILSSpeakerViewState extends State<ILSSpeakerView> {
  var micEnabled = true;
  var camEnabled = true;
  String hlsState = "HLS_STOPPED";

  Map<String, Participant> participants = {};

  @override
  void initState() {
    super.initState();
    //highlight-start
    //Setting up the event listeners and initializing the participants and hls state
    setMeetingEventListener();
    participants.putIfAbsent(
        widget.room.localParticipant.id, () => widget.room.localParticipant);
    //filtering the SEND_AND_RECV participants to be shown in the grid
    widget.room.participants.values.forEach((participant) {
      if (participant.mode == Mode.SEND_AND_RECV) {
        participants.putIfAbsent(participant.id, () => participant);
      }
    });
    hlsState = widget.room.hlsState;
    //highlight-end
  }

  @override
  void setState(VoidCallback fn) {
    if (mounted) {
      super.setState(fn);
    }
  }

  @override
  Widget build(BuildContext context) {
    return Padding(
      padding: const EdgeInsets.all(8.0),
      child: Column(
        children: [
          Row(
            children: [
              Expanded(
                  child: Text(
                widget.room.id,
                style: const TextStyle(color: Colors.white),
              )),
              ElevatedButton(
                onPressed: () => {
                  Clipboard.setData(ClipboardData(text: widget.room.id)),
                  ScaffoldMessenger.of(context).showSnackBar(const SnackBar(
                    content: Text("Meeting Id Coppied"),
                  ))
                },
                child: const Text("Copy Meeting Id"),
              ),
              const SizedBox(width: 10),
              ElevatedButton(
                onPressed: () => {widget.room.leave()},
                style: ElevatedButton.styleFrom(
                  backgroundColor: Colors.red,
                ),
                child: const Text("Leave"),
              )
            ],
          ),
          const SizedBox(
            height: 20,
          ),
          //highlight-start
          //Showing the current HLS state
          Text(
            "Current HLS State: ${hlsState == "HLS_STARTED" || hlsState == "HLS_PLAYABLE" ? "Livestream is Started" : hlsState == "HLS_STARTING" ? "Livestream is starting" : hlsState == "HLS_STOPPING" ? "Livestream is stopping" : "Livestream is stopped"}",
            style: const TextStyle(color: Colors.white),
          ),
          //highlight-end
          //render all participants in the room
          Expanded(
            child: GridView.builder(
              gridDelegate: const SliverGridDelegateWithFixedCrossAxisCount(
                crossAxisCount: 1,
              ),
              itemBuilder: (context, index) {
                return ParticipantTile(
                    participant: participants.values.elementAt(index));
              },
              itemCount: participants.length,
            ),
          ),
          //Rending the meeting Controls
          MeetingControls(
            hlsState: hlsState,
            onToggleMicButtonPressed: () {
              micEnabled ? widget.room.muteMic() : widget.room.unmuteMic();
              micEnabled = !micEnabled;
            },
            onToggleCameraButtonPressed: () {
              camEnabled ? widget.room.disableCam() : widget.room.enableCam();
              camEnabled = !camEnabled;
            },
            //highlight-start
            //HLS handler which will start and stop HLS
            onHLSButtonPressed: () => {
              if (hlsState == "HLS_STOPPED")
                {
                  widget.room.startHls(config: {
                    "layout": {
                      "type": "SPOTLIGHT",
                      "priority": "PIN",
                      "GRID": 20,
                    },
                    "mode": "video-and-audio",
                    "theme": "DARK",
                    "quality": "high",
                    "orientation": "portrait",
                  })
                }
              else if (hlsState == "HLS_STARTED" || hlsState == "HLS_PLAYABLE")
                {widget.room.stopHls()}
            },
          //highlight-end
          ),
        ],
      ),
    );
  }

  //highlight-start
  // listening to room events for participants join, left and hls state changes
  void setMeetingEventListener() {
    widget.room.on(
      Events.participantJoined,
      (Participant participant) {
        //Adding only SEND_AND_RECV participant to show in grid
        if (participant.mode == Mode.SEND_AND_RECV) {
          setState(
            () => participants.putIfAbsent(participant.id, () => participant),
          );
        }
      },
    );

    widget.room.on(Events.participantLeft, (String participantId) {
      if (participants.containsKey(participantId)) {
        setState(
          () => participants.remove(participantId),
        );
      }
    });
    widget.room.on(
      Events.hlsStateChanged,
      (Map<String, dynamic> data) {
        setState(
          () => hlsState = data['status'],
        );
      },
    );
  }
  //highlight-end
}
```

#### Output of Speaker View

<img src="https://cdn.videosdk.live/website-resources/docs-resources/flutter_ils_speaker_view.png" width="250"/>

### Step 5 : Implementing the Viewer View

Let's create `StatefulWidget` named `ILSViewerView` in the `ils_viewer_view.dart` file.

ILSViewerView will listen to the `hlsStateChanged` event and if the HLS is started, it will show the livestream using the `flutter_vlc_player` library.

:::note
`downstreamUrl` is now depecated. Use `playbackHlsUrl` or `livestreamUrl` in place of `downstreamUrl`
:::

```js title="ils_viewer_view.dart"
import 'package:flutter/material.dart';
import 'package:videosdk/videosdk.dart';
import './livestream_player.dart';

class ILSViewerView extends StatefulWidget {
  final Room room;
  const ILSViewerView({super.key, required this.room});

  @override
  State<ILSViewerView> createState() => _ILSViewerViewState();
}

class _ILSViewerViewState extends State<ILSViewerView> {
  String hlsState = "HLS_STOPPED";
  String? playbackHlsUrl;

  @override
  void initState() {
    super.initState();
    //highlight-start
    //initialize the room's hls state and hls's playbackHlsUrl
    hlsState = widget.room.hlsState;
    playbackHlsUrl = widget.room.hlsUrls['playbackHlsUrl'];
    //add the hlsStateChanged event listener
    setMeetingEventListener();
    //highlight-end
  }

  @override
  Widget build(BuildContext context) {
    return SingleChildScrollView(
      child: Column(
        mainAxisAlignment: MainAxisAlignment.center,
        children: [
          Padding(
            padding: const EdgeInsets.all(8.0),
            child: Row(
              children: [
                Expanded(
                    child: Text(widget.room.id,
                        style: const TextStyle(color: Colors.white))),
                ElevatedButton(
                  onPressed: () =>
                      {Clipboard.setData(ClipboardData(text: widget.room.id))},
                  child: const Text("Copy Meeting Id"),
                ),
                const SizedBox(width: 10),
                ElevatedButton(
                  onPressed: () => {widget.room.leave()},
                  style: ElevatedButton.styleFrom(
                    backgroundColor: Colors.red,
                  ),
                  child: const Text("Leave"),
                )
              ],
            ),
          ),
          //highlight-start
          //Show the livestream player if the playbackHlsUrl is present
          playbackHlsUrl != null
              ? LivestreamPlayer(playbackHlsUrl: playbackHlsUrl!)
              : const Text("Host has not started the HLS",
                  style: TextStyle(color: Colors.white)),
          //highlight-end
        ],
      ),
    );
  }

  void setMeetingEventListener() {
    //highlight-start
    // listening to hlsStateChanged events and updating the hlsState and downstremUrl
    widget.room.on(
      Events.hlsStateChanged,
      (Map<String, dynamic> data) {
        String status = data['status'];
        if (mounted) {
          setState(() {
            hlsState = status;
            if (status == "HLS_PLAYABLE" || status == "HLS_STOPPED") {
              playbackHlsUrl = data['playbackHlsUrl'];
            }
          });
        }
      },
    );
    //highlight-end
  }
}
```

- Let us use the `flutter_vlc_player` library to play the HLS stream on the Viewer side. For these we will create a `StatefulWidget` named `LivestreamPlayer` in the `livestream_player.dart` file.

```js title="livestream_player.dart"
import 'package:flutter/material.dart';
import 'package:flutter_vlc_player/flutter_vlc_player.dart';

class LivestreamPlayer extends StatefulWidget {
  final String playbackHlsUrl;
  const LivestreamPlayer({
    Key? key,
    required this.playbackHlsUrl,
  }) : super(key: key);

  @override
  LivestreamPlayerState createState() => LivestreamPlayerState();
}

class LivestreamPlayerState extends State<LivestreamPlayer>
    with AutomaticKeepAliveClientMixin {
  late VlcPlayerController _controller;

  @override
  bool get wantKeepAlive => true;

  @override
  void initState() {
    super.initState();
    //highlight-start
    //initializing the player
    _controller = VlcPlayerController.network(widget.playbackHlsUrl,
        options: VlcPlayerOptions());
        //highlight-end
  }

  @override
  void dispose() async {
    _controller.dispose();
    super.dispose();
  }

  @override
  Widget build(BuildContext context) {
    super.build(context);
    //highlight-start
    //rendering the VlcPlayer
    return VlcPlayer(
      controller: _controller,
      aspectRatio: 9 / 16,
      placeholder: const Center(child: CircularProgressIndicator()),
    );
    //highlight-end
  }
}
```

#### Output of Viewer View

<img src="https://cdn.videosdk.live/website-resources/docs-resources/flutter_ils_viewer_view.png" width="250"/>

## Run and Test

The app is all set to test. Make sure to update the `token` in `api_call.dart`

Your app should look like this after the implementation.

#### Speaker View Output

<div style={{textAlign: 'center'}}>

<ReactPlayer controls autoplay loop playing muted url='https://cdn.videosdk.live/website-resources/docs-resources/flutter_ils_speaker_video.mp4' height="560px" width={"100%"}/>

</div>

#### Viewer View Output

<div style={{textAlign: 'center'}}>

<ReactPlayer controls autoplay loop playing muted url='https://cdn.videosdk.live/website-resources/docs-resources/flutter_ils_viewer_video.mp4' height="560px" width={"100%"}/>

</div>

<br/>

:::caution
If you get `webrtc/webrtc.h file not found` error at a runtime in ios then check solution [here](https://docs.videosdk.live/flutter/guide/video-and-audio-calling-api-sdk/known-issues#issue--1).
:::

:::tip
You can checkout the complete [quick start example here](https://github.com/videosdk-live/quickstart/tree/main/flutter-hls).
:::


---

---
title: Quick Start with Flutter
hide_title: true
hide_table_of_contents: false
description: Video SDK enables the opportunity to integrate native IOS, Android & Web SDKs to add live video & audio conferencing to your applications.
sidebar_label: Start a Audio / Video Call
pagination_label: Quick Start with Flutter
keywords:
  - audio calling
  - video calling
  - real-time communication
  - collaboration
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: quick-start
---

# Quick Start for Conference in Flutter

<ReactPlayer controls url="https://www.youtube.com/watch?v=4h57eVcaC34" height="500px" width={"100%"} />

VideoSDK enables you to embed the video calling feature into your Flutter application in minutes.

In this quickstart, we are going to explore group calling feature of Video SDK. We will go through step by step guide of integrating video calling with Flutter Video SDK.

This guide will get you running with the VideoSDK video & audio calling in minutes.

## Prerequisites

Before proceeding, ensure that your development environment meets the following requirements:

- Video SDK Developer Account (Not having one, follow **[Video SDK Dashboard](https://app.videosdk.live/)**)
- The basic understanding of Flutter.
- **[Flutter Video SDK](https://pub.dev/packages/videosdk)**
- Have Flutter installed on your device.

:::important

One should have a VideoSDK account to generate token.
Visit VideoSDK **[dashboard](https://app.videosdk.live/api-keys)** to generate token

:::

## Getting Started with the Code!

Follow the steps to create the environment necessary to add video calls into your app. Also you can find the code sample for [quickstart here](https://github.com/videosdk-live/quickstart/tree/main/flutter-rtc).

### Create a new Flutter project.

Create a new Flutter App using the below command.

```bash
$ flutter create videosdk_flutter_quickstart
```

### Install Video SDK

Install the VideoSDK using the below-mentioned flutter command. Make sure you are in your flutter app directory before you run this command.

```js
$ flutter pub add videosdk

//run this command to add http library to perform network call to generate roomId
$ flutter pub add http
```

### Video SDK Compatibility

| Android and iOS                       | Web (Beta)                            | Desktop (Beta)                        | Safari                 |
| ------------------------------------- | ------------------------------------- | ------------------------------------- | ---------------------- |
| <center> :white_check_mark: </center> | <center> :white_check_mark: </center> | <center> :white_check_mark: </center> | <center> :x: </center> |

### Structure of the project

Your project structure should look like this.

```js title="Project Structure"
    root
    ├── android
    ├── ios
    ├── lib
         ├── api_call.dart
         ├── join_screen.dart
         ├── main.dart
         ├── meeting_controls.dart
         ├── meeting_screen.dart
         ├── participant_tile.dart
```

We are going to create flutter widgets (JoinScreen, MeetingScreen, MeetingControls, ParticipantTile).

### App Structure

App widget will contain `JoinScreen` and `MeetingScreen` widget. `MeetingScreen` will have `MeetingControls` and `ParticipantTile` widget.

<div style={{textAlign: 'center'}}>

![VideoSDK Flutter Quick Start Architecture](https://cdn.videosdk.live/website-resources/docs-resources/flutter_quick_start_arch.png)

</div>

### Configure Project

#### For Android

- Update the `/android/app/src/main/AndroidManifest.xml` for the permissions we will be using to implement the audio and video features.

```js title="AndroidManifest.xml"
<uses-feature android:name="android.hardware.camera" />
<uses-feature android:name="android.hardware.camera.autofocus" />
<uses-permission android:name="android.permission.CAMERA" />
<uses-permission android:name="android.permission.RECORD_AUDIO" />
<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
<uses-permission android:name="android.permission.CHANGE_NETWORK_STATE" />
<uses-permission android:name="android.permission.MODIFY_AUDIO_SETTINGS" />
<uses-permission android:name="android.permission.INTERNET"/>
<uses-permission android:name="android.permission.FOREGROUND_SERVICE"/>
<uses-permission android:name="android.permission.WAKE_LOCK" />
```

- Also you will need to set your build settings to Java 8 because the official WebRTC jar now uses static methods in `EglBase` interface. Just add this to your app-level `/android/app/build.gradle`.

```js
android {
    //...
    compileOptions {
        sourceCompatibility JavaVersion.VERSION_1_8
        targetCompatibility JavaVersion.VERSION_1_8
    }
}
```

- If necessary, in the same `build.gradle` you will need to increase `minSdkVersion` of `defaultConfig` up to `23` (currently default Flutter generator set it to `16`).

- If necessary, in the same `build.gradle` you will need to increase `compileSdkVersion` and `targetSdkVersion` up to `31` (currently default Flutter generator set it to `30`).

#### For iOS

- Add the following entries which allow your app to access the camera and microphone to your `/ios/Runner/Info.plist` file :

```xml
<key>NSCameraUsageDescription</key>
<string>$(PRODUCT_NAME) Camera Usage!</string>
<key>NSMicrophoneUsageDescription</key>
<string>$(PRODUCT_NAME) Microphone Usage!</string>
```

- Uncomment the following line to define a global platform for your project in `/ios/Podfile` :

```js title="Podfile"
# platform :ios, '12.0'
```

#### For MacOS

- Add the following entries to your `/macos/Runner/Info.plist` file which allow your app to access the camera and microphone.

```xml
<key>NSCameraUsageDescription</key>
<string>$(PRODUCT_NAME) Camera Usage!</string>
<key>NSMicrophoneUsageDescription</key>
<string>$(PRODUCT_NAME) Microphone Usage!</string>
```

- Add the following entries to your `/macos/Runner/DebugProfile.entitlements` file which allow your app to access the camera, microphone and open outgoing network connections.

```xml
<key>com.apple.security.network.client</key>
<true/>
<key>com.apple.security.device.camera</key>
<true/>
<key>com.apple.security.device.microphone</key>
<true/>
```

- Add the following entries to your `/macos/Runner/Release.entitlements` file which allow your app to access the camera, microphone and open outgoing network connections.

```xml
<key>com.apple.security.network.server</key>
<true/>
<key>com.apple.security.network.client</key>
<true/>
<key>com.apple.security.device.camera</key>
<true/>
<key>com.apple.security.device.microphone</key>
<true/>
```

### Step 1: Get started with api_call.dart

Before jumping to anything else, you will write a function to generate a unique meetingId. You will require auth token, you can generate it using either by using [videosdk-rtc-api-server-examples](https://github.com/videosdk-live/videosdk-rtc-api-server-examples) or generate it from the [Video SDK Dashboard](https://app.videosdk.live/api-keys) for development.

```js title="api_call.dart"
import 'dart:convert';
import 'package:http/http.dart' as http;

//Auth token we will use to generate a meeting and connect to it
//highlight-next-line
String token = "<Generated-from-dashboard>";

// API call to create meeting
Future<String> createMeeting() async {
  final http.Response httpResponse = await http.post(
    Uri.parse("https://api.videosdk.live/v2/rooms"),
    headers: {'Authorization': token},
  );

//Destructuring the roomId from the response
//highlight-next-line
  return json.decode(httpResponse.body)['roomId'];
}
```

### Step 2 : Creating the JoinScreen

Let's create `join_screen.dart` file in `lib` directory and create JoinScreen `StatelessWidget`.

The JoinScreen will consist of:

- **Create Meeting Button** - This button will create a new meeting for you.
- **Meeting ID TextField** - This text field will contain the meeting ID, you want to join.
- **Join Meeting Button** - This button will join the meeting, which you have provided.

```js title="join_screen.dart"
import 'package:flutter/material.dart';
import 'api_call.dart';
import 'meeting_screen.dart';

class JoinScreen extends StatelessWidget {
  final _meetingIdController = TextEditingController();

  JoinScreen({super.key});

//highlight-start
  void onCreateButtonPressed(BuildContext context) async {
    // call api to create meeting and then navigate to MeetingScreen with meetingId,token
    await createMeeting().then((meetingId) {
      if (!context.mounted) return;
      Navigator.of(context).push(
        MaterialPageRoute(
          builder: (context) => MeetingScreen(
            meetingId: meetingId,
            token: token,
          ),
        ),
      );
    });
  }
//highlight-end

//highlight-start
  void onJoinButtonPressed(BuildContext context) {
    String meetingId = _meetingIdController.text;
    var re = RegExp("\\w{4}\\-\\w{4}\\-\\w{4}");
    // check meeting id is not null or invaild
    // if meeting id is vaild then navigate to MeetingScreen with meetingId,token
    if (meetingId.isNotEmpty && re.hasMatch(meetingId)) {
      _meetingIdController.clear();
      Navigator.of(context).push(
        MaterialPageRoute(
          builder: (context) => MeetingScreen(
            meetingId: meetingId,
            token: token,
          ),
        ),
      );
    } else {
      ScaffoldMessenger.of(context).showSnackBar(const SnackBar(
        content: Text("Please enter valid meeting id"),
      ));
    }
  }
//highlight-end

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(
        title: const Text('VideoSDK QuickStart'),
      ),
      body: Padding(
        padding: const EdgeInsets.all(12.0),
        child: Column(
          mainAxisAlignment: MainAxisAlignment.center,
          children: [
            ElevatedButton(
              onPressed: () => onCreateButtonPressed(context),
              child: const Text('Create Meeting'),
            ),
            Container(
              margin: const EdgeInsets.fromLTRB(0, 8.0, 0, 8.0),
              child: TextField(
                decoration: const InputDecoration(
                  hintText: 'Meeting Id',
                  border: OutlineInputBorder(),
                ),
                controller: _meetingIdController,
              ),
            ),
            ElevatedButton(
              onPressed: () => onJoinButtonPressed(context),
              child: const Text('Join Meeting'),
            ),
          ],
        ),
      ),
    );
  }
}
```

- Update the home screen of the app in the `main.dart`

```js title="main.dart"
import 'package:flutter/material.dart';
import 'join_screen.dart';

void main() {
  runApp(const MyApp());
}

class MyApp extends StatelessWidget {
  const MyApp({super.key});

  // This widget is the root of your application.
  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      title: 'VideoSDK QuickStart',
      theme: ThemeData(
        primarySwatch: Colors.blue,
      ),
      //highlight-next-line
      home: JoinScreen(),
    );
  }
}
```

#### Output

<img src='https://cdn.videosdk.live/website-resources/docs-resources/flutter_rtc_join_screen.png' width="350"/>

### Step 3 : Creating the MeetingControls

Let's create `meeting_controls.dart` file and create MeetingControls `StatelessWidget`.

The MeetingControls will consist of:

- **Leave Button** - This button will leave the meeting.
- **Toggle Mic Button** - This button will unmute or mute mic.
- **Toggle Camera Button** - This button will enable or disable camera.

MeetingControls will accept 3 functions in constructor

- **onLeaveButtonPressed** - invoked when Leave button pressed
- **onToggleMicButtonPressed** - invoked when Toggle Mic button pressed
- **onToggleCameraButtonPressed** - invoked when Toggle Camera button pressed

```js title="meeting_controls.dart"
import 'package:flutter/material.dart';

class MeetingControls extends StatelessWidget {
  final void Function() onToggleMicButtonPressed;
  final void Function() onToggleCameraButtonPressed;
  final void Function() onLeaveButtonPressed;

  const MeetingControls(
      {super.key,
      required this.onToggleMicButtonPressed,
      required this.onToggleCameraButtonPressed,
      required this.onLeaveButtonPressed});

  @override
  Widget build(BuildContext context) {
    return Row(
      mainAxisAlignment: MainAxisAlignment.spaceEvenly,
      children: [
        ElevatedButton(
            onPressed: onLeaveButtonPressed, child: const Text('Leave')),
        ElevatedButton(
            onPressed: onToggleMicButtonPressed, child: const Text('Toggle Mic')),
        ElevatedButton(
            onPressed: onToggleCameraButtonPressed,
            child: const Text('Toggle WebCam')),
      ],
    );
  }
}
```

### Step 4 : Creating ParticipantTile

Let's create `participant_tile.dart` file and create ParticipantTile `StatefulWidget`.

The ParticipantTile will consist of:

- **RTCVideoView** - This will show participant's video stream.

ParticipantTile will accept `Participant` in constructor

- **participant** - participant of the meeting.

```js title="participant_tile.dart"
import 'package:flutter/material.dart';
import 'package:videosdk/videosdk.dart';

class ParticipantTile extends StatefulWidget {
  final Participant participant;
  const ParticipantTile({super.key, required this.participant});

  @override
  State<ParticipantTile> createState() => _ParticipantTileState();
}

class _ParticipantTileState extends State<ParticipantTile> {
  Stream? videoStream;

  @override
  void initState() {
    // initial video stream for the participant
    widget.participant.streams.forEach((key, Stream stream) {
      setState(() {
        if (stream.kind == 'video') {
          videoStream = stream;
        }
      });
    });
    _initStreamListeners();
    super.initState();
  }
  @override
  void setState(fn) {
    if (mounted) {
      super.setState(fn);
    }
  }

  _initStreamListeners() {
    widget.participant.on(Events.streamEnabled, (Stream stream) {
      if (stream.kind == 'video') {
        setState(() => videoStream = stream);
      }
    });

    widget.participant.on(Events.streamDisabled, (Stream stream) {
      if (stream.kind == 'video') {
        setState(() => videoStream = null);
      }
    });
  }

  @override
  Widget build(BuildContext context) {
    return Padding(
      padding: const EdgeInsets.all(8.0),
      child: videoStream != null
          ? RTCVideoView(
              videoStream?.renderer as RTCVideoRenderer,
              objectFit: RTCVideoViewObjectFit.RTCVideoViewObjectFitCover,
            )
          : Container(
              color: Colors.grey.shade800,
              child: const Center(
                child: Icon(
                  Icons.person,
                  size: 100,
                ),
              ),
            ),
    );
  }
}
```

### Step 5 : Creating the MeetingScreen

Let's create `meeting_screen.dart` file and create MeetingScreen `StatefulWidget`.

MeetingScreen will accept meetingId and token in constructor

- **meetingId** - meetingId, you want to join
- **token** - VideoSdk Auth token

```js title="meeting_screen.dart"
import 'package:flutter/foundation.dart';
import 'package:flutter/material.dart';
import 'package:videosdk/videosdk.dart';
import './participant_tile.dart';

class MeetingScreen extends StatefulWidget {
  final String meetingId;
  final String token;

  const MeetingScreen(
      {super.key, required this.meetingId, required this.token});

  @override
  State<MeetingScreen> createState() => _MeetingScreenState();
}

class _MeetingScreenState extends State<MeetingScreen> {
  late Room _room;
  var micEnabled = true;
  var camEnabled = true;

  Map<String, Participant> participants = {};

  @override
  void initState() {
//highlight-start
    // create room
    _room = VideoSDK.createRoom(
      roomId: widget.meetingId,
      token: widget.token,
      displayName: "John Doe",
      micEnabled: micEnabled,
      camEnabled: camEnabled,
      defaultCameraIndex: kIsWeb
          ? 0
          : 1  // Index of MediaDevices will be used to set default camera
    );
//highlight-end

    setMeetingEventListener();

//highlight-start
    // Join room
    _room.join();
//highlight-end

    super.initState();
  }

  @override
  void setState(fn) {
    if (mounted) {
      super.setState(fn);
    }
  }

//highlight-start
  // listening to meeting events
  void setMeetingEventListener() {
    _room.on(Events.roomJoined, () {
      setState(() {
        participants.putIfAbsent(
            _room.localParticipant.id, () => _room.localParticipant);
      });
    });

    _room.on(
      Events.participantJoined,
      (Participant participant) {
        setState(
          () => participants.putIfAbsent(participant.id, () => participant),
        );
      },
    );

    _room.on(Events.participantLeft, (String participantId) {
      if (participants.containsKey(participantId)) {
        setState(
          () => participants.remove(participantId),
        );
      }
    });

    _room.on(Events.roomLeft, () {
      participants.clear();
      Navigator.popUntil(context, ModalRoute.withName('/'));
    });
  }
//highlight-end

  // onbackButton pressed leave the room
  Future<bool> _onWillPop() async {
    _room.leave();
    return true;
  }

  // This widget is the root of your application.
  @override
  Widget build(BuildContext context) {
    return WillPopScope(
      onWillPop: () => _onWillPop(),
      child: Scaffold(
        appBar: AppBar(
          title: const Text('VideoSDK QuickStart'),
        ),
        body: Padding(
          padding: const EdgeInsets.all(8.0),
          child: Column(
            children: [
              Text(widget.meetingId),
//highlight-start
              //render all participant
              Expanded(
                child: Padding(
                  padding: const EdgeInsets.all(8.0),
                  child: GridView.builder(
                    gridDelegate: const SliverGridDelegateWithFixedCrossAxisCount(
                      crossAxisCount: 2,
                      crossAxisSpacing: 10,
                      mainAxisSpacing: 10,
                      mainAxisExtent: 300,
                    ),
                    itemBuilder: (context, index) {
                      return ParticipantTile(
                        key: Key(participants.values.elementAt(index).id),
                          participant: participants.values.elementAt(index));
                    },
                    itemCount: participants.length,
                  ),
                ),
              ),
//highlight-end
              MeetingControls(
                onToggleMicButtonPressed: () {
//highlight-next-line
                  micEnabled ? _room.muteMic() : _room.unmuteMic();
                  micEnabled = !micEnabled;
                },
                onToggleCameraButtonPressed: () {
//highlight-next-line
                  camEnabled ? _room.disableCam() : _room.enableCam();
                  camEnabled = !camEnabled;
                },
                onLeaveButtonPressed: () {
//highlight-next-line
                  _room.leave();
                },
              ),
            ],
          ),
        ),
      ),
    );
  }
}
```

#### Output

<img src='https://cdn.videosdk.live/website-resources/docs-resources/flutter_meeting_screen.png' width="350"/>

## Run and Test

The app is all set to test. Make sure to update the `token` in `api_call.dart`

Your app should look like this after the implementation.

import ReactPlayer from 'react-player'

<div style={{textAlign: 'center'}}>

<ReactPlayer controls url='https://cdn.videosdk.live/website-resources/docs-resources/flutter_quickstart_video.mp4' height="560px" width={"100%"}/>

</div>

<br/>

:::caution
If you get `webrtc/webrtc.h file not found` error at a runtime in ios then check solution [here](https://docs.videosdk.live/flutter/guide/video-and-audio-calling-api-sdk/known-issues#issue--1).
:::

:::tip
You can checkout the complete [quick start example here](https://github.com/videosdk-live/quickstart/tree/main/flutter-rtc).
:::


---

---
title: Understanding Usage Quota Limits
hide_title: true
hide_table_of_contents: false
description: Explore VideoSDK quota limits and subscription plans. Learn how to optimize usage and choose the right plan for your video development needs.
sidebar_label: Understanding Usage Quota Limits
pagination_label: Understanding Usage Quota Limits
keywords:
  - videosdk plans
  - videosdk quota
  - videosdk limit
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: quotas-and-limit
---

import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>

## Understanding Usage Quota Limits - Flutter

In this documentation, you will find detailed information about the quotas associated with each plan, including usage limits for various features and functionalities. Understanding these quotas will help you optimize your usage, selecting the best pricing plan and make the most of your VideoSDK experience.

## How VideoSDK limits concurrent usage quota

VideoSDK's approach to limiting usage focuses on concurrent usage rather than overall usage. Concurrent usage refers to the number of participants or requests that can be hosted or processed simultaneously. 

For example, if there's a limit of 50 concurrent participants per organization, users can run multiple calls (sessions) simultaneously, with a maximum of 50 participants across all sessions combined.

## How to view my current plan’s quota limits?

To view the current quota limits on your organization, simply navigate to the [VideoSDK Dashboard](https://app.videosdk.live/), go to your Profile section, and click on the Billing tab.

## Free Plan

Since, we’ve designed Free Plan for developers who are just exploring, we’ve kept the limits that would get you started without a hitch.

Organisations on Free Plan have the following limits on concurrent usage:

| Feature | Concurrent Limit |
| --- | --- |
| Participants in Video Calls | 50 concurrent participants |
| Viewers in Live Streams | 100 concurrent viewers |
| Recording Request | 1 concurrent request at a time |
| HLS Encoding Request | 1 concurrent request at a time |
| RTMP-Out Request | 1 concurrent request at a time |

 
### How to increase my limits?

To increase your limits, simply upgrade your plan by providing billing details and credit card information.

## Pay-as-you-Go Plan

We've increased participant limits for this paid plan. This way, it won't significantly impact users heavily involved in production or integration.

Organisations on Pay-as-you-Go have the following limits on concurrent usage:

| Feature | Concurrent Limit |
| --- | --- |
| Participants in Video Calls | 100 concurrent participants |
| Viewers in Live Streams | 500 concurrent viewers |
| Recording Request | 5 concurrent request at a time |
| HLS Encoding Request | 5 concurrent request at a time |
| RTMP-Out Request | 5 concurrent request at a time |

### How to increase my limits?

To increase your limits further more, simply get in touch with us. [Contact us](https://www.videosdk.live/contact) directly or reach out via email at [support@videosdk.live](mailto:support@videosdk.live), and we'll handle the rest gladly.

## Enterprise Plan

For Enterprise users, all limits are tailored to the specific needs. Customised limits ensure optimal performance for your unique requirements.

To get started as an Enterprise user, simply get in touch with us, explain your requirements and use case, and we’ll customise the quota and limits according to your needs.

## Examples to understand concurrent limits

**Example #1**

Let's say you're using video callings (RTC) in your organization on the Free Plan. In this scenario, you can concurrently host up to 50 participants. However, the number of calls (sessions) you initiate is unrestricted.

To simplify, you can run multiple sessions simultaneously, but concurrently, you can only accommodate a maximum of 50 participants across all sessions. If a 51st participant attempts to join, they won't be able to access the session until you upgrade your plan to increase your participant limits.

**Example #2**

Let’s say you're using live streaming in your organization on the Free Plan. In this setup, you can concurrently host up to 100 viewers joining the sessions. While you have the flexibility to host multiple live streaming sessions, the number of viewers joining session concurrently is restricted.

**Example #3**

Lets say you’re using video callings (RTC) in your organization on the Pay-as-you-Go Plan and you're hosting 5 concurrent calls (sessions), all of which are being recorded. Now, when you initiate the 6th call (session) and request recording, VideoSDK will not process your recording request. Instead, it will throw an error because you've reached your recording request limit.

If you have any questions regarding quota limits and pricing plan, post in our [Discord community](https://discord.com/invite/Qfm8j4YAUJ), [contact us](https://www.videosdk.live/contact) directly, or reach out to us on [support@videosdk.live](mailto:support@videosdk.live).

---

---
title: Custom Template - Flutter
sidebar_position: 1
sidebar_label: Customize Recording UI
hide_table_of_contents: false
---

import CustomTemplate from '../../../../mdx/\_custom-template.mdx';

<CustomTemplate title="Custom Template With Recording"/>


---

---
title: Geo Tag Meeting recordings - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: Geo Tag meeting recordings feature quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Geo Tag Recording
pagination_label: Geo Tag Recording
keywords:
  - Start Recording meeting
  - Stop Recording meeting
  - audio calling
  - video calling
  - geo tag
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: geo-tag-recording
---

# Geo Tag Meeting Recordings - Flutter

To ensure compliance for BFSIs doing vKYC, it very important to include the co-ordinates(location) of the customer in the recordings. VideoSDK provides a very customizable solution to implement this feature. You will be using custom templates for this purpose.

We have created a ready to use template for this use case which can be found [here](https://github.com/videosdk-live/videosdk-rtc-react-prebuilt-ui/tree/template/geo-tag-watermark). To integrate this template with your recordings follow the below mentiond instructions.

### Host the template

1. Clone the template repository and switch to the branch `template/geo-tag-watermark`.

```bash
git clone https://github.com/videosdk-live/videosdk-rtc-react-prebuilt-ui.git
cd videosdk-rtc-react-prebuilt-ui
git checkout template/geo-tag-watermark
```

2. Install the dependencies and create a build of the project using below mentioned commands.

```bash
npm install
npm run build
```

3. Host the contents of the build folder on your server and check if the template is up and running.

:::note

If you want to create the complete template from scratch you can [follow this guide.](./custom-template.md)

:::

### Using the template for recording

1. To use the template that we deployed earlier, we will be using the `templateUrl` feature in the `startRecording` API.
   To generate the template URL, you will have to append the `meetingId`, and `token` has to be added in the query parameters. Also if you are using the template provided above you need to added a few extra parameters mentioned below. Here is the code snippet to generate the URL.

```js
async function main() {
  let meetingId = "Your MeetingID";
  let token = "Your Token";
  const templateUrl = `https://${YOUR Template URL}/?meetingId=${meetingId}&token=${token}&name=recorder&isRecorder=true&joinWithoutUserInteraction=true`;

  console.log(templateUrl);
}

main();
```

2. Now that we have the template URL, we will use this URL to start the recording using the below provided API call.

```js
async function main() {
  let meetingId = "Your MeetingID";
  let token = "Your Token";
  const templateUrl = `https://${YOUR Template URL}/?meetingId=${meetingId}&token=${token}&name=recorder&isRecorder=true&joinWithoutUserInteraction=true`;

  console.log(templateUrl);

  //Using the previouly created template URL and starting the recording using the API.
  const options = {
    method: "POST",
    headers: {
      Authorization: "$YOUR_TOKEN",
      "Content-Type": "application/json",
    },
    body: JSON.stringify({
      roomId: "Your MeetingId",
      templateUrl: templateUrl,
    }),
  };
  const url = `https://api.videosdk.live/v2/recordings/start`;
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
}

main();
```

### Updating the Geo Tagging Coordinates

We will be using the PubSub feature of VideoSDK to update the data of latitude and longitude. For the predefined template provided by us we are using `GEO_TAG` as topic name. We will be publishing the `participantName`, `latitude` and `longitude` of the participant for whom we want to show in the recording.

:::note

You will have to fetch the longitude and latitude of the participant before sending it using the pubsub.

:::

Here is the code how you will have to publish the message:

```js
  ElevatedButton(
    onPressed:(){
      _room.pubSub.publish(
        "GEO_TAG",
        "GEO TAG DATA",
        const PubSubPublishOptions(persist: true),
        {
          "latitude": "LATITUDE OF PARTICIPANT",
          "longitude": "LONGITUDE OF PARTICIPANT",
          "participantName": "NAME OF PARTICIPANT",
        })
    },
    child: const Text("Send Message"),
  )
```

After implementing this, you should get the recording in the following format:

![Geo Tagging Recoridng](https://cdn.videosdk.live/website-resources/docs-resources/geo-tag-recording-template.png)

If you wish to change how UI looks on recording, you can change it by updating the layout in the template itself.

### API Reference

The API references for all the methods utilized in this guide are provided below.

- [Start Recording API](/api-reference/realtime-communication/start-recording)
- [Learn more about Custom Templates](./custom-template.md)


---

---
title: Recording Overview - Flutter
hide_title: false
hide_table_of_contents: false
description: Record Meeting features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Overview
pagination_label: Overview
keywords:
  - Overview
  - Start Recording meeting
  - Stop Recording meeting
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: Overview
---

import Overview from '../../../../mdx/\_recording-overview.mdx';

<Overview title="Recording Overview"/>


---

---
title: Generate presigned URL - Flutter
hide_title: false
hide_table_of_contents: false
description: presigned URL features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Generate presigned URL
pagination_label: Generate presigned URL
keywords:
  - Start Recording meeting
  - Stop Recording meeting
  - audio calling
  - video calling
  - real-time communication
  - presigned URL
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: presigned-URL
---

import PreSignedUrl from '../../../../mdx/\_presigned-url.mdx';

<PreSignedUrl title="Generate presigned URL - Flutter"/>


---

---
title: Record Meeting Video & Audio Call - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: Record Meeting features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Start and Stop
pagination_label: Start and Stop
keywords:
  - Start Recording meeting
  - Stop Recording meeting
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: record-meeting
---

# Start and Stop - Flutter

This guide will provide an overview of how to implement start and stop Meeting Recording.

### `startRecording()`

`startRecording()` can be used to start a recording of the meeting which can be accessed from the `Room` object. This method accepts four parameters:

- `1. webhookUrl (optional)`: This would the webhook URL where you would like to listen to event happening for the recording like starting and stopping of recording. It will be triggered when the recording is completed and stored into server. Read more about webhooks [here](https://en.wikipedia.org/wiki/Webhook)

- `2. awsDirPath (optional)`: This parameter accepts the path for the your S3 bucket where you want to store recordings to. To allow us to store recording in your S3 bucket, you will need to fill this form by providing the required values. ([VideoSDK Cloud (AWS S3, Azure Blob or GCP ) Integration](/flutter/guide/video-and-audio-calling-api-sdk/recording/recording-storage-config))

- `3. config (optional)`: This parameter will define how the recording should be recorded.

- `4. transcription (optional)`: This parameter lets you start post transcription for the recording.

  ```js
  Map<String, dynamic> config = {
    // highlight-next-line
    // Layout Configuration
    layout: {
      type: "GRID", // "SPOTLIGHT" | "SIDEBAR",  Default : "GRID"
      priority: "SPEAKER", // "PIN", Default : "SPEAKER"
      gridSize: 4, // MAX : 4
    },

    // highlight-next-line
    // Theme of recording
    theme: "DARK", //  "LIGHT" | "DEFAULT"

    // highlight-next-line
    // `mode` is used to either record video & audio both or only audio.
    mode: "video-and-audio", // "audio", Default : "video-and-audio"

    // highlight-next-line
    // Quality of recording and is only applicable to `video-and-audio` type mode.
    quality: "high", // "low" | "med",  Default : "med"

    //highlight-start
    // This mode refers to orientation of recording.
    // landscape : Record the meeting in horizontally
    // portrait : Record the meeting in vertically (Best for mobile view)
    //highlight-end
    orientation: "landscape", // "portrait",  Default : "landscape"
  };

  // highlight-next-line
  // Post Transcription Configuration
  Map<String, dynamic> transcription = {
    "enabled": true, // Enables post transcription
    "summary": {
      "enabled": true,  // Enables summary generation
       // Guides summary generation
      "prompt":
          "Write summary in sections like Title, Agenda, Speakers, Action Items, Outlines, Notes and Summary",
    }
  };

  room.startRecording(config: config, transcription: transcription);
  ```

### `stopRecording()`

- `stopRecording()` is used to stop the meeting recording which can be accessed from the `Room` object.

#### Example

```js
import 'package:flutter/material.dart';
import 'package:videosdk/videosdk.dart';

class MeetingScreen extends StatefulWidget {
  ...
}

class _MeetingScreenState extends State<MeetingScreen> {
  late Room _room;

  @override
  void initState() {
    //highlight-next-line
    ...
  }

  @override
  Widget build(BuildContext context) {
    return Column(
      children:[
        //highlight-start
        ElevatedButton(
          onPressed:(){
            Map<String, dynamic> config = {
              "layout": {
                "type": "GRID",
                "priority": "SPEAKER",
                "gridSize": 4,
              },
              "theme": "DARK",
              "mode": "video-and-audio",
              "quality": "high",
              "orientation": "portrait",
            };

            Map<String, dynamic> transcription = {
              "enabled": true,
              "summary": {
                "enabled": true,
                "prompt":
                    "Write summary in sections like Title, Agenda, Speakers, Action Items, Outlines, Notes and Summary",
              }
            };
            _room.startRecording(config: config, transcription: transcription);
          },
          child: const Text("Start Recording"),
        ),
        ElevatedButton(
          onPressed:(){
            _room.stopRecording();
          },
          child: const Text("Stop recording"),
        ),
    //highlight-end
      ]
    );
  }
}
```

:::important
To initiate automatic recording at the beginning of a `session`, simply provide the `autoStartConfig` feature `recording` during `room` creation. For more information on configuring the `autoStartConfig`, please refer to the provided documentation **[<u>here</u>](/api-reference/realtime-communication/create-room#autoStartConfig)**.
:::

## API Reference

The API references for all the methods utilized in this guide are provided below.

- [startRecording](/flutter/api/sdk-reference/room-class/methods#startrecording)
- [stopRecording](/flutter/api/sdk-reference/room-class/methods#stoprecording)
- [Events.recordingStateChanged](/flutter/api/sdk-reference/room-class/events#recordingstatechanged)
- [autoStartConfig](/api-reference/realtime-communication/create-room#autoStartConfig)


---

---
title: Participant Recording (Individual) - Flutter
hide_title: false
hide_table_of_contents: false
description: Individual participant recording features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Participant Recording (Individual)
pagination_label: Participant Recording
keywords:
  - Start Participant Recording
  - Stop Participant Recording
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: record-participant
---

import RecordParticipant from '../../../../mdx/\_intro-participant-recording.mdx';
import WebhookParticipantRecording from '../../../../mdx/\_webhook-participant-recording.mdx';

<RecordParticipant title="Record Participant"/>

## Start Individual Participant Recording

To start a participant recording, you will have to call `/v2/recordings/participant/start` API with following body parameters.

- `roomId`: RoomId for which the participant recording is to be started
- `participantId`: participantId of the participant to be recorder.
- `fileFormat`: Currently only `webm` is supported as file format. We will add the support for other formats in future.
- `webhookUrl`: The webhook URL where you would like to get the status updates of the recording. To learn more about webhooks refer [here](#participant-track-recording-starting).
- `bucketDirPath`: If you are using your own storage, you can provide the directory path where you want to store the recording. To configure the storage please [refere this quide](/javascript/guide/video-and-audio-calling-api-sdk/recording/recording-storage-config).

The usual recording path would look like `${sessionId}/${participantId}/${filename}`.

```js
import 'package:http/http.dart' as http;
import 'dart:convert';

Future<void> startParticipantRecording() async {
  final String roomId = "<YOUR ROOM ID>";
  final String participantId = "<PARTICIPANT ID>";
  final String fileFormat = "<YOUR FILE FORMAT>"; // (Optional) default: webm
  final String bucketDirPath = "<YOUR CLOUD STORAGE BUCKET PATH>"; // (Optional) test/abc
  final String webhookUrl = "<YOUR WEBHOOK URL>"; // (Optional)

  final url = Uri.parse("https://api.videosdk.live/v2/recordings/participant/start");
  final headers = {
    "Authorization": "$YOUR_TOKEN",
    "Content-Type": "application/json",
  };
  final body = jsonEncode({
    "roomId": roomId,
    "participantId": participantId,
    "fileFormat": fileFormat,
    "bucketDirPath": bucketDirPath,
    "webhookUrl": webhookUrl,
  });

  final response = await http.post(url, headers: headers, body: body);

  if (response.statusCode == 200) {
    print('Participant Recording started successfully');
  } else {
    print('Failed to start participant recording');
  }
}

```

## Stop Individual Participant Recording

To stop a participant recording, you will have to call `/v2/recordings/participant/stop` API with following body parameters.

- `roomId`: RoomId for which the participant recording is to be stopped
- `participantId`: participantId for which the recording is to be stopped.

```js
import 'dart:convert';
import 'package:http/http.dart' as http;

Future<void> stopParticipantRecording(String roomId, String participantId) async {
  final url = Uri.parse('https://api.videosdk.live/v2/recordings/participant/stop');
  final headers = {
    'Authorization': '$YOUR_TOKEN',
    'Content-Type': 'application/json',
  };
  final body = json.encode({
    'roomId': roomId,
    'participantId': participantId,
  });

  final response = await http.post(url, headers: headers, body: body);

  if (response.statusCode == 200) {
    print('Participant Recording stopped successfully');
  } else {
    print('Failed to stop participant recording');
  }
}

```

<WebhookParticipantRecording title="Webhooks"/>


---

---
title: Participant Track Recording - Flutter
hide_title: false
hide_table_of_contents: false
description: Participant track recording features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Participant Track Recording
pagination_label: Participant Track Recording
keywords:
  - Start Track Recording
  - Start Track Recording
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: record-track
---

import RecordTrack from '../../../../mdx/\_intro-track-recording.mdx';
import WebhookTrackRecording from '../../../../mdx/\_webhook-track-recording.mdx';

<RecordTrack title="Record Track"/>

## Start Participant Track Recording

To start a participant track recording, you will have to call `/v2/recordings/participant/track/start` API with following body parameters.

- `roomId`: RoomId for which the participant track recording is to be started
- `participantId`: participantId of the participant to be recorder.
- `kind`: The kind of tracks you want to record.
  - You can pass following values: _`audio`_ | _`video`_ | _`screen_audio`_ | _`screen_video`_
- `fileFormat`: Currently only `webm` is supported as file format. We will add the support for other formats in future.
- `webhookUrl`: The webhook URL where you would like to get the status updates of the recording. To learn more about webhooks refer [here](#participant-track-recording-starting).
- `bucketDirPath`: If you are using your own storage, you can provide the directory path where you want to store the recording. To configure the storage please [refere this quide](/javascript/guide/video-and-audio-calling-api-sdk/recording/recording-storage-config).

The usual recording path would look like `${sessionId}/${participantId}/${kind}/${filename}`.

```dart
import 'package:http/http.dart' as http;
import 'dart:convert';

Future<void> startTrackRecording() async {
  final String roomId = "<YOUR ROOM ID>";
  final String participantId = "<PARTICIPANT ID>";
  final String kind = "<YOUR STREAM KIND>";
  final String fileFormat = "<YOUR FILE FORMAT>";
  final String bucketDirPath = "<YOUR CLOUD STORAGE BUCKET PATH>";
  final String webhookUrl = "<YOUR WEBHOOK URL>";

  final Map<String, dynamic> body = {
    "roomId": roomId,
    "participantId": participantId,
    "kind": kind,
    "fileFormat": fileFormat,
    "bucketDirPath": bucketDirPath,
    "webhookUrl": webhookUrl,
  };

  final response = await http.post(
    Uri.parse('https://api.videosdk.live/v2/recordings/participant/track/start'),
    headers: {
      "Authorization": "$YOUR_TOKEN",
      "Content-Type": "application/json",
    },
    body: jsonEncode(body),
  );

  if (response.statusCode == 200) {
    print(jsonDecode(response.body));
  } else {
    print('Failed to start track recording');
  }
}

```

## Stop Participant Track Recording

To stop a participant track recording, you will have to call `/v2/recordings/participant/track/stop` API with following body parameters.

- `roomId`: RoomId for which the participant track recording is to be stopped
- `participantId`: participantId for which the recording is to be stopped.
- `kind`: The kind of track recording you want to stop for the given participant.
  - You can pass following values: _`audio`_ | _`video`_ | _`screen_audio`_ | _`screen_video`_

```dart
import 'package:http/http.dart' as http;
import 'dart:convert';

Future<void> stopTrackRecording() async {
  final String roomId = "<YOUR ROOM ID>";
  final String participantId = "<PARTICIPANT ID>";
  final String kind = "<YOUR STREAM KIND>";

  final Map<String, dynamic> body = {
    "roomId": roomId,
    "participantId": participantId,
    "kind": kind,
  };

  final response = await http.post(
    Uri.parse('https://api.videosdk.live/v2/recordings/participant/track/stop'),
    headers: {
      "Authorization": "$YOUR_TOKEN",
      "Content-Type": "application/json",
    },
    body: jsonEncode(body),
  );

  if (response.statusCode == 200) {
    print(jsonDecode(response.body));
  } else {
    print('Failed to stop track recording');
  }
}

```

<WebhookTrackRecording title="Webhooks" />


---

---
title: Configure Recording Storage - Flutter
hide_title: false
hide_table_of_contents: false
sidebar_label: Configure Recording Storage
sidebar_position: 1
pagination_label: Configure Recording Storage
keywords:
  - configure recording storage
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
slug: recording-storage-config
---

### Storage Configuration

While recording your meetings, you have the flexibility to store them either on VideoSDK's storage or configure your own storage solution such as **`AWS S3 Storage, Azure Blob or GCP Cloud Storage`**. To set up your own storage, you can navigate to the [API section](https://app.videosdk.live/api-keys) in the VideoSDK Dashboard.

- This feature allows you to configure storage provider for your meeting recordings.

- You can configure multiple storage provider with multiple API Keys.

- Currently, we support `AWS S3`, `Azure Blob` and `GCP Cloud Storage`. We will add support for other storage provider soon !!

## Prerequisites

- An active [VideoSDK Developer Account](https://app.videosdk.live)
- `Aws S3`, `Azure Blob Storage` or `GCP Cloud Storage` Credentials

## How to setup ?

### Step 1 : Select Api Key

![Dashboard](/img/tutorial/dashboard/api-key-dashboard.png)

- Go to [VideoSDK Dashboard](https://app.videosdk.live/api-keys).
- Select API Key for which, you want to set storage configuration.
- Then click on `Storage Config` Icon in Actions.

### Step 2 : Choose Cloud Storage Provider

![Dashboard](/img/tutorial/dashboard/storage-config.png)

- As you can see in the image, there are 3 Cloud Storage Provider (`Aws`, `Azure`, `GCP`).
- You can select a Cloud Storage Provider as per your requirements.

### Step 3 : Configure Bucket or Container

<h4> For Aws S3 Storage </h4>

![Aws S3](/img/tutorial/dashboard/s3.png)

- You will need AWS S3 Bucket. [Learn to create S3 Bucket](https://docs.aws.amazon.com/AmazonS3/latest/userguide/creating-bucket.html).

- As you can see in the image, you will need enter `accessKeyId`, `secretAccessKey`, `region`, `bucket`, and `ACL` to setup for Aws S3 Storage.

- Click on `Save` button.

<hr />

<h4> For Azure Blob Storage: </h4>

![Azure Blob](/img/tutorial/dashboard/blob.png)

- You will need Azure Blob Container. [Learn to create Blob Container](https://docs.microsoft.com/en-us/azure/storage/blobs/storage-quickstart-blobs-portal#create-a-container).

- As you can see in the image, you will need to enter `connectionString` and `containerName` to setup for Azure Blob.

- Click on `Save` button.

<hr />

<h4> For Google Cloud Storage: </h4>

<img src="/img/tutorial/dashboard/gcp.png" alt="GCP Cloud Storage" width="436" height="632"/>

1. You will need Google Cloud Storage Bucket. [Learn to create Google Cloud Storage Bucket](https://cloud.google.com/storage/docs/creating-buckets).

2. After creation, click on the <b> &#xFE19; </b>button in the upper right corner and select **`Project settings`**.

3. Under **`IAM and Admin`**, select **`Service Accounts`**. In the service account list, click on the <b> &#xFE19; </b> button for the account just added or created before, and select **`Manage keys`**.

4. Click **`ADD KEY > Create new key`**. Select **`JSON`** in the pop-up box and click **`CREATE`**. A json file is downloaded with the name format `projectId-xxxxxxxx.json`.

5. Open the downloaded json file, which looks like the following example:

```
{
  "type": "service_account",
  "project_id": "videosdk-12345",
  "private_key_id": "yourprivateidkeyyourprivateidkeyyourprivateidkey",
  "private_key": "-----BEGIN PRIVATE KEY-----\nThisisYourPrivateKeyThisisYourPrivateKeyThisisYourPrivateKey\nThisisYourPrivateKey\nThisisYourPrivateKey\nThisisYourPrivateKey\n-----END PRIVATE KEY-----\n",
  "client_email": "xxxx-xxxx@videosdk-12345.iam.gserviceaccount.com",
  "client_id": "123456789012345678901",
  "auth_uri": "https://accounts.google.com/o/oauth2/auth",
  "token_uri": "https://oauth2.googleapis.com/token",
  "auth_provider_x509_cert_url": "https://www.googleapis.com/oauth2/v1/certs",
  "client_x509_cert_url": "https://www.googleapis.com/robot/v1/metadata/x509/videosdk%40videosdk-404307.iam.gserviceaccount.com",
  "universe_domain": "googleapis.com"
}
```

- As you can see in the image, you will need to enter `Project Id`, `Client Email`, `Bucket`, `Private Key` to setup for Google Cloud Storage Bucket. You can retrieve these details from the json file.

- Click on `Save` button.

### Step 4 : Test

- It's time to test !!
- [Create Room](https://docs.videosdk.live/api-reference/realtime-communication/create-room) with token generated with the API Key, you have configured for.
- Start meeting with the roomId created and Start Recording !!
- Then, you can see that recording will be available in your Bucket or Container.

:::note

- Only a single Recording Storage Config can be possible for a particular Api Key at a time.
- In order to add new Recording Configuration, first you need to delete current configuration.

:::


---

---
title: Record Meeting Video & Audio Call - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: Record Meeting features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Webhook and Events
pagination_label: Webhook and Events
keywords:
  - Start Recording meeting
  - Stop Recording meeting
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: webhook-and-events
---

# Webhooks and Events - Flutter

### Event associated with Recording

- **recordingStateChanged** - Whenever meeting recording state changes, then `recordingStateChanged` event will trigger.

```js
import 'package:flutter/material.dart';
import 'package:videosdk/videosdk.dart';

class MeetingScreen extends StatefulWidget {
  ...
}

class _MeetingScreenState extends State<MeetingScreen> {
  late Room room;

  @override
  void initState() {
    //highlight-next-line
    ...

    setupRoomEventListener();
  }

  @override
  Widget build(BuildContext context) {
    return YourMeetingWidget();
  }

  //highlight-start
  void setupRoomEventListener() {
    room.on(Events.recordingStateChanged, (String status) {
      //Status can be :: RECORDING_STARTING
      //Status can be :: RECORDING_STARTED
      //Status can be :: RECORDING_STOPPING
      //Status can be :: RECORDING_STOPPED
      log("Meeting Recording status : $status");
    });
  }
  //highlight-end
}
```

## Webhook associated with Recording

### recording-starting

- A "Recording Starting" webhook is triggered when the recording process for a meeting is initiated.

###### Example

```javascript
{
    "webhookType": "recording-starting",
    "data": {
        "meetingId": "jvsg-8rjn-j304",
        "sessionId": "613731342f27f56e4fc4b6d0",
    },
}
```

---

### recording-started

- Recording started webhook will be received when successfully recording is started in meeting

###### Example

```javascript
{
    "webhookType": "recording-started",
    "data": {
        "meetingId": "jvsg-8rjn-j304",
        "sessionId": "613731342f27f56e4fc4b6d0",
    },
}
```

---

### recording-stopping

- A "Recording Stopping" webhook is triggered when the recording end process for a meeting is initiated.

###### Example

```javascript
{
    "webhookType": "recording-stopping",
    "data": {
        "meetingId": "jvsg-8rjn-j304",
        "sessionId": "613731342f27f56e4fc4b6d0",
    },
}
```

---

### recording-stopped

- Recording stopped webhook will be received when recording is successfully stopped in meeting.

###### Example

```javascript
{
    "webhookType": "recording-stopped",
    "data": {
        "meetingId": "jvsg-8rjn-j304",
        "sessionId": "613731342f27f56e4fc4b6d0",
        "filePath" : "/encoded/videos/62d148951a1eb20029fc9b05.mp4",
        "fileUrl" : "https://cdn.videosdk.live/encoded/videos/62d148951a1eb20029fc9b05.mp4",

    },
}
```

---

### recording-failed

- A "Recording Failed" webhook is generated when the recording process encounters an interruption or issue during either the starting or stopping phases.

###### Example

```javascript
{
    "webhookType": "recording-failed",
    "data": {
        "meetingId": "jvsg-8rjn-j304",
        "sessionId": "613731342f27f56e4fc4b6d0",
    },
}
```


---

---
title: Interactive Livestream - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: Interactive Livestream features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Interactive Livestream (HLS)
pagination_label: Interactive Livestream (HLS)
keywords:
  - Start HLS meeting
  - Stop HLS meeting
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: interactive-livestream
---

# Interactive Livestream (HLS) - Flutter

Interactive live streaming (HLS) refers to a type of live streaming where viewers can actively engage with the content being streamed and with other viewers in real-time.

In an interactive live stream (HLS), viewers can take part in a variety of activities like live polling, Q&A sessions, and even sending virtual gifts to the content creator or each other.

<center>

![Screen Share with Audio](https://cdn.videosdk.live/website-resources/docs-resources/mobile_hls.png)

</center>

VideoSDK also allows you to configure the interactive livestream layouts in numerous ways like by simply setting different prebuilt layouts in the configuration or by providing your own custom template to do the livestream according to your layout choice.

This guide will provide an overview of how to implement start and stop Livestreaming.

### `startHls()`

`startHls()` can be used to start a interactive livestream of the meeting which can be accessed from the `Room` object. This method accepts two parameters:

- `1. config (optional)`: This parameter will define how the livestream layout should look like.

- `2. transcription (optional)`: This parameter lets you start post transcription for the Livestreaming.

  ```js
  Map<String, dynamic> config = {
    // highlight-next-line
    // Layout Configuration
    "layout": {
      "type": "GRID", // "SPOTLIGHT" | "SIDEBAR",  Default : "GRID"
      "priority": "SPEAKER", // "PIN", Default : "SPEAKER"
      "gridSize": 4, // MAX : 4
    },

    // highlight-next-line
    // Theme of recording
    "theme": "DARK", //  "LIGHT" | "DEFAULT"

    // highlight-next-line
    // `mode` is used to either record video & audio both or only audio.
    "mode": "video-and-audio", // "audio", Default : "video-and-audio"

    // highlight-next-line
    // Quality of recording and is only applicable to `video-and-audio` type mode.
    "quality": "high", // "low" | "med",  Default : "med"

    //highlight-start
    // This mode refers to orientation of recording.
    // landscape : Record the meeting in horizontally
    // portrait : Record the meeting in vertically (Best for mobile view)
    //highlight-end
    "orientation": "landscape", // "portrait",  Default : "landscape"
  };

  // highlight-next-line
  // Post Transcription Configuration
  Map<String, dynamic> transcription = {
    "enabled": true, // Enables post transcription
    "summary": {
      "enabled": true,  // Enables summary generation
       // Guides summary generation
      "prompt":
          "Write summary in sections like Title, Agenda, Speakers, Action Items, Outlines, Notes and Summary",
    }
  };

  room.startHls(config: config, transcription: transcription);
  ```

### `stopHls()`

- `stopHls()` is used to stop the meeting livestream which can be accessed from the `Room` object.

#### Example

```js
import 'package:flutter/material.dart';
import 'package:videosdk/videosdk.dart';

class MeetingScreen extends StatefulWidget {
  ...
}

class _MeetingScreenState extends State<MeetingScreen> {
  late Room _room;

  @override
  void initState() {
    //highlight-next-line
    ...
  }

  @override
  Widget build(BuildContext context) {
    return Column(
      children:[
        //highlight-start
        ElevatedButton(
          onPressed:(){
            Map<String, dynamic> config = {
              "layout": {
                "type": "GRID",
                "priority": "SPEAKER",
                "gridSize": 4,
              },
              "theme": "DARK",
              "mode": "video-and-audio",
              "quality": "high",
              "orientation": "portrait",
            };

            Map<String, dynamic> transcription = {
              "enabled": true,
              "summary": {
                "enabled": true,
                "prompt":
                    "Write summary in sections like Title, Agenda, Speakers, Action Items, Outlines, Notes and Summary",
              }
            };
            _room.startHls(config: config, transcription: transcription);
          },
          child: const Text("Start HLS"),
        ),
        ElevatedButton(
          onPressed:(){
            _room.stopHls();
          },
          child: const Text("Stop HLS"),
        ),
    //highlight-end
      ]
    );
  }
}
```

:::tip
If you want to learn more about the Interactive Livestream and how you can implement it in your own platform, you can checkout this [guide](/flutter/guide/interactive-live-streaming/integrate-hls/overview).
:::

### Event associated with HLS

- **hlsStateChanged** - Whenever meeting HLS state changes, then `hlsStateChanged` event will trigger.

- You can get the `playbackHlsUrl` and `livestreamUrl` of the HLS to play it on the Viewer side when the state changes to `HLS_PLAYABLE`
  - `playbackHlsUrl` - Live HLS with playback support
  - `livestreamUrl` - Live HLS without playback support

:::note
`downstreamUrl` is now depecated. Use `playbackHlsUrl` or `livestreamUrl` in place of `downstreamUrl`
:::

```js
import 'package:flutter/material.dart';
import 'package:videosdk/videosdk.dart';

class MeetingScreen extends StatefulWidget {
  ...
}

class _MeetingScreenState extends State<MeetingScreen> {
  late Room room;

  @override
  void initState() {
    //highlight-next-line
    ...

    setupRoomEventListener();
  }

  @override
  Widget build(BuildContext context) {
    return YourMeetingWidget();
  }

  //highlight-start
  void setupRoomEventListener() {
    room.on(Events.hlsStateChanged, (Map<String, dynamic> data) {
      //Status can be :: HLS_STARTING
      //Status can be :: HLS_STARTED
      //Status can be :: HLS_PLAYABLE
      //Status can be :: HLS_STOPPING
      //Status can be :: HLS_STOPPED
      log("Meeting HLS status : ${data['status']}");
      if (data['status'] == "HLS_PLAYABLE")
        log("PLAYBACKHLS URL -- " + data['playbackHlsUrl']);
    });
  }
  //highlight-end
}
```

### Custom Template

With VideoSDK, you can also use your own custom designed layout template to livestream the meetings. In order to use the custom template, you need to create a template for which you can [follow this guide](/react/guide/interactive-live-streaming/custom-template). Once you have setup the template, you can use the [REST API to start](/api-reference/realtime-communication/start-livestream) the livestream with the `templateURL` parameter.

## API Reference

The API references for all the methods utilized in this guide are provided below.

- [startHls](/flutter/api/sdk-reference/room-class/methods#starthls)
- [stopHls](/flutter/api/sdk-reference/room-class/methods#stophls)
- [Events.hlsStateChanged](/flutter/api/sdk-reference/room-class/events#hlsstatechanged)


---

---
title: Record Meeting Video & Audio Call - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: Record Meeting features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Record Meeting
pagination_label: Record Meeting
keywords:
  - Start Recording meeting
  - Stop Recording meeting
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: record-meeting
---

# Record Meeting - Flutter

VideoSDK allows you to record video & audio during the meeting. The recording files are available in developer dashboard or you can also choose to store them in your own cloud storage.

VideoSDK also allows you to configure the recording layouts in numerous ways like by simply setting different prebuilt layouts in the configuration or by providing your own custom template to do the recording according to your layout choice.

This guide will provide an overview of how to implement start and stop Meeting Recording.

:::important

To initiate automatic recording at the beginning of a `session`, simply provide the `autoStartConfig` feature `recording` during `room` creation. For more information on configuring the `autoStartConfig`, please refer to the provided documentation **[<u>here</u>](/api-reference/realtime-communication/create-room#autoStartConfig)**.

:::

### `startRecording()`

`startRecording()` can be used to start a recording of the meeting which can be accessed from the `Room` object. This method accepts four parameters:

- `1. webhookUrl (optional)`: This would the webhook URL where you would like to listen to event happening for the recording like starting and stopping of recording. It will be triggered when the recording is completed and stored into server. Read more about webhooks [here](https://en.wikipedia.org/wiki/Webhook)

- `2. awsDirPath (optional)`: This parameter accepts the path for the your S3 bucket where you want to store recordings to. To allow us to store recording in your S3 bucket, you will need to fill this form by providing the required values. ([VideoSDK Cloud (AWS S3, Azure Blob or GCP ) Integration](/flutter/guide/video-and-audio-calling-api-sdk/recording/recording-storage-config))

- `3. config (optional)`: This parameter will define how the recording should be recorded.

- `4. transcription (optional)`: This parameter lets you start post transcription for the recording.

  ```js
  Map<String, dynamic> config = {
    // highlight-next-line
    // Layout Configuration
    layout: {
      type: "GRID", // "SPOTLIGHT" | "SIDEBAR",  Default : "GRID"
      priority: "SPEAKER", // "PIN", Default : "SPEAKER"
      gridSize: 4, // MAX : 4
    },

    // highlight-next-line
    // Theme of recording
    theme: "DARK", //  "LIGHT" | "DEFAULT"

    // highlight-next-line
    // `mode` is used to either record video & audio both or only audio.
    mode: "video-and-audio", // "audio", Default : "video-and-audio"

    // highlight-next-line
    // Quality of recording and is only applicable to `video-and-audio` type mode.
    quality: "high", // "low" | "med",  Default : "med"

    //highlight-start
    // This mode refers to orientation of recording.
    // landscape : Record the meeting in horizontally
    // portrait : Record the meeting in vertically (Best for mobile view)
    //highlight-end
    orientation: "landscape", // "portrait",  Default : "landscape"
  };

  // highlight-next-line
  // Post Transcription Configuration
  Map<String, dynamic> transcription = {
    "enabled": true, // Enables post transcription
    "summary": {
      "enabled": true,  // Enables summary generation
       // Guides summary generation
      "prompt":
          "Write summary in sections like Title, Agenda, Speakers, Action Items, Outlines, Notes and Summary",
    }
  };

  room.startRecording(config: config, transcription: transcription);
  ```

### `stopRecording()`

- `stopRecording()` is used to stop the meeting recording which can be accessed from the `Room` object.

#### Example

```js
import 'package:flutter/material.dart';
import 'package:videosdk/videosdk.dart';

class MeetingScreen extends StatefulWidget {
  ...
}

class _MeetingScreenState extends State<MeetingScreen> {
  late Room _room;

  @override
  void initState() {
    //highlight-next-line
    ...
  }

  @override
  Widget build(BuildContext context) {
    return Column(
      children:[
        //highlight-start
        ElevatedButton(
          onPressed:(){
            Map<String, dynamic> config = {
              "layout": {
                "type": "GRID",
                "priority": "SPEAKER",
                "gridSize": 4,
              },
              "theme": "DARK",
              "mode": "video-and-audio",
              "quality": "high",
              "orientation": "portrait",
            };

            Map<String, dynamic> transcription = {
              "enabled": true,
              "summary": {
                "enabled": true,
                "prompt":
                    "Write summary in sections like Title, Agenda, Speakers, Action Items, Outlines, Notes and Summary",
              }
            };
            _room.startRecording(config: config, transcription: transcription);
          },
          child: const Text("Start Recording"),
        ),
        ElevatedButton(
          onPressed:(){
            _room.stopRecording();
          },
          child: const Text("Stop recording"),
        ),
    //highlight-end
      ]
    );
  }
}
```

### Event associated with Recording

- **recordingStateChanged** - Whenever meeting recording state changes, then `recordingStateChanged` event will trigger.

```js
import 'package:flutter/material.dart';
import 'package:videosdk/videosdk.dart';

class MeetingScreen extends StatefulWidget {
  ...
}

class _MeetingScreenState extends State<MeetingScreen> {
  late Room room;

  @override
  void initState() {
    //highlight-next-line
    ...

    setupRoomEventListener();
  }

  @override
  Widget build(BuildContext context) {
    return YourMeetingWidget();
  }

  //highlight-start
  void setupRoomEventListener() {
    room.on(Events.recordingStateChanged, (String status) {
      //Status can be :: RECORDING_STARTING
      //Status can be :: RECORDING_STARTED
      //Status can be :: RECORDING_STOPPING
      //Status can be :: RECORDING_STOPPED
      log("Meeting Recording status : $status");
    });
  }
  //highlight-end
}
```

### Storage Configuration

While recording your meetings, you can choose to store them on the VideoSDK's storage or you can also configure your own **`AWS S3 Storage, Azure Blob or GCP Cloud Storage`** to store the meeting recordings directly on your storage.

You can configure your own **`AWS S3 Storage, Azure Blob or GCP Cloud Storage`** from the [VideoSDK Dashboard's API section](https://app.videosdk.live/api-keys).

You can also go through this [guide to setup](/docs/tutorials/user-dashboard/recording-storage-config) the storage or watch this [video to configure](https://www.loom.com/share/23a2617f824a4a5da004d14d1a541a9d) your storage.

### Custom Template

With VideoSDK, you can also use your own custom designed layout template to record the meetings. In order to use the custom template, you need to create a template for which you can [follow this guide](/react/guide/interactive-live-streaming/custom-template). Once you have setup the template, you can use the [REST API to start](/api-reference/realtime-communication/start-recording) the recording with the `templateURL` parameter.

## API Reference

The API references for all the methods utilized in this guide are provided below.

- [startRecording](/flutter/api/sdk-reference/room-class/methods#startrecording)
- [stopRecording](/flutter/api/sdk-reference/room-class/methods#stoprecording)
- [Events.recordingStateChanged](/flutter/api/sdk-reference/room-class/events#recordingstatechanged)
- [autoStartConfig](/api-reference/realtime-communication/create-room#autoStartConfig)


---

---
title: RTMP Livestream - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: RTMP Livestream features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: RTMP Livestream
pagination_label: RTMP Livestream
keywords:
  - Start Livestream meeting
  - Stop Livestream meeting
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: rtmp-livestream
---

# RTMP Livestream - Flutter

RTMP is a popular protocol for live streaming video content from a VideoSDK to platforms such as YouTube, Twitch, Facebook, and others.

By providing the platform-specific stream key and stream URL, the VideoSDK can connect to the platform's RTMP server and transmit the live video stream.

VideoSDK allows you to livestream your meeting to platform which support RTMP ingestion just by providing the platform-specific stream key and stream URL, we can connect to the platform's RTMP server and transmit the live video stream.

VideoSDK also allows you to configure the livestream layouts in numerous ways like by simply setting different prebuilt layouts in the configuration or by providing your own custom template to do the livestream according to your layout choice.

This guide will provide an overview of how to implement start and stop RTMP Livestreaming.

### `startLivestream()`

`startLivestream()` can be used to start a RTMP livestream of the meeting which can be accessed from the `Room` object. This method accepts two parameters:

- `1. outputs`: This parameter accepts an array of objects which contains the RTMP `url` and `streamKey` of the platforms you want to start the livestream.

- `2. config (optional)`: This parameter will define how the livestream layout should look like.

  ```js
  var outputs = [
    {
      url: "rtmp://a.rtmp.youtube.com/live2",
      streamKey: "<STREAM_KEY>",
    },
    {
      url: "rtmps://",
      streamKey: "<STREAM_KEY>",
    },
  ];
  Map<String, dynamic> config = {
    // highlight-next-line
    // Layout Configuration
    layout: {
      type: "GRID", // "SPOTLIGHT" | "SIDEBAR",  Default : "GRID"
      priority: "SPEAKER", // "PIN", Default : "SPEAKER"
      gridSize: 4, // MAX : 4
    },

    // highlight-next-line
    // Theme of livestream
    theme: "DARK", //  "LIGHT" | "DEFAULT"
  };

  room.startLivestream(outputs,config:config);
  ```

### `stopLivestream()`

- `stopLivestream()` is used to stop the meeting livestream which can be accessed from the `Room` object.

#### Example

```js
import 'package:flutter/material.dart';
import 'package:videosdk/videosdk.dart';

class MeetingScreen extends StatefulWidget {
  ...
}

class _MeetingScreenState extends State<MeetingScreen> {
  late Room _room;

  @override
  void initState() {
    //highlight-next-line
    ...
  }

  @override
  Widget build(BuildContext context) {
    return Column(
      children:[
        //highlight-start
        ElevatedButton(
          onPressed:(){
            var outputs = [
              {
                url: "rtmp://a.rtmp.youtube.com/live2",
                streamKey: "<STREAM_KEY>",
              },
              {
                url: "rtmps://",
                streamKey: "<STREAM_KEY>",
              },
            ];
            var liveStreamConfig =  {
              'layout': {
                'type': 'GRID',
                'priority': 'SPEAKER',
                'gridSize': 4,
              },
              'theme': "LIGHT",
            };
            room.startLivestream(outputs, config: livestreamConfig);
          },
          child: const Text("Start Livestream"),
        ),
        ElevatedButton(
          onPressed:(){
            _room.stopLivestream();
          },
          child: const Text("Stop Livestream"),
        ),
    //highlight-end
      ]
    );
  }
}
```

### Event associated with Livestream

- **livestreamStateChanged** - Whenever meeting livestream state changes, then `livestreamStateChanged` event will trigger.

```js
import 'package:flutter/material.dart';
import 'package:videosdk/videosdk.dart';

class MeetingScreen extends StatefulWidget {
  ...
}

class _MeetingScreenState extends State<MeetingScreen> {
  late Room room;

  @override
  void initState() {
    //highlight-next-line
    ...

    setupRoomEventListener();
  }

  @override
  Widget build(BuildContext context) {
    return YourMeetingWidget();
  }

  //highlight-start
  void setupRoomEventListener() {
    room.on(Events.livestreamStateChanged, (String status) {
      //Status can be :: LIVESTREAM_STARTING
      //Status can be :: LIVESTREAM_STARTED
      //Status can be :: LIVESTREAM_STOPPING
      //Status can be :: LIVESTREAM_STOPPED
      log("Meeting Livestream status : $status");
    });
  }
  //highlight-end
}
```

### Custom Template

With VideoSDK, you can also use your own custom designed layout template to livestream the meetings. In order to use the custom template, you need to create a template for which you can [follow this guide](/react/guide/interactive-live-streaming/custom-template). Once you have setup the template, you can use the [REST API to start](/api-reference/realtime-communication/start-livestream) the livestream with the `templateURL` parameter.

## API Reference

The API references for all the methods utilized in this guide are provided below.

- [startLivestream](/flutter/api/sdk-reference/room-class/methods#startlivestream)
- [stopLivestream](/flutter/api/sdk-reference/room-class/methods#stoplivestream)
- [Events.livestreamStateChanged](/flutter/api/sdk-reference/room-class/events#livestreamstatechanged)


---

---
sidebar_label: Release Notes
pagination_label: Release Notes
---

# Release Notes - Flutter

This page will keep you updated with all the releases of Flutter SDK.

## v1.3.0

**Release Date** : 22nd Jan 2025

Change Log :

- **Deprecated Modes:** Replaced `CONFERENCE` with `SEND_AND_RECV` and `VIEWER` with `SIGNALLING_ONLY`.
- **New Mode:** Added `RECV_ONLY` for live streaming, allowing participants to receive media only.
- **Role Switching:** Enabled seamless role switching between `SEND_AND_RECV` (host) and `RECV_ONLY` (audience) using `changeMode()` of Room Class.

**Docs:** [Quick Start for Interactive Live Streaming](./quick-start-flutter-ils)



---

---
title: Display Video | Video SDK
hide_title: true
hide_table_of_contents: false
description: Video SDK and Audio SDK, developers need to implement a token server. This requires efforts on both the front-end and backend.
sidebar_label: Display Video
pagination_label: Display Video
keywords:
  - audio calling
  - video calling
  - real-time communication
  - collaboration
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: display-video
---

# Display Video - Flutter

In this guide, we will take a look at how to render the participant's audio and video on the screen.

## Rendering Participant

The two steps are involve to achieve this process.

1. [Get Mic and Webcam Status](#1-get-mic-and-webcam-status)
2. [Rendering Video](#2-rendering-video)

### `1. Get Mic and Webcam Status`

We must determine whether the participant's audio or video is on or off before rendering him or her. Hence, if the webcam is not turned on, we will begin by rendering the participant's frames with their name in them; otherwise, we will render the video.

**`Step 1:`** Let's get every `participants` from `Room` by listenting to the `participantJoined` as well as `participantLeft` event.

```js title="meeting_screen.dart"
import 'package:flutter/material.dart';
import 'package:videosdk/videosdk.dart';
import './participant_tile.dart';

class MeetingScreen extends StatefulWidget {
  final String meetingId;
  final String token;

  const MeetingScreen(
      {super.key, required this.meetingId, required this.token});

  @override
  State<MeetingScreen> createState() => _MeetingScreenState();
}

class _MeetingScreenState extends State<MeetingScreen> {
  late Room _room;
  var micEnabled = true;
  var camEnabled = true;
  String? _presenterId;

  Map<String, Participant> participants = {};

  @override
  void initState() {
    // create room
    _room = VideoSDK.createRoom(
      roomId: widget.meetingId,
      token: widget.token,
      displayName: "John Doe",
      micEnabled: micEnabled,
      camEnabled: camEnabled,
      defaultCameraIndex:
          1, // Index of MediaDevices will be used to set default camera
    );

    setMeetingEventListener();

    // Join room
    _room.join();

    super.initState();
  }

  //highlight-start
  // listening to meeting events
  void setMeetingEventListener() {
    _room.on(Events.roomJoined, () {
      setState(() {
        participants.putIfAbsent(
            _room.localParticipant.id, () => _room.localParticipant);
      });
    });

    _room.on(
      Events.participantJoined,
      (Participant participant) {
        setState(
          () => participants.putIfAbsent(participant.id, () => participant),
        );
      },
    );

    _room.on(Events.participantLeft, (String participantId) {
      if (participants.containsKey(participantId)) {
        setState(
          () => participants.remove(participantId),
        );
      }
    });

    _room.on(Events.roomLeft, () {
      participants.clear();
      Navigator.popUntil(context, ModalRoute.withName('/'));
    });
  }
  //highlight-end

  // onbackButton pressed leave the room
  Future<bool> _onWillPop() async {
    _room.leave();
    return true;
  }

  @override
  Widget build(BuildContext context) {
    return WillPopScope(
      onWillPop: () => _onWillPop(),
      child: Scaffold(
        body: Padding(
          padding: const EdgeInsets.all(8.0),
          child: Column(
            children: [],
          ),
        ),
      ),
    );
  }
}
```

**`Step 2:`** WIth participant list ready, let render a list of participants with create a straightforward box with each person's name.

```js title="meeting_screen.dart"
import 'package:flutter/material.dart';
import 'package:videosdk/videosdk.dart';
import './participant_tile.dart';

class MeetingScreen extends StatefulWidget {
  ...
}

class _MeetingScreenState extends State<MeetingScreen> {
  late Room _room;
  var micEnabled = true;
  var camEnabled = true;

  Map<String, Participant> participants = {};

  @override
  void initState() {
    // create room
    ...
  }

  // listening to meeting events
  void setMeetingEventListener() {
    ...
  }

  // onbackButton pressed leave the room
  Future<bool> _onWillPop() async {
    _room.leave();
    return true;
  }

  @override
  Widget build(BuildContext context) {
    return WillPopScope(
      onWillPop: () => _onWillPop(),
      child: Scaffold(
        body: Padding(
          padding: const EdgeInsets.all(8.0),
          child: Column(
            children: [
              //highlight-start
              //render all participant
              Expanded(
                child: GridView.builder(
                  gridDelegate: const SliverGridDelegateWithFixedCrossAxisCount(
                    crossAxisCount: 1,
                  ),
                  itemBuilder: (context, index) {
                    return ParticipantTile(
                        participant: participants.values.elementAt(index));
                  },
                  itemCount: participants.length,
                ),
              ),
              //highlight-end
            ],
          ),
        ),
      ),
    );
  }
}
```

```js title="participant_tile.dart"
import 'package:flutter/material.dart';
import 'package:videosdk/videosdk.dart';

class ParticipantTile extends StatefulWidget {
  final Participant participant;
  const ParticipantTile({super.key, required this.participant});

  @override
  State<ParticipantTile> createState() => _ParticipantTileState();
}

class _ParticipantTileState extends State<ParticipantTile> {

  @override
  void initState() {
    super.initState();
  }

  @override
  Widget build(BuildContext context) {
    return Container(
      color: Colors.black54,
      child: Stack(
        children: [
          //highlight-start
          Positioned(
            top: 10,
            left: 10,
            child: Text(
              "Name: ${widget.participant.displayName}",
              textAlign: TextAlign.center,
              style: const TextStyle(
                color: Colors.white,
                fontSize: 16.0,
              ),
            ),
          ),
          //highlight-end
        ],
      ),
    );
  }
}
```

**`Step 3:`** To display the status of each participant's microphone and webcam in the list, we will create the local state of audio and video streams of the participant fromt he `streams` property and also add the event listener to get notified on status change.

Here's a code code snippet of rendering mic and webcam status:

```js
import 'package:flutter/material.dart';
import 'package:videosdk/videosdk.dart';

class ParticipantTile extends StatefulWidget {
  final Participant participant;
  const ParticipantTile({super.key, required this.participant});

  @override
  State<ParticipantTile> createState() => _ParticipantTileState();
}

class _ParticipantTileState extends State<ParticipantTile> {
  //highlight-start
  //declare stream state
  Stream? videoStream;
  Stream? audioStream;
  //highlight-end

  @override
  void initState() {
    //highlight-start
    // initial video stream for the participant
    widget.participant.streams.forEach((key, Stream stream) {
      setState(() {
        if (stream.kind == 'video') {
          videoStream = stream;
        }
      });
    });
    _initStreamListeners();
    //highlight-end
    super.initState();
  }

  //highlight-start
  _initStreamListeners() {
    widget.participant.on(Events.streamEnabled, (Stream stream) {
      if (stream.kind == 'video') {
        setState(() => videoStream = stream);
      } else if (stream.kind == 'audio') {
        setState(() => audioStream = stream);
      }
    });

    widget.participant.on(Events.streamDisabled, (Stream stream) {
      if (stream.kind == 'video') {
        setState(() => videoStream = null);
      } else if (stream.kind == 'audio') {
        setState(() => audioStream = null);
      }
    });
  }
  //highlight-end

  @override
  Widget build(BuildContext context) {
    return Container(
      color: Colors.black54,
      child: Stack(
        children: [
          Positioned(
            top: 10,
            left: 10,
            //highlight-start
            //Update the text
            child: Text(
              "Name : ${widget.participant.displayName}" +
                  "\nMic :${audioStream == null ? "Off" : "On"}" +
                  "\nCam :${audioStream == null ? "Off" : "On"}",
              style: const TextStyle(
                color: Colors.white,
                fontSize: 16.0,
              ),
            ),
            //highlight-end
          ),
        ],
      ),
    );
  }
}
```

<center>

<img src='https://cdn.videosdk.live/website-resources/docs-resources/display_video_empty_participant_list.png' style={{height: '600px'}}/>

</center>

### `2. Rendering Video`

The status of the `webcam` and `mic` is now displayed. If the webcam is turned `on`, we will use the `videoStream` we declared earlier and display the participant's video.

```js
import 'package:flutter/material.dart';
import 'package:videosdk/videosdk.dart';

class ParticipantTile extends StatefulWidget {
  final Participant participant;
  //highlight-next-line
  ...
}

class _ParticipantTileState extends State<ParticipantTile> {
  Stream? videoStream;
  Stream? audioStream;

  @override
  void initState() {
    //highlight-next-line
    ...
  }

  _initStreamListeners() {
    //highlight-next-line
    ...
  }

  @override
  Widget build(BuildContext context) {
    return Container(
      color: Colors.black54,
      child: Stack(
        children: [
          //highlight-start
          if (videoStream != null)
            RTCVideoView(
              videoStream?.renderer as RTCVideoRenderer,
              objectFit: RTCVideoViewObjectFit.RTCVideoViewObjectFitCover,
            ),
          //highlight-end
          Positioned(
            top: 10,
            left: 10,
            child: Text(
              "Name : ${widget.participant.displayName}" +
                  "\nWebcam :${videoStream == null ? "Off" : "On"}",
                  " Mic :${audioStream == null ? "Off" : "On"}" +
              style: const TextStyle(
                color: Colors.black,
                fontSize: 16.0,
              ),
            ),
          ),
        ],
      ),
    );
  }
}
```

:::caution

Unlike before, you don't need to render audio separately because RTCView is a component that handles audio stream automatically.
:::

<center>

<img src='https://cdn.videosdk.live/website-resources/docs-resources/display_video_participant_with_video.png' style={{height: '600px'}}/>

</center>

#### `2.1 Mirror Local Video View`

If you wish to show the mirror view of the local participant, you can pass boolean value to `mirror` property of RTCView.

```js
import 'package:flutter/material.dart';
import 'package:videosdk/videosdk.dart';

class ParticipantTile extends StatefulWidget {
  final Participant participant;
  //highlight-next-line
  ...
}

class _ParticipantTileState extends State<ParticipantTile> {
  Stream? videoStream;
  Stream? audioStream;

  @override
  void initState() {
    //highlight-next-line
    ...
  }

  _initStreamListeners() {
    //highlight-next-line
    ...
  }

  @override
  Widget build(BuildContext context) {
    return Container(
      color: Colors.black54,
      child: Stack(
        children: [
          if (videoStream != null)
            RTCVideoView(
              videoStream?.renderer as RTCVideoRenderer,
              objectFit: RTCVideoViewObjectFit.RTCVideoViewObjectFitCover,
              //highlight-next-line
              mirror: true,
            ),
        ],
      ),
    );
  }
}
```

##### Sample of mirror view video

![mirror view](https://cdn.videosdk.live/website-resources/docs-resources/mirror_view_mobile.jpg)

## API Reference

The API references for all the methods and events utilised in this guide are provided below.

- [Participant](/flutter/api/sdk-reference/participant-class/introduction)
- [streamEnabled](/flutter/api/sdk-reference/participant-class/events#streamenabled)
- [streamDisabled](/flutter/api/sdk-reference/participant-class/events#streamdisabled)


---

---
title: Layout and Grid Management | Video SDK
hide_title: true
hide_table_of_contents: false
description: Video SDK and Audio SDK, developers need to implement a token server. This requires efforts on both the front-end and backend.
sidebar_label: Layout and Grid Management
pagination_label: Layout and Grid Management
keywords:
  - audio calling
  - video calling
  - real-time communication
  - collaboration
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: layout-and-grid-management
---

# Layout and Grid Management - Flutter

In this guide, we will take a look at how to efficiently manage the participants in different types of layout.

## Grid Layout

The most usual way to showing participants within a grid. There are multiple things you should keep in mind when showing participants in the grid.

This includes the number of participants being shown on the screens, number of participants in the background(in the meeting but not on the grid), quality which is being consumed for each and every participant in the grid.

### Quality of Participant's Video

When there are large number of participants present on the screen, it is best to consume them in lower resolutions. For this we recommend you to call the `setQuality` method on the participants present in the grid with dynamic values based on the number of participants on the screen.

Here is the recommended video quality:

1. Participants less than 3: `setQuality("high")`
2. Participants between 3 to 4: `setQuality("med")`
3. Participants greater than 4: `setQuality("low")`

<center>
<img src='https://cdn.videosdk.live/website-resources/docs-resources/grid_quality_mobile.png' />
</center>

### Grid with Screen Share

When you are rendering a small grid along with the screen share of the presenter or you are showing a simple sidebar video of the participants while the screenshare is on, it is recommended to do `setQuality("low")` for the participants who are present in the sidebar.

## Grid with Pagination

If you are having large video calls where there are multiple speakers with video turned on, it is best to implement a pagination type setup where only a few (4-6) participants are shown on the grid and rest can be seen by changing the page.

To best utilize the resourses, you should pause the streams of the participants who are not present in the grid and resume them when the come in to the grid, you can resume their streams.

<center>
<img src='https://cdn.videosdk.live/website-resources/docs-resources/grid_pagination.png' />
</center>

###### Example to pause and resume streams

```js
import 'package:flutter/material.dart';
import 'package:videosdk/videosdk.dart';

class ParticipantTile extends StatefulWidget {
  final Participant participant;
  //highlight-next-line
  ...
}

class _ParticipantTileState extends State<ParticipantTile> {

  @override
  void initState() {
    //highlight-next-line
    ...
  }

  @override
  Widget build(BuildContext context) {
    return Column(
      children: [
        //highlight-start
        ElevatedButton(
          onPressed:(){
            widget.participant.streams.forEach((stream){
              if(stream.kind == "video"){
                _stream.track.pause();
              }
            });
          },
          child: const Text("Pause Stream"),
        ),
        ElevatedButton(
          onPressed:(){
            widget.participant.streams.forEach((stream){
              if(stream.kind == "video"){
                _stream.track.resume();
              }
            });
          },
          child: const Text("Resume Stream"),
        ),
        //highlight-end
      ],
    );
  }
}
```

## API Reference

The API references for all the methods and events utilised in this guide are provided below.

- [setQuality](/flutter/api/sdk-reference/participant-class/methods#setquality)


---

---
title: Optimize Audio Track | VideoSDK Docs
hide_title: false
hide_table_of_contents: false
description: Optimize Audio  Tracks features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Optimize Audio Track
pagination_label: Optimize Audio Track
keywords:
  - Camera on
  - Camera off
  - Webcam on
  - Webcam off
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
---

# Optimize Audio Track - Flutter

While optimizing for the best listening experience, it is necessary to fine-tune the audio track that is being used during the calls.

For the best fine-tuning experience, we have introduced the ability to pass a custom audio track for the participant's media before and during the meeting.

## Custom Audio Track

This feature can be used to add custom layers like background noise removal, echo cancellation, etc. on audio and send it to other participants.

### `How to Create Custom Audio Track ?`

- You can create a Audio Track using `createMicrophoneAudioTrack()` method of `VideoSDK`.

- This method can be used to create audio track using different encoding parameters and noise cancellation configuration.

#### Example

```javascript
import 'package:videosdk/videosdk.dart';

CustomTrack? customTrack = await VideoSDK.createMicrophoneAudioTrack({
  // highlight-next-line
  // It will be the id of the mic from which the voice should be captured.
  microphoneId : 'mic-id' // OPTIONAL

  // highlight-next-line
  // This will accept the voice profile you want to capture.
  encoderConfig: CustomAudioTrackConfig.speech_standard, // `high_quality` | `music_standard`,  Default : `speech_standard`

  noiseConfig: {
  // highlight-start
  // It is used to improve the quality of audio by removing background noise
  // that can interfere with the clarity of speech.
  // highlight-end
    "noiseSuppression": true,

  // highlight-next-line
  // It is used to remove unwanted echoes from voice.
    "echoCancellation": true,

 // highlight-next-line
  // It is used to maintain a consistent level of loudness or amplitude in a voice.
    "autoGainControl": true,
  },
});
```

- `speech_standard` : This config is optimised for normal voice communication.

- `high_quality` : This config is used for getting RAW audio, where you can apply your `noiseConfig`.

- `music_standard` : This config is optimised for communication, where sharing of musical notes such as songs or instrumental sounds, is important.

### `How to Setup Custom Audio Track ?`

The custom track can be set up both before and after the initialization of the meeting.

1. [Setting up a Custom Track during the initialization of a meeting](#1-setting-up-a-custom-track-during-the-initialization-of-a-meeting)
2. [Setting up a Custom Track with methods](#2-setting-up-a-custom-track-with-methods)

##### 1. Setting up a Custom Track during the initialization of a meeting

If you are passing `micEnabled: true` in the `createRoom` and want to use custom tracks from start of the meeting, you can pass custom track in the `customMicrophoneAudioTrack` as shown below.

:::caution
Custom Track will not apply on `micEnabled: false` configuration.
:::

##### Example

```javascript
import 'package:flutter/material.dart';
import 'package:videosdk/videosdk.dart';

class MeetingScreen extends StatefulWidget {
  final String meetingId;
  final String token;

  const MeetingScreen(
      {super.key, required this.meetingId, required this.token});

  @override
  State<MeetingScreen> createState() => _MeetingScreenState();
}

class _MeetingScreenState extends State<MeetingScreen> {
  late Room _room;

  @override
  void initState() {
    initRoom();
    super.initState();
  }

  void initRoom() {
    //highlight-start
    //Creating Custom Audio Track
    CustomTrack? audioTrack = await VideoSDK.createMicrophoneAudioTrack(
        encoderConfig: CustomAudioTrackConfig.speech_standard);

    //Creating a new Room with custom audio track
    // create room
    _room = VideoSDK.createRoom(
      roomId: widget.meetingId,
      token: widget.token,
      displayName: "John Doe",
      micEnabled: true,
      camEnabled: true,
      defaultCameraIndex:
          1, // Index of MediaDevices will be used to set default camera
      customMicrophoneAudioTrack: audioTrack, // custom audio track :: optional
    );
    //highlight-end
  }

  @override
  Widget build(BuildContext context) {
    return YourMeetingWidget();
  }
}
```

#### 2. Setting up a Custom Track with methods

In order to switch tracks during the meeting, you have to pass the `CustomTrack` in the **`unmuteMic()`** method of `Room`.

:::tip
Make sure to call `muteMic()` before you create a new track as it may lead to unexpected behavior.
:::

##### Example

```javascript
import 'package:flutter/material.dart';
import 'package:videosdk/videosdk.dart';

class MeetingScreen extends StatefulWidget {
  final String meetingId;
  final String token;

  const MeetingScreen(
      {super.key, required this.meetingId, required this.token});

  @override
  State<MeetingScreen> createState() => _MeetingScreenState();
}

class _MeetingScreenState extends State<MeetingScreen> {
  late Room _room;

  @override
  void initState() {
    initRoom();
    super.initState();
  }

  void initRoom() {
    //highlight-next-line
    ...
  }

  @override
  Widget build(BuildContext context) {
    return Column(
      childern: [
        ElevatedButton(
          onPressed: ()async{
            //highlight-start
            //Creating Custom Audio Track
            CustomTrack? audioTrack = await VideoSDK.createMicrophoneAudioTrack(
                encoderConfig: CustomAudioTrackConfig.speech_standard);

            _room.unmuteMic(audioTrack);
            //highlight-end
          },
          child: const Text("Unmute with Custom Track"),
        ),
      ]
    )
  }
}
```

## API Reference

The API references for all the methods and events utilised in this guide are provided below.

- [Custom Audio Track](/flutter/api/sdk-reference/custom-tracks#custom-audio-track---flutter)


---

---
title: Optimize Video Tracks | VideoSDK Docs
hide_title: false
hide_table_of_contents: false
description: Optimize Video Tracks features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Optimize Video Tracks
pagination_label: Optimize Video Tracks
keywords:
  - Camera on
  - Camera off
  - Webcam on
  - Webcam off
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
---

# Optimize Video Tracks - Flutter

While optimizing for the best viewing experience, it is necessary to fine-tune the video tracks that are being used during the calls.

For the best fine-tuning experience, we have introduced the ability to pass a custom video track for the participant's media before and during the meeting.

## Custom Video Track

This feature can be used to add custom video encoder configurations and background removal & video filter from external libraries and send it to other participants.

### `How to Create a Custom Video Track ?`

- You can create a Video Track using `createCameraVideoTrack()` method of `VideoSDK` class.

- This method can be used to create video track using different encoding parameters, camera facing mode, and optimization mode and return `Future<CustomTrack?>`.

#### Example

```javascript
import 'package:videosdk/videosdk.dart';

CustomTrack? customTrack = await VideoSDK.createCameraVideoTrack({
  // highlight-next-line
  // It will be the id of the camera from which the video should be captured.
  cameraId:"camera-id", // OPTIONAL

  // highlight-next-line
  // This will accept the resolution (height x width) of video you want to capture.
  encoderConfig: "h480p_w640p", // "h540p_w960p" | "h720p_w1280p" ... // Default : "h360p_w640p"

  // highlight-next-line
  // For Mobile browser It will specify whether to use front or back camera for the video track.
  facingMode: "FacingMode.environment", // "FacingMode.front"

  // highlight-next-line
  // We will discuss this parameter in next step.
  multiStream:true // false,  Default : true

});
```

:::caution
The capabilities of the device have a significant impact on how custom track configurations behave. Assuming a case where you set encoder configuration to 1080p but the webcam only supports 720p, then encoder configuration will automatically switch to the highest resolution that the device can handle, which is 720p.
:::

##### What is `multiStream`?

- It will specify if the stream should send multiple resolution layers or single resolution layer.

**`multiStream : true`** By default, VideoSDK sends multiple resolution video streams to the server (whether you are using custom video track or not), For instance, user device capabilty is 720p, so VideoSDK sends 720p along with 640p and 480p streams. This allows VideoSDK to deliver the appropriate stream to each participant based on their network bandwidth.

<center>

![Multi Stream False](/img/multistream_true.png)

</center>

**`multiStream : false`** If you want to restrict the VideoSDK to send only one stream to maintain quality, you can set `multiStream` to `false`.

<center>

![Multi Stream False](/img/multistream_false.png)

</center>

:::important
MultiStream functionality is not supported in the Firefox browser. VideoSDK will only send one stream for Firefox browsers.
:::

:::danger
`setQuality` would not have any effect if multiStream is set to `false`.
:::

### `How to Setup a Custom Video Track ?`

The custom track can be set up both before and after the initialization of the meeting.

1. [Setting up a Custom Track during the initialization of a meeting](#1-setting-up-a-custom-track-during-the-initialization-of-a-meeting)
2. [Setting up a Custom Track with methods](#2-setting-up-a-custom-track-with-methods)

##### 1. Setting up a Custom Track during the initialization of a meeting

If you are passing `webcamEnabled: true` in the `createRoom` and want to use custom tracks from start of the meeting, you can pass custom track in the `customCameraVideoTrack` as shown below.

:::caution
Custom Track will not apply on `webcamEnabled: false` configuration.
:::

##### Example

```javascript
import 'package:flutter/material.dart';
import 'package:videosdk/videosdk.dart';

class MeetingScreen extends StatefulWidget {
  final String meetingId;
  final String token;

  const MeetingScreen(
      {super.key, required this.meetingId, required this.token});

  @override
  State<MeetingScreen> createState() => _MeetingScreenState();
}

class _MeetingScreenState extends State<MeetingScreen> {
  late Room _room;

  @override
  void initState() {
    initRoom();
    super.initState();
  }

  void initRoom() {
    //highlight-start
    //Creating Custom Video Track
    CustomTrack? videoTrack = await VideoSDK.createCameraVideoTrack(
      encoderConfig: CustomVideoTrackConfig.h1440p_w1920p,
      multiStream: false,
    );

    //Creating a new Room with custom audio track
    // create room
    _room = VideoSDK.createRoom(
      roomId: widget.meetingId,
      token: widget.token,
      displayName: "John Doe",
      micEnabled: true,
      camEnabled: true,
      defaultCameraIndex:
          1, // Index of MediaDevices will be used to set default camera
      customCameraVideoTrack: videoTrack, // custom video track :: optional
    );
    //highlight-end
  }

  @override
  Widget build(BuildContext context) {
    return YourMeetingWidget();
  }
}
```

#### 2. Setting up a Custom Track with methods

In order to switch tracks during the meeting, you have to pass the `CustomTrack` in the **`enableCam()`** method of `Room`.

:::tip
Make sure to call `disableCam()` before you create a new track as it may lead to unexpected behavior.
:::

##### Example

```javascript
import 'package:flutter/material.dart';
import 'package:videosdk/videosdk.dart';

class MeetingScreen extends StatefulWidget {
  final String meetingId;
  final String token;

  const MeetingScreen(
      {super.key, required this.meetingId, required this.token});

  @override
  State<MeetingScreen> createState() => _MeetingScreenState();
}

class _MeetingScreenState extends State<MeetingScreen> {
  late Room _room;

  @override
  void initState() {
    initRoom();
    super.initState();
  }

  void initRoom() {
    //highlight-next-line
    ...
  }

  @override
  Widget build(BuildContext context) {
    return Column(
      childern: [
        ElevatedButton(
          onPressed: ()async{
            //highlight-start
            //Creating Custom Video Track
            CustomTrack? videoTrack = await VideoSDK.createCameraVideoTrack(
              encoderConfig: CustomVideoTrackConfig.h1440p_w1920p,
              multiStream: false,
            );

            _room.enableCam(videoTrack);
            //higlight-end
          },
          child: const Text("Enable Cam with Custom Track"),
        ),
      ]
    )
  }
}
```

### `Which Configuration is suitable for Device ?`

In this section, we will understand participant size wise `encoder(Resolution)` and `multiStream` configuration.

<center>
<img src='https://cdn.videosdk.live/website-resources/docs-resources/mobile_device_config.png' />
</center>

## API Reference

The API references for all the methods and events utilised in this guide are provided below.

- [Custom Video Track](/flutter/api/sdk-reference/custom-tracks#custom-video-track---flutter)


---

---
title: Picture-in-Picture Mode | Video SDK
sidebar_label: Picture-in-Picture Mode
pagination_label: Picture-in-Picture Mode
description: Picture-in-picture (PiP) is a feature that is commonly used in video conferencing software. It allows you to continue your video conference while also performing other tasks on your device.
hide_title: true
hide_table_of_contents: false
keywords:
  - audio calling
  - video calling
  - real-time communication
  - collaboration
  - Picture In Picture Mode 
  - Flutter Application 
  - Android Picture In Picture Mode
  - Flutter Picture In Picture Mode 
  - WebRTC PiP Mode
  - Native iOS Picture In Picture Mode 
---

# Picture-in-Picture Mode

### Overview

Picture-in-Picture (PiP) mode enhances the video conferencing experience by allowing users to multitask while keeping a small, floating video window on their screen. This guide walks you through implementing PiP mode in Flutter using VideoSDK, covering both Android and iOS platforms—without relying on third-party dependencies.

To enable PiP mode, native methods are used on both Android and iOS through the method channel. On Android, PiP mode is activated with the `enterPictureInPictureMode()` method. On iOS, the process involves capturing RTC frames natively, rendering them into a custom view with `AVPlayer`, and then utilizing that view to enable PiP functionality.

<center>
    <img src='https://cdn.videosdk.live/website-resources/docs-resources/pip_flutter_ios.jpg'/>
</center>

:::note
You can check out the complete implementation in the [Github repository](https://github.com/videosdk-live/videosdk-flutter-pip-mode-example)
:::

### Prerequisites

- Familiarity with method channels in Flutter.
- To implement PiP (Picture-in-Picture) mode, clone the [Quick Start Repository](https://github.com/videosdk-live/quickstart/tree/main/flutter-rtc) and follow the implementation steps.

## Architecture Diagram
<center>
    <img src='https://cdn.videosdk.live/website-resources/docs-resources/flutter_pip_architecture.jpg'/>
</center>

## Android Implementation

**Step 1 : Configuring `AndroidManifest.xml`**

To enable Picture-in-Picture (PiP) mode in your Flutter application, update the `AndroidManifest.xml` file with the necessary permissions and activity configurations:


```js title="AndroidManifest.xml"
<uses-permission android:name="android.permission.WAKE_LOCK" />  
<uses-permission android:name="android.permission.SYSTEM_ALERT_WINDOW"/>  
<uses-permission android:name="android.permission.PICTURE_IN_PICTURE"/>  

<activity  
    android:configChanges="orientation|screenSize|smallestScreenSize|screenLayout"  
    android:supportsPictureInPicture="true">  
</activity>  
```


**Step 2: Implementing PiP Mode**

The native Android implementation utilizes the [Picture-in-Picture (PiP)](https://developer.android.com/develop/ui/views/picture-in-picture) API to manage PiP mode effectively. The following methods play a crucial role in this implementation:


1. `onPictureInPictureRequested` (System-defined)

- Invoked when the system detects a request to enter PiP mode.

2. `startPiPMode` (Custom implementation)

- Manually initiates PiP mode with a 16:9 aspect ratio.
- It invokes `enterPictureInPictureMode()` Method 
- This method attempts to put the activity into Picture-in-Picture mode, allowing it to continue displaying content in a small, resizable window when the user navigates away from the app.


```kotlin title="MainActivity.kt"
package com.example.quick_start  

import android.app.PictureInPictureParams  
import android.os.Build  
import android.os.Bundle  
import android.util.Log  
import android.util.Rational  
import io.flutter.embedding.android.FlutterActivity  
import io.flutter.embedding.engine.FlutterEngine  
import io.flutter.plugin.common.MethodChannel  

class MainActivity : FlutterActivity() {  

    companion object {  
        var instance: MainActivity? = null  
    }  

    // MethodChannel for Flutter-native communication  
    private val Channel = "pip_channel"  

    // Flag to track if the user is on the meeting screen  
    private var isInMeetingScreen: Boolean = false  

    override fun onCreate(savedInstanceState: Bundle?) {  
        super.onCreate(savedInstanceState)  
        instance = this  
    }  

    override fun configureFlutterEngine(flutterEngine: FlutterEngine) {  
        super.configureFlutterEngine(flutterEngine)  

        // Establish a MethodChannel for interaction with Flutter  
        MethodChannel(flutterEngine.dartExecutor.binaryMessenger, Channel)  
            .setMethodCallHandler { call, result ->  
                when (call.method) {  
                    "enterPiPMode" -> {  
                        // Enter PiP mode upon request from Flutter  
                        startPiPMode()  
                        result.success(null)  
                    }  
                    "setMeetingScreen" -> {  
                        // Update the meeting screen flag based on Flutter’s input  
                        isInMeetingScreen = call.arguments as Boolean  
                        result.success(null)  
                    }  
                    else -> result.notImplemented()  
                }  
            }  
    }  

    // Sends a message from Android to Flutter via MethodChannel  
    private fun sendMessageToFlutter(message: String) {  
        // Notify Flutter when PiP mode is activated  
        MethodChannel(flutterEngine!!.dartExecutor.binaryMessenger, Channel)  
            .invokeMethod("sendMessage", hashMapOf("message" to message))  
    }  

    // Handles system-triggered PiP requests  
    override fun onPictureInPictureRequested(): Boolean {  
        Log.d("MainActivity", "onPictureInPictureRequested: $isInMeetingScreen")  

        // If the user is on the meeting screen, activate PiP mode and notify Flutter  
        return if (isInMeetingScreen) {  
            startPiPMode()  
            sendMessageToFlutter("Done")  
            true  
        } else {  
            super.onPictureInPictureRequested()  
        }  
    }  

    // Initiates PiP mode  
    private fun startPiPMode() {  
        Log.d("MainActivity", "startPiPService")  

        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {  
            // Ensure PiP mode is supported (Android 8.0+)  
            val paramsBuilder = PictureInPictureParams.Builder()  
                .setAspectRatio(Rational(16, 9)) // Define the PiP window aspect ratio  
            this.enterPictureInPictureMode(paramsBuilder.build()) // Activate PiP mode  
        }  
    }  
} 

```

## iOS Implementation ##

**Step 1 : Enable Xcode Capabilities**

Enable the necessary capabilities in Xcode:
1. Open your project in Xcode.
2. Navigate to your target settings.
3. Select the "Signing & Capabilities" tab.
4. Click the "+" button to add capabilities.
5. Add **Background Modes**.

Under **Background Modes**, enable the following options:
- Audio, AirPlay, and Picture in Picture
- Voice over IP

<center>
    <img src='https://cdn.videosdk.live/website-resources/docs-resources/pip_flutter_ios_modes.png'/>
</center>


**Step 2: Handling Local and Remote participant Frames in iOS**

**Local participant Frames Handling**

For local participant frames, we utilize the `VideoProcessor` class in VideoSDK. 


:::info 
For a detailed setup guide on proceesor refer to [*this documentation*](https://docs.videosdk.live/flutter/guide/video-and-audio-calling-api-sdk/video-processor/ios-setup).
:::

- Below is the Swift implementation to process and render local frames:

```swift 
public class FrameProcessor: VideoProcessor {
    
  // Override the onFrameReceived function to access VideoFrames
  public override func onFrameReceived(_ frame: RTCVideoFrame) -> RTCVideoFrame? {
    // Access the frame data
    return frame
  }
}
```

**Handling Remote participant Streams**

- To handle remote participants video streams, we extract the WebRTC stream and pass it to the PiP manager.

```swift
public class FrameProcessor: VideoProcessor {

  // for the remote stream for specific remote id 
  static func updateRemote(remoteId: String) {
    remoteTrack = FlutterWebRTCPlugin.sharedSingleton()?.remoteTrack(forId: remoteId)
  }
}
```

**Step 3: Converting RTC Frames for PiP Mode**

To display Video in PiP mode, we need to convert `RTCVideoFrame` into a format compatible with AVKit.

1. Extract the frame buffer (`RTCCVPixelBuffer`).
2. Convert it to a `CVPixelBuffer`.
3. Create a `CMSampleBuffer` for AVFoundation compatibility.
4. Render the sample buffer using `AVSampleBufferDisplayLayer`.
5. Manage PiP mode using `AVPictureInPictureController`.

**Step 4 : Integrating PiP Mode**

To enable PiP mode using AVKit:

1. Create a PiPManager class for managing PiP state.
2. Use `AVPictureInPictureController` to toggle PiP mode.
3. Assign the **AVSampleBufferDisplayLayer** to PiP.
4. Enable user interactions with PiP mode.

- For a full implementation, refer to the [frame.swift](https://github.com/videosdk-live/videosdk-flutter-pip-mode-example/blob/main/ios/Runner/Frame.swift)

**Step 5 : Implementing PiP Method Channel in `AppDelegate.swift`**

The method channel in `AppDelegate.swift` is responsible for connecting Flutter and iOS for PiP mode control.


```swift title="AppDelegate.swift"
import UIKit
import Flutter
import videosdk

@main
@objc class AppDelegate: FlutterAppDelegate {
    override func application(
        _ application: UIApplication,
        didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?
    ) -> Bool {
        GeneratedPluginRegistrant.register(with: self)

        // Video SDK setup
        let bgProcessor = FrameProcessor()
        let videoSDK = VideoSDK.getInstance
        videoSDK.registerVideoProcessor(videoProcessorName: "processor", videoProcessor: bgProcessor)

        guard let controller = window?.rootViewController as? FlutterViewController else {
            return super.application(application, didFinishLaunchingWithOptions: launchOptions)
        }

        // PiP Channel Setup
        let pipChannel = FlutterMethodChannel(
            name: "pip_channel",
            binaryMessenger: controller.binaryMessenger
        )

        pipChannel.setMethodCallHandler { (call, result) in
            switch call.method {
            case "setupPiP":
                PiPManager.setupPiP()
                result(nil)

            case "remoteStream":
                guard let args = call.arguments as? [String: Any],
                      let remoteId = args["remoteId"] as? String else {
                    result(FlutterError(code: "INVALID_ARGUMENTS", message: "Missing remoteId", details: nil))
                    return
                }
                FrameProcessor.updateRemote(remoteId: remoteId)
                result(nil)

            case "startPiP":
                PiPManager.startPIP()
                result(nil)

            case "stopPiP":
                PiPManager.stopPIP()
                result(nil)

            case "dispose":
                PiPManager.dispose()
                result(nil)

            default:
                result(FlutterMethodNotImplemented)
            }
        }

        return super.application(application, didFinishLaunchingWithOptions: launchOptions)
    }
}  
```


## Flutter Side Implementation ##


**Step 1: Adding a PiP Mode Button in `meeting_controls.dart`**

- Modify the meeting controls UI to include a PiP mode button:

```js  title="meeting_controls.dart"
import 'package:flutter/material.dart';

class MeetingControls extends StatelessWidget {
  // ...
  final void Function() pipButtonPressed;

  const MeetingControls({
    super.key,
    // ...
    required this.pipButtonPressed,
  });

  @override
  Widget build(BuildContext context) {
    return Row(
      mainAxisAlignment: MainAxisAlignment.spaceEvenly,
      children: [
        // ...
        ElevatedButton(
            onPressed: pipButtonPressed,
            child: const Text('PiP Mode'),
        ),
      ],
    );
  }
}
```

**Step 2: Creating a Custom PiP View `pip_view.dart`**

- Since Android natively converts the entire page into PiP mode, we need to create a custom PiP View in Flutter.

```js title="pip_view.dart"
import 'package:flutter/material.dart';
import 'package:videosdk/videosdk.dart';
import './participant_tile.dart';

class PiPView extends StatefulWidget {
  final Room room;

  const PiPView({super.key, required this.room});

  @override
  State<PiPView> createState() => _PiPViewState();
}

class _PiPViewState extends State<PiPView> with WidgetsBindingObserver {
  late Room _room;
  Map<String, Participant> participants = {};

  @override
  void initState() {
    super.initState();
    WidgetsBinding.instance.addObserver(this);
    _room = widget.room;
    setMeetingEventListener();

    participants.putIfAbsent(
        _room.localParticipant.id, () => _room.localParticipant);
    participants.addAll(_room.participants);
  }

  @override
  void dispose() {
    WidgetsBinding.instance.removeObserver(this);
    super.dispose();
  }

  void setMeetingEventListener() {
    _room.on(Events.participantJoined, (Participant participant) {
      setState(() {
        participants.putIfAbsent(participant.id, () => participant);
      });
    });

    _room.on(Events.participantLeft, (String participantId) {
      setState(() {
        participants.remove(participantId);
      });
    });
  }

  @override
  Widget build(BuildContext context) {
    List<Participant> participantList = participants.values.toList();

    return Scaffold(
      backgroundColor: Colors.black,
      body: Center(
        child: SizedBox(
          width: 200,
          height: 120,
          child: _buildParticipantsView(participantList),
        ),
      ),
    );
  }

  Widget _buildParticipantsView(List<Participant> participantList) {
    if (participantList.length == 1) {
      return Row(
        children: [
          Expanded(child: ParticipantTile(participant: _room.localParticipant)),
          Expanded(
            child: Container(
              color: Colors.grey.shade800,
              child: const Center(
                child: Text(
                  "Only one participant in the meeting",
                  style: TextStyle(color: Colors.white, fontSize: 12),
                  textAlign: TextAlign.center,
                ),
              ),
            ),
          ),
        ],
      );
    } else {
      Participant localParticipant = _room.localParticipant;
      Participant remoteParticipant = participantList.firstWhere(
        (p) => p.id != localParticipant.id,
        orElse: () => participantList[1],
      );
      return Row(
        children: [
          Expanded(child: ParticipantTile(participant: localParticipant)),
          Expanded(child: ParticipantTile(participant: remoteParticipant)),
        ],
      );
    }
  }
}
```

**Step 3: Updating `meeting_screen.dart` for PiP Mode**

We now enhance the MeetingScreen to support Picture-in-Picture (PiP) mode. This includes:

- Establishing a method channel for Flutter to interact with native platforms (Android and iOS).
- Registering a video processor to capture and process local frames in iOS side.
- Handling remote participant streams by extracting stream IDs, sending them to native iOS, and keeping them updated.
- Properly disposing of PiP mode resources when leaving the meeting to prevent memory leaks and ensure smooth transitions.

For a full implementation, refer to the [meeting_screen.dart](https://github.com/videosdk-live/videosdk-flutter-pip-mode-example/blob/main/lib/meeting_screen.dart)

## Final Output ##

The final output of Picture-in-Picture (PiP) Mode in the Flutter application using VideoSDK, without relying on any third-party packages. You can further customize the view and optimize it as per your requirements.


import ReactPlayer from 'react-player';

<div style={{ textAlign: 'center', marginBottom: '20px' }}>
    <ReactPlayer 
        url="https://cdn.videosdk.live/website-resources/docs-resources/flutter_ios_pip_vid.mov"
        playing 
        loop 
        muted 
        controls 
        height="500px" 
        width="100%" 
    />
</div>

<div style={{ marginTop: '30px' }}>
    :::tip  
    Stuck anywhere? Check out this [here](https://github.com/videosdk-live/videosdk-flutter-pip-mode-example.git) on GitHub  
    :::
</div>


---

---
title: Understanding Analytics Dashboard | Video SDK
hide_title: true
hide_table_of_contents: false
description: Video SDK and Audio SDK, developers need to implement a token server. This requires efforts on both the front-end and backend.
sidebar_label: Understanding Analytics Dashboard
pagination_label: Understanding Analytics Dashboard
keywords:
  - audio calling
  - video calling
  - real-time communication
  - collaboration
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: understanding-analytics-dashboard
---

import NoIndex from '/mdx/\_no-index.mdx';

<NoIndex/>

# Understanding Analytics Dashboard - Flutter

Welcome to the world of actionable insights and empowered decision-making. VideoSDK's session analytics dashboard is your gateway to understanding, optimizing, and elevating every aspect of your sessions.

## Accessing Analytics Made Easy

Navigating through session data is a breeze with VideoSDK. Simply head to your session page at https://app.videosdk.live/meetings/sessions, where a treasure trove of session information awaits.

### How to Access Analytics?

Open Session Analytics effortlessly by following these steps:

1. **Click on Meeting-ID:**
    - Directly access analytics by clicking on the meeting-ID within the session table.
2. **Hover and Click View Analytics:**
    - Hover over a specific meeting row to reveal the **View Analytics** button in the Actions Column.
    - Click on **View Analytics** to open the Session Overview sidebar, unlocking a wealth of insights.

![Access Analytics](https://cdn.videosdk.live/website-resources/docs-resources/access_analytics.png)

---

There are three tabs available within the session analytics view:

## **1. Session Overview**

This tab provides an overview of the session, including its duration and participant details. You can explore individual participant statistics to understand their session performance better.

## **2. Errors**

In this tab, you can find information about any errors encountered during the session. It helps you identify and address issues like network problems or technical glitches promptly.

:::note

Session errors are visible with JS SDK v0.0.82 or higher, React SDK v0.1.85 or higher, and React Native v0.1.6 or newer versions.

:::

## **3. Session Stats**

Explore data and metrics sent and received by participants to measure performance of the session in this tab. It offers insights into data exchange among participants, including metrics on jitter, RTT, and packet loss, resolutions, and fps aiding in assessing communication efficiency.

Let's dive deeper into each of these tabs to gain a better understanding of session analytics.

# Session Overview

The session overview page is your compass in the sea of data. Here's what you'll uncover:

- **Meeting ID:** Unique identifier for the meeting in the format of `abcd-efgh-ijkl`.
- **Session ID:** Unique identifier for each session, uniquely identified by its `sessionId`.
- **Session Status:** Indicates if the session is ongoing or ended.
- **Session Initiating Time:** Time taken by the first participant to establish the connection.
- **Start and End Time:** Marks the start and end of the session.
- **Total Unique Participants Joined:** Total number of unique participants in the session.
- **Total Session Duration:** Overall duration of the session from start to end.
- **Total Participant Minutes:** A sum of all participant duration.
- **Recording, HLS, RTMP:** Additional services used in the session.

### Participant Table List

- **Participant ID:** Unique identifier for each participant.
- **Participant Name:** Personalized identification for each participant.
- **Join Time:** Time taken by the participant to establish connection.
- **Duration:** Total time spent by this participant in the session.

### Efficient Session Management with Actions

Enhance your session management with streamlined actions:

- **Kick Out Participants:** Effortlessly remove/kickout participants from ongoing sessions.
- **Detailed Participant Analytics:**
- Hover over a specific participant row to reveal the `View Stats` button at the end of the row.
- Click on `View Stats` to open the Participant Overview sidebar.
    
    
![View Stats](https://cdn.videosdk.live/website-resources/docs-resources/view_stats.png)

## Explore Participant Insights

Discover valuable participant data that provides a clear view of engagement and experience:

- **Participant ID:** Unique identifier for each participant.
- **Participant Name:** Personalized identification for better interaction.
- **Joined At:** Indicates the precise moment when participant connects to the session.
- **Left At:** Indicates the precise moment when participant left the session.
- **Total Duration:** Total duration of participant within that session.
- **Joining Time:** Time taken by the this participant to establish the connection.
- **Location:** Approx. geographic location from where the participant joined.
- **Platform:** Specifies whether participants are using a desktop or mobile device.
- **Device Info:** Offers details regarding the participant's device.
- **OS:** Provides information about the participant's OS.
- **Browser:** Provides specifics about the participant's browser
- **SDK Version:** Indicates the version of the SDK used by participants.

### Understanding Participant Call Health

We've developed call health to offer a rapid assessment of participant performance during calls. This feature highlights the performance of audio, video, and screen sharing audio-video separately. We've utilized color theory, with green indicating good performance, orange for moderate, and red for poor performance, to enhance clarity. For detailed insights, simply hover over the bars

![Participant Call Health](https://cdn.videosdk.live/website-resources/docs-resources/participant_call_health.png)

## Participant Session Stats

Dive into Participant Session Stats for valuable insights into your session experience! With just a click on `View Session Stats` at the bottom of the page, unlock a treasure trove of data crucial for understanding audio and video experiences.

Within this section, you can observe quality metrics for the selected participant, comparing them to others. Additionally, the `Sessions Stats` covers quality stats comparison for every participant. Keep reading to explore more about Session Stats.

**Visualizing Session Performance from Both Sides**

This section provides a two-sided view of your session's metrics.

- **Left Side: Sender Participant Graph** This section displays graphs representing the metrics sent by the sender participant.. Here, you can see how the various factors impacted the data you transmitted.
- **Right Side: Receiver Participant Graph** On the right side, you'll find a dropdown menu where you can select a specific participant. Choosing a receiver will display graphs showcasing the metrics **received by that participant**. This allows you to compare the sending experience (left side) with the receiving experience (right side) for different participants.

![VideoSDK Jitter Graph](https://cdn.videosdk.live/website-resources/docs-resources/video_jitter_graph.png)

**See How Your Session Performed**

These metrics give you a clear picture of your session's quality. Understanding them helps you spot any issues and keep things running smoothly. Let's dive into what each metric means!

**Jitter:** Imagine your internet connection like a bumpy road. Jitter is how much those bumps cause your signal to bounce around. Less jitter means a smoother ride for your data (audio and video, threshold ≤ 30ms).

**RTT (Latency):** This is how long it takes for data to travel between you and the server you're connected to. Think of it like the time it takes for a message to get delivered – a lower RTT means a faster delivery (affects both audio and video, threshold ≤ 300ms).

**Bitrate:** This measures the amount of data flowing through your connection per second. Imagine it like the width of a water pipe – a higher bitrate allows for more data to flow, which can be good for high-quality audio/video or fast downloads.

**Packet Loss:** Think of data traveling in tiny packets. Packet loss is when some of those packets get dropped along the way. More packet loss means information might be missing, affecting things like audio/video quality or lag in games (threshold ≤ 5%).

**Resolution:** This refers to the sharpness and detail of an image or video. Think of it like the number of pixels on your screen – a higher resolution means a crisper picture (**Video Only**).

**FPS (Frames Per Second):** This measures how many images (frames) are displayed on your screen every second. Imagine it like a flipbook – a higher FPS creates a smoother and more fluid animation or video experience (**Video Only**).

![VideoSDK FPS Graph](https://cdn.videosdk.live/website-resources/docs-resources/video_fps_graph.png)

![VideoSDK Resolution Graph](https://cdn.videosdk.live/website-resources/docs-resources/video_resolution_graph.png)

---

# **Analyse Session Stats**

Similar to `Participant Session Stats`, this tab covers quality statistics sent by individual participants. You can select any participant to compare effectively with others.

Choose a sender participant from the dropdown menu on the left and select a recipient on the right to compare data over different time frames. This allows you to identify and explore issues within specific durations.

This tab covers the same metrics as covered in the `participant session stats`: Jitter, RTT (Latency), Bitrate, Packet-loss, Resolution (Video only), and FPS (Video only).

![VideoSDK Session Stats](https://cdn.videosdk.live/website-resources/docs-resources/session_stats.png)


---

---
title: Understanding Call Quality | Video SDK
hide_title: true
hide_table_of_contents: false
description: Video SDK and Audio SDK, developers need to implement a token server. This requires efforts on both the front-end and backend.
sidebar_label: Understanding Call Quality
pagination_label: Understanding Call Quality
keywords:
  - audio calling
  - video calling
  - real-time communication
  - collaboration
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: understanding-call-quality
---

# Understanding Call Quality - Flutter

When developing a video call app, customer satisfaction heavily depends on your app's video and audio quality and its fluctuation.

## Call Quality

If we look at the video quality from the user's perspective, a good video quality can be defined as smooth and clear video, along with a crystal clear audio. If the same is viewed from the developer's perspective, a good video quality can be determined as a high resolution, high frame rate video with minimal latency along with a high bitrate audio with minimal audio loss.

## Factors affecting Quality

When it comes to measuring the video and audio quality of a call, there are multiple variables to consider, and the most common factors which affect the video and audio quality are:

### `1. Network Bandwidth`

- Network bandwidth is a measurement of a user's network capability to how large data can be received and send.
- If the bandwidth is low at participant side, he/she is likely to get pixelated or frozen video along with robotic voice or minor breaking in the audio.
- Frequent change in the network providers can also result in high fluctuation of the internet bandwidth, which can also result in poor quality video.

### `2. Latency`

- Latency basically means the time it takes for data to transfer from one machine to another.
- If the meeting is hosted in `Ohio` region, and users are joining from `Singapore` region, so this will create long delay for data to transfer from one machine to another, thus you should pick a server according to your user base.
- In VideoSDK you can set the server during creation of Meeting/Room.

### `3. CPU Usage`

- CPU Usage is an also quite determining factor as all the audio and video streams which are going out and coming in will have to encoded or decoded which will require a significant amount of computation.
- The high the resolution and frame rate of the videos, the larger would be the computation required, which can be a reason for the bottleneck of delivering a good quality video.
- If the CPU is being consumed heavily, it can also result in a choppy or robotic audio.

### `4. Camera and Mic Quality`

- The camera and microphone should capture good quality of streams so that remote user doesn't get low quality stream even if he/she has good network bandwidth

## Identifying the Quality Issues

In order to identify quality issues, VideoSDK collects multiple audio and video related metrics which can help in pinpointing the quality issues. Let's have a look at those metrics and understand what the indicates.

### `1. Resolutions and Framerates`

- Resolution and frame rate are key metrics for video quality in a video call app. Resolution refers to the number of pixels in a video image, while frame rate refers to the number of frames displayed per second.

- Higher resolutions and frame rates can provide better video quality, but they also require more bandwidth and processing power. It's important to optimize this metrics for the devices and network conditions of your users.

- For example, if most of your users are on mobile devices, a lower resolution and frame rate may be more appropriate to ensure smooth playback and minimize bandwidth usage.

- If most of your users are on mobile and desktop devices, having higher resolution for desktop and mid-resolutions for mobile devices can help in improving the performance and quality as we will be saving the bandwidth on the mobile end.

### `2. Bitrate`

- Bitrate is the number of bits per second send or received during the transmission of audio or video streams. Bitrate can be a key parameter to determine the quality of the audio or video streams, as it should be fine-tuned for each resolution to achieve the best match of performance and bandwidth utilization.

- If the users are having excellent network conditions, higher bitrate can result in much better video quality but on the other hand, having very high bitrates on the mobile devices can result in heating issues due to high computation required to encode and decode the videos.

##### Example

We joined using the same phone **(iPhone 14)**, but the resolution and bitrate were different, first participant having resolution **`1280x720`** with bitrate **`1442 kbps`** and second participant having resolution **`960x540`** with bitrate **`642 kbps`**, so as we can see both participants' video appeared to be of equal quality even though resolution and bitrate are different.

![resolution-and-bitrate](/img/resolution-and-bitrate.png)

### `3. Packet Loss`

- Packet loss is a metric that indicates how many data packets are lost during transmission from the sender to the receiver. Packet loss can occur due to network congestion, hardware or software issues, or network latency. Higher packet loss can result in poor video and audio quality, as the missing packets can cause gaps or distortions in the media stream.

import ReactPlayer from 'react-player'

<div style={{textAlign: 'center'}}>

<ReactPlayer autoplay muted loop playing url='/video/packet-loss-burst.mp4' width={"100%"}/>

</div>

### `4. Jitter`

- The audio and video packets are sent out at random intervals over a specified time frame as they are being sent between the server and client. Nevertheless, jitter is produced when there is a variation in transmitting or receiving this data packets as a result of a faulty network connection.

- When data packets delay while being transmitted to the participant, usually because the network is busy. They'll display as pixelated video on a video call or sound choppy, distorted, or robotic on a voice call as they arrive. They'll arrive at random intervals, creating jitter.

### `5. Round Trip Time (Latency)`

- Round trip time is the amount of time required to transmit the data packets to send or receive from the server. If the servers are located very far from the user's location, they can observe a high latency (delay).

- With VideoSDK, this factor is taken care of as we automatically choose the nearest available server for participants. But if you are geofencing to a certain region, you should make sure that you choose the server which will be nearest to your users.

<center>

![resolution-and-bitrate](/img/rtt.png)

</center>

## Checking Realtime Statistics

VideoSDK provides methods to check the realtime statistics of the audio and video of all the participants.

### `getVideoStats()`

- `getVideoStats()` returns an array of object containing the different quality parameters for video stream which can be accessed through the `useParticipant` hook.

- This objects will have values for the specific participant's video stream resolution, frame rate, bitrate, jitter, round trip time, and packet loss.

<div style={{textAlign: 'center'}}>

<ReactPlayer autoplay muted loop playing url='/video/realtime-stats.mp4' width={"100%"}/>

</div>

### `getAudioStats()`

- `getAudioStats()` returns an array of object containing the different quality parameters for audio stream which can be accessed through the `useParticipant` hook.

- This objects will have values for the specific participant's audio stream bitrate, jitter, round trip time and packet loss.

### `getShareStats()`

- `getShareStats()` returns an array of object containing the different quality parameters for screen share stream which can be accessed through the `useParticipant` hook.

- This objects will have values for the specific participant's screen share stream resolution, frame rate, bitrate, jitter, round trip time, and packet loss.

:::note
To show the popup dialog for the participant's realtime stats, you can [refer to this component](https://github.com/videosdk-live/videosdk-rtc-flutter-sdk-example/blob/main/lib/widgets/common/stats/call_stats_bottom_sheet.dart).
:::

## Quality analysis Graphs

For all the sessions taken using the VideoSDK, you can find the quality analysis graphs from the [VideoSDK Dashboard](https://app.videosdk.live/meetings/sessions) which can help you visualize the data you are seeing in realtime and identify the spikes of a few parameters happing during call which can help figure out the reason for the quality issue.

![quality analysis](/img/quality-analysis.png)

## API Reference

The API references for all the methods and events utilised in this guide are provided below.

- [getVideoStats()](/flutter/api/sdk-reference/participant-class/methods#getvideostats)
- [getAudioStats()](/flutter/api/sdk-reference/participant-class/methods#getaudiostats)
- [getShareStats()](/flutter/api/sdk-reference/participant-class/methods#getsharestats)


---

---
sidebar_label: Virtual Background(BETA)
pagination_label: Virtual Background(BETA)
---

# Virtual Background(BETA) - Flutter

Virtual backgrounds let you replace your real background during video calls or meetings with a digital image or video. This can be useful for:

- Privacy: Hide your messy room or anything you don't want others to see.

- Focus: Minimize distractions and keep the focus on the conversation.

- Fun: Liven up the call with a cool background theme.

:::note

Virtual background is currently in BETA and may not perform optimally on certain devices or with custom tracks that have high resolutions.

:::

<center>
<img src='https://cdn.videosdk.live/website-resources/docs-resources/virtual-background-ios.jpg' style={{height: '400px'}}/>
</center>

## Virtual Background using `VideoSDKMediaEffects` plugin

The `VideoSDKMediaEffects` plugin enables the integration of sophisticated virtual background effects within your video applications. By leveraging this plugin, users can replace their physical backgrounds with custom images or dynamic video backdrops, creating a more immersive and engaging experience. 

:::info

- The Virtual Background methods from the `VideoSDKMediaEffects` plugin are supported only on Android and iOS devices.
- The Virtual Background feature in VideoSDK can be utilized regardless of the meeting environment, including the pre-call screen.

:::

### Install the plugin 

- Install the `VideoSDKMediaEffects` plugin using the below-mentioned flutter command. Make sure you are in your flutter app directory before you run this command.

```js
$ flutter pub add videosdk_media_effects
```

### Apply Virtual Background

- The `applyVirtualBackground()` method from the `VideoSDKMediaEffects` plugin allows users to dynamically change the video background during a live session. By passing a URI of the desired background image, this method seamlessly integrates the virtual background into the video stream.

### Change Virtual Background

- The `changeVirtualBackground()` method from the `VideoSDKMediaEffects` plugin enables users to effortlessly switch their current virtual background to a new image. This functionality allows for dynamic customization and enhances the user's video experience by providing the ability to update their background on the fly. By passing a URI of the new background image, this method seamlessly integrates the new virtual background into the video stream.

### Remove Virtual Background

- The `removeVirtualBackground()` method from the `VideoSDKMediaEffects` plugin provides users with a convenient way to revert their video background to its original state, removing any previously applied virtual background. This functionality ensures flexibility for users to switch between virtual and real backgrounds as needed.

**Example Code:**


```js

import 'package:flutter/material.dart';
import 'package:videosdk/videosdk.dart';
//Import the plugin
import 'package:videosdk_media_effects/videosdk_media_effects.dart';

class MeetingScreen extends StatefulWidget {
  //Existing configuration
}

class _MeetingScreenState extends State<MeetingScreen> {
  late Room _room;

  @override
  void initState() {
    //highlight-next-line
    //Existing configuration
  }

  @override
  Widget build(BuildContext context) {
    return Column(
      children:[
        //highlight-start
        //To Apply Virtual Background
        ElevatedButton(
          onPressed:(){
            Uri backgroundImageURI = Uri.parse("https://cdn.videosdk.live/virtual-background/cloud.jpeg");
            VideosdkMediaEffects.applyVirtualBackground(backgroundSource: backgroundImageURI);
          },
          child: const Text("Apply Virtual Background"),
        ),
        //To Change Virtual Background 
        ElevatedButton(
          onPressed:(){
            Uri newBackgroundImageURI = Uri.parse("https://cdn.videosdk.live/virtual-background/san-fran.jpeg");
            VideosdkMediaEffects.changeVirtualBackground(backgroundSource: newBackgroundImageURI);
          },
          child: const Text("Change Virtual Background"),
        ),
        //To Remove Virtual Background
        ElevatedButton(
          onPressed:(){
            VideosdkMediaEffects.removeVirtualBackground();
          },
          child: const Text("Remove Virtual Background"),
        ),
    //highlight-end
      ]
    );
  }
}
```

## API Reference

The API references for all the methods utilized in this guide are provided below.

- [applyVirtualBackground()](/flutter/api/sdk-reference/videosdkmediaeffects-plugin#applyvirtualbackground)
- [changeVirtualBackground()](/flutter/api/sdk-reference/videosdkmediaeffects-plugin#changevirtualbackground)
- [removeVirtualBackground()](/flutter/api/sdk-reference/videosdkmediaeffects-plugin#removevirtualbackground)



---

---
title: Run a sample HLS Flutter Project - Video SDK Docs
hide_title: true
hide_table_of_contents: false
description: Create customizable real-time video & audio calling applications with Flutter SDK with Video SDK add live Video & Audio conferencing to your applications.
sidebar_label: "Run Http Live Streaming Project"
pagination_label: "Run Http Live Streaming Project"
keywords:
  - flutter sdk
  - dart sdk
  - sample project
  - flutter app
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: run-a-sample-hls-project
---

# Run a Sample HLS Project - Flutter

Video SDK provides open-source sample project [videosdk-hls-flutter-sdk-example](https://github.com/videosdk-live/videosdk-hls-flutter-sdk-example) on Github. This document introduces how to run this project.

### Prerequisites

- If your target platform is iOS, your development environment must meet the following requirements:
  - Flutter 2.0 or later
  - Dart 2.12.0 or later
  - macOS
  - Xcode (Latest version recommended)
- If your target platform is Android, your development environment must meet the following requirements:
  - Flutter 2.0 or later
  - Dart 2.12.0 or later
  - macOS or Windows
  - Android Studio (Latest version recommended)
- If your target platform is iOS, you need a real iOS device.
- If your target platform is Android, you need an Android simulator or a real Android device.
- Valid Video SDK [Account](https://app.videosdk.live/)

import APISecret from '../../../mdx/introduction/\_api-key.mdx';

<APISecret title="Get your API key and Secret key" />

s

### Step 1: Clone the sample project

Clone the repository to your local environment.

```js
$ git clone https://github.com/videosdk-live/videosdk-hls-flutter-sdk-example.git
```

### Step 2: Copy the .env.example file to .env file.

Open your favorite code editor and copy `.env.example` to `.env` file.

```bash
$ cp .env.example .env
```

### Step 3: Modify .env file

Paste earlier generated temporary token here.

```js title=".env"
AUTH_TOKEN = "TEMPORARY-TOKEN";
```

### Step 4: Install the dependencies

Install all the dependencies to run the project.

```js
flutter pub get
```

### Step 4: Run the sample app

Bingo, it's time to push the launch button.

```js
flutter run
```


---

---
title: Run the ILS Sample Flutter Project - Video SDK Docs
hide_title: true
hide_table_of_contents: false
description: Create customizable real-time video & audio calling applications with Flutter SDK with Video SDK add live Video & Audio conferencing to your applications.
sidebar_label: Run Interactive Live Streaming Project
pagination_label: Run Interactive Live Streaming Project
keywords:
  - flutter sdk
  - dart sdk
  - sample project
  - flutter app
  - Interactive Live Streaming Flutter sdk
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: run-a-sample-ils-project
---

# Run Interactive Live Streaming Project - Flutter

Video SDK provides open-source sample project [videosdk-ils-flutter-sdk-example](https://github.com/videosdk-live/videosdk-ils-flutter-sdk-example) on Github. This document introduces how to run this project.

## Prerequisites

- If your target platform is iOS, your development environment must meet the following requirements:
  - Flutter 2.0 or later
  - Dart 2.12.0 or later
  - macOS
  - Xcode (Latest version recommended)
- If your target platform is Android, your development environment must meet the following requirements:
  - Flutter 2.0 or later
  - Dart 2.12.0 or later
  - macOS or Windows
  - Android Studio (Latest version recommended)
- If your target platform is iOS, you need a real iOS device.
- If your target platform is Android, you need an Android simulator or a real Android device.
- Valid Video SDK [Account](https://app.videosdk.live/)

import APISecret from '../../../mdx/introduction/\_api-key.mdx';

<APISecret title="Get your API key and Secret key" />

### Step 1: Clone the sample project

Clone the repository to your local environment.

```js
$ git clone https://github.com/videosdk-live/videosdk-ils-flutter-sdk-example
```

After that change directory to the project folder:

```
cd VideoSDK-ILS-Flutter-Example
```

### Step 2: Install the dependencies

Install all the Flutter dependencies

```js
flutter clean

flutter pub get
```

### Step 3: Modify .env

Open your favorite code editor and add VideoSDK `token` in it.

```js title=".env"
AUTH_TOKEN = "TEMPORARY-TOKEN";
```

### Step 4: Run the sample app

Run the Flutter app with

```js
flutter run
```


---

---
title: Run a sample Flutter Project - Video SDK Docs
hide_title: true
hide_table_of_contents: false
description: Create customizable real-time video & audio calling applications with Flutter SDK with Video SDK add live Video & Audio conferencing to your applications.
sidebar_label: "Run Audio & Video Call Project"
pagination_label: "Run Audio & Video Call Project"
keywords:
  - flutter sdk
  - dart sdk
  - sample project
  - flutter app
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: run-a-sample-flutter-project
---

# Run Audio & Video Call Project - Flutter

Video SDK provides open-source sample project [videosdk-rtc-flutter-sdk-example](https://github.com/videosdk-live/videosdk-rtc-flutter-sdk-example) on Github. This document introduces how to run this project.

### Prerequisites

- If your target platform is iOS, your development environment must meet the following requirements:
  - Flutter 2.0 or later
  - Dart 2.12.0 or later
  - macOS
  - Xcode (Latest version recommended)
- If your target platform is Android, your development environment must meet the following requirements:
  - Flutter 2.0 or later
  - Dart 2.12.0 or later
  - macOS or Windows
  - Android Studio (Latest version recommended)
- If your target platform is iOS, you need a real iOS device.
- If your target platform is Android, you need an Android simulator or a real Android device.
- Valid Video SDK [Account](https://app.videosdk.live/)

import APISecret from '../../../mdx/introduction/\_api-key.mdx';

<APISecret title="Get your API key and Secret key" />

### Step 1: Clone the sample project

Clone the repository to your local environment.

```js
$ git clone https://github.com/videosdk-live/videosdk-rtc-flutter-sdk-example.git
```

### Step 2: Copy the .env.example file to .env file.

Open your favorite code editor and copy `.env.example` to `.env` file.

```js
$ cp .env.example .env
```

### Step 3: Modify .env file

Paste earlier generated temporary token here.

```js title=".env"
AUTH_TOKEN = "TEMPORARY-TOKEN";
```

### Step 4: Install the dependencies

Install all the dependencies to run the project.

```js
flutter pub get
```

### Step 4: Run the sample app

Bingo, it's time to push the launch button.

```js
flutter run
```


---

---
title: Just Click Setup - Testing Token Server | Video SDK
hide_title: true
hide_table_of_contents: false
description: Video SDK and Audio SDK, developers need to implement a token server. This requires efforts on both the front-end and backend.
sidebar_label: Authentication and Tokens
pagination_label: Authentication and Tokens
keywords:
  - audio calling
  - video calling
  - real-time communication
  - collaboration
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: server-setup
---

import NoIndex from '../../../mdx/\_no-index.mdx';
import ServerSetup from '../../../mdx/introduction/\_server-setup.mdx';

<NoIndex/>
<ServerSetup />


---

---
title: Initialise Meeting | Video SDK
hide_title: true
hide_table_of_contents: false
description: Video SDK and Audio SDK, developers need to implement a token server. This requires efforts on both the front-end and backend.
sidebar_label: Initialise Meeting
pagination_label: Initialise Meeting
keywords:
  - audio calling
  - video calling
  - real-time communication
  - collaboration
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: initialise-meeting
---

# Initialise Meeting - Flutter

To configure a VideoSDK meeting you require two things, first the `token` which will be used for **Authentication** purpose and a `meetingId` which will be used to specify where a participant will join. Let's see each of the steps closely.

### Generating Token

You can generate a `token` in two ways:

1. **`Temporary Token`** : You can visit [Dashboard's API Key section](https://app.videosdk.live/api-keys) and generate the temporary token from there.

2. **`Server`** : You can setup **JWT** in backend and make an API call to get the token from your server.

To learn more about **Authentication** and token in detail you can follow [this guide](../authentication-and-tokens).

```js
// With Temporary Token
Future<String> getToken() async {
  // Update the token here from the VideoSDK dashboard
  // highlight-next-line
  let token = "YOUR_TOKEN";
  return token;
};

// Server
// API call to create meeting
Future<String> getToken(String token) async {
  final http.Response httpResponse = await http.post(
    //highlight-start
    //Using the VideoSDK API Endpoint
    Uri.parse('http://localhost:8080/get-token'),
    //highlight-end
  );

  //Destructuring the roomId from the response
  return json.decode(httpResponse.body)['token'];
}
```

### Generating Meeting Id

With the token ready, we can get the `meetingId` from the [VideoSDK's rooms API](/api-reference/realtime-communication/create-room).

```js
// API call to create meeting
Future<String> createMeeting(String token) async {
  final http.Response httpResponse = await http.post(
    //highlight-start
    //Using the VideoSDK API Endpoint
    Uri.parse('https://api.videosdk.live/v2/rooms'),
    //Passing the token in headers
    headers: {'Authorization': token},
    //highlight-end
  );

  //Destructuring the roomId from the response
  return json.decode(httpResponse.body)['roomId'];
}
```

### Initialization of Meeting

We can initialize a new meeting using the `createRoom` method of the `VideoSDK` class. `createRoom` method returns a `Room` object, which will be configured using the provided `token`, `meetingId`, `participantId` and other parameters.

#### createRoom()

Let's take a deeper look at the available configuration options first.

```js
Room room = VideoSDK.createRoom(
  roomId: "Meeting-d",
  token: "Token",
  displayName: "<Name-of-participant>",
  micEnabled: "<Flag-to-enable-mic>",,
  camEnabled: "<Flag-to-enable-webcam>",
  participantId: "Id-of-participant", // optional, default: SDK will generate
);
```

- **`roomId`** :

  - roomId is unique identifiers that allow participants to join a specific meeting or room.
  - It will be in the format of `xxx-yyy-zzz` and will be generated using the [VideoSDK's Room API](/api-reference/realtime-communication/create-room).

- **`displayName`**:

  - This will represent the name of the participant in the meeting.
  - It will accept `String`type value.

- **`micEnabled`**:

  - This is a `boolean` flag, indicating whether a participant's microphone will be automatically enabled when they join a meeting.

- **`camEnabled`**:

  - This is a `boolean` flag, indicating whether a participant's webcam will be automatically enabled when they join a meeting.

- **`participantId`**:

  - This will be the unique identifier for the participant inside the meeting.

    - It can be used to specify the **unique identifier** which can be linked with **your own database** service.
    - It has to be of `String` type.
    - This is an `OPTIONAL` parameter. By default VideoSDK will generate unique id for each participant.

:::caution
You must ensure that the `participantId` is not repeated in the same meeting or room, It will enable VideoSDK to eliminate any participant respect to that `participantId`.
:::

To know more about other properties, you can follow [our API Reference](../../../api/sdk-reference/videosdk-class/methods).

With all the configuration options explained, here is how you will be using the `MeetingProvider`.

```js
import 'package:flutter/material.dart';
import 'package:videosdk/videosdk.dart';

class MeetingScreen extends StatefulWidget {
  final String meetingId;
  final String token;

  const MeetingScreen(
      {super.key, required this.meetingId, required this.token});

  @override
  State<MeetingScreen> createState() => _MeetingScreenState();
}

class _MeetingScreenState extends State<MeetingScreen> {
  late Room _room;

  @override
  void initState() {
    //highlight-start
    //Creating a new Room based on the passed meetingId and token from the Joining Screen
    // create room
    _room = VideoSDK.createRoom(
      roomId: widget.meetingId,
      token: widget.token,
      displayName: "John Doe",
      micEnabled: true,
      camEnabled: true,
      defaultCameraIndex:
          1, // Index of MediaDevices will be used to set default camera
    );
    //highlight-end
    super.initState();
  }

  @override
  Widget build(BuildContext context) {
    return YourMeetingWidget();
  }
}

```

## API Reference

The API references for all the methods utilized in this guide are provided below.

- [createRoom](/flutter/api/sdk-reference/videosdk-class/methods#createroom)


---

---
title: Join Meeting | Video SDK
hide_title: true
hide_table_of_contents: false
description: Video SDK and Audio SDK, developers need to implement a token server. This requires efforts on both the front-end and backend.
sidebar_label: Join Meeting
pagination_label: Join Meeting
keywords:
  - audio calling
  - video calling
  - real-time communication
  - collaboration
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: join-meeting
---

# Join Meeting - Flutter

### Overview

Before joining the meeting, it has to be initialized. If you have not initialized a meeting/room yet, you can [follow the guide here.](./initialise-meeting)

### `join()`

- To join the meeting you can call the `join()` on the created `Room` object.

```js
import 'package:flutter/material.dart';
import 'package:videosdk/videosdk.dart';

class MeetingScreen extends StatefulWidget {
  ...
}

class _MeetingScreenState extends State<MeetingScreen> {
  late Room _room;

  @override
  void initState() {
    //Creating a new Room based on the passed meetingId and token from the Joining Screen
    // create room
    _room = VideoSDK.createRoom(
      roomId: widget.meetingId,
      token: widget.token,
      displayName: "John Doe",
      micEnabled: true,
      camEnabled: true,
      defaultCameraIndex:
          1, // Index of MediaDevices will be used to set default camera
    );

    //highlight-start
    //Calling Join after the room object is created
    _room.join()
    //highlight-end

    super.initState();
  }

  @override
  Widget build(BuildContext context) {
    return YourMeetingWidget();
  }
}

```

### Events associated with Join

Following callbacks are received when a participant is successfully joined.

- [Local Participant](../concept-and-architecture#2-participant) will receive a [`Events.roomJoined`](/flutter/api/sdk-reference/room-class/events#roomjoined) event, when successfully joined.
- [Remote Participant](../concept-and-architecture#2-participant) will receive a [`Events.participantJoined`](/flutter/api/sdk-reference/room-class/events#participantjoined) event with the newly joined `Participant` object from the event callback.

```js
import 'package:flutter/material.dart';
import 'package:videosdk/videosdk.dart';

class MeetingScreen extends StatefulWidget {
  ...
}

class _MeetingScreenState extends State<MeetingScreen> {
  late Room _room;

  @override
  void initState() {
    //highlight-next-line
    ...

    setupRoomEventListener();
  }

  @override
  Widget build(BuildContext context) {
    return YourMeetingWidget();
  }

  //highlight-start
  void setupRoomEventListener() {
    room.on(Events.roomJoined, (){
      // Room/Meeting joined Successfully
    });
    room.on(Events.participantJoined, (Participant participant){
      // New Participant joined the meeting
    });
  }
  //highlight-end
}
```

#### API Reference

The API references for all the methods and events utilized in this guide are provided below.

- [join()](/react/api/sdk-reference/use-meeting/methods#join)
- [roomJoined](/flutter/api/sdk-reference/room-class/events#roomjoined)
- [participantJoined](/flutter/api/sdk-reference/room-class/events#participantjoined)


---

---
title: Leave or End Meeting | Video SDK
hide_title: true
hide_table_of_contents: false
description: Video SDK and Audio SDK, developers need to implement a token server. This requires efforts on both the front-end and backend.
sidebar_label: Leave or End Meeting
pagination_label: Leave or End Meeting
keywords:
  - audio calling
  - video calling
  - real-time communication
  - collaboration
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: leave-end-meeting
---

# Leave or End Meeting - Flutter

Participant can choose to leave the meeting without removing all the other participants. This is typically done by `Leave Meeting`.

Alternatively, if the participant is the host or the last person remaining in the session, they can choose `End Meeting` by removing all other participants, which will end the session for everyone.

### `leave()`

To leave the meeting without removing all the participant you need to call `leave()` on the `Room` object.

### `end()`

To leave the meeting by removing all the participant you need to call `end()` on the `Room` object.

#### Example

```jsx
import 'package:flutter/material.dart';
import 'package:videosdk/videosdk.dart';

class MeetingScreen extends StatefulWidget {
  ...
}

class _MeetingScreenState extends State<MeetingScreen> {
  late Room _room;

  @override
  void initState() {
    //highlight-next-line
    ...
  }

  @override
  Widget build(BuildContext context) {
    return Column(
      children:[
        //highlight-start
        ElevatedButton(
          onPressed:(){
            _room.leave();
          },
          child: const Text("Leave Meeting"),
        ),
        ElevatedButton(
          onPressed:(){
            _room.end();
          },
          child: const Text("End Meeting"),
        ),
    //highlight-end
      ]
    );
  }
}
```

:::tip
You should call the `leave()` method on the unmount of your main meeting widget so that meeting is left once the widget is unmounted.
:::

### Events associated with Leave

Following callbacks are received when a participant leaves the meeting.

- [Local Participant](../concept-and-architecture#2-participant) will receive a callback on [`Events.roomLeft`](/flutter/api/sdk-reference/room-class/events#roomleft).
- All [remote participants](../concept-and-architecture#2-participant) will receive a callback [`Events.participantLeft`](/flutter/api/sdk-reference/room-class/events#participantleft) with `participantId`.

### Events associated with End

Following callbacks are received when a participant ends the meeting.

- All [remote participants](../concept-and-architecture#2-participant) and local participant will receive a callback on [`Events.roomLeft`](/flutter/api/sdk-reference/room-class/events#participantleft).

```jsx
import 'package:flutter/material.dart';
import 'package:videosdk/videosdk.dart';

class MeetingScreen extends StatefulWidget {
  ...
}

class _MeetingScreenState extends State<MeetingScreen> {
  late Room _room;

  @override
  void initState() {
    //highlight-next-line
    ...

    setupRoomEventListener();
  }

  @override
  Widget build(BuildContext context) {
    return YourMeetingWidget();
  }

  //highlight-start
  void setupRoomEventListener() {
    room.on(Events.roomLeft, (){
      // Room/Meeting left
    });
    room.on(Events.participantLeft, (String participantId){
      // Participant left the meeting
    });
  }
  //highlight-end
}
```

### API Reference

The API references for all the methods and events utilized in this guide are provided below.

- [leave()](/flutter/api/sdk-reference/room-class/methods#leave)
- [end()](/flutter/api/sdk-reference/room-class/methods#end)
- [roomLeft](/flutter/api/sdk-reference/room-class/events#roomleft)
- [participantLeft](/flutter/api/sdk-reference/room-class/events#participantleft)


---

---
title: Precall Setup | Video SDK
hide_title: true
hide_table_of_contents: false
description: The precall feature allows users to configure their audio and video settings,  before starting a video call, ensuring a smooth and tailored communication experience.
sidebar_label: Precall Setup
pagination_label: Precall Setup
keywords:
  - audio calling
  - video calling
  - real-time communication
  - precall
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: precall
---

# Precall Setup - Flutter

Picture this: before diving into the depths of a video call, imagine giving your setup a quick check-up, like a tech-savvy doctor ensuring all systems are a go. That's essentially what a precall experience does- it’s like your extensive debug session before the main code execution—a crucial step in ensuring your app's performance is top-notch.

## **Step-by-Step Guide: Integrating Precall Feature**

### **Step 1: Check Permissions**

- Begin by ensuring that your application has the necessary permissions to access user devices such as cameras, microphones, and speakers.
- Utilize the `checkPermissions()` method of the `VideoSDK` class to verify if permissions are granted.
- To enable checking of microphone and camera permissions on iOS devices, add the following to your `Podfile`:

```js
post_install do |installer|
  installer.pods_project.targets.each do |target|
    flutter_additional_ios_build_settings(target)
    target.build_configurations.each do |config|
    //Add this into your podfile
      config.build_settings['GCC_PREPROCESSOR_DEFINITIONS'] ||= [
        'PERMISSION_CAMERA=1',
        'PERMISSION_MICROPHONE=1',
      ]
    end
  end
end
```

```js
import 'package:videosdk/videosdk.dart';

void checkMediaPermissions() async {
  try {
  //By default both audio and video permissions will be checked.
  Map<String, bool>? checkAudioVideoPermissions = await VideoSDK.checkPermissions();
  //For checking just audio permission.
  Map<String, bool>? checkAudioPermissions = await VideoSDK.checkPermissions(Permissions.audio);
  //For checking just video permission.
  Map<String, bool>? checkVideoPermissions = await VideoSDK.checkPermissions(Permissions.video);
  //For checking both audio and video permissions.
  Map<String, bool>? checkAudioVideoPermissions = await VideoSDK.checkPermissions(Permissions.audio_video);
  } catch (ex) {
    print("Error in checkPermissions()");
  }
  // Output: Map object for both audio and video permission:
  /*
        Map(2)
        0 : {"audio" => true}
            key: "audio"
            value: true
        1 : {"video" => true}
            key: "video"
            value: true
    */
};
```

:::info

- `checkPermissions()` method is not supported on Desktop Applications and Firefox Browser.

:::

- When microphone and camera permissions are blocked, rendering device lists is not possible:

<center>

<img src="https://cdn.videosdk.live/website-resources/docs-resources/flutter_precall_check_permissions.png" />

</center>

### **Step 2: Request Permissions (if necessary)**

- If permissions are not granted, use the `requestPermission()` method of the `VideoSDK` class to prompt users to grant access to their devices.
- To enable requesting of microphone and camera permissions on iOS devices, add the following to your `Podfile`:

```js
post_install do |installer|
  installer.pods_project.targets.each do |target|
    flutter_additional_ios_build_settings(target)
    target.build_configurations.each do |config|
    //Add this into your podfile
      config.build_settings['GCC_PREPROCESSOR_DEFINITIONS'] ||= [
        'PERMISSION_CAMERA=1',
        'PERMISSION_MICROPHONE=1',
      ]
    end
  end
end
```

:::note

In case permissions are blocked by the user, the permission request dialogue cannot be re-rendered programmatically. In such cases, consider providing guidance to users on manually adjusting their permissions.

:::

```js
void requestMediaPermissions() async {
  try {
      //By default both audio and video permissions will be requested.
      Map<String, bool>? reqAudioVideoPermissions = await VideoSDK.requestPermissions();
      //For requesting just audio permission.
      Map<String, bool>? reqAudioPermissions = await VideoSDK.requestPermissions(Permissions.audio);
      //For requesting just video permission.
      Map<String, bool>? reqVideoPermissions = await VideoSDK.requestPermissions(Permissions.video);
      //For requesting both audio and video permissions.
      Map<String, bool>? reqAudioVideoPermissions = await VideoSDK.requestPermissions(Permissions.audio_video);

  } catch (ex) {
    print("Error in requestPermission ");
  }
};
```

:::info

- The `requestPermissions()` method is not supported on Desktop Applications and Firefox Browser.

:::

- Requesting permissions if not already granted:

<center>

<img src="https://cdn.videosdk.live/website-resources/docs-resources/flutter_precall_request_permissions.png" />

</center>

### **Step 3: Render Device List**

- Once you have the necessary permissions, Fetch and render list of available video and audio devices using the `getVideoDevices()` and `getAudioDevices()` methods of the `VideoSDK` class respectively.
- Enable users to select their preferred devices from these lists.

:::note

For iOS devices:

- `EARPIECE` is not supported whenever `WIRED_HEADSET` or `BLUETOOTH` device is connected.
- `WIRED_HEADSET` and `BLUETOOTH` devices are not supported simultaneously. Priority is given to the most recently connected device.

:::

```js

List<AudioDeviceInfo> audioInputDevices = [];
List<AudioDeviceInfo> audioOutputDevices = [];

const getMediaDevices = async () => {
  try {
    //Method to get all available video devices.
    List<VideoDeviceInfo>? videoDevices = await VideoSDK.getVideoDevices();
    //Method to get all available Microphones.
    List<AudioDeviceInfo>? audioDevices = await VideoSDK.getAudioDevices();
    for (AudioDeviceInfo device in audioDevices!) {
      //For Mobile Applications
      if (!kIsWeb) {
        if (Platform.isAndroid || Platform.isIOS) {
          audioOutputDevices.add(device);
        }
      } else {
        //For Web and Desktop Applications
          if (device.kind == 'audioinput') {
            audioInputDevices.add(device);
          } else {
            audioOutputDevices.add(device);
          }
        }
      }
  } catch (err) {
    print("Error in getting audio or video devices");
  }
};
```

- Displaying device lists once permissions are granted:

<center>

<img src="https://cdn.videosdk.live/website-resources/docs-resources/flutter_precall_dropdowns.png" />

</center>

### **Step 4: Handle Device Changes**

- Implement the `deviceChanged` callback of the `VideoSDK` class to dynamically re-render device lists whenever new devices are attached or removed from the system.
- Ensure that users can seamlessly interact with newly connected devices without disruptions.

:::info

- The `deviceChanged` event is not supported in macOS applications.

:::

```js
VideoSDK.on(
  Events.deviceChanged,
  (devices) {
    print("device changed ${devices}");
  },
);
```

### **Step 5: Ensuring the selected devices are used in the Meeting**

- Ensure that all relevant states, such as microphone and camera status (on/off), and selected devices, are passed into the meeting from the precall screen.
- This can be accomplished by passing these crucial states and media streams onto the VideoSDK and Room Methods.
- For the video device, create a custom track with the selected CameraID and pass it to the `createRoom` method.
- For audio devices in web and desktop applications:
  - Use the `switchAudioDevice` method to select the desired audio output device.
  - Use the `changeMic `method to select the desired audio input device once the room is joined.
- For audio devices in mobile applications, use the `switchAudioDevice` method to select both the input and output audio devices.
- By ensuring this integration, users can seamlessly transition from the precall setup to the actual meeting while preserving their preferred settings.

```js
import 'package:flutter/material.dart';
import 'package:videosdk/videosdk.dart';

class MeetingScreen extends StatefulWidget {
  final String meetingId;
  final String token;

  const MeetingScreen(
      {super.key, required this.meetingId, required this.token});

  @override
  State<MeetingScreen> createState() => _MeetingScreenState();
}

class _MeetingScreenState extends State<MeetingScreen> {
  late Room _room;

  @override
  void initState() {
    //Create a custom track with the selectedVideoDevice Id
    CustomTrack? cameraTrack = await VideoSDK.createCameraVideoTrack(
      cameraId: selectedVideoDevice?.deviceId);
    // create room
    _room = VideoSDK.createRoom(
      roomId: widget.meetingId,
      token: widget.token,
      displayName: "John Doe",
      micEnabled: true,
      camEnabled: true,
      customCameraVideoTrack: cameraTrack, //For Video Devices
    );
    registerMeetingEvents(room);
    super.initState();
  }

  //For Audio Devices
void registerMeetingEvents(Room _meeting) {
    // Called when joined in meeting
  _meeting.on(
    Events.roomJoined,
    () {
      //When meeting is joined, call the switchAudioDevice method to switch Audio Output.
      _meeting.switchAudioDevice(widget.selectedAudioOutputDevice!);

      //When meeting is joined, call the changeMic method to switch Audio Input.(Onlyrequired for web and desktop applications)
        if (kIsWeb || Platform.isWindows || Platform.isMacOS) {
          _meeting.changeMic(widget.selectedAudioInputDevice!);
        }
    },
  );
}

  @override
  Widget build(BuildContext context) {
    return YourMeetingWidget();
  }
}
```

By following these step-by-step instructions, you can seamlessly integrate a precall feature into your application, empowering users to optimize their audio and video setup for a superior communication experience.

:::note

You can explore the complete implementation of the Precall feature in the official Flutter SDK example [available here.](https://github.com/videosdk-live/videosdk-rtc-flutter-sdk-example)

:::

## API Reference

The API references for all the methods utilized in this guide are provided below.

- [getVideoDevices](/flutter/api/sdk-reference/videosdk-class/methods#getvideodevices)
- [getAudioDevices](/flutter/api/sdk-reference/videosdk-class/methods#getaudiodevices)
- [deviceChanged](/flutter/api/sdk-reference/videosdk-class/events#devicechanged)
- [checkPermissions](/flutter/api/sdk-reference/videosdk-class/methods#checkpermissions)
- [requestPermissions](/flutter/api/sdk-reference/videosdk-class/methods#requestpermissions)


---

---
title: Sign up for free account Custom Video SDK
hide_title: true
hide_table_of_contents: false
description: Video SDK Sign up. Get started with 10,000 minutes free every month! Programmable Video SDKs and Rest APIs to build up scalable video conferencing applications.
sidebar_label: Get your API key and Secret
pagination_label: Get your API key and Secret
keywords:
  - authentication audio calling
  - authentication video calling
  - authentication real-time communication
  - tokens
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: signup-and-create-api
---

import APISecret from '../../../mdx/introduction/\_api-key.mdx';
import NoIndex from '../../../mdx/\_no-index.mdx';

<NoIndex/>

<APISecret title="Get your API key and Secret key" />


---

---
title: Getting Started with Video & Audio Calling
hide_title: false
hide_table_of_contents: false
description: video & audio calling sdk will help you to integrate video & audio calling in your application.
sidebar_label: Start or Join Room
pagination_label: Getting Started Video & Audio Calling
keywords:
  - audio calling
  - video calling
  - real-time communication
  - collaboration
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: start-or-join-room
---

import NoIndex from '../../../mdx/\_no-index.mdx';

<NoIndex/>

import Mermaid from '@theme/Mermaid';

# Explore video & audio calling

This guide will get you running with the VideoSDK video & audio calling in minutes.

## Overview

At it's core, VideoSDK RTC is a distributed SFU. It enables highly scalable video & audio meetings unlike vanilla webRTC.

VideoSDK enables opportunity to integrate video & audio calling to Web, Android, IOS applications. it provides Programmable SDKs and REST APIs to build up scalable video conferencing applications.

## Terminology

#### **Room**

A Room represents real-time audio, video, and/or screen-share session, and is the basic building block for media sharing among participants.

#### **Participants**

Participants are the client applications that are connected to a Room and shares video & audio media with one another.

#### **Local Participant**

Local Participant producing audio or video stream from the local client's media sources

#### **Streams**

Streams are individual video & audio streams produced by the participants in the room

#### **Active Speaker**

Active Speaker represents the participant who is currently producing highest decibels audio stream (in other words speaking)

#### **Active Presenter**

Active Presenter is the participant who is currently sharing his/her screen as a video stream

#### **Main participant**

Main Participant represents the client who shall be displayed on the main screen indicating that he/she is either presenting or speaking

## Architecture

This diagram demonstrates end-to-end flow to implement video & audio calling, record calls and go-live on social media.
<Mermaid chart={`sequenceDiagram Your App Client->>Your App Server: Request to Auth; activate Your App Server; Note right of Your App Server: JWT Auth using Key and Secret; Your App Server-->>Your App Client: Received Token; deactivate Your App Server; Your App Client->>VideoSDK Server: Request for roomId; activate VideoSDK Server; Note right of VideoSDK Server: Generate unique roomId; VideoSDK Server-->>Your App Client: roomId Received; deactivate VideoSDK Server; Your App Client->>VideoSDK Server: Request to Join; activate VideoSDK Server; Note right of VideoSDK Server: Broadcasting to each participants; VideoSDK Server-->>Your App Client: Room Joined; deactivate VideoSDK Server; Your App Client-)VideoSDK Server: Subscribe to Events; VideoSDK Server--)Your App Client: Get notified on Updates; Your App Client->>VideoSDK Server: Request to Go Live via RTMP; Note right of VideoSDK Server: Composing Real-time Stream; VideoSDK Server--)Social Media: Push RTMP Stream; Your App Client->>VideoSDK Server: Request to Start Recording; Note right of VideoSDK Server: Recording Started; VideoSDK Server-->>Your App Client: Trigger Webhook to Start Recording; Your App Client->>VideoSDK Server: Request to Leave Room; activate VideoSDK Server; Note right of VideoSDK Server: Participant Left; VideoSDK Server-->>Your App Client: Room Left; deactivate VideoSDK Server; Your App Client->>VideoSDK Server: Request to End Room; activate VideoSDK Server; Note right of VideoSDK Server: Kick off all the Participants; VideoSDK Server--)Social Media: End Pushing RTMP Stream; VideoSDK Server-->>Your App Client: Trigger Webhook to Stop Recording; VideoSDK Server-->>Your App Client: Room End; deactivate VideoSDK Server;`}/>


---

---
title: Supported Browser and Device OS
hide_title: false
hide_table_of_contents: false
description: video & audio calling sdk will help you to integrate video & audio calling in your application.
sidebar_label: Supported Browsers and Device OS
pagination_label: Supported Browsers and Device OS
keywords:
  - audio calling
  - video calling
  - real-time communication
  - collaboration
  - supported browsers and device os
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: supported-browser-and-device-os
---

import NoIndex from '../../../mdx/\_no-index.mdx';

<NoIndex/>

# Supported Browsers and Device OS

:::note
The following browser and device OS versions represent the minimum required versions to ensure full support for the listed features.
:::

import SupportList from '../../../src/theme/SupportedListContainer'

<SupportList isSDKListInclude={false} isSDKListRenderSeperately={true} isFlutterSDK={true}  />

<br />

# Supported ABIs

import SupportABIList from '../../../src/theme/SupportedABIContainerFlutter'

<SupportABIList />


---

---
title: Install Video & Audio Calling SDK
hide_title: false
hide_table_of_contents: false
description: VideoSDK supports many programmable interfaces such as javascript, react, react native, android, ios and flutter.
sidebar_label: Supported platforms
pagination_label: Supported platforms
keywords:
  - audio calling
  - video calling
  - real-time communication
  - collaboration
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: supported-platforms
---

import NoIndex from '../../../mdx/\_no-index.mdx';

<NoIndex/>

# Supported platforms

## For video & audio calling SDK

This guide will follow installation guide for all the VideoSDK for Video & Audio Calling. Follow the below guide to install VideoSDK RTC in your website or App

## Web SDK

1. [JavaScript](/javascript/guide/video-and-audio-calling-api-sdk/getting-started)
2. [React JS](/react/guide/video-and-audio-calling-api-sdk/concept-and-architecture)

## Mobile SDK

1. [React Native Android](/react-native/guide/video-and-audio-calling-api-sdk/react-native-android-sdk)
2. [React Native IOS](/react-native/guide/video-and-audio-calling-api-sdk/react-native-ios-sdk)
3. [Android](/android/guide/video-and-audio-calling-api-sdk/concept-and-architecture)
4. [IOS](/ios/guide/video-and-audio-calling-api-sdk/concept-and-architecture)
5. [Flutter](/flutter/guide/video-and-audio-calling-api-sdk/getting-started)


---

---
title: Post Transcription & Summary - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: Post Transcription features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add support for post transcription or captioning to your applications.
sidebar_label: Post Transcription & Summary
pagination_label: Post Transcription & Summary
keywords:
  - Start Post Transcription meeting
  - Stop Post Transcription meeting
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: post-transcribe-meeting
---

# Post Transcription & Summary - Flutter

This guide will walk you through the necessary steps to enable post-transcription functionality in your application, allowing users to access transcriptions of recorded meetings.

Moreover, VideoSDK offers flexibility in configuring post-time transcription, allowing you to set up webhooks for this purpose.

## Integrating Post Transcription Feature

![alt text](/img/transcription/post-transcription.png)

In the image above, the recording begins with transcription and summary features turned on. This triggers a webhook call for the start of recording. When the recording stops, another webhook is activated. After the recording, our transcriber starts transcribing, which in turn activates a webhook. Once the transcription is finished, it's sent to the summarizer for summary generation, and then another webhook is triggered.

### **Step 1: Configure Post Transcription & Summary**

- In this step, we set up the configuration for post transcription and summary generation. We define the webhook URL where the webhooks will be received.

```js
// Webhook URL where, webhooks are received
const String webhookUrl = "https://webhook.your-api-server.com";

Map<String, dynamic> config = { 
  'layout': {
    'type': 'GRID',
    'priority': 'SPEAKER',
    'gridSize': 4,
  },
  'theme': "LIGHT",
  "mode": "video-and-audio",
};

PostTranscriptionConfig postTranscriptionConfig = PostTranscriptionConfig(
  enabled: true,
  modelId: "raman_v1",
  summaryConfig: SummaryConfig(
    enabled: true,
    prompt: "Write summary in sections like Title, Agenda, Speakers, Action Items, Outlines, Notes and Summary"
  ),
);
```

### **Step 2: Start Recording with Transcription Configuration**

- Once the configuration is set, we initiate the recording process for the meeting, incorporating the transcription configuration we defined earlier.

```js
// Start Recording
room.startRecording(
  webhookUrl: webhookUrl,
  config: config,
  postTranscriptionConfig: postTranscriptionConfig
);
```

### **Step 3: Stop Recording**

- When the meeting concludes or recording is no longer needed, we stop the recording process.

```js
// Stop Recording
room.stopRecording();
```

### **Step 4: Fetch Post Transcriptions**

- After the meeting recording is stopped, post transcription and summary data can be obtained using the [Post Transcription API](/api-reference/realtime-communication/fetch-post-transcriptions-summary).

- The API provides information such as the status of transcription, file paths for transcription data in various formats (JSON, SRT, TXT, TSV, VTT), and a summarized text file.

- The transcription document is structured as follows:

```json
{
  "id": "40b0a4ed-9842-40c9-a288-e4b1bf98a90a",
  "status": "completed",
  "roomId": "abc-xyzw-lmno",
  "sessionId": "621497578bea0d0404c35c4c",
  "recordingId": "65d303d6d2c373dfd71b38a2",
  "filePath": "https://cdn.videosdk.live/encoded/videos/dummy.mp4",
  "transcriptionFilePaths": {
    "json": "https://cdn.videosdk.live/transcriptions/dummy/dummy.json",
    "srt": "https://cdn.videosdk.live/transcriptions/dummy/dummy.srt",
    "txt": "https://cdn.videosdk.live/transcriptions/dummy/dummy.txt",
    "tsv": "https://cdn.videosdk.live/transcriptions/dummy/dummy.tsv",
    "vtt": "https://cdn.videosdk.live/transcriptions/dummy/dummy.vtt"
  },
  "summarizedFilePaths": {
    "txt": "https://cdn.videosdk.live/transcriptions/dummy/dummy-summary.txt"
  },
  "userStorage": null,
  "start": "2024-02-27T16:00:36.828Z",
  "end": "2024-02-27T16:01:46.939Z"
}
```

### Example

- The following code snippet allows you to start and stop recording meetings with just a click. When you click the "Start Recording" button, it begins recording the meeting and enables post-transcription, which generates a summary of the meeting's content. Clicking the "Stop Recording" button ends the recording.

```js
import 'package:flutter/material.dart';
import 'package:videosdk/videosdk.dart';

class MeetingScreen extends StatefulWidget {
  ...
}

class _MeetingScreenState extends State<MeetingScreen> {
  late Room _room;

  @override
  void initState() {
    //highlight-next-line
    ...
  }

  @override
  Widget build(BuildContext context) {
    return Column(children: [
      ElevatedButton(
        onPressed: () {
          //highlight-start
          // Configuration for post transcription
          const String webhookUrl = "https://webhook.your-api-server.com";

          Map<String, dynamic> config = {
            'layout': {
              'type': 'GRID',
              'priority': 'SPEAKER',
              'gridSize': 4,
            },
            'theme': "LIGHT",
            "mode": "video-and-audio",
          };

          PostTranscriptionConfig postTranscriptionConfig =
              PostTranscriptionConfig(
            enabled: true,
            modelId: "raman_v1",
            summaryConfig: SummaryConfig(
                enabled: true,
                prompt:
                    "Write summary in sections like Title, Agenda, Speakers, Action Items, Outlines, Notes and Summary"),
          );

          _room.startRecording(
              webhookUrl: webhookUrl,
              config: config,
              postTranscriptionConfig: postTranscriptionConfig);
          //highlight-end
        },
        child: const Text("Start Recording"),
      ),
      ElevatedButton(
        onPressed: () {
          //highlight-start
          // Stop recording
          _room.stopRecording();
          //highlight-end
        },
        child: const Text("Stop recording"),
      ),
    ]);
  }
}

```

:::important

Please be aware that there may be a delay in processing the transcription data after the recording has been stopped. This delay could vary depending on factors such as server load and the duration of the meeting.

:::

### API Reference

The API references for all the methods utilized in this guide are provided below.

- [startRecording()](/flutter/api/sdk-reference/room-class/methods#startrecording)
- [stopRecording()](/flutter/api/sdk-reference/room-class/methods#stoprecording)
- [fetchPostTranscriptions](/api-reference/realtime-communication/fetch-post-transcriptions-summary)


---

---
title: Realtime Transcription - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: Realtime Transcription features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with VideoSDK to add support for realtime transcription or captioning to your applications.
sidebar_label: Realtime Transcription
pagination_label: Realtime Transcription
keywords:
  - Start Realtime Transcription meeting
  - Stop Realtime Transcription meeting
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: realtime-transcribe-meeting
---

# Realtime Transcription - Flutter

Realtime transcription allows you to transcribe audio content into text in real-time during a session. This guide will walk you through using the `startTranscription()` and `stopTranscription()` functions to manage realtime transcription in your application.

Moreover, VideoSDK offers flexibility in configuring real-time transcription, allowing you to set up webhooks for this purpose.

## Integrating Realtime Transcription Feature

![alt text](/img/transcription/realtime-transcription.png)

The above image represents,

1. **Start Transcription:** The SDK Client initiates real-time transcription using the `startTranscription` method.

2. **Resource Acquisition:** VideoSDK server requests necessary resources from transcription service.

   - If the request is denied, the server sends a `transcription-failed` event to the SDK Client.
   - If the request is successful, the server sends a `transcription-started` event to the client, indicating that transcription has begun.

3. **Transcription Data:** As transcription progresses, the client receives `transcription-text` event with data such as the text itself, participant ID, and timestamp.

4. **Stop Transcription:** When the client decides to stop transcription, it informs the VideoSDK server to release resources.
   - The server then sends a `transcription-stopped` event to confirm that transcription has ended and resources are released.

### **Step 1: Configure Realtime Transcription**

- In this step, we set up the configuration for realtime transcription. We define the webhook URL where the webhooks will be received.

```js
// highlight-next-line
// Realtime Transcription Configuration
TranscriptionConfig transcriptionConfig = TranscriptionConfig(
    webhookUrl: "https://webhook.your-api-server.com",
    summaryConfig: SummaryConfig(
        enabled: true,
        prompt:
            "Write summary in sections like Title, Agenda, Speakers, Action Items, Outlines, Notes and Summary"));

```

### **Step 2: Listen for the transcription events**

- Here, we configure the callback methods for transcription events.

```js
// Listen for transcription state changed event
room.on(Events.transcriptionStateChanged, (Map<String, dynamic> data) {
    var status = data['status'];
    var id = data['id'];

    if (TranscriptionState.TRANSCRIPTION_STARTING == status) {
        print(
            "onTranscriptionStateChanged, Realtime Transcription is starting, ID: $id");
    } else if (TranscriptionState.TRANSCRIPTION_STARTED == status) {
        print(
            "onTranscriptionStateChanged, Realtime Transcription has started, ID: $id");
    } else if (TranscriptionState.TRANSCRIPTION_STOPPING == status) {
        print(
            "onTranscriptionStateChanged, Realtime Transcription is stopping, ID: $id");
    } else if (TranscriptionState.TRANSCRIPTION_STOPPED == status) {
        print(
            "onTranscriptionStateChanged, Realtime Transcription has stopped, ID: $id");
    } else {
        print(
            "onTranscriptionStateChanged, Realtime Transcription status $status, ID: $id");
    }
});

// Listen for transcription text event
room.on(Events.transcriptionText, (TranscriptionText transcriptionText) {
  print("TranscriptionText : ${transcriptionText.participantName} (${transcriptionText.participantId}) :  ${transcriptionText.text} ${transcriptionText.timestamp}");

});
```

### **Step 3: Start realtime transcription**

- Initiate the realtime transcription using the `startTranscription()` method.

```js
// Starts realtime transcription
room.startTranscription(transcriptionConfig: transcriptionConfig);
```

### **Step 4: Stop realtime transcription**

- Terminate the realtime transcription using the `stopTranscription() `method.

```js
// Stops realtime transcription
room.stopTranscription();
```

:::important

You can access a summary of your realtime transcription using the **[<u>Fetch Realtime Transcription API</u>](/api-reference/realtime-communication/fetch-a-realtime-transcription)**.

:::

### Example

- The following code snippet allows you to start and stop realtime transcription with just a click. When you click the "Start Realtime Transcription" button, it begins realtime transcription. Clicking the "Stop Realtime Transcription" button ends the realtime transcription.

```js
import 'dart:developer';

import 'package:flutter/material.dart';
import 'package:videosdk/videosdk.dart';

class MeetingScreen extends StatefulWidget {
  ...
}

class _MeetingScreenState extends State<MeetingScreen> {
  // Room object
  late Room _room;

  @override
  void initState() {
    ...
    //highlight-next-line
    setupRoomEventListener();
  }

  @override
  Widget build(BuildContext context) {
    return Column(children: [
      ElevatedButton(
        onPressed: () {
          //highlight-start
          // Configuration for realtime transcription
          TranscriptionConfig transcriptionConfig = TranscriptionConfig(
              webhookUrl: "https://webhook.your-api-server.com",
              summaryConfig: SummaryConfig(
                  enabled: true,
                  prompt:
                      "Write summary in sections like Title, Agenda, Speakers, Action Items, Outlines, Notes and Summary"));
          // Start realtime transcription
          _room.startTranscription(transcriptionConfig: transcriptionConfig);
          //highlight-end
        },
        child: const Text("Start Realtime Transcription"),
      ),
      ElevatedButton(
        onPressed: () {
          //highlight-start
          // Stop realtime transcription
          _room.stopTranscription();
          //highlight-end
        },
        child: const Text("Stop Realtime Transcription"),
      ),
    ]);
  }

  void setupRoomEventListener() {
    //highlight-start
    // Listen for transcription state changed event
    _room.on(Events.transcriptionStateChanged, (Map<String, dynamic> data) {
      //Status can be :: TRANSCRIPTION_STARTING
      //Status can be :: TRANSCRIPTION_STARTED
      //Status can be :: TRANSCRIPTION_STOPPING
      //Status can be :: TRANSCRIPTION_STOPPED
      log("Meeting transcription status : ${data['status']}");
    });
    //highlight-end

    //highlight-start
    // Listen for transcription text event
    _room.on(Events.transcriptionText, (TranscriptionText transcriptionText) {
      print(
          "TranscriptionText : ${transcriptionText.participantName} (${transcriptionText.participantId}) :  ${transcriptionText.text} ${transcriptionText.timestamp}");
    });
    //highlight-end
  }
}

```

### API Reference

The API references for all the methods utilized in this guide are provided below.

- [startTranscription()](/flutter/api/sdk-reference/room-class/methods#starttranscription)
- [stopTranscription()](/flutter/api/sdk-reference/room-class/methods#stoptranscription)
- [Events.transcriptionStateChanged](/flutter/api/sdk-reference/room-class/events#transcriptionstatechanged)
- [Events.transcriptionText](/flutter/api/sdk-reference/room-class/events#transcriptiontext)


---

---
sidebar_label: Video Processor Android Setup
pagination_label: Video Processor Android Setup
---

# Video Processor Android Setup - Flutter

- VideoSDK allows you to add unique effects to your video stream before transmission during video calls with custom native video processing code. This guide offers step-by-step instructions for creating and implementing a custom video processor for frame manipulation on Android.

- To enable native processor development on Android, add the following dependency to your `build.gradle` file located at `<project root>/android/build.gradle`:

```js title="build.gradle"
dependencies {
  implementation 'io.github.webrtc-sdk:android:125.6422.02'
  // other app dependencies
  }
```
## **Step-by-Step Guide: Integrating Native Video Processor in Flutter**

### **Step 1: Create Your Own Processor Code** 

- First, create a class that implements the `VideoProcessor` interface. In this class, define the `onFrameReceived` function, which will contain the logic for manipulating video frames according to your needs. After applying the desired effect, make sure to return the processed frame.

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js title="YourOwnBackgroundProcessor.kt"
package com.yourOwnPackage

import live.videosdk.webrtc.VideoProcessor
import org.webrtc.VideoFrame

class YourOwnBackgroundProcessor : VideoProcessor {
    // Override the onFrameReceived function to access VideoFrames
    override fun onFrameReceived(videoFrame: VideoFrame): VideoFrame {
        // Function to manipulate frame as per requirement
        return applyEffect(videoFrame)
    }

    private fun applyEffect(videoFrame: VideoFrame): VideoFrame {
        // Add your custom code here to apply the effect and return the processed VideoFrame
        return processedVideoFrame 
    }
}
```

</TabItem>

<TabItem value="Java">

```js title="YourOwnBackgroundProcessor.java"
package com.yourOwnPackage

import live.videosdk.webrtc.VideoProcessor;
import org.webrtc.VideoFrame;

public class YourOwnBackgroundProcessor implements VideoProcessor {
    //Override the onFrameReceived function to get access to the VideoFrames
    @Override
    public VideoFrame onFrameReceived(VideoFrame videoFrame) {
        //Function to manupulate frame as per requirement.
        VideoFrame processedVideoFrame = applyEffect(videoFrame)
        return processedVideoFrame
    }
    private VideoFrame applyEffect(VideoFrame videoFrame) {
        // Add your custom code here to apply the effect and return the processed VideoFrame
        return processedVideoFrame
    }
}
```

</TabItem>

</Tabs>

### **Step 2: Register your Processor** 

- In your `MainActivity`, register your custom video processor using the `registerVideoProcessor()` method from the `VideoSDK` class during app initialization. Provide a string representing the unique processor name along with an instance of your processor to complete the registration. This processor name will be used later to apply the effects offered by your processor.

<Tabs
defaultValue="Kotlin"
groupId={"AndroidLanguage"}
values={[{label: 'Kotlin', value: 'Kotlin'},{label: 'Java', value: 'Java'},]}>

<TabItem value="Kotlin">

```js title="MainActivity.kt"
package com.example.example

import io.flutter.embedding.android.FlutterActivity
import android.os.Bundle
import com.yourOwnPackage.YourOwnBackgroundProcessor
import live.videosdk.videosdk.VideoSDK

class MainActivity : FlutterActivity() {

    private lateinit var bgProcessor: YourOwnBackgroundProcessor

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        //Create an instance of your Processor 
        bgProcessor = YourOwnBackgroundProcessor()
        //Create an instance of the VideoSDK class
        val videoSDK = VideoSDK.getInstance()
        //Register your processor with a unique name and its instance
        videoSDK.registerVideoProcessor("ProcessorName", bgProcessor)
    }
}
```

</TabItem>

<TabItem value="Java">

```js title="MainActivity.java"
package com.example.example;

import io.flutter.embedding.android.FlutterActivity;
import android.os.Bundle;
import com.yourOwnPackage.YourOwnBackgroundProcessor;
import live.videosdk.videosdk.VideoSDK;

public class MainActivity extends FlutterActivity {

    private YourOwnBackgroundProcessor bgProcessor;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        //Create an instance of your Processor 
        bgProcessor = new YourOwnBackgroundProcessor();
        //Create an instance of the VideoSDK class
        VideoSDK videoSDK = VideoSDK.getInstance();
        //Register your processor with a unique name and its instance
        videoSDK.registerVideoProcessor("ProcessorName", bgProcessor);
    }
}
```

</TabItem>

</Tabs>

### **Step 3: Apply the Processor** 

- Once you have registered the processor during initialization, you can use it throughout the entire app lifecycle. To apply the effect provided by the processor, use the `applyVideoProcessor()` method from the `VideoSDK` class. This method requires the name of the processor that was used during registration. 
- If you have registered multiple processors and wish to switch between them, simply call the `applyVideoProcessor()` method with the name of the desired processor.

```js
import 'package:flutter/material.dart';
import 'package:videosdk/videosdk.dart';

class MeetingScreen extends StatefulWidget {
  //Existing configuration
}

class _MeetingScreenState extends State<MeetingScreen> {
  late Room _room;

  @override
  void initState() {
    //highlight-next-line
    //Existing configuration
  }

  @override
  Widget build(BuildContext context) {
    return Column(
      children:[
        //highlight-start
        // To apply the effect from the processor, provide the name used during registration.
        ElevatedButton(
          onPressed:(){
            VideoSDK.applyVideoProcessor(videoProcessorName: "ProcessorName");
          },
          child: const Text("Apply Video Processor"),
        ),
    //highlight-end
      ]
    );
  }
}
```

### **Step 4: Remove the Processor** 

- You can remove the processor when you no longer need the effect. To do this, use the `removeVideoProcessor()` method from the `VideoSDK` class to eliminate the effect provided by the processor. This method will remove the effect of the currently active video processor.

```js
import 'package:flutter/material.dart';
import 'package:videosdk/videosdk.dart';

class MeetingScreen extends StatefulWidget {
  //Existing configuration
}

class _MeetingScreenState extends State<MeetingScreen> {
  late Room _room;

  @override
  void initState() {
    //highlight-next-line
    //Existing configuration
  }

  @override
  Widget build(BuildContext context) {
    return Column(
      children:[
        //highlight-start
        // To apply the effect from the processor, provide the name used during registration.
        ElevatedButton(
          onPressed:(){
            VideoSDK.removeVideoProcessor();
          },
          child: const Text("Remove Video Processor"),
        ),
    //highlight-end
      ]
    );
  }
}
```

## API Reference

The API references for all the methods utilized in this guide are provided below.

- [registerVideoProcessor()](/flutter/api/sdk-reference/videosdk-class/native-android-methods#registervideoprocessor)
- [applyVideoProcessor](/flutter/api/sdk-reference/videosdk-class/methods#applyvideoprocessor)
- [removeVideoProcessor()](/flutter/api/sdk-reference/videosdk-class/methods#removevideoprocessor)


---

---
sidebar_label: Video Processor iOS Setup
pagination_label: Video Processor iOS Setup
---

# Video Processor iOS Setup - Flutter

- VideoSDK allows you to add unique effects to your video stream before transmission during video calls with custom native video processing code. This guide offers step-by-step instructions for creating and implementing a custom video processor for frame manipulation on iOS.

- To enable native processor development on iOS, replace the `use_frameworks!` line with `use_frameworks! :linkage => :static` in your podfile:

```js title="Podfile"
target 'Runner' do
  //highlight-next-line
  use_frameworks! :linkage => :static
  use_modular_headers!

  flutter_install_all_ios_pods File.dirname(File.realpath(__FILE__))
end
```
## **Step-by-Step Guide: Integrating Native Video Processor in Flutter**

### **Step 1: Create Your Own Processor Code** 

- First, create a class that implements the `VideoProcessor` interface. In this class, define the `onFrameReceived` function, which will contain the logic for manipulating video frames according to your needs. After applying the desired effect, make sure to return the processed frame.

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="Swift"
groupId={"language"}
values={[{label: 'Swift', value: 'Swift'},{label: 'Objective-C', value: 'Objective-C'}]}>

<TabItem value="Swift">

```js title="YourOwnBackgroundProcessor.swift"
import Foundation

 public class YourOwnBackgroundProcessor: VideoProcessor {
    
     // Override the onFrameReceived function to access VideoFrames
     public override func onFrameReceived(_ frame: RTCVideoFrame) -> RTCVideoFrame? {
         // Function to manipulate frame as per requirement
         let processedframe = applyEffect(<#T##frame: RTCVideoFrame##RTCVideoFrame#>)
         return processedframe
         
     }

     private func applyEffect(_ frame:RTCVideoFrame) -> RTCVideoFrame?{
         // Add your custom code here to apply the effect and return the processed VideoFrame
         return processedFrame
     }
}
```

</TabItem>

<TabItem value="Objective-C">

```js title="YourOwnBackgroundProcessor.m"

#import <Foundation/Foundation.h>
#import <WebRTC/RTCVideoFrame.h>
#import "videosdk_webrtc/VideoProcessor.h"

@interface YourOwnBackgroundProcessor : VideoProcessor

@end

@implementation YourOwnBackgroundProcessor

// Override the onFrameReceived function to access VideoFrames
- (RTCVideoFrame *)onFrameReceived:(RTCVideoFrame *)frame {
    // Function to manipulate frame as per requirement
    RTCVideoFrame *processedFrame = [self applyEffect:frame];
    return processedFrame;
}

- (RTCVideoFrame *)applyEffect:(RTCVideoFrame *)frame {
    // Apply effect here and return the processed VideoFrame
    return processedFrame; // Define processedFrame appropriately
}

@end
```

</TabItem>

</Tabs>

### **Step 2: Register your Processor** 

- In your `AppDelegate`, register your custom video processor using the `registerVideoProcessor()` method from the `VideoSDK` class during app initialization. Provide a string representing the unique processor name along with an instance of your processor to complete the registration. This processor name will be used later to apply the effects offered by your processor.

<Tabs
defaultValue="Swift"
groupId={"language"}
values={[{label: 'Swift', value: 'Swift'},]}>

<TabItem value="Swift">

```js title="AppDelegate.swift"
import UIKit
import Flutter
import videosdk
import Foundation 

@UIApplicationMain
@objc class AppDelegate: FlutterAppDelegate {
  override func application(
    _ application: UIApplication,
    didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?
  ) -> Bool {
    {
        //Create an instance of your Processor 
        let bgProcessor = YourOwnBackgroundProcessor()
        //Create an instance of the VideoSDK class
        let videoSDK = VideoSDK.getInstance
        //Register your processor with a unique name and its instance
        videoSDK.registerVideoProcessor(videoProcessorName: "ProcessorName", videoProcessor: bgProcessor)
    }

    return super.application(application, didFinishLaunchingWithOptions: launchOptions)
  }
}
```

</TabItem>

</Tabs>

### **Step 3: Apply the Processor** 

- Once you have registered the processor during initialization, you can use it throughout the entire app lifecycle. To apply the effect provided by the processor, use the `applyVideoProcessor()` method from the `VideoSDK` class. This method requires the name of the processor that was used during registration. 
- If you have registered multiple processors and wish to switch between them, simply call the `applyVideoProcessor()` method with the name of the desired processor.

```js
import 'package:flutter/material.dart';
import 'package:videosdk/videosdk.dart';

class MeetingScreen extends StatefulWidget {
  //Existing configuration
}

class _MeetingScreenState extends State<MeetingScreen> {
  late Room _room;

  @override
  void initState() {
    //highlight-next-line
    //Existing configuration
  }

  @override
  Widget build(BuildContext context) {
    return Column(
      children:[
        //highlight-start
        // To apply the effect from the processor, provide the name used during registration.
        ElevatedButton(
          onPressed:(){
            VideoSDK.applyVideoProcessor(videoProcessorName: "ProcessorName");
          },
          child: const Text("Apply Video Processor"),
        ),
    //highlight-end
      ]
    );
  }
}
```

### **Step 4: Remove the Processor** 

- You can remove the processor when you no longer need the effect. To do this, use the `removeVideoProcessor()` method from the `VideoSDK` class to eliminate the effect provided by the processor. This method will remove the effect of the currently active video processor.

```js
import 'package:flutter/material.dart';
import 'package:videosdk/videosdk.dart';

class MeetingScreen extends StatefulWidget {
  //Existing configuration
}

class _MeetingScreenState extends State<MeetingScreen> {
  late Room _room;

  @override
  void initState() {
    //highlight-next-line
    //Existing configuration
  }

  @override
  Widget build(BuildContext context) {
    return Column(
      children:[
        //highlight-start
        // To apply the effect from the processor, provide the name used during registration.
        ElevatedButton(
          onPressed:(){
            VideoSDK.removeVideoProcessor();
          },
          child: const Text("Remove Video Processor"),
        ),
    //highlight-end
      ]
    );
  }
}
```

## API Reference

The API references for all the methods utilized in this guide are provided below.

- [registerVideoProcessor()](/flutter/api/sdk-reference/videosdk-class/native-ios-methods#registervideoprocessor)
- [applyVideoProcessor()](/flutter/api/sdk-reference/videosdk-class/methods#applyvideoprocessor)
- [removeVideoProcessor()](/flutter/api/sdk-reference/videosdk-class/methods#removevideoprocessor)



---

---
sidebar_label: Overview
pagination_label: Overview
---

# Video Processor - Flutter

VideoSDK allows you to add custom effects to your video stream before it's transmitted during video calls. This lets you enhance your video in creative ways or achieve specific functionalities.

### Understanding Video Processing

Video processing involves manipulating raw video data (frames) captured by your camera. You can create native processors for Android and iOS to enhance video streams during meetings.

:::info

- Currently, Video Processing is supported only on Android and iOS devices.

:::

### The `VideoProcessor` Interface

The `VideoProcessor` Interface defines a way for your code to interact with the video stream. It essentially lets you intercept each frame before it's sent and apply your processing logic.

#### Key Function: `onFrameReceived`

This is the heart of video processing with VideoSDK. Whenever a new video frame is captured by your camera, the `onFrameReceived` function is called. This function provides you with the raw frame data, allowing you to modify it as needed.

### How it Works:

1. **Implement the Interface:** Create a class that implements the `VideoProcessor` interface. Within this class, define the `onFrameReceived` function.

2. **Process the Frame:** In the `onFrameReceived` function, access the raw video frame data. Apply your desired effects or manipulations to this data.

3. **Return the Processed Frame:** After processing the frame, return the modified version to VideoSDK. This processed frame will then be transmitted during the video call.

4. **Register Your Processor:** Create instances of all the processors you plan to use during the meeting and register them with the `registerVideoProcessor()` method from the `VideoSDK` class during your app's initialization.

5. **Apply the Processor:** Select the desired processor and apply it during the meeting using the `applyVideoProcessor()` method from the `VideoSDK` class to utilize its features.

6. **Remove the Processor:** Stop applying the selected video processor during the meeting, using the `removeVideoProcessor()` method from the `VideoSDK` class allowing you to switch to a different effect or processor as needed.

## API Reference

The API references for all the methods utilized in this guide are provided below.

- [applyVideoProcessor()](/flutter/api/sdk-reference/videosdk-class/methods#applyvideoprocessor)
- [removeVideoProcessor()](/flutter/api/sdk-reference/videosdk-class/methods#removevideoprocessor)


---

---
sidebar_position: 2
sidebar_label: MeetingBuilder widget
pagination_label: MeetingBuilder widget
title: MeetingBuilder widget
---

import NoIndex from '../../../../../mdx/\_no-index.mdx';

<NoIndex/>

# MeetingBuilder widget - Flutter

<div class="sdk-api-ref">

MeetingBuilder is a widget provided by the SDK, which handles building a widget for the [`Meeting`](../meeting-class/introduction) instance initialized.

## MeetingBuilder()

```js
MeetingBuilder(
  meetingId: "<meeting-id>",
  token: "<token>",
  displayName: "<your-name>",
  participantId: "abcdefgh",
  micEnabled: true,
  webcamEnabled: true,
  maxResolution: "hd",
  notification: const NotificationInfo(
    title: "Video SDK",
    message: "Video SDK is sharing screen in the meeting",
    icon: "notification_share", // drawable icon name
  ),
  builder: (Meeting meeting) {
    return Text("Meeting screen");
  },
)
```

## Meeting Initialization Parameters

---

### meetingId

- Unique Id of the meeting, where that participant will be joining.

  - type : `String`
  - `REQUIRED`

Please refer this [documentation](/api-reference/realtime-communication/create-room) to create a room.

---

### token

- Token, which is used for authentication purposes.

  - type: `String`
  - `REQUIRED`

Please refer this [documentation](/api-reference/realtime-communication/intro/) to generate a token.

---

### displayName

- Name of the participant, who will be joining the meeting, this name will be displayed to other participants in the same meeting.

  - type : String
  - `REQUIRED`

---

### participantId

- Unique Id of the participant. If not passed then SDK will create an Id by itself and will use that id.

  - type : `String`
  - `OPTIONAL`

---

### micEnabled

- Whether `mic` of the participant will be `on`, while joining the meeting. If it is set to `false`, then mic of that participant will be `disabled` by default, but can be `enabled` or `disabled` later.

  - type: `Boolean`
  - `REQUIRED`

---

### webcamEnabled

- Whether `webcam` of the participant will be `on`, while joining the meeting. If it is set to `false`, then webcam of that participant will be `disabled` by default, but can be `enabled` or `disabled` later.

  - type: `Boolean`
  - `REQUIRED`

---

### maxResolution

- Sets the maximum upload resolution of that participant's webcam stream.

  - type: `String`
  - value: `sd` | `hd`
  - defaultValue: `sd`
  - `OPTIONAL`

### notification

- Notification, that will be shown, while screen-sharing.

  - type: `NotificationInfo`

    - title: `String`
    - message: `String`
    - icon: `String`

  - `REQUIRED`

### builder

- This will take builder method with [`Meeting`](../meeting-class/introduction) instance as a parameter.

  - type: `Widget Function(Meeting)`
  - `REQUIRED`

</div>


---

---
title: Meeting Builder Widget for flutter SDK.
hide_title: false
hide_table_of_contents: false
description: Video SDK Class is a factory for initialize, configure and init meetings.
sidebar_label: Meeting Builder Widget
pagination_label: Meeting Builder Widget
keywords:
  - RTC IOS
  - VideoSDK Class
  - Video API
  - Video Conferencing
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: meeting-builder-widget
---

import NoIndex from '../../../../mdx/\_no-index.mdx';

<NoIndex/>

# Meeting Builder Widget - Flutter

The entry point into real-time communication SDK.

## Using Meeting Builder Widget

The `Meeting Builder Widget` includes methods and events to initialize and configure the SDK. It is a factory class.

import MethodListGroup from '@theme/MethodListGroup';
import MethodListItemLabel from '@theme/MethodListItemLabel';
import MethodListHeading from '@theme/MethodListHeading';

### Properties

<MethodListGroup>
<MethodListHeading heading="Properties" />
  <MethodListGroup name="initMeeting()">
    <MethodListItemLabel name="meetingId" type={"String"} />
    <MethodListItemLabel name="displayName" type={"String"}   />
    <MethodListItemLabel name="token" type={"String"}   />
    <MethodListItemLabel name="micEnabled" type={"Bool"}   />
    <MethodListItemLabel name="webcamEnabled" type={"Bool"}   />
    <MethodListItemLabel name="notification" type={"NotificationInfo"}   />
    <MethodListItemLabel name="builder" type={"Widget Function(Meeting)"}   />
  </MethodListGroup>
</MethodListGroup>

## Example

```js title="Configure MeetingBuilder Example"
MeetingBuilder(
  meetingId: "<meeting-id>",
  displayName: "Chintan",
  token: "<token>",
  micEnabled: true,
  webcamEnabled: true,
  notification: const NotificationInfo(
    title: "Video SDK",
    message: "Video SDK is sharing screen in the meeting",
    icon: "notification_share", // drawable icon name
  ),
  builder: (Meeting meeting) {
    return Text("Meeting screen");
  },
)
```


---

---
title: Meeting Class Events
sidebar_position: 1
sidebar_label: Events
pagination_label: Meeting Class Events
---

import NoIndex from '../../../../../mdx/\_no-index.mdx';

<NoIndex/>

# Meeting Class Events - Flutter

<div class="sdk-api-ref-only-h4">

---

### meetingJoined

- This event will be emitted when a [localParticipant](properties#localparticipant) successfully joined the meeting.

#### Example

```javascript
meeting.on(Events.meetingJoined, (){
  // do something
});
```

---

### meetingLeft

- This event will be emitted when a [localParticipant](properties#localparticipant) left the meeting.

#### Example

```javascript
meeting.on(Events.meetingLeft, () {
  // do something
});
```

---

### participantJoined

- This event will be emitted when a new [participant](../participant-class/introduction) joined the meeting.

#### Event handler parameters

- **participant**: [Participant](../participant-class/introduction)

#### Example

```javascript
meeting.on(Events.participantJoined, (participant) {
  // do something
});
```

---

### participantLeft

- This event will be emitted when a joined [participant](../participant-class/introduction) left the meeting.

#### Event handler parameters

- **participant**: [Participant](../participant-class/introduction)

#### Example

```javascript
meeting.on(Events.participantLeft, (participant) {
  // do something
});
```

---

### speakerChanged

- This event will be emitted when a active speaker changed.
- If you want to know which participant is actively speaking, then this event will be used.
- If no participant is actively speaking, then this event will pass `null` as an event handler parameter.

#### Event handler parameters

- **activeSpeakerId**: String?

#### Example

```javascript
meeting.on(Events.speakerChanged, (activeSpeakerId) {
  // do something
});
```

---

### presenterChanged

- This event will be emitted when any [participant](../participant-class/introduction) starts or stops screen sharing.
- It will pass `participantId` as an event handler parameter.
- If a participant stops screen-sharing, then this event will pass `null` as en event handler parameter.

#### Event handler parameters

- **activePresenterId**: String?

#### Example

```javascript
meeting.on(Events.presenterChanged, (activePresenterId) {
  // do something
});
```

---

### entryRequested

- This event will be emitted when a new [participant](../participant-class/introduction), who is trying to join the meeting, is having permission **`ask_join`** in token.
- This event will only be emitted to the [participants](properties#participants) in the meeting, who is having the permission **`allow_join`** in token.
- This event will pass following parameters as an event parameters, `participantId` and `name` of the new participant who is trying to join the meeting, `allow()` and `deny()` to take required actions.

#### Event handler parameters

- **data**: `Map{'<'}String, dynamic>`\{ **"allow"**: Function; **"deny"**: Function; **"name"**: String; **"participantId"**: String }
  - **allow**: Function
  - **deny**: Function
  - **name**: String
  - **participantId**: String

#### Example

```javascript
meeting.on(Events.entryRequested, (data){
  String? participantId = data["participantId"];
  String? name = data["name"];

  Function allow = data["allow"];
  Function deny = data["deny"];

  print("$name requested to join the meeting.");

  // If you want to allow the entry request
  allow();

  // if you want to deny the entry request
  deny();
});
```

---

### entryResponded

- This event will be emitted when the `join()` request is responded.
- This event will be emitted to the [participants](properties#participants) in the meeting, who is having the permission **`allow_join`** in token.
- This event will be also emitted to the [participant](../participant-class/introduction), who requested to join the meeting.

#### Event handler parameters

- **participantId**: _String_
- **decision**: _"allowed"_ | _"denied"_

#### Example

```javascript
meeting.on(Events.entryResponded, (participantId, decision) {
  // participantId will be id of participant, who requested to join meeting

  if (decision === "allowed") {
    // entry allowed
  } else {
    // entry denied
  }
});
```

---

### webcamRequested

- This event will be emitted to the participant `B` when any other participant `A` requests to enable webcam of participant `B`.
- On accepting the request, webcam of participant `B` will be enabled.

#### Event handler parameters

- **data**: `Map{'<'}String, dynamic>`\{ **accept**: Function; **participantId**: String; **reject**: Function }
  - **accept**: Function
  - **participantId**: String
  - **reject**: Function

#### Example

```javascript
meeting.on(Events.webcamRequested, (data) {
  String? participantId = data["participantId"];

  Function accept = data["accept"];
  Function reject = data["deny"];

  // participantId, will be the id of participant who requested to enable webcam

  // if accept request
  accept();

  // if reject request
  reject();
});
```

---

### micRequested

- This event will be emitted to the participant `B` when any other participant `A` requests to enable mic of participant `B`.
- On accepting the request, mic of participant `B` will be enabled.

#### Event handler parameters

- **data**: Map{'<'}String{','} dynamic>\{ **accept**: Function; **participantId**: String; **reject**: Function }
  - **accept**: Function
  - **participantId**: String
  - **reject**: Function

#### Example

```javascript
meeting.on(Events.micRequested, (data) {
  String participantId = data["participantId"];

  Function accept = data["accept"];
  Function reject = data["reject"];

  // participantId, will be the id of participant who requested to enable webcam

  // if accept request
  accept();

  // if reject request
  reject();
});
```

---

### recordingStarted

- This event will be emitted when recording of the meeting is started.

#### Example

```javascript
meeting.on(Events.recordingStarted, () {
  // do something
});
```

---

### recordingStopped

- This event will be emitted when recording of the meeting is stopped.

#### Example

```javascript
meeting.on(Events.recordingStopped, () {
  // do something
});
```

---

### liveStreamStarted

- This event will be emitted when `RTMP` live stream of the meeting is started.

#### Example

```javascript
meeting.on(Events.liveStreamStarted, () {
  // do something
});
```

---

### liveStreamStopped

- This event will be emitted when `RTMP` live stream of the meeting is stopped.

#### Example

```javascript
meeting.on(Events.liveStreamStopped, () {
  // do something
});
```

</div>


---

---
title: Meeting class for Flutter SDK.
hide_title: true
hide_table_of_contents: false
description: RTC Meeting Class provides features to implement custom meeting layout in your application.
sidebar_label: Example
pagination_label: Meeting Class Example
keywords:
  - RTC Flutter
  - Meeting Class
  - Video API
  - Video Conferencing
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: meeting-class-example
---

import NoIndex from '../../../../../mdx/\_no-index.mdx';

<NoIndex/>

# Meeting Class Example - Flutter

```js title="Play with meeting instance"
// Join the meeting
meeting?.join();

// Get local participants
meeting?.localParticipant;

// Get remote participants
meeting?.participants;

// Adding event listner
meeting.on(Events.participantJoined, (Participant participant) {
  print("new participant => $participant");
  },
);
```


---

---
sidebar_position: 1
sidebar_label: Introduction
pagination_label: Intro to Video SDK Meeting Class
title: Video SDK Meeting Class
---

import NoIndex from '../../../../../mdx/\_no-index.mdx';

<NoIndex/>

# Video SDK Meeting Class - Flutter

<div id="tailwind" class="sdk-api-ref">

## Introduction

The `Meeting` class includes properties, methods and events for managing a meeting, participants, video, audio and share streams, messaging and UI customization.

import LinksGrid from '../../../../../src/theme/LinksGrid'
import properties from '../data/properties.json'
import methods from '../data/methods.json'
import events from '../data/events.json'

## Meeting Properties

<div class="row">

<div class="col col--4 margin-bottom--sm" >

- [id](./properties.md#id)

</div>
<div class="col col--4 margin-bottom--sm" >

- [activeSpeakerId](./properties.md#activespeakerid)

</div>
<div class="col col--4 margin-bottom--sm" >

- [activePresenterId](./properties.md#activepresenterid)

</div>
<div class="col col--4 margin-bottom--sm" >

- [selectedWebcamId](./properties.md#selectedwebcamid)

</div>
<div class="col col--4 margin-bottom--sm" >

- [selectedMicId](./properties.md#selectedmicid)

</div>
<div class="col col--4 margin-bottom--sm" >

- [localParticipant](./properties.md#localparticipant)

</div>
<div class="col col--4 margin-bottom--sm" >

- [participants](./properties.md#participants)

</div>
<div class="col col--4 margin-bottom--sm" >

- [PubSub](./properties.md#pubsub)

</div>

</div>

## Meeting Methods

<div class="row">
<div class="col col--4 margin-bottom--sm" >

- [join](./methods#join)

</div>
<div class="col col--4 margin-bottom--sm" >

- [leave](./methods#leave)

</div>
<div class="col col--4 margin-bottom--sm" >

- [enableWebcam](./methods#enablewebcam)

</div>
<div class="col col--4 margin-bottom--sm" >

- [disableWebcam](./methods#disablewebcam)

</div>
<div class="col col--4 margin-bottom--sm" >

- [unmuteMic](./methods#unmutemic)

</div>
<div class="col col--4 margin-bottom--sm" >

- [muteMic](./methods#mutemic)

</div>
<div class="col col--4 margin-bottom--sm" >

- [enableScreenShare](./methods#enablescreenshare)

</div>
<div class="col col--4 margin-bottom--sm" >

- [disableScreenShare](./methods#disablescreenshare)

</div>
<div class="col col--4 margin-bottom--sm" >

- [startRecording](./methods#startrecording)

</div>
<div class="col col--4 margin-bottom--sm" >

- [stopRecording](./methods#stoprecording)

</div>
<div class="col col--4 margin-bottom--sm" >

- [startLivestream](./methods#startlivestream)

</div>
<div class="col col--4 margin-bottom--sm" >

- [stopLivestream](./methods#stoplivestream)

</div>
<div class="col col--4 margin-bottom--sm" >

- [getWebcams](./methods#getwebcams)

</div>
<div class="col col--4 margin-bottom--sm" >

- [changeWebcam](./methods#changewebcam)

</div>
<div class="col col--4 margin-bottom--sm" >

- [on](./methods#on)

</div>
</div>

## Meeting Events

<div class="row">

<div class="col col--4 margin-bottom--sm" >

- [meetingJoined](./events.md#meetingjoined)

</div>
<div class="col col--4 margin-bottom--sm" >

- [meetingLeft](./events.md#meetingleft)

</div>
<div class="col col--4 margin-bottom--sm" >

- [participantJoined](./events.md#participantjoined)

</div>
<div class="col col--4 margin-bottom--sm" >

- [participantLeft](./events.md#participantleft)

</div>
<div class="col col--4 margin-bottom--sm" >

- [speakerChanged](./events.md#speakerchanged)

</div>
<div class="col col--4 margin-bottom--sm" >

- [presenterChanged](./events.md#presenterchanged)

</div>
<div class="col col--4 margin-bottom--sm" >

- [entryRequested](./events.md#entryrequested)

</div>
<div class="col col--4 margin-bottom--sm" >

- [entryResponded](./events.md#entryresponded)

</div>
<div class="col col--4 margin-bottom--sm" >

- [webcamRequested](./events.md#webcamrequested)

</div>
<div class="col col--4 margin-bottom--sm" >

- [micRequested](./events.md#micrequested)

</div>
<div class="col col--4 margin-bottom--sm" >

- [recordingStarted](./events.md#recordingstarted)

</div>
<div class="col col--4 margin-bottom--sm" >

- [recordingStopped](./events.md#recordingstopped)

</div>
<div class="col col--4 margin-bottom--sm" >

- [livestreamStarted](./events.md#livestreamstarted)

</div>
<div class="col col--4 margin-bottom--sm" >

- [livestreamStopped](./events.md#livestreamstopped)

</div>

</div>

</div>


---

---
title: Meeting class for Flutter SDK.
hide_title: false
hide_table_of_contents: false
description: RTC Meeting Class provides features to implement custom meeting layout in your application.
sidebar_label: Meeting Class
pagination_label: Meeting Class
keywords:
  - RTC IOS
  - Meeting Class
  - Video API
  - Video Conferencing
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: meeting-class
---

import NoIndex from '../../../../../mdx/\_no-index.mdx';

<NoIndex/>

# Meeting Class - Flutter

## Using Meeting Class {#h2}

The `Meeting Class` includes methods and events for managing meetings, participants, video & audio streams, data channels and UI customization.

import MethodListGroup from '@theme/MethodListGroup';
import MethodListItemLabel from '@theme/MethodListItemLabel';
import MethodListHeading from '@theme/MethodListHeading';

## Properties {#h2}

### id {#h3}

- `type`: String
- `id` represents the meetingId for the current meeting

### localParticipant {#h3}

- `type`: Participant
- `localParticipant` represents the local participant of the meeting

### participants {#h3}

- `type`: Map{'<'}String, Participant>
- `participants` represents all remote participants in the meeting

### pubSub {#h3}

- `type`: PubSub
- `pubSub` represents Publisher-Subscriber feature

### selectedWebcamId {#h3}

- `type`: String?
- `selectedWebcamId` represents the id of currently selected webcam

## Events

### Events.meetingJoined

- `Events.meetingJoined` will be emitted when local participant joins the meeting successfully

### Events.meetingLeft {#h3}

- `Events.meetingLeft` will be emitted when local participant leaves the meeting

### Events.entryRequested {#h3}

- `Events.entryRequested` will be emitted when remote participant requests for entry in your meeting

### Events.entryResponded {#h3}

- `Events.entryResponded` will be emitted when meeting host responds to your entry request

### Events.micRequested {#h3}

- `Events.micRequested` will be emitted when mic is requested

### Events.webcamRequested {#h3}

- `Events.webcamRequested` will be emitted when webcam is requested

### Events.participantJoined {#h3}

- `Events.participantJoined` will be emitted when new participant joins the meeting

### Events.participantLeft {#h3}

- `Events.participantLeft` will be emitted when any participant from the meeting leaves

### Events.recordingStarted {#h3}

- `Events.recordingStarted` will be emitted when recording of the meeting is started successfully

### Events.recordingStopped {#h3}

- `Events.recordingStopped` will be emitted when recording of the meeting is stopped

### Events.liveStreamStarted {#h3}

- `Events.liveStreamStarted` will be emitted when live streaming of the meeting in social media is started successfully

### Events.liveStreamStopped {#h3}

- `Events.liveStreamStopped` emitted when live streaming of the meeting is stopped

### Events.speakerChanged {#h3}

- `Events.speakerChanged` will be emitted when active speaker is changed

### Events.presenterChanged {#h3}

- `Events.presenterChanged` will be emitted when any participant started presenting

## Methods {#h2}

### join() {#h3}

- Return Type : `void`
- `join()` is used to join a meeting.
- Events associated with `join()` method :

  - Local Participant will receive a [`Events.meetingJoined`](/flutter/0.0.x/api/sdk-reference/meeting-class/meeting-class#eventsmeetingjoined) event, when successfully joined.
  - Remote Participant will receive a `Events.participantJoined` event with `participant`.

- When `join()` is called and the permission in the token is `ask_join`, then direct joining is not preformed.
  - In this case `onEntryRequested()` will be emitted to the participant with permission `allow_join`. Once the participant with permission `allow_join` responds to the request, `onEntryResponded({participantId, decision})`.
  - If the `decision` is `allowed`, participant will be joined else if `decision` is `denied` participant showed not be joined.

### leave() {#h3}

- Return Type : `void`
- `leave()` is used to leave current meeting.
- Events associated with `leave()` method :
  - Local Participant will receive a `Events.meetingLeft` event.
  - Remote Participant will receive a `Events.participantLeft` event with `participantId`.

### enableWebcam() {#h3}

- Return Type : `void`
- `enableWebcam()` is used to enable self camera.
- Every Participant will receive a `Events.streamEnabled` event with `stream` object.

### disableWebcam() {#h3}

- Return Type : `void`
- `disableWebcam()` is used to disable self camera.
- Every Participant will receive a `Events.streamDisabled` event with `stream` object.

### unmuteMic() {#h3}

- Return Type : `void`
- `unmuteMic()` is used to enable self microphone.
- Every Participant will receive a `Events.streamEnabled` event with `stream` object.

### muteMic() {#h3}

- Return Type : `void`
- `muteMic()` is used to disable self microphone.
- Every Participant will receive a `Events.streamDisabled` event with `stream` object.

### enableScreenShare() {#h3}

- Return Type : `void`
- `enableScreenShare()` is used to enable screen-sharing.
- Every Participant will receive a `Events.streamEnabled` event with `stream` object.

### disableScreenShare() {#h3}

- Return Type : `void`
- `disableScreenShare()` is used to disable screen-sharing.
- Every Participant will receive a `Events.streamDisabled` event with `stream` object.

### getWebcams() {#h3}

- Return Type : `List<MediaDeviceInfo>`
- `getWebcams()` is used to get list of available cameras.

### getMics() {#h3}

- Return Type : `List<MediaDeviceInfo>`
- `getMics()` is used to get list of available microphones.

### changeWebcam() {#h3}

- Return Type : `void`
- `changeWebcam` is used to change self camera.
- Every Participant will receive `Events.streamEnabled` event with `stream` object and `Events.streamDisabled` event with `stream` object.

### startRecording() {#h3}

- Return Type : `void`
- `startRecording()` is used to start meeting recording.
- Every Participant will receive `Events.recordingStarted` event.

### stopRecording() {#h3}

- Return Type : `void`
- `stopRecording()` is used to stop meeting recording.
- Every Participant will receive `Events.recordingStopped` event.

### startLivestream() {#h3}

- Return Type : `void`
- `startLivestream()` is used to start meeting livestreaming.
- Every Participant will receive `Events.liveStreamStarted` event.

### stopLivestream() {#h3}

- Return Type : `void`
- `stopLivestream()` is used to stop meeting livestreaming.
- Every Participant will receive `Events.liveStreamStopped` event.

### on(Events event, Function handler) {#h3}

- Return Type : `void`
- `on()` is used to handle custom events.
- This method takes an event and handler. Handler function will be called when given event is emitted.

## Example

```js title="Play with meeting instance"
// Join the meeting
meeting?.join();

// Get local participants
meeting?.localParticipant;

// Get remote participants
meeting?.participants;

// Adding event listner
meeting.on(Events.participantJoined, (Participant participant) {
  print("new participant => $participant");
  },
);
```


---

---
sidebar_position: 1
sidebar_label: Methods
pagination_label: Meeting Class Methods
title: Meeting Class Methods
---

import NoIndex from '../../../../../mdx/\_no-index.mdx';

<NoIndex/>

# Meeting Class Methods - Flutter

<div class="sdk-api-ref-only-h4">

### join()

- It is used to join a meeting.
- After meeting initialization by [`MeetingBuilder Widget`](../meeting-builder/introduction), it returns a new instance of [Meeting](introduction.md). However by default, it will not automatically join the meeting. Hence, to join the meeting you should call `join()`.

#### Events associated with `join()`:

- Local Participant will receive a [`meetingJoined`](/flutter/0.0.x/api/sdk-reference/meeting-class/events#meetingjoined) event, when successfully joined.
- Remote Participant will receive a [`participantJoined`](events#participantjoined) event with the newly joined [`Participant`](../participant-class/introduction.md) object from the event handler.

#### Participant having `ask_join` permission inside token

- If a token contains the permission `ask_join`, then the participant will not join the meeting directly after calling `join()`, but an event will be emitted to the participant having the permission `allow_join` called [`entryRequested`](events#entryrequested).

- After the decision from the remote participant, an event will be emitted to participant called [`entryResponded`](events#entryresponded). This event will contain the decision made by the remote participant.

#### Participant having `allow_join` permission inside token

- If a token containing the permission `allow_join`, then the participant will join the meeting directly after calling `join()`.

#### Returns

- _`void`_

---

### leave()

- It is used to leave the current meeting.

#### Events associated with `leave()`:

- Local participant will receive a [`meetingLeft`](events#meetingleft) event.
- All remote participants will receive a [`participantLeft`](events#participantleft) event with `participantId` string from the event handler.

#### Returns

- _`void`_

---

<!-- ### end()

- It is used to end the current running session.
- By calling `end()`, all joined [participants](properties#participants) including [localParticipant](properties#localparticipant) of that session will leave the meeting.

#### Events associated with `end()`:

- All [participants](properties#participants) and [localParticipant](properties#localparticipant), will be emitted [`meetingLeft`](events#meetingLeft) event.

#### Returns

- _`void`_

--- -->

### enableWebcam()

- It is used to enable self camera.
- [`streamEnabled`](../participant-class/events#streamenabled) event will be emitted with [`stream`](../stream-class/introduction) object from the event handler, inside that [participant](../participant-class/introduction) object.

#### Returns

- _`void`_

---

### disableWebcam()

- It is used to enable self camera.
- [`streamDisabled`](../participant-class/events#streamdisabled) event will be emitted with [`stream`](../stream-class/introduction) object from the event handler, inside that [participant](../participant-class/introduction) object.

#### Returns

- _`void`_

---

### unmuteMic()

- It is used to enable self microphone.
- [`streamEnabled`](../participant-class/events#streamenabled) event will be emitted with [`stream`](../stream-class/introduction) object from the event handler, inside that [participant](../participant-class/introduction) object.

#### Returns

- _`void`_

---

### muteMic()

- It is used to disable self microphone.
- [`streamDisabled`](../participant-class/events#streamdisabled) event will be emitted with [`stream`](../stream-class/introduction) object from the event handler, inside that [participant](../participant-class/introduction) object.

#### Returns

- _`void`_

---

### enableScreenShare()

- it is used to enable screen-sharing.
- [`streamEnabled`](../participant-class/events#streamenabled) event will be emitted with [`stream`](../stream-class/introduction) object from the event handler, inside that [participant](../participant-class/introduction) object.
- [presenterChanged](./events#presenterchanged) will also receive a callback with the `presenterId`.

#### Returns

- _`void`_

---

### disableScreenShare()

- It is used to disable screen-sharing.
- [`streamDisabled`](../participant-class/events#streamdisabled) event will be emitted with [`stream`](../stream-class/introduction) object from the event handler, inside that [participant](../participant-class/introduction) object.
- [presenterChanged](./events#presenterchanged) will also receive a callback with the `null`.

#### Returns

- _`void`_

---

### startRecording()

- It is used to start meeting recording.
- All [participants](properties#participants) and [localParticipant](properties#localparticipant), will receive [`recordingStarted`](events#recordingstarted) event.

- `webhookUrl` will be triggered when the recording is completed and stored into server. Read more about webhooks [here](https://en.wikipedia.org/wiki/Webhook).

#### Parameters

- **webhookUrl**: String

#### Returns

- _`void`_

#### Example

```javascript
const webhookUrl = "https://webhook.your-api-server.com";

meeting.startRecording(webhookUrl);
```

---

### stopRecording()

- It is used to stop meeting recording.
- All [participants](properties#participants) and [localParticipant](properties#localparticipant), will receive [`recordingStopped`](events#recordingstopped) event.

#### Returns

- _`void`_

#### Example

```javascript
meeting.stopRecording();
```

---

### startLivestream()

- It is used to start meeting livestreaming.
- You will be able to start livestream the meeting to another platforms such as Youtube, Facebook, etc. that supports [`rtmp`](https://en.wikipedia.org/wiki/Real-Time_Messaging_Protocol) streaming.
- All [participants](properties#participants) and [localParticipant](properties#localparticipant), will receive [`liveStreamStarted`](events#livestreamstarted) event.

#### Parameters

- **outputs**: `List{'<'}Map{'<'}String{','} String{'>'}{'>'}` \[\{ **url**: String, **streamKey**: String }]

#### Returns

- _`void`_

---

#### Example

```javascript
var outputs = [
  {
    url: "rtmp://a.rtmp.youtube.com/live2",
    streamKey: "<STREAM_KEY>",
  },
  {
    url: "rtmps://",
    streamKey: "<STREAM_KEY>",
  },
];

meeting.startLivestream(outputs);
```

### stopLivestream()

- It is used to stop meeting livestreaming.
- All [participants](properties#participants) and [localParticipant](properties#localparticipant), will receive [`livestreamStopped`](events#livestreamstopped) event.

#### Returns

- _`void`_

#### Example

```javascript
meeting.stopLivestream();
```

---

### getWebcams()

- It will return all camera devices connected.

#### Returns

- List< [`MediaDeviceInfo`](https://api.flutter.dev/flutter/dart-html/MediaDeviceInfo-class.html) >

#### Example

```javascript
List<MediaDeviceInfo> webcams = meeting.getWebcams();
print(webcams);
```

---

### changeWebcam()

- It is used to change the webcam device.
- If multiple webcam devices are connected, by using `changeWebcam()`, one can change the camera device.

#### Parameters

- **deviceId**: String

#### Returns

- _`void`_

#### Example

```javascript
meeting.changeWebcam(deviceId);
```

---

### on()

- It is used to listen [`Meeting`](introduction) related events.

#### Parameters

- event

  - type: [`Events`](events)
  - This will specify the event to be listened.

- eventHandler
  - type: [`Function`](https://api.dart.dev/stable/2.15.1/dart-core/Function-class.html)
  - This will be invoked whenever, specified event occurred.

#### Returns

- _`void`_

#### Example

```js
meeting.on(Events.meetingJoined, () {
  // do something
});
```

</div>


---

---
sidebar_position: 1
sidebar_label: Properties
pagination_label: Meeting Class Properties
title: Meeting Class Properties
---

import NoIndex from '../../../../../mdx/\_no-index.mdx';

<NoIndex/>

# Meeting Class Properties - Flutter

<div class="sdk-api-ref-only-h4">

### id

- type: [`String`](https://api.dart.dev/stable/2.15.1/dart-core/String-class.html)

- Unique id of the meeting where the participant has joined.

---

### activeSpeakerId

- type: [`String?`](https://api.dart.dev/stable/2.15.1/dart-core/String-class.html)

- It will be the `id` of the participant who is actively speaking in the meeting. If no participant is speaking, at that time value of `activeSpeakerId` will be `null`.

---

### activePresenterId

- type: [`String?`](https://api.dart.dev/stable/2.15.1/dart-core/String-class.html)

- It will be the `id` of the participant who started `Presenting` / `Screen sharing` in the meeting. If no participant is sharing the screen, at that time value of `activePresenterId` will be `null`.

---

### selectedWebcamId

- type: [`String?`](https://api.dart.dev/stable/2.15.1/dart-core/String-class.html)
- It will be the `id` of webcam, which is currently selected. If no webcam is selected, at that time, value of `selectedWebCamId` will be `null`.

---

### selectedMicId

- type: [`String?`](https://api.dart.dev/stable/2.15.1/dart-core/String-class.html)
- It will be the `id` of microphone, which is currently selected. If no microphone is selected, at that time, value of `selectedMicId` will be `null`.

---

### localParticipant

- type: [Participant](../participant-class/introduction)

- It will be the instance of [Participant](../participant-class/introduction) class for the local participant(You) who joined the meeting.

---

### participants

- type: [`Map`](https://api.dart.dev/stable/2.15.1/dart-core/Map-class.html) of [`String`](https://api.dart.dev/stable/2.15.1/dart-core/String-class.html) and [Participant](../participant-class/introduction)

- `Map<String, Participant>`

  - Map{'<'}`participantId`, [Participant](../participant-class/introduction)>

- It will contain all joined participants in the meeting except the `localParticipant`.

- This will be the [`Map`](https://api.dart.dev/stable/2.15.1/dart-core/Map-class.html) what will container all participants attached with the key as id of that participant.

```javascript
String remoteParticipantId = "ajf897";

Participant? remoteParticipant = meeting.participants[remoteParticipantId];
```

---

### pubSub

- type: [`PubSub`](../pubsub-class/introduction)
- It is used to enable Publisher-Subscriber feature in [`meeting`](introduction) class.

Learn more about `PubSub`, [here](../pubsub-class/introduction)

</div>


---

---
title: Meeting class for Flutter SDK.
hide_title: false
hide_table_of_contents: false
description: RTC Meeting Class provides features to implement custom meeting layout in your application.
sidebar_label: Meeting Class
pagination_label: Meeting Class
keywords:
  - RTC IOS
  - Meeting Class
  - Video API
  - Video Conferencing
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: meeting-class
---

import NoIndex from '../../../../mdx/\_no-index.mdx';

<NoIndex/>

# Meeting Class - Flutter

## Using Meeting Class

The `Meeting Class` includes methods and events for managing meetings, participants, video & audio streams, data channels and UI customization.

import MethodListGroup from '@theme/MethodListGroup';
import MethodListItemLabel from '@theme/MethodListItemLabel';
import MethodListHeading from '@theme/MethodListHeading';

### Properties

<MethodListGroup>
  <MethodListItemLabel name="__properties"  >
    <MethodListGroup>
      <MethodListHeading heading="Properties" />
      <MethodListItemLabel description={"meeting Id"} name="id"  type={"String"} />
      <MethodListItemLabel description={"local participant of the meeting"} name="localParticipant"  type={"Participant"} />
      <MethodListItemLabel description={"all remote participants of the meeting"} name="participants"  type={"Map<String, Participant>"} />
      <MethodListItemLabel description={"Publisher-Subscriber feature"} name="pubSub"  type={"PubSub"} />
      <MethodListItemLabel description={"Id of the webcam device selected as input video source"} name="selectedWebcamId"  type={"String?"} />
      <MethodListItemLabel description={"Id of the microphone device selected as input audio source"} name="selectedMicId"  type={"String?"} />
    </MethodListGroup>
  </MethodListItemLabel>
</MethodListGroup>

### Events

<MethodListGroup>
  <MethodListItemLabel name="__events" >
    <MethodListGroup>
      <MethodListHeading heading="Events" />
      <MethodListItemLabel description={"emitted when local participant joined the meeting successfuly"} name="Events.meetingJoined"  type={"void"} />
      <MethodListItemLabel description={"emitted when local participant left the meeting"} name="Events.meetingLeft"  type={"void"} />      
      <MethodListItemLabel description={"emitted when new participant joined the meeting"} name="Events.participantJoined"  type={"participant"} />
      <MethodListItemLabel description={"emitted when any participant from the meeting left"} name="Events.participantLeft"  type={"participantId"} />
      <MethodListItemLabel description={"emitted when recording of the meeting is started successfully"} name="Events.recordingStarted" type={"void"} />
      <MethodListItemLabel description={"emitted when recording of the meeting is stopped"} name="Events.recordingStopped" type={"void"} />
      <MethodListItemLabel description={"emitted when live streaming of the meeting in social media is started successfully"} name="Events.liveStreamStarted" type={"void"} />
      <MethodListItemLabel description={"emitted when live streaming of the meeting is stopped"} name="Events.liveStreamStopped" type={"void"} />
      <MethodListItemLabel description={"emitted when active speaker is changed"} name="Events.speakerChanged" type={"void"} />
      <MethodListItemLabel description={"emitted when any participant started presenting"} name="Events.presenterChanged" type={"void"} />
      </MethodListGroup>
  </MethodListItemLabel>
</MethodListGroup>

### Methods

<MethodListGroup>
  <MethodListItemLabel name="__methods" >
    <MethodListGroup>
      <MethodListHeading heading="Methods" />
      <MethodListItemLabel description={"join the meeting"} type={"void"} name="join()" />
      <MethodListItemLabel description={"leave the meeting"} type={"void"} name="leave()" />
      <MethodListItemLabel description={"enable self webcam"} type={"void"} name="enableWebcam()" />
      <MethodListItemLabel description={"disable self webcam"} type={"void"} name="disableWebcam()" />
      <MethodListItemLabel description={"unmute self mic"} type={"void"} name="unmuteMic()" />
      <MethodListItemLabel description={"mute self mic"} type={"void"} name="muteMic()" />
      <MethodListItemLabel description={"start sharing phone screen"} type={"void"} name="enableScreenShare()" />
      <MethodListItemLabel description={"stop sharing phone screen"} type={"void"} name="disableScreenShare()" />
      <MethodListItemLabel description={"get all webcam devices"} type={"void"} name="getWebcams()"  />
      <MethodListItemLabel description={"get all mic devices"} type={"void"} name="getMics()"  />
      <MethodListItemLabel description={"change self webcam"} type={"void"} name="changeWebcam()" option={"<deviceId>"} />
      <MethodListItemLabel description={"start screen sharing"} type={"void"} name="enableScreenShare()" />
      <MethodListItemLabel description={"stop screen sharing"} type={"void"} name="disableScreenShare()" />
      <MethodListItemLabel description={"start meeting recording"} type={"void"} name="startRecording()" />
      <MethodListItemLabel description={"stop meeting recording"} type={"void"} name="stopRecording()" />
      <MethodListItemLabel description={"start meeting live streaming"} type={"void"} name="startLivestream()" />
      <MethodListItemLabel description={"stop meeting live streaming"} type={"void"} name="stopLivestream()" />
      <MethodListItemLabel description={"event handler of the meeting"} type={"void"} name="on(Events event, Function handler)" />
    </MethodListGroup>
  </MethodListItemLabel>
</MethodListGroup>

## Example

```js title="Play with meeting instance"
// Join the meeting
meeting?.join();

// Get local participants
meeting?.localParticipant;

// Get remote participants
meeting?.participants;

// Adding event listner
meeting.on(Events.participantJoined, (Participant participant) {
  print("new participant => $participant");
  },
);
```


---

---
title: Participant Class Events
sidebar_position: 1
sidebar_label: Events
pagination_label: Participant Class Events
---

import NoIndex from '../../../../../mdx/\_no-index.mdx';

<NoIndex/>

# Participant Class Events - Flutter

<div class="sdk-api-ref-only-h4">

---

### streamEnabled

- This event will be emitted when any [participant](introduction) starts consuming or producing stream of any type.

#### Example

```javascript
meeting.localParticipant.on(Events.streamEnabled, (Stream stream){
  // do something
});
```

---

### streamDisabled

- This event will be emitted when any [participant](introduction) stops consuming or producing stream of any type.

#### Example

```javascript
meeting.localParticipant.on(Events.streamDisabled, (Stream stream){
  // do something
});
```

---

### streamPaused

- This event will be emitted when any [participant](introduction) pauses consuming or producing stream of any type.

#### Example

```javascript
meeting.localParticipant.on(Events.streamPaused, (Stream stream){
  // do something
});
```

---

### streamResumed

- This event will be emitted when any [participant](introduction) resumes consuming or producing stream of any type.

#### Example

```javascript
meeting.localParticipant.on(Events.streamResumed, (Stream stream){
  // do something
});
```

</div>


---

---
title: Video SDK Participant Class
sidebar_position: 1
sidebar_label: Introduction
pagination_label: Video SDK Participant Class
---

import NoIndex from '../../../../../mdx/\_no-index.mdx';

<NoIndex/>

# Video SDK Participant Class - Flutter

<div id="tailwind" class="sdk-api-ref">

## Introduction

`Participant` class includes all the properties, methods and events related to the participants joined in a particular meeting.

## Participant Properties

<div class="row">
<div class="col col--4 margin-bottom--sm" >

- [id](properties#id)

</div>
<div class="col col--4 margin-bottom--sm" >

- [displayName](properties#displayname)

</div>
<div class="col col--4 margin-bottom--sm" >

- [isLocal](properties#islocal)

</div>
<div class="col col--4 margin-bottom--sm" >

- [streams](properties#streams)

</div>
</div>

## Participant Methods

<div class="row">
<div class="col col--4 margin-bottom--sm" >

- [enableWebcam](methods#enablewebcam)

</div>
<div class="col col--4 margin-bottom--sm" >

- [disableWebcam](methods#disablewebcam)

</div>
<div class="col col--4 margin-bottom--sm" >

- [enableMic](methods#enablemic)

</div>
<div class="col col--4 margin-bottom--sm" >

- [disableMic](methods#disablemic)

</div>
<div class="col col--4 margin-bottom--sm" >

- [setQuality](methods#setquality)

</div>
<div class="col col--4 margin-bottom--sm" >

- [setViewPort](methods#setviewport)

</div>
<div class="col col--4 margin-bottom--sm" >

- [remove](methods#remove)

</div>
<div class="col col--4 margin-bottom--sm" >

- [on](methods#on)

</div>
</div>

## Participant Events

<div class="row">
<div class="col col--4 margin-bottom--sm" >

- [streamEnabled](events#streamenabled)

</div>
<div class="col col--4 margin-bottom--sm" >

- [streamDisabled](events#streamdisabled)

</div>
<div class="col col--4 margin-bottom--sm" >

- [streamPaused](events#streampaused)

</div>
<div class="col col--4 margin-bottom--sm" >

- [streamResumed](events#streamresumed)

</div>
</div>
</div>


---

---
title: Participant Class Methods
sidebar_position: 1
sidebar_label: Methods
pagination_label: Participant Class Methods
---

import NoIndex from '../../../../../mdx/\_no-index.mdx';

<NoIndex/>

# Participant Class Methods - Flutter

<div class="sdk-api-ref-only-h4">

### enableWebcam()

- `enableWebcam()` is used to enable participant's camera.

#### Events associated with `enableWebcam()`:

- First the participant will get a callback on [webcamRequested](../meeting-class/events#webcamrequested) and once the participant accepts the request, webcam will be enabled.
- Every Participant will receive a `streamEnabled` event with `stream` object.

#### Returns

- _`void`_

#### Example

```js
participant.enableWebcam();
```

---

### disableWebcam()

- `disableWebcam()` is used to disable participant camera.

#### Events associated with `disableWebcam()`:

- Every Participant will receive a `streamDisabled` event with `stream` object.

#### Returns

- _`void`_

#### Example

```js
participant.disableWebcam();
```

---

### enableMic()

- `enableMic()` is used to enable participant microphone.

#### Events associated with `enableMic()`:

- First the participant will get a callback on [micRequested](../meeting-class/events#micrequested) and once the participant accepts the request, mic will be enabled.
- Every Participant will receive a `streamEnabled` event with `stream` object.

#### Returns

- _`void`_

#### Example

```js
participant.enableMic();
```

---

### disableMic()

- `disableMic()` is used to disable participant microphone.

#### Events associated with `disableMic()`:

- Every Participant will receive a `streamDisabled` event with `stream` object.

#### Returns

- _`void`_

#### Example

```js
participant.disableMic();
```

---

### setQuality()

- It is used to set the quality of the participant's video stream.

#### Parameters

- **quality**: `"low"`|| `"med"` | `"high"`

#### Returns

- _`void`_

#### Example

```js
participant.setQuality("high");
```

---

### setViewPort()

- `setViewPort()` is used to set the quality of the participant's video stream based on the viewport height and width.

#### Parameters

- **width**: int
- **height**: int

#### Returns

- `void`

#### Example

```js
participant.setViewPort(480, 360);
```

---

### remove()

- It is used to remove participant from the meeting.

#### Returns

- _`void`_

#### Example

```js
participant.remove();
```

---

### on()

- It is used to listen [`Participant`](introduction) related events.

#### Parameters

- event

  - type: [`Events`](events)
  - This will specify the event to be listened.

- eventHandler
  - type: [`Function`](https://api.dart.dev/stable/2.15.1/dart-core/Function-class.html)
  - This will be invoked whenever, specified event occurred.

#### Returns

- _`void`_

#### Example

```js
participant.on(Events.streamEnabled, (Stream stream){
    // do something
});
```

</div>


---

---
title: Participant class for IOS SDK.
hide_title: false
hide_table_of_contents: false
description: The `Participant Class` includes methods and events for participants and their associated video & audio streams, data channels and UI customization.
sidebar_label: Participant Class
pagination_label: Participant Class
keywords:
  - RTC IOS
  - Participant Class
  - Video API
  - Video Conferencing
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: participant-class
---

import NoIndex from '../../../../../mdx/\_no-index.mdx';

<NoIndex/>

# Participant Class - Flutter

## Using Participant Class

The `Participant Class` includes methods and events for participants and their associated video & audio streams, data channels and UI customization.

import MethodListGroup from '@theme/MethodListGroup';
import MethodListItemLabel from '@theme/MethodListItemLabel';
import MethodListHeading from '@theme/MethodListHeading';

### Properties

<MethodListGroup>
  <MethodListItemLabel name="__properties"  >
    <MethodListGroup>
      <MethodListHeading heading="Properties" />
      <MethodListItemLabel description={"id of participant"} name="id"  type={"String"}  />
      <MethodListItemLabel description={"display name of participant"} name="displayName"  type={"String"} />
    </MethodListGroup>
  </MethodListItemLabel>
</MethodListGroup>

### Methods

<MethodListGroup>
  <MethodListItemLabel name="__methods" >
    <MethodListGroup>
      <MethodListHeading heading="Methods" />
      <MethodListItemLabel description={"participant event handler"} name="on(Events event, Function handler)"  type={"Function"} />
      <MethodListItemLabel description={"Streams of participant i.e. audio stream, video stream and share stream"} name="streams"  type={"Map<String, Stream>"} />
      <MethodListItemLabel description={"Request participant to enable webcam the participant"} name="enableWebcam()"  type={"Function"} />
      <MethodListItemLabel description={"Disable webcam of the participant"} name="disableWebcam()"  type={"Function"} />
      <MethodListItemLabel description={"Request participant to enable mic the participant"} name="enableMic()"  type={"Function"} />
      <MethodListItemLabel description={"Disable mic of the participant"} name="disableMic()"  type={"Function"} />
      <MethodListItemLabel description={"Set video quality of the participant"} name="setQuality(<quality>)"  type={"Function"} option={"'low' | 'med' | 'high'"} />
      <MethodListItemLabel description={"Remove the participant from meeting session"} name="remove()"  type={"Function"} />
    </MethodListGroup>
  </MethodListItemLabel>
</MethodListGroup>

### Events

<MethodListGroup>
  <MethodListItemLabel name="__events" >
    <MethodListGroup>
      <MethodListHeading heading="Events" />
      <MethodListItemLabel description={"This event will be emitted when any stream i.e. audio, video or sharescreen, of the participant is enabled."} name="streamEnabled"  type={"Stream"} />
      <MethodListItemLabel description={"This event will be emitted when any stream i.e. audio, video or sharescreen, of the participant is disabled."} name="streamDisabled"  type={"Stream"} />
      <MethodListItemLabel description={"This event will be emitted when any stream i.e. audio, video or sharescreen, of the participant is paused."} name="streamPaused"  type={"Stream"} />
      <MethodListItemLabel description={"This event will be emitted when any stream i.e. audio, video or sharescreen, of the participant is resumed."} name="streamResumed"  type={"Stream"} />
    </MethodListGroup>
  </MethodListItemLabel>
</MethodListGroup>

<!--

### Methods

<MethodListGroup>
  <MethodListItemLabel name="__methods" >
    <MethodListGroup>
      <MethodListHeading heading="Methods" />
      <MethodListGroup>
        <MethodListHeading heading="addStream(stream): void" />
        <MethodListItemLabel name="stream"  type={"MediaStream"} />
      </MethodListGroup>
      <MethodListGroup>
        <MethodListHeading heading="removeStream(streamId): void" />
        <MethodListItemLabel name="streamId"  type={"String"} />
      </MethodListGroup>
    </MethodListGroup>
  </MethodListItemLabel>
</MethodListGroup> -->

## Example

```js title="Play with Participant instance"
// get displayName
participant.displayName;

// Set video quality of that participant to low
participant.setQuality("low");

// Adding event listeners in participant
participant.on(Events.streamEnabled, (Stream stream) {
  // this stream is enabled
});

participant.on(Events.streamDisabled, (Stream stream) {
  // this stream is disabled
});
```


---

---
title: Participant Class Properties
sidebar_position: 1
sidebar_label: Properties
pagination_label: Participant Class Properties
---

import NoIndex from '../../../../../mdx/\_no-index.mdx';

<NoIndex/>

# Participant Class Properties - Flutter

<div class="sdk-api-ref-only-h4">

### id

- type: [`String`](https://api.flutter.dev/flutter/dart-core/String-class.html)

- Unique id of the participant, who has joined the meeting.

---

### displayName

- type: [`String`](https://api.flutter.dev/flutter/dart-core/String-class.html)

- It will be the `displayName` of the participant, who has joined the meeting.

---

### isLocal

- type: [`bool`](https://api.flutter.dev/flutter/dart-core/bool-class.html)

- It will represents whether the participant is [`LocalParticipant`](../meeting-class/properties#localparticipant)(You) or not. If it is true, then participant is [`LocalParticipant`](../meeting-class/properties#localparticipant) otherwise RemoteParticipant.

---

### streams

- type: [`Map<String, Stream>`](https://api.flutter.dev/flutter/dart-core/Map-class.html)

- It will represents the stream for that particular participant who has joined the meeting. Stream could be `audio` , `video` or `share`.

---

</div>


---

---
title: Video SDK PubSub Class
sidebar_position: 1
sidebar_label: Introduction
pagination_label: Video SDK PubSub Class
---

import NoIndex from '../../../../../mdx/\_no-index.mdx';

<NoIndex/>

# Video SDK PubSub Class - Flutter

<div class="sdk-api-ref">

## Introduction

PubSub class provides the methods to implement Publisher-Subscriber feature in your Flutter Application.

## PubSub Methods

<div class="row">

<div class="col col--4 margin-bottom--sm" >

- [publish](methods#publish)

</div>
<div class="col col--4 margin-bottom--sm" >

- [subscribe](methods#subscribe)

</div>

<div class="col col--4 margin-bottom--sm" >

- [unsubscribe](methods#unsubscribe)

</div>
</div>
</div>


---

---
sidebar_position: 1
sidebar_label: Methods
pagination_label: PubSub Class Methods
title: PubSub Class Methods
---

import NoIndex from '../../../../../mdx/\_no-index.mdx';

<NoIndex/>

# PubSub Class Methods - Flutter

<div class="sdk-api-ref-only-h4">

### publish()

- `publish()` is used to publish messages on a specified topic in the meeting.

#### Parameters

- topic

  - type: [`String`](https://api.dart.dev/stable/2.15.1/dart-core/String-class.html)
  - This is the name of the topic, for which message will be published.

- message

  - type: [`String`](https://api.dart.dev/stable/2.15.1/dart-core/String-class.html)
  - This is the actual message.

- options
  - type: [`PubSubPublishOptions`](pubsub-publish-options-class)
  - This specifies the options for publish.

#### Returns

- _`Future<void>`_

#### Example

```js
// Publishing message
meeting.pubSub
    .publish(
      "CHAT",
      "Hii",
      const PubSubPublishOptions(persist: true),
    );
```

---

### subscribe()

- `subscribe()` is used to subscribe a particular topic to get all the messages of that particular topic in the meeting.

#### Parameters

- topic:

  - type: [`String`](https://api.dart.dev/stable/2.15.1/dart-core/String-class.html)
  - Participants can listen to messages on that particular topic.

- messageHandler:

  - type: [`Function(PubSubMessage)`](pubsub-message-class)
  - This function will be called, whenever pubsub message received.

#### Returns

- [_`Future<PubSubMessages>`_](pubsub-message-class)

#### Example

```js
// Subscribing 'CHAT' Topic

void handleMessage(PubSubMessage pubsubMessage) {
  print(pubsubMessage.message);
}

void subscribePubSubTopic() async {
  PubSubMessages pubsubMessages =
      meeting.pubSub.subscribe("CHAT", handleMessage);

  // do something
}

subscribePubSubTopic();
```

---

### unsubscribe()

- `unsubscribe()` is used to unsubscribe a particular topic on which you have subscribed priviously.

#### Parameters

- topic:

  - type: [`String`](https://api.dart.dev/stable/2.15.1/dart-core/String-class.html)
  - This is the name of the topic to be unsubscribed.

- messageHandler:

  - type: [`Function(PubSubMessage)`](https://api.dart.dev/stable/2.15.1/dart-core/Function-class.html)
  - This is the message handler to be unsubscribed.

#### Returns

- _`Future<void>`_

#### Example

```js
// Unsubscribing 'CHAT' topic
meeting.pubSub.unsubscribe("CHAT", handleMessage);
```

</div>


---

---
sidebar_position: 1
sidebar_label: PubSubMessage Class
pagination_label: PubSubMessage Class
title: PubSubMessage Class
---

import NoIndex from '../../../../../mdx/\_no-index.mdx';

<NoIndex/>

# PubSubMessage Class - Flutter

<div class="sdk-api-ref-only-h4">

## Properties

### id

- type: [`String`](https://api.dart.dev/stable/2.15.1/dart-core/String-class.html)

- Unique id of the pubsub message.

---

### message

- type: [`String`](https://api.dart.dev/stable/2.15.1/dart-core/String-class.html)

- Message that has been published on the specific topic.

---

### topic

- type: [`String`](https://api.dart.dev/stable/2.15.1/dart-core/String-class.html)

- Name of the topic.

---

### senderId

- type: [`String`](https://api.dart.dev/stable/2.15.1/dart-core/String-class.html)

- This is the id of the participant, who has sent this pubsub message.

---

### senderName

- type: [`String`](https://api.dart.dev/stable/2.15.1/dart-core/String-class.html)

- This is the name of the participant, who has sent this pubsub message.

---

### timestamp

- type: [`DateTime`](https://api.dart.dev/stable/2.15.1/dart-core/DateTime-class.html)

- Timestamp of when a message has been published.

</div>


---

---
sidebar_position: 1
sidebar_label: PubSubPublishOptions Class
pagination_label: PubSubPublishOptions Class
title: PubSubPublishOptions Class
---

import NoIndex from '../../../../../mdx/\_no-index.mdx';

<NoIndex/>

# PubSubPublishOptions Class - Flutter

<div class="sdk-api-ref-only-h4">

## Properties

### persist

- type: [`bool`](https://api.dart.dev/stable/2.15.1/dart-core/bool-class.html)

- defaultValue: `false`

- This property specifies whether to store messages on server for upcoming participants.

- If the value of this property is true, then server will store pubsub messages for the upcoming participants.

</div>


---

---
title: PubSubMessage class for Flutter SDK.
hide_title: false
hide_table_of_contents: false
description: PubSubMessage Class
sidebar_label: PubSubMessage Class
pagination_label: PubSubMessage Class
keywords:
  - RTC Flutter
  - Publisher-Subscriber
  - PubSub
  - PubSubMessage
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: pubsub-message-class
---

import NoIndex from '../../../../mdx/\_no-index.mdx';

<NoIndex/>

# PubSubMessage Class - Flutter

## using PubSubMessage Class

The `PubSubMessage` includes properties of PubSub message.

import MethodListGroup from '@theme/MethodListGroup';
import MethodListItemLabel from '@theme/MethodListItemLabel';
import MethodListHeading from '@theme/MethodListHeading';

### Properties

<MethodListGroup>
  <MethodListItemLabel name="__properties"  >
    <MethodListGroup>
      <MethodListHeading heading="Properties" />
      <MethodListItemLabel name="id" type={"String"} />
      <MethodListItemLabel name="message" type={"String"} />
      <MethodListItemLabel name="senderId" type={"String"} />
      <MethodListItemLabel name="senderName" type={"String?"} />
      <MethodListItemLabel name="timestamp" type={"DateTime"} />
      <MethodListItemLabel name="topic" type={"String"} />
    </MethodListGroup>
  </MethodListItemLabel>
</MethodListGroup>


---

---
title: PubSubOptions class for Flutter SDK.
hide_title: false
hide_table_of_contents: false
description: PubSubOptions Class
sidebar_label: PubSubOptions Class
pagination_label: PubSubOptions Class
keywords:
  - RTC Flutter
  - PubSub
  - PubSubOptions
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: pubsub-options-class
---

import NoIndex from '../../../../mdx/\_no-index.mdx';

<NoIndex/>

# PubSubOptions Class - Flutter

## using PubSubOptions Class

The `PubSubOptions` includes properties of PubSub options.

import MethodListGroup from '@theme/MethodListGroup';
import MethodListItemLabel from '@theme/MethodListItemLabel';
import MethodListHeading from '@theme/MethodListHeading';

### Properties

<MethodListGroup>
  <MethodListItemLabel name="__properties"  >
    <MethodListGroup>
      <MethodListHeading heading="Properties" />
      <MethodListItemLabel name="persist" type={"bool"} description={"Specifies whether to store messages on server for upcoming participants"} />
    </MethodListGroup>
  </MethodListItemLabel>
</MethodListGroup>


---

---
title: Installation Steps for RTC Flutter SDK
hide_title: false
hide_table_of_contents: false
description: RTC Flutter SDK provides client for almost all Android and IOS devices. it takes less amount of cpu and memory.
sidebar_label: Setup
pagination_label: Setup
keywords:
  - RTC FLUTTER
  - FLUTTER SDK
  - DART SDK
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: setup
---

import NoIndex from '../../../../mdx/\_no-index.mdx';

<NoIndex/>

# Setup - Flutter

Flutter SDK is client for real-time communication for android and ios devices. It inherits the same terminology as all other SDKs does.

## Minimum OS/SDK versions

Android: minSdkVersion >= 23

<!-- ### IOS: > 11 -->

## Use this package as a library

### Step 1: Add this package in your flutter project

Run this command:

```js
flutter pub add videosdk
```

This will add a line like this to your package's pubspec.yaml (and run an implicit flutter pub get):

```js
dependencies:
  videosdk: ^0.0.12
```

Alternatively, your editor might support or flutter pub get. Check the docs for your editor to learn more.

### Step 2: Import it

Now in your Dart code, you can use:

```js
import "package:videosdk/rtc.dart";
import "package:videosdk/meeting.dart";
import "package:videosdk/meeting_builder.dart";
import "package:videosdk/participant.dart";
import "package:videosdk/rtc.dart";
import "package:videosdk/stream.dart";
```


---

---
title: Video SDK Stream Class
sidebar_position: 1
sidebar_label: Introduction
pagination_label: Video SDK Stream Class
---

import NoIndex from '../../../../../mdx/\_no-index.mdx';

<NoIndex/>

# Video SDK Stream Class - Flutter

<div class="sdk-api-ref">

## Introduction

Stream class is responsible for handling audio, video and screen sharing streams.

Stream class defines instance of audio, video and shared screen stream of participants.

## Stream Properties

<div class="row">
<div class="col col--4 margin-bottom--sm" >

- [id](properties#id)

</div><div class="col col--4 margin-bottom--sm" >

- [kind](properties#kind)

</div><div class="col col--4 margin-bottom--sm" >

- [track](properties#track)

</div><div class="col col--4 margin-bottom--sm" >

- [renderer](properties#renderer)

</div>
</div>

## Stream Methods

<div class="row">
<div class="col col--4 margin-bottom--sm" >

- [resume](methods#resume)

</div>
<div class="col col--4 margin-bottom--sm" >

- [pause](methods#pause)

</div>
</div>
</div>


---

---
sidebar_position: 1
sidebar_label: Methods
pagination_label: Stream Class Methods
title: Stream Class Methods
---

import NoIndex from '../../../../../mdx/\_no-index.mdx';

<NoIndex/>

# Stream Class Methods - Flutter

<div class="sdk-api-ref-only-h4">

### resume()

- By using `resume()`, a participant can resume the stream of Remote Participant.

#### Events associated with `resume()` :

- All participants will receive a [`streamResumed`](../participant-class/events#streamresumed) event with [`stream`](introduction) object

#### Returns

- _`void`_

#### Example

```js
stream.resume();
```

---

### pause()

- By using `pause()`, a participant can pause the stream of Remote Participant.

#### Events associated with `pause()` :

- All participants will receive a [`streamPaused`](../participant-class/events#streampaused) event with [`stream`](introduction) object

#### Returns

- _`void`_

#### Example

```js
stream.pause();
```

</div>


---

---
title: Stream Class Properties
sidebar_position: 1
sidebar_label: Properties
pagination_label: Stream Class Properties
---

import NoIndex from '../../../../../mdx/\_no-index.mdx';

<NoIndex/>

# Stream Class Properties - Flutter

<div class="sdk-api-ref-only-h4">

### id

- type: `String`

- Represents the id for that stream .

---

### kind

- type: `String?`

- `kind` represents the type of stream which could be `audio` | `video` or `share` .

---

### renderer

- type: `RTCVideoRenderer?`

- This is a renderer, which is passed to RTCVideoView widget.

---

### track

- type: `Consumer`

- It represents a single media track within a stream.

</div>


---

---
title: Stream class for Flutter SDK.
hide_title: false
hide_table_of_contents: false
description: RTC Stream Class enables opportunity to .
sidebar_label: Stream Class
pagination_label: Stream Class
keywords:
  - RTC Android
  - Stream Class
  - Video API
  - Video Conferencing
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: stream-class
---

import NoIndex from '../../../../../mdx/\_no-index.mdx';

<NoIndex/>

# Stream Class - Flutter

## using Stream Class

The `Stream Class` includes methods and events video & audio streams.

import MethodListGroup from '@theme/MethodListGroup';
import MethodListItemLabel from '@theme/MethodListItemLabel';
import MethodListHeading from '@theme/MethodListHeading';

### Properties

<MethodListGroup>
  <MethodListItemLabel name="__properties"  >
    <MethodListGroup>
      <MethodListHeading heading="Properties" />
      <MethodListItemLabel name="id" type={"String"} />
      <MethodListItemLabel name="track" type={"Consumer"} description="video | audio | share" />
      <MethodListItemLabel name="kind" type={"String?"} />
      <MethodListItemLabel name="renderer" type={"RTCVideoRenderer?"} />
    </MethodListGroup>
  </MethodListItemLabel>
</MethodListGroup>

### Methods

<MethodListGroup>
  <MethodListItemLabel name="__methods" >
    <MethodListGroup>
      <MethodListHeading heading="Methods" />
      <MethodListItemLabel type={"void"} name="pause()" />
      <MethodListItemLabel type={"void"} name="resume()" />
    </MethodListGroup>
  </MethodListItemLabel>
</MethodListGroup>

## Example

```js title="Play with Stream instance"
// pause stream
stream?.pause();

// resume stream
stream?.resume();
```


---

---
title: Terminology - Video SDK Documentation
hide_title: true
hide_table_of_contents: false
description: Video SDK enables the opportunity to integrate native IOS, Android & Web SDKs to add live video & audio conferencing to your applications.
sidebar_label: Terminology
pagination_label: Terminology
keywords:
  - audio calling
  - video calling
  - real-time communication
  - collaboration
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: terminology
---

import Terminology from '../../../../mdx/introduction/\_terminology.mdx';
import NoIndex from '../../../../mdx/\_no-index.mdx';

<NoIndex/>

<Terminology title="Terms related to VideoSDK - Flutter" />


---

---
title: Authentication in Video & Audio Calling SDK
hide_title: false
hide_table_of_contents: false
description: This guide will explain authentication and token flow for video & audio calling SDK.
sidebar_label: Authentication and Tokens
pagination_label: Authentication and Tokens
keywords:
  - authentication audio calling
  - authentication video calling
  - authentication real-time communication
  - tokens
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: authentication-and-tokens
---

import Mermaid from '@theme/Mermaid';
import NoIndex from '../../../../mdx/\_no-index.mdx';

<NoIndex/>

# Authentication and Token - Flutter

VideoSDK uses access tokens for authentication. Using our dashboard ([app.videosdk.live](https://app.videosdk.live/)), anyone can generate access tokens tokens with an API key and secret pair.

- Your backend server will generate access tokens using API Key and secret.
- Your client obtains token from your backend server.
- Your client will pass the token to VideoSDK server.
- VideoSDK client sdk will conncts to the VideoSDK server with available token.
- VideoSDK server will validate the token and accpets your incoming connection.

Here is the simple sequence diagram represents the authentication.
<Mermaid chart={`sequenceDiagram Your App Client->>Your App Server: Request for token; activate Your App Server; Note left of Your App Server: Generate token; Your App Server-->>Your App Client: Received token; deactivate Your App Server; Your App Client->>VideoSDK Server: Request to establish connection; activate VideoSDK Server; Note left of VideoSDK Server: Validates Token; VideoSDK Server-->>Your App Client: Connection established; deactivate VideoSDK Server;`}/>

## Generate API Key and Secret

Visit, [app.videosdk.live](https://app.videosdk.live/) to gererate API Key and secret.

![Generate API Key from Dashboard](/img/tutorial/generate-api-key.jpg)

## Generate Access Token

For security, every participant that connects to meeting needs a access token. By substituting `apikey` and `permissions` in it.

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

<Tabs
defaultValue="node"
groupId={"server-group-id"}
values={[
{label: 'Node.js', value: 'node'},
{label: 'Python', value: 'python'},
{label: 'Java', value: 'java'},
{label: 'Ruby', value: 'ruby'},
{label: 'PHP', value: 'php'},
]}>
<TabItem value="node">

```js
var jwt = require("jsonwebtoken");
var uuid4 = require("uuid4");

// Need to generate from app.videosdk.live
const API_KEY = "API_KEY_GENERATED";
const SECRET_KEY = "API_SECRET_KEY_GENERATED";

jwt.sign(
  {
    apikey: API_KEY,
    permissions: ["allow_join"], // Permission to join the meeting
  },
  SECRET_KEY,
  {
    algorithm: "HS256",
    expiresIn: "24h",
    jwtid: uuid4(),
  },
  function (err, token) {
    console.log(token);
  }
);
```

</TabItem>
<TabItem value="python">

```python
#!/usr/bin/env python3
import jwt
import uuid
import datetime

api_key = 'api_key_generated'
secret_key = 'secret_key_generated'


def generateToken():
    expires = 24 * 3600
    now = datetime.datetime.utcnow()
    exp = now + datetime.timedelta(seconds=expires)
    return jwt.encode(payload={
          'apikey': api_key,
          permissions: ["allow_join"]
        }, key=secret_key).decode('utf-8')

if __name__ == '__main__':
    print(generateToken())
```

</TabItem>
<TabItem value="java">

```js
import java.time.Instant;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;
import java.util.UUID;
import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.SignatureAlgorithm;

private void generateManagementToken() {
    Map<String, Object> payload = new HashMap<>();
    payload.put("apikey", "<api_key_generated>");
    payload.put("permissions", ["allow_join"]);
    String token = Jwts.builder().setClaims(payload).setId(UUID.randomUUID().toString())
        .setExpiration(new Date(System.currentTimeMillis() + 86400 * 1000))
        .setIssuedAt(Date.from(Instant.ofEpochMilli(System.currentTimeMillis() - 60000)))
        .setNotBefore(new Date(System.currentTimeMillis()))
        .signWith(SignatureAlgorithm.HS256, "<secret_key_generated>".getBytes()).compact();
  }
```

</TabItem>
<TabItem value="ruby">

```js
require 'jwt'
require 'securerandom'

$api_key = "api_key_generated"
$secret_key = "secret_key_generated"

def generateToken()
    payload = {
      apikey: $api_key,
      permissions: ["allow_join"]
    }
token = JWT.encode(payload, $secret_key, 'HS256')
return token
end

puts generateToken
```

</TabItem>
<TabItem value="php">

```js
<?php

use Firebase\JWT\JWT;
use Ramsey\Uuid\Uuid;

$api_key = "api_key_generated";
$secret_key = "secret_key_generated"

$payload = [
    'apikey' => api_key,
    'permissions': ["allow_join"],
];

$token = JWT::encode($payload, $secret_key, 'HS256');
?>
```

</TabItem>
</Tabs>

Available permissions are:

- **allow_join**: The participant will be permitted entry without request.
- **ask_join**: The participant will not be permitted entry without request.
- **allow_mod**: Allow participant to enable/disable other participant's mic/webcam.


---

---
sidebar_label: Concept And Architecture
pagination_label: Concept And Architecture
---

import NoIndex from '../../../../mdx/\_no-index.mdx';

<NoIndex/>

# Concept and Architecture - Flutter

Before diving into the concept, let's understand the VideoSDK, VideoSDK is a software development kit that offers tools and APIs for creating apps that are based on video and audio. It typically includes features such as video and audio calls, chat, cloud recording, simulcasting (RTMP), interactive live streaming (HLS), and many more across a wide range of platforms and devices.

## Concepts

![img.png](../../../../static/img/room-concept.png)

### `1. Meeting / Room`

- Meeting or Room objects in the VideoSDK provide a virtual place for participants to interact and engage in real-time voice, video, and screen-sharing sessions. The object is in charge of handling media streams and participant communication.

- Meeting or Room can be uniquely identified by `meetingId` or `roomId`.

### `2. Participant`

- Participant is a VideoSDK object that represents each user/client in the meeting or room and allows them to share audio/video assets.

- `2.1 Local Participant` :
  The local participant is the one that runs on the user's device. The local participant has control over their own media streams, including the ability to start and stop audio and video.

  - The local participant in a meeting/room can also connect with other participants by transmitting and receiving audio and video streams, exchanging chat messages, and more.

- `2.2 Remote Participant` :
  The remote participant receives audio and video streams from the local participant and other remote participants and also has the ability to exchange audio, video, and chat messages with the local participant.

- Each participant in VideoSDK can be uniquely identified by `participantId`.

### `3. MediaStream & Track`

- A mediastream is a collection of audio & video tracks that can be transmitted between participants in real-time.

- A track is a continuous flow of audio or video data and can be thought of as a stream of media frames.

- A mediastream can contain multiple tracks. One video track for the video feed from the camera and one audio track for the audio feed from the microphone. These tracks can be transmitted between participants in VideoSDK Meeting / Room.

### `4. Events / Notifications`

- Events / Notifications can be used to inform users about various activities happening in a Meeting / Room, including participant join/leave and new messages. They can also be used to alert users about any SDK-level errors that occur during a call.

---

### `5. Session`

- A Session is the instance of an ongoing meeting/room which has one or more participants in it. A single room or meeting can have multiple sessions.
- Each session can be uniquely identified by `sessionId`.

![img.png](../../../../static/img/meeting-session.jpg)

---

![img.png](../../../../static/img/recording-hls-rtmp.png)

### `6. Cloud Recording`

- Cloud recording in VideoSDK refers to the process of recording audio or video content and storing it on a remote server or VideoSDK server.

### `7. Simulcasting (RTMP)`

- RTMP is a popular protocol for live streaming video content from a VideoSDK to platforms such as YouTube, Twitch, Facebook, and others.
- By providing the platform-specific `stream key` and `stream URL`, the VideoSDK can connect to the platform's RTMP server and transmit the live video stream.

### `8. Http Live Streaming (HLS)`

- Interactive live streaming (HLS) refers to a type of live streaming where viewers can actively engage with the content being streamed and with other viewers in real-time.

- In an interactive live stream (HLS), viewers can take part in a variety of activities like live polling, Q&A sessions, and even sending virtual gifts to the content creator or each other.

## Architecture

This diagram demonstrates end-to-end flow to implement video & audio calls, record calls, and go live on social media.

![Video-sdk-architecture!](/img/video-sdk-archietecture.svg)


---

---
title: Camera Controls Video & Audio Call - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: Camera Controls features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Camera Controls
pagination_label: Camera Controls
keywords:
  - Camera on
  - Camera off
  - Webcam on
  - Webcam off
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: camera-controls
---

import NoIndex from '../../../../../mdx/\_no-index.mdx';

<NoIndex/>

# Camera Controls - Flutter

Whenever any participant wants to start/stop broadcasting their video to other participant in a meeting, they can simply do it with VideoSDK Meeting.

This guide will provide an overview of how to implement enable, disable and switch webcam features in a meeting.

1. **Enable Camera** - By using `enableWebcam()` function, a participant can publish camera stream to other participants.
2. **Disable Camera** - By using `disableWebcam()` function, a participant can stop publishing camera stream to other participants.
3. **Switch Camera** - By using `changeWebcam()` function, a participant can stream from front / rear camera during the meeting.This function is only applicable for Mobile devices.

### Enable, Disable And Switch Webcam

```js
ElevatedButton(
  onPressed: meeting.disableWebcam,
  child: Text("disableWebcam"),
),
ElevatedButton(
  onPressed: meeting.enableWebcam,
  child: Text("enableWebcam"),
),
ElevatedButton(
  onPressed:  () {
    meeting?.changeWebcam("<device-id>")
  },
  child: Text("changeWebcam"),
),
```


---

---
title: Custom Participant ID - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: Custom participant id features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Custom Participant ID
pagination_label: Custom Participant ID
keywords:
  - custom participant id
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: custom-participant-id
---

import NoIndex from '../../../../../mdx/\_no-index.mdx';

<NoIndex/>

# Custom Participant ID - Flutter

- Whenever any participant joins meeting, it is assigned a new unique participant id every time.

- To assign an unique participant id manually to local participant, specify participant id in `MeetingBuilder`.

```js
MeetingBuilder(
    .
    .
    participantId: "abcd-efgh-ijkl", // custom participant id
),
```


---

---
title: Entry - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: Entry features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Entry Request-Response
pagination_label: Entry Request-Response
keywords:
  - entry request response
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: entry-request-response
---

import NoIndex from '../../../../../mdx/\_no-index.mdx';

<NoIndex/>

# Entry Request-Response - Flutter

- When anyone joins meeting, he/she will request for joining meeting and that request will get either accepted or denied by host.

## Entry Request

- When anyone asks for joining in your meeting, `Events.entryRequested` event is triggered with data having

  - `participantId` - This is the Id of participant, who have requested for joining meeting
  - `name` - This is the name of the participant.
  - `allow()` - Call this method if you want to allow that participant
  - `deny()` - Call this method if you want to deny that participant

```js
meeting.on(Events.entryRequested, (data) {
  var participantId = data['participantId'];
  var name = data["name"];
  var allow = data["allow"];
  var deny = data["deny"];

  showDialog(
    context: context,
    builder: (context) => AlertDialog(
      title: const Text("Join Request"),
      content: Text("Do you want to allow $name to join meeting?"),
      actions: [
        TextButton(
          child: const Text("Deny"),
          onPressed: () {
            deny();
            Navigator.of(context).pop();
          },
        ),
        TextButton(
          child: const Text("Allow"),
          onPressed: () {
            allow();
            Navigator.of(context).pop();
          },
        ),
      ],
    ),
  );
});
```

## Entry Respond

- If you have requested for joining meeting, `Events.entryResponded` is triggered when host accept or deny meeting.

  - `decision` - This will tell you, if you are allowed to join or not

```js
meeting.on(Events.entryResponded, (data) {
  var decision = data['decision'];
  if (id == meeting.localParticipant.id) {
    if (decision == 'allowed') {
      print("Allowed to join the meeting.");
    } else {
      print("Denied to join the meeting.");
    }
  }
});
```


---

---
title: RTMP Live Social Media Video & Audio Call - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: RTMP Live Social Media features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Go Live On Social Media
pagination_label: Go Live On Social Media
keywords:
  - Facebook Live
  - Youtube Live
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: go-live-social-media
---

import NoIndex from '../../../../../mdx/\_no-index.mdx';

<NoIndex/>

# Go Live On Social Media - Flutter

This feature allows participant to broadcast meeting on various social media platforms such as Facebook or Youtube.
This guide will provide an overview of how participant can start and stop broadcasting meeting.

1. **Start LiveStream** - By using `startLivestream()` function, a participant can start broadcasting meeting on various platforms by provding url and stream keys as an argument.
2. **Stop LiveStream** - By using `stopLivestream()` function, a participant can stop broadcasting on all platforms.

### Start And Stop Live Stream

```js
// Start Live Stream
meeting.startLivestream([
  {
    url: "rtmp://a.rtmp.youtube.com/live2",
    streamKey: "streamKey1",
  },
]);

// Stop Live Stream
meeting?.stopLivestream();
```

### Events

1. **livestreamStarted** - Whenever broadcasting of meeting started, `livestreamStarted` event will trigger.

2. **livestreamStopped** - Whenever broadcasting of meeting stopped, `livestreamStopped` event will trigger.

```js
meeting.on(Events.livestreamStarted, () {
  print("meeting livestream started");
});
//
meeting.on(Events.livestreamStopped, () {
  print("meeting livestream stopped");
});

```


---

---
title: Leave End Meeting Video & Audio Call - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: Leave or End Meeting features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Leave or End Meeting
pagination_label: Leave or End Meeting
keywords:
  - Exit Meeting
  - Leave Meeting
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: leave-end-meeting
---

import NoIndex from '../../../../../mdx/\_no-index.mdx';

<NoIndex/>

# Leave or End Meeting - Flutter

Whenever participant wishes to end their communication in the meeting, they can simply leave the meeting.

This guide will provide an overview of how to implement leave or end feature in VideoSDK meetings.

1. **Leave** - By using `leave()` function, only a participant will leave/exit the meeting, the rest of the meeting will continue with other participants.
2. **End** - By using `end()` function, meeting will end for each and every participant. So, use this function according to your use cases.

### Leave And End Meeting

```js
// Leave the meeting
meeting.leave();

// end() method is coming soon in flutter.
```


---

---
title: Manage Participants Video & Audio Call - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: Manage Participants features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Manage Participants
pagination_label: Manage Participants
keywords:
  - Exit Meeting
  - Leave Meeting
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: manage-participants
---

import NoIndex from '../../../../../mdx/\_no-index.mdx';

<NoIndex/>

# Manage Participants - Flutter

## 1. Local Participant (self)

Local participant is used to consume your video & audio streams.
it contains information about local participant such as displayName, id, quality and streams Map.

You can access localParticipant from the [meeting object](./start-join-meeting#2-initialization).

### Participant object properties

| Property Name | Type          | Description                                            |
| ------------- | ------------- | ------------------------------------------------------ |
| id            | string        | Unique id of the participant.                          |
| displayName   | string        | The name you define during the meeting initialization. |
| local         | boolean       | Indicates the participant is local or not.             |
| quality       | string        | Indicates the participant streams quality.             |
| Streams       | Map of Stream | Returns Video & Audio Streams.                         |

### Stream Object properties

| Property Name | Type   | Description        |
| ------------- | ------ | ------------------ |
| id            | string | Unique id          |
| codec         | string | Video/Audio codec. |
| kind          | string | Stream Kind.       |
| track         | string | MediaStreamTrack   |

## 2. Other Participants (Except You)

Other participants Map is used to get all the participants (except you) in the meeting at any given time.

Other participants Map contains same properties as [LocalParticipant](/flutter/guide/video-and-audio-calling-api-sdk/features/manage-participants#participant-object-properties).

### ParticipantTile

```js title=participant_tile.dart
import 'package:flutter/material.dart';
import 'package:videosdk/rtc.dart';
import '../../utils/toast.dart';

class ParticipantTile extends StatefulWidget {
  final Participant participant;
  final bool isLocalParticipant;
  const ParticipantTile({
    Key? key,
    required this.participant,
    this.isLocalParticipant = false,
    }): super(key: key);

  @override
  State<ParticipantTile> createState() => _ParticipantTileState();
}

class _ParticipantTileState extends State<ParticipantTile> {
  Stream? shareStream;
  Stream? videoStream;
  Stream? audioStream;
  String? quality;

  @override
  void initState() {
    _initStreamListeners();
    super.initState();
  }

  @override
  Widget build(BuildContext context) {
    return Container(
        margin: const EdgeInsets.all(4.0),
        decoration: BoxDecoration(
          color: Theme.of(context).backgroundColor.withOpacity(1),
          border: Border.all(color: Colors.white38),
        ),
        child: AspectRatio(
          aspectRatio: 1,
          child: Padding(
            padding: const EdgeInsets.all(4.0),
            child: Stack(
              children: [
                videoStream != null
                    ? RTCVideoView(
                        videoStream?.renderer as RTCVideoRenderer,
                        objectFit:
                            RTCVideoViewObjectFit.RTCVideoViewObjectFitCover,
                      )
                    : const Center(
                        child: Icon(
                          Icons.person,
                          size: 180.0,
                          color: Color.fromARGB(140, 255, 255, 255),
                        ),
                      ),
                Positioned(
                  bottom: 0,
                  left: 0,
                  child: FittedBox(
                    fit: BoxFit.scaleDown,
                    child: Container(
                      padding: const EdgeInsets.all(2.0),
                      decoration: BoxDecoration(
                        color: Theme.of(context).backgroundColor.withOpacity(0.2),
                        border: Border.all(color: Colors.white24),
                        borderRadius: BorderRadius.circular(4.0),
                      ),
                      child: Text(
                        widget.participant.displayName,
                        textAlign: TextAlign.center,
                        style: const TextStyle(
                          color: Colors.white,
                          fontSize: 10.0,
                        ),
                      ),
                    ),
                  ),
                ),
                Positioned(
                  top: 0,
                  left: 0,
                  child: InkWell(
                    child: Container(
                      padding: const EdgeInsets.all(4),
                      decoration: BoxDecoration(
                        shape: BoxShape.circle,
                        color: audioStream != null
                            ? Theme.of(context).backgroundColor
                            : Colors.red,
                      ),
                      child: Icon(
                        audioStream != null ? Icons.mic : Icons.mic_off,
                        size: 16,
                      ),
                    ),
                    onTap: widget.isLocalParticipant
                        ? null
                        : () => audioStream != null
                              ? widget.participant.disableMic()
                              : widget.participant.enableMic(),
                  ),
                ),
                Positioned(
                  top: 0,
                  right: 0,
                  child: InkWell(
                    child: Container(
                      padding: const EdgeInsets.all(4),
                      decoration: BoxDecoration(
                        shape: BoxShape.circle,
                        color: videoStream != null
                            ? Theme.of(context).backgroundColor
                            : Colors.red,
                      ),
                      child: Icon(
                        videoStream != null
                            ? Icons.videocam
                            : Icons.videocam_off,
                        size: 16,
                      ),
                    ),
                    onTap: widget.isLocalParticipant
                        ? null
                        : () => videoStream != null
                                  ? widget.participant.disableWebcam()
                                  : widget.participant.enableWebcam(),
                  ),
                ),
                if (!widget.isLocalParticipant)
                  Positioned(
                    bottom: 0,
                    right: 0,
                    child: InkWell(
                      child: Container(
                        padding: const EdgeInsets.all(4),
                        decoration: const BoxDecoration(
                          shape: BoxShape.circle,
                          color: Colors.red,
                        ),
                        child: const Icon(
                          Icons.logout,
                          size: 16,
                        ),
                      ),
                      onTap: () {
                        showDialog(
                            context: context,
                            builder: (context) => AlertDialog(
                                  title: const Text("Are you sure ?"),
                                  actions: [
                                    TextButton(
                                      child: const Text("Yes"),
                                      onPressed: () {
                                        widget.participant.remove();
                                        toastMsg("Participant removed");
                                        Navigator.of(context).pop();
                                      },
                                    ),
                                    TextButton(
                                      child: const Text("No"),
                                      onPressed: () => Navigator.of(context).pop(),
                                    )
                                  ],
                                ));
                      },
                    ),
                  ),
              ],
            ),
          ),
        ),
    );
  }

  _initStreamListeners() {
    widget.participant.on(Events.streamEnabled, (Stream _stream) {
      setState(() {
        if (_stream.kind == 'video') {
          videoStream = _stream;
        } else if (_stream.kind == 'audio') {
          audioStream = _stream;
        } else if (_stream.kind == 'share') {
          shareStream = _stream;
        }
      });
    });

    widget.participant.on(Events.streamDisabled, (Stream _stream) {
      setState(() {
        if (_stream.kind == 'video' && videoStream?.id == _stream.id) {
          videoStream = null;
        } else if (_stream.kind == 'audio' && audioStream?.id == _stream.id) {
          audioStream = null;
        } else if (_stream.kind == 'share' && shareStream?.id == _stream.id) {
          shareStream = null;
        }
      });
    });
  }
}
```

```js title=participant_grid_view.dart
import 'dart:developer';
import 'package:flutter/material.dart';
import 'package:videosdk/rtc.dart';
import 'participant_tile.dart';

class ParticipantGridView extends StatefulWidget {
  final Meeting meeting;
  const ParticipantGridView({
    Key? key,
    required this.meeting,
  }) : super(key: key);

  @override
  State<ParticipantGridView> createState() => _ParticipantGridViewState();
}

class _ParticipantGridViewState extends State<ParticipantGridView> {
  String? activeSpeakerId;
  Participant? localParticipant;
  Map<String, Participant> participants = {};

  @override
  void initState() {
    // Initialize participants
    localParticipant = widget.meeting.localParticipant;
    participants = widget.meeting.participants;

    // Setting meeting event listeners
    setMeetingListeners(widget.meeting);
    super.initState();
  }

  @override
  Widget build(BuildContext context) {
    return GridView.count(
      crossAxisCount: 2,
      children: [
        ParticipantTile(
          participant: localParticipant!,
          isLocalParticipant: true,
        ),
        ...participants.values
            .map((participant) => ParticipantTile(participant: participant))
            .toList()
      ],
    );
  }

  void setMeetingListeners(Meeting _meeting) {
    // Called when participant joined meeting
    _meeting.on(
      Events.participantJoined,
      (Participant participant) {
        final newParticipants = participants;
        newParticipants[participant.id] = participant;
        setState(() {
          participants = newParticipants;
        });
      },
    );

    // Called when participant left meeting
    _meeting.on(
      Events.participantLeft,
      (participantId) {
        final newParticipants = participants;

        newParticipants.remove(participantId);
        setState(() {
          participants = newParticipants;
        });
      },
    );

    // Called when speaker is changed
    _meeting.on(Events.speakerChanged, (_activeSpeakerId) {
      setState(() {
        activeSpeakerId = _activeSpeakerId;
      });
    });
  }
}
```

## 3. Participant Related Events

1. **participantJoined** - Whenever any new participant join the meeting, `participantJoined` event will trigger. For example, the meeting is running with **Alice** and **Bob**, then **Eve** join that meeting, after that `participantJoined` event trigger and return the [participant object](/flutter/guide/video-and-audio-calling-api-sdk/features/manage-participants#participant-object-properties).

2. **participantLeft** - Whenever any participant leave/exit the meeting, `participantLeft` event will trigger.For example, the meeting is running with **Alice** and **Bob**, then **Bob** leave that meeting, after that `participantLeft` event trigger and return the [participant object](/flutter/guide/video-and-audio-calling-api-sdk/features/manage-participants#participant-object-properties)

3. **speakerChanged** - Whenever any participant starts actively speaking in meeting, `speakerChanged` event will trigger and return the speaker `participantId`.

4. **presenterChanged** - Whenever any participant present/screenshare their screen/window in meeting, `presenterChanged` event will trigger and return the presenter `participantId`.

5. **streamEnabled** - Whenever any participant enabled mic/webcam in meeting, `streamEnabled` event will trigger and return [Stream Map](/flutter/guide/video-and-audio-calling-api-sdk/features/manage-participants#stream-object-properties).

6. **streamDisabled** - Whenever any participant disabled mic/webcam in meeting, `streamDisabled` event will trigger and return [Stream Map](/flutter/guide/video-and-audio-calling-api-sdk/features/manage-participants#stream-object-properties).

```js
// Adding event listner
meeting.on(Events.participantJoined, (Participant participant) {
  print("new participant => $participant");
  },
);

meeting.on(Events.participantLeft, (Participant participant) {
  print("new participant => $participant");
  },
);
```


---

---
title: Mic Controls Video & Audio Call - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: Mic Controls features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Mic Controls
pagination_label: Mic Controls
keywords:
  - Mic on
  - Mic off
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: mic-controls
---

import NoIndex from '../../../../../mdx/\_no-index.mdx';

<NoIndex/>

# Mic Controls - Flutter

Whenever any participant wants to start / stop broadcasting their audio to other participant in meeting, they can simply do it with VideoSDK Meeting.

This guide will provide an overview of how to use enable and disable Mic in a meeting.

1. **Enable Mic** - By using `unmuteMic()` function, a participant can publish audio to other participants.
2. **Disable Mic** - By using `muteMic()` function, a participant can stop publishing audio to other participants.
3. **Change Mic** - By using `changeMic()` function, a participant can change mic.

### Enable, Disable, Change Mic

```js
ElevatedButton(
  onPressed: meeting.unmuteMic,
  child: Text("unmuteMic"),
),
ElevatedButton(
  onPressed: meeting.muteMic,
  child: Text("muteMic"),
),

// changeMic() method is coming soon in flutter.
```


---

---
title: Pause/Resume Video Stream - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: Pause/Resume Video Stream features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Pause/Resume Video Stream
pagination_label: Pause/Resume Video Stream
keywords:
  - pause/resume video stream
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: pause-resume-video-stream
---

import NoIndex from '../../../../../mdx/\_no-index.mdx';

<NoIndex/>

# Participant Video Stream - Flutter

- Using this feature, you can pause/resume participant's video stream.

## Pause video stream

- `pause()` method is used to pause videostream of a participant.

```js
ElevatedButton(
  child: Text("Pause Video"),
  onPressed: () {
    List<Stream> streams = participant.streams.where((e) => e.kind == 'video').toList();

    if(streams.length != 0){
      Stream videoStream = streams[0];
      videoStream.track.pause();
    }
  }
),
```

## Resume video stream

- `resume()` method is used to resume videostream of a participant.

```js
ElevatedButton(
  child: Text("Resume Video"),
  onPressed: () {
    List<Stream> streams = participant.streams.where((e) => e.kind == 'video').toList();

    if(streams.length != 0){
      Stream videoStream = streams[0];
      videoStream.track.resume();
    }
  }
),

```


---

---
sidebar_label: Send Message using PubSub
pagination_label: PubSub
---

import NoIndex from '../../../../../mdx/\_no-index.mdx';

<NoIndex/>

# PubSub - Flutter

PubSub feature allows the participant to send and receive messages of the topics which he has subscribed.

## Methods

### publish()

This method is use for publishing message of specific topic.

#### Syntax

```js
  Future<void> publish(
    String topic,
    String message,
    [PubSubPublishOptions options]
  )
```

| Parameter Name | Type                 | Description                                                                                                                                       |
| -------------- | -------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------- |
| topic          | String               | This should be the topic for which you are publishing a message.                                                                                  |
| message        | String               | This is the actual message, which will be published to participants, who had subscribed to a particular topic.                                    |
| options        | PubSubPublishOptions | This is an object of PubSubPublishOptions, which provides an option, such as `persist`, which persists message history for upcoming participants. |

#### Example

```js
  // publish()
  ElevatedButton(
    onPressed: () async {
      // Publish a message
      await meeting.pubSub.publish(
        "CHAT", // Topic
        "Hello from Flutter!", // Message Content
        const PubSubPublishOptions(
          "persist": true // Stores the message in server for future participants
        ),
      );

      print("Message published");
    },
    child: Text("Publish"),
  ),
```

<br />

### subscribe()

This method is used to subscribe for particular topic. This method returns a list of messages which were sent earlier.

#### Syntax

```js
  Future<PubSubMessages> subscribe(
    String topic,
    Function(PubSubMessage) messageHandler,
  )
```

| Parameter Name | Type   | Description                                                                 |
| -------------- | ------ | --------------------------------------------------------------------------- |
| topic          | String | This should be the topic to be subscribed.                                  |
| messageHandler | String | This is a handler function, which will be called when new message received. |

#### Example

```js
  // subscribe()
  ElevatedButton(
    onPressed: () async {
      // Subscribe 'CHAT' topic and get persisted messages
      var messages = await meeting.pubSub.subscribe("CHAT", messageHandler);

      // Printing message list
      print("Messages: ${messages.messages.map((msg) => msg.message).join(" ")}");
    },
    child: Text("Subscribe"),
  ),

  // Message Handler
  void messageHandler(msg){
    // Do something
    print("New message received: $msg");
  }
```

### unsubscribe()

This method is used to unsubscribe the message topic.

#### Syntax

```js
  Future<void> unsubscribe(
    String topic,
    Function(PubSubMessage) messageHandler,
  )
```

| Parameter Name | Type   | Description                                                    |
| -------------- | ------ | -------------------------------------------------------------- |
| topic          | String | This should be the topic to be unsubscribed.                   |
| messageHandler | String | This is a handler function, which was passed in `subscribe()`. |

#### Example

```js
  // unsubscribe
  ElevatedButton(
    onPressed: () {
      // Unsubscribe 'CHAT' topic
      await meeting.pubSub.unSubscribe("CHAT", messageHandler);
    },
    child: Text("UnSubscribe"),
  ),
```

## Sample Code

```js
import 'package:flutter/material.dart';
import 'package:videosdk/rtc.dart';

// ChatScreen
class ChatScreen extends StatefulWidget {
  final Meeting meeting;
  const ChatScreen({required this.meeting});

  @override
  _ChatScreenState createState() => _ChatScreenState();
}

class _ChatScreenState extends State<ChatScreen> {
  @override
  void initState() {
    super.initState();

    widget.meeting.pubSub.subscribe("CHAT", messageHandler)
      .then((messages) =>
          print("Subscribed to chat: ${messages.messages.map((msg) => msg.message).join(" ")}"));
  }

  @override
  Widget build(BuildContext context) {
    final meeting = widget.meeting;
    return Scaffold(
      appBar: AppBar(title: const Text("PubSub Sample Code")),
      body: Center(
        child: ElevatedButton(
          child: const Text("Send Hello !"),
          // Publish Hello message
          onPressed: () => meeting.pubSub.publish(
            "CHAT",
            "Hello",
            const PubSubPublishOptions(persist: true),
          ),
        ),
      ),
    );
  }

  // Handle incoming messages
  void messageHandler(PubSubMessage message) {
    print("New message: ${message.message}");
  }

  @override
  void dispose() {
    // Unsubscribe
    widget.meeting.pubSub.unsubscribe("CHAT", messageHandler);
    super.dispose();
  }
}

```


---

---
title: Record Meeting Video & Audio Call - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: Record Meeting features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Record Meeting
pagination_label: Record Meeting
keywords:
  - Start Recording meeting
  - Stop Recording meeting
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: recording-meeting
---

import NoIndex from '../../../../../mdx/\_no-index.mdx';

<NoIndex/>

# Record Meeting - Flutter

Record meeting allows participants to record video & audio during the meeting. The recording files are available in developer dashboard.
Any participant can start / stop recording any time during the meeting.

This guide will provide an overview of how to implement start and stop Meeting Recording.

1. **Start Recording** - By using `startRecording()` function, a participant can start meeting recording.
2. **Stop Recording** - By using `stopRecording()` function, a participant can stop meeting recording.

### Start And Stop Recording

```js
// Start Recording
meeting.startRecording('<webhookUrl>');
// Stop Recording
meeting.stopRecording(),
```

### Events

1. **recordingStarted** - Whenever any participant start meeting recording, then `recordingStarted` event will trigger.

2. **recordingStopped** - Whenever any participant stop meeting recording, then `recordingStopped` event will trigger.

```js
meeting.on(Events.recordingStarted, () {
  print("meeting recording started");
});
//
meeting.on(Events.recordingStopped, () {
  print("meeting recording stopped");
});
```


---

---
title: Remove Participant - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: Remove Participant features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Remove Participant
pagination_label: Remove Participant
keywords:
  - remove participant
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: remove-participant
---

import NoIndex from '../../../../../mdx/\_no-index.mdx';

<NoIndex/>

# Remove Participant - Flutter

- Whenever any participant (having privileges) wants to remove other participant in meeting, he/she can do it with this feature.

- `Participant` class provides the `remove()` method to remove participant from the meeting.

```js
ElevatedButton(
    child: Text("Remove Participant"),
    onPressed: () {
        participant.remove();
    },
),
```

:::note
To remove any participant, you must have appropriate permissions
:::


---

---
title: Share your Screen Video & Audio Call - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: Share your Screen features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Share Your Screen (Android)
pagination_label: Share Your Screen (Android)
keywords:
  - Start Screen share
  - Stop Screen share
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: screenshare
---

import NoIndex from '../../../../../mdx/\_no-index.mdx';

<NoIndex/>

# Share Your Screen - Flutter

- Whenever any participant wants to share a complete screen of mobile, they can simply do it with VideoSDK Meeting.

- This guide will provide an overview of how to enable or disable Screen Share in a meeting.

## Enable Screen Share

- `Meeting` class provides the method to enable screen-sharing.

- In order to start screen-sharing just call `meeting.enableScreenShare()` method.

```js
ElevatedButton(
    child: Text("Start ScreenSharing"),
    onPressed: () {
        meeting.enableScreenShare();
    },
),
```

### Customise notification

- When a presenter starts screen share, presenter will receive a notification with a pre-defined title and messages.

- You can Customise those title, message and icon as per your requirements using `NotificationInfo` class and passed to `MeetingBuilder`.

```js
MeetingBuilder(
    .
    .
    notification: const NotificationInfo(
        title: "Video SDK",
        message: "Video SDK is sharing screen in the meeting",
        icon: "notification_share", // drawable icon name
    ),
),
```

## Disable Screen Share

By using `meeting.disableScreenShare()` function, a participant can stop publishing screen stream to other participants.

```js
ElevatedButton(
    child: Text("Stop ScreenSharing"),
    onPressed: () {
        meeting.disableScreenShare();
    },
),
```

## Display Screen Share Stream

#### Local Participant

When a Local participant share the screen, `streamEnabled` Event on the `Participant` is triggered with the `Stream` which can be added to a `RTCVideoView`.

```js
meeting.localParticipant.on(Events.streamEnabled, (Stream _stream) {
    if (_stream.kind == 'share') {
        screenShareStream = _stream;
      }
    });
```

#### Other Participants

When other participant(Except you) share their screen, `presenterChanged` Event on the `Participant` is triggered with the `participantId` of the screen share.

```js
meeting.on(Events.presenterChanged, (_activePresenterId) {
    Participant? activePresenterParticipant = meeting.participants[_activePresenterId];

    Stream? _stream = activePresenterParticipant?
                        .streams.values
                        .singleWhere((e) => e.kind == "share");

    remoteParticipantShareStream = _stream;
});
```


---

---
title: Set Video Quality - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: Set Video Quality features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Set Video Quality
pagination_label: Set Video Quality
keywords:
  - set video quality
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: set-video-quality
---

import NoIndex from '../../../../../mdx/\_no-index.mdx';

<NoIndex/>

# Set Video Quality - Flutter

- Set Video Quality feature allows participants to set other participant's video quality during the meeting.

- `Participant` class provides the `setQuality()` method to set participant's video quality.

```js
ElevatedButton(
    child: Text("Set High Quality"),
    onPressed: () {
        // Set Video Quality

        // High Quality
        participant.setQuality('high');

        // Medium Quality
        participant.setQuality('med');

        // Low Quality
        participant.setQuality('low');

    },
),
```


---

---
title: Set Viewport
hide_title: false
hide_table_of_contents: false
sidebar_label: Set Viewport
pagination_label: Set Viewport
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: set-viewport
---

import NoIndex from '../../../../../mdx/\_no-index.mdx';

<NoIndex/>

# Set Viewport - Flutter

When you are working with Video Calling, video quality is the most important part of communication. When a participant is shown on the screen, consuming multiple high quality although not required, will result in more memory and CPU usage of the device, eventually degrading quality.

The way to optimze around these situation is to consume the video quality which is required to fit the view of a particular participant, resulting in better quality, less usage of network bandwith and providing a better experience.

Viewport is the size of window or visible area in which video for the participant is shown. We can optimize the consuming video quality based on the viewport size of the participant. For example if the viewport size of a particular participant view is `480x360`, VideoSDK will download a `480x360` stream. If a participant on screen is present in bigger size, VideoSDK will provide a higher quality video for that particular participant only.

import ReactPlayer from 'react-player'

<div style={{textAlign: 'center'}}>

<ReactPlayer autoplay muted loop playing url='/img/viewport_illustration.mp4' width={"100%"}/>

</div>

### setViewPort()

`setViewPort()` can be used to achieve the best optimization of the video. This method is called with the `width` and `height` of the participant view on the `Participant` object and VideoSDK will handle the rest.

##### Parameters

- `width`

  - type: `int`
  - Width of the participant view for which the quliaty of video is to be adjusted.

- `height`
  - type: `int`
  - Height of the participant view for which the quliaty of video is to be adjusted.

### Example

```js
class ParticipantTile extends StatefulWidget {
  final Participant participant;
  final bool isLocalParticipant;
  const ParticipantTile(
      {Key? key, required this.participant, this.isLocalParticipant = false})
      : super(key: key);

  @override
  State<ParticipantTile> createState() => _ParticipantTileState();
}

class _ParticipantTileState extends State<ParticipantTile> {
  //create a widgetKey which can be used to refer the Video container
  GlobalKey _widgetKey = GlobalKey();

  @override
  Widget build(BuildContext context) {
    return Container(
        key: _widgetKey, //assign key to reference this view
        child: <Your Widget Here for Displaying participant>
    );
  }

  //call this method whenever the widget height of width gets changed.
  //it can be during stream enabled, stream resume, etc
  onViewPortChange() {
    try {
      //get the renderbox
      final RenderBox renderBox =
          _widgetKey.currentContext?.findRenderObject() as RenderBox;
      _widgetKey.currentContext?.size;

      //Get Size of the renderbox
      final Size size = renderBox.size;

      //apply setViewPort on the participant with height and width of view
      widget.participant.setViewPort(size.width, size.height);
    } catch (exception) {
      log("Unable to set Viewport $exception");
    }
  }
}
```


---

---
title: Speaker Indication Video & Audio Call - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: Speaker Indication features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Speaker Indication
pagination_label: Speaker Indication
keywords:
  - Active Speaker
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: speaker-indication
---

import NoIndex from '../../../../../mdx/\_no-index.mdx';

<NoIndex/>

# Speaker Indication - Flutter

Speaker indication feature in VideoSDK let you know, which participant in a meeting is active speaker.

Whenever any participant speaks in meeting, `speaker-changed` event will trigger.

For example, the meeting is running with **Alice** and **Bob**. Whenever any of them speaks, `speaker-changed` event will trigger and return the speaker `participantId`.

We can access `speaker-changed` event through [meeting object](./start-join-meeting#2-initialization).

### speaker-changed Event

```js
meeting.on('speaker-changed', (activeSpeakerId) {
  print("participantId => $activeSpeakerId");
});

```


---

---
title: Start join Meeting Video & Audio Call - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: Start or join Meeting features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Start or Join Meeting
pagination_label: Start or Join Meeting
keywords:
  - Join audio calling
  - Join video calling
  - Join real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: start-join-meeting
---

import NoIndex from '../../../../../mdx/\_no-index.mdx';

<NoIndex/>

# Start or Join Meeting - Flutter

<div style={{display:'flex',flexDirection:'row',alignItems:'stretch',}}>
<div style={{}}>
<p>After the successful installation of VideoSDK, the next step is to integrate VideoSDK features with your webApp/MobileApp.</p>

<p>To Communicate with other participant's audio or video call, you will need to join the meeting.</p>

<p>This guide will provide an overview of how to configure, initialize and join a VideoSDK meeting.</p>

</div>
<div>
<img src="/img/gif/new-meeting.gif"/>
</div>

</div>

## 1. Configuration

To configure a meeting, you will need [generated token](/flutter/guide/video-and-audio-calling-api-sdk/server-setup) and [meetingId](/api-reference/realtime-communication/create-room), we had discussed in [Server Setup](/flutter/guide/video-and-audio-calling-api-sdk/server-setup).
This code snippet calls API from local server

**Scenario 1** - Suppose you **don't have** any meetingId, you can simply generate meetingId by invoking `create-meeting` API.

**Scenario 2** - Suppose you **have** meetingId, now you don't have to call `create-meeting` API to generate meetingId, instead you can call `validate-meeting` API to validate meetingId.

**Token generation API is necessary for both scenario.**

```js
import 'dart:convert';
import 'package:http/http.dart' as http; // For API Calling, you need to add third party package "http"
import 'package:videosdk/rtc.dart';

// States Defined in Stateful Component.
String? meetingId;
String? token;

void _getMeetingIdAndToken() async {
    final LOCAL_SERVER_URL = dotenv.env['LOCAL_SERVER_URL'];

    // Calling get-token API.
    final Uri tokenUrl = Uri.parse('$LOCAL_SERVER_URL/get-token');
    final http.Response tokenResponse = await http.get(tokenUrl);

    final dynamic _token = json.decode(tokenResponse.body)['token'];

    // Calling create-meeting API.
    final Uri meetingIdUrl =
        Uri.parse('$LOCAL_SERVER_URL/create-meeting/');

    final http.Response meetingIdResponse =
        await http.post(meetingIdUrl, body: {"token": _token});

    final _meetingId = json.decode(meetingIdResponse.body)['meetingId'];

    // Setting into states of stateful widget
    setState(() {
      token = _token;
      meetingId = _meetingId;
    });
  }

  // This API is for validate the meeting id
  // Not require to call this API after create meeting API

dynamic validateMeeting(token, meetingId) async {
    final String LOCAL_SERVER_URL = dotenv.env['LOCAL_SERVER_URL'];
    final Uri validateMeetingUrl =
        Uri.parse('$LOCAL_SERVER_URL/validate-meeting/$meetingId');
    final http.Response validateMeetingResponse =
        await http.post(validateMeetingUrl, body: {"token": token});
    final _meetingId = json.decode(validateMeetingResponse.body)['meetingId'];
    if (_meetingId != null) {
      return _meetingId;
    } else {
      return null;
    }
  }

```

## 2. Initialization

<div style={{display:'flex',flexDirection:'row',alignItems:'stretch',}}>
<div style={{}}>
<p>
After configuration, you will have to Initialize 
<p>
meeting by providing name, meetingId, micEnabled, webcamEnabled & maxResolution.
</p>
</p>

</div>
<div>
<img src="/img/gif/add-participant.gif"/>
</div>

</div>

```js
import 'package:flutter/material.dart';
import 'package:videosdk/rtc.dart';

class MyApp extends StatelessWidget {
    @override
    Widget build(BuildContext context) {
        return MeetingBuilder(
            meetingId: "<Id-on-meeting>",
            displayName: "<Name-of-participant>",
            micEnabled: "<Flag-to-enable-mic>",
            webcamEnabled: "<Flag-to-enable-webcam>",
            token: "<Authentication-token>",
            builder: (Meeting: meeting) {
                // Do Something
                return Container(); // Returning widget
            }
        );
    }
}
```

## 3. Join

<div style={{display:'flex',flexDirection:'row',alignItems:'stretch',}}>
<div style={{}}>
<p>
After configuration & initialization, the third step is to call join() to join a meeting.
</p>

<p>
After joining, you will be able to Manage Participant in a meeting.
</p>

</div>
<div>
<img src="/img/gif/join-meeting.gif"/>
</div>

</div>

```js
// Join the meeting
meeting?.join();
```


---

---
title: Toggle Participant Media
hide_title: false
hide_table_of_contents: false
description: Camera Controls features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Toggle Participant Media
pagination_label: Toggle Participant Media
keywords:
  - Camera on
  - Camera off
  - Webcam on
  - Webcam off
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: toggle-participant-media
---

import NoIndex from '../../../../../mdx/\_no-index.mdx';

<NoIndex/>

# Toggle Participant Media - Flutter

Control other participant's webcam and mic.
For better idea, let's understand this with a real case scenario

**Scenario 1 (Online Class)** - In this scenario, the lecturer(Local Participant) will control the student's(Other Participant) webcam and mic as per his/her needs.

**Scenario 2 (Online Events)** - In this scenario, the event hosts will control the audience webcam and mic when someone wants to speak.

This guide will provide an overview of how to control other participant webcam and mic in a meeting.

1. **Enable Webcam of Participant** - By using `enableWebcam()` function, a `webcam-requested` event will trigger on requested participant side.

   **Example** : Meeting is running with **User A** and **User B**. Now **User A** wants to Enable Webcam of **User B**, so **User A** will use `enableWebcam()` function to request **User B**, after that **User B** recieve the `webcam-requested` event, from there user can either accept or reject the incoming request.

2. **Disable Webcam of Participant** - By using `disableWebcam()` function, webcam of that participant will be turned off.

   **Example** : **User A** wants to Disable Webcam of **User B**, so **User A** will use `disableWebcam()` function to Disable it without any request.

3. **Enable Mic of Participant** - By using `enableMic()` function, a `mic-requested` event will trigger on requested participant side.

   **Example** : Meeting is running with **User A** and **User B**. Now **User A** wants to Enable Mic of **User B**, so **User A** will use `enableMic()` function to request **User B**, after that **User B** will receive the `Mic-requested` event, from there user can either accept or reject the incoming request.

4. **Disable Mic of Participant** - By using `disableMic()` function, Mic of that participant will disable.

   **Example** : **User A** wants to Disable Mic of **User B**, so **User A** will use `disableMic()` function to Disable it without any request.

:::note

To achieve this feature, you need to pass `allow_join` persmission while genearting token for meeting initialization. After that you will be able to access participant media methods.

[How to apply permission while generating token?](/flutter/guide/video-and-audio-calling-api-sdk/server-setup)

:::

### Request Media Methods

```js
const participants = meeting.participants;
const participant = participants.get("<participant-id>");

// This will emit an event called "webcam-requested" to that particular participant
participant.enableWebcam();

// This will directly disable webcam of particular participant
participant.disableWebcam();

// This will emit an event called "mic-requested" to that particular participant
participant.enableMic();

// This will directly disable mic of particular participant
participant.disableMic();
```

### Manage Requested Media Events

1. **webcam-requested** - This event will be emitted to the participant `B` when any other participant `A` requests to enable webcam of that participant `B`. This event handler will receieve following three arguments:

   - `accept()` - Callback function to accept the request.
   - `reject()` - Callback function to reject the request.

<div style={{height: "10px"}}></div>

2. **mic-requested** - This event will be emitted to the participant `B` when any other participant `A` requests to enable mic of that participant `B`. This event handler will receieve following three arguments:

   - `accept()` - Callback function to accept the request.
   - `reject()` - Callback function to reject the request.

```js
// Handle Webcam Requested
widget.meeting.on("webcam-requested", ({ accept, reject }) {
    // callback function to accept the request
    accept();

    // callback function to reject the request
    reject();
}, );

// Handle Mic Requested
widget.meeting.on("mic-requested", ({ accept, reject }) {
     // callback function to accept the request
    accept();

    // callback function to reject the request
    reject();
}, );
```


---

---
title: Start a Video & Audio Call in Flutter SDK - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: Build customizable real-time video & audio calling applications in Flutter SDK with Video SDK add live Video & Audio conferencing to your applications.
sidebar_label: "Client Setup for Flutter"
pagination_label: "Client Setup for Flutter"
keywords:
  - flutter sdk
  - dart sdk
  - javascript sdk
  - sky sdk
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: flutter-sdk
---

import NoIndex from '../../../../mdx/\_no-index.mdx';

<NoIndex/>

# Getting Started - Flutter SDK

Flutter SDK is natively written SDK using Dart. It is compatible with both IOS and Android.

## Install a Flutter SDK

Flutter SDK is client for real-time communication for android and ios devices. It inherits the same terminology as all other SDKs does.

### Minimum OS/SDK versions

Android: minSdkVersion >= 23

<!-- ### IOS: > 11 -->

### Step 1: Add this package in your flutter project

#### Run this command:

```
flutter pub add videosdk
```

This will add a line like this to your package's pubspec.yaml (and run an implicit flutter pub get):

```
dependencies:
  videosdk: ^0.0.12
```

### Step 2: Update AndroidManifest.xml file for the permissions

Ensure the following permission is present in your Android Manifest file, located in `<project root>/android/app/src/main/AndroidManifest.xml`:

```xml
<uses-feature android:name="android.hardware.camera" />
<uses-feature android:name="android.hardware.camera.autofocus" />
<uses-permission android:name="android.permission.CAMERA" />
<uses-permission android:name="android.permission.RECORD_AUDIO" />
<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
<uses-permission android:name="android.permission.CHANGE_NETWORK_STATE" />
<uses-permission android:name="android.permission.MODIFY_AUDIO_SETTINGS" />
<uses-permission android:name="android.permission.INTERNET"/>

```

If you need to use a Bluetooth device, please add:

```xml
<uses-permission android:name="android.permission.BLUETOOTH" />
<uses-permission android:name="android.permission.BLUETOOTH_ADMIN" />
```

The Flutter project template adds it, so it may already be there.

Also you will need to set your build settings to Java 8, because official WebRTC jar now uses static methods in `EglBase` interface. Just add this to your app level `build.gradle`:

```js
android {
    //...
    compileOptions {
        sourceCompatibility JavaVersion.VERSION_1_8
        targetCompatibility JavaVersion.VERSION_1_8
    }
}
```

If necessary, in the same `build.gradle` you will need to increase `minSdkVersion` of `defaultConfig` up to `23` (currently default Flutter generator set it to `16`).

If necessary, in the same `build.gradle` you will need to increase `compileSdkVersion` and `targetSdkVersion` up to `31` (currently default Flutter generator set it to `30`).

## Step 3: iOS Setup

Add the following entry to your Info.plist file, located at `<project root>`/ios/Runner/Info.plist:

```xml
<key>NSCameraUsageDescription</key>
<string>$(PRODUCT_NAME) Camera Usage!</string>
<key>NSMicrophoneUsageDescription</key>
<string>$(PRODUCT_NAME) Microphone Usage!</string>
```

This entry allows your app to access camera and microphone.

## Step 4: Import it

Now in your Dart code, you can use:

```js
import "package:videosdk/rtc.dart";
```

---

:::note

Check out official example of Flutter SDK implementation: [videosdk-rtc-flutter-sdk-example](https://github.com/videosdk-live/videosdk-rtc-flutter-sdk-example)

:::


---

---
title: Get Started with Video & Audio Call - Video SDK Documentation
hide_title: true
hide_table_of_contents: false
description: Video SDK enables the opportunity to integrate native IOS, Android & Web SDKs to add live video & audio conferencing to your applications.
sidebar_label: Getting Started
pagination_label: Getting Started
keywords:
  - audio calling
  - video calling
  - real-time communication
  - collaboration
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: getting-started
---

import Mermaid from '@theme/Mermaid';
import GettingStarted from '../../../../mdx/introduction/\_getting-started.mdx';
import NoIndex from '../../../../mdx/\_no-index.mdx';

<NoIndex/>

<GettingStarted title="Get Started with Flutter" />

## Steps

import Card from '@theme/Card';

<div class="container guide-steps-block">
  <div class="row ">
    <div class="col col--6">
      <Card heading="1. Get your API key and Secret" link="/flutter/0.0.x/guide/video-and-audio-calling-api-sdk/signup-and-create-api" description="Generate your API key and Secret from Video SDK." />
    </div>
     <div class="col col--6">
      <Card heading="2. Client Setup for Flutter" link="/flutter/0.0.x/guide/video-and-audio-calling-api-sdk/flutter-sdk" description="Easy to integrate SDK with cross-channel support." />
    </div>
  </div>
  <div class="row ">
   <div class="col col--6" >
      <Card heading="3. Authentication and Tokens" link="/flutter/0.0.x/guide/video-and-audio-calling-api-sdk/server-setup" description="Setup secured server authentication and authorization."  />
    </div>
    <div class="col col--6">
      <Card heading="4. Start a Audio / Video Call" link="/flutter/0.0.x/guide/video-and-audio-calling-api-sdk/quick-start" description="Get started with step by step guide of integrating Video SDK." />
    </div>
  </div>
  <div class="row ">
   <div class="col col--6" >
      <Card heading="5. Basic Features" link="/flutter/0.0.x/guide/video-and-audio-calling-api-sdk/features/start-join-meeting" description="Explore basic features such as join, leave and customise sessions."  />
    </div>
    <div class="col col--6">
      <Card heading="6. Advanced Features" link="/flutter/0.0.x/guide/video-and-audio-calling-api-sdk/features/entry-request-response" description="Explore advanced features such as screen sharing, recording and live streaming." />
    </div>
  </div>
</div>

## Architecture

This diagram demonstrates end-to-end flow to implement video & audio calling, record calls and go-live on social media.

![Video-sdk-architecture!](/img/video-sdk-archietecture.svg)


---

---
title: Quick Start with Flutter
hide_title: true
hide_table_of_contents: false
description: Video SDK enables the opportunity to integrate native IOS, Android & Web SDKs to add live video & audio conferencing to your applications.
sidebar_label: Start a Audio / Video Call
pagination_label: Quick Start with Flutter
keywords:
  - audio calling
  - video calling
  - real-time communication
  - collaboration
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: quick-start
---

import NoIndex from '../../../../mdx/\_no-index.mdx';

<NoIndex/>

# Quick Start - Flutter

VideoSDK enables the opportunity to integrate video & audio calling to Web, Android, IOS applications. It provides Programmable SDKs and REST APIs to build scalable video conferencing applications.

This guide will get you running with the VideoSDK video & audio calling in minutes.

## Prerequisites

Before proceeding, ensure that your development environment meets the following requirements:

- Video SDK Developer Account (Not having one, follow **[Video SDK Dashboard](https://app.videosdk.live/)**)
- The basic understanding of Flutter.
- **[Flutter Video SDK](https://pub.dev/packages/videosdk)**
- Have Flutter installed on your device.

:::important

One should have a VideoSDK account to generate token.
Visit VideoSDK **[dashboard](https://app.videosdk.live/api-keys)** to generate token

:::

## Getting Started with the Code!

Follow the steps to create the environment necessary to add video calls into your app.

### Create a new Flutter project.

Create a new Flutter App using the below command.

```bash
$ flutter create videosdk_flutter_quickstart
```

### Install Video SDK

Install the VideoSDK using the below-mentioned flutter command. Make sure you are in your flutter app directory before you run this command.

```js
$ flutter pub add videosdk

//run this command to add http library to perform network call to generate meetingId
$ flutter pub add http
```

### Structure of the project

Your project structure should look like this.

```js title="Project Structure"
    root
    ├── android
    ├── ios
    ├── lib
         ├── api.dart
         ├── join_screen.dart
         ├── main.dart
         ├── meeting_controls.dart
         ├── meeting_screen.dart
         ├── participant_tile.dart
    .
```

We are going to create flutter widgets (JoinScreen, MeetingScreen, MeetingControls, ParticipantTile).

### App Structure

App widget will contain JoinScreen and MeetingScreen widget. MeetingScreen will have MeetingControls and ParticipantTile widget.

<div style={{textAlign: 'center'}}>

![VideoSDK Flutter Quick Start Architecture](/img/quick-start/flutter-widget-structure.jpg)

</div>

### Configure Project

#### For Android

Update the `AndroidManifest.xml` for the permissions we will be using to implement the audio and video features. You can find the `AndroidManifest.xml` file at

`<project root>/android/app/src/main/AndroidManifest.xml`

```js title="AndroidManifest.xml"
<uses-feature android:name="android.hardware.camera" />
<uses-feature android:name="android.hardware.camera.autofocus" />
<uses-permission android:name="android.permission.CAMERA" />
<uses-permission android:name="android.permission.RECORD_AUDIO" />
<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
<uses-permission android:name="android.permission.CHANGE_NETWORK_STATE" />
<uses-permission android:name="android.permission.MODIFY_AUDIO_SETTINGS" />
<uses-permission android:name="android.permission.INTERNET"/>
```

Also you will need to set your build settings to Java 8 because the official WebRTC jar now uses static methods in `EglBase` interface. Just add this to your app-level `build.gradle`

```js
android {
    //...
    compileOptions {
        sourceCompatibility JavaVersion.VERSION_1_8
        targetCompatibility JavaVersion.VERSION_1_8
    }
}
```

If necessary, in the same `build.gradle` you will need to increase `minSdkVersion` of `defaultConfig` up to `23` (currently default Flutter generator set it to `16`).

If necessary, in the same `build.gradle` you will need to increase `compileSdkVersion` and `targetSdkVersion` up to `31` (currently default Flutter generator set it to `30`).

#### For iOS

Add the following entries which allow your app to access the camera and microphone to your Info.plist file, located in

`<project root>`/ios/Runner/Info.plist:

```xml
<key>NSCameraUsageDescription</key>
<string>$(PRODUCT_NAME) Camera Usage!</string>
<key>NSMicrophoneUsageDescription</key>
<string>$(PRODUCT_NAME) Microphone Usage!</string>
```

### Step 1: Get started with api.dart

Before jumping to anything else, you will write a function to generate a unique meetingId. You will require auth token, you can generate it using either by using [videosdk-rtc-api-server-examples](https://github.com/videosdk-live/videosdk-rtc-api-server-examples) or generate it from the [Video SDK Dashboard](https://app.videosdk.live/api-keys) for development.

```js title="api.dart"
import 'dart:convert';
import 'package:http/http.dart' as http;

String token = "<Generated-from-dashboard>";

Future<String> createMeeting() async {
  final http.Response httpResponse = await http.post(
    Uri.parse("https://api.videosdk.live/v2/rooms"),
    headers: {'Authorization': token},
  );

  return json.decode(httpResponse.body)['roomId'];
}
```

### Step 2 : Creating the JoinScreen

Let's create join_screen.dart file in lib directory and create JoinScreen StateLessWidget.

The JoinScreen will consist of:

- Create Meeting Button - This button will create a new meeting for you.
- Meeting ID TextField - This text field will contain the meeting ID, you want to join.
- Join Button - This button will join the meeting, which you have provided.

JoinScreen will accept 3 functions in constructor.

- onCreateMeetingButtonPressed - invoked when Create Meeting button pressed
- onJoinMeetingButtonPressed - invoked when Join button pressed
- onMeetingIdChanged - invoked when MeetingId TextField value changed

```js title="join_screen.dart"
import 'package:flutter/material.dart';

class JoinScreen extends StatelessWidget {
  final void Function() onCreateMeetingButtonPressed;
  final void Function() onJoinMeetingButtonPressed;
  final void Function(String) onMeetingIdChanged;

  const JoinScreen({
    Key? key,
    required this.onCreateMeetingButtonPressed,
    required this.onJoinMeetingButtonPressed,
    required this.onMeetingIdChanged,
  }) : super(key: key);

  @override
  Widget build(BuildContext context) {
    return Column(
      mainAxisAlignment: MainAxisAlignment.center,
      children: [
        ElevatedButton(
            child: const Text("Create Meeting"),
            onPressed: onCreateMeetingButtonPressed),
        const SizedBox(height: 16),
        TextField(
            decoration: const InputDecoration(
              hintText: "Meeting ID",
              border: OutlineInputBorder(),
            ),
            onChanged: onMeetingIdChanged),
        const SizedBox(height: 8),
        ElevatedButton(
          child: const Text("Join"),
          onPressed: onJoinMeetingButtonPressed,
        )
      ],
    );
  }
}
```

#### Output

![VideoSDK Flutter Quick Start Join Screen](/img/quick-start/flutter-join-screen-widget.jpg)

### Step 3 : Creating the MeetingControls

Let's create meeting_controls.dart file and create MeetingControls StateLess Widget.

The MeetingControls will consist of:

- Leave Button - This button will leave the meeting.
- Toggle Mic Button - This button will enable or disable mic.
- Toggle Webcam Button - This button will enable or disable Webcam.

MeetingControls will accept 3 functions in constructor

- onLeaveButtonPressed - invoked when Leave button pressed
- onToggleMicButtonPressed - invoked when Toggle Mic button pressed
- onToggleWebcamButtonPressed - invoked when Toggle Webcam button pressed

```js title="meeting_controls.dart"
import 'package:flutter/material.dart';

class MeetingControls extends StatelessWidget {
  final void Function() onToggleMicButtonPressed;
  final void Function() onToggleWebcamButtonPressed;
  final void Function() onLeaveButtonPressed;

  const MeetingControls({
    Key? key,
    required this.onToggleMicButtonPressed,
    required this.onToggleWebcamButtonPressed,
    required this.onLeaveButtonPressed,
  }) : super(key: key);

  @override
  Widget build(BuildContext context) {
    return Row(
      mainAxisAlignment: MainAxisAlignment.spaceAround,
      children: [
        ElevatedButton(
          child: const Text("Leave"),
          onPressed: onLeaveButtonPressed,
        ),
        ElevatedButton(
          child: const Text("Toggle Mic"),
          onPressed: onToggleMicButtonPressed,
        ),
        ElevatedButton(
          child: const Text("Toggle WebCam"),
          onPressed: onToggleWebcamButtonPressed,
        )
      ],
    );
  }
}
```

#### Output

![VideoSDK Flutter Quick Start Meeting Controls](/img/quick-start/flutter-meeting-controls.jpg)

### Step 4 : Creating ParticipantTile

Let's create participant_tile.dart file and create ParticipantTile StateLess Widget.

The ParticipantTile will consist of:

- RTCVideoView - This will show remote participant video stream.

ParticipantTile will accept Stream in constructor

- stream - remote participant video stream

```js title="participant_tile.dart"
import 'package:flutter/material.dart';
import 'package:videosdk/rtc.dart';

class ParticipantTile extends StatelessWidget {
  final Stream stream;
  const ParticipantTile({
    Key? key, required this.stream,
  }) : super(key: key);

  @override
  Widget build(BuildContext context) {
    return Padding(
      padding: const EdgeInsets.all(8.0),
      child: SizedBox(
        height: 200,
        width: 200,
        child: RTCVideoView(
          stream.renderer!,
          objectFit: RTCVideoViewObjectFit.RTCVideoViewObjectFitCover,
        ),
      ),
    );
  }
}
```

### Step 5 : Creating the MeetingScreen

Let's create meeting_screen.dart file and create MeetingScreen StateFul Widget.

The MeetingScreen will consist of:

- MeetingBuilder - This will build `Meeting` based on given configuration.

MeetingScreen will accept meetingId and token in constructor

- meetingId - meetingId, you want to join
- token - VideoSdk Auth token

```js title="meeting_screen.dart"
import 'package:flutter/material.dart';
import 'package:videosdk/rtc.dart';
import 'meeting_controls.dart';
import 'participant_tile.dart';

class MeetingScreen extends StatefulWidget {
  final String meetingId;
  final String token;
  final void Function() leaveMeeting;

  const MeetingScreen(
      {Key? key,
      required this.meetingId,
      required this.token,
      required this.leaveMeeting})
      : super(key: key);

  @override
  State<MeetingScreen> createState() => _MeetingScreenState();
}

class _MeetingScreenState extends State<MeetingScreen> {
  Map<String, Stream?> participantVideoStreams = {};

  bool micEnabled = true;
  bool webcamEnabled = true;

  void setParticipantStreamEvents(Participant participant) {
    participant.on(Events.streamEnabled, (Stream stream) {
      if (stream.kind == 'video') {
        setState(() => participantVideoStreams[participant.id] = stream);
      }
    });

    participant.on(Events.streamDisabled, (Stream stream) {
      if (stream.kind == 'video') {
        setState(() => participantVideoStreams.remove(participant.id));
      }
    });
  }

  void setMeetingEventListener(Meeting _meeting) {
    setParticipantStreamEvents(_meeting.localParticipant);
    _meeting.on(
      Events.participantJoined,
      (Participant participant) => setParticipantStreamEvents(participant),
    );
    _meeting.on(Events.participantLeft, (String participantId) {
      if (participantVideoStreams.containsKey(participantId)) {
        setState(() => participantVideoStreams.remove(participantId));
      }
    });
    _meeting.on(Events.meetingLeft, () {
      participantVideoStreams.clear();
      widget.leaveMeeting();
    });
  }

  @override
  Widget build(BuildContext context) {
    return MeetingBuilder(
      meetingId: widget.meetingId,
      token: widget.token,
      micEnabled: micEnabled,
      webcamEnabled: webcamEnabled,
      displayName: "Yash Chudasama",
      notification: const NotificationInfo(
          title: "Video SDK",
          message: "Video SDK is sharing screen in the meeting",
          icon: "notification_share"),
      builder: (_meeting) {
        setMeetingEventListener(_meeting);
        return SingleChildScrollView(
          child: Column(
            crossAxisAlignment: CrossAxisAlignment.center,
            children: [
              Text("Meeting ID: ${widget.meetingId}"),
              MeetingControls(
                onToggleMicButtonPressed: () {
                  micEnabled ? _meeting.muteMic() : _meeting.unmuteMic();
                  micEnabled = !micEnabled;
                },
                onToggleWebcamButtonPressed: () {
                  webcamEnabled
                      ? _meeting.disableWebcam()
                      : _meeting.enableWebcam();
                  webcamEnabled = !webcamEnabled;
                },
                onLeaveButtonPressed: () => _meeting.leave(),
              ),
              ...participantVideoStreams.values
                  .map(
                    (e) => ParticipantTile(
                      stream: e!,
                    ),
                  )
                  .toList(),
            ],
          ),
        );
      },
    );
  }
}
```

### Step 6 : Change main.dart

Let's change `main.dart` file.

Remove boilerplate code from the `main.dart`. Create `VideoSDKQuickStart` StatefulWidget and pass it to `MaterialApp`.

`VideoSDKQuickStart` widget will return `MeetingScreen` if meeting is active, otherwise return `JoinScreen`.

```js title="main.dart"
import 'package:flutter/material.dart';
import 'api.dart';
import 'join_screen.dart';
import 'meeting_screen.dart';

void main() {
  runApp(
    const MaterialApp(
      title: 'VideoSDK QuickStart',
      home: VideoSDKQuickStart(),
    ),
  );
}

class VideoSDKQuickStart extends StatefulWidget {
  const VideoSDKQuickStart({Key? key}) : super(key: key);

  @override
  State<VideoSDKQuickStart> createState() => _VideoSDKQuickStartState();
}

class _VideoSDKQuickStartState extends State<VideoSDKQuickStart> {
  String meetingId = "";
  bool isMeetingActive = false;

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(
        title: const Text("VideoSDK QuickStart"),
      ),
      body: Padding(
        padding: const EdgeInsets.all(16.0),
        child: isMeetingActive
            ? MeetingScreen(
                meetingId: meetingId,
                token: token,
                leaveMeeting: () {
                  setState(() => isMeetingActive = false);
                },
              )
            : JoinScreen(
                onMeetingIdChanged: (value) => meetingId = value,
                onCreateMeetingButtonPressed: () async {
                  meetingId = await createMeeting();
                  setState(() => isMeetingActive = true);
                },
                onJoinMeetingButtonPressed: () {
                  setState(() => isMeetingActive = true);
                },
              ),
      ),
    );
  }
}
```

## Run and Test

The app is all set to test. Make sure to update the `token` in `api.dart`

Your app should look like this after the implementation.

import ReactPlayer from 'react-player'

<div style={{textAlign: 'center'}}>

<ReactPlayer controls url='/img/quick-start/flutter-final-video.mp4' height="560px" width={"100%"}/>

</div>

:::caution
For the tutorial purpose, we used a static token to initialize and join the meeting. But for the production version of the app, we recommend you use an Authentication Server that will generate and pass on the token to the Client App. For more details checkout [how to do server setup](/flutter/guide/video-and-audio-calling-api-sdk/server-setup).
:::


---

---
sidebar_label: Release Notes
pagination_label: Release Notes
---

import NoIndex from '../../../../mdx/\_no-index.mdx';

<NoIndex/>

# Release Notes - Flutter

This page will keep you update all the releases of Flutter SDK.

## v0.0.14

**Release Date** : 11th July 2022

**Change log** : None

**Bug Fix** :

1. Add the ViewPort method for better video quality based on view container.

   **Docs** : [How to Set Viewport?](https://docs.videosdk.live/flutter/guide/video-and-audio-calling-api-sdk/features/set-viewport)

---

## v0.0.8

**Release Date** : 25th November 2021

**Change log** : None

**Bug Fix** :

1. Participant can pause or resume all video, audio and shareshare streams.

2. Participant can set quality of video stream of other participant.

---


---

---
title: Run a sample Flutter Project - Video SDK Docs
hide_title: true
hide_table_of_contents: false
description: Create customizable real-time video & audio calling applications with Flutter SDK with Video SDK add live Video & Audio conferencing to your applications.
sidebar_label: "Run the Sample Project"
pagination_label: "Run the Sample Project"
keywords:
  - flutter sdk
  - dart sdk
  - sample project
  - flutter app
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: run-a-sample-flutter-project
---

import NoIndex from '../../../../mdx/\_no-index.mdx';

<NoIndex/>

# Run a Sample Project - Flutter

Video SDK provides open-source sample project [videosdk-rtc-javascript-sdk-example](https://github.com/videosdk-live/videosdk-rtc-javascript-sdk-example) on Github. This document introduces how to run this project.

## Prerequisites

- If your target platform is iOS, your development environment must meet the following requirements:
  - Flutter 2.0 or later
  - Dart 2.12.0 or later
  - macOS
  - Xcode (Latest version recommended)
- If your target platform is Android, your development environment must meet the following requirements:
  - Flutter 2.0 or later
  - Dart 2.12.0 or later
  - macOS or Windows
  - Android Studio (Latest version recommended)
- If your target platform is iOS, you need a real iOS device.
- If your target platform is Android, you need an Android simulator or a real Android device.
- Valid Video SDK [Account](https://app.videosdk.live/)

import APISecret from '../../../../mdx/introduction/\_api-key.mdx';

<APISecret title="Get your API key and Secret key" />

## Run the Sample Project

### Step 1: Clone the sample project

Clone the repository to your local environment.

```js
$ git clone https://github.com/videosdk-live/videosdk-rtc-flutter-sdk-example.git
```

### Step 2: Copy the .env.example file to .env file.

Open your favorite code editor and copy `.env.example` to `.env` file.

```js
$ cp .env.example .env
```

### Step 3: Modify .env file

Paste earlier generated temporary token here.

```js title=".env"
AUTH_TOKEN = "TEMPORARY-TOKEN";
```

### Step 4: Install the dependencies

Install all the dependencies to run the project.

```js
flutter pub get
```

### Step 4: Run the sample app

Bingo, it's time to push the launch button.

```js
flutter run
```


---

---
title: Just Click Setup - Testing Token Server | Video SDK
hide_title: true
hide_table_of_contents: false
description: Video SDK and Audio SDK, developers need to implement a token server. This requires efforts on both the front-end and backend.
sidebar_label: Authentication and Tokens
pagination_label: Authentication and Tokens
keywords:
  - audio calling
  - video calling
  - real-time communication
  - collaboration
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: server-setup
---

import ServerSetup from '../../../../mdx/introduction/\_server-setup.mdx';
import NoIndex from '../../../../mdx/\_no-index.mdx';

<NoIndex/>
<ServerSetup />


---

---
title: Sign up for free account Custom Video SDK
hide_title: true
hide_table_of_contents: false
description: Video SDK Sign up. Get started with 10,000 minutes free every month! Programmable Video SDKs and Rest APIs to build up scalable video conferencing applications.
sidebar_label: Get your API key and Secret
pagination_label: Get your API key and Secret
keywords:
  - authentication audio calling
  - authentication video calling
  - authentication real-time communication
  - tokens
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: signup-and-create-api
---

import APISecret from '../../../../mdx/introduction/\_api-key.mdx';
import NoIndex from '../../../../mdx/\_no-index.mdx';

<NoIndex/>
<APISecret title="Get your API key and Secret key" />


---

---
title: Getting Started with Video & Audio Calling
hide_title: false
hide_table_of_contents: false
description: video & audio calling sdk will help you to integrate video & audio calling in your application.
sidebar_label: Start or Join Meeting
pagination_label: Getting Started Video & Audio Calling
keywords:
  - audio calling
  - video calling
  - real-time communication
  - collaboration
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: start-or-join-meeting
---

import Mermaid from '@theme/Mermaid';
import NoIndex from '../../../../mdx/\_no-index.mdx';

<NoIndex/>

# Explore video & audio calling

This guide will get you running with the VideoSDK video & audio calling in minutes.

## Overview

At it's core, VideoSDK RTC is a distributed SFU. It eanbles highly scalable video & audio meetings unlike vanilla webRTC.

VideoSDK enables opportunity to integrate video & audio calling to Web, Android, IOS applications. it provides Programmable SDKs and REST APIs to build up scalable video conferencing applications.

## Terminology

#### **Meeting**

A Meeting represents real-time audio, video, and/or screen-share session, and is the basic building block for media sharing among participants.

#### **Participants**

Participants are the client applications that are connected to a Meeting and shares video & audio media with one another.

#### **Local Participant**

Local Participant producing audio or video stream from the local client's media sources

#### **Streams**

Streams are indiviual video & audio streams produced by the participants in the meeting

#### **Active Speaker**

Active Speaker represents the participant who is currently producing highest decibels audio stream (in other words speaking)

#### **Active Presenter**

Active Presenter is the participant who is currently sharing his/her screen as a video stream

#### **Main participant**

Main Participant represents the client who shall be displayed on the main screen indicating that he/she is either presenting or speaking

## Architecture

This diagram demonstrates end-to-end flow to implement video & audio calling, record calls and go-live on social media.
<Mermaid chart={`sequenceDiagram Your App Client->>Your App Server: Request to Auth; activate Your App Server; Note right of Your App Server: JWT Auth using Key and Secret; Your App Server-->>Your App Client: Received Token; deactivate Your App Server; Your App Client->>VideoSDK Server: Request for meetingId; activate VideoSDK Server; Note right of VideoSDK Server: Generate unique meetingId; VideoSDK Server-->>Your App Client: meetingId Received; deactivate VideoSDK Server; Your App Client->>VideoSDK Server: Request to Join; activate VideoSDK Server; Note right of VideoSDK Server: Broadcasting to each participants; VideoSDK Server-->>Your App Client: Meeting Joined; deactivate VideoSDK Server; Your App Client-)VideoSDK Server: Subscribe to Events; VideoSDK Server--)Your App Client: Get notified on Updates; Your App Client->>VideoSDK Server: Request to Go Live via RTMP; Note right of VideoSDK Server: Composing Real-time Stream; VideoSDK Server--)Social Media: Push RTMP Stream; Your App Client->>VideoSDK Server: Request to Start Recording; Note right of VideoSDK Server: Recording Started; VideoSDK Server-->>Your App Client: Trigger Webhook to Start Recording; Your App Client->>VideoSDK Server: Request to Leave Meeting; activate VideoSDK Server; Note right of VideoSDK Server: Participant Left; VideoSDK Server-->>Your App Client: Meeting Left; deactivate VideoSDK Server; Your App Client->>VideoSDK Server: Request to End Meeting; activate VideoSDK Server; Note right of VideoSDK Server: Kick off all the Participants; VideoSDK Server--)Social Media: End Pushing RTMP Stream; VideoSDK Server-->>Your App Client: Trigger Webhook to Stop Recording; VideoSDK Server-->>Your App Client: Meeting End; deactivate VideoSDK Server;`}/>


---

---
title: Install Video & Audio Calling SDK
hide_title: false
hide_table_of_contents: false
description: VideoSDK supports many programmable interfaces such as javascript, react, react native, android, ios and flutter.
sidebar_label: Supported platforms
pagination_label: Supported platforms
keywords:
  - audio calling
  - video calling
  - real-time communication
  - collaboration
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: supported-platforms
---

import NoIndex from '../../../../mdx/\_no-index.mdx';

<NoIndex/>

# Supported platforms

## For video & audio calling SDK

This guide will follow installation guide for all the VideoSDK for Video & Audio Calling. Follow the below guide to install VideoSDK RTC in your website or App

## Web SDK

1. [JavaScript](/javascript/guide/video-and-audio-calling-api-sdk/getting-started)
2. [React JS](/react/guide/video-and-audio-calling-api-sdk/concept-and-architecture)

## Mobile SDK

1. [React Native Android](/react-native/guide/video-and-audio-calling-api-sdk/react-native-android-sdk)
2. [React Native IOS](/react-native/guide/video-and-audio-calling-api-sdk/react-native-ios-sdk)
3. [Android](/android/guide/video-and-audio-calling-api-sdk/concept-and-architecture)
4. [IOS](/ios/guide/video-and-audio-calling-api-sdk/concept-and-architecture)
5. [Flutter](/flutter/guide/video-and-audio-calling-api-sdk/getting-started)


---

---
title: Custom Tracks
hide_title: true
hide_table_of_contents: false
description: Custom Video Track features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Custom Tracks
pagination_label: Custom Tracks
keywords:
  - Camera on
  - Camera off
  - Webcam on
  - Webcam off
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
---

import NoIndex from '../../../../mdx/\_no-index.mdx';

<NoIndex/>

## Custom Video Track - Flutter

- You can create a Video Track using `createCameraVideoTrack()` method of `VideoSDK` class.
- This method can be used to create video track using different encoding parameters, camera facing mode, and optimization mode.

### Parameters

- **cameraId**:

  - type: `String`
  - required: `false`
  - It will be the id of the camera from which the video should be captured.

- **encoderConfig**:

  - type: `CustomTrackVideoConfig`
  - required: `false`
  - default: `h360p_w640p`
  - You can chose from the below mentioned list of values for the encoder config.

| Encoder Config | Resolution | Frame Rate |   Bitrate    |
| -------------- | :--------: | :--------: | :----------: |
| h90p_w160p     |   160x90   |   15 fps   |  60000 kbps  |
| h180p_w320p    |  320x180   |   15 fps   | 120000 kbps  |
| h216p_w384p    |  384x216   |   15 fps   | 180000 kbps  |
| h360p_w640p    |  640x360   |   20 fps   | 300000 kbps  |
| h540p_w960p    |  960x540   |   25 fps   | 600000 kbps  |
| h720p_w1280p   |  1280x720  |   30 fps   | 2000000 kbps |
| h1080p_w1920p  | 1920x1080  |   30 fps   | 3000000 kbps |
| h1440p_w2560p  | 2560x1440  |   30 fps   | 5000000 kbps |
| h2160p_w3840p  | 3840x2160  |   30 fps   | 8000000 kbps |
| h120p_w160p    |  160x120   |   15 fps   |  80000 kbps  |
| h180p_w240p    |  240x180   |   15 fps   | 100000 kbps  |
| h240p_w320p    |  320x240   |   15 fps   | 150000 kbps  |
| h360p_w480p    |  480x360   |   20 fps   | 225000 kbps  |
| h480p_w640p    |  640x480   |   25 fps   | 300000 kbps  |
| h540p_w720p    |  720x540   |   30 fps   | 450000 kbps  |
| h720p_w960p    |  960x720   |   30 fps   | 1500000 kbps |
| h1080p_w1440p  | 1440x1080  |   30 fps   | 2500000 kbps |
| h1440p_w1920p  | 1920x1440  |   30 fps   | 3500000 kbps |

:::note

Above mentioned encoder configurations are valid for both, landscape as well as portrait mode.

:::

- **facingMode**:

  - type: `String`
  - required: `false`
  - Allowed values : `front` | `environment`
  - It will specify whether to use front or back camera for the video track.

- **multiStream**

  - type: `boolean`
  - required: `false`
  - default: `true`
  - It will specify if the stream should send multiple resolution layers or single resolution layer.

:::info

- To learn more about optimizations and best practices for using custom video tracks, [follow this guide](/flutter/guide/video-and-audio-calling-api-sdk/render-media/optimize-video-track).
- This parameter is only available from `v1.0.9`.

:::

#### Returns

- `Future<CustomTrack>`

### Example

```javascript
CustomTrack videoTrack = await VideoSDK.createCameraVideoTrack(
      encoderConfig: CustomVideoTrackConfig.h1440p_w1920p,
      multiStream: false,
      facingMode:"user",
    );
```

## Custom Audio Track

- You can create a Audio Track using `createMicrophoneAudioTrack()` method of `VideoSDK` class.
- This method can be used to create audio track using different encoding parameters and noise cancellation configuration.

### Parameters

- **microphoneId**:

  - type: `String`
  - required: `false`
  - It will be the id of the mic from which the audio should be captured.

- **encoderConfig**:

  - type: `CustomTrackAudioConfig`
  - required: `false`
  - default: `speech_standard`
  - You can chose from the below mentioned list of values for the encoder config.

| Encoder Config      | Bitrate  | Auto Gain | Echo Cancellation | Noise Suppression |
| ------------------- | :------: | :-------: | :---------------: | :---------------: |
| speech_low_quality  | 16 kbps  |   TRUE    |       TRUE        |       TRUE        |
| speech_standard     | 24 kbps  |   TRUE    |       TRUE        |       TRUE        |
| music_standard      | 32 kbps  |   FALSE   |       FALSE       |       FALSE       |
| standard_stereo     | 64 kbps  |   FALSE   |       FALSE       |       FALSE       |
| high_quality        | 128 kbps |   FALSE   |       FALSE       |       FALSE       |
| high_quality_stereo | 192 kbps |   FALSE   |       FALSE       |       FALSE       |

- **noiseConfig**

  - **echoCancellation**

    - type: `boolean`
    - required: `false`
    - If `true` echo cancellation will turned on else it would be turned off.

  - **autoGainControl**

    - type: `boolean`
    - required: `false`
    - If `true` auto gain will turned on else it would be turned off.

  - **noiseSuppression**
    - type: `boolean`
    - required: `false`
    - If `true` noise suppression will turned on else it would be turned off.

#### Returns

- `Future<CustomTrack>`

### Example

```javascript
CustomTrack audioTrack = await VideoSDK.createMicrophoneAudioTrack(
        encoderConfig: CustomAudioTrackConfig.high_quality);
```


---

---
title: Participant Class Events
sidebar_position: 1
sidebar_label: Events
pagination_label: Participant Class Events
---

import NoIndex from '../../../../../mdx/\_no-index.mdx';

<NoIndex/>

# Participant Class Events - Flutter

<div class="sdk-api-ref-only-h4">

---

### streamEnabled

- This event will be emitted when any [participant](introduction) starts consuming or producing stream of any type.

#### Example

```javascript
room.localParticipant.on(Events.streamEnabled, (Stream stream){
  // do something
});
```

---

### streamDisabled

- This event will be emitted when any [participant](introduction) stops consuming or producing stream of any type.

#### Example

```javascript
room.localParticipant.on(Events.streamDisabled, (Stream stream){
  // do something
});
```

---

### streamPaused

- This event will be emitted when any [participant](introduction) pauses consuming or producing stream of any type.

#### Example

```javascript
room.localParticipant.on(Events.streamPaused, (Stream stream){
  // do something
});
```

---

### streamResumed

- This event will be emitted when any [participant](introduction) resumes consuming or producing stream of any type.

#### Example

```javascript
room.localParticipant.on(Events.streamResumed, (Stream stream){
  // do something
});
```

---

### videoQualityChanged

- `videoQualityChanged` is a callback which gets triggered whenever a participant's video quality changes.

- `currentQuality` and `prevQuality` can have values `HIGH` | `MEDIUM` | `LOW`.

#### Example

```js
participant.on(Events.videoQualityChanged, (data) {
  String currentQuality = data["currentQuality"];
  String prevQuality = data["prevQuality"];
});
```

---

</div>


---

---
title: Video SDK Participant Class
sidebar_position: 1
sidebar_label: Introduction
pagination_label: Video SDK Participant Class
---

import NoIndex from '../../../../../mdx/\_no-index.mdx';

<NoIndex/>

# Video SDK Participant Class - Flutter

<div id="tailwind" class="sdk-api-ref">

## Introduction

`Participant` class includes all the properties, methods and events related to the participants joined in a particular room.

## Participant Properties

<div class="row">
<div class="col col--4 margin-bottom--sm" >

- [id](properties#id)

</div>
<div class="col col--4 margin-bottom--sm" >

- [displayName](properties#displayname)

</div>
<div class="col col--4 margin-bottom--sm" >

- [isLocal](properties#islocal)

</div>
<div class="col col--4 margin-bottom--sm" >

- [pinState](properties#pinstate)

</div>

<div class="col col--4 margin-bottom--sm" >

- [mode](properties#mode)

</div>
<div class="col col--4 margin-bottom--sm" >

- [streams](properties#streams)

</div>
</div>

## Participant Methods

<div class="row">
<div class="col col--4 margin-bottom--sm" >

- [enableCam](/flutter/1.0.x/api/sdk-reference/participant-class/methods#enablecam)

</div>
<div class="col col--4 margin-bottom--sm" >

- [disableCam](/flutter/1.0.x/api/sdk-reference/participant-class/methods#disablecam)

</div>
<div class="col col--4 margin-bottom--sm" >

- [unmuteMic](methods#unmutemic)

</div>
<div class="col col--4 margin-bottom--sm" >

- [muteMic](methods#mutemic)

</div>
<div class="col col--4 margin-bottom--sm" >

- [setQuality](methods#setquality)

</div>
<div class="col col--4 margin-bottom--sm" >

- [pin](methods#pin)

</div>
<div class="col col--4 margin-bottom--sm" >

- [unpin](methods#unpin)

</div>
<div class="col col--4 margin-bottom--sm" >

- [setViewPort](methods#setviewport)

</div>
<div class="col col--4 margin-bottom--sm" >

- [remove](methods#remove)

</div>
<div class="col col--4 margin-bottom--sm" >

- [on](methods#on)

</div>
<div class="col col--4 margin-bottom--sm" >

- [getVideoStats](methods#getvideostats)

</div>
<div class="col col--4 margin-bottom--sm" >

- [getAudioStats](methods#getaudiostats)

</div>
<div class="col col--4 margin-bottom--sm" >

- [getShareStats](methods#getsharestats)

</div>
</div>

## Participant Events

<div class="row">
<div class="col col--4 margin-bottom--sm" >

- [streamEnabled](events#streamenabled)

</div>
<div class="col col--4 margin-bottom--sm" >

- [streamDisabled](events#streamdisabled)

</div>
<div class="col col--4 margin-bottom--sm" >

- [streamPaused](events#streampaused)

</div>
<div class="col col--4 margin-bottom--sm" >

- [streamResumed](events#streamresumed)

</div>
</div>
</div>


---

---
title: Participant Class Methods
sidebar_position: 1
sidebar_label: Methods
pagination_label: Participant Class Methods
---

import NoIndex from '../../../../../mdx/\_no-index.mdx';

<NoIndex/>

# Participant Class Methods - Flutter

<div class="sdk-api-ref-only-h4">

### enableCam()

- `enableCam()` is used to enable participant's camera.

#### Events associated with `enableCam()`:

- First the participant will get a callback on [cameraRequested](../room-class/events#camerarequested) and once the participant accepts the request, camera device will be enabled.
- Every Participant will receive a `streamEnabled` event with `stream` object.

#### Returns

- _`void`_

#### Example

```js
participant.enableCam();
```

---

### disableCam()

- `disableCam()` is used to disable participant camera.

#### Events associated with `disableCam()`:

- Every Participant will receive a `streamDisabled` event with `stream` object.

#### Returns

- _`void`_

#### Example

```js
participant.disableCam();
```

---

### unmuteMic()

- `unmuteMic()` is used to enable participant microphone.

#### Events associated with `unmuteMic()`:

- First the participant will get a callback on [micRequested](../room-class/events#micrequested) and once the participant accepts the request, mic will be enabled.
- Every Participant will receive a `streamEnabled` event with `stream` object.

#### Returns

- _`void`_

#### Example

```js
participant.unmuteMic();
```

---

### muteMic()

- `muteMic()` is used to disable participant microphone.

#### Events associated with `muteMic()`:

- Every Participant will receive a `streamDisabled` event with `stream` object.

#### Returns

- _`void`_

#### Example

```js
participant.muteMic();
```

---

### setQuality()

- It is used to set the quality of the participant's video stream.

#### Parameters

- **quality**: `"low"`|| `"med"` | `"high"`

#### Returns

- _`void`_

#### Example

```js
participant.setQuality("high");
```

---

### pin()

- It is used to set pin state of the participant. You can use it to pin the screen share, camera or both of the participant. It accepts a optional paramter of type `PinType`. Default PinType is `SHARE_AND_CAM`

#### Parameters

- **pinType**: `PinType.SHARE_AND_CAM` | `PinType.CAM` | `PinType.SHARE`

#### Returns

- _`void`_

#### Example

```js
participant.pin(PinType.CAM);
```

---

### unpin()

- It is used to unpin participant. You can use it to unpin the screen share, camera or both of the participant. It accepts a optional paramter of type `PinType`. Default PinType is `SHARE_AND_CAM`

#### Parameters

- **pinType**: `PinType.SHARE_AND_CAM` | `PinType.CAM` | `PinType.SHARE`

#### Returns

- _`void`_

#### Example

```js
participant.unpin(PinType.CAM);
```

---

### setViewPort()

- `setViewPort()` is used to set the quality of the participant's video stream based on the viewport height and width.

#### Parameters

- **width**: int
- **height**: int

#### Returns

- `void`

#### Example

```js
participant.setViewPort(480, 360);
```

---

### remove()

- It is used to remove participant from the room.

#### Returns

- _`void`_

#### Example

```js
participant.remove();
```

---

### on()

- It is used to listen [`Participant`](introduction) related events.

#### Parameters

- event

  - type: [`Events`](events)
  - This will specify the event to be listened.

- eventHandler
  - type: [`Function`](https://api.dart.dev/stable/2.15.1/dart-core/Function-class.html)
  - This will be invoked whenever, specified event occurred.

#### Returns

- _`void`_

#### Example

```js
participant.on(Events.streamEnabled, (Stream stream){
    // do something
});
```

### getVideoStats()

- `getVideoStats()` will return an `List<dynamic>?` which will contain details regarding the participant's critical video metrics such as **Jitter**, **Packet Loss** etc.

#### Returns

- `object`
  - `jitter` : It represents the distortion in the stream.
  - `bitrate` : It represents the bitrate of the stream which is being transmitted.
  - `totalPackets` : It represents the total packet count which were transmitted for that particiular stream.
  - `packetsLost` : It represents the total packets lost during the transimission of the stream.
  - `rtt` : It represents the time between the stream being reached to client from the server in milliseconds(ms).
  - `codec`: It represents the codec used for the stream.
  - `network`: It represents the network used to transmit the stream
  - `size`: It is object containing the height, width and frame rate of the stream.

:::note

getVideoStats() will return the metrics for the participant at that given point of time and not average data of the complete meeting.

To view the metrics for the complete meeting using the stats API documented [here](/api-reference/realtime-communication/fetch-session-quality-stats).

:::

:::info

If you are getting `rtt` greater than 300ms, try using a different region which is nearest to your user. To know more about changing region [visit here](/api-reference/realtime-communication/create-room).
:::

---

### getAudioStats()

- `getAudioStats()` will return an `List<dynamic>?` which will contain details regarding the participant's critical audio metrics such as **Jitter**, **Packet Loss** etc.

#### Returns

- `List`
  - `jitter` : It represents the distortion in the stream.
  - `bitrate` : It represents the bitrate of the stream which is being transmitted.
  - `totalPackets` : It represents the total packet count which were transmitted for that particiular stream.
  - `packetsLost` : It represents the total packets lost during the transimission of the stream.
  - `rtt` : It represents the time between the stream being reached to client from the server in milliseconds(ms).
  - `codec`: It represents the codec used for the stream.
  - `network`: It represents the network used to transmit the stream

:::note

getAudioStats() will return the metrics for the participant at that given point of time and not average data of the complete meeting.

To view the metrics for the complete meeting using the stats API documented [here](/api-reference/realtime-communication/fetch-session-quality-stats).

:::

:::info

If you are getting `rtt` greater than 300ms, try using a different region which is nearest to your user. To know more about changing region [visit here](/api-reference/realtime-communication/create-room).

:::

### getShareStats()

- `getShareStats()` will return an `List<dynamic>?` which will contain details regarding the participant's critical video metrics such as **Jitter**, **Packet Loss** etc.

#### Returns

- `List`
  - `jitter` : It represents the distortion in the stream.
  - `bitrate` : It represents the bitrate of the stream which is being transmitted.
  - `totalPackets` : It represents the total packet count which were transmitted for that particiular stream.
  - `packetsLost` : It represents the total packets lost during the transimission of the stream.
  - `rtt` : It represents the time between the stream being reached to client from the server in milliseconds(ms).
  - `codec`: It represents the codec used for the stream.
  - `network`: It represents the network used to transmit the stream
  - `size`: It is object containing the height, width and frame rate of the stream.

:::note

getShareStats() will return the metrics for the participant at that given point of time and not average data of the complete meeting.

To view the metrics for the complete meeting using the stats API documented [here](/api-reference/realtime-communication/fetch-session-quality-stats).

:::

:::info

If you are getting `rtt` greater than 300ms, try using a different region which is nearest to your user. To know more about changing region [visit here](/api-reference/realtime-communication/create-room).

:::

</div>


---

---
title: Participant Class Properties
sidebar_position: 1
sidebar_label: Properties
pagination_label: Participant Class Properties
---

import NoIndex from '../../../../../mdx/\_no-index.mdx';

<NoIndex/>

# Participant Class Properties - Flutter

<div class="sdk-api-ref-only-h4">

### id

- type: [`String`](https://api.flutter.dev/flutter/dart-core/String-class.html)

- Unique id of the participant, who has joined the room.

---

### displayName

- type: [`String`](https://api.flutter.dev/flutter/dart-core/String-class.html)

- It will be the `displayName` of the participant, who has joined the room.

---

### isLocal

- type: [`bool`](https://api.flutter.dev/flutter/dart-core/bool-class.html)

- It will represents whether the participant is [`LocalParticipant`](../room-class/properties#localparticipant)(You) or not. If it is true, then participant is [`LocalParticipant`](../room-class/properties#localparticipant) otherwise RemoteParticipant.

---

### streams

- type: [`Map<String, Stream>`](https://api.flutter.dev/flutter/dart-core/Map-class.html)

- It will represents the stream for that particular participant who has joined the room. Stream could be `audio` , `video` or `share`.

---

### pinState

- type: `ParticipantPinState`

- It will represents the current pin state of the participant. It has properties `cam` and `share` of type boolean.

---

### mode

- type: `Mode`

- It will represents the participants current mode.

---

</div>


---

---
title: Video SDK PubSub Class
sidebar_position: 1
sidebar_label: Introduction
pagination_label: Video SDK PubSub Class
---

import NoIndex from '../../../../../mdx/\_no-index.mdx';

<NoIndex/>

# Video SDK PubSub Class - Flutter

<div class="sdk-api-ref">

## Introduction

PubSub class provides the methods to implement Publisher-Subscriber feature in your Flutter Application.

## PubSub Methods

<div class="row">

<div class="col col--4 margin-bottom--sm" >

- [publish](methods#publish)

</div>
<div class="col col--4 margin-bottom--sm" >

- [subscribe](methods#subscribe)

</div>

<div class="col col--4 margin-bottom--sm" >

- [unsubscribe](methods#unsubscribe)

</div>
</div>
</div>


---

---
sidebar_position: 1
sidebar_label: Methods
pagination_label: PubSub Class Methods
title: PubSub Class Methods
---

import NoIndex from '../../../../../mdx/\_no-index.mdx';

<NoIndex/>

# PubSub Class Methods - Flutter

<div class="sdk-api-ref-only-h4">

### publish()

- `publish()` is used to publish messages on a specified topic in the room.

#### Parameters

- topic

  - type: [`String`](https://api.dart.dev/stable/2.15.1/dart-core/String-class.html)
  - This is the name of the topic, for which message will be published.

- message

  - type: [`String`](https://api.dart.dev/stable/2.15.1/dart-core/String-class.html)
  - This is the actual message.

- options
  - type: [`PubSubPublishOptions`](pubsub-publish-options-class)
  - This specifies the options for publish.

#### Returns

- _`Future<void>`_

#### Example

```js
// Publishing message
room.pubSub
    .publish(
      "CHAT",
      "Hii",
      const PubSubPublishOptions(persist: true),
    );
```

---

### subscribe()

- `subscribe()` is used to subscribe a particular topic to get all the messages of that particular topic in the room.

#### Parameters

- topic:

  - type: [`String`](https://api.dart.dev/stable/2.15.1/dart-core/String-class.html)
  - Participants can listen to messages on that particular topic.

- messageHandler:

  - type: [`Function(PubSubMessage)`](pubsub-message-class)
  - This function will be called, whenever pubsub message received.

#### Returns

- [_`Future<PubSubMessages>`_](pubsub-message-class)

#### Example

```js
// Subscribing 'CHAT' Topic

void handleMessage(PubSubMessage pubsubMessage) {
  print(pubsubMessage.message);
}

void subscribePubSubTopic() async {
  PubSubMessages pubsubMessages =
      room.pubSub.subscribe("CHAT", handleMessage);

  // do something
}

subscribePubSubTopic();
```

---

### unsubscribe()

- `unsubscribe()` is used to unsubscribe a particular topic on which you have subscribed priviously.

#### Parameters

- topic:

  - type: [`String`](https://api.dart.dev/stable/2.15.1/dart-core/String-class.html)
  - This is the name of the topic to be unsubscribed.

- messageHandler:

  - type: [`Function(PubSubMessage)`](https://api.dart.dev/stable/2.15.1/dart-core/Function-class.html)
  - This is the message handler to be unsubscribed.

#### Returns

- _`Future<void>`_

#### Example

```js
// Unsubscribing 'CHAT' topic
room.pubSub.unsubscribe("CHAT", handleMessage);
```

</div>


---

---
sidebar_position: 1
sidebar_label: PubSubMessage Class
pagination_label: PubSubMessage Class
title: PubSubMessage Class
---

import NoIndex from '../../../../../mdx/\_no-index.mdx';

<NoIndex/>

# PubSubMessage Class - Flutter

<div class="sdk-api-ref-only-h4">

## Properties

### id

- type: [`String`](https://api.dart.dev/stable/2.15.1/dart-core/String-class.html)

- Unique id of the pubsub message.

---

### message

- type: [`String`](https://api.dart.dev/stable/2.15.1/dart-core/String-class.html)

- Message that has been published on the specific topic.

---

### topic

- type: [`String`](https://api.dart.dev/stable/2.15.1/dart-core/String-class.html)

- Name of the topic.

---

### senderId

- type: [`String`](https://api.dart.dev/stable/2.15.1/dart-core/String-class.html)

- This is the id of the participant, who has sent this pubsub message.

---

### senderName

- type: [`String`](https://api.dart.dev/stable/2.15.1/dart-core/String-class.html)

- This is the name of the participant, who has sent this pubsub message.

---

### timestamp

- type: [`DateTime`](https://api.dart.dev/stable/2.15.1/dart-core/DateTime-class.html)

- Timestamp of when a message has been published.

</div>


---

---
sidebar_position: 1
sidebar_label: PubSubPublishOptions Class
pagination_label: PubSubPublishOptions Class
title: PubSubPublishOptions Class
---

import NoIndex from '../../../../../mdx/\_no-index.mdx';

<NoIndex/>

# PubSubPublishOptions Class - Flutter

<div class="sdk-api-ref-only-h4">

## Properties

### persist

- type: [`bool`](https://api.dart.dev/stable/2.15.1/dart-core/bool-class.html)

- defaultValue: `false`

- This property specifies whether to store messages on server for upcoming participants.

- If the value of this property is true, then server will store pubsub messages for the upcoming participants.

</div>


---

---
title: Room Class Events
sidebar_position: 1
sidebar_label: Events
pagination_label: Room Class Events
---

import NoIndex from '../../../../../mdx/\_no-index.mdx';

<NoIndex/>

# Room Class Events - Flutter

<div class="sdk-api-ref-only-h4">

---

### roomJoined

- This event will be emitted when a [localParticipant](properties#localparticipant) successfully joined the room.

#### Example

```javascript
room.on(Events.roomJoined, (){
  // do something
});
```

---

### roomLeft

- This event will be emitted when a [localParticipant](properties#localparticipant) left the room.

#### Example

```javascript
room.on(Events.roomLeft, () {
  // do something
});
```

---

### participantJoined

- This event will be emitted when a new [participant](../participant-class/introduction) joined the room.

#### Event handler parameters

- **participant**: [Participant](../participant-class/introduction)

#### Example

```javascript
room.on(Events.participantJoined, (participant) {
  // do something
});
```

---

### participantLeft

- This event will be emitted when a joined [participant](../participant-class/introduction) left the room.

#### Event handler parameters

- **participant**: [Participant](../participant-class/introduction)

#### Example

```javascript
room.on(Events.participantLeft, (participant) {
  // do something
});
```

---

### speakerChanged

- This event will be emitted when a active speaker changed.
- If you want to know which participant is actively speaking, then this event will be used.
- If no participant is actively speaking, then this event will pass `null` as an event handler parameter.

#### Event handler parameters

- **activeSpeakerId**: String?

#### Example

```javascript
room.on(Events.speakerChanged, (activeSpeakerId) {
  // do something
});
```

---

### presenterChanged

- This event will be emitted when any [participant](../participant-class/introduction) starts or stops screen sharing.
- It will pass `participantId` as an event handler parameter.
- If a participant stops screen-sharing, then this event will pass `null` as en event handler parameter.

#### Event handler parameters

- **activePresenterId**: String?

#### Example

```javascript
room.on(Events.presenterChanged, (activePresenterId) {
  // do something
});
```

---

### pinStateChanged

- This event will be emitted when any [participant](../participant-class/introduction) pin state gets changed.
- It will pass `participantId`, `state`, and `pinnedBy` as `Map<String, dynamic>` as an event handler parameter.

#### Event handler parameters

- **data**: `Map{'<'}String{','} dynamic>`\{**participantId**:String, **state**:Map{'<'}String, dynamic>, **pinnedBy**:String}

#### Example

```javascript
room.on(Events.pinStateChanged, (data) {
  // do something
});
```

### participantModeChanged

- This event will be emitted when any [participant](../participant-class/introduction) mode gets changed.
- It will pass `participantId`, and `pinnedBy` as `Map<String, dynamic>` as an event handler parameter.

#### Event handler parameters

- **data**: `Map{'<'}String, dynamic>`\{**participantId**:String, **mode**:String}

#### Example

```javascript
room.on(Events.participantModeChanged, (data) {
  // do something
});
```

---

### entryRequested

- This event will be emitted when a new [participant](../participant-class/introduction), who is trying to join the room, is having permission **`ask_join`** in token.
- This event will only be emitted to the [participants](properties#participants) in the room, who is having the permission **`allow_join`** in token.
- This event will pass following parameters as an event parameters, `participantId` and `name` of the new participant who is trying to join the room, `allow()` and `deny()` to take required actions.

#### Event handler parameters

- **data**: `Map{'<'}String, dynamic>`\{ **"allow"**: Function; **"deny"**: Function; **"name"**: String; **"participantId"**: String }
  - **allow**: Function
  - **deny**: Function
  - **name**: String
  - **participantId**: String

#### Example

```javascript
room.on(Events.entryRequested, (data){
  String? participantId = data["participantId"];
  String? name = data["name"];

  Function allow = data["allow"];
  Function deny = data["deny"];

  print("$name requested to join the room.");

  // If you want to allow the entry request
  allow();

  // if you want to deny the entry request
  deny();
});
```

---

### entryResponded

- This event will be emitted when the `join()` request is responded.
- This event will be emitted to the [participants](properties#participants) in the room, who is having the permission **`allow_join`** in token.
- This event will be also emitted to the [participant](../participant-class/introduction), who requested to join the room.

#### Event handler parameters

- **participantId**: _String_
- **decision**: _"allowed"_ | _"denied"_

#### Example

```javascript
room.on(Events.entryResponded, (participantId, decision) {
  // participantId will be id of participant, who requested to join room

  if (decision === "allowed") {
    // entry allowed
  } else {
    // entry denied
  }
});
```

---

### cameraRequested

- This event will be emitted to the participant `B` when any other participant `A` requests to enable camera of participant `B`.
- On accepting the request, camera of participant `B` will be enabled.

#### Event handler parameters

- **data**: `Map{'<'}String, dynamic>`\{ **accept**: Function; **participantId**: String; **reject**: Function }
  - **accept**: Function
  - **participantId**: String
  - **reject**: Function

#### Example

```javascript
room.on(Events.cameraRequested, (data) {
  String? participantId = data["participantId"];

  Function accept = data["accept"];
  Function reject = data["deny"];

  // participantId, will be the id of participant who requested to enable camera

  // if accept request
  accept();

  // if reject request
  reject();
});
```

---

### micRequested

- This event will be emitted to the participant `B` when any other participant `A` requests to enable mic of participant `B`.
- On accepting the request, mic of participant `B` will be enabled.

#### Event handler parameters

- **data**: Map{'<'}String, dynamic>\{ **accept**: Function; **participantId**: String; **reject**: Function }
  - **accept**: Function
  - **participantId**: String
  - **reject**: Function

#### Example

```javascript
room.on(Events.micRequested, (data) {
  String participantId = data["participantId"];

  Function accept = data["accept"];
  Function reject = data["reject"];

  // participantId, will be the id of participant who requested to enable camera

  // if accept request
  accept();

  // if reject request
  reject();
});
```

---

### recordingStarted

_`This event will be deprecated soon`_

- This event will be emitted when recording of the room is started.

#### Example

```javascript
room.on(Events.recordingStarted, () {
  // do something
});
```

---

### recordingStopped

_`This event will be deprecated soon`_

- This event will be emitted when recording of the room is stopped.

#### Example

```javascript
room.on(Events.recordingStopped, () {
  // do something
});
```

---

### recordingStateChanged

- This event will be emitted when the meeting's recording status changed.

#### Event callback parameters

- **status**: String

`status` has following values

- `RECORDING_STARTING` - Recording is in starting phase and hasn't started yet.
- `RECORDING_STARTED` - Recording has started successfully.
- `RECORDING_STOPPING` - Recording is in stopping phase and hasn't stopped yet.
- `RECORDING_STOPPED` - Recording has stopped successfully.

#### Example

```javascript
room.on(Events.recordingStateChanged, (String status) {
  log("Meeting recording status : $status");
});
```

---

### liveStreamStarted

_`This event will be deprecated soon`_

- This event will be emitted when `RTMP` live stream of the room is started.

#### Example

```javascript
room.on(Events.liveStreamStarted, () {
  // do something
});
```

---

### liveStreamStopped

_`This event will be deprecated soon`_

- This event will be emitted when `RTMP` live stream of the room is stopped.

#### Example

```javascript
room.on(Events.liveStreamStopped, () {
  // do something
});
```

---

### livestreamStateChanged

- This event will be emitted when the meeting's livestream status changed.

#### Event callback parameters

- **status**: String

`status` has following values

- `LIVESTREAM_STARTING` - Livestream is in starting phase and hasn't started yet.
- `LIVESTREAM_STARTED` - Livestream has started successfully.
- `LIVESTREAM_STOPPING` - Livestream is in stopping phase and hasn't stopped yet.
- `LIVESTREAM_STOPPED` - Livestream has stopped successfully.

#### Example

```javascript
room.on(Events.liveStreamStateChanged, (String status) {
  log("Meeting live streaming status : $status");
});
```

---

### hlsStateChanged

- This event will be emitted when the meeting's HLS(Http Livestreaming) status changed.

#### Event callback parameters

- **data**: \{ **status**: String , **playbackHlsUrl**: String , **livestreamUrl**: String }
  - **status**: String
  - **playbackHlsUrl**: String _`will receive this property only in HLS_STARTED status`_
  - **livestreamUrl**: String _`will receive this property only in HLS_STARTED status`_

`status` has following values

- `HLS_STARTING` - Hls is in starting phase and hasn't started yet.
- `HLS_STARTED` - Hls has started successfully will return `playbaclHlsUrl` and `livestreamUrl`.
- `HLS_PLAYABLE` - Hls has started can be played now, it will return `playbaclHlsUrl` and `livestreamUrl`.
- `HLS_STOPPING` - Hls is in stopping phase and hasn't stopped yet.
- `HLS_STOPPED` - Hls has stopped successfully.

#### Example

```javascript
room.on(Events.hlsStateChanged, (Map<String, dynamic> data) {
  toastMsg("Meeting HLS status : ${data['status']}");
  if (data['status'] == "HLS_PLAYABLE")
    log("PLAYBACKHLS URL -- " + data['playbackHlsUrl']);
});
```

---

---

### hlsStarted

_`This event will be deprecated soon`_

- This event will be emitted when `HLS` of the meeting is started.

#### Event callback parameters

- **downstreamUrl**: String

#### Example

```javascript
room.on(Events.hlsStarted, (String downstreamUrl) => {
  //
});
```

---

### hlsStopped

_`This event will be deprecated soon`_

- This event will be emitted when `HLS` of the meeting is stopped.

#### Example

```javascript
room.on(Events.hlsStopped, () => {
  //
});
```

---

### error

- This event will be emitted when and error occurs in the room.

#### Example

```javascript
room.on(Events.error, (error) {
  log("VIDEOSDK ERROR :: " +
      error['code'].toString() +
      "  :: " +
      error['name'].toString() +
      " :: " +
      error['message'].toString());
});
```

---

</div>


---

---
title: Room class for Flutter SDK.
hide_title: true
hide_table_of_contents: false
description: VideoSDK Room Class provides features to implement custom room layout in your application.
sidebar_label: Example
pagination_label: Room Class Example
keywords:
  - RTC Flutter
  - Room Class
  - Video API
  - Video Conferencing
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: room-class-example
---

import NoIndex from '../../../../../mdx/\_no-index.mdx';

<NoIndex/>

# Room Class Example - Flutter

```js title="Play with room instance"
// Join the room
room?.join();

// Get local participants
room?.localParticipant;

// Get remote participants
room?.participants;

// Adding event listner
room.on(Events.participantJoined, (Participant participant) {
  print("new participant => $participant");
  },
);
```


---

---
sidebar_position: 1
sidebar_label: Introduction
pagination_label: Intro to Video SDK Room Class
title: Video SDK Room Class
---

import NoIndex from '../../../../../mdx/\_no-index.mdx';

<NoIndex/>

# Video SDK Room Class - Flutter

<div id="tailwind" class="sdk-api-ref">

## Introduction

The `Room` class includes properties, methods and events for managing a VideoSDK Room, participants, video, audio and share streams, messaging and UI customization.

import LinksGrid from '../../../../../src/theme/LinksGrid'
import properties from '../data/properties.json'
import methods from '../data/methods.json'
import events from '../data/events.json'

## Room Properties

<div class="row">

<div class="col col--4 margin-bottom--sm" >

- [id](./properties#id)

</div>
<div class="col col--4 margin-bottom--sm" >

- [activeSpeakerId](./properties#activespeakerid)

</div>
<div class="col col--4 margin-bottom--sm" >

- [activePresenterId](./properties#activepresenterid)

</div>

<div class="col col--4 margin-bottom--sm" >

- [camEnabled](./properties#camenabled)

</div>

<div class="col col--4 margin-bottom--sm" >

- [selectedCamId](/flutter/1.0.x/api/sdk-reference/room-class/properties#selectedcamid)

</div>

<div class="col col--4 margin-bottom--sm" >

- [micEnabled](./properties#micenabled)

</div>

<div class="col col--4 margin-bottom--sm" >

- [hlsState](./properties#hlsstate)

</div>

<div class="col col--4 margin-bottom--sm" >

- [livestreamState](./properties#livestreamstate)

</div>

<div class="col col--4 margin-bottom--sm" >

- [recordingState](/flutter/1.0.x/api/sdk-reference/room-class/properties#recordingstate)

</div>

<div class="col col--4 margin-bottom--sm" >

- [hlsDownstreamUrl](./properties#hlsdownstreamurl)

</div>

<div class="col col--4 margin-bottom--sm" >

- [selectedMicId](./properties#selectedmicid)

</div>
<div class="col col--4 margin-bottom--sm" >

- [localParticipant](./properties#localparticipant)

</div>
<div class="col col--4 margin-bottom--sm" >

- [participants](./properties#participants)

</div>
<div class="col col--4 margin-bottom--sm" >

- [pinnedParticipants](/flutter/1.0.x/api/sdk-reference/room-class/properties#pinnedparticipants)

</div>
<div class="col col--4 margin-bottom--sm" >

- [pubSub](./properties#pubsub)

</div>

</div>

## Room Methods

<div class="row">
<div class="col col--4 margin-bottom--sm" >

- [join](./methods#join)

</div>
<div class="col col--4 margin-bottom--sm" >

- [leave](./methods#leave)

</div>
<div class="col col--4 margin-bottom--sm" >

- [enableCam](./methods#enablecam)

</div>
<div class="col col--4 margin-bottom--sm" >

- [disableCam](./methods#disablecam)

</div>
<div class="col col--4 margin-bottom--sm" >

- [unmuteMic](./methods#unmutemic)

</div>
<div class="col col--4 margin-bottom--sm" >

- [muteMic](./methods#mutemic)

</div>
<div class="col col--4 margin-bottom--sm" >

- [enableScreenShare](./methods#enablescreenshare)

</div>
<div class="col col--4 margin-bottom--sm" >

- [disableScreenShare](./methods#disablescreenshare)

</div>

<div class="col col--4 margin-bottom--sm" >

- [changeMode](./methods#changemode)

</div>
<div class="col col--4 margin-bottom--sm" >

- [startRecording](./methods#startrecording)

</div>
<div class="col col--4 margin-bottom--sm" >

- [stopRecording](./methods#stoprecording)

</div>
<div class="col col--4 margin-bottom--sm" >

- [startLivestream](./methods#startlivestream)

</div>
<div class="col col--4 margin-bottom--sm" >

- [stopLivestream](./methods#stoplivestream)

</div>
<div class="col col--4 margin-bottom--sm" >

- [getCameras](./methods#getcameras)

</div>
<div class="col col--4 margin-bottom--sm" >

- [changeCam](./methods#changecam)

</div>
<div class="col col--4 margin-bottom--sm" >

- [on](./methods#on)

</div>
</div>

## Room Events

<div class="row">

<div class="col col--4 margin-bottom--sm" >

- [roomJoined](./events#roomjoined)

</div>
<div class="col col--4 margin-bottom--sm" >

- [roomLeft](./events#roomleft)

</div>
<div class="col col--4 margin-bottom--sm" >

- [participantJoined](./events#participantjoined)

</div>
<div class="col col--4 margin-bottom--sm" >

- [participantLeft](./events#participantleft)

</div>
<div class="col col--4 margin-bottom--sm" >

- [speakerChanged](./events#speakerchanged)

</div>
<div class="col col--4 margin-bottom--sm" >

- [presenterChanged](./events#presenterchanged)

</div>
<div class="col col--4 margin-bottom--sm" >

- [participantModeChanged](./events#participantmodechanged)

</div>
<div class="col col--4 margin-bottom--sm" >

- [pinStateChanged](./events#pinstatechanged)

</div>
<div class="col col--4 margin-bottom--sm" >

- [entryRequested](./events#entryrequested)

</div>
<div class="col col--4 margin-bottom--sm" >

- [entryResponded](./events#entryresponded)

</div>
<div class="col col--4 margin-bottom--sm" >

- [cameraRequested](/flutter/1.0.x/api/sdk-reference/room-class/events#camerarequested)

</div>
<div class="col col--4 margin-bottom--sm" >

- [micRequested](./events#micrequested)

</div>
<div class="col col--4 margin-bottom--sm" >

- [recordingStarted](./events#recordingstarted)

</div>
<div class="col col--4 margin-bottom--sm" >

- [recordingStopped](./events#recordingstopped)

</div>
<div class="col col--4 margin-bottom--sm" >

- [livestreamStarted](./events#livestreamstarted)

</div>
<div class="col col--4 margin-bottom--sm" >

- [livestreamStopped](./events#livestreamstopped)

</div>

</div>

</div>


---

---
sidebar_position: 1
sidebar_label: Methods
pagination_label: Room Class Methods
title: Room Class Methods
---

import NoIndex from '../../../../../mdx/\_no-index.mdx';

<NoIndex/>

# Room Class Methods - Flutter

<div class="sdk-api-ref-only-h4">

### join()

- After creating the instance of VideoSDK Room, you can join VideoSDK Room by calling `join()` method.

#### Events associated with `join()`:

- Local Participant will receive a [`roomJoined`](events#roomjoined) event, when successfully joined.
- Remote Participant will receive a [`participantJoined`](events#participantjoined) event with the newly joined [`Participant`](../participant-class/introduction) object from the event handler.

#### Participant having `ask_join` permission inside token

- If a token contains the permission `ask_join`, then the participant will not join the room directly after calling `join()`, but an event will be emitted to the participant having the permission `allow_join` called [`entryRequested`](events#entryrequested).

- After the decision from the remote participant, an event will be emitted to participant called [`entryResponded`](events#entryresponded). This event will contain the decision made by the remote participant.

#### Participant having `allow_join` permission inside token

- If a token containing the permission `allow_join`, then the participant will join the room directly after calling `join()`.

#### Returns

- _`void`_

---

### leave()

- It is used to leave the current running room session.

#### Events associated with `leave()`:

- Local participant will receive a [`roomLeft`](events#roomleft) event.
- All remote participants will receive a [`participantLeft`](events#participantleft) event with `participantId` string from the event handler.

#### Returns

- _`void`_

---

### end()

- It is used to end the current running room session.
- By calling `end()`, all joined [participants](properties#participants) including [localParticipant](properties#localparticipant) of that session will leave the room.

#### Events associated with `end()`:

- All [participants](properties#participants) and [localParticipant](properties#localparticipant), will receive [`roomLeft`](events#roomleft) event.

#### Returns

- _`void`_

---

### enableCam()

- It is used to enable camera device.
- [`streamEnabled`](../participant-class/events#streamenabled) event will be emitted with [`stream`](../stream-class/introduction) object from the event handler, inside that [participant](../participant-class/introduction) object.

#### Returns

- _`void`_

---

### disableCam()

- It is used to disable camera device.
- [`streamDisabled`](../participant-class/events#streamdisabled) event will be emitted with [`stream`](../stream-class/introduction) object from the event handler, inside that [participant](../participant-class/introduction) object.

#### Returns

- _`void`_

---

### unmuteMic()

- It is used to enable microphone device.
- [`streamEnabled`](../participant-class/events#streamenabled) event will be emitted with [`stream`](../stream-class/introduction) object from the event handler, inside that [participant](../participant-class/introduction) object.

#### Returns

- _`void`_

---

### muteMic()

- It is used to disable microphone device.
- [`streamDisabled`](../participant-class/events#streamdisabled) event will be emitted with [`stream`](../stream-class/introduction) object from the event handler, inside that [participant](../participant-class/introduction) object.

#### Returns

- _`void`_

---

### enableScreenShare()

- it is used to enable screen-sharing.
- [`streamEnabled`](../participant-class/events#streamenabled) event will be emitted with [`stream`](../stream-class/introduction) object from the event handler, inside that [participant](../participant-class/introduction) object.
- [presenterChanged](./events#presenterchanged) will also receive a callback with the `presenterId`.

#### Returns

- _`void`_

---

### disableScreenShare()

- It is used to disable screen-sharing.
- [`streamDisabled`](../participant-class/events#streamdisabled) event will be emitted with [`stream`](../stream-class/introduction) object from the event handler, inside that [participant](../participant-class/introduction) object.
- [presenterChanged](./events#presenterchanged) will also receive a callback with the `null`.

#### Returns

- _`void`_

---

### changeMode()

- It is used to change the mode fo the participant from `SEND_AND_RECV` to `SIGNALLING_ONLY` and vice-versa.
- [`participantModeChange`](./events#participantmodechanged) event will be emitted with `participantId` and `mode` of the participant

#### Parameters

- **requestedMode**: `Mode.SEND_AND_RECV` | `Mode.SIGNALLING_ONLY`

#### Returns

- _`void`_

#### Example

```javascript
room.changeMode(Mode.SEND_AND_RECV);
```

---

### startRecording()

- It is used to start room recording.
- All [participants](properties#participants) and [localParticipant](properties#localparticipant), will receive [`recordingStarted`](events#recordingstarted) event.

- `webhookUrl` will be triggered when the recording is completed and stored into server. Read more about webhooks [here](https://en.wikipedia.org/wiki/Webhook).

#### Parameters

- **webhookUrl**: String

- **awsDirPath**: String

- **config**:
  - **layout**:
    - **type**: _"GRID"_ | _"SPOTLIGHT"_ | _"SIDEBAR"_
    - **priority**: _"SPEAKER"_ | _"PIN"_
    - **gridSize**: Number _\`max 4\`_
  - **theme**: _"DARK"_ | _"LIGHT"_ | _"DEFAULT"_
  - **mode**: _"video-and-audio"_ | _"audio"_
  - **quality**: _"low"_ | _"med"_ | _"high"_
  - **orientation**: _"landscape"_ | _"portrait"_

#### Returns

- _`void`_

#### Example

```javascript
const webhookUrl = "https://webhook.your-api-server.com";

room.startRecording(webhookUrl:webhookUrl,
 config: {
  'layout': {
    'type': 'GRID',
    'priority': 'SPEAKER',
    'gridSize': 4,
  },
  'theme': "LIGHT",
  "mode": "video-and-audio"
});
```

---

### stopRecording()

- It is used to stop room recording.
- All [participants](properties#participants) and [localParticipant](properties#localparticipant), will receive [`recordingStopped`](events#recordingstopped) event.

#### Returns

- _`void`_

#### Example

```javascript
room.stopRecording();
```

---

### startLivestream()

- It is used to start room livestreaming.
- You will be able to start livestream the room to another platforms such as Youtube, Facebook, etc. that supports [`rtmp`](https://en.wikipedia.org/wiki/Real-Time_Messaging_Protocol) streaming.
- All [participants](properties#participants) and [localParticipant](properties#localparticipant), will receive [`liveStreamStarted`](events#livestreamstarted) event.

#### Parameters

- **outputs**: `List<Map<String, String>>` \[\{ **url**: String, **streamKey**: String }]

- **config**:
  - **layout**:
    - **type**: _"GRID"_ | _"SPOTLIGHT"_ | _"SIDEBAR"_
    - **priority**: _"SPEAKER"_ | _"PIN"_
    - **gridSize**: Number _\`max 4\`_
  - **theme**: _"DARK"_ | _"LIGHT"_ | _"DEFAULT"_

#### Returns

- _`void`_

#### Example

```javascript
var outputs = [
  {
    url: "rtmp://a.rtmp.youtube.com/live2",
    streamKey: "<STREAM_KEY>",
  },
  {
    url: "rtmps://",
    streamKey: "<STREAM_KEY>",
  },
];
var liveStreamConfig =  {
  'layout': {
    'type': 'GRID',
    'priority': 'SPEAKER',
    'gridSize': 4,
  },
  'theme': "LIGHT",
};
room.startLivestream(outputs, config: livestreamConfig);
```

---

### stopLivestream()

- It is used to stop room livestreaming.
- All [participants](properties#participants) and [localParticipant](properties#localparticipant), will receive [`livestreamStopped`](events#livestreamstopped) event.

#### Returns

- _`void`_

#### Example

```javascript
room.stopLivestream();
```

---

### startHls()

- It is used to start HLS.
- All [participants](properties#participants) and [localParticipant](properties#localparticipant), will receive [`hlsStarted`](events#hlsstarted) event with the `playbackHlsUrl` and `liveStreamUrl` of the HLS feed.

#### Parameters

- **config**:
  - **layout**:
    - **type**: _"GRID"_ | _"SPOTLIGHT"_ | _"SIDEBAR"_
    - **priority**: _"SPEAKER"_ | _"PIN"_
    - **gridSize**: Number _\`max 25\`_
  - **theme**: _"DARK"_ | _"LIGHT"_ | _"DEFAULT"_
  - **mode**: _"video-and-audio"_ | _"audio"_
  - **quality**: _"low"_ | _"med"_ | _"high"_
  - **oreintation**: _"landscape"_ | _"portrait"_

#### Returns

- _`void`_

#### Example

```javascript
room.startHls(config: {
  'layout': {
    'type': 'GRID',
    'priority': 'SPEAKER',
    'gridSize': 4,
  },
  'theme': "LIGHT",
  "mode": "video-and-audio"
});
```

---

### stopHls()

- It is used to stop HLS.
- All [participants](properties#participants) and [localParticipant](properties#localparticipant), will receive [`hlsStopped`](events#hlsstopped) event.

#### Returns

- _`void`_

#### Example

```javascript
room.stopHls();
```

---

### getCameras()

- It will return all connected camera devices.

#### Returns

- List< [`MediaDeviceInfo`](https://api.flutter.dev/flutter/dart-html/MediaDeviceInfo-class.html) >

#### Example

```javascript
List<MediaDeviceInfo> cams = room.getCameras();
print(cams);
```

---

### changeCam()

- It is used to change the camera device.
- If multiple camera devices are connected, by using `changeCam()`, one can change the camera device with camera device id.
- You can get list of connected video devices using [`VideoSDK.mediaDevices`](../videosdk-class/properties#mediadevices)

#### Parameters

- **deviceId**: String

#### Returns

- _`void`_

#### Example

```javascript
room.changeCam(deviceId);
```

---

### getAudioOutputDevices()

- It will return all the available audio output devices.

#### Returns

- List< [`MediaDeviceInfo`](https://api.flutter.dev/flutter/dart-html/MediaDeviceInfo-class.html) >

#### Example

```javascript
List<MediaDeviceInfo> audioOutputDevices = room.getAudioOutputDevices();
print(audioOutputDevices);
```

---

### switchAudioDevice()

- It is used to change the audio output device.
- You can get list of connected audio output devices using [`getAudioOutputDevices`](#getaudiooutputdevices)

#### Parameters

- **device**: MediaDeviceInfo

#### Returns

- _`void`_

#### Example

```javascript
room.switchAudioDevice(device);
```

---

### on()

- It is used to listen [`Room`](introduction) related events.

#### Parameters

- event

  - type: [`Events`](events)
  - This will specify the event to be listened.

- eventHandler
  - type: [`Function`](https://api.dart.dev/stable/2.15.1/dart-core/Function-class.html)
  - This will be invoked whenever, specified event occurred.

#### Returns

- _`void`_

#### Example

```js
room.on(Events.roomJoined, () {
  // do something
});
```

</div>


---

---
sidebar_position: 1
sidebar_label: Properties
pagination_label: Room Class Properties
title: Room Class Properties
---

import NoIndex from '../../../../../mdx/\_no-index.mdx';

<NoIndex/>

# Room Class Properties - Flutter

<div class="sdk-api-ref-only-h4">

### id

- type: [`String`](https://api.dart.dev/stable/2.15.1/dart-core/String-class.html)

- Unique id of the room where the participant has joined.

---

### activeSpeakerId

- type: [`String?`](https://api.dart.dev/stable/2.15.1/dart-core/String-class.html)

- It will be the `id` of the participant who is actively speaking in the room. If no participant is speaking, at that time value of `activeSpeakerId` will be `null`.

---

### activePresenterId

- type: [`String?`](https://api.dart.dev/stable/2.15.1/dart-core/String-class.html)

- It will be the `id` of the participant who started `Presenting` / `Screen sharing` in the room. If no participant is sharing the screen, at that time value of `activePresenterId` will be `null`.

---

### camEnabled

- type: [`bool`](https://api.dart.dev/stable/2.15.1/dart-core/bool-class.html)
- It indicates if camera device is enabled or not.

---

### selectedCamId

- type: [`String?`](https://api.dart.dev/stable/2.15.1/dart-core/String-class.html)
- It will be the `id` of camera device, which is currently selected. If camera device is disabled, at that time, value of `selectedCamId` will be `null`.

---

### micEnabled

- type: [`bool`](https://api.dart.dev/stable/2.15.1/dart-core/bool-class.html)
- It indicates if microphone device is enabled or not.

---

### selectedMicId

- type: [`String?`](https://api.dart.dev/stable/2.15.1/dart-core/String-class.html)
- It will be the `id` of microphone, which is currently selected. If no microphone is selected, at that time, value of `selectedMicId` will be `null`.

---

### localParticipant

- type: [Participant](../participant-class/introduction)

- It will be the instance of [Participant](../participant-class/introduction) class for the local participant(You) who joined the room.

---

### participants

- type: [`Map`](https://api.dart.dev/stable/2.15.1/dart-core/Map-class.html) of [`String`](https://api.dart.dev/stable/2.15.1/dart-core/String-class.html) and [Participant](../participant-class/introduction)

- `Map<String, Participant>`

  - Map{'<'}`participantId`, [Participant](../participant-class/introduction)>

- It will contain all joined participants in the room except the `localParticipant`.

- This will be the [`Map`](https://api.dart.dev/stable/2.15.1/dart-core/Map-class.html) what will container all participants attached with the key as id of that participant.

```javascript
String remoteParticipantId = "ajf897";

Participant? remoteParticipant = room.participants[remoteParticipantId];
```

---

### pinnedParticipants

- type: [`Map`](https://api.dart.dev/stable/2.15.1/dart-core/Map-class.html) of [`String`](https://api.dart.dev/stable/2.15.1/dart-core/String-class.html) and `ParticipantPinState`

- `Map<String, ParticipantPinState>`

  - Map{'<'}`participantId`, `ParticipantPinState`>

- It will contain all participants who are pinned in the room.

- This will be the [`Map`](https://api.dart.dev/stable/2.15.1/dart-core/Map-class.html) which will contain all participant who are currently pinned's pin state attached with the key as id of that

---

### hlsState

- type: String

- It will return the state of HLS for the room.

---

### liveStreamState

- type: String

- It will return the state of Live stream for the room.

---

### recordingState

- type: String

- It will return the state of Recording for the room.

---

### hlsDownstreamUrl

- type: String?

- It will return the downstream URL for the ongoing HLS of the room if any.

---

### pubSub

- type: [`PubSub`](../pubsub-class/introduction)
- It is used to enable Publisher-Subscriber feature in [`room`](introduction) class.

Learn more about `PubSub`, [here](../pubsub-class/introduction)

</div>


---

---
title: Installation Steps for RTC Flutter SDK
hide_title: false
hide_table_of_contents: false
description: RTC Flutter SDK provides client for almost all Android and IOS devices. it takes less amount of cpu and memory.
sidebar_label: Setup
pagination_label: Setup
keywords:
  - RTC FLUTTER
  - FLUTTER SDK
  - DART SDK
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: setup
---

import NoIndex from '../../../../mdx/\_no-index.mdx';

<NoIndex/>

# Setup - Flutter

Flutter SDK is client for real-time communication for android and ios devices. It inherits the same terminology as all other SDKs does.

## Minimum OS/SDK versions

Android: minSdkVersion >= 23

<!-- ### IOS: > 11 -->

## Use this package as a library

### Step 1: Add this package in your flutter project

Run this command:

```js
flutter pub add videosdk
```

This will add a line like this to your package's pubspec.yaml (and run an implicit flutter pub get):

```js
dependencies:
  videosdk: ^1.0.0
```

Alternatively, your editor might support or flutter pub get. Check the docs for your editor to learn more.

### Step 2: Import it

Now in your Dart code, you can use:

```js
import "package:videosdk/videosdk.dart";
```


---

---
title: Video SDK Stream Class
sidebar_position: 1
sidebar_label: Introduction
pagination_label: Video SDK Stream Class
---

import NoIndex from '../../../../../mdx/\_no-index.mdx';

<NoIndex/>

# Video SDK Stream Class - Flutter

<div class="sdk-api-ref">

## Introduction

Stream class is responsible for handling audio, video and screen sharing streams.

Stream class defines instance of audio, video and shared screen stream of participants.

## Stream Properties

<div class="row">
<div class="col col--4 margin-bottom--sm" >

- [id](properties#id)

</div><div class="col col--4 margin-bottom--sm" >

- [kind](properties#kind)

</div><div class="col col--4 margin-bottom--sm" >

- [track](properties#track)

</div><div class="col col--4 margin-bottom--sm" >

- [renderer](properties#renderer)

</div>
</div>
</div>


---

---
title: Stream Class Properties
sidebar_position: 1
sidebar_label: Properties
pagination_label: Stream Class Properties
---

import NoIndex from '../../../../../mdx/\_no-index.mdx';

<NoIndex/>

# Stream Class Properties - Flutter

<div class="sdk-api-ref-only-h4">

### id

- type: `String`

- Represents the id for that stream .

---

### kind

- type: `String?`

- `kind` represents the type of stream which could be `audio` | `video` or `share` .

---

### renderer

- type: `RTCVideoRenderer?`

- This is a renderer, which is passed to RTCVideoView widget.

---

### track

- type: `Consumer`

- It represents a single media track within a stream.

- You can call `pause()` method to pause MediaStreamTrack. And you can also call `resume()` method to resume MediaStreamTrack. [Learn more](../../../guide/video-and-audio-calling-api-sdk/features/pause-resume-video-stream)

</div>


---

---
title: Terminology - Video SDK Documentation
hide_title: true
hide_table_of_contents: false
description: Video SDK enables the opportunity to integrate native IOS, Android & Web SDKs to add live video & audio conferencing to your applications.
sidebar_label: Terminology
pagination_label: Terminology
keywords:
  - audio calling
  - video calling
  - real-time communication
  - collaboration
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: terminology
---

import Terminology from '../../../../mdx/introduction/\_terminology.mdx';
import NoIndex from '../../../../mdx/\_no-index.mdx';

<NoIndex/>

<Terminology title="Terms related to VideoSDK - Flutter" />


---

---
sidebar_position: 2
sidebar_label: Introduction
pagination_label: VideoSDK Class
title: VideoSDK Class
---

import NoIndex from '../../../../../mdx/\_no-index.mdx';

<NoIndex/>

# VideoSDK Class - Flutter

<div div id="tailwind" class="sdk-api-ref">

## Introduction

VideoSDK Class is a core class of SDK that provides methods to create and configure [`VideoSDK Room`](../room-class/introduction).

import LinksGrid from '../../../../../src/theme/LinksGrid'

## VideoSDK Class Properties

<div class="row">

<div class="col col--4 margin-bottom--sm" >

- [mediaDevices](./properties#mediadevices)

</div>

</div>

## VideoSDK Class Methods

<div class="row">

<div class="col col--4 margin-bottom--sm" >

- [createRoom](./methods#createroom)

</div>

<div class="col col--4 margin-bottom--sm" >

- [loadMediaDevices](./methods#loadmediadevices)

</div>

</div>
</div>


---

---
sidebar_position: 1
sidebar_label: Methods
pagination_label: VideoSDK Class Methods
title: VideoSDK Class Methods
---

import NoIndex from '../../../../../mdx/\_no-index.mdx';

<NoIndex/>

# VideoSDK Class Methods - Flutter

<div class="sdk-api-ref-only-h4">

### createRoom()

- This method is provided by SDK to build instance of [`VideoSDK Room`](../room-class/introduction) based on given configuration.

#### Parameters

- roomId

  - type: [`String`](https://api.dart.dev/stable/2.15.1/dart-core/String-class.html)
  - `REQUIRED`
  - Id of the Room to be created.

- token

  - type: [`String`](https://api.dart.dev/stable/2.15.1/dart-core/String-class.html)
  - `REQUIRED`
  - Sets AuthToken, which is used for authentication purposes.

- displayName

  - type: [`String`](https://api.dart.dev/stable/2.15.1/dart-core/String-class.html)
  - `REQUIRED`
  - Sets name of the LocalParticipant to be displayed.

- notification

  - type: [`NotificationInfo`]
  - `OPTIONAL`
  - Sets configuration for the notification, that will be shown, while screen-sharing.

- micEnabled

  - type: [`bool`](https://api.dart.dev/stable/2.15.1/dart-core/bool-class.html)
  - `OPTIONAL`
  - Whether `mic` of the participant will be `on`, while joining the room. If it is set to `false`, then mic of that participant will be `disabled` by default, but can be `enabled` or `disabled` later.
  - Default value of `micEnabled` is true.

- camEnabled

  - type: [`bool`](https://api.dart.dev/stable/2.15.1/dart-core/bool-class.html)
  - `OPTIONAL`
  - Whether `camera` of the participant will be `on`, while joining the room. If it is set to `false`, then camera of that participant will be `disabled` by default, but can be `enabled` or `disabled`
  - Default value of `camEnabled` is true.

- multiStream

  - type: [`bool`](https://api.dart.dev/stable/2.15.1/dart-core/bool-class.html)
  - `OPTIONAL`
  - Default value is `true`.
  - It will specify if the stream should send multiple resolution layers or single resolution.

- participantId

  - type: [`String`](https://api.dart.dev/stable/2.15.1/dart-core/String-class.html)
  - `OPTIONAL`
  - Unique Id of the participant. If not passed then SDK will create an Id by itself and will use that id.

- maxResolution

  - type: [`String`](https://api.dart.dev/stable/2.15.1/dart-core/String-class.html)
  - `OPTIONAL`
  - Sets the maximum upload resolution of that participant's camera video stream.

- defaultCameraIndex

  - type: [`int`](https://api.dart.dev/stable/2.15.1/dart-core/int-class.html)
  - `OPTIONAL`
  - Sets camera, which will be used by default, while joining the VideoSDK Room. Index of [`MediaDevices`](properties#mediadevices) will be used to set default camera. You can also change camera later.
  - Default value of `defaultCameraIndex` is `0`.

- customCameraVideoTrack

  - type: `CustomTrack`
  - `OPTIONAL`
  - Set the initial custom video track using different encoding parameters, camera facing mode, and optimization mode.

- customMicrophoneAudioTrack

  - type: `CustomTrack`
  - `OPTIONAL`
  - Set the initial custom audio track using different encoding parameters and optimization mode.

- mode

  - type: `Mode`
  - `OPTIONAL`
  - Set the participant mode i.e. `SEND_AND_RECV` or `SIGNALLING_ONLY`.
  - Default value is `SEND_AND_RECV`.

---

#### Returns

- _[`Room`](../room-class/introduction)_

#### Example

```js

CustomTrack videoTrack = await VideoSDK.createCameraVideoTrack(
  encoderConfig: CustomVideoTrackConfig.h1440p_w1920p,
  multiStream: false,
);

//Creating Custom Audio Track
CustomTrack audioTrack = await VideoSDK.createMicrophoneAudioTrack(
    encoderConfig: CustomAudioTrackConfig.high_quality);

// Create VideoSDK Room
Room room = VideoSDK.createRoom(
  roomId: "<ROOM-ID>",
  token: "<TOKEN>",
  displayName: "<DISPLAY-NAME>",
  micEnabled: false,
  camEnabled: false,
  maxResolution: 'hd',
  multiStream: false,
  defaultCameraIndex: 1, // Front Camera
  customCameraVideoTrack: videoTrack, // custom video track :: optional
  customMicrophoneAudioTrack: audioTrack, // custom audio track :: optional
  notification: const NotificationInfo(
    title: "Video SDK",
    message: "Video SDK is sharing screen in the room",
    icon: "notification_share",
  ),
);
```

---

### loadMediaDevices()

- This method is used to load or refresh MediaDevices i.e. Audio Devices and Video Devices.

#### Returns

- _`Future<Map<MediaDeviceType, List<MediaDeviceInfo>>>`_

#### Example

```js
Map<MediaDeviceType, List<MediaDeviceInfo>> mediaDevices = await VideoSDK.loadMediaDevices();
```

---

### createCameraVideoTrack

- You can create a Video Track using `createCameraVideoTrack()` method of `VideoSDK` class.
- This method can be used to create video track using different encoding parameters, camera facing mode, and optimization mode.

#### Parameters

- **cameraId**:

  - type: `String`
  - required: `false`
  - It will be the id of the camera from which the video should be captured.

- **encoderConfig**:

  - type: `CustomVideoTrackConfig`
  - required: `false`
  - default: `h360p_w640p`
  - Allowed values : `h90p_w160p` | `h180p_w320p` | `h216p_w384p` | `h360p_w640p` | `h540p_w960p` | `h720p_w1280p` | `h1080p_w1920p` | `h1440p_w2560p` | `h2160p_w3840p` | `h120p_w160p` | `h180p_w240p` | `h240p_w320p` | `h360p_w480p` | `h480p_w640p` | `h540p_w720p` | `h720p_w960p` | `h1080p_w1440p` | `h1440p_w1920p`
  - It will be the encoderConfigs you can want to use for the Video Track.

:::note

Above mentioned encoder configurations are valid for both, landscape as well as portrait mode.

:::

- **facingMode**:

  - type: `String`
  - required: `false`
  - Allowed values : `user` | `environment`
  - It will specify whether to use front or back camera for the video track.

- **multiStream**

  - type: `boolean`
  - required: `false`
  - default: true
  - It will specify if the stream should send multiple resolution layers or single resolution layer.

  :::info

  - For meetings with fewer than or equal to four participants, setting `multiStream:false` is regarded as best practice.
  - This parameter is only available from `v1.0.9`.

  :::

#### Returns

- `Future<CustomTrack>`

#### Example

```javascript
CustomTrack videoTrack = await VideoSDK.createCameraVideoTrack(
      encoderConfig: CustomVideoTrackConfig.h1440p_w1920p,
      multiStream: false,
      facingMode:"user",
    );
```

---

### createMicrophoneAudioTrack

- You can create a Audio Track using `createMicrophoneAudioTrack()` method of `VideoSDK` class.
- This method can be used to create audio track using different encoding parameters and noise cancellation configuration.

#### Parameters

- **microphoneId**:

  - type: `String`
  - required: `false`
  - It will be the id of the mic from which the audio should be captured.

- **encoderConfig**:

  - type: `CustomTrackAudioConfig`
  - required: `false`
  - default: `speech_standard`
  - Allowed values : `speech_low_quality` | `speech_standard` | `music_standard` | `standard_stereo` | `high_quality` | `high_quality_stereo`
  - It will be the encoder configuration you want to use for Audio Track.

- **noiseConfig**

  - **echoCancellation**

    - type: `boolean`
    - required: `false`
    - If `true` echo cancellation will turned on else it would be turned off.

  - **autoGainControl**

    - type: `boolean`
    - required: `false`
    - If `true` auto gain will turned on else it would be turned off.

  - **noiseSuppression**
    - type: `boolean`
    - required: `false`
    - If `true` noise suppression will turned on else it would be turned off.

#### Returns

- `Future<CustomTrack>`

#### Example

```javascript
CustomTrack audioTrack = await VideoSDK.createMicrophoneAudioTrack(
        encoderConfig: CustomAudioTrackConfig.high_quality);
```

</div>


---

---
sidebar_position: 1
sidebar_label: Properties
pagination_label: VideoSDK Class Properties
title: VideoSDK Class Properties
---

import NoIndex from '../../../../../mdx/\_no-index.mdx';

<NoIndex/>

# VideoSDK Class Properties - Flutter

<div class="sdk-api-ref-only-h4">

### mediaDevices

- type: [`Map<MediaDeviceType, List<MediaDeviceInfo>>`](https://api.dart.dev/stable/2.15.1/dart-core/Map-class.html)

- It contains all the connected media devices i.e. Video Devices, Audio Devices.

- This will be the [`Map`](https://api.dart.dev/stable/2.15.1/dart-core/Map-class.html) of `MediaDeviceType` and [`List<MediaDeviceInfo>`](https://api.flutter.dev/flutter/dart-html/MediaDeviceInfo-class.html).

```javascript
// Audio Devices
List<MediaDeviceInfo> audioDevices = VideoSDK.mediaDevices[MediaDeviceType.audioInput];

// Video Devices
List<MediaDeviceInfo> videoDevices = VideoSDK.mediaDevices[MediaDeviceType.videoInput];
```

---

</div>


---

---
title: Display Attendees Count - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: Interactive Livestream features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Display Attendees Count
pagination_label: Display Attendees Count
keywords:
  - Start HLS meeting
  - Stop HLS meeting
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: display-attendees-count
---

import NoIndex from '../../../../../mdx/\_no-index.mdx';

<NoIndex/>

# Display Attendees Count - Flutter

In this guide, we will see how you can display the number of attendees in realtime.

:::note
Before going forward in this guide, do make sure all the attendees join the meeting with mode as `SIGNALLING_ONLY`
:::

**`Step 1:`** We will get the `participants` from the `Room` object. and filter the `SIGNALLING_ONLY` participants from it. We will also added the `participantJoined`, `participantLeft` and `participantModeChanged` listerners to keep the list of attendees updated.

```js
import 'package:flutter/material.dart';
import 'package:videosdk/videosdk.dart';

class ViewerScreen extends StatefulWidget {
  ...
}

class _ViewerScreenState extends State<ViewerScreen> {
  late Room room;

  Map<String, Participant> _attendees = {};

  @override
  void initState() {
    //highlight-next-line
    ...

    updateAttendees();

    setupRoomEventListener();
  }

  @override
  Widget build(BuildContext context) {
    return YourMeetingWidget();
  }

  //highlight-start
  void updateAttendees(){
    Map<String, Participant> attendees = {};
    if(room.localParticipant.mode == Mode.SIGNALLING_ONLY);
    attendees.putIfAbsent(
        room.localParticipant.id, () => room.localParticipant);
    room.participants.values.forEach((participant) {
      if (participant.mode == Mode.SIGNALLING_ONLY) {
        attendees.putIfAbsent(participant.id, () => participant);
      }
    });
    setState(()=>_attendees = attendees);
  }
  //highlight-end

  void setupRoomEventListener() {
    room.on(Events.roomJoined, () {
      //highlight-start
      updateAttendees();
      //highlight-end
    });

    room.on(Events.participantModeChanged, (Map<String, dynamic> data){
      //highlight-start
      updateAttendees()
      //highlight-end
    });

    room.on(Events.participantJoined, (Participant participant) {
      //highlight-start
      updateAttendees();
      //highlight-end
    });


    room.on(Events.participantLeft, (String participantId) {
      //highlight-start
      updateAttendees();
      //highlight-end
    });
  }
}
```

**`Step 2:`** With all the participants, we will filter out participants who have joined as a `SIGNALLING_ONLY` and then display that count.

```js
import 'package:flutter/material.dart';
import 'package:videosdk/videosdk.dart';

class ViewerScreen extends StatefulWidget {
  ...
}

class _ViewerScreenState extends State<ViewerScreen> {
  late Room room;

  Map<String, Participant> attendees = {};

  @override
  void initState() {
    //highlight-next-line
    ...

    attendees.putIfAbsent(
        room.localParticipant.id, () => room.localParticipant);
    room.participants.values.forEach((participant) {
      if (participant.mode == Mode.SIGNALLING_ONLY) {
        attendees.putIfAbsent(participant.id, () => participant);
      }
    });

    setupRoomEventListener();
  }

  //higlight-start
  @override
  Widget build(BuildContext context) {
    return Text("Total attendees :: ${attendees.length}");
  }
  //higlight-end

  void setupRoomEventListener() {
    //highlight-next-line
    ...
  }
}
```

## API Reference

The API references for all the methods utilized in this guide are provided below.

- [participants](/flutter/api/sdk-reference/room-class/properties#participants)


---

---
title: Invite Guest on Stage - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: Interactive Livestream features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Invite Guest on Stage
pagination_label: Invite Guest on Stage
keywords:
  - Start HLS meeting
  - Stop HLS meeting
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: invite-guest-on-stage
---

import NoIndex from '../../../../../mdx/\_no-index.mdx';

<NoIndex/>

# Invite Guest on Stage - Flutter

In this guide, we will see how you can request a viewer to join your livestream by using the `changeMode()`.

:::note
Before going forward in this guide, do make sure all the attendees join the meeting with mode as `SIGNALLING_ONLY` and the host joins with mode as `SEND_AND_RECV`
:::

Let's first have a look at how we will be using the `PubSub` mechanism to acheive the requesting and switching of the participant's mode.

![invite-guest-pubsub](https://cdn.videosdk.live/website-resources/docs-resources/invite_guest_pubsub.png)

### Step 1: Loading Viewer List

The host will see a list of participants who have joined as `SIGNALLING_ONLY` along with a button that, when selected, will invite that user to join the livestream.

```js
import 'package:flutter/material.dart';
import 'package:videosdk/videosdk.dart';

class SpeakerScreen extends StatefulWidget {
  ...
}

class _SpeakerScreenState extends State<SpeakerScreen> {
  late Room room;

  Map<String, Participant> _attendees = {};

  @override
  void initState() {
    //highlight-next-line
    ...

    updateAttendees();

    setupRoomEventListener();
  }

  @override
  Widget build(BuildContext context) {
    return Column(
      children:[
        //highlight-start
        //button which will show viewers list
        ElevatedButton(
            onPressed: () {
              showDialog(
                  context: context,
                  builder: (context) => AlertDialog(
                        content: ListView.builder(
                            itemCount: viewers.values.length,
                            itemBuilder: (builderContext, index) {
                              return Padding(
                                padding: const EdgeInsets.all(8.0),
                                child: Row(
                                  children: [
                                    Expanded(
                                        child: Text(viewers.values
                                            .elementAt(index)
                                            .displayName)),
                                    ElevatedButton(
                                        onPressed: () {

                                        },
                                        child: Text("Invite on Stage")),
                                  ],
                                ),
                              );
                            }),
                      ));
            },
            child: const Text("Invite Viewer on Stage"),
          ),
        //highlight-end
        ...
      ]
    );
  }

  //highlight-start
  void updateAttendees(){
    Map<String, Participant> attendees = {};
    if(room.localParticipant.mode == Mode.SIGNALLING_ONLY);
    attendees.putIfAbsent(
        room.localParticipant.id, () => room.localParticipant);
    room.participants.values.forEach((participant) {
      if (participant.mode == Mode.SIGNALLING_ONLY) {
        attendees.putIfAbsent(participant.id, () => participant);
      }
    });
    setState(()=>_attendees = attendees);
  }
  //highlight-end

  void setupRoomEventListener() {
    room.on(Events.roomJoined, () {
      //highlight-start
      updateAttendees();
      //highlight-end
    });

    room.on(Events.participantModeChanged, (Map<String, dynamic> data){
      //highlight-start
      updateAttendees()
      //highlight-end
    });

    room.on(Events.participantJoined, (Participant participant) {
      //highlight-start
      updateAttendees();
      //highlight-end
    });


    room.on(Events.participantLeft, (String participantId) {
      //highlight-start
      updateAttendees();
      //highlight-end
    });
  }
}
```

<img src="https://cdn.videosdk.live/website-resources/docs-resources/flutter_invite_guest_viewer_list.png" width="350" />

### Step 2: Requesting a Viewer to Join Livestream

We have a Viewer list ready. Now, let us handle the click event for the Join Livestream button.

We will be using `CHANGE_MODE_$participantId` as the topic for PubSub.

```js
import 'package:flutter/material.dart';
import 'package:videosdk/videosdk.dart';

class SpeakerScreen extends StatefulWidget {
  ...
}

class _SpeakerScreenState extends State<SpeakerScreen> {
  late Room room;

  Map<String, Participant> _attendees = {};

  @override
  void initState() {
    //highlight-next-line
    ...
  }

  @override
  Widget build(BuildContext context) {
    return Column(
      children:[
        ElevatedButton(
          onPressed: () {
            showDialog(
              context: context,
              builder: (context) => AlertDialog(
                  content: ListView.builder(
                      itemCount: viewers.values.length,
                      itemBuilder: (builderContext, index) {
                        return Padding(
                          padding: const EdgeInsets.all(8.0),
                          child: Row(
                            children: [
                              Expanded(
                                  child: Text(viewers.values
                                      .elementAt(index)
                                      .displayName)),
                              ElevatedButton(
                                  onPressed: () {
                                  //highlight-start
                                  //Publish the message on CHANGE_MODE_$participantId to join
                                  widget.room.pubSub.publish(
                                        "CHANGE_MODE_${viewers.values.elementAt(index).id}",
                                        "SIGNALLING_ONLY");
                                  //highlight-end
                                  },
                                  child: Text("Invite on Stage")),
                            ],
                          ),
                        );
                      }),
                  ));
          },
          child: const Text("Invite Viewer on Stage"),
        ),
        ...
      ]
    );
  }

  void updateAttendees(){
    //highlight-next-line
    ...
  }

  void setupRoomEventListener() {
  //highlight-next-line
    ...
  }
}
```

### Step 3: Showing Viewer Request Dialog

After implementing the Host requesting viewer to join the livestream, let's display the viewer's request dialogue and switch the `SIGNALLING_ONLY` mode to `SEND_AND_RECV`.

```js
import 'package:flutter/material.dart';
import 'package:flutter/services.dart';
import 'package:videosdk/videosdk.dart';
import './livestream_player.dart';

class ILSViewerView extends StatefulWidget {
  final Room room;
  //highlight-next-line
  ...
}

class _ILSViewerViewState extends State<ILSViewerView> {

  @override
  void initState() {
    super.initState();

    //highlight-start
    //subscribe to the change mode reequest topic
    widget.room.pubSub.subscribe(
        "CHANGE_MODE_${widget.room.localParticipant.id}",
        changeModeRequestHandler);
        //highlight-end
  }

  //highlight-start
  //show dialog to accept or reject when change mode requested by speaker
  void changeModeRequestHandler(PubSubMessage message) {
    if (mounted) {
      showDialog(
          context: this.context,
          builder: (context) {
            return AlertDialog(
              actions: [
                ElevatedButton(
                  onPressed: () {
                    widget.room.changeMode(Mode.SEND_AND_RECV);
                    Navigator.of(context).pop();
                  },
                  child: const Text("Accept"),
                ),
                ElevatedButton(
                  onPressed: () {
                    Navigator.of(context).pop();
                  },
                  child: const Text("Reject"),
                )
              ],
              content:
                  Text("${message.senderName} requestd you to join livestream"),
            );
          });
    }
  }
  //highlight-end

  @override
  Widget build(BuildContext context) {
    return YourViewerWidget;
  }

  //highlight-start
  @override
  void dispose() {
    widget.room.pubSub.unsubscribe(
        "CHANGE_MODE_${widget.room.localParticipant.id}",
        changeModeRequestHandler);
    super.dispose();
  }
  //highlight-start
}

```

<img src="https://cdn.videosdk.live/website-resources/docs-resources/flutter_invite_guest_join_request.png" width="350" />

### Step 4: Pin the participant

We need to pin the participant so that he/she can appears on the livestream. To achieve this, we will listen to the callback on the `participantModeChanged` of `Room` object. Here, we are already calling the `updateAttendees()` which we will update to pin only the `SEND_AND_RECV` mode participants.

```js
import 'package:flutter/material.dart';
import 'package:videosdk/videosdk.dart';

class SpeakerScreen extends StatefulWidget {
  ...
}

class _SpeakerScreenState extends State<SpeakerScreen> {
  late Room room;

  Map<String, Participant> _attendees = {};

  @override
  void initState() {
    //highlight-next-line
    ...
  }

  @override
  Widget build(BuildContext context) {
    return Column(
      children:[
        //highlight-next-line
        ...
      ]
    );
  }

  void updateAttendees(){
    Map<String, Participant> attendees = {};
    //highlight-start
    //we will pin localparticiant if mode is SEND_AND_RECV
    if(room.localParticipant.mode == Mode.SIGNALLING_ONLY);{
      attendees.putIfAbsent(
          room.localParticipant.id, () => room.localParticipant);
      room.localParticipant.unpin();
    }else{
      room.localParticipant.pin();
    }
      //highlight-end
    room.participants.values.forEach((participant) {
      if (participant.mode == Mode.SIGNALLING_ONLY) {
        attendees.putIfAbsent(participant.id, () => participant);
        //highlight-next-line
        participant.unpin();
      }
    });
    setState(()=>_attendees = attendees);
  }

}
```

import ReactPlayer from 'react-player'

<div style={{textAlign: 'center'}}>

<ReactPlayer autoplay muted loop playing controls url="https://cdn.videosdk.live/website-resources/docs-resources/flutter_invite_guest_video.mp4" height="500px" width={"100%"} />

</div>

## API Reference

The API references for all the methods utilized in this guide are provided below.

- [Room](/flutter/api/sdk-reference/room-class/introduction)
- [PubSub](/flutter/api/sdk-reference/pubsub-class/introduction)
- [changeMode](/flutter/api/sdk-reference/room-class/methods#changemode)


---

---
title: Manage On-Screen Participants - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: Interactive Livestream features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Manage On-Screen Participants
pagination_label: Manage On-Screen Participants
keywords:
  - Start HLS meeting
  - Stop HLS meeting
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: manage-on-screen-participants
---

import NoIndex from '../../../../../mdx/\_no-index.mdx';

<NoIndex/>

# Manage On-Screen Participants - Flutter

It is important that only the necessary person are present on the screen when livestream is on. To handle this, we will be using the `pin` and `unpin` methods of the `Participant` object.

:::note
To ensure only the hosts/speakers are shown in the grid, you should use the `SPOTLIGHT` layout and `pin` as the priority when starting the interactive livestream.
:::

Let us first explore two methods that we will be using to manage on-screen participats.

### `pin()`

With these method you can pin any participant's Camera, Screen Share or both. This can be useful to identify the participants based on which you can perform rendering participant grid.

### `unpin()`

With these methods you can unpin any participant's Camera, Screen Share or both. This can be useful to reset pin state of the participant.

### Managing On-Screen Participants

1. If you want to pin all the hosts/speakers automatically, you can do it by listenting to the `Events.roomJoined` callback and `Events.participantModeChanged`, where you can `pin` and `unpin` based on the mode.

```js
import 'package:flutter/material.dart';
import 'package:videosdk/videosdk.dart';

class MeetingScreen extends StatefulWidget {
  ...
}

class _MeetingScreenState extends State<MeetingScreen> {
  late Room room;

  @override
  void initState() {
    //highlight-next-line
    ...

    setupRoomEventListener();
  }

  @override
  Widget build(BuildContext context) {
    return YourMeetingWidget();
  }

  //highlight-start
  void setupRoomEventListener() {
    room.on(Events.roomJoined, () {
      //highlight-start
      //We will pin the participant if mode is conference
      if(room.localParticipant.mode == Mode.SEND_AND_RECV){
        room.localParticipant.pin();
      }
      //highlight-end
    });

    room.on(Events.participantModeChanged, (Map<String, dynamic> data){
      //highlight-start
      //We will pin the participant if mode is conference else unpin him
      if (data['participantId'] == room.localParticipant.id) {
        if (room.localParticipant.mode == Constants.modes.SEND_AND_RECV) {
          room.localParticipant.pin();
        } else {
          room.localParticipant.unpin();
        }
      }
      //highlight-end
    });
  }
  //highlight-end
}
```

2. When rendering the participant grid on the Speaker side, make sure to show only the participants who are in `SEND_AND_RECV` mode. You can filter the participants as shown in below examples.

```js
import 'package:flutter/material.dart';
import 'package:videosdk/videosdk.dart';

class MeetingScreen extends StatefulWidget {
  ...
}

class _MeetingScreenState extends State<MeetingScreen> {
  late Room room;

  Map<String, Participant> _speakers = {};

  @override
  void initState() {
    //highlight-next-line
    ...

    updateSpekers();

    setupRoomEventListener();
  }

  @override
  Widget build(BuildContext context) {
    return YourMeetingWidget();
  }

  //highlight-start
  void updateSpeakers(){
    Map<String, Participant> speakers = {};
    if(room.localParticipant.mode == Mode.SEND_AND_RECV);
    speakers.putIfAbsent(
        room.localParticipant.id, () => room.localParticipant);
    room.participants.values.forEach((participant) {
      if (participant.mode == Mode.SEND_AND_RECV) {
        speakers.putIfAbsent(participant.id, () => participant);
      }
    });
    setState(()=>_speakers = speakers);
  }
  //highlight-end

  void setupRoomEventListener() {
    room.on(Events.roomJoined, () {
      //highlight-start
      updateSpeakers();
      //highlight-end
    });

    room.on(Events.participantModeChanged, (Map<String, dynamic> data){
      //highlight-start
      updateSpeakers()
      //highlight-end
    });

    room.on(Events.participantJoined, (Participant participant) {
      //highlight-start
      updateSpeakers();
      //highlight-end
    });


    room.on(Events.participantLeft, (String participantId) {
      //highlight-start
      updateSpeakers();
      //highlight-end
    });
  }
}
```

## API Reference

The API references for all the methods utilized in this guide are provided below.

- [pin](/flutter/api/sdk-reference/participant-class/methods#pin)
- [unpin](/flutter/api/sdk-reference/participant-class/methods#unpin)
- [participants](/flutter/api/sdk-reference/room-class/properties#participants)


---

---
title: Manage Roles - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: Interactive Livestream features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Manage Roles
pagination_label: Manage Roles
keywords:
  - Start HLS meeting
  - Stop HLS meeting
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: manage-roles
---

import NoIndex from '../../../../../mdx/\_no-index.mdx';

<NoIndex/>

# Manage Roles - Flutter

## Roles with VideoSDK

When doing interactive live streaming maintaining the role of users is quite important. To help manage these roles better, VideoSDK allows a participant with two types of modes:

**`1. SEND_AND_RECV`** When a participant is joining with mode set to `SEND_AND_RECV`, we will be able to **publish and consume the media** of other participants and also interact with them using the features like chat, poll etc.

**`2. SIGNALLING_ONLY`** When a participant is joining with mode set to `SIGNALLING_ONLY`, that participant is **not allowed to publish or consume any media** from other participants. Although they can interact with other participants using chat, polls etc.

![manage-roles](https://cdn.videosdk.live/website-resources/docs-resources/meeting_modes.jpg)

## When to use the Roles?

##### 1. Simple Adaptive Streaming

- Simple Adaptive Streaming (SAS) is a type of livestreaming that requires minimal interaction between the host and viewers.

- It is particularly useful for events with a large number of viewers who prefer not to engage with the host.

- In SAS, each speaker attends a VideoSDK meeting in `SEND_AND_RECV` mode, while viewers can simply watch the livestream using the `playbackHlsUrl` or `livestreamUrl`. Unlike the speakers, viewers do not need to join the meeting in `SEND_AND_RECV` or `SIGNALLING_ONLY` mode. This allows for a seamless streaming experience without any unnecessary interruptions or distractions.
  - `playbackHlsUrl` - Live HLS with playback support
  - `livestreamUrl` - Live HLS without playback support

:::note
`downstreamUrl` is now depecated. Use `playbackHlsUrl` or `livestreamUrl` in place of `downstreamUrl`
:::

import ReactPlayer from 'react-player'

<div style={{textAlign: 'center'}}>

<ReactPlayer autoplay muted loop playing controls url="https://cdn.videosdk.live/website-resources/docs-resources/react_simple_ils.mp4" height="500px" width={"100%"} />

</div>

##### 2. Adaptive Streaming with increased engagement

- If you're looking to increase engagement with your audience during a live streaming event, consider using Adaptive Streaming technology. With this approach, you can incorporate interactive features such as polls and conversations, and give viewers the ability to join and leave the livestream as the host decides.

- To set this up, have all speakers join as `SEND_AND_RECV` mode participants, while the audience joins as `SIGNALLING_ONLY` mode participants. This way, everyone can participate in the interactive elements of the live stream and create a more dynamic and engaging experience for all.

<div style={{textAlign: 'center'}}>

<ReactPlayer autoplay muted loop playing controls url="https://cdn.videosdk.live/website-resources/docs-resources/react_livestream_interaction_1.mp4" height="500px" width={"100%"} />

</div>

## Using roles

The mode of the participants is set during the creating the room.

```js
import 'package:flutter/material.dart';
import 'package:videosdk/videosdk.dart';

class MeetingScreen extends StatefulWidget {
  final String meetingId;
  final String token;

  const MeetingScreen(
      {super.key, required this.meetingId, required this.token});

  @override
  State<MeetingScreen> createState() => _MeetingScreenState();
}

class _MeetingScreenState extends State<MeetingScreen> {
  late Room _room;

  Mode? localParticipantMode;

  @override
  void initState() {
    //Creating a new Room based on the passed meetingId and token from the Joining Screen
    // create room
    _room = VideoSDK.createRoom(
      roomId: widget.meetingId,
      token: widget.token,
      displayName: "John Doe",
      micEnabled: true,
      camEnabled: true,
      defaultCameraIndex:
          1, // Index of MediaDevices will be used to set default camera
      //highlight-next-line
      mode: Mode.SEND_AND_RECV, // or Mode.SIGNALLING_ONLY
    );

    _room.join();

    setRoomEventListener();

    super.initState();
  }

  @override
  Widget build(BuildContext context) {
    return  SafeArea(
      child: Scaffold(
        backgroundColor: Colors.black,
        //highlight-start
        //Show Speaker view if mode is Conference else show Viewer View
        body: localParticipantMode != null
            ? localParticipantMode == Mode.SEND_AND_RECV
                ? ILSSpeakerView(room: _room)
                : localParticipantMode == Mode.SIGNALLING_ONLY
                    ? ILSViewerView(room: _room)
                    : null
            : const Center(
                child: Text("Joining...")),
                //highlight-end
      ),
    );
  }

  void setRoomEventListener(){
    _room.on(Events.roomJoined, (){
      setState(()=>localParticipantMode = _room.localParticipant.mode);
    });

    _room.on(Events.participantModeChanged, (Map<String, dynamic> data){
      if(data['participantId']){
        setState(()=>localParticipantMode = _room.localParticipant.mode);
      }
    });
  }
}
```

## Getting Participant Mode

You can identify the participants role by using `mode` property from `Participant` object.

```js
import 'package:flutter/material.dart';
import 'package:videosdk/videosdk.dart';

class ParticipantTile extends StatefulWidget {
  final Participant participant;
  const ParticipantTile({super.key, required this.participant});

  @override
  State<ParticipantTile> createState() => _ParticipantTileState();
}

class _ParticipantTileState extends State<ParticipantTile> {

  @override
  Widget build(BuildContext context) {
    //highlight-next-line
    return Text("${widget.participant.displayName} is in ${widget.participant.mode.name}");
  }
}
```

## Changing Participant's Mode

Let's say you are hosting a livestream and you want one of your viewer to join the livestream with you. In this case you can change the mode of the participant using the `changeMode()` of the `Room` object.

```js
import 'package:flutter/material.dart';
import 'package:videosdk/videosdk.dart';

class MeetingScreen extends StatefulWidget {
  ...
}

class _MeetingScreenState extends State<MeetingScreen> {
  late Room _room;

  @override
  void initState() {
    //highlight-next-line
    ...
  }

  @override
  Widget build(BuildContext context) {
    return Column(
      children:[
        ElevatedButton(
          onPressed:(){
            //highlight-next-line
            _room.changeMode(Mode.SIGNALLING_ONLY);
          },
          child: const Text("Change Mode to Viewer"),
        ),
        ElevatedButton(
          onPressed:(){
            //highlight-next-line
            _room.changeMode(Mode.SEND_AND_RECV);
          },
          child: const Text("Change Mode to Speaker"),
        ),
      ]
    );
  }
}
```

## API Reference

The API references for all the methods utilized in this guide are provided below.

- [createRoom](/flutter/api/sdk-reference/videosdk-class/methods#createroom)
- [Room](/flutter/api/sdk-reference/room-class/introduction)
- [Participant](/flutter/api/sdk-reference/participant-class/introduction)
- [changeMode](/flutter/api/sdk-reference/room-class/methods#changemode)


---

---
title: Interactive Livestream - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: Interactive Livestream features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Overview
pagination_label: Overview
keywords:
  - Start HLS meeting
  - Stop HLS meeting
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: overview
---

import NoIndex from '../../../../../mdx/\_no-index.mdx';

<NoIndex/>

# Interactive Livestream (HLS) - Flutter

### What is Interactive Livestream (HLS)?

Interactive live streaming (HLS) refers to a type of live streaming where viewers can actively engage with the content being streamed and with other viewers in real-time.

In an interactive live stream (HLS), viewers can take part in a variety of activities like live polling, Q&A sessions, and even sending virtual gifts to the content creator or each other.

### What is Adaptive Live Streaming?

Livestream experience is important while undertaking interactive live streaming in order to increase audience. To do this, the livestream should be able to respond to the viewer's network bandwidth, and change the stream's resolution as necessary. Therefore, adaptive live streaming refers to a feed that automatically adjusts to a lower or higher resolution dependent on the user's preferences.

### What is Latency?

Latency is the delay between capturing video content and its playback. Key factors that affecting latency :

- **Buffering**: Balance buffer size for smoother playback against latency.
- **Network Conditions**: Efficient servers and network health contribute to lower latency.

Standard HLS has a latency around 5-6 seconds.

### HLS Architecture of VideoSDK

<center>

![VideoSDK HLS](https://cdn.videosdk.live/website-resources/docs-resources/mobile_hls.png)

</center>

When a host starts the interactive live stream, VideoSDK will use a deafult theme or user specified template to compose and encode a live stream which will be delivered to the viewers through a `M3U8` video file which can be played directly on the viewer end which will adapt to the viewer's network bandwidth.

When using VideoSDK for interactive live stream, you get multiple types of URLs which you can use based on your requirements.

**`1. Standard Streaming:`** This type of streaming is where the user is not allowed to go back in the live and can just stream it.

**`2. Rolling Playback:`** This type of streaming is where the user is allowed to do rewind and do a playback of the complete stream.

**`3. VoD Playback`** With this, users can playback the complete live stream on demand whenever needed.

### Using HLS with VideoSDK

You can use HLS with VideoSDK in two different ways.

#### 1. Simple Adaptive Streaming

When we talk about simple adaptive streaming, we imply that there is hardly any interaction between the hosts and the viewers.

These livestreams are helpful when there are a lot of viewers, and they don't want to engage with the host. In this scenario, every presenter attends a VideoSDK meeting, while every viewer only watches the livestream.

import ReactPlayer from 'react-player'

<div style={{textAlign: 'center'}}>

<ReactPlayer autoplay muted loop playing controls url="https://cdn.videosdk.live/website-resources/docs-resources/react_simple_ils.mp4" height="500px" width={"100%"} />

</div>

#### 2. Adaptive Streaming with increased engagement

When you want to communicate with your audience by enabling polls, conversations, and the ability for viewers to join and leave the livestream based on the host's decision, adaptive streaming with enhanced engagement will be the best fit for you.

In this scenario, both the host and the viewer will have to join a VideoSDK meeting with different roles. To learn more about the roles [follow these guide.](../handling-participants/manage-roles)

<div style={{textAlign: 'center'}}>

<ReactPlayer autoplay muted loop playing controls url="https://cdn.videosdk.live/website-resources/docs-resources/react_livestream_interaction_2.mp4" height="500px" width={"100%"} />

</div>


---

---
title: Setup HLS Player | Video SDK
hide_title: true
hide_table_of_contents: false
description: Using VideoSDK to do the interactive livestreaming.
sidebar_label: Setup HLS Player
pagination_label: Setup HLS Player
keywords:
  - audio calling
  - video calling
  - real-time communication
  - interactive live streaming
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: setup-hls-player
---

import NoIndex from '../../../../../mdx/\_no-index.mdx';

<NoIndex/>

# Setup HLS Player - Flutter

In this guide, we will create a new Component which will be responsible for playing the HLS stream.
Before starting this guide, make sure you have a VideoSDK meetings setup allowing you to join the room. To learn more about setting up a VideoSDK meeting, follow this quick start guide.

To play the HLS stream we will be using the [flutter_vlc_player](https://pub.dev/packages/flutter_vlc_player) library.

### `1. Setup Component with HLS events`

**`Step 1:`** Let us first start by creating the new `StatefulWidget` named `HlsScreen` which will listen to all the HLS related events and play the HLS stream whenever available.

```js
import 'package:flutter/material.dart';
import 'package:videosdk/videosdk.dart';

class HlsScreen extends StatefulWidget {
  final Room room;
  const HlsScreen({super.key, required this.room});

  @override
  State<HlsScreen> createState() => _HlsScreenState();
}

class _HlsScreenState extends State<HlsScreen> {
  //highlight-start
  //Declare state of the HLS and the playbackHlsUrl
  String hlsState = "HLS_STOPPED";
  String? playbackHlsUrl;
  //highlight-end

  @override
  void initState() {
    super.initState();
    //highlight-start
    //initialize the state from the room object
    hlsState = widget.room.hlsState;
    playbackHlsUrl = widget.room.hlsPlaybackHlsUrl;
    //highlight-end

    //setup hlsStateChanged event listener
    setMeetingEventListener();
  }

  @override
  Widget build(BuildContext context) {
    return Column(
      mainAxisAlignment: MainAxisAlignment.center,
      children: [
      ],
    );
  }

  //highlight-start
  // listening to meeting events
  void setMeetingEventListener() {
    widget.room.on(
      Events.hlsStateChanged,
      (Map<String, dynamic> data) {
        String status = data['status'];
        if (mounted) {
          setState(() {
            hlsState = status;
            //we will update the downstream URL if the HLS state is HLS_PLAYABLE and HLS_STOPPED
            if (status == "HLS_PLAYABLE" || status == "HLS_STOPPED") {
              playbackHlsUrl = data['playbackHlsUrl'];
            }
          });
        }
      },
    );
  }
  //highlight-end
}
```

**`Step 2:`** Now let's add the placeholder that will be shown when there is no active HLS. For these, we will use the `playbackHlsUrl` identify if there is an active HLS.

```js
import 'package:flutter/material.dart';
import 'package:videosdk/videosdk.dart';
import './livestream_player.dart';

class HlsScreen extends StatefulWidget {
  final Room room;
  //highlight-next-line
  ...
}

class _HlsScreenState extends State<HlsScreen> {
  String hlsState = "HLS_STOPPED";
  String? playbackHlsUrl;

  @override
  void initState() {
    //highlight-next-line
    ...
  }

  @override
  Widget build(BuildContext context) {
    return Column(
      mainAxisAlignment: MainAxisAlignment.center,
      children: [
        //Render the text placeholder if downstream url is null
        playbackHlsUrl != null
              ? LivestreamPlayer(playbackHlsUrl: playbackHlsUrl!)
              : const Text("Host has not started the HLS"),
      ],
    );
  }

  // listening to meeting events
  void setMeetingEventListener() {
    //highlight-next-line
    ...
  }
}
```

### `2. Playing HLS stream`

**`Step 1:`** We will be using the [flutter_vlc_player](https://pub.dev/packages/flutter_vlc_player) library to play the HLS stream. So let's start by installing the library.

```bash
flutter pub add flutter_vlc_player
```

**`Step 2:`** Next we will be `StatefulWidget` named `LivestreamPlayer` which will play our livestream from the provided `playbackHlsUrl`.

```js
import 'package:flutter/material.dart';
import 'package:flutter_vlc_player/flutter_vlc_player.dart';

class LivestreamPlayer extends StatefulWidget {
  final String playbackHlsUrl;
  const LivestreamPlayer({
    Key? key,
    required this.playbackHlsUrl,
  }) : super(key: key);

  @override
  LivestreamPlayerState createState() => LivestreamPlayerState();
}

class LivestreamPlayerState extends State<LivestreamPlayer>
    with AutomaticKeepAliveClientMixin {
  late VlcPlayerController _controller;

  @override
  bool get wantKeepAlive => true;

  @override
  void initState() {
    super.initState();
    //highlight-start
    //initialize the player with playbackHlsUrl
    _controller = VlcPlayerController.network(widget.playbackHlsUrl,
        options: VlcPlayerOptions());
    //highlight-end
  }

  @override
  void dispose() async {
    _controller.dispose();
    super.dispose();
  }

  @override
  Widget build(BuildContext context) {
    super.build(context);
    //highlight-start
    //return the VlcPlayer Widget
    return VlcPlayer(
      controller: _controller,
      aspectRatio: 9 / 16,
      placeholder: const Center(child: CircularProgressIndicator()),
    );
    //highlight-end
  }
}

```

With this, the player is setup to play the HLS.

<img src="https://cdn.videosdk.live/website-resources/docs-resources/flutter_ils_viewer_view.png" width="250"/>

## API Reference

The API references for all the methods utilized in this guide are provided below.

- [startHls](/flutter/api/sdk-reference/room-class/methods#starthls)
- [stopHls](/flutter/api/sdk-reference/room-class/methods#stophls)
- [Events.hlsStateChanged](/flutter/api/sdk-reference/room-class/events#hlsstatechanged)


---

---
title: Start HLS | Video SDK
hide_title: true
hide_table_of_contents: false
description: Using VideoSDK to do the interactive livestreaming.
sidebar_label: Start HLS
pagination_label: Start HLS
keywords:
  - audio calling
  - video calling
  - real-time communication
  - interactive live streaming
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: start-hls
---

import NoIndex from '../../../../../mdx/\_no-index.mdx';

<NoIndex/>

# Start HLS - Flutter

Before starting the HLS, the prequisite steps require you to have a VideoSDK Meeting running which you want to use for interactive livestream. To learn more about setting up a interactive live streaming, you can follow the steps [here in the quick start guide.](/flutter/guide/video-and-audio-calling-api-sdk/quick-start-ils)

## Starting HLS

`startHls()` can be used to start a interactive livestream of the meeting which can be accessed from the `Room` object. This method accepts one parameter:

- `config (optional)`: This parameter will define how the livestream layout should look like.

```js
Map<String, dynamic> config = {
  // highlight-next-line
  // Layout Configuration
  "layout": {
    "type": "GRID", // "SPOTLIGHT" | "SIDEBAR",  Default : "GRID"
    "priority": "SPEAKER", // "PIN", Default : "SPEAKER"
    "gridSize": 4, // MAX : 4
  },

  // highlight-next-line
  // Theme of recording
  "theme": "DARK", //  "LIGHT" | "DEFAULT"

  // highlight-next-line
  // `mode` is used to either record video & audio both or only audio.
  "mode": "video-and-audio", // "audio", Default : "video-and-audio"

  // highlight-next-line
  // Quality of recording and is only applicable to `video-and-audio` type mode.
  "quality": "high", // "low" | "med",  Default : "med"

  //highlight-start
  // This mode refers to orientation of recording.
  // landscape : Record the meeting in horizontally
  // portrait : Record the meeting in vertically (Best for mobile view)
  //highlight-end
  "orientation": "landscape", // "portrait",  Default : "landscape"
};

room.startHls(config: config);
```

:::note
If you want only the conference participants to be seen in the livestream, you can `pin` all the participants in the conference mode and start the livestream with the `SPOTLIGHT` layout and `PIN` as the `PRIORITY`.
:::

### Example

```js
import 'package:flutter/material.dart';
import 'package:videosdk/videosdk.dart';

class MeetingScreen extends StatefulWidget {
  ...
}

class _MeetingScreenState extends State<MeetingScreen> {
  late Room _room;

  @override
  void initState() {
    //highlight-next-line
    ...
  }

  @override
  Widget build(BuildContext context) {
    return Column(
      children:[
        //highlight-start
        ElevatedButton(
          onPressed:(){
            Map<String, dynamic> config = {
              "layout": {
                "type": "GRID",
                "priority": "SPEAKER",
                "gridSize": 4,
              },
              "theme": "DARK",
              "mode": "video-and-audio",
              "quality": "high",
              "orientation": "portrait",
            };
            _room.startHls(config: config);
          },
          child: const Text("Start HLS"),
        ),
    //highlight-end
      ]
    );
  }
}
```

## Understanding Layouts

##### 1. GRID Layout

This layout is default layout if no participants are pinned, it will look same as a normal meeting grid layout, when any participant is pinned that participant will be moved on top of the main screen grid above all non pinned participants

While screenshare as well the main view will contain only screenshare media but the side panel view of participant grid will maintain same order of pinned and unpinned participants.

|                       Grid                        |                     Grid with Screenshare                     |
| :-----------------------------------------------: | :-----------------------------------------------------------: |
| ![prebuilt-grid](/img/prebuilt/prebuilt-grid.png) | ![prebuilt-grid-share](/img/prebuilt/prebuilt-grid-share.png) |

##### 2. SIDEBAR Layout

This layout will have one main screen view and other sidebar grid layout. Only pinned participant will be visible in this layout, all unpinned participants will not be visible in this layout. If more than one participant is pinned then the first participant who was pinned will appear in main screen layout and all other remaining pinned particiapants will be visible in sidebar.

If any pinned participant started screenshare then the screenshare media will be visible in main screen layout and all other pinned participants webcam view will be visible in sidebar

|                         Sidebar                         |                      Sidebar with Screenshare                       |
| :-----------------------------------------------------: | :-----------------------------------------------------------------: |
| ![prebuilt-sidebar](/img/prebuilt/prebuilt-sidebar.png) | ![prebuilt-sidebar-share](/img/prebuilt/prebuilt-sidebar-share.png) |

##### 3. SPOTLIGHT Layout

This layout will only contain main screen layout, multiple pinned participants will be visible in main screen view. Same as `SIDEBAR` layout only pinned participants will be visible in main screen.

If any pinned participant started screenshare then only screenshare view will be visible in main screen, no webcam view will be visible when any pinned participant started screenshare.

|                          Spotlight                          |                       Spotlight with Screenshare                        |
| :---------------------------------------------------------: | :---------------------------------------------------------------------: |
| ![prebuilt-spotlight](/img/prebuilt/prebuilt-spotlight.png) | ![prebuilt-spotlight-share](/img/prebuilt/prebuilt-spotlight-share.png) |

## Event associated with HLS

- **hlsStateChanged** - Whenever meeting HLS state changes, then `hlsStateChanged` event will trigger.

- You can get the `playbackHlsUrl` and `livestreamUrl` of the HLS to play it on the Viewer side when the state changes to `HLS_PLAYABLE`
  - `playbackHlsUrl` - Live HLS with playback support
  - `livestreamUrl` - Live HLS without playback support

:::note
`downstreamUrl` is now depecated. Use `playbackHlsUrl` or `livestreamUrl` in place of `downstreamUrl`
:::

```js
import 'package:flutter/material.dart';
import 'package:videosdk/videosdk.dart';

class MeetingScreen extends StatefulWidget {
  ...
}

class _MeetingScreenState extends State<MeetingScreen> {
  late Room room;

  @override
  void initState() {
    //highlight-next-line
    ...

    setupRoomEventListener();
  }

  @override
  Widget build(BuildContext context) {
    return YourMeetingWidget();
  }

  //highlight-start
  void setupRoomEventListener() {
    room.on(Events.hlsStateChanged, (Map<String, dynamic> data) {
      //Status can be :: HLS_STARTING
      //Status can be :: HLS_STARTED
      //Status can be :: HLS_PLAYABLE
      //Status can be :: HLS_STOPPING
      //Status can be :: HLS_STOPPED
      log("Meeting HLS status : ${data['status']}");
      if (data['status'] == "HLS_PLAYABLE")
        log("PLAYBACKHLS URL -- " + data['playbackHlsUrl']);
    });
  }
  //highlight-end
}
```

## Custom Template

With VideoSDK, you can also use your own custom designed layout template to livestream the meetings. In order to use the custom template, you need to create a template for which you can [follow this guide](/react/guide/interactive-live-streaming/custom-template). Once you have setup the template, you can use the [REST API to start](/api-reference/realtime-communication/start-livestream) the livestream with the `templateURL` parameter.

## API Reference

The API references for all the methods utilized in this guide are provided below.

- [startHls](/flutter/api/sdk-reference/room-class/methods#starthls)
- [stopHls](/flutter/api/sdk-reference/room-class/methods#stophls)
- [Events.hlsStateChanged](/flutter/api/sdk-reference/room-class/events#hlsstatechanged)


---

---
title: Stop HLS | Video SDK
hide_title: true
hide_table_of_contents: false
description: Using VideoSDK to do the interactive livestreaming.
sidebar_label: Stop HLS
pagination_label: Stop HLS
keywords:
  - audio calling
  - video calling
  - real-time communication
  - interactive live streaming
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: stop-hls
---

import NoIndex from '../../../../../mdx/\_no-index.mdx';

<NoIndex/>

# Stop HLS - Flutter

This could refer to stopping the transmission of an ongoing HLS stream, which would mean the stream is no longer available to viewers.

## Stopping HLS

`stopHls()` can be used to stop a interactive livestream of the meeting which can be accessed from the `Room` object.

### Example

```js
import 'package:flutter/material.dart';
import 'package:videosdk/videosdk.dart';

class MeetingScreen extends StatefulWidget {
  ...
}

class _MeetingScreenState extends State<MeetingScreen> {
  late Room _room;

  @override
  void initState() {
    //highlight-next-line
    ...
  }

  @override
  Widget build(BuildContext context) {
    return Column(
      children:[
        //highlight-start
        ElevatedButton(
          onPressed:(){
            _room.stopHls();
          },
          child: const Text("Stop HLS"),
        ),
    //highlight-end
      ]
    );
  }
}
```

## Event associated with HLS

- **hlsStateChanged** - Whenever meeting HLS state changes, then `hlsStateChanged` event will trigger.

- You will get `HLS_STOPPING` and `HLS_STOPPED` status on calling `stopHls()`.

```js
import 'package:flutter/material.dart';
import 'package:videosdk/videosdk.dart';

class MeetingScreen extends StatefulWidget {
  ...
}

class _MeetingScreenState extends State<MeetingScreen> {
  late Room room;

  @override
  void initState() {
    //highlight-next-line
    ...

    setupRoomEventListener();
  }

  @override
  Widget build(BuildContext context) {
    return YourMeetingWidget();
  }

  //highlight-start
  void setupRoomEventListener() {
    room.on(Events.hlsStateChanged, (Map<String, dynamic> data) {
      //Status can be :: HLS_STARTING
      //Status can be :: HLS_STARTED
      //Status can be :: HLS_PLAYABLE
      //Status can be :: HLS_STOPPING
      //Status can be :: HLS_STOPPED
      log("Meeting HLS status : ${data['status']}");
      if (data['status'] == "HLS_STOPPING")
        log("HLS Stopping");
      if (data['status'] == "HLS_STOPPED")
        log("HLS Stopped");
    });
  }
  //highlight-end
}
```

## Custom Template

With VideoSDK, you can also use your own custom designed layout template to livestream the meetings. In order to use the custom template, you need to create a template for which you can [follow this guide](/react/guide/interactive-live-streaming/custom-template). Once you have setup the template, you can use the [REST API to start](/api-reference/realtime-communication/start-livestream) the livestream with the `templateURL` parameter.

## API Reference

The API references for all the methods utilized in this guide are provided below.

- [startHls](/flutter/api/sdk-reference/room-class/methods#starthls)
- [stopHls](/flutter/api/sdk-reference/room-class/methods#stophls)
- [Events.hlsStateChanged](/flutter/api/sdk-reference/room-class/events#hlsstatechanged)


---

---
title: Chat messages with PubSub - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: PubSub features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Chat using PubSub
pagination_label: Chat using PubSub
keywords:
  - Start Livestream meeting
  - Stop Livestream meeting
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: chat-using-pubsub
---

import NoIndex from '../../../../../mdx/\_no-index.mdx';

<NoIndex/>

# Chat using PubSub - Flutter

For the communication or any kind of messaging in between the participants, VideoSDK provides `pubSub` which use Publish-Subsciribe mechanism and can be used to develope wide varitey of functionalities. For example, participants could use it to send chat messages to each other, share files or other media, or even trigger actions like muting or unmuting audio or video.

Now we will see, how we can use PubSub to implement Chat functionality. If you are not familiar with the PubSub mechanism, you can [follow this guide](/flutter/guide/video-and-audio-calling-api-sdk/collaboration-in-meeting/pubsub).

## Implementing Chat

1. First step in creating a group chat is choosing the topic which all the participants will publish and subscribe to send and receive the messages. We will be using `CHAT` as the topic for this one. So let us lets create a message input and send button to publish the messages using the `pubSub` from the `Room` object.

```js
import 'package:flutter/material.dart';
import 'package:videosdk/videosdk.dart';

class ChatView extends StatefulWidget {
  final Room room;
  ...
}

class _ChatViewState extends State<ChatView> {

  final msgTextController = TextEditingController();


  @override
  void initState() {
    //highlight-next-line
    ...
  }

  @override
  Widget build(BuildContext context) {
    return Column(
      children:[
        //highlight-start
        Row(
          children: [
            Expanded(
              child: TextField(
                style: TextStyle(
                  fontSize:16,
                  fontWeight: FontWeight.w500,
                ),
                controller: msgTextController,
                onChanged: (value) => setState(() {
                  msgTextController.text;
                }),
                decoration: const InputDecoration(
                  hintText: "Write your message",
                  border: InputBorder.none,
                ),
              ),
            ),
            ElevatedButton(
              onPressed:(){
                if(!msgTextController.text.trim().isEmpty){
                  widget.room.pubSub
                        .publish(
                          "CHAT",
                          msgTextController.text,
                          const PubSubPublishOptions(
                              persist: true),
                        )
                        .then(
                            (value) => msgTextController.clear())
                }
              },
              child: const Text("Send Message"),
            ),
          ],
        ),
    //highlight-end
      ]
    );
  }

}
```

2. Final step in the group chat would be to display the messages others send. For this will use the `messages` and display all the messages by subscribing to the topic `CHAT`.

```js
import 'package:flutter/material.dart';
import 'package:videosdk/videosdk.dart';

class ChatView extends StatefulWidget {
  final Room room;
  ...
}

class _ChatViewState extends State<ChatView> {

  // PubSubMessages
  PubSubMessages? messages;

  @override
  void initState() {
    //highlight-next-line
    ...

    //highlight-start
    // Subscribing 'CHAT' Topic
    widget.meeting.pubSub
      .subscribe("CHAT", messageHandler)
      .then((value) => setState((() => messages = value)));
    //highlight-end
  }

  //highlight-start
  //Handler which will be called when new mesasge is received
  void messageHandler(PubSubMessage message) {
    setState(() => messages!.messages.add(message));
  }
  //highlight-end

  @override
  Widget build(BuildContext context) {
    return Column(
      children:[
        //highlight-start
        Expanded(
          child: messages == null
              ? const Center(child: CircularProgressIndicator())
              : SingleChildScrollView(
                  reverse: true,
                  child: Column(
                    children: messages!.messages
                        .map(
                          (message) => Text(
                            message.message
                          ),
                        )
                        .toList(),
                  ),
                ),
        ),

        ...
        //Send Message code Here
    //highlight-end
      ]
    );
  }

  @override
  void dispose() {
    //highlight-start
    // Unsubscribe
    widget.room.pubSub.unsubscribe("CHAT", messageHandler);
    //highlight-end
    super.dispose();
  }
}
```

### Displaying Latest Message Notificaiton

You may want to show the notification to the user when new message arrives. So lets continue our example and add alert for the new images.

```js
import 'package:flutter/material.dart';
import 'package:videosdk/videosdk.dart';

class ChatView extends StatefulWidget {
  final Room room;
  ...
}

class _ChatViewState extends State<ChatView> {

  @override
  void initState() {
    //highlight-next-line
    ...
  }

  //highlight-start
  //Handler which will be called when new mesasge is received
  void messageHandler(PubSubMessage message) {
    //Show snackbar on new message
    if(context.mounted){
      ScaffoldMessenger.of(context).showSnackBar(SnackBar(
        content: Text(
          message.message,
          overflow: TextOverflow.fade,
        ),
      ));
    }
    setState(() => messages!.messages.add(message));
  }
  //highlight-end

  @override
  Widget build(BuildContext context) {
    return Column(
      children:[
        //highlight-start
        ...
         //highlight-end
      ]
    );
  }

  @override
  void dispose() {
    //highlight-next-line
    ...
  }
}
```

## Downloading Chat Messages

All the messages from the PubSub which where published with `persist : true` and can be downloaded as an `.csv` file. This file will be available in the VideoSDK dashboard as well as throught the [Sessions API](/api-reference/realtime-communication/fetch-session-using-sessionid).

## API Reference

The API references for all the methods and events utilised in this guide are provided below.

- [pubSub](/flutter/api/sdk-reference/pubsub-class/introduction)


---

---
title: Notify Attendees with PubSub - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: PubSub features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Notify Attendees in Realtime
pagination_label: Notify Attendees in Realtime
keywords:
  - Start Livestream meeting
  - Stop Livestream meeting
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: notify-attendees
---

import NoIndex from '../../../../../mdx/\_no-index.mdx';

<NoIndex/>

# Notify Attendees in Realtime - Flutter

When doing livestream, you may want to broadcast message to all the viewers at once.

Let us see, how we can use PubSub to implement this functionality. If you are not familiar with the PubSub mechanism you can [follow this guide](/flutter/guide/video-and-audio-calling-api-sdk/collaboration-in-meeting/pubsub).

### Notifying Attendees

1. We will be creating a button and text input to take the message input and we will publish a message to the topic `NOTIFY_ATTENDEES`

```js
import 'package:flutter/material.dart';
import 'package:videosdk/videosdk.dart';

class NotifyView extends StatefulWidget {
  final Room room;
  ...
}

class _NotifyViewState extends State<NotifyView> {

  final msgTextController = TextEditingController();


  @override
  void initState() {
    //highlight-next-line
    ...
  }

  @override
  Widget build(BuildContext context) {
    return Column(
      children:[
        //highlight-start
        Row(
          children: [
            Expanded(
              child: TextField(
                style: TextStyle(
                  fontSize:16,
                  fontWeight: FontWeight.w500,
                ),
                controller: msgTextController,
                onChanged: (value) => setState(() {
                  msgTextController.text;
                }),
                decoration: const InputDecoration(
                  hintText: "Write your message",
                  border: InputBorder.none,
                ),
              ),
            ),
            ElevatedButton(
              onPressed:(){
                if(!msgTextController.text.trim().isEmpty){
                  widget.room.pubSub
                        .publish(
                          "NOTIFY_ATTENDEES",
                          msgTextController.text,
                          const PubSubPublishOptions(
                              persist: true),
                        )
                        .then(
                            (value) => msgTextController.clear())
                }
              },
              child: const Text("Notify Attendees"),
            ),
          ],
        ),
    //highlight-end
      ]
    );
  }

}
```

2. Now let us show an alert to all the viewers displaying the message posted by the speaker.

```js
import 'package:flutter/material.dart';
import 'package:videosdk/videosdk.dart';

class ViewerView extends StatefulWidget {
  final Room room;
  ...
}

class _ViewerViewState extends State<ViewerView> {

  @override
  void initState() {
    //highlight-next-line
    ...

    //highlight-start
    // Subscribing 'NOTIFY_ATTENDEES' Topic
    widget.meeting.pubSub
      .subscribe("NOTIFY_ATTENDEES", messageHandler);
    //highlight-end
  }

  //highlight-start
  //Handler which will be called when new mesasge is
  //These is where we will show the message
  void messageHandler(PubSubMessage message) {
    if(context.mounted && widget.room.localParticipant.mode == MOde.SIGNALLING_ONLY){
      ScaffoldMessenger.of(context).showSnackBar(SnackBar(
        content: Text(
          message.message,
          overflow: TextOverflow.fade,
        ),
      ));
    }
  }
  //highlight-end

  @override
  Widget build(BuildContext context) {
    return Column(
      children:[
        //highlight-next-line
        ...
      ]
    );
  }

  @override
  void dispose() {
    //highlight-start
    // Unsubscribe
    widget.room.pubSub.unsubscribe("NOTIFY_ATTENDEES", messageHandler);
    //highlight-end
    super.dispose();
  }
}
```

### API Reference

The API references for all the methods and events utilized in this guide are provided below.

- [PubSub](/flutter/api/sdk-reference/pubsub-class/introduction)


---

---
title: Raise Hand with PubSub - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: PubSub features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Raise Hand
pagination_label: Raise Hand
keywords:
  - Start Livestream meeting
  - Stop Livestream meeting
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: raise-hand
---

import NoIndex from '../../../../../mdx/\_no-index.mdx';

<NoIndex/>

# Raise Hand - Flutter

Let us see, how we can use PubSub to implement Raise hand functionality. If you are not familiar with the PubSub mechanism you can [follow this guide](/flutter/guide/video-and-audio-calling-api-sdk/collaboration-in-meeting/pubsub).

### Implementing Raise Hand

1. We will be creating a button when clicked, we will publish a message it the topic `RAISE_HAND`

```js
import 'package:flutter/material.dart';
import 'package:videosdk/videosdk.dart';

class NotifyView extends StatefulWidget {
  final Room room;
  ...
}

class _NotifyViewState extends State<NotifyView> {

  final msgTextController = TextEditingController();


  @override
  void initState() {
    //highlight-next-line
    ...
  }

  @override
  Widget build(BuildContext context) {
    return Column(
      children:[
        //highlight-start
        ElevatedButton(
          onPressed:(){
            widget.room.pubSub
                  .publish(
                    "RAISE_HAND",
                    "Raised Hand",
                    const PubSubPublishOptions(
                        persist: true),
                  );
          },
          child: const Text("Raise Hand"),
        ),
    //highlight-end
      ],
    );
  }

}
```

2. Now let us show an alert to all the speakers showing who raised the hand.

```js
import 'package:flutter/material.dart';
import 'package:videosdk/videosdk.dart';

class SpeakerView extends StatefulWidget {
  final Room room;
  ...
}

class _SpeakerViewState extends State<SpeakerView> {

  @override
  void initState() {
    //highlight-next-line
    ...

    //highlight-start
    // Subscribing 'RAISE_HAND' Topic
    widget.meeting.pubSub
      .subscribe("RAISE_HAND", messageHandler);
    //highlight-end
  }

  //highlight-start
  //Handler which will be called when new mesasge is
  //These is where we will show the message
  void messageHandler(PubSubMessage message) {
    if(context.mounted && widget.room.localParticipant.mode == Mode.SEND_AND_RECV){
      ScaffoldMessenger.of(context).showSnackBar(SnackBar(
        content: Text(
          "${message.senderName} raised hand",
          overflow: TextOverflow.fade,
        ),
      ));
    }
  }
  //highlight-end

  @override
  Widget build(BuildContext context) {
    return Column(
      children:[
        //highlight-next-line
        ...
      ]
    );
  }

  @override
  void dispose() {
    //highlight-start
    // Unsubscribe
    widget.room.pubSub.unsubscribe("RAISE_HAND", messageHandler);
    //highlight-end
    super.dispose();
  }

}
```

### API Reference

The API references for all the methods and events utilized in this guide are provided below.

- [PubSub](/flutter/api/sdk-reference/pubsub-class/introduction)


---

---
title: Authentication in Video & Audio Calling SDK
hide_title: true
hide_table_of_contents: false
description: This guide will explain authentication and token flow for video & audio calling SDK.
sidebar_label: Authentication and Tokens
pagination_label: Authentication and Tokens
keywords:
  - authentication audio calling
  - authentication video calling
  - authentication real-time communication
  - tokens
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: authentication-and-tokens
---

import ServerSetup from '../../../../mdx/introduction/\_server-setup.mdx';
import NoIndex from '../../../../mdx/\_no-index.mdx';

<NoIndex/>

<ServerSetup title="Authentication and Tokens for VideoSDK - Flutter"/>


---

---
title: Chat messages with PubSub - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: PubSub features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Chat using PubSub
pagination_label: Chat using PubSub
keywords:
  - Start Livestream meeting
  - Stop Livestream meeting
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: chat-using-pubsub
---

import NoIndex from '../../../../../mdx/\_no-index.mdx';

<NoIndex/>

# Chat using PubSub - Flutter

For the communication or any kind of messaging in between the participants, VideoSDK provides `pubSub` which use Publish-Subsciribe mechanism and can be used to develope wide varitey of functionalities. For example, participants could use it to send chat messages to each other, share files or other media, or even trigger actions like muting or unmuting audio or video.

Now we will see, how we can use PubSub to implement Chat functionality. If you are not familiar with the PubSub mechanism, you can [follow this guide](./pubsub).

## Implementing Chat

### `Group Chat`

1. First step in creating a group chat is choosing the topic which all the participants will publish and subscribe to send and receive the messages. We will be using `CHAT` as the topic for this one. So let us lets create a message input and send button to publish the messages using the `pubSub` from the `Room` object.

```js
import 'package:flutter/material.dart';
import 'package:videosdk/videosdk.dart';

class ChatView extends StatefulWidget {
  final Room room;
  ...
}

class _ChatViewState extends State<ChatView> {

  final msgTextController = TextEditingController();


  @override
  void initState() {
    //highlight-next-line
    ...

    //highlight-start
    // Subscribing 'CHAT' Topic
    widget.meeting.pubSub
      .subscribe("CHAT", messageHandler)
      .then((value) => setState((() => messages = value)));
    //highlight-end
  }

  //highlight-start
  //Handler which will be called when new mesasge is received
  void messageHandler(PubSubMessage message) {
    setState(() => messages!.messages.add(message));
  }
  //highlight-end

  @override
  Widget build(BuildContext context) {
    return Column(
      children:[
        //highlight-start
        Row(
          children: [
            Expanded(
              child: TextField(
                style: TextStyle(
                  fontSize:16,
                  fontWeight: FontWeight.w500,
                ),
                controller: msgTextController,
                onChanged: (value) => setState(() {
                  msgTextController.text;
                }),
                decoration: const InputDecoration(
                  hintText: "Write your message",
                  border: InputBorder.none,
                ),
              ),
            ),
            ElevatedButton(
              onPressed:(){
                if(!msgTextController.text.trim().isEmpty){
                  widget.room.pubSub
                        .publish(
                          "CHAT",
                          msgTextController.text,
                          const PubSubPublishOptions(
                              persist: true),
                        )
                        .then(
                            (value) => msgTextController.clear())
                }
              },
              child: const Text("Send Message"),
            ),
          ],
        ),
    //highlight-end
      ]
    );
  }

}
```

2. Final step in the group chat would be to display the messages others send. For this will use the `messages` and display all the messages by subscribing to the topic `CHAT`.

```js
import 'package:flutter/material.dart';
import 'package:videosdk/videosdk.dart';

class ChatView extends StatefulWidget {
  final Room room;
  ...
}

class _ChatViewState extends State<ChatView> {

  // PubSubMessages
  PubSubMessages? messages;

  @override
  void initState() {
    //highlight-next-line
    ...

    //highlight-start
    // Subscribing 'CHAT' Topic
    widget.meeting.pubSub
      .subscribe("CHAT", messageHandler)
      .then((value) => setState((() => messages = value)));
    //highlight-end
  }

  //highlight-start
  //Handler which will be called when new mesasge is received
  void messageHandler(PubSubMessage message) {
    setState(() => messages!.messages.add(message));
  }
  //highlight-end

  @override
  Widget build(BuildContext context) {
    return Column(
      children:[
        //highlight-start
        Expanded(
          child: messages == null
              ? const Center(child: CircularProgressIndicator())
              : SingleChildScrollView(
                  reverse: true,
                  child: Column(
                    children: messages!.messages
                        .map(
                          (message) => Text(
                            message.message
                          ),
                        )
                        .toList(),
                  ),
                ),
        ),

        ...
        //Send Message code Here
    //highlight-end
      ]
    );
  }

  @override
  void dispose() {
    //highlight-start
    // Unsubscribe
    widget.room.pubSub.unsubscribe("CHAT", messageHandler);
    //highlight-end
    super.dispose();
  }
}
```

### `Private Chat`

In the above example, if you want to convert into the private chat between two participants, then all you have to do is change the topic which will be unique to those two participants only.

So if we look at creating a private chat between two participants only, we can have the topic something like `<participantId_of_A>_<participantId_of_B>` or `<participantId_of_B>_<participantId_of_A>`.

So you can use either of this topics and the private chat is ready.

### Displaying Latest Message Notificaiton

You may want to show the notification to the user when new message arrives. So lets continue our example and add alert for the new images.

```js
import 'package:flutter/material.dart';
import 'package:videosdk/videosdk.dart';

class ChatView extends StatefulWidget {
  final Room room;
  ...
}

class _ChatViewState extends State<ChatView> {

  @override
  void initState() {
    //highlight-next-line
    ...
  }

  //highlight-start
  //Handler which will be called when new mesasge is received
  void messageHandler(PubSubMessage message) {
    //Show snackbar on new message
    if(context.mounted){
      ScaffoldMessenger.of(context).showSnackBar(SnackBar(
        content: Text(
          message.message,
          overflow: TextOverflow.fade,
        ),
      ));
    }
    setState(() => messages!.messages.add(message));
  }
  //highlight-end

  @override
  Widget build(BuildContext context) {
    return Column(
      children:[
        //highlight-start
        ...
         //highlight-end
      ]
    );
  }

  @override
  void dispose() {
    //highlight-next-line
    ...
  }
}
```

## Downloading Chat Messages

All the messages from the PubSub which where published with `persist : true` and can be downloaded as an `.csv` file. This file will be available in the VideoSDK dashboard as well as throught the [Sessions API](/api-reference/realtime-communication/fetch-session-using-sessionid).

## API Reference

The API references for all the methods and events utilised in this guide are provided below.

- [pubSub](/flutter/api/sdk-reference/pubsub-class/introduction)


---

---
title: PubSub - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: PubSub features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: PubSub
pagination_label: PubSub
keywords:
  - Start Livestream meeting
  - Stop Livestream meeting
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: pubsub
---

import NoIndex from '../../../../../mdx/\_no-index.mdx';

<NoIndex/>

# PubSub - Flutter

PubSub is a short acronym for Publish-Subscribe mechanism. This mechanism is used to send and recieve messages from a particular topic. As the name suggests, for someone to send a message, they have to specify the topic and the message which should be published and for someone to receive a message, they should be subscribed to that topic.

Here is a visual to better understand publish-subscribe mechanism.

![pubsub](/img/pubsub.png)

## PubSub

In order to use PubSub in meeting, VideoSDK provides a hook `usePubSub` which allows you to subscribe to any topic and publish to any topic allowing to pass on messages and instructions during the meeting easily.

### `publish()`

- This method is used for publishing message of specific topic.
- This method can be accessed from the `pubSub` from the `Room`.
- This method will accept thre parameters as input:
  - `topic`: This will be the topic where the message will be published.
  - `message`: This will be the actual message to be published. It has to be in `String` format.
  - `options`: This object offered the option of keeping the message around for the duration of the session. When `persist` is set to `true`, that message will be retained for upcoming participants and will be available in [VideoSDK Session Dashboard](https://app.videosdk.live/meetings/sessions) with `.CSV` format after completion of session.

```js
import 'package:flutter/material.dart';
import 'package:videosdk/videosdk.dart';

class MeetingScreen extends StatefulWidget {
  ...
}

class _MeetingScreenState extends State<MeetingScreen> {
  late Room _room;

  @override
  void initState() {
    //highlight-next-line
    ...
  }

  @override
  Widget build(BuildContext context) {
    return Column(
      children:[
        //highlight-start
        //These will publish "Hello World!" on the "CHAT" topic
        ElevatedButton(
          onPressed:(){
            _room.pubSub.publish("CHAT", "Hello World!")
          },
          child: const Text("Send Message"),
        ),
    //highlight-end
      ]
    );
  }
}
```

## Receiving the messages

- All the previous messages for the particular topic can be recieved by subscribing to the topic.
- To subscribe to a specific topic, use can use the `subscribe()` method which will return the `Future<PubSubMessages>` and accepts the `topic` to be subscribed and a `callback function` which will be called when ever any new message is received.

- `PubSubMessages` contains the `messages` as a list of `PubSubMessage` which will contain following properties:
  - `senderId`: This represents the `participantId` of the participant who send the message.
  - `senderName`: This represents the `displayName` of the participant who send the message.
  - `message`: This will be the acatual message that was send.
  - `timestamp`: This wil the timestamp for when the message was published.
  - `topic`: This will be the name of the topic message was published to.

## Example

```js
import 'package:flutter/material.dart';
import 'package:videosdk/videosdk.dart';

class ChatView extends StatefulWidget {
  final Room room;
  ...
}

class _ChatViewState extends State<ChatView> {

  // PubSubMessages
  PubSubMessages? messages;

  @override
  void initState() {
    //highlight-next-line
    ...

    //highlight-start
    // Subscribing 'CHAT' Topic
    widget.meeting.pubSub
      .subscribe("CHAT", messageHandler)
      .then((value) => setState((() => messages = value)));
    //highlight-end
  }

  //highlight-start
  //Handler which will be called when new mesasge is received
  void messageHandler(PubSubMessage message) {
    setState(() => messages!.messages.add(message));
  }
  //highlight-end

  @override
  Widget build(BuildContext context) {
    return Column(
      children:[
        //highlight-start
        Expanded(
          child: messages == null
              ? const Center(child: CircularProgressIndicator())
              : SingleChildScrollView(
                  reverse: true,
                  child: Column(
                    children: messages!.messages
                        .map(
                          (message) => Text(
                            message.message
                          ),
                        )
                        .toList(),
                  ),
                ),
        ),
    //highlight-end
      ]
    );
  }

  @override
  void dispose() {
    //highlight-start
    // Unsubscribe
    widget.room.pubSub.unsubscribe("CHAT", messageHandler);
    //highlight-end
    super.dispose();
  }
}
```

## Applications of PubSub

PubSub is a very powerful mechanism which can be used to do alot of things which can make your meeting experience much more interactive. Some of the most common usecase that we have come across for the PubSub during a meeting are listed below:

1. [`Chat`](./chat-using-pubsub): You can utilise this to develop various Chat features, such as Private Chat and Group Chat. You can follow our chat [integration guide here](./chat-using-pubsub).
2. `Raise Hand`: You can allow attendees to raise their hands at any time during the meeting, informing everyone else that someone has done so.
3. `Layout Switching`: You can change the meeting's layout for every participant at once during the meeting, such as from Grid layout to Spotlight or Grid Layout to Sidebar Layout, etc.
4. `Whiteboard`: You can develop an interactive whiteboard functionality that is completely functional.
5. `Poll`: You may make polls, let users respond to them, and display the results at the end of a poll.
6. `Question Answer Session`: You can also design interactive functionality that is question-and-answer based.

## Downloading PubSub Messages

All the messages from the PubSub which were published with `persist : true` and can be downloaded as an `.csv` file. This file will be available in the VideoSDK dashboard as well as throught the [Sessions API](/api-reference/realtime-communication/fetch-session-using-sessionid).

## API Reference

The API references for all the methods and events utilised in this guide are provided below.

- [pubSub](/flutter/api/sdk-reference/pubsub-class/introduction)


---

---
sidebar_label: Concept And Architecture
pagination_label: Concept And Architecture
---

import NoIndex from '../../../../mdx/\_no-index.mdx';

<NoIndex/>

# Concept and Architecture - Flutter

Before diving into the concept, let's understand the VideoSDK, VideoSDK is a software development kit that offers tools and APIs for creating apps that are based on video and audio. It typically includes features such as video and audio calls, chat, cloud recording, simulcasting (RTMP), interactive live streaming (HLS), and many more across a wide range of platforms and devices.

## Concepts

![img.png](../../../../static/img/room-concept.png)

### `1. Meeting / Room`

- Meeting or Room objects in the VideoSDK provide a virtual place for participants to interact and engage in real-time voice, video, and screen-sharing sessions. The object is in charge of handling media streams and participant communication.

- Meeting or Room can be uniquely identified by `meetingId` or `roomId`.

### `2. Participant`

- Participant is a VideoSDK object that represents each user/client in the meeting or room and allows them to share audio/video assets.

- `2.1 Local Participant` :
  The local participant is the one that runs on the user's device. The local participant has control over their own media streams, including the ability to start and stop audio and video.

  - The local participant in a meeting/room can also connect with other participants by transmitting and receiving audio and video streams, exchanging chat messages, and more.

- `2.2 Remote Participant` :
  The remote participant receives audio and video streams from the local participant and other remote participants and also has the ability to exchange audio, video, and chat messages with the local participant.

- Each participant in VideoSDK can be uniquely identified by `participantId`.

### `3. MediaStream & Track`

- A mediastream is a collection of audio & video tracks that can be transmitted between participants in real-time.

- A track is a continuous flow of audio or video data and can be thought of as a stream of media frames.

- A mediastream can contain multiple tracks. One video track for the video feed from the camera and one audio track for the audio feed from the microphone. These tracks can be transmitted between participants in VideoSDK Meeting / Room.

### `4. Events / Notifications`

- Events / Notifications can be used to inform users about various activities happening in a Meeting / Room, including participant join/leave and new messages. They can also be used to alert users about any SDK-level errors that occur during a call.

---

### `5. Session`

- A Session is the instance of an ongoing meeting/room which has one or more participants in it. A single room or meeting can have multiple sessions.
- Each session can be uniquely identified by `sessionId`.

![img.png](../../../../static/img/meeting-session.jpg)

---

![img.png](../../../../static/img/recording-hls-rtmp.png)

### `6. Cloud Recording`

- Cloud recording in VideoSDK refers to the process of recording audio or video content and storing it on a remote server or VideoSDK server.

### `7. Simulcasting (RTMP)`

- RTMP is a popular protocol for live streaming video content from a VideoSDK to platforms such as YouTube, Twitch, Facebook, and others.
- By providing the platform-specific `stream key` and `stream URL`, the VideoSDK can connect to the platform's RTMP server and transmit the live video stream.

### `8. Http Live Streaming (HLS)`

- Interactive live streaming (HLS) refers to a type of live streaming where viewers can actively engage with the content being streamed and with other viewers in real-time.

- In an interactive live stream (HLS), viewers can take part in a variety of activities like live polling, Q&A sessions, and even sending virtual gifts to the content creator or each other.

## Architecture

This diagram demonstrates end-to-end flow to implement video & audio calls, record calls, and go live on social media.

![Video-sdk-architecture!](/img/video-sdk-archietecture.svg)


---

---
title: Mute All Participants | Video SDK
hide_title: true
hide_table_of_contents: false
description: Video SDK and Audio SDK, developers need to implement a token server. This requires efforts on both the front-end and backend.
sidebar_label: Mute All Participants
pagination_label: Mute All Participants
keywords:
  - audio calling
  - video calling
  - real-time communication
  - collaboration
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: mute-all-participants
---

import NoIndex from '../../../../../mdx/\_no-index.mdx';

<NoIndex/>

# Mute All Participants - Flutter

If you are the host or moderator of a video conference, you may want to mute all the participants at once. This can be useful in various scenarios, such as when you want to deliver a presentation or when there is background noise that is causing distractions.

- To achieve this, you have to iterate over the list of participants from the `Room` object and call `muteMic` method on each `Participant` object.

```javascript
import 'package:flutter/material.dart';
import 'package:videosdk/videosdk.dart';

class MeetingScreen extends StatefulWidget {
  ...
}

class _MeetingScreenState extends State<MeetingScreen> {
  late Room _room;

  @override
  void initState() {
    ...
  }

  @override
  Widget build(BuildContext context) {
    return Column(
      children:[
        ElevatedButton(
          child: Text("Mute all participants"),
          onPressed: () => {
            _room.participants.values.forEach((participant) {
              participant.muteMic();
            });
        }),
      ]
    );
  }
}
```

:::note
Participant who will be muting other participants should have permission **`allow_mod`** passed in the token. To know more about permissions [**visit here**](/react-native/guide/video-and-audio-calling-api-sdk/authentication-and-token).
:::

### API Reference

The API references for all the methods and events utilised in this guide are provided below.

- [muteMic()](/flutter/api/sdk-reference/participant-class/methods#mutemic)


---

---
title: Toggle Remote Participant Media | Video SDK
hide_title: true
hide_table_of_contents: false
description: Video SDK and Audio SDK, developers need to implement a token server. This requires efforts on both the front-end and backend.
sidebar_label: Toggle Remote Participant Media
pagination_label: Toggle Remote Participant Media
keywords:
  - audio calling
  - video calling
  - real-time communication
  - collaboration
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: remote-participant-media
---

import NoIndex from '../../../../../mdx/\_no-index.mdx';

<NoIndex/>

# Toggle Remote Participant Media - Flutter

When hosting a meeting, it's important that the host of the meeting should be able to request someone's Mic or Camera to be turned on or should be able to turn them off.

:::note
Participant who will be controlling other participant's mic and camera should have permission **`allow_mod`** passed in the token. To know more about permissions [**visit here**](/flutter/guide/video-and-audio-calling-api-sdk/authentication-and-tokens).
:::

Before we discuss the methods and events associated with this functionality, here is how the flow would look like.

![img1](/img/toggle-remote-media.png)

## Methods

### `unmuteMic()`

- If you wish to turn **on** the microphone of a participant, you will be calling the `unmuteMic()` on the `Participant` object.

- When this method is called, the participant whose microphone is requested will receive the `Events.micRequested` event with the `participantId` of the participant who requested it and two callback functions `accept` and `reject` which should be called based on decision made by the user.

- **Example:** Meeting is running with **Participant A** and **Participant B**. Now **Participant A** wants to unmute Mic of **Participant B**, so **Participant A** will use `unmuteMic()` function to request **Participant B**, after that **Participant B** recieve the `Events.micRequested` event, from there user can either accept or reject the incoming request.

### `enableCam()`

- If you wish to turn **on** the camera of a participant, you will be calling the `enableCam()` from the `useParticipant` hook.

- When this method is called, the participant whose camera is requested will receive the `Events.cameraRequested` event with the `participantId` of the participant who requested it and two callback functions `accept` and `reject` which should be called based on decision made by the user.

- **Example:** Meeting is running with **Participant A** and **Participant B**. Now **Participant A** wants to Enable Cam of **Participant B**, so **Participant A** will use `enableCam()` function to request **Participant B**, after that **Participant B** recieve the `Events.cameraRequested` event, from there user can either accept or reject the incoming request.

### `muteMic()`

- If you wish to turn **off** the microphone of a participant, you will be calling the `muteMic()` on the `Participant` object.
- This will disable the microphone of the participant.

### `disableCam()`

- If you wish to turn **off** the camera of a participant, you will be calling the `disableCam()` on the `Participant` object.
- This will disable the camera of the participant.

#### Example

```js
import 'package:flutter/material.dart';
import 'package:videosdk/videosdk.dart';

class ParticipantTile extends StatefulWidget {
  final Participant participant;
  const ParticipantTile({super.key, required this.participant});

  @override
  State<ParticipantTile> createState() => _ParticipantTileState();
}

class _ParticipantTileState extends State<ParticipantTile> {

  @override
  Widget build(BuildContext context) {
    return Column(
      children: [
        ElevatedButton(
          child: Text("Enable Mic"),
          onPressed: () => {
            widget.participant.unmuteMic();
        }),
        ElevatedButton(
          child: Text("Disable Mic"),
          onPressed: () => {
            widget.participant.muteMic();
        }),
        ElevatedButton(
          child: Text("Enable Cam"),
          onPressed: () => {
            widget.participant.enableCam();
        }),
        ElevatedButton(
          child: Text("Disable Cam"),
          onPressed: () => {
            widget.participant.disableCam();
        }),
      ],
    );
  }
}
```

## Events

### `camemaRequested`

This event will be emitted to the `Participant B` when any other `Participant A` requests to enable webcam of that participant (`Participant B`). This event handler will receieve following three arguments in the `Map<String, dynamic>`:

- `accept()` - Callback function to accept the request.
- `reject()` - Callback function to reject the request.
- `participantId` - ParticipantId of the requesting participant

### `micRequested`

This event will be emitted to the `Participant B` when any other `Participant A` requests to enable mic of that participant (`Participant B`). This event handler will receieve following three arguments in the `Map<String, dynamic>`:

- `accept()` - Callback function to accept the request.
- `reject()` - Callback function to reject the request.
- `participantId` - ParticipantId of the requesting participant

###### Usage

```js
import 'package:flutter/material.dart';
import 'package:videosdk/videosdk.dart';

class MeetingScreen extends StatefulWidget {
  ...
}

class _MeetingScreenState extends State<MeetingScreen> {
  late Room room;

  @override
  void initState() {
    //highlight-next-line
    ...

    setupRoomEventListener();
  }

  @override
  Widget build(BuildContext context) {
    return YourMeetingWidget();
  }

  //highlight-start
  void setupRoomEventListener() {
    //Event for mic request
    room.on(Events.micRequested, (_data_) {
      log("_data => $_data");
      dynamic accept = _data['accept'];
      dynamic reject = _data['reject'];

      log("accept => $accept reject => $reject");

      // Mic Request Dialog
      showDialog(
        context: navigatorKey.currentContext!,
        builder: (context) => AlertDialog(
          title: const Text("Mic requested?"),
          content: const Text("Do you want to turn on your mic? "),
          actions: [
            TextButton(
              onPressed: () {
                reject();

                Navigator.of(context).pop();
              },
              child: const Text("Reject"),
            ),
            TextButton(
              onPressed: () {
                accept();

                Navigator.of(context).pop();
              },
              child: const Text("Accept"),
            ),
          ],
        ),
      );
    });

    // Called when camera is requested
    room.on(Events.cameraRequested, (_data) {
      log("_data => $_data");
      dynamic accept = _data['accept'];
      dynamic reject = _data['reject'];

      log("accept => $accept reject => $reject");

      // camera Request Dialog
      showDialog(
        context: navigatorKey.currentContext!,
        builder: (context) => AlertDialog(
          title: const Text("Camera requested?"),
          content: const Text("Do you want to turn on your Camera? "),
          actions: [
            TextButton(
              onPressed: () {
                reject();

                Navigator.of(context).pop();
              },
              child: const Text("Reject"),
            ),
            TextButton(
              onPressed: () {
                accept();

                Navigator.of(context).pop();
              },
              child: const Text("Accept"),
            ),
          ],
        ),
      );
    });
  }
  //highlight-end
}
```

import ReactPlayer from 'react-player'

<div style={{textAlign: 'center'}}>

<ReactPlayer autoplay muted loop playing url='/video/toggle-media.mp4' width={"100%"}/>

</div>

## API Reference

The API references for all the methods and events utilised in this guide are provided below.

- [unmuteMic()](/flutter/api/sdk-reference/participant-class/methods#unmutemic)
- [muteMic()](/flutter/api/sdk-reference/participant-class/methods#mutemic)
- [enableCam()](/flutter/api/sdk-reference/participant-class/methods#enablecam)
- [disableCam()](/flutter/api/sdk-reference/participant-class/methods#disablecam)
- [Events.cameraRequested](/flutter/api/sdk-reference/room-class/events#camerarequested)
- [Events.micRequested](/flutter/api/sdk-reference/room-class/events#micrequested)


---

---
title: Remove participant from the meeting - React JS SDK
hide_title: false
hide_table_of_contents: false
description: Remove a participant or a peer from the meeting while it is still in progress. It helps in meeting moderation.
sidebar_label: Remove Participant
pagination_label: Remove Participant
keywords:
  - remove participant
  - block participant
  - react js
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: remove-participant
---

import NoIndex from '../../../../../mdx/\_no-index.mdx';

<NoIndex/>

# Remove Participant - Flutter

This feature in a meeting allows the meeting host or organizer to remove a participant from the meeting. This can be helpful in situations where a participant is causing a disturbance, is behaving inappropriately, or is not following meeting guidelines.

VideoSDK provide three ways to remove participant from meeting.

1. [Using SDK](#1-using-sdk)
2. [Using VideoSDK Dashboard](#2-using-videosdk-dashboard)
3. [Using Rest API](#3-using-rest-api)

## 1. Using SDK

### `remove()`

Remove participant allows removing participant while session is on-going. This can be helpful when moderation in particular meeting is required.

```js
import 'package:flutter/material.dart';
import 'package:videosdk/videosdk.dart';

class ParticipantTile extends StatefulWidget {
  final Participant participant;
  const ParticipantTile({super.key, required this.participant});

  @override
  State<ParticipantTile> createState() => _ParticipantTileState();
}

class _ParticipantTileState extends State<ParticipantTile> {

  @override
  Widget build(BuildContext context) {
    return ElevatedButton(
      child: Text("Remove ${widget.participant.displayName}"),
      onPressed: () => {
        widget.participant.remove();
    });
  }
}
```

### Events associated with remove

Following callbacks are received when a participant is removed from the meeting.

- Participant who was removed from the meeting will receive a callback on[`roomLeft`](/flutter/api/sdk-reference/room-class/events#roomleft) on `Room` object.
- All other [remote participants](../concept-and-architecture#2-participant) will receive a callback [`participantLeft`](/flutter/api/sdk-reference/room-class/events#participantleft) with `participantId`.

## 2. Using VideoSDK Dashboard

- You can go the session page on [VideoSDK Dashboard](https://app.videosdk.live/meetings/sessions) and select the meeting you can to remove a participant from.
- And then from the participants list you can remove any participant you want.

import ReactPlayer from 'react-player'

<div style={{textAlign: 'center'}}>

<ReactPlayer autoplay muted loop playing url='/video/kickout-user.mp4' width={"100%"}/>

</div>

## 3. Using Rest API

- You can also remove the particular participant from the meeting [using the REST API](/api-reference/realtime-communication/remove-participant).
- To use this method, you should have the `sessionId` of the meeting and `participantId` of the participant who is supposed to be removed.

## API Reference

The API references for all the methods and events utilised in this guide are provided below.

- [remove()](/flutter/api/sdk-reference/participant-class/methods#remove)
- [Events.roomLeft](/flutter/api/sdk-reference/room-class/events#roomleft)
- [Events.participantLeft](/flutter/api/sdk-reference/room-class/events#participantleft)


---

---
title: Share your Screen Video & Audio Call - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: Share your Screen features quick integrate in Flutter IOS with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Flutter iOS Screen Share
pagination_label: Flutter iOS Screen Share
keywords:
  - Start Screen share
  - Stop Screen share
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: flutter-ios-screen-share
---

import NoIndex from '../../../../../mdx/\_no-index.mdx';

<NoIndex/>

# Share screen - Flutter iOS

iOS requires you to add an Broadcast Upload Extension to capture the screen to the device.

:::note

Flutter iOS screenshare is available from the SDK version 1.0.5 and above and the deployment target for iOS app should be **iOS 14 or newer**
:::

## Create Broadcast Upload Extension in iOS

### Step 1 : Open Target

Open your project with xcode, select **File > New > Target** in menu bar.

![IOS Screen Share](/img/ios-screenshare/step1-xcode.png)

### Step 2 : Select Target

Choose **Broadcast Upload Extension**, and click next.

![IOS Screen Share](/img/ios-screenshare/step2-xcode.png)

### Step 3 : Configure Broadcast Upload Extension

Enter extensions name in **Product Name** field, choose team from dropdown, Uncheck include UI extension field and click finish.

![IOS Screen Share](/img/ios-screenshare/step3-xcode.png)

### Step 4 : Activate Extension scheme

You will be prompted **Activate "Your-Extension-name" scheme?** pop-up, click activate.

![IOS Screen Share](/img/ios-screenshare/step4-xcode.png)

Now, broadcast folder will appear in xcode left side bar.

![IOS Screen Share](/img/ios-screenshare/step5-xcode.png)

### Step 5 : Add External file in Created Extension

Open [videosdk-rtc-flutter-sdk-example](https://github.com/videosdk-live/videosdk-rtc-flutter-sdk-example/tree/main/ios/FlutterBroadcast), Copy `SampleUploader.swift`, `SocketConnection.swift`, `DarwinNotificationCenter.swift`, and `Atomic.swift` files to your extension's folder and make sure they're added to the target.

### Step 6 : Update `SampleHandler.swift` file

Open [SampleHandler.swift](https://github.com/videosdk-live/videosdk-rtc-flutter-sdk-example/blob/main/ios/FlutterBroadcast/SampleHandler.swift) and Copy `SampleHandler.swift` file content and paste it to your extensions `SampleHandler.swift` file.

### Step 7 : Add Capability in App

In Xcode, go to **YourappName > Signing & Capabilities**. and click on **+Capability** to configure app group.

![IOS Screen Share](/img/ios-screenshare/step8-xcode.png)

Select **App Groups** from list

![IOS Screen Share](/img/ios-screenshare/step9-xcode.png)

After that, you have to select or add generated app group id which you have created before.

![IOS Screen Share](/img/ios-screenshare/step10-xcode.png)

### Step 8 : Add Capability in Extension

Go to **Your-Extension-Name > Signing & Capabilities** and configure **App Group** functionality which we had perform in previous steps. (Group id should be same for both targets)

![IOS Screen Share](/img/ios-screenshare/step11-xcode.png)

### Step 9 : Add App Group Id in Extension File

Go to extensions `SampleHandler.swift` file and paste your group Id in `appGroupIdentifier` constant.

![IOS Screen Share](/img/ios-screenshare/step12-xcode.png)

### Step 10 : Update App level info.plist file

1.  Add a new key **RTCScreenSharingExtension** in Info.plist with the extension's Bundle Identifier as the value.
2.  Add a new key **RTCAppGroupIdentifier** in Info.plist with the extension's App groups Id as the value.

**Note** : For extension's Bundle Identifier, go to **TARGETS > Your-Extension-Name > Signing & Capabilities** .

![IOS Screen Share](/img/ios-screenshare/step13-xcode.png)

:::note

You can also check out extension [example code](https://github.com/videosdk-live/videosdk-rtc-flutter-sdk-example/tree/main/ios/FlutterBroadcast) on github
:::

## Enable Screen Share

- In order to start screen-sharing just call `room.enableScreenShare()` method.

```js
ElevatedButton(
    child: Text("Start ScreenSharing"),
    onPressed: () {
        room.enableScreenShare();
    },
),
```

![IOS Screen Share](/img/ios-screenshare/step23-xcode.png)

After clicking **Start Broadcast** button, we wiil be able to get the screen stream in session.

## Disable Screen Share

By using `room.disableScreenShare()` function, a participant can stop publishing screen stream to other participants.

```js
ElevatedButton(
    child: Text("Stop ScreenSharing"),
    onPressed: () {
        room.disableScreenShare();
    },
),
```


---

---
title: Camera Controls Video & Audio Call - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: Camera Controls features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Camera Controls
pagination_label: Camera Controls
keywords:
  - Camera on
  - Camera off
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: camera-controls
---

import NoIndex from '../../../../../mdx/\_no-index.mdx';

<NoIndex/>

# Camera Controls - Flutter

Whenever any participant wants to start/stop broadcasting their video to other participant in a room, they can simply do it with VideoSDK Room.

This guide will provide an overview of how to implement enable, disable and switch camera features in a room.

1. **Enable Camera** - By using `enableCam()` function, a participant can publish camera stream to other participants.
2. **Disable Camera** - By using `disableCam()` function, a participant can stop publishing camera stream to other participants.
3. **Switch Camera** - By using `changeCam()` function, a participant can stream from front / rear camera during the room.This function is only applicable for Mobile devices.

### Enable, Disable And Switch Camera

```js
ElevatedButton(
  onPressed: room.disableCam,
  child: Text("disable camera"),
),
ElevatedButton(
  onPressed: room.enableCam,
  child: Text("enable camera"),
),
ElevatedButton(
  onPressed:  () {
    room.changeCam("<device-id>")
  },
  child: Text("changeCam"),
),
```

### Events

**Events associated with `enableWebcam()`:**

- [`streamEnabled`](/flutter/1.0.x/api/sdk-reference/participant-class/events#streamenabled) event will be emitted with [`stream`](../../../api/sdk-reference/stream-class/introduction.md) object from the event callback, inside that [participant](../../../api/sdk-reference/participant-class/introduction.md) object.

**Events associated with `disableWebcam()`:**

- [`streamDisabled`](/flutter/1.0.x/api/sdk-reference/participant-class/events#streamdisabled) event will be emitted with [`stream`](../../../api/sdk-reference/stream-class/introduction.md) object from the event callback, inside that [participant](../../../api/sdk-reference/participant-class/introduction.md) object.

```js
participant.on(Events.streamEnabled, (Stream stream){
  if (stream.kind === "video") {
    //particiapnt turned on video
    //Render Participant video logic here
  }
});
participant.on(Events.streamDisabled, (Stream stream){
  if (stream.kind === "video") {
    //particiapnt turned off video
    //remove Participant video logic here
  }
});
```


---

---
title: Custom Participant ID - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: Custom participant id features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Custom Participant ID
pagination_label: Custom Participant ID
keywords:
  - custom participant id
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: custom-participant-id
---

import NoIndex from '../../../../../mdx/\_no-index.mdx';

<NoIndex/>

# Custom Participant ID - Flutter

- Whenever any participant joins room, it is assigned a new unique participant id every time.

- To assign an unique participant id manually to local participant, specify participant id while creating Room using `createRoom()` method.

```js
createRoom(
    .
    .
    participantId: "abcd-efgh-ijkl", // custom participant id
),
```


---

---
title: Custom Audio Track
hide_title: false
hide_table_of_contents: false
description: Custom Audio Track features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Custom Audio Track
pagination_label: Custom Audio Track
keywords:
  - Camera on
  - Camera off
  - Webcam on
  - Webcam off
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
---

import NoIndex from '../../../../../../mdx/\_no-index.mdx';

<NoIndex/>

# Custom Audio Track - Flutter

We have introduced the ability to pass a custom Audio track for the Audio of the participants. This feature can be used to add custom layers like background noise removal, echo cancellation, etc. on audio and send it to other participants.

## Creating a Custom Audio Track

- You can create a Audio Track using `createMicrophoneAudioTrack()` method of `VideoSDK` class.
- This method can be used to create audio track using different encoding parameters and noise cancellation configuration.

### Parameters

- **microphoneId**:

  - type: `String`
  - required: `false`
  - It will be the id of the mic from which the audio should be captured.

- **encoderConfig**:

  - type: `CustomTrackAudioConfig`
  - required: `false`
  - default: `speech_standard`
  - Allowed values : `speech_low_quality` | `speech_standard` | `music_standard` | `standard_stereo` | `high_quality` | `high_quality_stereo`
  - It will be the encoder configuration you want to use for Audio Track.

- **noiseConfig**

  - **echoCancellation**

    - type: `boolean`
    - required: `false`
    - If `true` echo cancellation will turned on else it would be turned off.

  - **autoGainControl**

    - type: `boolean`
    - required: `false`
    - If `true` auto gain will turned on else it would be turned off.

  - **noiseSuppression**
    - type: `boolean`
    - required: `false`
    - If `true` noise suppression will turned on else it would be turned off.

#### Returns

- `Future<CustomTrack>`

### Example

```javascript
CustomTrack audioTrack = await VideoSDK.createMicrophoneAudioTrack(
        encoderConfig: CustomAudioTrackConfig.high_quality);
```

## Using Custom Audio Track

### Custom Track while initializing the meeting

If you are passing `micEnabled: true` in the `createRoom` and want to use custom tracks from start of the meeting, you can pass custom track in the `createRoom` as shown below.

```javascript
CustomTrack audioTrack = await VideoSDK.createMicrophoneAudioTrack(
        encoderConfig: CustomAudioTrackConfig.high_quality);

Room room = VideoSDK.createRoom(
      roomId: widget.meetingId,
      token: widget.token,
      displayName: widget.displayName,
      micEnabled: widget.micEnabled,
      camEnabled: widget.camEnabled,
      maxResolution: 'hd',
      defaultCameraIndex: 1,
      multiStream: false,

      // Pass the custom track here
      customMicrophoneAudioTrack: audioTrack, // custom audio track :: optional
      notification: const NotificationInfo(
        title: "Video SDK",
        message: "Video SDK is sharing screen in the meeting",
        icon: "notification_share", // drawable icon name
      ),
    );
```

### Custom Track with `unmuteMic()`

In order to switch tracks during the meeting, you have to pass the `CustomTrack` in the `room.unmuteMic()` method.

:::note

Make sure to call `muteMic()` before you create a new track as it may lead to unexpected behavior.

:::

```javascript
CustomTrack audioTrack = await VideoSDK.createMicrophoneAudioTrack(
        encoderConfig: CustomAudioTrackConfig.high_quality);

room.unmuteMic(customTrack);
```


---

---
title: Custom Video Track
hide_title: false
hide_table_of_contents: false
description: Custom Video Track features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Custom Video Track
pagination_label: Custom Video Track
keywords:
  - Camera on
  - Camera off
  - Webcam on
  - Webcam off
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
---

import NoIndex from '../../../../../../mdx/\_no-index.mdx';

<NoIndex/>

# Custom Video Track - Flutter

We have introduced the ability to pass a custom video track for the video of the participants. This feature can be used to add custom video encoder config, and background removal & video filter from external SDK(e.g., [Banuba](https://www.banuba.com/)) and send it to other participants.

## Creating a Custom Video Track

- You can create a Video Track using `createCameraVideoTrack()` method of `VideoSDK` class.
- This method can be used to create video track using different encoding parameters, camera facing mode, and optimization mode.

### Parameters

- **cameraId**:

  - type: `String`
  - required: `false`
  - It will be the id of the camera from which the video should be captured.

- **encoderConfig**:

  - type: `CustomVideoTrackConfig`
  - required: `false`
  - default: `h360p_w640p`
  - Allowed values : `h90p_w160p` | `h180p_w320p` | `h216p_w384p` | `h360p_w640p` | `h540p_w960p` | `h720p_w1280p` | `h1080p_w1920p` | `h1440p_w2560p` | `h2160p_w3840p` | `h120p_w160p` | `h180p_w240p` | `h240p_w320p` | `h360p_w480p` | `h480p_w640p` | `h540p_w720p` | `h720p_w960p` | `h1080p_w1440p` | `h1440p_w1920p`
  - It will be the encoderConfigs you can want to use for the Video Track.

:::note

Above mentioned encoder configurations are valid for both, landscape as well as portrait mode.

:::

- **facingMode**:

  - type: `String`
  - required: `false`
  - Allowed values : `user` | `environment`
  - It will specify whether to use front or back camera for the video track.

- **multiStream**

  - type: `boolean`
  - required: `false`
  - default: true
  - It will specify if the stream should send multiple resolution layers or single resolution layer.

  :::info

  - For meetings with fewer than or equal to four participants, setting `multiStream:false` is regarded as best practice.
  - This parameter is only available from `v1.0.9`.

  :::

#### Returns

- `Future<CustomTrack>`

### Example

```javascript
CustomTrack videoTrack = await VideoSDK.createCameraVideoTrack(
      encoderConfig: CustomVideoTrackConfig.h1440p_w1920p,
      multiStream: false,
      facingMode:"user",
    );
```

## Using Custom Video Track

### Custom Track while initializing the meeting

If you are passing `webcamEnabled: true` in the `createRoom` and want to use custom tracks from start of the meeting, you can pass custom track in the `createRoom` params as shown below.

```javascript
CustomTrack videoTrack = await VideoSDK.createCameraVideoTrack(
      encoderConfig: CustomVideoTrackConfig.h1440p_w1920p,
      multiStream: false,
      facingMode:"user",
    );

Room room = VideoSDK.createRoom(
      roomId: widget.meetingId,
      token: widget.token,
      displayName: widget.displayName,
      micEnabled: widget.micEnabled,
      camEnabled: widget.camEnabled,
      maxResolution: 'hd',
      defaultCameraIndex: 1,
      multiStream: false,

      // Pass the custom track here
      customCameraVideoTrack: videoTrack, // custom video track :: optional
      notification: const NotificationInfo(
        title: "Video SDK",
        message: "Video SDK is sharing screen in the meeting",
        icon: "notification_share", // drawable icon name
      ),
    );
```

### Custom Track with `enableCam()`

In order to switch tracks during the meeting, you have to pass the `CustomTrack` in the `room.enableCam()` method.

:::note

Make sure to call `disableCam()` before you create a new track as it may lead to unexpected behavior.

:::

```javascript
CustomTrack track = await VideoSDK.createCameraVideoTrack(
  facingMode: "environment",
  encoderConfig: CustomVideoTrackConfig.h1440p_w1920p,
  multiStream: true,
);
room.enableCam(track);
```


---

---
title: Entry - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: Entry features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Entry Request-Response
pagination_label: Entry Request-Response
keywords:
  - entry request response
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: entry-request-response
---

import NoIndex from '../../../../../mdx/\_no-index.mdx';

<NoIndex/>

# Entry Request-Response - Flutter

- When anyone joins room, he/she will request for joining room and that request will get either accepted or denied by host.

## Entry Request

- When anyone asks for joining in your room, `Events.entryRequested` event is triggered with data having

  - `participantId` - This is the Id of participant, who have requested for joining room
  - `name` - This is the name of the participant.
  - `allow()` - Call this method if you want to allow that participant
  - `deny()` - Call this method if you want to deny that participant

```js
room.on(Events.entryRequested, (data) {
  var participantId = data['participantId'];
  var name = data["name"];
  var allow = data["allow"];
  var deny = data["deny"];

  showDialog(
    context: context,
    builder: (context) => AlertDialog(
      title: const Text("Join Request"),
      content: Text("Do you want to allow $name to join room?"),
      actions: [
        TextButton(
          child: const Text("Deny"),
          onPressed: () {
            deny();
            Navigator.of(context).pop();
          },
        ),
        TextButton(
          child: const Text("Allow"),
          onPressed: () {
            allow();
            Navigator.of(context).pop();
          },
        ),
      ],
    ),
  );
});
```

## Entry Respond

- If you have requested for joining room, `Events.entryResponded` is triggered when host accept or deny room.

  - `decision` - This will tell you, if you are allowed to join or not

```js
room.on(Events.entryResponded, (data) {
  var decision = data['decision'];
  if (id == room.localParticipant.id) {
    if (decision == 'allowed') {
      print("Allowed to join the room.");
    } else {
      print("Denied to join the room.");
    }
  }
});
```


---

---
sidebar_label: Error Event
pagination_label: Error Event
---

import NoIndex from '../../../../../mdx/\_no-index.mdx';

<NoIndex/>

# Error Event - Flutter

This event is helpful for development level troubleshooting while integrating SDK.

Whenever any invalid configuration provided or server/network errors arise, this event will trigger with a specific error code and message.

This event can ease your development process.

We have depicted a specific error name with code and message in the below table.

| Error Name                            | Code | Message                                                                                                                     |
| ------------------------------------- | ---- | --------------------------------------------------------------------------------------------------------------------------- |
| **INVALID_API_KEY**                   | 4001 | `apikey` provided in the token is empty or invalid, please verify it on the dashboard.                                      |
| **INVALID_TOKEN**                     | 4002 | `token` is empty or invalid or might have expired.                                                                          |
| **INVALID_MEETING_ID**                | 4003 | `meetingId` is empty or invalid, please verify it or generate new meetingId using the API.                                  |
| **INVALID_PARTICIPANT_ID**            | 4004 | `participantId` is empty or invalid, it shouldn't contain any whitespaces.                                                  |
| **DUPLICATE_PARTICIPANT**             | 4005 | Leaving meeting, since this `participantId` joined from another device.                                                     |
| **ACCOUNT_DEACTIVATED**               | 4006 | It seems your account is deactivated by VideoSDK for some reason, you can reach out to us at `support@videosdk.live`.       |
| **ACCOUNT_DISCONTINUED**              | 4007 | _Server will respond you with specific message._                                                                            |
| **INVALID_PERMISSIONS**               | 4008 | `permissions` provided in the token are invalid, please don't use `allow_join` or `allow_mod` with `ask_join`.              |
| **MAX_PARTICIPANT_REACHED**           | 4009 | You have reached max participant limit in a meeting to increase contact at support@videosdk.live :)                          |
| **MAX_PARTICIPANT_REACHED**            | 4009 | You have reached max participant limit in a meeting.                                                                         |
| **MAX_SPEAKER_REACHED**               | 4010 | You have reached max speaker limit in a meeting.                                                                            |
| **START_RECORDING_FAILED**            | 4011 | Recording start request failed due to an unknown error.                                                                     |
| **STOP_RECORDING_FAILED**             | 4012 | Recording stop request failed due to an unknown error.                                                                      |
| **START_LIVESTREAM_FAILED**           | 4013 | Livestream start request failed due to an unknown error.                                                                    |
| **STOP_LIVESTREAM_FAILED**            | 4014 | Livestream stop request failed due to an unknown error.                                                                     |
| **INVALID_LIVESTREAM_CONFIG**         | 4015 | Livestream 'outputs' configuration provided was invalid.                                                                    |
| **START_HLS_FAILED**                  | 4016 | HLS start request failed due to an unknown error.                                                                           |
| **STOP_HLS_FAILED**                   | 4017 | HLS stop request failed due to an unknown error.                                                                            |
| **PREV_RECORDING_PROCESSING**         | 4018 | Previous recording session is being processed, please try again after few seconds!                                          |
| **PREV_RTMP_RECORDING_PROCESSING**    | 4019 | Previous RTMP recording session is being processed, please try again after few seconds!                                     |
| **PREV_HLS_STREAMING_PROCESSING**     | 4020 | Previous HLS streaming session is being processed, please try again after few seconds!                                      |
| **MAX_SPEAKER_LIMIT_REACHED_ON_ORGANIZATION**    | 4026 | You have reached max speaker limit on organization. To increase contact at support@videosdk.live".                                                               |
| **MAX_VIEWER_LIMIT_REACHED_ON_ORGANIZATION**    | 4027 | You have reached max viewer limit on organization. To increase contact at support@videosdk.live".                                                               |
| **MAX_RECORDING_LIMIT_REACHED_ON_ORGANIZATION**    | 4028 | You have reached max limit of recording on organization. To increase contact at support@videosdk.live.                                                               |
| **MAX_HLS_LIMIT_REACHED_ON_ORGANIZATION**    | 4029 | You have reached max limit of hls on organization. To increase contact at support@videosdk.live.                                                               |
| **MAX_LIVESTREAM_LIMIT_REACHED_ON_ORGANIZATION**    | 4030 | You have reached max limit of livestream on organization. To increase contact at support@videosdk.live.                                                               |
| **RECORDING_FAILED**                  | 5001 | Recording stopped due to an unknown error.                                                                                  |
| **LIVESTREAM_FAILED**                 | 5002 | Livestream stopped due to an unknown error.                                                                                 |
| **HLS_FAILED**                        | 5003 | HLS stopped due to an unknown error.                                                                                        |
| **RECORDING_DURATION_LIMIT_REACHED**  | 5004 | Recording has been automatically stopped by the system, due to max duration limit of 2 hours reached for a single Recording |
| **LIVESTREAM_DURATION_LIMIT_REACHED** | 5005 | Livestream has been automatically stopped by the system, due to max duration limit of 2 hours reached for a single RTMP     |
| **HLS_DURATION_LIMIT_REACHED**        | 5006 | Hls has been automatically stopped by the system, due to max duration limit of 2 hours reached for a single HLS             |
| **ERROR_STARTING_VIDEO**              | 3011 | Some error occured during starting the video                                                                                |
| **ERROR_STARTING_AUDIO**              | 3012 | Some error occured during starting the audio.                                                                               |
| **ERROR_STARTING_SCREENSHARE**        | 3013 | Some error occured during starting the screen share.                                                                        |

### Event Code

You can get all the error codes from `VideoSDKErrors` which is a `Map<int, Map<String, String>>` containing all the errors.

```js

//add listener for the error events.
_meeting.on(Events.error, (error) {
  log("VIDEOSDK ERROR :: " +
      error['code'].toString() +
      "  :: " +
      error['name'].toString() +
      " :: " +
      error['message'].toString());
});
```


---

---
title: RTMP Live Social Media Video & Audio Call - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: RTMP Live Social Media features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Go Live On Social Media
pagination_label: Go Live On Social Media
keywords:
  - Facebook Live
  - Youtube Live
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: go-live-social-media
---

import NoIndex from '../../../../../mdx/\_no-index.mdx';

<NoIndex/>

# Go Live On Social Media - Flutter

This feature allows participant to broadcast room on various social media platforms such as Facebook or Youtube.
This guide will provide an overview of how participant can start and stop broadcasting room.

1. **Start LiveStream** - By using `startLivestream()` function, a participant can start broadcasting room on various platforms by provding url and stream keys as an argument.

### Parameters

- **outputs**

  - type: `Array`
  - required: `true`
  - It will the array of object containing the url and stream keys.

- **config**:
  - type: `Object`
    - **config**:
      - **layout**:
        - **type**: _"GRID"_ | _"SPOTLIGHT"_ | _"SIDEBAR"_
        - **priority**: _"SPEAKER"_ | _"PIN"_
        - **gridSize**: Number _\`max 4\`_
      - **theme**: _"DARK"_ | _"LIGHT"_ | _"DEFAULT"_
  - required: `false`
  - It will be config for the layout of the recording you can to use.

2. **Stop LiveStream** - By using `stopLivestream()` function, a participant can stop broadcasting on all platforms.

### Start And Stop Live Stream

```js
// Start Live Stream
room.startLivestream([
  {
    url: "rtmp://a.rtmp.youtube.com/live2",
    streamKey: "streamKey1",
  },
], config: {
  'layout': {
    'type': 'GRID',
    'priority': 'SPEAKER',
    'gridSize': 4,
  },
  'theme': "LIGHT",
});

// Stop Live Stream
room?.stopLivestream();
```

### Events

1. **livestreamStateChanged** - Whenever broadcasting of meeting started / stopped, `livestreamStateChanged` event will trigger.

```js
room.on(Events.liveStreamStateChanged, (String status) {

  //Status can have values:
  // LIVESTREAM_STARTING -- Live Stream is starting
  // LIVESTREAM_STARTED -- Live Stream has started
  // LIVESTREAM_STOPPING -- Live Stream is stopping
  // LIVESTREAM_STOPPED -- Live Stream has stopped

  toastMsg("Meeting live streaming status : $status");
});
```


---

---
title: Leave End Room Video & Audio Call - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: Leave or End Room features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Leave or End Room
pagination_label: Leave or End Room
keywords:
  - Exit Room
  - Leave Room
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: leave-end-room
---

import NoIndex from '../../../../../mdx/\_no-index.mdx';

<NoIndex/>

# Leave or End Room - Flutter

Whenever participant wishes to end their communication in the room, they can simply leave the room.

This guide will provide an overview of how to implement leave or end feature in VideoSDK rooms.

1. **Leave** - By using `leave()` function, only a participant will leave/exit the room, the rest of the room will continue with other participants.
2. **End** - By using `end()` function, room will end for each and every participant. So, use this function according to your use cases.

### Leave And End Room

```js
// Leave the room
room.leave();

// End Room Session
room.end();
```

### Events

**Events associated with `leave()`:**

- Local participant will receive a [`roomLeft`](/flutter/1.0.x/api/sdk-reference/room-class/events#roomleft) event.
- All remote participants will receive a [`participantLeft`](/flutter/1.0.x/api/sdk-reference/room-class/events#participantleft) event with `participantId`.

**Event associated with `end()`:**

- All [participants](../../../api/sdk-reference/participant-class/introduction.md) and [localParticipant](../../../api/sdk-reference/participant-class/introduction.md), will be emitted with [`roomLeft`](/flutter/1.0.x/api/sdk-reference/room-class/events#roomleft) event.

```js
room.on(Events.roomLeft, () => {
  //room Left
});

room.on(Events.participantLeft, (participant) => {
  //Participant Left the room
});
```


---

---
title: Manage Participants Video & Audio Call - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: Manage Participants features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Manage Participants
pagination_label: Manage Participants
keywords:
  - Exit Room
  - Leave Room
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: manage-participants
---

import NoIndex from '../../../../../mdx/\_no-index.mdx';

<NoIndex/>

# Manage Participants - Flutter

## 1. Local Participant (self)

Local participant is used to consume your video & audio streams.
it contains information about local participant such as displayName, id, quality and streams Map.

You can access localParticipant from the [room object](./start-join-room#2-initialization).

### Participant object properties

| Property Name | Type          | Description                                         |
| ------------- | ------------- | --------------------------------------------------- |
| id            | string        | Unique id of the participant.                       |
| displayName   | string        | The name you define during the room initialization. |
| local         | boolean       | Indicates the participant is local or not.          |
| quality       | string        | Indicates the participant streams quality.          |
| Streams       | Map of Stream | Returns Video & Audio Streams.                      |

### Stream Object properties

| Property Name | Type   | Description        |
| ------------- | ------ | ------------------ |
| id            | string | Unique id          |
| codec         | string | Video/Audio codec. |
| kind          | string | Stream Kind.       |
| track         | string | MediaStreamTrack   |

## 2. Other Participants (Except You)

Other participants Map is used to get all the participants (except you) in the room at any given time.

Other participants Map contains same properties as [LocalParticipant](/flutter/1.0.x/guide/video-and-audio-calling-api-sdk/features/manage-participants#participant-object-properties).

### ParticipantTile

```js title=participant_tile.dart
import 'package:flutter/material.dart';
import 'package:videosdk/videosdk.dart';
import '../../utils/toast.dart';

class ParticipantTile extends StatefulWidget {
  final Participant participant;
  final bool isLocalParticipant;
  const ParticipantTile({
    Key? key,
    required this.participant,
    this.isLocalParticipant = false,
    }): super(key: key);

  @override
  State<ParticipantTile> createState() => _ParticipantTileState();
}

class _ParticipantTileState extends State<ParticipantTile> {
  Stream? shareStream;
  Stream? videoStream;
  Stream? audioStream;
  String? quality;

  @override
  void initState() {
    _initStreamListeners();
    super.initState();
  }

  @override
  Widget build(BuildContext context) {
    return Container(
        margin: const EdgeInsets.all(4.0),
        decoration: BoxDecoration(
          color: Theme.of(context).backgroundColor.withOpacity(1),
          border: Border.all(color: Colors.white38),
        ),
        child: AspectRatio(
          aspectRatio: 1,
          child: Padding(
            padding: const EdgeInsets.all(4.0),
            child: Stack(
              children: [
                videoStream != null
                    ? RTCVideoView(
                        videoStream?.renderer as RTCVideoRenderer,
                        objectFit:
                            RTCVideoViewObjectFit.RTCVideoViewObjectFitCover,
                      )
                    : const Center(
                        child: Icon(
                          Icons.person,
                          size: 180.0,
                          color: Color.fromARGB(140, 255, 255, 255),
                        ),
                      ),
                Positioned(
                  bottom: 0,
                  left: 0,
                  child: FittedBox(
                    fit: BoxFit.scaleDown,
                    child: Container(
                      padding: const EdgeInsets.all(2.0),
                      decoration: BoxDecoration(
                        color: Theme.of(context).backgroundColor.withOpacity(0.2),
                        border: Border.all(color: Colors.white24),
                        borderRadius: BorderRadius.circular(4.0),
                      ),
                      child: Text(
                        widget.participant.displayName,
                        textAlign: TextAlign.center,
                        style: const TextStyle(
                          color: Colors.white,
                          fontSize: 10.0,
                        ),
                      ),
                    ),
                  ),
                ),
                Positioned(
                  top: 0,
                  left: 0,
                  child: InkWell(
                    child: Container(
                      padding: const EdgeInsets.all(4),
                      decoration: BoxDecoration(
                        shape: BoxShape.circle,
                        color: audioStream != null
                            ? Theme.of(context).backgroundColor
                            : Colors.red,
                      ),
                      child: Icon(
                        audioStream != null ? Icons.mic : Icons.mic_off,
                        size: 16,
                      ),
                    ),
                    onTap: widget.isLocalParticipant
                        ? null
                        : () => audioStream != null
                              ? widget.participant.unmuteMic()
                              : widget.participant.muteMic(),
                  ),
                ),
                Positioned(
                  top: 0,
                  right: 0,
                  child: InkWell(
                    child: Container(
                      padding: const EdgeInsets.all(4),
                      decoration: BoxDecoration(
                        shape: BoxShape.circle,
                        color: videoStream != null
                            ? Theme.of(context).backgroundColor
                            : Colors.red,
                      ),
                      child: Icon(
                        videoStream != null
                            ? Icons.videocam
                            : Icons.videocam_off,
                        size: 16,
                      ),
                    ),
                    onTap: widget.isLocalParticipant
                        ? null
                        : () => videoStream != null
                                  ? widget.participant.disableCam()
                                  : widget.participant.enableCam(),
                  ),
                ),
                if (!widget.isLocalParticipant)
                  Positioned(
                    bottom: 0,
                    right: 0,
                    child: InkWell(
                      child: Container(
                        padding: const EdgeInsets.all(4),
                        decoration: const BoxDecoration(
                          shape: BoxShape.circle,
                          color: Colors.red,
                        ),
                        child: const Icon(
                          Icons.logout,
                          size: 16,
                        ),
                      ),
                      onTap: () {
                        showDialog(
                            context: context,
                            builder: (context) => AlertDialog(
                                  title: const Text("Are you sure ?"),
                                  actions: [
                                    TextButton(
                                      child: const Text("Yes"),
                                      onPressed: () {
                                        widget.participant.remove();
                                        toastMsg("Participant removed");
                                        Navigator.of(context).pop();
                                      },
                                    ),
                                    TextButton(
                                      child: const Text("No"),
                                      onPressed: () => Navigator.of(context).pop(),
                                    )
                                  ],
                                ));
                      },
                    ),
                  ),
              ],
            ),
          ),
        ),
    );
  }

  _initStreamListeners() {
    widget.participant.on(Events.streamEnabled, (Stream _stream) {
      setState(() {
        if (_stream.kind == 'video') {
          videoStream = _stream;
        } else if (_stream.kind == 'audio') {
          audioStream = _stream;
        } else if (_stream.kind == 'share') {
          shareStream = _stream;
        }
      });
    });

    widget.participant.on(Events.streamDisabled, (Stream _stream) {
      setState(() {
        if (_stream.kind == 'video' && videoStream?.id == _stream.id) {
          videoStream = null;
        } else if (_stream.kind == 'audio' && audioStream?.id == _stream.id) {
          audioStream = null;
        } else if (_stream.kind == 'share' && shareStream?.id == _stream.id) {
          shareStream = null;
        }
      });
    });
  }
}
```

```js title=participant_grid_view.dart
import 'dart:developer';
import 'package:flutter/material.dart';
import 'package:videosdk/videosdk.dart';
import 'participant_tile.dart';

class ParticipantGridView extends StatefulWidget {
  final Room room;
  const ParticipantGridView({
    Key? key,
    required this.room,
  }) : super(key: key);

  @override
  State<ParticipantGridView> createState() => _ParticipantGridViewState();
}

class _ParticipantGridViewState extends State<ParticipantGridView> {
  String? activeSpeakerId;
  Participant? localParticipant;
  Map<String, Participant> participants = {};

  @override
  void initState() {
    // Initialize participants
    localParticipant = widget.room.localParticipant;
    participants = widget.room.participants;

    // Setting room event listeners
    setRoomListeners(widget.room);
    super.initState();
  }

  @override
  Widget build(BuildContext context) {
    return GridView.count(
      crossAxisCount: 2,
      children: [
        ParticipantTile(
          participant: localParticipant!,
          isLocalParticipant: true,
        ),
        ...participants.values
            .map((participant) => ParticipantTile(participant: participant))
            .toList()
      ],
    );
  }

  void setRoomListeners(Room _room_) {
    // Called when participant joined room
    _room.on(
      Events.participantJoined,
      (Participant participant) {
        final newParticipants = participants;
        newParticipants[participant.id] = participant;
        setState(() {
          participants = newParticipants;
        });
      },
    );

    // Called when participant left room
    _room.on(
      Events.participantLeft,
      (participantId) {
        final newParticipants = participants;

        newParticipants.remove(participantId);
        setState(() {
          participants = newParticipants;
        });
      },
    );

    // Called when speaker is changed
    _room.on(Events.speakerChanged, (_activeSpeakerId) {
      setState(() {
        activeSpeakerId = _activeSpeakerId;
      });
    });
  }
}
```

## 3. Participant Related Events

1. **participantJoined** - Whenever any new participant join the room, `participantJoined` event will trigger. For example, the room is running with **Alice** and **Bob**, then **Eve** join that room, after that `participantJoined` event trigger and return the [participant object](/flutter/guide/video-and-audio-calling-api-sdk/features/manage-participants#participant-object-properties).

2. **participantLeft** - Whenever any participant leave/exit the room, `participantLeft` event will trigger.For example, the room is running with **Alice** and **Bob**, then **Bob** leave that room, after that `participantLeft` event trigger and return the [participant object](/flutter/guide/video-and-audio-calling-api-sdk/features/manage-participants#participant-object-properties)

3. **speakerChanged** - Whenever any participant starts actively speaking in room, `speakerChanged` event will trigger and return the speaker `participantId`.

4. **presenterChanged** - Whenever any participant present/screenshare their screen/window in room, `presenterChanged` event will trigger and return the presenter `participantId`.

5. **streamEnabled** - Whenever any participant enabled mic/camera in room, `streamEnabled` event will trigger and return `Stream`.

6. **streamDisabled** - Whenever any participant disabled mic/camera in room, `streamDisabled` event will trigger and return `Stream`.

```js
// Adding event listner
room.on(Events.participantJoined, (Participant participant) {
  print("new participant => $participant");
  },
);

room.on(Events.participantLeft, (Participant participant) {
  print("new participant => $participant");
  },
);

room.on(Events.presenterChanged, (activePresenterId) {
  print("presenter changed => $activePresenterId");
  },
);
```


---

---
title: Mic Controls Video & Audio Call - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: Mic Controls features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Mic Controls
pagination_label: Mic Controls
keywords:
  - Mic on
  - Mic off
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: mic-controls
---

import NoIndex from '../../../../../mdx/\_no-index.mdx';

<NoIndex/>

# Mic Controls - Flutter

Whenever any participant wants to start / stop broadcasting their audio to other participant in room, they can simply do it with VideoSDK room.

This guide will provide an overview of how to use enable and disable Mic in a room.

1. **Enable Mic** - By using `unmuteMic()` function, a participant can publish audio to other participants.
2. **Disable Mic** - By using `muteMic()` function, a participant can stop publishing audio to other participants.
3. **Change Mic** - By using `changeMic()` function, a participant can change mic.

### Enable, Disable, Change Mic

```js
ElevatedButton(
  onPressed: room.unmuteMic,
  child: Text("unmuteMic"),
),
ElevatedButton(
  onPressed: room.muteMic,
  child: Text("muteMic"),
),

// changeMic() method is coming soon in flutter.
```

### Events

**Events associated with `unmuteMic()`:**

- [`streamEnabled`](/flutter/1.0.x/api/sdk-reference/participant-class/events#streamenabled) event will be emitted with [`stream`](../../../api/sdk-reference/stream-class/introduction.md) object from the event callback, inside that [participant](../../../api/sdk-reference/participant-class/introduction.md) object.

**Events associated with `muteMic()`:**

- [`streamDisabled`](/flutter/1.0.x/api/sdk-reference/participant-class/events#streamdisabled) event will be emitted with [`stream`](../../../api/sdk-reference/stream-class/introduction.md) object from the event callback, inside that [participant](../../../api/sdk-reference/participant-class/introduction.md) object.

```js
participant.on(Events.streamEnabled, (Stream stream){
  if (stream.kind === "audio") {
    //particiapnt turned on audio
  }
});
participant.on(Events.streamDisabled, (Stream stream){
  if (stream.kind === "audio") {
    //particiapnt turned off audio
  }
});
```


---

---
title: Pause/Resume Video Stream - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: Pause/Resume Video Stream features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Pause/Resume Video Stream
pagination_label: Pause/Resume Video Stream
keywords:
  - pause/resume video stream
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: pause-resume-video-stream
---

import NoIndex from '../../../../../mdx/\_no-index.mdx';

<NoIndex/>

# Participant Video Stream - Flutter

- Using this feature, you can pause/resume participant's video stream.

## Pause video stream

- `pause()` method is used to pause videostream of a participant.

```js
ElevatedButton(
  child: Text("Pause Video"),
  onPressed: () {
    List<Stream> streams = participant.streams.where((e) => e.kind == 'video').toList();

    if(streams.length != 0){
      Stream videoStream = streams[0];
      videoStream.track.pause();
    }
  }
),
```

## Resume video stream

- `resume()` method is used to resume videostream of a participant.

```js
ElevatedButton(
  child: Text("Resume Video"),
  onPressed: () {
    List<Stream> streams = participant.streams.where((e) => e.kind == 'video').toList();

    if(streams.length != 0){
      Stream videoStream = streams[0];
      videoStream.track.resume();
    }
  }
),

```

## Events

**Event associated with `pause()`:**

- [`streamPaused`](/flutter/1.0.x/api/sdk-reference/participant-class/events#streampaused) event will be emitted with [`stream`](../../../api/sdk-reference/stream-class/introduction.md) object from the event callback, inside that [participant](../../../api/sdk-reference/participant-class/introduction.md) object.

**Event associated with `resume()`:**

- [`streamResumed`](/flutter/1.0.x/api/sdk-reference/participant-class/events#streamresumed) event will be emitted with [`stream`](../../../api/sdk-reference/stream-class/introduction.md) object from the event callback, inside that [participant](../../../api/sdk-reference/participant-class/introduction.md) object.

```js
participant.on(Events.streamPaused, (Stream stream){
  if (stream.kind === "video") {
    //particiapnt video stream paused
  }
});
participant.on(Events.streamResumed, (Stream stream){
  if (stream.kind === "video") {
    //particiapnt video stream resumed
  }
});
```


---

---
sidebar_label: Send Message using PubSub
pagination_label: PubSub
---

import NoIndex from '../../../../../mdx/\_no-index.mdx';

<NoIndex/>

# PubSub - Flutter

PubSub feature allows the participant to send and receive messages of the topics which he has subscribed.

## Methods

### publish()

This method is use for publishing message of specific topic.

#### Syntax

```js
  Future<void> publish(
    String topic,
    String message,
    [PubSubPublishOptions options]
  )
```

| Parameter Name | Type                 | Description                                                                                                                                       |
| -------------- | -------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------- |
| topic          | String               | This should be the topic for which you are publishing a message.                                                                                  |
| message        | String               | This is the actual message, which will be published to participants, who had subscribed to a particular topic.                                    |
| options        | PubSubPublishOptions | This is an object of PubSubPublishOptions, which provides an option, such as `persist`, which persists message history for upcoming participants. |

#### Example

```js
  // publish()
  ElevatedButton(
    onPressed: () async {
      // Publish a message
      await room.pubSub.publish(
        "CHAT", // Topic
        "Hello from Flutter!", // Message Content
        const PubSubPublishOptions(
          "persist": true // Stores the message in server for future participants
        ),
      );

      print("Message published");
    },
    child: Text("Publish"),
  ),
```

<br />

### subscribe()

This method is used to subscribe for particular topic. This method returns a list of messages which were sent earlier.

#### Syntax

```js
  Future<PubSubMessages> subscribe(
    String topic,
    Function(PubSubMessage) messageHandler,
  )
```

| Parameter Name | Type   | Description                                                                 |
| -------------- | ------ | --------------------------------------------------------------------------- |
| topic          | String | This should be the topic to be subscribed.                                  |
| messageHandler | String | This is a handler function, which will be called when new message received. |

#### Example

```js
  // subscribe()
  ElevatedButton(
    onPressed: () async {
      // Subscribe 'CHAT' topic and get persisted messages
      var messages = await room.pubSub.subscribe("CHAT", messageHandler);

      // Printing message list
      print("Messages: ${messages.messages.map((msg) => msg.message).join(" ")}");
    },
    child: Text("Subscribe"),
  ),

  // Message Handler
  void messageHandler(msg){
    // Do something
    print("New message received: $msg");
  }
```

### unsubscribe()

This method is used to unsubscribe the message topic.

#### Syntax

```js
  Future<void> unsubscribe(
    String topic,
    Function(PubSubMessage) messageHandler,
  )
```

| Parameter Name | Type   | Description                                                    |
| -------------- | ------ | -------------------------------------------------------------- |
| topic          | String | This should be the topic to be unsubscribed.                   |
| messageHandler | String | This is a handler function, which was passed in `subscribe()`. |

#### Example

```js
  // unsubscribe
  ElevatedButton(
    onPressed: () {
      // Unsubscribe 'CHAT' topic
      await room.pubSub.unSubscribe("CHAT", messageHandler);
    },
    child: Text("UnSubscribe"),
  ),
```

## Sample Code

```js
import 'package:flutter/material.dart';
import 'package:videosdk/videosdk.dart';

// ChatScreen
class ChatScreen extends StatefulWidget {
  final Room room;
  const ChatScreen({required this.room});

  @override
  _ChatScreenState createState() => _ChatScreenState();
}

class _ChatScreenState extends State<ChatScreen> {
  @override
  void initState() {
    super.initState();

    widget.room.pubSub.subscribe("CHAT", messageHandler)
      .then((messages) =>
          print("Subscribed to chat: ${messages.messages.map((msg) => msg.message).join(" ")}"));
  }

  @override
  Widget build(BuildContext context) {
    final room = widget.room;
    return Scaffold(
      appBar: AppBar(title: const Text("PubSub Sample Code")),
      body: Center(
        child: ElevatedButton(
          child: const Text("Send Hello !"),
          // Publish Hello message
          onPressed: () => room.pubSub.publish(
            "CHAT",
            "Hello",
            const PubSubPublishOptions(persist: true),
          ),
        ),
      ),
    );
  }

  // Handle incoming messages
  void messageHandler(PubSubMessage message) {
    print("New message: ${message.message}");
  }

  @override
  void dispose() {
    // Unsubscribe
    widget.room.pubSub.unsubscribe("CHAT", messageHandler);
    super.dispose();
  }
}

```


---

---
title: Record Room Video & Audio Call - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: Record Room features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Record Room
pagination_label: Record Room
keywords:
  - Start Recording Room
  - Stop Recording Room
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: recording-room
---

import NoIndex from '../../../../../mdx/\_no-index.mdx';

<NoIndex/>

# Record Room - Flutter

Record room allows participants to record video & audio during the room. The recording files are available in developer dashboard.
Any participant can start / stop recording any time during the room.

This guide will provide an overview of how to implement start and stop Room Recording.

1. **Start Recording** - By using `startRecording()` function, a participant can start room recording.

### Parameters

- **webhookUrl**:

  - type: `String`
  - required: `false`
  - It will be webhook url where you want to get teh status of the recording.

- **awsDirPath**:

  - type: `String`
  - required: `false`
  - It will be path for your AWS storage specifing where to store the recording file.

- **config**:

  - type: `Object`
    - **config**:
      - **layout**:
        - **type**: _"GRID"_ | _"SPOTLIGHT"_ | _"SIDEBAR"_
        - **priority**: _"SPEAKER"_ | _"PIN"_
        - **gridSize**: Number _\`max 4\`_
      - **theme**: _"DARK"_ | _"LIGHT"_ | _"DEFAULT"_
      - **mode**: _"video-and-audio"_ | _"audio"_
      - **quality**: _"low"_ | _"med"_ | _"high"_
      - **orientation**: _"landscape"_ | _"portrait"_
  - required: `false`
  - It will be config for the layout of the recording you can to use.

2. **Stop Recording** - By using `stopRecording()` function, a participant can stop room recording.

### Start And Stop Recording

```js
// Start Recording
room.startRecording(config: {
  'layout': {
    'type': 'GRID',
    'priority': 'SPEAKER',
    'gridSize': 4,
  },
  'theme': "LIGHT",
  "mode": "video-and-audio".
  'quality':'high'
});

// Stop Recording
room.stopRecording(),
```

### Events

- **recordingStateChanged** - Whenever meeting recording state changes, then `recordingStateChanged` event will trigger.

```js
room.on(Events.recordginStateChanged, (String status) {

  // Status can have values -
  // RECORDING_STARTING -- Recording is starting
  // RECORDING_STARTED -- Recording is started
  // RECORDING_STOPPING -- Recording is stopping
  // RECORDING_STOPPED -- Recording is stopped

  toastMsg("Meeting recording status : $status");
});
```


---

---
title: Remove Participant - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: Remove Participant features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Remove Participant
pagination_label: Remove Participant
keywords:
  - remove participant
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: remove-participant
---

import NoIndex from '../../../../../mdx/\_no-index.mdx';

<NoIndex/>

# Remove Participant - Flutter

- Whenever any participant (having privileges) wants to remove other participant in room, he/she can do it with this feature.

- `Participant` class provides the `remove()` method to remove participant from the room.

```js
ElevatedButton(
    child: Text("Remove Participant"),
    onPressed: () {
        participant.remove();
    },
),
```

:::note
To remove any participant, you must have appropriate permissions
:::


---

---
title: Share your Screen Video & Audio Call - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: Share your Screen features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Share Your Screen
pagination_label: Share Your Screen
keywords:
  - Start Screen share
  - Stop Screen share
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: screenshare
---

import NoIndex from '../../../../../mdx/\_no-index.mdx';

<NoIndex/>

# Share Your Screen - Flutter

- Whenever any participant wants to share a complete screen of mobile, they can simply do it with VideoSDK Room.

- This guide will provide an overview of how to enable or disable Screen Share in a room.

## Enable Screen Share

- `Room` class provides the method to enable screen-sharing.

- In order to start screen-sharing just call `room.enableScreenShare()` method.

```js
ElevatedButton(
    child: Text("Start ScreenSharing"),
    onPressed: () {
        room.enableScreenShare();
    },
),
```

:::caution

For Flutter iOS Screen Share feature, you need to follow this guide [Flutter iOS Screen Share](../extras/flutter-ios-screen-share)
:::

### Customise notification

- When a presenter starts screen share, presenter will receive a notification with a pre-defined title and messages.

- You can Customise those title, message and icon as per your requirements using `NotificationInfo` class and passed to `createRoom()` method.

```js
VideoSDK.createRoom(
    .
    .
    notification: const NotificationInfo(
        title: "Video SDK",
        message: "Video SDK is sharing screen in the room",
        icon: "notification_share", // drawable icon name
    ),
),
```

## Disable Screen Share

By using `room.disableScreenShare()` function, a participant can stop publishing screen stream to other participants.

```js
ElevatedButton(
    child: Text("Stop ScreenSharing"),
    onPressed: () {
        room.disableScreenShare();
    },
),
```

## Display Screen Share Stream

#### Local Participant

When a Local participant share the screen, `streamEnabled` Event on the `Participant` is triggered with the `Stream` which can be added to a `RTCVideoView`.

```js
room.localParticipant.on(Events.streamEnabled, (Stream _stream) {
    if (_stream.kind == 'share') {
        screenShareStream = _stream;
      }
    });
```

#### Other Participants

When other participant(Except you) share their screen, `presenterChanged` Event on the `Participant` is triggered with the `participantId` of the screen share.

```js
room.on(Events.presenterChanged, (_activePresenterId) {
    Participant? activePresenterParticipant = room.participants[_activePresenterId];

    Stream? _stream = activePresenterParticipant?
                        .streams.values
                        .singleWhere((e) => e.kind == "share");

    remoteParticipantShareStream = _stream;
});
```


---

---
title: Set Video Quality - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: Set Video Quality features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Set Video Quality
pagination_label: Set Video Quality
keywords:
  - set video quality
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: set-video-quality
---

import NoIndex from '../../../../../mdx/\_no-index.mdx';

<NoIndex/>

# Set Video Quality - Flutter

- Set Video Quality feature allows participants to set other participant's video quality during the room.

- `Participant` class provides the `setQuality()` method to set participant's video quality.

```js
ElevatedButton(
    child: Text("Set High Quality"),
    onPressed: () {
        // Set Video Quality

        // High Quality
        participant.setQuality('high');

        // Medium Quality
        participant.setQuality('med');

        // Low Quality
        participant.setQuality('low');

    },
),
```


---

---
title: Set Viewport
hide_title: false
hide_table_of_contents: false
sidebar_label: Set Viewport
pagination_label: Set Viewport
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: set-viewport
---

import NoIndex from '../../../../../mdx/\_no-index.mdx';

<NoIndex/>

# Set Viewport - Flutter

When you are working with Video Calling, video quality is the most important part of communication. When a participant is shown on the screen, consuming multiple high quality although not required, will result in more memory and CPU usage of the device, eventually degrading quality.

The way to optimize around these situation is to consume the video quality which is required to fit the view of a particular participant, resulting in better quality, less usage of network bandwidth and providing a better experience.

Viewport is the size of window or visible area in which video for the participant is shown. We can optimize the consuming video quality based on the viewport size of the participant. For example if the viewport size of a particular participant view is `480x360`, VideoSDK will download a `480x360` stream. If a participant on screen is present in bigger size, VideoSDK will provide a higher quality video for that particular participant only.

import ReactPlayer from 'react-player'

<div style={{textAlign: 'center'}}>

<ReactPlayer autoplay muted loop playing url='/img/viewport_illustration.mp4' width={"100%"}/>

</div>

### setViewPort()

`setViewPort()` can be used to achieve the best optimization of the video. This method is called with the `width` and `height` of the participant view on the `Participant` object and VideoSDK will handle the rest.

##### Parameters

- `width`

  - type: `int`
  - Width of the participant view for which the quliaty of video is to be adjusted.

- `height`
  - type: `int`
  - Height of the participant view for which the quliaty of video is to be adjusted.

### Example

```js
class ParticipantTile extends StatefulWidget {
  final Participant participant;
  final bool isLocalParticipant;
  const ParticipantTile(
      {Key? key, required this.participant, this.isLocalParticipant = false})
      : super(key: key);

  @override
  State<ParticipantTile> createState() => _ParticipantTileState();
}

class _ParticipantTileState extends State<ParticipantTile> {
  //create a widgetKey which can be used to refer the Video container
  GlobalKey _widgetKey = GlobalKey();

  @override
  Widget build(BuildContext context) {
    return Container(
        key: _widgetKey, //assign key to reference this view
        child: <Your Widget Here for Displaying participant>
    );
  }

  //call this method whenever the widget height of width gets changed.
  //it can be during stream enabled, stream resume, etc
  onViewPortChange() {
    try {
      //get the renderbox
      final RenderBox renderBox =
          _widgetKey.currentContext?.findRenderObject() as RenderBox;
      _widgetKey.currentContext?.size;

      //Get Size of the renderbox
      final Size size = renderBox.size;

      //apply setViewPort on the participant with height and width of view
      widget.participant.setViewPort(size.width, size.height);
    } catch (exception) {
      log("Unable to set Viewport $exception");
    }
  }
}
```


---

---
title: Speaker Indication Video & Audio Call - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: Speaker Indication features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Speaker Indication
pagination_label: Speaker Indication
keywords:
  - Active Speaker
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: speaker-indication
---

import NoIndex from '../../../../../mdx/\_no-index.mdx';

<NoIndex/>

# Speaker Indication - Flutter

Speaker indication feature in VideoSDK let you know, which participant in a room is active speaker.

Whenever any participant speaks in room, `speakerChanged` event will trigger.

For example, the room is running with **Alice** and **Bob**. Whenever any of them speaks, `speakerChanged` event will trigger and return the speaker `participantId`.

We can access `speakerChanged` event through [room object](./start-join-room#2-initialization).

### speakerChanged Event

```js
room.on(Events.speakerChanged, (activeSpeakerId) {
  print("participantId => $activeSpeakerId");
});
```


---

---
title: Start join Room Video & Audio Call - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: Start or join Room features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Start or Join Room
pagination_label: Start or Join Room
keywords:
  - Join audio calling
  - Join video calling
  - Join real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: start-join-room
---

import NoIndex from '../../../../../mdx/\_no-index.mdx';

<NoIndex/>

# Start or Join Room - Flutter

<div style={{display:'flex',flexDirection:'row',alignItems:'stretch',}}>
<div style={{}}>
<p>After the successful installation of VideoSDK, the next step is to integrate VideoSDK features with your webApp/MobileApp.</p>

<p>To Communicate with other participant's audio or video call, you will need to join the room.</p>

<p>This guide will provide an overview of how to configure, initialize and join a VideoSDK room.</p>

</div>
<div>
<img src="/img/gif/new-meeting.gif"/>
</div>

</div>

## 1. Configuration

To configure a room, you will need [generated token](/flutter/1.0.x/guide/video-and-audio-calling-api-sdk/server-setup) and [roomId](/api-reference/realtime-communication/create-room), we had discussed in [Server Setup](/flutter/guide/video-and-audio-calling-api-sdk/server-setup).
This code snippet calls API from local server

**Scenario 1** - Suppose you **don't have** any roomId, you can simply generate roomId by invoking `create-room` API.

**Scenario 2** - Suppose you **have** roomId, now you don't have to call `create-room` API to generate roomId, instead you can call `validate-room` API to validate roomId.

**Token generation API is necessary for both scenario.**

```js
import 'dart:convert';
import 'package:http/http.dart' as http; // For API Calling, you need to add third party package "http"
import 'package:videosdk/videosdk.dart';

// States Defined in Stateful Component.
String? roomId;
String? token;

void _getRoomIdAndToken() async {
    final LOCAL_SERVER_URL = dotenv.env['LOCAL_SERVER_URL'];

    // Calling get-token API.
    final Uri tokenUrl = Uri.parse('$LOCAL_SERVER_URL/get-token');
    final http.Response tokenResponse = await http.get(tokenUrl);

    final dynamic _token = json.decode(tokenResponse.body)['token'];

    // Calling create-room API.
    final Uri roomIdUrl =
        Uri.parse('$LOCAL_SERVER_URL/create-room/');

    final http.Response roomIdResponse =
        await http.post(roomIdUrl, body: {"token": _token});

    final _roomId = json.decode(roomIdResponse.body)['roomId'];

    // Setting into states of stateful widget
    setState(() {
      token = _token;
      roomId = _roomId;
    });
  }

  // This API is for validate the room id
  // Not require to call this API after create room API

dynamic validateRoom(token, roomId) async {
    final String LOCAL_SERVER_URL = dotenv.env['LOCAL_SERVER_URL'];
    final Uri validateRoomUrl =
        Uri.parse('$LOCAL_SERVER_URL/validate-room/$roomId');
    final http.Response validateRoomResponse =
        await http.post(validateRoomUrl, body: {"token": token});
    final _roomId = json.decode(validateRoomResponse.body)['roomId'];
    if (_roomId != null) {
      return _roomId;
    } else {
      return null;
    }
  }

```

## 2. Initialization

<div style={{display:'flex',flexDirection:'row',alignItems:'stretch',}}>
<div style={{}}>
<p>
After configuration, you will have to Initialize 
<p>
room by providing name, roomId, micEnabled, camEnabled & maxResolution.
</p>
</p>

</div>
<div>
<img src="/img/gif/add-participant.gif"/>
</div>

</div>

```js
import 'package:flutter/material.dart';
import 'package:videosdk/videosdk.dart';

class MyApp extends StatelessWidget {
  final Room = VideoSDK.createRoom(
    roomId: "<Id-of-Room>",
    displayName: "<Name-of-participant>",
    micEnabled: "<Flag-to-enable-mic>",
    camEnabled: "<Flag-to-enable-cam>",
    token: "<Authentication-token>",
    notification: const NotificationInfo(
      title: "Video SDK",
      message: "Video SDK is sharing screen",
      icon: "notification_share",
    ),
  );
    @override
    Widget build(BuildContext context) {
        return return Container(); // Returning widget
    }
}
```

## 3. Join

<div style={{display:'flex',flexDirection:'row',alignItems:'stretch',}}>
<div style={{}}>
<p>
After configuration & initialization, the third step is to call join() to join a room.
</p>

<p>
After joining, you will be able to Manage Participant in a room.
</p>

</div>
<div>
<img src="/img/gif/join-meeting.gif"/>
</div>

</div>

```js
// Join the room
room?.join();
```

## Events

Following events are emitted on the `room` when it is successfully joined.

- Local Participant will receive a [`roomJoined`](/flutter/1.0.x/api/sdk-reference/room-class/events#roomjoined) event when successfully joined.
- Remote Participant will receive a [`participantJoined`](/flutter/1.0.x/api/sdk-reference/room-class/events#participantjoined) event with the newly joined [`Participant`](../../../api/sdk-reference/participant-class/introduction.md) object from the event callback.

```js
room.on(Events.roomJoined, () => {
  print("Room Joined Successfully");
});

room.on(Events.participantJoined, (participant) => {
  print("New Participant Joined");
});
```


---

---
sidebar_label: Switch Audio Output (BETA)
pagination_label: Switch Audio Output (BETA)
---

import NoIndex from '../../../../../mdx/\_no-index.mdx';

<NoIndex/>

# Switch Audio Output (BETA) - Flutter

This feature will help yout to switch audio output device during the session.

## Get Connected Device List

This method will help you to list down all possible connected audio devices.

To get the list of all available audio output devices, use the `getAudioOutputDevices()`, which will return a list of `MediaDeviceInfo`.

`MediaDeviceInfo` will contain the `deviceId` and `label` of the particular audio output device.

```js

ElevatedButton(
  child: Text("Get Output Device"),
  onPressed: () => {
    List<MediaDeviceInfo> outputDevice = meeting.getAudioOutputDevices()
    log(outputDevice);
  }),
```

## Switch Audio to Another Device

This method will help you to switch specific audio output device.

```js
// Pass the MediaDeviceInfo object to which the audio is to be switched.
meeting.switchAudioOutput(mediaDeviceInfo);
```

:::note

`EARPIECE` is not supported whenever `WIRED_HEADSET` or `BLUETOOTH` device is connected
:::

To check the implementation of switch audio device in detail, check out the [Flutter Code Sample](https://github.com/videosdk-live/videosdk-rtc-flutter-sdk-example)


---

---
title: Toggle Participant Media
hide_title: false
hide_table_of_contents: false
description: Camera Controls features quick integrate in Javascript, React JS, Android, IOS, React Native, Flutter with Video SDK to add live video & audio conferencing to your applications.
sidebar_label: Toggle Participant Media
pagination_label: Toggle Participant Media
keywords:
  - Camera on
  - Camera off
  - audio calling
  - video calling
  - real-time communication
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: toggle-participant-media
---

import NoIndex from '../../../../../mdx/\_no-index.mdx';

<NoIndex/>

# Toggle Participant Media - Flutter

Control other participant's camera and mic.
For better idea, let's understand this with a real case scenario

**Scenario 1 (Online Class)** - In this scenario, the lecturer(Local Participant) will control the student's(Other Participant) camera and mic as per his/her needs.

**Scenario 2 (Online Events)** - In this scenario, the event hosts will control the audience camera and mic when someone wants to speak.

This guide will provide an overview of how to control other participant camera and mic in a room.

1. **Enable camera of Participant** - By using `enableCam()` function, a `cameraRequested` event will trigger on requested participant side.

   **Example** : Room is running with **User A** and **User B**. Now **User A** wants to Enable camera of **User B**, so **User A** will use `enableCam()` function to request **User B**, after that **User B** receive the `cameraRequested` event, from there user can either accept or reject the incoming request.

2. **Disable camera of Participant** - By using `disableCam()` function, camera of that participant will be turned off.

   **Example** : **User A** wants to Disable camera of **User B**, so **User A** will use `disableCam()` function to Disable it without any request.

3. **Unmute Mic of Participant** - By using `unmuteMic()` function, a `micRequested` event will trigger on requested participant side.

   **Example** : Room is running with **User A** and **User B**. Now **User A** wants to Enable Mic of **User B**, so **User A** will use `unmuteMic()` function to request **User B**, after that **User B** will receive the `micRequested` event, from there user can either accept or reject the incoming request.

4. **Mute Mic of Participant** - By using `muteMic()` function, Mic of that participant will disable.

   **Example** : **User A** wants to Disable Mic of **User B**, so **User A** will use `mute()` function to Disable it without any request.

:::note

To achieve this feature, you need to pass `allow_join` persmission while genearting token for room initialization. After that you will be able to access participant media methods.

[How to apply permission while generating token?](/flutter/1.0.x/guide/video-and-audio-calling-api-sdk/server-setup)

:::

### Request Media Methods

```js
const participants = room.participants;
const participant = participants.get("<participant-id>");

// This will emit an event called "cameraRequested" to that particular participant
participant.enableCam();

// This will directly disable camera of particular participant
participant.disableCam();

// This will emit an event called "micRequested" to that particular participant
participant.unmuteMic();

// This will directly disable mic of particular participant
participant.muteMic();
```

### Manage Requested Media Events

1. **cameraRequested** - This event will be emitted to the participant `B` when any other participant `A` requests to enable camera of that participant `B`. This event handler will receive following three arguments:

   - `accept()` - Callback function to accept the request.
   - `reject()` - Callback function to reject the request.

<div style={{height: "10px"}}></div>

2. **micRequested** - This event will be emitted to the participant `B` when any other participant `A` requests to enable mic of that participant `B`. This event handler will receieve following three arguments:

   - `accept()` - Callback function to accept the request.
   - `reject()` - Callback function to reject the request.

```js
// Handle camera Requested
widget.room.on(Events.cameraRequested, ({ accept, reject }) {
    // callback function to accept the request
    accept();

    // callback function to reject the request
    reject();
}, );

// Handle Mic Requested
widget.room.on(Events.micRequested, ({ accept, reject }) {
     // callback function to accept the request
    accept();

    // callback function to reject the request
    reject();
}, );
```


---

---
title: Integrate Flutter SDK - Video SDK Docs
hide_title: false
hide_table_of_contents: false
description: Build customizable real-time video & audio calling applications in Flutter SDK with Video SDK add live Video & Audio conferencing to your applications.
sidebar_label: Integrate Flutter SDK
pagination_label: Integrate Flutter SDK
keywords:
  - flutter sdk
  - dart sdk
  - javascript sdk
  - sky sdk
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: flutter-sdk
---

import NoIndex from '../../../../mdx/\_no-index.mdx';

<NoIndex/>

# Getting Started - Flutter SDK

Flutter SDK is natively written SDK using Dart. It is compatible with both IOS and Android.

## Installing Flutter SDK

Flutter SDK is client for real-time communication for android and ios devices. It inherits the same terminology as all other SDKs does.

### Step 1: Add this package in your flutter project

VideoSDK flutter SDK canbe added using the following command:

```bash
flutter pub add videosdk
```

This will add a line like this to your package's pubspec.yaml (and run an implicit flutter pub get):

```
dependencies:
  videosdk: ^1.0.x
```

### Step 2: Android Setup

VideoSDK requires you to add following permissions to your app so that it can access the audio and video from the device.

Ensure the following permission is present in your Android Manifest file, located in `<project root>/android/app/src/main/AndroidManifest.xml`:

```xml
<uses-feature android:name="android.hardware.camera" />
<uses-feature android:name="android.hardware.camera.autofocus" />
<uses-permission android:name="android.permission.CAMERA" />
<uses-permission android:name="android.permission.RECORD_AUDIO" />
<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
<uses-permission android:name="android.permission.CHANGE_NETWORK_STATE" />
<uses-permission android:name="android.permission.MODIFY_AUDIO_SETTINGS" />
<uses-permission android:name="android.permission.INTERNET"/>
<uses-permission android:name="android.permission.FOREGROUND_SERVICE"/>
<uses-permission android:name="android.permission.WAKE_LOCK" />
```

If you need to use a Bluetooth device, please add:

```xml
<uses-permission android:name="android.permission.BLUETOOTH" />
<uses-permission android:name="android.permission.BLUETOOTH_ADMIN" />
```

Also you will need to set your build settings to Java 8, because official WebRTC jar now uses static methods in `EglBase` interface. Just add this to your app level `build.gradle`:

```js
android {
    //...
    compileOptions {
        sourceCompatibility JavaVersion.VERSION_1_8
        targetCompatibility JavaVersion.VERSION_1_8
    }
}
```

###### Update the minimumSdkVersion for android

If necessary, in the same `build.gradle` you will need to increase `minSdkVersion` of `defaultConfig` up to `23` (currently default Flutter generator set it to `16`).

If necessary, in the same `build.gradle` you will need to increase `compileSdkVersion` and `targetSdkVersion` up to `31` (currently default Flutter generator set it to `30`).

### Step 3: iOS Setup

VideoSDK requires you to add following permissions to your app so that it can access the audio and video from the device.

Add the following entry to your `Info.plist` file, located at `<project root>/ios/Runner/Info.plist`:

```xml
<key>NSCameraUsageDescription</key>
<string>$(PRODUCT_NAME) Camera Usage!</string>
<key>NSMicrophoneUsageDescription</key>
<string>$(PRODUCT_NAME) Microphone Usage!</string>
```

###### Update the minimum platform version

Update the minimum iOS platform version to `11.0`. You can update it in the `ios/Podfile`.

```js title="Podfile"
platform: ios, "11.0";
```

### Step 4: Import it

Now in your Dart code, you can use:

```js
import "package:videosdk/videosdk.dart";
```

:::note

Check out official example of Flutter SDK implementation: [videosdk-rtc-flutter-sdk-example](https://github.com/videosdk-live/videosdk-rtc-flutter-sdk-example)

:::


---

---
title: Error Events | Video SDK
hide_title: true
hide_table_of_contents: false
description: Video SDK and Audio SDK, developers need to implement a token server. This requires efforts on both the front-end and backend.
sidebar_label: Error Events
pagination_label: Error Events
keywords:
  - audio calling
  - video calling
  - real-time communication
  - collaboration
image: img/videosdklive-thumbnail.jpg
sidebar_position: 1
slug: error-events
---

import NoIndex from '../../../../../mdx/\_no-index.mdx';

<NoIndex/>

# Error Events - Flutter

VideoSDK provides `error` event which will notify you of any error happening during the meeting.

### Events.error

- This event will be triggered whenever any invalid configuration provided or server/network errors arise, this event will trigger with a specific error code and message.
- This event is helpful for development level troubleshooting while integrating SDK.
- This event can be subscribed on the `Room` object.

### Example

Here is the usage of the event mentioned in this page.

```javascript
import 'package:flutter/material.dart';
import 'package:videosdk/videosdk.dart';

class MeetingScreen extends StatefulWidget {
  ...
}

class _MeetingScreenState extends State<MeetingScreen> {
  late Room room;

  @override
  void initState() {
    //highlight-next-line
    ...

    setupRoomEventListener();
  }

  @override
  Widget build(BuildContext context) {
    return YourMeetingWidget();
  }

  //highlight-start
  void setupRoomEventListener() {
    room.on(Events.error, (error) {
      log("VIDEOSDK ERROR :: " +
          error['code'].toString() +
          "  :: " +
          error['name'].toString() +
          " :: " +
          error['message'].toString());
    });
  }
  //highlight-end
}
```

### Error Codes

We have depicted a specific constant with code and message in the below table.

| Constant                                      | Code | Message                                                                                                                     |
| --------------------------------------------- | ---- | --------------------------------------------------------------------------------------------------------------------------- |
| **INVALID_API_KEY**                           | 4001 | `apikey` provided in the token is empty or invalid, please verify it on the dashboard.                                      |
| **INVALID_TOKEN**                             | 4002 | `token` is empty or invalid or might have expired.                                                                          |
| **INVALID_MEETING_ID**                        | 4003 | `meetingId` is empty or invalid, please verify it or generate new meetingId using the API.                                  |
| **INVALID_PARTICIPANT_ID**                    | 4004 | `participantId` is empty or invalid, it shouldn't contain any whitespaces.                                                  |
| **DUPLICATE_PARTICIPANT**                     | 4005 | Leaving meeting, since this `participantId` joined from another device.                                                     |
| **ACCOUNT_DEACTIVATED**                       | 4006 | It seems your account is deactivated by VideoSDK for some reason, you can reach out to us at `support@videosdk.live`.       |
| **ACCOUNT_DISCONTINUED**                      | 4007 | _Server will respond you with specific message._                                                                            |
| **INVALID_PERMISSIONS**                       | 4008 | `permissions` provided in the token are invalid, please don't use `allow_join` or `allow_mod` with `ask_join`.              |
| **MAX_PARTICIPANT_REACHED**                    | 4009 | You have reached max participant limit in a meeting.                                                                         |
| **MAX_SPEAKER_REACHED**                       | 4010 | You have reached max speaker limit in a meeting.                                                                            |
| **START_RECORDING_FAILED**                    | 4011 | Recording start request failed due to an unknown error.                                                                     |
| **STOP_RECORDING_FAILED**                     | 4012 | Recording stop request failed due to an unknown error.                                                                      |
| **START_LIVESTREAM_FAILED**                   | 4013 | Livestream start request failed due to an unknown error.                                                                    |
| **STOP_LIVESTREAM_FAILED**                    | 4014 | Livestream stop request failed due to an unknown error.                                                                     |
| **INVALID_LIVESTREAM_CONFIG**                 | 4015 | Livestream 'outputs' configuration provided was invalid.                                                                    |
| **START_HLS_FAILED**                          | 4016 | HLS start request failed due to an unknown error.                                                                           |
| **STOP_HLS_FAILED**                           | 4017 | HLS stop request failed due to an unknown error.                                                                            |
| **PREV_RECORDING_PROCESSING**                 | 4018 | Previous recording session is being processed, please try again after few seconds!                                          |
| **PREV_RTMP_RECORDING_PROCESSING**            | 4019 | Previous RTMP recording session is being processed, please try again after few seconds!                                     |
| **PREV_HLS_STREAMING_PROCESSING**             | 4020 | Previous HLS streaming session is being processed, please try again after few seconds!                                      |
| **MAX_SPEAKER_LIMIT_REACHED_ON_ORGANIZATION**    | 4026 | You have reached max speaker limit on organizat