Conference Room

ArctosLinks.Conference provides a set of APIs to manage and control various operations in a conference room.
These functionalities include creating and closing conference rooms, handling join requests, removing participants, updating room information, adjusting screen layouts, and more.

ArctosLinks.ConferenceEventCallback provides event callback notifications that help developers handle various events in the conference room. To observe these notifications, iOS developers need to import RxSwift, and Android developers need to import coroutines flow. These libraries are not included in this SDK, please import them yourself.

Here is how to use this SDK to implement these operations.

Host Only

host create room

Function: Create a new conference room. Only users logged in as host can perform this operation.

Parameters:

roomName: The title of the conference room, type is String.
description: Detailed description of the conference room, type is String.

Return Value: If the conference room is successfully created, it completes; otherwise, it returns an error.

Swift

import ArctosLinks
import RxSwift

func hostCreateRoom(roomName: String = "Weekly Meeting", description: String? = "Discuss weekly updates") {
    _ = ArctosLinks.Conference.hostCreateRoom(roomName: roomName, description: description)
        .subscribe(onSuccess: { _ in
            print("🎉 Successfully created conference room.")
        }, onFailure: { error in
            print("Conference room creation failed: \(error.localizedDescription)")
        })
}

Kotlin

import com.arctos.sdk.links.core.application.ArctosLinks

private suspend fun hostCreateRoom(roomName: String = "Weekly Meeting", description: String = "Discuss weekly updates") {
    runCatching {
        ArctosLinks.getInstance(Context).conferenceManager.hostCreateRoom(roomName = roomName, description = description)
            .getOrThrow()
    }.onSuccess { result ->
        if (result) 
            Log.d(TAG, "Meeting room created successfully")        
        else 
            Log.d(TAG, "Failed to create meeting room")
    }.onFailure {
        Log.d(TAG, "Failed to create meeting room: ${it.message}")
    }
}

c++

#include "arctos_qt.h"

void hostCreateRoom(const std::string& name, const std::string& description) {
    auto& arctos_app = arctos::ArctosQt::getInstance();
    arctos_app.hostCreateRoom(name.c_str(), description.c_str()); // emit roomCreationFailed signal when failed
}

host close room

Function: Host closes the conference room. Only the host who created the room can perform this operation.

Parameters:

roomId: The ID of the conference room, type is String.

Return Value: If the conference room is successfully closed, it completes; otherwise, it returns an error.

Trigger Callback: Host Closes Conference Room

Swift

import ArctosLinks
import RxSwift

func hostCloseRoom(roomId: String = "unique_room_id") {
    _ = ArctosLinks.Conference.hostCloseRoom(roomId: roomId)
        .subscribe(onSuccess: { _ in
            print("🎉 Successfully closed room.")
        }, onFailure: { error in
            print("Failed to close room: \(error.localizedDescription)")
        })
}

Kotlin

import com.arctos.sdk.links.core.application.ArctosLinks
    
private suspend fun hostCloseRoom(roomId: String = "unique_room_id") {
    runCatching {
        ArctosLinks.getInstance(Context).conferenceManager.hostCloseRoom(roomId = roomId)
            .getOrThrow()           
    }.onSuccess { result ->
        if (result)
            Log.d(TAG, "Meeting room closed successfully")                                
        else 
            Log.d(TAG, "Failed to close meeting room")            
    }.onFailure {
        Log.d(TAG, "Failed to close meeting room ${it.message}")            
    }
}

c++

#include "arctos_qt.h"

void hostCloseRoom(const std::string& room_id) {
    auto& arctos_app = arctos::ArctosQt::getInstance();
    arctos_app.hostRemoveRoom(room_id.c_str()); // emit roomRemovingFailed signal when failed
}

host join handle

Function: Host handles the request of an applicant to join the conference room. Only the host of the conference room can perform this operation.

Parameters:

roomId: The ID of the conference room, type is String.
applicantId: The ID of the applicant, type is Int.
accept: Whether to accept the application, type is Bool.
message: Approval or rejection message, type is String.

Return Value: If the request is successfully handled, it completes; otherwise, it returns an error.

Trigger Callback: Response to Join Room Request

Swift

import ArctosLinks
import RxSwift

func hostHandleJoinRequest(at roomId: String = "unique_room_id", for applicantId: Int = .min, isAccept: Bool = Bool.random()) {
    let message: String = isAccept ? "Welcome!" : "Sorry, all available places have been taken."
    _ = ArctosLinks.Conference.hostJoinHandle(roomId: roomId, applicantId: applicantId, accept: isAccept, message: message)
        .subscribe(onSuccess: { _ in
            if isAccept {
                print("Approved applicant to join room.")                
            } else {                
                print("Disapproved applicant to join room.")                
            }
        }, onFailure: { error in
            print("Failed to handle join request: \(error.localizedDescription)")
        })
}

Kotlin

import com.arctos.sdk.links.core.application.ArctosLinks

private suspend fun hostHandleJoinRequest(
    roomId: String,
    applicantId: String,
    accept: Boolean,
    message: String? = "Welcome!"
) {        
    runCatching {
        ArctosLinks.getInstance(Context).conferenceManager.hostJoinHandle(
            roomId = roomId,
            applicantId = applicantId,
            accept = accept,
            message = message
        ).getOrThrow()
    }.onSuccess { result ->
        if (result)
            Log.d(TAG, "Approved applicant to join room")                
        else
            Log.d(TAG, "Disapproved applicant to join room")                                            
    }.onFailure {
        Log.d(TAG, "Failed to handle join request: ${it.message} , ${it.cause}")            
    }
}

c++

#include "arctos_qt.h"

void hostHandleJoinRequest(const std::string& room_id,
                            const std::string& user_id,
                            const std::string& carrier_id,
                            const std::string& carrier_address,
                            bool accept) {
    auto& arctos_app = arctos::ArctosQt::getInstance();
    arctos_app.handleJoinRequest(room_id.c_str(),
                                    user_id.c_str(),
                                    carrier_id.c_str(),
                                    carrier_address.c_str(),
                                    accept); // emit errorMessage when failed
}

host kick participant

Function: Host removes a participant. Only the host of the conference room can perform this operation.

Parameters:

roomId: The ID of the conference room, type is String.
participantId: The ID of the participant to be removed, type is Int.
message: Explanation message, type is String.

Return Value: If the participant is successfully removed, it completes; otherwise, it returns an error.

Trigger Callback: Other participants in the conference room receive Participant Removed by Host; the removed participant receives Removed by Host

Swift

import ArctosLinks
import RxSwift

func hostRemoveParticipant(at roomId: String = "unique_room_id", for participantId: Int, with message: String? = "Inappropriate behavior") {
    _ = ArctosLinks.Conference.hostKickParticipant(from: roomId, participantId: participantId, with: message)
        .subscribe(onSuccess: { _ in
            print("Successfully removed participant.")
        }, onFailure: { error in
            print("Failed to remove participant: \(error.localizedDescription)")
        })
}

Kotlin

import com.arctos.sdk.links.core.application.ArctosLinks

private suspend fun hostRemoveParticipant(
    roomId: String,
    participantId: String,
    message: String
) {        
    runCatching {            
        ArctosLinks.getInstance(Context).conferenceManager.hostKickParticipant(
            roomId =  roomId, participantId =  participantId, message =  message)
            .getOrThrow()
    }.onSuccess { _ ->
        Log.d(TAG, "Successfully removed participant")
    }.onFailure {
        Log.d(TAG, "Failed to remove participant: ${it.message}")
    }
}

c++

#include "arctos_qt.h"

void hostRemoveParticipant(const std::string& room_id,
                            const std::string& user_id) {
    auto& arctos_app = arctos::ArctosQt::getInstance();
    arctos_app.leaveRoom(room_id.c_str(), user_id.c_str()); // emit errorMessage when failed
}

host update room info

Function: Host updates the name and description of the conference room. Only the host of the conference room can perform this operation.

Parameters:

roomId: The ID of the conference room, type is String.
roomName: The new name of the conference room, type is String.
description: The new description of the conference room, type is String.

Return Value: If the information is successfully updated, it completes; otherwise, it returns an error.

Trigger Callback: Room Info Updated

Swift

import ArctosLinks
import RxSwift

func hostUpdateRoomInfo(at roomId: String = "unique_room_id", name: String? = "Updated Room Name", description: String? = "New room description") {
    _ = ArctosLinks.Conference.hostUpdateRoomInfo(roomId: roomId, roomName: name, description: description)
        .subscribe(onSuccess: { _ in
            print("Successfully updated room info.")
        }, onFailure: { error in
            print("Failed to update room info: \(error.localizedDescription)")
        })
}

Kotlin

import com.arctos.sdk.links.core.application.ArctosLinks

private suspend fun hostUpdateRoomInfo(
    roomId: String,
    roomName: String,
    description: String
) {
    runCatching {
        ArctosLinks.getInstance(Context).conferenceManager.hostUpdateRoomInfo(
            roomId = roomId,
            roomName = roomName,
            description = description
        ).getOrThrow()
    }.onSuccess { _ ->
        Log.d(TAG, "Successfully updated room info")
    }.onFailure {
        Log.d(TAG, "Failed to update room info: ${it.message}")
    }
}

c++

#include "arctos_qt.h"

void hostUpdateRoomInfo(const std::string& room_id,
                        const std::string& name,
                        const std::string& description) {
    auto& arctos_app = arctos::ArctosQt::getInstance();
    arctos_app.updateRoomInfo(room_id.c_str(), name.c_str(), description.c_str()); // emit errorMessage when failed
}

host switch screen template

Function: Switch the screen layout of the conference room. Only the host of the conference room can perform this operation.

Parameters:

templateType (ScreenTemplate): Layout style, available parameters see ScreenTemplate.

Error Handling: If the user is unauthorized or the layout type is invalid, an error is thrown.

Swift

import ArctosLinks

func hostSwitchTemplate(to template: ArctosLinks.Conference.ScreenTemplate) {
    do {
        try ArctosLinks.Conference.hostSwitchScreenTemplate(to: .template_1)
        print("Successfully switched screen template.")
    } catch {
        print("Failed to switch screen template: \(error.localizedDescription)")
    }
}

Kotlin

import com.arctos.sdk.links.core.application.ArctosLinks

private fun hostSwitchScreenTemplate(template: ConferenceRoomInterface.ScreenTemplate) {
    runCatching {
        ArctosLinks.getInstance(Context).conferenceManager.hostSwitchScreenTemplate(
            template
        ).getOrThrow()
    }.onSuccess {
        Log.d(TAG, "Successfully switched screen template")
    }.onFailure {
        Log.d(TAG, "Failed to switch screen template: ${it.message}")
    }
}

c++

#include "arctos_qt.h"

void hostSwitchScreenTemplate(int layout_id /*1 - 4*/) {
    auto& arctos_app = arctos::ArctosQt::getInstance();
    arctos_app.media()->setTemplate(layout_id);
}

Common

Join Room

Function: Send a request to join the conference room.

Parameters:

roomID: The ID of the conference room, type is String.

The creator of the conference room is the host. After sending the application, the host can immediately join the conference room without review.

Other applicants need to wait for the host's approval before entering the conference room. Multiple conference rooms can be applied for at the same time.

Return Value: If the application is successfully submitted, it completes and returns Application Status; otherwise, it returns an error.

Trigger Callback: The host receives Request to Join Conference Room

Swift

import ArctosLinks
import RxSwift

func joinRoom(with roomId: String = "unique_room_id") {
    _ = ArctosLinks.Conference.joinRoom(roomID: roomId)
        .observe(on: MainScheduler.instance)
        .subscribe(onSuccess: { status in
            switch status {
            case .approved:
                print("Application approved.")
            case .waiting:
                print("Application sent. Awaiting review...")
            }
        }, onFailure: { error in
            print(error.localizedDescription)
        })
}

Kotlin

import com.arctos.sdk.links.core.application.ArctosLinks

private suspend fun joinRoom(roomId: String) {
    runCatching {
        ArctosLinks.getInstance(Context).conferenceManager.joinRoom(roomId = roomId)
            .getOrThrow()
    }.onSuccess { result ->            
        when (result) {
            ArctosLinksCallback.ConferenceEventCallback.JoinRoomResponse.Approve -> {
                Log.d(TAG, "Application approved")                    
            }

            ArctosLinksCallback.ConferenceEventCallback.JoinRoomResponse.Waiting -> {                    
                Log.d(TAG, "Application sent. Awaiting review...")                    
            }                
        }
    }.onFailure {
        Log.d(TAG, "Failed to join room: ${it.message}")
    }
}

c++

#include "arctos_qt.h"

void joinRoom(const std::string& room_id) {
    auto& arctos_app = arctos::ArctosQt::getInstance();
    arctos_app.joinRoom(room_id.c_str());
}

Cancel Join Request

Function: Cancel the request to join the conference room.

Parameters:

roomID: The ID of the conference room, type is String.

Return Value: If the request is successfully canceled, it completes; otherwise, it returns an error.

Trigger Callback: Cancel Join Room Request

Swift

import ArctosLinks
import RxSwift

func cancelJoin(for roomId: String = "unique_room_id") {
    _ = ArctosLinks.Conference.cancelJoinRequest(for: roomId)
        .observe(on: MainScheduler.instance)
        .subscribe(onSuccess: { _ in
            print("Successfully canceled application.")
        }, onFailure: { error in
            print(error.localizedDescription)
        })
}

Kotlin

import com.arctos.sdk.links.core.application.ArctosLinks

private suspend fun cancelJoin(roomId: String) {
    runCatching {
        ArctosLinks.getInstance(Context).conferenceManager.cancelJoinRequest(roomId = roomId)
            .getOrThrow()
    }.onSuccess { result ->            
        if (result)
            Log.d(TAG, "cancel success ")                
        else 
            Log.d(TAG, "cancel failed ")                            
    }.onFailure {
        Log.d(TAG, "cancel failed ")            
    }
}

c++

#include "arctos_qt.h"

void cancelJoin(const std::string& room_id) {
    auto& arctos_app = arctos::ArctosQt::getInstance();
    // my_user_id_ is from `loginOk` signal
    arctos_app.leaveRoom(room_id.c_str(), my_user_id_);
}

Leave Room

Note

If the user is the `host`, the conference room will be closed as well.

Function: Leave the conference room.

Parameters:

roomID: The ID of the conference room, type is String.

Return Value: If the user successfully leaves the conference room, it completes; otherwise, it returns an error.

Trigger Callback: Participant Left Room

Swift

import ArctosLinks
import RxSwift

func leaveRoom(_ roomId: String = "unique_room_id") {
    _ = ArctosLinks.Conference.leaveRoom(roomId)
    .observe(on: MainScheduler.instance)
    .subscribe(onSuccess: { _ in
        print("Successfully left room.")
    }, onFailure: { error in
        print(error.localizedDescription)
    })
}

Kotlin

import com.arctos.sdk.links.core.application.ArctosLinks

    private suspend fun leaveRoom(roomId: String) {
    runCatching { 
        ArctosLinks.getInstance(Context).conferenceManager.leaveRoom(roomId = roomId)
            .getOrThrow()
    }.onSuccess { result ->            
        if (result) 
            Log.d(TAG, "Successfully left room")                
        else
            Log.d(TAG, "Failed to left room")                            
    }.onFailure {
        Log.d(TAG, "Failed to left room ${it.message}")            
    }
}

c++

#include "arctos_qt.h"

void leaveRoom(const std::string& room_id) {
    auto& arctos_app = arctos::ArctosQt::getInstance();
    // my_user_id_ is from `loginOk` signal
    arctos_app.leaveRoom(room_id.c_str(), my_user_id_);
}

get Room List

Function: Retrieve the latest list of conference rooms.

Return Value: If successful, returns Room List; otherwise, returns an error.

Swift

import ArctosLinks
import RxSwift

func retrieveRoomList() {
    _ = ArctosLinks.Conference.getRoomList()
    .observe(on: MainScheduler.instance)
    .subscribe(onSuccess: { data in
        dump(data, name: "ArctosLinks.Conference.getRoomList")
    }, onFailure: { error in
        print(error.localizedDescription)
    })
}

Kotlin

import com.arctos.sdk.links.core.application.ArctosLinks

private suspend fun retrieveRoomList() {        
    runCatching {
        ArctosLinks.getInstance(Context).conferenceManager.getRoomList()
            .getOrThrow()
    }.onSuccess { it ->            
        val roomList = it.toMutableList()                      
    }.onFailure {
        Log.d(TAG, "Failed to retrive Rooms: ${it.message}")
    }
}

c++

#include "arctos_qt.h"

void retrieveRoomList() {
    auto& arctos_app = arctos::ArctosQt::getInstance();
    arctos_app.listRoom(); // emit updateRoomList signal when succeed
}

get Room Info

Function: Retrieve detailed information about a conference room.

Parameters:

roomID: The ID of the conference room, type is String.

Return: If successful, returns Room Info; otherwise, returns an error.

Swift

import ArctosLinks
import RxSwift

func getInfo(for roomId: String = "unique_room_id") {
    _ = ArctosLinks.Conference.getRoomInfo(roomId: roomId)
        .subscribe(onSuccess: { roomInfo in
            print("Successfully retrieved room info：\(roomInfo)")
        }, onFailure: { error in
            print("Failed to retrieve room info with error：\(error.localizedDescription)")
        })
}

Kotlin

import com.arctos.sdk.links.core.application.ArctosLinks

private suspend fun getRoomInfo() {        
    runCatching {
        ArctosLinks.getInstance(Context).conferenceManager.getRoomInfo(roomId)
            .getOrThrow()
    }.onSuccess { roomInfo ->            
        Log.d(TAG, "RoomInfo info: $roomInfo")            
    }.onFailure {
        Log.d(TAG, "onFailure getRoomInfo: ${it.message}")            
    }
}

c++

#include "arctos_qt.h"

void getRoomInfo(const std::string& room_id) {
    auto& arctos_app = arctos::ArctosQt::getInstance();
    arctos_app.getRoomInfo(room_id.c_str()); // emit errorMessage signal when failed
}

Callback

Request Join Room

Description: When a user requests to join the conference room, the host will receive this notification.

Notification Parameters:

id: The ID of the applicant, type is Int.
name: The username of the applicant, type is String.

Swift

import ArctosLinks
import RxSwift

func hostStartObservingJoinEvent() {
    _ = ArctosLinks.ConferenceEventCallback.requestJoinRoom
        .observe(on: ConcurrentDispatchQueueScheduler(qos: .background))
        .subscribe(onNext: { [weak self] (requesterId, requesterName) in
            guard let self else { return }
            print("\(requesterName)(\(requesterId)) has requested to join.")
        })
        .disposed(by: disposeBag)
}

Kotlin

import com.arctos.sdk.links.core.application.ArctosLinks

ArctosLinks.getInstance(Context).conferenceManager.conferenceEvent.collect { event ->
    when (event) {
        is ArctosLinksCallback.ConferenceEventCallback.RequestJoinRoom -> {                
            Log.d(TAG, "MeetingRoom RequestJoinRoom : ${event.requesterId} , ${event.requesterName}")
        }
    }
}

c++

#include "arctos_qt.h"
auto& arctos_app = arctos::ArctosQt::getInstance();
QObject::connect(&arctos_app, &ArctosQt::joinedRoom, [](const QString& room_id, const QString& user_id){
    LOG(INFO) << "MeetingRoom RequestJoinRoom " << user_id.c_str();
});

Cancel Join Request

Description: When an applicant cancels the request to join the conference, the host will receive this notification.

Notification Parameters:

id: The ID of the applicant who canceled, type is Int.

Swift

import ArctosLinks
import RxSwift

func hostStartObservingCancelEvent() {
    _ = ArctosLinks.ConferenceEventCallback.cancelJoinRequest
        .subscribe(onNext: { id in
            print("\(id) has canceled their request to join.")
        })
        .disposed(by: disposeBag)
}

Kotlin

import com.arctos.sdk.links.core.application.ArctosLinks

ArctosLinks.getInstance(Context).conferenceManager.conferenceEvent.collect { event ->
    when (event) {
        is ArctosLinksCallback.ConferenceEventCallback.CancelJoinRoom -> {
            Log.d(TAG, "Cancel Join Room ${event.id}")                      
        }
    }
}

c++

#include "arctos_qt.h"
auto& arctos_app = arctos::ArctosQt::getInstance();
QObject::connect(&arctos_app, &ArctosQt::joinRequestCancelled, [](const QString& room_id, const QString& user_id){
    LOG(INFO) << "MeetingRoom RequestJoinRoomCancelled " << user_id.c_str();
});

Response Join Room

Description: When the host approves or rejects the applicant's request to join the conference room, the applicant will receive this notification.

If the host approves, the applicant can enter the conference room. At this time, other participants in the conference room will receive New Participant Joined Notification. If rejected, the applicant cannot enter.

Notification Parameters:

roomId: The ID of the conference room, type is String.
isApproved: Whether the application is approved or rejected, type is Bool.
message: Message, type is String.

Swift

import ArctosLinks
import RxSwift

func applicantStartObservingJoinResponse() {
    _ = ArctosLinks.ConferenceEventCallback.responseJoinRoom
        .subscribe(onNext: { (roomID, isApproved, message) in
            if isApproved {
                print("✅ Application approved in \(roomID), welcome message: \(message ?? "").")
            } else {
                print("❌ Application disapproved in \(roomID), reason: \(message ?? "").")
            }
        })
        .disposed(by: disposeBag)
}

Kotlin

import com.arctos.sdk.links.core.application.ArctosLinks

ArctosLinks.getInstance(Context).conferenceManager.conferenceEvent.collect { event ->
    when (event) {
        is ArctosLinksCallback.ConferenceEventCallback.ResponseJoinRoom -> {
            Log.d(TAG, "Receive Join Response: ${event.isApprove} , ${event.roomId} , ${event.message}")
        }
    }
}

c++

#include "arctos_qt.h"
auto& arctos_app = arctos::ArctosQt::getInstance();
QObject::connect(&arctos_app, &ArctosQt::joiningRoomSucceed, [](const QString& room_id, const QString& host_carrier_id){
    LOG(INFO) << "Joined room " << room_id.c_str();
});

QObject::connect(&arctos_app, &ArctosQt::joiningRoomFailed, [](const QString& room_id){
    LOG(INFO) << "Joined room failed " << room_id.c_str();
});

Participant Join room

Description: When a new participant joins the conference room, other participants will receive this notification.

Notification Parameters:

id: The ID of the participant, type is Int.

Swift

import ArctosLinks
import RxSwift

func roomEventObservers() {
    _ = ArctosLinks.ConferenceEventCallback.participantJoinRoom
    .subscribe(onNext: { id in
            print("Participant(\(id)) has joined.")
        })
        .disposed(by: disposeBag)
    }
}

Kotlin

import com.arctos.sdk.links.core.application.ArctosLinks

ArctosLinks.getInstance(Context).conferenceManager.conferenceEvent.collect { event ->
    when (event) {
        is ArctosLinksCallback.ConferenceEventCallback.ParticipantJoinRoom -> {
            Log.d(TAG, "MeetingRoom ParticipantJoinRoom : ${event.participantId}")
        }
    }
}

c++

#include "arctos_qt.h"
auto& arctos_app = arctos::ArctosQt::getInstance();
QObject::connect(&arctos_app, &ArctosQt::joinedRoom, [](const QString& room_id, const QString& participant_id){
    LOG(INFO) << participant_id.c_str() << " joined room " << room_id.c_str();
});

application rejected

Description: When the host rejects a user's application, all participants in the conference room will receive this notification.

Notification Parameters:

id: The ID of the rejected applicant, type is Int.

Swift

import ArctosLinks
import RxSwift

func roomEventObservers() {
    _ = ArctosLinks.ConferenceEventCallback.applicationRejected
        .subscribe(onNext: { id in
            print("Applicant(\(id)) has been rejected by the host.")
        })
        .disposed(by: disposeBag)
}

Kotlin

import com.arctos.sdk.links.core.application.ArctosLinks

ArctosLinks.getInstance(Context).conferenceManager.conferenceEvent.collect { event ->
    when (event) {
        is ArctosLinksCallback.ConferenceEventCallback.ApplicantRejectByHost -> {
            Log.d(TAG, "Applicant Reject By Host : ${event.applicantId}")
        }
    }
}

c++

#include "arctos_qt.h"
auto& arctos_app = arctos::ArctosQt::getInstance();
QObject::connect(&arctos_app, &ArctosQt::userRemoved, [](const QString& room_id, const QString& user_id){
    LOG(INFO) << user_id.c_str() << " rejected";
});

Participant Left Room

Description: When a participant leaves the conference room, all participants in the conference room will receive this notification.

Notification Parameters:

id: The ID of the participant, type is Int.
message: Reason for leaving, type is String.

Swift

import ArctosLinks
import RxSwift

func roomEventObservers() {
    _ = ArctosLinks.ConferenceEventCallback.participantLeftRoom
        .subscribe(onNext: { (id, message) in
            print("Participant(\(id)) has left the room due to \(message ?? "unknown reasons").")
        })
        .disposed(by: disposeBag)
}

Kotlin

import com.arctos.sdk.links.core.application.ArctosLinks

ArctosLinks.getInstance(Context).conferenceManager.conferenceEvent.collect { event ->
    when (event) {
        is ArctosLinksCallback.ConferenceEventCallback.ParticipantLeftRoom -> {
            Log.d(TAG, "MeetingRoom Participant Left Room : ${event.participantId}, ${event.message}")
        }
    }
}

c++

#include "arctos_qt.h"
auto& arctos_app = arctos::ArctosQt::getInstance();
QObject::connect(&arctos_app, &ArctosQt::userRemoved, [](const QString& room_id, const QString& user_id){
    LOG(INFO) << user_id.c_str() << " removed";
});

kick out by host

Note

Only the removed participant will receive this notification.

Description: When a participant is removed by the host, they will receive this notification.

Notification Parameters:

message: Reason for removal by the host, type is String.

Swift

import ArctosLinks
import RxSwift

func roomEventObservers() {
    _ = ArctosLinks.ConferenceEventCallback.kickOutByHost
        .subscribe(onNext: { message in
            print("Removed by the host due to \(message ?? "unknown reasons").")
        })
        .disposed(by: disposeBag)
}

Kotlin

import com.arctos.sdk.links.core.application.ArctosLinks

ArctosLinks.getInstance(Context).conferenceManager.conferenceEvent.collect { event ->
    when (event) {
        is ArctosLinksCallback.ConferenceEventCallback.ParticipantKickedOutByHost -> {
            Log.d(TAG, "我被主持人踢出 ${event.message}")
        }
    }
}

c++

#include "arctos_qt.h"
auto& arctos_app = arctos::ArctosQt::getInstance();
QObject::connect(&arctos_app, &ArctosQt::userRemoved, [](const QString& room_id, const QString& user_id){
    LOG(INFO) << user_id.c_str() << " kicked";
});

participant kicked out room

Note

All participants in the conference room will receive this notification.

Description: When a participant is removed by the host, they will receive this notification.

Notification Parameters:

id: The ID of the removed participant, type is Int.

Swift

import ArctosLinks
import RxSwift

func roomEventObservers() {
    _ = ArctosLinks.ConferenceEventCallback.participantKickedOutRoom
        .subscribe(onNext: { id in
            print("Participant(\(id)) has been removed from the room.")
        })
        .disposed(by: disposeBag)
}

Kotlin

import com.arctos.sdk.links.core.application.ArctosLinks

ArctosLinks.getInstance(Context).conferenceManager.conferenceEvent.collect { event ->
    when (event) {
        is ArctosLinksCallback.ConferenceEventCallback.ParticipantKickedOutRoom -> {
            Log.d(TAG,"$Participant {event.participantId} has been removed from the room.")
        }
    }
}

c++

#include "arctos_qt.h"
auto& arctos_app = arctos::ArctosQt::getInstance();
QObject::connect(&arctos_app, &ArctosQt::userRemoved, [](const QString& room_id, const QString& user_id){
    LOG(INFO) << user_id.c_str() << " kicked";
});

Host Closes Room

Note

All participants in the conference room will receive this notification.

Description: When the host closes the conference room or leaves the conference room, they will receive this notification.

Notification Parameters:

message: Reason for the host closing the conference room, type is String.

Swift

import ArctosLinks
import RxSwift

func roomEventObservers() {
    _ = ArctosLinks.ConferenceEventCallback.hostCloseRoom
        .subscribe(onNext: { message in
            print("The host closed the room due to \(message ?? "unknown reasons").")
        })
        .disposed(by: disposeBag)
}

Kotlin

import com.arctos.sdk.links.core.application.ArctosLinks

ArctosLinks.getInstance(Context).conferenceManager.conferenceEvent.collect { event ->
    when (event) {
        is ArctosLinksCallback.ConferenceEventCallback.HostCloseRoom -> {
            Log.d(TAG, "MeetingRoom closed : ${event.message}")
        }
    }
}

c++

#include "arctos_qt.h"
auto& arctos_app = arctos::ArctosQt::getInstance();
QObject::connect(&arctos_app, &ArctosQt::roomRemoved, [](const QString& room_id){
    LOG(INFO) << room_id.c_str() << " removed";
});

Room Info Updated

Description: When the room information is updated, all participants in the conference room will receive this notification.

Notification Parameters:

roomName: The new name of the room, type is String.
description: The new description of the room, type is String.

Swift

import ArctosLinks
import RxSwift

func roomEventObservers() {
    _ = ArctosLinks.ConferenceEventCallback.roomInfoUpdated
        .subscribe(onNext: { (roomName, description) in
            var body: String = ""
            if let roomName {
                body.append(" roomName: \(roomName)")
            }
            if let description {
                body.append(" description: \(description)")
            }
            print("Room info has been updated. New info:\(body)")
        })
        .disposed(by: disposeBag)
}

Kotlin

import com.arctos.sdk.links.core.application.ArctosLinks

ArctosLinks.getInstance(Context).conferenceManager.conferenceEvent.collect { event ->
    when (event) {
        is ArctosLinksCallback.ConferenceEventCallback.RoomInfoUpdate -> {
            Log.d(TAG, "MeetingRoom update : ${event.roomName}, ${event.description}")
        }
    }
}

c++

#include "arctos_qt.h"
auto& arctos_app = arctos::ArctosQt::getInstance();
QObject::connect(&arctos_app, &ArctosQt::roomInfoUpdated, [](const QString& name, const QString& description){
    LOG(INFO) << "new name " name.c_str() << "; new description " << description.c_str();
});

update participant

Description: When the online status of a participant in the conference room changes, all participants in the conference room will receive this notification.

Notification Parameters:

id: The ID of the participant, type is Int.
name: The username of the participant, type is String.
isOnline: The online status of the participant, type is Bool.

Swift

import ArctosLinks
import RxSwift

func hostStartObservingMemberOnlineStatus() {
    _ = ArctosLinks.ConferenceEventCallback.updateParticipant
        .observe(on: ConcurrentDispatchQueueScheduler(qos: .background))
        .subscribe(onNext: { (id, name, isOnline) in
            print("\(name)(\(id)) is currently \(isOnline ? "online" : "offline").")
        })
        .disposed(by: disposeBag)
}

Kotlin

import com.arctos.sdk.links.core.application.ArctosLinks

ArctosLinks.getInstance(Context).conferenceManager.conferenceEvent.collect { event ->
    when (event) {
        is ArctosLinksCallback.ConferenceEventCallback.UpdateParticipant -> {
            Log.d(TAG, "MeetingRoom Update Participant : ${event.id} , ${event.name} , ${event.isOnline}")
        }
    }
}

c++

#include "arctos_qt.h"
auto& arctos_app = arctos::ArctosQt::getInstance();
QObject::connect(&arctos_app, &ArctosQt::updateFriendList, [](const QVariant& updated_friend_list){
    for (const auto& user : friend_list) {
        const auto friend_map = user.toMap();
        if (friend_map["status"].toString() == "Offline") {
            LOG(INFO) << "Offline";
        } else {
            LOG(INFO) << "Online";
        }
    }
});

approved: Approved, join the conference room, only received when the user is also the host who created the conference room.
waiting: Waiting for the host to review.

Swift

/// Represents the possible outcomes of a join room request.
///
/// This enumeration is typically used as the result type when a user attempts to join a conference room.
/// It allows for clear differentiation between an immediate approval and a pending state.
enum JoinRoomResponse {
    /// Indicates that the join room request was immediately approved.
    /// The user can proceed to enter the conference room.
    case approved
    /// Indicates that the join room request is pending approval.
    /// The user must wait for the host to make a decision on their request.
    case waiting
}

Kotlin

sealed class JoinRoomResponse {
    data object Approve : JoinRoomResponse()
    data object Waiting : JoinRoomResponse()
}

c++

// no enum, used different signals to distinguish events
// joiningRoomFailed
// joiningRoomSucceed

ScreenTemplate

Function: Used to enumerate the available display layouts for the conference room.

Members:

template_1: One small frame on the left top, one frame filling the rest.
template_2: Two equal frames side by side.
template_3: Three frames on top, one frame filling the bottom.
template_4: Four equally distributed frames.

Properties:

representValue: Returns the string representation of each template, type is String.

Swift

/// Enumerates the available display layouts for the conference room.
enum ScreenTemplate: CaseIterable {
    /// One small frame on the left top, one frame filling the rest
    case template_1
    /// Two equal frames side by side
    case template_2
    /// Three frames on top, one frame filling the bottom
    case template_3
    /// Four equally distributed frames
    case template_4
    
    /// The string representation of each template.
    public var representValue: String {
        switch self {
        case .template_1:
            return "template No.1"
        case .template_2:
            return "template No.2"
        case .template_3:
            return "template No.3"
        case .template_4:
            return "template No.4"
        }
    }
}

Kotlin

sealed class ScreenTemplate {
    data object Template1 : ScreenTemplate()
    data object Template2 : ScreenTemplate()
    data object Template3 : ScreenTemplate()
    data object Template4 : ScreenTemplate()
}

c++

// integer 1, 2, 3, 4

Structs

RoomList

Function: Used to represent the information of conference rooms in the room list.

Properties:

roomID: The unique identifier of the conference room, type is String.
name: The display name of the conference room, type is String.
description: Detailed description of the conference room, type is Optional String.
host: Host information, type is struct, properties see RoomInfo.Host.

RoomInfo

Function: Used to represent detailed information about a specific conference room.

Properties:

roomID: The ID of the conference room, type is String.
name: The display name of the conference room, type is String.
description: Detailed description of the conference room, type is String.
host: Host information, type is struct, properties see RoomInfo.Host.
participants: List of participant information, type is struct, properties see RoomInfo.Participant.
applicants: List of applicant information (visible only to the host), type is struct, properties see RoomInfo.Applicant.

Host

Function: Used to represent the information of the host of the conference room.

Properties:

id: The ID of the host, type is Int.
displayName: The display name of the host, type is String.

Participant

Function: Used to represent the information of participants in the conference room.

Properties:

id: The ID of the participant, type is Int.
displayName: The display name of the participant, type is String.

Applicant

Function: Used to represent the information of members applying to join the conference room.

Properties:

id: The ID of the applicant, type is Int.
displayName: The display name of the applicant, type is String.

Conference Room

Host Only

host create room

host close room

host join handle

host kick participant

host update room info

host switch screen template

Common

Join Room

Cancel Join Request

Leave Room

get Room List

get Room Info

Callback

Request Join Room

Cancel Join Request

Response Join Room

Participant Join room

application rejected

Participant Left Room

kick out by host

participant kicked out room

Host Closes Room

Room Info Updated

update participant

Types

Enum Classes

JoinRoomResponse

ScreenTemplate

Structs

RoomList

RoomInfo

Host

Participant

Applicant