Join and Leave Channels

Use join and leave operations when the current user needs to enter or exit an existing channel. Joining does not create a missing channel, and conversation channels are already membership-managed by the SDK, so calling join or leave on a conversation channel can fail on platforms that enforce that restriction.

Platform Surface

Operation	TypeScript	iOS	Android	Flutter
Join channel	`ChannelRepository.joinChannel(channelId)`	`channelRepository.joinChannel(channelId:)`	`joinChannel(channelId)`	`joinChannel(channelId)`
Leave channel	`ChannelRepository.leaveChannel(channelId)`	`channelRepository.leaveChannel(channelId:)`	`leaveChannel(channelId)`	`leaveChannel(channelId)`
Join result	`Promise<boolean>`	`AmityChannel`	`Single<AmityChannel>`	`Future`
Leave result	`Promise<boolean>`	`Void`	`Completable`	`Future`
Current membership	`channel.myMembership(callback)`	`channel.currentUserMembership` or `channel.myMembership()`	`membership(channelId).getMyMembership()`	`membership(channelId).getMyMembership()`

Parameters

Operation	Parameter	Required	Description
Join channel	`channelId`	Yes	Existing channel ID that the current user should join.
Leave channel	`channelId`	Yes	Channel ID that the current user should leave.
Check membership	`channelId`	Yes	Channel ID whose current-user membership should be inspected.
Check membership	Channel object	Depends	TypeScript and iOS can also read membership state from an observed channel object.
Check membership	Observer / disposable	Depends	Required by live APIs when observing channel or membership changes.

Join A Channel

Join adds the current user as a member of an existing channel. On iOS, joining an already joined channel returns the existing channel. On TypeScript, the API returns true when the returned membership is member.

import { ChannelRepository } from '@amityco/ts-sdk';

const didJoin = await ChannelRepository.joinChannel(channelId);

if (didJoin) {
  showSuccessMessage(channelId);
}

let joinedChannel = try await channelRepository.joinChannel(channelId: channelId)

showSuccessMessage(joinedChannel.channelId)

val disposable = AmityChatClient.newChannelRepository()
    .joinChannel(channelId = channelId)
    .subscribe(
        { joinedChannel -> showSuccessMessage(joinedChannel.getChannelId()) },
        { error -> handleGeneralError(error) },
    )

final channelRepository = AmityChatClient.newChannelRepository();

await channelRepository.joinChannel(channelId);

Leave A Channel

Leave removes the current user’s membership from the channel. After leaving, stop routing the user into the channel UI and refresh any channel list or unread-count state that depends on membership.

import { ChannelRepository } from '@amityco/ts-sdk';

const didLeave = await ChannelRepository.leaveChannel(channelId);

if (didLeave) {
  showSuccessMessage(channelId);
}

try await channelRepository.leaveChannel(channelId: channelId)

showSuccessMessage(channelId)

val disposable = AmityChatClient.newChannelRepository()
    .leaveChannel(channelId = channelId)
    .subscribe(
        { showSuccessMessage(channelId) },
        { error -> handleGeneralError(error) },
    )

final channelRepository = AmityChatClient.newChannelRepository();

await channelRepository.leaveChannel(channelId);

Check Current Membership

Use current membership state to hide composer controls, redirect banned users, or distinguish a channel that is only visible from one the user has joined.

const unsubscribe = channel.myMembership(({ data: membership, error }) => {
  if (error) handleError(error);

  if (membership?.membership === 'banned') {
    updateUI(membership);
  }
});

unsubscribe();

var token: AmityNotificationToken?

token = channelRepository.getChannel(channelId).observe { liveObject, error in
    if let error {
        handleError(error)
        return
    }

    guard let channel = liveObject.snapshot else { return }

    switch channel.currentUserMembership {
    case .member:
        showSuccessMessage("member")
    case .banned:
        showSuccessMessage("banned")
    case .none:
        showSuccessMessage("none")
    @unknown default:
        break
    }
}

val disposable = AmityChatClient.newChannelRepository()
    .membership(channelId = channelId)
    .getMyMembership()
    .subscribe(
        { membership ->
            when (membership.getMembershipType()) {
                AmityMembershipType.MEMBER -> showSuccessMessage("member")
                AmityMembershipType.BANNED -> showSuccessMessage("banned")
                AmityMembershipType.NONE -> showSuccessMessage("none")
            }
        },
        { error -> handleGeneralError(error) },
    )

final membership = await AmityChatClient.newChannelRepository()
    .membership(channelId)
    .getMyMembership();

final isBanned = membership.isBanned == true;

Query Members

Retrieve and filter channel members.

Preview Members

Render lightweight participant previews where the SDK exposes them.

Get Channels

Load channel objects before routing users into a chat screen.

Ban Management

Handle moderation states that affect membership.

Powered by

Getting Started

Fundamentals

Social

Chat

Video

Release Notes

Migration Guides

Support

Join and Leave Channels

Platform Surface

Parameters

Join A Channel

Leave A Channel

Check Current Membership

Query Members

Preview Members

Get Channels

Ban Management

​Platform Surface

​Parameters

​Join A Channel

​Leave A Channel

​Check Current Membership

​Related Topics

Query Members

Preview Members

Get Channels

Ban Management

Platform Surface

Parameters

Join A Channel

Leave A Channel

Check Current Membership

Related Topics