# Manage breakout rooms

<!-- WARNING: THIS FILE WAS AUTOGENERATED! DO NOT EDIT! -->

> The code on this page works with either the **default UI** or the **custom UI**.

Manage breakout room related functionality in the Meeting SDK for iOS. There are five distinct breakout room
roles, each with its own associated interface and ability to perform certain pieces of breakout room
functionality. These roles are assigned according to a combination of in-client meeting roles and the
user's platform.

To know when you can have a user perform a given task, listen for role changes in the `MobileRTCMeetingServiceDelegate`.

## Listen for role changes

To know when the current user's role has changed, extend your class with the `MobileRTCMeetingServiceDelegate`.

```swift
if let meetingService = MobileRTC.shared().getMeetingService() {
meetingService.delegate = self
}

extension ViewController: MobileRTCMeetingServiceDelegate {

}
```

ViewController.h

```objectivec
#import <UIKit/UIKit.h>
//Import the Zoom SDK library
#import <MobileRTC/MobileRTC.h>
// Change the interface declaration to conform to the Meeting Service Delegate
@interface ViewController : UIViewController <MobileRTCMeetingServiceDelegate>
```

ViewController.m

```objectivec
- (void)joinMeeting:(NSString *)meetingNumber meetingPassword:(NSString *)meetingPassword {
    // Obtain the MobileRTCMeetingService from the Zoom SDK, this service can start, join, leave, etc. meetings
    MobileRTCMeetingService *meetService = [[MobileRTC sharedRTC] getMeetingService];
		if (meetService) {
 		 // Set the ViewContoller to be the MobileRTCMeetingServiceDelegate
        meetService.delegate = self
        MobileRTCMeetingJoinParam *joinParams = [[MobileRTCMeetingJoinParam alloc] init];
        joinParams.meetingNumber = meetingNumber;
        joinParams.password = meetingPassword;
        [meetService joinMeetingWithJoinParam:joinParams];
  }
}
```

This delegate has two callbacks associated with each role. One callback indicates that the current user has
been assigned that role, and the other that the user has been unassigned from the role. For example, Zoom
calls `onHasCreatorRightsNotification` when the meeting host has the ability to create breakout rooms. When
they no longer have this ability, Zoom invokes `onLostCreatorRightsNotification`.

When a role is assigned to a user, the related callback includes a parameter for the interface that exposes
the role's functionality. Store a reference to this interface when you receive the callback up until you
receive a callback indicating that this role is no longer available.

## The roles

These five roles let users perform the various breakout room functions. Any given user can be assigned to
multiple breakout room roles at a time.

-   [Data](#the-data-role) (`MobileRTCBOData`) - Access users' data in breakout rooms, including which users are assigned to various breakout rooms, users' names, and breakout rooms' names.
-   [Admin](#the-admin-role) (`MobileRTCBOAdmin`) - Manages existing breakout rooms and receives help requests from users in breakout rooms.
-   [Creator](#the-creator-role) (`MobileRTCBOCreator`) - Directly creates and modifies breakout rooms. The creator and admin roles are usually assigned to the same user.
-   [Assistant](#the-assistant-role) (`MobileRTCBOAssistant`) - The assistant role is a minor role, similar to an attendee. Assistant role holders can join any breakout room directly without being assigned to it.
-   [Attendee](#the-attendee-role) (`MobileRTCBOAttendee`) - A regular user who can join breakout rooms.

### The data role

When a user receives the `onHasDataHelperRightsNotification` callback, that user can access role-related
functionality through `MobileRTCBOData`.

```swift
func onHasDataHelperRightsNotification(_ dataHelper: MobileRTCBOData) {
yourDataHelper = dataHelper
}
```

```objectivec
- (void)onHasDataHelperRightsNotification:(MobileRTCBOData * _Nonnull)dataHelper
{
	yourDataHelper = dataHelper;
}
```

Rely on the callbacks to determine when `MobileRTCBOData` is accessible. You can also get an instance directly.

```swift
if let dataHelper = MobileRTC.shared().getMeetingService()?.getDataHelper() {
yourDataHelper = dataHelper
}
```

```objectivec
MobileRTCMeetingService *meetingService = [[MobileRTC sharedRTC] getMeetingService];
MobileRTCBOData *dataHelper = [meetingService getDataHelper];
if (dataHelper) {
    yourDataHelper = dataHelper;
}
```

The breakout data role receives notifications when data is updated through the callbacks under the `MobileRTCMeetingServiceDelegate`.

```swift
func onBOInfoUpdated(_ boId: String?) {

}

func onBOListInfoUpdated() {

}

func onUnAssignedUserUpdated() {

}
```

```objectivec
- (void)onBOInfoUpdated:(NSString *)boId {

}


- (void)onBOListInfoUpdated {

}


- (void)onUnAssignedUserUpdated {

}
```

#### Data-role tasks

[Get information on breakout rooms](#get-information-on-breakout-rooms), [get user information](#get-user-information)

### The admin role

When a user receives the `onHasAdminRightsNotification` callback, that user can access role-related functionality
through `MobileRTCBOAdmin`.

```swift
func onHasAdminRightsNotification(_ admin: MobileRTCBOAdmin) {
    adminHelper = admin
}
```

```objectivec
- (void)onHasAdminRightsNotification:(MobileRTCBOAdmin *)admin {
    adminHelper = admin;
}
```

Rely on the callbacks to determine when `MobileRTCBOAdmin` is accessible. You can also get an instance directly.

```swift
if let adminHelper = MobileRTC.shared().getMeetingService()?.getAdminHelper() {
    yourAdminHelper = adminHelper
}
```

```objectivec
MobileRTCMeetingService *meetingService = [[MobileRTC sharedRTC] getMeetingService];
MobileRTCBOAdmin *adminHelper = [meetingService getAdminHelper];
if (adminHelper) {
    yourAdminHelper = adminHelper;
}
```

The breakout admin can receive notifications when other users send a help request through the `MobileRTCMeetingServiceDelegate`.

```swift
func onHelpRequestReceived(_ strUserID: String?) {

}

func onStartBOError(_ errType: MobileRTCBOControllerError) {

}

func onBOEndTimerUpdated(_ remaining: UInt, isTimesUpNotice: Bool) {

}
```

```objectivec
- (void)onHelpRequestReceived:(NSString *)strUserID {

}

- (void)onStartBOError:(MobileRTCBOControllerError)errType {

}

- (void)onBOEndTimerUpdated:(NSUInteger)remaining isTimesUpNotice:(BOOL)isTimesUpNotice {

}
```

#### Admin-role tasks

[Receive users' help requests](#receive-users-help-requests), [assign users to existing breakout rooms](#assign-users-to-existing-breakout-rooms), [broadcast messages into breakout rooms](#broadcast-messages-into-breakout-rooms), [invite users back into the main room](#invite-users-back-into-the-main-room), [respond to help requests from breakout rooms](#respond-to-help-requests-from-breakout-rooms), [start or stop breakout rooms](#start-or-stop-breakout-rooms)

### The creator role

When a user receives the `onHasCreatorRightsNotification` callback, that user can access role-related
functionality through `MobileRTCBOCreator`.

```swift
func onHasCreatorRightsNotification(_ creator: MobileRTCBOCreator) {
    creatorHelper = creator
}
```

```objectivec
- (void)onHasCreatorRightsNotification:(MobileRTCBOCreator *)creator {
	creatorHelper = creator
}
```

Rely on the callbacks to know when `MobileRTCBOCreator` is accessible. You can also get an instance directly.

```swift
if let creatorHelper = MobileRTC.shared().getMeetingService()?.getAdminHelper() {
    yourCreatorHelper = creatorHelper
}
```

```objectivec
MobileRTCMeetingService *meetingService = [[MobileRTC sharedRTC] getMeetingService];
MobileRTCBOCreator *creatorHelper = [meetingService getCreatorHelper];
if (creatorHelper) {
    yourCreatorHelper = creatorHelper;
}
```

The creator receives notifications related to breakout room creation through the `MobileRTCMeetingServiceDelegate`.

```swift
func onCreateBOResponse(_ success: Bool, boid BOID: String?) {

}

func onWebPreAssignBODataDownloadStatusChanged(_ status: MobileRTCBOPreAssignBODataStatus) {

}
```

```objectivec
- (void)onCreateBOResponse:(BOOL)success BOID:(NSString *_Nullable)BOID {

}


- (void)onWebPreAssignBODataDownloadStatusChanged:(MobileRTCBOPreAssignBODataStatus)status {

}
```

#### Creator-role tasks

[Create a breakout room](#create-a-breakout-room), [manage a breakout room](#manage-a-breakout-room), [preassign users to breakout rooms](#preassign-users-to-breakout-rooms), [configure breakout rooms](#configure-breakout-rooms)

### The assistant role

The assistant role is a minor role similar to an attendee. Assistant role holders can join any breakout room
directly without being assigned to it. Use the `boId`, available through `MobileRTCBOData`, to join a
specific room.

```swift
if let assistantHelper = MobileRTC.shared().getMeetingService()?.getAssistantHelper() {
    assistantHelper.joinBO(boID)
    assistantHelper.leaveBO()
}
```

```objectivec
MobileRTCMeetingService *meetingService = [[MobileRTC sharedRTC] getMeetingService];
MobileRTCBOAssistant *assistantHelper = [meetingService getAssistantHelper];
if (assistantHelper) {
	[assistantHelper joinBO:boId];
[assistantHelper leaveBO];
}
```

### The attendee role

When a user receives the `onHasAttendeeRightsNotification` callback, that user can access role-related
functionality through `MobileRTCBOAttendee`.

```swift
func onHasAttendeeRightsNotification(_ attendee: MobileRTCBOAttendee) {
    yourAttendeeHelper = attendee
}
```

```objectivec
- (void)onHasAttendeeRightsNotification:(MobileRTCBOAttendee *)attendee {
    yourAttendeeHelper = attendeeHelper;
}
```

Rely on the callbacks to know when `MobileRTCBOAttendee` is accessible. You can also get an instance directly.

```swift
if let attendeeHelper = MobileRTC.shared().getMeetingService()?.getAttendeeHelper() {
    yourAttendeeHelper = attendeeHelper
}
```

```objectivec
MobileRTCMeetingService *meetingService = [[MobileRTC sharedRTC] getMeetingService];
MobileRTCBOAttendee *attendeeHelper = [meetingService getAttendeeHelper];
if (attendeeHelper) {
    yourAttendeeHelper = attendeeHelper;
}
```

Breakout attendees receive notifications related to the host's actions through the `MobileRTCMeetingServiceDelegate`.

```swift
func onHelpRequestHandleResultReceived(_ eResult: MobileRTCBOHelpReply) {

}

func onHostJoinedThisBOMeeting() {

}

func onHostLeaveThisBOMeeting() {

}
```

```objectivec
- (void)onHelpRequestHandleResultReceived:(MobileRTCBOHelpReply)eResult {

}

- (void)onHostJoinedThisBOMeeting {

}

- (void)onHostLeaveThisBOMeeting {

}
```

#### Attendee-role tasks

[Join or leave breakout rooms as an attendee](#join-or-leave-breakout-rooms-as-an-attendee), [ask for admin help](#ask-for-admin-help)

## Get information about breakout rooms

Users with the **data role** can perform this task.

Each breakout room is associated with a `MobileRTCBOMeeting` object and breakout ID. Once you have
[listened for the role change](#listen-for-role-changes) and
[received the `onHasDataHelperRightsNotification` callback](#the-data-role), access a list of breakout
rooms at any time and get information about each room.

```swift
guard let meetingIDList = dataHelper.getBOMeetingIDList() as? [String] else { return }
for meetingID in meetingIDList {
    if let currentMeetingInfo = dataHelper.getBOMeeting(byID: meetingID) {
        currentMeetingInfo.getName()
        currentMeetingInfo.getId()
        currentMeetingInfo.getUserList()
        currentMeetingInfo.getBOUserStatus(withUserID: breakoutUserId)
    }
}
```

```objectivec
NSArray<NSString *> *meetingIDList = [dataHelper getBOMeetingIDList];
if (meetingIDList) {
    for (NSString *meetingID in meetingIDList) {
        MobileRTCBOMeeting *currentMeetingInfo = [dataHelper getBOMeetingByID:meetingID];
        if (currentMeetingInfo) {
            [currentMeetingInfo getBOMeetingName];
            [currentMeetingInfo getBOMeetingId];
            [currentMeetingInfo getBOMeetingUserList];
            [currentMeetingInfo getBOUserStatusWithUserID:breakoutUserId];
        }
    }
}
```

## Get user information

Users with the **data role** can perform this task.

Once you have [listened for the role change](#listen-for-role-changes) and
[received the `onHasDataHelperRightsNotification` callback](#the-data-role), get a list of unassigned users
by using `getUnassignedUserList` to provide a list of IDs. These user IDs are specific to breakout rooms, and
can be used to uniquely identify each user. Use this ID to assign that user to a breakout room or to get
more data about that user.

```swift
guard let unassignedUserList = dataHelper.getUnassignedUserList() as? [String] else { return }
for userBOID in unassignedUserList {
    dataHelper.getBOUser(byUserID: userBOID)
    dataHelper.isBOUserMyself(userBOID)
}
```

```objectivec
NSArray<NSString *> *unassignedUserList = [dataHelper getUnassignedUserList];
if (unassignedUserList) {
    for (NSString *userBOID in unassignedUserList) {
        [dataHelper getBOUserByUserID:userBOID];
        [dataHelper isBOUserMyself:userBOID];
    }
}
```

To get the name of the current user's assigned breakout room, use `getCurrentBoName`.

```swift
dataHelper.getCurrentBOName()
```

```objectivec
[dataHelper getCurrentBOName];
```

You can also get the user's name based on their breakout user ID.

```swift
dataHelper.getBOUser(byUserID: userBOID)?.getName()
```

```objectivec
[[dataHelper getBOUserByUserID:userBOID] getUserName];
```

To see your currently assigned breakout room's name, use `boName`.

```swift
yourAttendeeHelper.getBOName()
```

```objectivec
[yourAttendeeHelper getBOName];
```

## Receive users' help requests

Users with the **admin role** can perform this task.

Once you have [listened for the role change](#listen-for-role-changes) and
[received the `onHasAdminRightsNotification` callback](#the-data-role), admins receive notifications
through `MobileRTCBOAdmin` when other users send a help request.

```swift
func onHelpRequestReceived(_ strUserID: String?) {

}

func onStartBOError(_ errType: MobileRTCBOControllerError) {

}

func onBOEndTimerUpdated(_ remaining: UInt, isTimesUpNotice: Bool) {

}
```

```objectivec
- (void)onHelpRequestReceived:(NSString *)strUserID {

}


- (void)onStartBOError:(MobileRTCBOControllerError)errType {

}


- (void)onBOEndTimerUpdated:(NSUInteger)remaining isTimesUpNotice:(BOOL)isTimesUpNotice {

}
```

## Assign users to existing breakout rooms

Users with the **admin role** can perform this task.

To assign users to breakout rooms that haven't been started yet, see the creator-role task
[Preassign users to breakout rooms](#preassign-users-to-breakout-rooms).

Once you have [listened for the role change](#listen-for-role-changes) and [received the `onHasAdminRightsNotification` callback](#the-admin-role), assign a user to an existing breakout room by using `assignNewUserToRunningBO`. The `userId` and `breakoutId` are available through `MobileRTCBOData`.

```swift
adminHelper.assignNewUser(boUserID, toRunningBO: boID)
```

```objectivec
[adminHelper assignNewUser:boUserID toRunningBO:boID];
```

To switch an already-assigned user to a different breakout room, use `switchAssignedUserToRunningBO`.
The `userId` and `breakoutId` are available through `MobileRTCBOData`.

```swift
adminHelper.switchUser(boUserID, toRunningBO: boID)
```

```objectivec
[adminHelper switchUser:boUserID toRunningBO:boID];
```

## Broadcast messages into breakout rooms

Users with the **admin role** can perform this task.

Once you have [listened for the role change](#listen-for-role-changes) and
[received the `onHasAdminRightsNotification` callback](#the-admin-role), broadcast a message
to all breakout rooms using `broadcastMessage`.

```swift
adminHelper.broadcastMessage(message)
```

```objectivec
[adminHelper broadcastMessage:message];
```

## Invite users back into the main room

Users with the **admin role** can perform this task.

Once you have [listened for the role change](#listen-for-role-changes) and [received the `onHasAdminRightsNotification` callback](#the-admin-role), invite a specific user back into the main meeting by using `inviteBOUserReturnToMainSession`. The userId is available through MobileRTCBOData.

```swift
adminHelper.inviteBOUserReturn(toMainSession: boUserID)
```

```objectivec
[admin inviteBOUserReturnToMainSession:boUserID];
```

##Respond to help requests from breakout rooms

Users with the **admin role** can perform this task.

Once you have [listened for the role change](#listen-for-role-changes) and [received the `onHasAdminRightsNotification` callback](#the-admin-role), and after receiving the `onHelpRequestReceived` callback, either accept the request and join that user's breakout room, or ignore it and stay in the current meeting.

```swift
func onHelpRequestReceived(_ strUserID: String?) {
    adminHelper.joinBO(byUserRequest: strUserID)
    adminHelper.ignoreUserHelpRequest(strUserID)
}
```

```objectivec
- (void)onHelpRequestReceived:(NSString *)strUserID {
    [adminHelper joinBOByUserRequest: strUserID];
    [adminHelper ignoreUserHelpRequest: strUserID];
}
```

## Start or stop breakout rooms

Users with the **admin role** can perform this task.

Once you have [listened for the role change](#listen-for-role-changes) and [received the `onHasAdminRightsNotification` callback](#the-admin-role), admins can start or stop breakout rooms for the whole meeting.

```swift
if adminHelper.canStartBO() {
    adminHelper.startBO()
}

adminHelper.stopBO()
```

```objectivec
if ([admin canStartBO]) {
    [admin startBO];
}

[admin stopBO];
```

## Create a breakout room

Users with the **creator role** can perform this task.

Once you have [listened for the role change](#listen-for-role-changes) and [received the `onHasCreatorRightsNotification` callback](#the-creator-role), create a single breakout room by choosing a name for the room and passing it to `createBreakoutRoom`. To batch create breakout rooms, pass a list of names into `createGroupBO`.

```swift
creatorHelper.createBreakoutRoom(boName)
creatorHelper.createGroupBO(boNameList)
```

```objectivec
[creator createBreakoutRoom:boName];
[creator createGroupBO:boNameList];
```

Once a breakout room is created, you'll receive the `onCreateBOResponse` callback.

After receiving this callback, the creator can now assign and remove users, remove a breakout room, or
update the name of an existing room. The `userId` and `breakoutId` used in these methods are available
through `MobileRTCBOData`.

### Receive breakout room creation notices

Users with the **creator role** can perform this task.

Once you have [listened for the role change](#listen-for-role-changes) and [received the `onHasCreatorRightsNotification` callback](#the-creator-role), the creator receives breakout room creation notifications through `MobileRTCMeetingServiceDelegate`.

```swift
func onCreateBOResponse(_ success: Bool, boid BOID: String?) {

}

func onWebPreAssignBODataDownloadStatusChanged(_ status: MobileRTCBOPreAssignBODataStatus) {

}
```

```objectivec
- (void)onCreateBOResponse:(BOOL)success BOID:(NSString *_Nullable)BOID {

}

- (void)onWebPreAssignBODataDownloadStatusChanged:(MobileRTCBOPreAssignBODataStatus)status {

}
```

## Manage breakout rooms

Users with the **creator role** can perform these tasks.

Perform any of these tasks once you have [listened for the role change](#listen-for-role-changes) and
[received the `onHasCreatorRightsNotification` callback](#the-creator-role).

### Assign users to breakout rooms that haven't yet started

```swift
creatorHelper.assignUser(boUserID, toBO: boID)
creatorHelper.removeUser(boUserID, fromBO: boID)
```

```objectivec
[creatorHelper assignUser:boUserID toBO:boID];
[creatorHelper removeUser:boUserID fromBO:boID];
```

### Remove a breakout room from the list of available rooms

Once breakout rooms are created, you can remove them from the list of available breakout rooms. The room itself is only ever deleted by Zoom's back end. Developers can't delete breakout rooms.

```swift
creatorHelper.removeBO(boID)
```

```objectivec
[creatorHelper removeBO:boID];
```

### Change a breakout room's name

```swift
creatorHelper.updateBO(boID, name: newBOName)
```

```objectivec
[creator updateBO:boID name:newBOName];
```

## Preassign users to breakout rooms

Users with the **creator role** can perform this task.

This task lets you assign users to breakout rooms that haven't been started. To assign users to breakout rooms that are already started, see the admin-role task [Assign users to existing breakout rooms](#assign-users-to-existing-breakout-rooms).

Once you have [listened for the role change](#listen-for-role-changes) and [received the `onHasCreatorRightsNotification` callback](#the-creator-role), if the meeting allows you to preassign breakout rooms, apply those preassignments through `requestAndUseWebPreAssignBOList`.

```swift
if (creator.isWebPreAssignBOEnabled()) {
    creator.requestAndUseWebPreAssignBOList()
}
```

```objectivec
if ([creator isWebPreAssignBOEnabled]) {
    [creator requestAndUseWebPreAssignBOList];
}
```

To get updates on the creation, assignment, or preassignment of breakout rooms, use the `onWebPreAssignBODataDownloadStatusChanged` callback.

```swift
func onWebPreAssignBODataDownloadStatusChanged(_ status: MobileRTCBOPreAssignBODataStatus) {

}
```

```objectivec
- (void)onWebPreAssignBODataDownloadStatusChanged:(MobileRTCBOPreAssignBODataStatus)status {

}
```

## Configure breakout rooms

Users with the **creator role** can perform this task.

Once you have [listened for the role change](#listen-for-role-changes) and [received the `onHasCreatorRightsNotification` callback](#the-creator-role), configure breakout rooms by setting the various options through a `MobileRTCBOOption` object.

-   `countdownSeconds` - The number of seconds until breakout rooms automatically close for all users.
-   `isAttendeeCanChooseBO` - Whether attendees in a webinar can select their own breakout rooms.
-   `isAttendeeContained` - Whether webinar attendees are allowed to join webinar breakout rooms.
-   `isAutoMoveAllAssignedParticipantsEnabled` - Whether all assigned participants are automatically moved into their respective breakout room.
-   `isBOTimerEnabled` - Whether setting a timer for breakout rooms is enabled.
-   `isPanelistCanChooseBO` - Whether panelists in a webinar can select their own breakout rooms.
-   `isParticipantCanChooseBO` - Whether participants in a meeting can select their own breakout rooms.
-   `isParticipantCanReturnToMainSessionAtAnyTime - Whether participants in a meeting can return to the main session before the admin has ended breakout rooms.
-   `isTimerAutoStopBOEnabled` - Whether stopping breakout rooms automatically after a set time is supported.
-   `isUserConfigMaxRoomUserLimitsEnabled` - Whether setting a maximum number of users per breakout room is supported.
-   `nUserConfigMaxRoomUserLimits` - The maximum number of users that can join a breakout room, if enabled.
-   `timerDuration` - The amount of time before breakout rooms automatically end, if enabled.

After setting any of these options on the `BOOption` object, update the settings by passing the option setting into the `MobileRTCBOCreator` instance.

```swift
let option = MobileRTCBOOption()
option.countdownSeconds = MobileRTCBOStopCountDown_Seconds_60
if let creator = MobileRTC.sharedRTC().getMeetingService()?.getCreatorHelper() {
    let ret = creator.setBOOption(option)
    if ret != .success {
        // An error occurred during setBOOption. Please refer to the MobileRTCSDKError enum for details.
    }
}
```

```objectivec
MobileRTCBOOption *option = [[MobileRTCBOOption alloc] init];
option.countdownSeconds = MobileRTCBOStopCountDown_Seconds_60;
MobileRTCBOCreator *creator = [[[MobileRTC sharedRTC] getMeetingService] getCreatorHelper];
if (creator) {
    MobileRTCSDKError ret = [creator setBOOption:option];
    if (ret != MobileRTCSDKError_Success) {
        //An error occurred during setBOOption. Please refer to the MobileRTCSDKError enum for details.
    }
}
```

Access the current breakout configuration through the same interface.

```swift
if let currentBOOption = creatorHelper.getBOOption(), currentBOOption.isBOTimerEnabled {
    // Timer is enabled and can be set by the creator role
}
```

```objectivec
if ([creatorHelper getBOOption] != nil) {
    MobileRTCBOOption *currentBOOption = [creatorHelper getBOOption];
    if (currentBOOption.isBOTimerEnabled) {
        // Timer is enabled and can be set by the creator role
    }
}
```

## Join or leave breakout rooms as an attendee

Users with the **attendee role** can perform these task.

Once you have [listened for the role change](#listen-for-role-changes) and [received the `onHasAttendeeRightsNotification` callback](#the-attendee-role), join a breakout room by using `joinBO`.

```swift
attendee.joinBO()
```

```objectivec
[attendee joinBO];
```

To leave the current breakout room and return to the main meeting, use `leaveBO`.

```swift
if (attendee.isCanReturnMainSession()) {
    attendee.leaveBO()
}
```

```objectivec
if (attendee.isCanReturnMainSession) {
    [attendee leaveBO];
}
```

## Ask for admin help

Users with the **attendee role** can perform this task.

Once you have [listened for the role change](#listen-for-role-changes) and [received the `onHasAttendeeRightsNotification` callback](#the-attendee-role), request help from the breakout room admin by using `requestForHelp`. If the admin is already in the same breakout room as you, you don't need to send a help request.

```swift
if (!attendee.isHostInThisBO()) {
    attendee.requestForHelp()
}
```

```objectivec
if (!attendee.isHostInThisBO) {
    [attendee requestForHelp];
}
```

---