Build Zoom Video Sdk App

# Android Video SDK Overview

## What this platform skill is for

- Building fully custom Android video session UI (not Zoom Meeting UI)
- Managing join/leave and participant state via Video SDK events
- Handling camera, mic, share, chat, command, and optional raw data paths

## Primary implementation path

1. Backend generates short-lived Video SDK token using Video SDK Key/Secret.
2. Android initializes SDK and joins a session by `sessionName` + token.
3. App binds SDK events to UI state (user join/leave, video/audio/share changes).
4. App starts/stops media explicitly and cleans up SDK resources on leave.

## Prerequisites

- Android Studio + supported Gradle/AGP stack
- Video SDK Android package (`mobilertc.aar`)
- Backend token endpoint for Video SDK JWT generation
- Camera/microphone permissions flow and runtime handling

## Important notes

- Video SDK session auth is token-based and server-generated.
- Do not use Meeting SDK payload fields (`meetingNumber`, `passWord`) in Video SDK flows.
- Keep token generation and key/secret handling server-side only.

## Source links

- Docs: https://developers.zoom.us/docs/video-sdk/android/
- API reference: https://marketplacefront.zoom.us/sdk/custom/android/index.html


# Android Architecture Concept

```mermaid
flowchart LR
  UI[Android UI Layer] --> VM[Session ViewModel / Controller]
  VM --> SDK[Zoom Video SDK Android]
  VM --> API[Token API]
  API --> Signer[Server-side JWT Signer]
  Signer --> Market[Video SDK App Credentials]
  SDK --> Events[Participant/Media Events]
  Events --> UI
```

## Design guidance

- Keep token creation strictly backend-side.
- Keep SDK calls in a session controller or ViewModel boundary.
- Drive UI from SDK event streams to avoid stale participant state.
- Treat join/start-media/leave as explicit state transitions.


# Android Lifecycle Workflow

```mermaid
flowchart TD
  A[Fetch token from backend] --> B[Initialize Video SDK]
  B --> C[Join session]
  C --> D[Bind event listeners]
  D --> E[Start local media]
  E --> F[Handle remote user/media events]
  F --> G[Leave session]
  G --> H[Cleanup listeners and media]
```

## Operational sequence

1. Request token from backend using app auth context.
2. Initialize SDK and register core listeners.
3. Join session with session name/topic, display name, and token.
4. Start local camera/mic only after successful join.
5. Render remote users when events indicate media state changes.
6. On leave/disconnect, unsubscribe listeners and release resources.


# Android Session Join Pattern

```kotlin
suspend fun joinVideoSession(sessionName: String, userName: String) {
  val token = tokenApi.getVideoSdkToken(sessionName, userName)

  val initResult = videoSdk.initialize(initParams)
  check(initResult.isSuccess) { "SDK init failed" }

  videoSdk.addListener(sessionListener)

  val joinResult = videoSdk.joinSession(
    sessionName = sessionName,
    userName = userName,
    token = token
  )
  check(joinResult.isSuccess) { "Join failed" }

  videoHelper.startVideo()
  audioHelper.startAudio()
}
```

## Notes

- Start local media after join success.
- Keep camera/mic permissions and denial handling explicit.


# Android Reference Map

## Docs anchors

- Getting started and integration: https://developers.zoom.us/docs/video-sdk/android/
- API surface index: https://marketplacefront.zoom.us/sdk/custom/android/index.html

## API areas to focus on

- Session lifecycle and join context
- Audio/video helpers
- Participant/user helpers
- Share/chat/command channels
- Raw data interfaces and delegates

## Crawl summary

- Reference pages crawled: 650
- Docs pages crawled: 23 (22 markdown files persisted)


# Android Environment Variables

| Variable | Required | Used for | Where to find |
| --- | --- | --- | --- |
| `ZOOM_VIDEO_SDK_KEY` | Yes | Video SDK credential pair | Zoom Marketplace -> Video SDK app -> App Credentials |
| `ZOOM_VIDEO_SDK_SECRET` | Yes (server only) | Token/JWT signing | Zoom Marketplace -> Video SD