---
title: "Android seat map"
description: "Install the official SeatLayer Android SDK from Maven Central, render live seating charts in Kotlin, create holds, and hand booking to a trusted server."
---

The official SeatLayer Android seat map SDK adds an interactive seating chart
and seat picker to reserved-seating apps in Kotlin. The
[`io.seatlayer:seatlayer-android` package](https://central.sonatype.com/artifact/io.seatlayer/seatlayer-android)
provides a typed view, listener, suspending commands, structured errors, and
events for live availability, seat selection, temporary holds, and
best-available seating on Android 7.0 (API 24) and later.

[Inspect the Android source and sample app](https://github.com/seatlayer/seatlayer-android),
learn about the [SeatLayer reserved-seating platform](https://seatlayer.io/), or
preview the wider buyer experience in the
[browser seat-map demo](https://app.seatlayer.io/demo/play/grand-theatre). The
browser demo is product proof, not an Android application.

<Aside type="caution" title="The app selects and holds; your server books">
  Never put a SeatLayer secret key in an Android binary or WebView. Send the
  opaque hold id to your trusted backend, inspect the hold there, calculate the
  charge from server data, and book with a stable `bookingRef`.
</Aside>

## Install from Maven Central

```kotlin title="build.gradle.kts"
dependencies {
    implementation("io.seatlayer:seatlayer-android:0.2.0")
}
```

The library supports minSdk 24 with a Kotlin-first API. Releases before 0.2.0
were distributed through JitPack; use Maven Central for current versions.

## Render a seating chart

Add `SeatLayerView` to your layout — it is a `FrameLayout` subclass, so XML
inflation and Jetpack Compose's `AndroidView` both work — then load your event:

```kotlin
val map = findViewById<SeatLayerView>(R.id.seatMap)

val config = SeatLayerConfiguration(event = "ev_your_event_key", currency = "USD")

lifecycleScope.launch {
    val info = map.load(config)
    if (info.mode == EventMode.Test) showTestBadge() // books no real inventory

    val hold = map.hold()
}
```

Give the view a definite height or make it full-screen. Do not place it inside
a scrolling container — the buyer canvas owns pan and pinch gestures.

## Understand the hosted runtime boundary

`SeatLayerView` hosts the buyer experience in an Android WebView. Production
views load the immutable, version-pinned mobile runtime from
`https://cdn.seatlayer.io`; application code stays in Kotlin and communicates
through typed commands, listener events, payloads, and structured errors.

The bridge is origin-restricted and main-frame-only, the WebView is hardened
(file and content access off, mixed content blocked, multiple windows off),
and access tokens stay in memory — never in page URLs or application events.
Protocol negotiation fails closed with a typed error when an app update is
required, and every bridged enum tolerates unknown future values.

For private channel inventory, provide a short-lived token from your backend
through the buyer-access provider in `SeatLayerConfiguration`.

## Select, hold, and hand off checkout

Keep the security boundary explicit:

- The Android app selects seats and creates a temporary hold.
- Your backend inspects the hold and derives the amount to charge.
- Your payment and order workflow stays outside the WebView.
- Your backend books with a stable `bookingRef` so retries are safe.
- Expiry and inventory conflicts return buyers to a recoverable selection
  state.

Continue with [holds and checkout](/buyer-sdk/holds-and-checkout) before
connecting a production order flow.

## Commands and events

Common commands include `hold`, `resumeHold`, `extendHold`, `release`,
`bestAvailable`, `holdGeneralAdmission`, `getSelection`, `selectObjects`,
`clearSelection`, `getCurrentHold`, `setFloor`, `setViewMode`, `zoomIn`,
`zoomOut`, `zoomToFit`, and `destroy` — all suspending calls with typed
failures.

Events cover readiness, selection changes, selection validity, buyer-access
expiry, hold changes, hold restoration, hold expiry, general-admission taps,
seat hover, errors, and a dedicated callback for unknown future events.

## Android seat-map checklist

- Give the seat map a definite height or a full-screen destination.
- Keep one view per screen lifecycle and destroy it with the screen.
- Preserve the hold id across checkout navigation or process death if your
  product promises restoration.
- Test rotation, split-screen, back navigation, process death, and resume.
- Verify selection, hold, expiry, release, conflict, and booking with a test
  event.
- Smoke-test supported physical Android devices before rollout.

## Frequently asked questions

### Is this a native Kotlin seat map or a WebView?

Rendering runs in a hardened Android WebView on SeatLayer's immutable,
version-pinned buyer runtime, and application code never touches the web
layer: commands, payloads, errors, and events are all typed Kotlin.

### Does it work with Jetpack Compose?

Yes — `SeatLayerView` is a `FrameLayout`, so host it with `AndroidView` and
give it a definite size. A dedicated Compose wrapper is not currently shipped.

### How do temporary seat holds work?

Selecting seats creates a temporary hold that reserves inventory against
concurrent buyers for a limited window. The hold expires automatically if
checkout does not complete — the hold-expired event tells the app to return
the buyer to the map — and `extendHold` and `resumeHold` cover longer
checkouts and app restarts.

### Can I use my own payment provider?

Yes. SeatLayer never processes payment inside the seat map. The app hands the
hold id to your backend, and your backend charges through any payment provider
you already use before booking the hold.

### Does the Android SDK include a 3D seating chart?

SeatLayer offers an [optional browser 3D seat-map experience](https://seatlayer.io/3d-seat-map/).
This page does not claim a released native Android 3D contract; validate the
documented view modes and device support for your integration.

## Next steps

- [Install from Maven Central](https://central.sonatype.com/artifact/io.seatlayer/seatlayer-android)
- [Run or inspect the Android SDK source](https://github.com/seatlayer/seatlayer-android)
- [Understand the SeatLayer platform](https://seatlayer.io/)
- [Compare every mobile SDK](/buyer-sdk/mobile)
- [Connect holds to secure checkout](/buyer-sdk/holds-and-checkout)