Live Room Viewing

Live room viewing starts from a room ID or a room post. The social.plus SDK owns room discovery, room status, live playback URLs, recorded playback metadata, and live room post collections. Your app owns the actual video player, buffering UI, autoplay policy, and platform playback SDK.

This page covers SDK room viewing data. AVPlayer, ExoPlayer, HLS.js, browser autoplay handling, DRM, and player UI are app-owned concerns after the SDK returns a playback URL.

Platform Surface

Platform	Find room posts	Observe room	Live playback field	Recorded playback field
TypeScript	`PostRepository.getLiveRoomPosts(...)`, `getCommunityLiveRoomPosts(...)`	`RoomRepository.getRoom(roomId, callback)`	`room.livePlaybackUrl`	`room.recordedPlaybackInfos[]`
iOS	`AmityPostRepository().getLiveRoomPosts()`, `getCommunityLiveRoomPosts(withIds:)`	`AmityRoomRepository().getRoom(withId:)`	`room.livePlaybackUrl`	`room.recordedData[]`
Android	`AmityPostRepository.getLiveRoomPosts()`, `getCommunityLiveRoomPosts(...)`	`AmityVideoClient.newRoomRepository().getRoom(roomId)`	`room.getLivePlaybackUrl()`	`room.getRecordedPlaybackInfos()`
Flutter	No current public room viewing API found in this audit	Not available	Not available	Not available

Parameters

Concept	Platforms	TypeScript	iOS	Android
Live room post collection	TypeScript, iOS, Android	`getLiveRoomPosts(callback)`	`getLiveRoomPosts()`	`getLiveRoomPosts()`
Community live room posts	TypeScript, iOS, Android	`getCommunityLiveRoomPosts({ communityIds })`	`getCommunityLiveRoomPosts(withIds:)`	`getCommunityLiveRoomPosts(communityIds)`
Room ID in post data	TypeScript, iOS, Android	`post.data.roomId` when `dataType === "room"`	`post.data?["roomId"]` when `dataType == "room"`	`AmityPost.Data.ROOM.getRoomId()`
Observe room	TypeScript, iOS, Android	`RoomRepository.getRoom(roomId, callback)`	`AmityRoomRepository().getRoom(withId:)`	`AmityVideoClient.newRoomRepository().getRoom(roomId)`
Live URL	TypeScript, iOS, Android	`room.livePlaybackUrl`	`room.livePlaybackUrl`	`room.getLivePlaybackUrl()`
Recorded URL	TypeScript, iOS, Android	`room.recordedPlaybackInfos[].url`	`room.recordedData[].playbackUrl`	`room.getRecordedPlaybackInfos()[].url`

Find Live Room Posts

Use live room post collections when your product shows a live shelf or a community-specific live section. Extract the roomId from room post data, then observe the room itself for playback state.

import { PostRepository } from "@amityco/ts-sdk";

function observeCommunityLiveRoomPosts(communityId: string): Amity.Unsubscriber {
  return PostRepository.getCommunityLiveRoomPosts(
    { communityIds: [communityId] },
    snapshot => {
      if (snapshot.error) {
        handleError(snapshot.error);
        return;
      }

      snapshot.data.forEach(post => {
        const roomData = post.data as { roomId?: string } | undefined;

        if (post.dataType === "room" && roomData?.roomId) {
          showSuccessMessage(roomData.roomId);
        }
      });
    },
  );
}

import com.amity.socialcloud.sdk.api.social.AmitySocialClient
import com.amity.socialcloud.sdk.model.social.post.AmityPost

val disposable = AmitySocialClient.newPostRepository()
    .getCommunityLiveRoomPosts(listOf(communityId))
    .subscribe(
        { posts ->
            posts.forEach { post ->
                val roomData = post.getData()

                if (roomData is AmityPost.Data.ROOM) {
                    showSuccessMessage(roomData.getRoomId())
                }
            }
        },
        { error -> handleGeneralError(error) }
    )

var liveRoomPostsToken: AmityNotificationToken?
let liveRoomPosts = AmityPostRepository()
    .getCommunityLiveRoomPosts(withIds: [communityId])

liveRoomPostsToken = liveRoomPosts.observe { collection, error in
    if let error {
        handleGeneralError(error)
        return
    }

    collection.snapshots.forEach { post in
        if post.dataType == "room",
           let roomId = post.data?["roomId"] as? String {
            showSuccessMessage(roomId)
        }
    }
}

Observe Room Playback State

Observe the room record while the viewing screen is open. A live object update can move the UI from waiting, to live playback, to ended, and later to recorded playback.

import { RoomRepository } from "@amityco/ts-sdk";

function observeRoomPlayback(roomId: string): Amity.Unsubscriber {
  return RoomRepository.getRoom(roomId, snapshot => {
    if (snapshot.error) {
      handleError(snapshot.error);
      return;
    }

    const room = snapshot.data;

    if (room.status === "live" && room.livePlaybackUrl) {
      showSuccessMessage(room.livePlaybackUrl);
      return;
    }

    if (room.status === "recorded") {
      showSuccessMessage(room.recordedPlaybackInfos[0]?.url);
      return;
    }

    showSuccessMessage(room.status);
  });
}

import com.amity.socialcloud.sdk.api.video.AmityVideoClient
import com.amity.socialcloud.sdk.model.video.room.AmityRoomStatus

val disposable = AmityVideoClient.newRoomRepository()
    .getRoom(roomId)
    .subscribe(
        { room ->
            when (room.getStatus()) {
                AmityRoomStatus.LIVE -> {
                    room.getLivePlaybackUrl()?.let { showSuccessMessage(it) }
                }
                AmityRoomStatus.RECORDED -> {
                    room.getRecordedPlaybackInfos()
                        .firstOrNull()
                        ?.url
                        ?.let { showSuccessMessage(it) }
                }
                else -> {
                    showSuccessMessage(room.getStatus())
                }
            }
        },
        { error -> handleGeneralError(error) }
    )

var roomObservationToken: AmityNotificationToken?
let roomObject = AmityRoomRepository().getRoom(withId: roomId)

roomObservationToken = roomObject.observe { liveObject, error in
    if let error {
        handleGeneralError(error)
        return
    }

    guard let room = liveObject.snapshot else { return }

    switch room.status {
    case .live, .waitingReconnect:
        showSuccessMessage(room.livePlaybackUrl)
    case .recorded:
        showSuccessMessage(room.recordedData.first?.playbackUrl)
    default:
        showSuccessMessage(room.status.rawValue)
    }
}

Choose a Playback Source

Keep playback source selection small and deterministic. Pass the selected URL to your own player layer only when the SDK room state has a playable source.

function playbackSourceForRoom(room: Amity.Room): string | undefined {
  if (room.status === "live" || room.status === "waitingReconnect") {
    return room.livePlaybackUrl;
  }

  if (room.status === "recorded") {
    return room.recordedPlaybackInfos[0]?.url;
  }

  return undefined;
}

import com.amity.socialcloud.sdk.model.video.room.AmityRoom
import com.amity.socialcloud.sdk.model.video.room.AmityRoomStatus

fun playbackSourceForRoom(room: AmityRoom): String? {
    return when (room.getStatus()) {
        AmityRoomStatus.LIVE,
        AmityRoomStatus.WAITING_RECONNECT -> room.getLivePlaybackUrl()
        AmityRoomStatus.RECORDED -> room.getRecordedPlaybackInfos()
            .firstOrNull()
            ?.url
        else -> null
    }
}

func playbackSource(for room: AmityRoom) -> String? {
    switch room.status {
    case .live, .waitingReconnect:
        return room.livePlaybackUrl
    case .recorded:
        return room.recordedData.first?.playbackUrl
    default:
        return nil
    }
}

Status Handling

Status	Viewer behavior
`idle`	Show a waiting or scheduled state.
`live`	Use the live playback URL when present.
`waitingReconnect`	Keep the player UI available, but show reconnecting state if playback stalls.
`ended`	Stop live playback and show a processing state while recorded playback is not ready.
`recorded`	Use recorded playback metadata.
`error`	Show a recoverable error state and let the user retry or leave.

If a room is live but the SDK returns no live playback URL, do not invent a fallback URL. Treat it as unavailable for the current viewer and show a product-specific blocked, unavailable, or retry state.

Player Boundary

Area	Owned by social.plus SDK	Owned by your app/player
Discovery	Live room post collections and room IDs	Placement, ranking, and empty states
State	Room status and live object updates	Player state machine and user-facing copy
Playback source	`livePlaybackUrl` and recorded playback metadata	AVPlayer, ExoPlayer, HLS.js, web video, buffering, and errors
Cleanup	Observer unsubscribe, token release, Rx disposal	Player teardown and audio/video session cleanup

Start Broadcasting

Fetch broadcaster credentials and start the host-side media session.

Manage Rooms

Observe, stop, update, or delete room records.

Recorded Playback

Handle recorded playback after a live room ends.

Powered by

Getting Started

Fundamentals

Social

Chat

Video

Release Notes

Migration Guides

Support

Platform Surface

Parameters

Find Live Room Posts

Observe Room Playback State

Choose a Playback Source

Status Handling

Player Boundary

Start Broadcasting

Manage Rooms

Recorded Playback

​Platform Surface

​Parameters

​Find Live Room Posts

​Observe Room Playback State

​Choose a Playback Source

​Status Handling

​Player Boundary

​Related Topics

Start Broadcasting

Manage Rooms

Recorded Playback

Platform Surface

Parameters

Find Live Room Posts

Observe Room Playback State

Choose a Playback Source

Status Handling

Player Boundary

Related Topics