rea
Reverse engineer anything with agents, from app behavior down to native binaries.
- 472k
- TypeScript
- MIT
- 2 h ago

LiveKit SDK for Android
Repo livekit/client-sdk-android, read from GitHub 1 min ago. livekit has not joined Take My Repo.
livekit/client-sdk-android is a public repo on GitHub by livekit. LiveKit SDK for Android. It declares the Apache-2.0 license on GitHub. It is written mainly in Kotlin, has 371 stars and last changed on 2026-11-20. Nobody has reviewed it on Take My Repo yet, which says nothing about its quality. Read from GitHub on 2026-11-21.
In the maintainer's words. Shown from GitHub; Take My Repo does not keep a copy.
Use this SDK to add realtime video, audio and data features to your Android/Kotlin app. By connecting to LiveKit Cloud or a self-hosted server, you can quickly build applications such as multi-modal AI, live streaming, or video calls with just a few lines of code.
Important
If you're building Voice AI, LiveKit Agents is the SDK for code-first realtime voice agents. STT, LLM, TTS, turn detection, expressive speech, keyterm accuracy, tool usage, and telephony all come bundled in the framework. It's available in both Python and Node.js.
LiveKit Agents is a great fit for customer support, healthcare, financial services, and outbound calling. Try the live demos.
# agent.py from livekit import agents from livekit.agents import Agent, AgentServer, AgentSession, STTContextOptions, TurnHandlingOptions, inference server = AgentServer() @server.rtc_session(agent_name="my-agent") async def my_agent(ctx: agents.JobContext): session = AgentSession( stt=inference.STT(model="deepgram/nova-3", language="multi"), llm=inference.LLM(model="google/gemma-4-31b-it"), tts=inference.TTS(model="inworld/inworld-tts-2", voice="Ashley"), turn_handling=TurnHandlingOptions(turn_detection=inference.TurnDetector()), stt_context_options=STTContextOptions(keyterms=["LiveKit", "Acme Corp"]), expressive=True, ) await session.start(room=ctx.room, agent=Agent(instructions="You are a helpful voice AI assistant.")) await session.generate_reply(instructions="Greet the user and offer your assistance.") if __name__ == "__main__": agents.cli.run_app(server)
Models come from LiveKit Inference with no per-provider API keys, and LiveKit Cloud handles deployment and observability. Visit the docs for more info at docs.livekit.io/agents.
Using a coding agent? Install the LiveKit skill with npx skills add livekit/agent-skills and add the docs MCP at https://docs.livekit.io/mcp/ (see coding agent support).
Docs and guides at https://docs.livekit.io.
API reference can be found at https://docs.livekit.io/client-sdk-android/index.html .
Note
This is v2 of the Android SDK. When migrating from v1.x to v2.x you might encounter a small set of breaking changes. Read the migration guide for a detailed overview of what has changed.
LiveKit for Android is available as a Maven package.
... dependencies { def livekit_version = "2.30.0" implementation "io.livekit:livekit-android:$livekit_version" // CameraX support with pinch to zoom, torch control, etc. implementation "io.livekit:livekit-android-camerax:$livekit_version" // Track processors, such as virtual background implementation "io.livekit:livekit-android-track-processors:$livekit_version" // Snapshots of the latest development version are available at: // implementation "io.livekit:livekit-android:2.30.1-SNAPSHOT" }
Compose-based apps should check out our Android Components SDK for composables support.
You'll also need JitPack as one of your repositories. In your settings.gradle file:
dependencyResolutionManagement {
repositories {
google()
mavenCentral()
//...
maven { url 'https://jitpack.io' }
// For SNAPSHOT access
// maven { url 'https://central.sonatype.com/repository/maven-snapshots/' }
}
}The SDK includes native WebRTC libraries for multiple CPU architectures (arm64-v8a, armeabi-v7a, x86, x86_64). When inspecting the AAR or a universal APK, the combined size may appear to be dozens of megabytes.
However, when distributing your app via Google Play using App Bundles, only the native library for the user's specific device architecture is delivered, resulting in a significantly smaller download size.
To measure the actual size impact for a specific architecture:
/lib/<arch>/ folders individuallyIf you have strict size requirements, such as voice-only use cases where video codecs are not needed, please contact our support team to discuss options for further reducing the SDK footprint.
LiveKit relies on the RECORD_AUDIO and CAMERA permissions to use the microphone and camera.
These permission must be requested at runtime. Reference
the sample app
for an example.
To connect to a room, you need a server URL and a participant token. The TokenSource factory
methods cover the common ways of obtaining these credentials:
Use this to pass a pregenerated server URL and token. Generate tokens via the LiveKit CLI or from your LiveKit Cloud project's API key page.
val source = TokenSource.fromLiteral("wss://your.livekit.host", "your_token")
For development and testing. Follow the development token server guide to enable your project's development token server and get the token server ID from the settings page.
This token generation mechanism is inherently insecure and should only be used for prototyping; do not use it in production.
val source = TokenSource.fromDevelopmentTokenServer("your token server id")
For production. Point to your own token endpoint URL and add any required authentication headers. The request and response follow the standard format described in the endpoint token generation guide.
val source = TokenSource.fromEndpoint( url = "https://your.token-server/api/token", headers = mapOf("Authorization" to "Bearer <auth>"), )
For fully custom logic, supply your own fetch function:
val source = TokenSource.fromCustom { options -> // Generate credentials via custom means here. Result.success(TokenSourceResponse(serverUrl = "...", participantToken = "...")) }
Configurable token sources (development token server, endpoint, custom) accept
TokenRequestOptions per fetch; fixed sources (literal) take no options:
val response = source.fetch( TokenRequestOptions(roomName = "room", participantName = "participant"), ).getOrThrow() room.connect(response.serverUrl, response.participantToken)
To avoid refetching credentials that are still valid, wrap any token source with .cached():
val cachedSource = source.cached()
room.localParticipant.setCameraEnabled(true) room.localParticipant.setMicrophoneEnabled(true)
// create an intent launcher for screen capture // this *must* be registered prior to onCreate(), ideally as an instance val val screenCaptureIntentLauncher = registerForActivityResult( ActivityResultContracts.StartActivityForResult() ) { result -> val resultCode = result.resultCode val data = result.data if (resultCode != Activity.RESULT_OK || data == null) { return@registerForActivityResult } lifecycleScope.launch { room.localParticipant.setScreenShareEnabled(true, data) } } // when it's time to enable the screen share, perform the following val mediaProjectionManager = getSystemService(MEDIA_PROJECTION_SERVICE) as MediaProjectionManager screenCaptureIntentLauncher.launch(mediaProjectionManager.createScreenCaptureIntent())
LiveKit uses SurfaceViewRenderer to render video tracks. A TextureView implementation is also
provided through TextureViewRenderer. Subscribed audio tracks are automatically played.
class MainActivity : AppCompatActivity() { lateinit var room: Room override fun onCreate(savedInstanceState: Bundle?) { super.onCreate(savedInstanceState) setContentView(R.layout.activity_main) // Create Room object. room = LiveKit.create(applicationContext) // Setup the video renderer room.initVideoRenderer(findViewById<SurfaceViewRenderer>(R.id.renderer)) connectToRoom() } private fun connectToRoom() { val url = "wss://your_host" val token = "your_token" lifecycleScope.launch { // Setup event handling. launch { room.events.collect { event -> when (event) { is RoomEvent.TrackSubscribed -> onTrackSubscribed(event) else -> {} } } } // Connect to server. room.connect( url, token, ) // Turn on audio/video recording. val localParticipant = room.localParticipant localParticipant.setMicrophoneEnabled(true) localParticipant.setCameraEnabled(true) } } private fun onTrackSubscribed(event: RoomEvent.TrackSubscribed) { val track = event.track if (track is VideoTrack) { attachVideo(track) } } private fun attachVideo(videoTrack: VideoTrack) { videoTrack.addRenderer(findViewById<SurfaceViewRenderer>(R.id.renderer)) findViewById<View>(R.id.progress).visibility = View.GONE } }
See the basic sample app for the full implementation.
By default, the audio is configured for two-way communications.
If you are building a livestreaming or media playback focus app, you can use the preset
MediaAudioType when creating the Room object for better audio quality.
val room = LiveKit.create( appContext = application, overrides = LiveKitOverrides( audioOptions = AudioOptions( audioOutputType = AudioType.MediaAudioType() ) ) )
Note: audio routing becomes automatically handled by the system and cannot be manually controlled.
For more control over the specific audio attributes and modes, a CustomAudioType can be
passed instead.
@FlowObservableProperties marked with @FlowObservable can be accessed as a Kotlin Flow to observe changes
directly:
coroutineScope.launch {
room::activeSpeakers.flow.collectLatest { speakersList ->
/*...*/
}
}Note: If you wish to run the sample apps directly from this repo, please consult the Dev Environment instructions.
We have a basic quickstart sample app here, showing how to connect to a room, publish your device's audio/video, and display the video of one remote participant.
There are two more full featured video conferencing sample apps:
They both use
the CallViewModel
, which handles the Room connection and exposes the data needed for a basic video conferencing
app.
The respective ParticipantItem class in each app is responsible for the displaying of each
participant's UI.
To develop the Android SDK or running the sample app directly from this repo, you'll need:
git clone https://github.com/livekit/client-sdk-android.git
cd client-sdk-android
git submodule update --init
For those developing on Macs with Apple silicon (e.g. M1, M2, etc.), please add below to $HOME/.gradle/gradle.properties
protoc_platform=osx-x86_64
webrtc/sdk/android folder.| LiveKit Ecosystem | |
|---|---|
| Agents SDKs | Python · Node.js |
| LiveKit SDKs | Browser · Swift · Android · Flutter · React Native · Rust · Node.js · Python · Unity · Unity (WebGL) · ESP32 · C++ |
| Robotics | Portal · Portal for ROS |
| Starter Apps | Python Agent · TypeScript Agent · React App · SwiftUI App · Android App · Flutter App · React Native App · Web Embed |
| UI Components | React · Android Compose · SwiftUI · Flutter |
| Server APIs | Node.js · Golang · Ruby · Java/Kotlin · Python · Rust · PHP (community) · .NET (community) |
| Resources | Docs · Docs MCP Server · CLI · LiveKit Cloud |
| LiveKit Server OSS | LiveKit server · Egress · Ingress · SIP |
| Community | Developer Community · Slack · X · YouTube |
livekit/client-sdk-android is a public repo on GitHub by livekit. LiveKit SDK for Android.
It declares the Apache-2.0 license on GitHub.
Its maker has not tagged a system, so it is unknown here. Its README says what it needs.
Open "Take it" on its page: Take My Repo writes an install plan for your machine and hands it to your AI agent (Claude Code, Codex or Cursor), which asks you before each step. Take My Repo has not tested it on any machine.
Its last change on GitHub was on 2026-11-20. Take My Repo does not judge from that whether it is maintained.
Nobody has reviewed it on Take My Repo yet, which says nothing about its quality.
Reverse engineer anything with agents, from app behavior down to native binaries.
Interoperable by design. Governed by you. Open-source, secure platform for messaging, voice, video and governed AI, built for defense and government.

Flutter makes it easy and fast to build beautiful apps for mobile and beyond
This page is also available as structured data, with the same sources and dates.
/api/v1/resources/gh/livekit/client-sdk-androidTake My Repo has not tested this on your machine. Requirements come from the project's own documentation.