diff --git a/docs/ios-core/reference/DyteChat.md b/docs/ios-core/reference/DyteChat.md new file mode 100644 index 000000000..d4f998c62 --- /dev/null +++ b/docs/ios-core/reference/DyteChat.md @@ -0,0 +1,212 @@ +--- +sidebar_position: 7 +web_core_version: 1.20.0 +--- + + + + + +This is the chat module, which can be used to send and receive messages from the meeting. + +- [DyteChat](#module_DyteChat) + - [.messages](#module_DyteChat+messages) + - [.channels](#module_DyteChat+channels) + - [.roomJoined](#module_DyteChat+roomJoined) + - [.pinned](#module_DyteChat+pinned) + - [.sendTextMessage(message)](#module_DyteChat+sendTextMessage) + - [.sendImageMessage(image)](#module_DyteChat+sendImageMessage) + - [.sendFileMessage(file)](#module_DyteChat+sendFileMessage) + - [.sendMessage(message, participantIds)](#module_DyteChat+sendMessage) + - [.getMessagesByUser(userId)](#module_DyteChat+getMessagesByUser) + - [.getMessagesByType(type)](#module_DyteChat+getMessagesByType) + - [.pin(id)](#module_DyteChat+pin) + - [.unpin(id)](#module_DyteChat+unpin) + - [.getMessages()](#module_DyteChat+getMessages) + - [.createChannel()](#module_DyteChat+createChannel) + - [.updateChannel()](#module_DyteChat+updateChannel) + - [.sendMessageToChannel(message, channelId)](#module_DyteChat+sendMessageToChannel) + - [.getChannelMembers()](#module_DyteChat+getChannelMembers) + - [.searchMessages()](#module_DyteChat+searchMessages) + - [.markLastReadMessage()](#module_DyteChat+markLastReadMessage) + + + +### meeting.chat.messages + +An array of chat messages. + + + +### meeting.chat.channels + +An Array of all available channels. + + + +### meeting.chat.roomJoined + +Returns true if the local participant has joined the meeting. + + + +### meeting.chat.pinned + +Returns an array of pinned messages. + + + +### meeting.chat.sendTextMessage(message) + +Sends a chat text message to the room. + +**Kind**: instance method of [DyteChat](#module_DyteChat) + +| Param | Description | +| ------- | ------------------------------------------ | +| message | The message that must be sent to the room. | + + + +### meeting.chat.sendImageMessage(image) + +Sends an image message to the meeting. + +**Kind**: instance method of [DyteChat](#module_DyteChat) + +| Param | Description | +| ----- | ----------------------------- | +| image | The image that is to be sent. | + + + +### meeting.chat.sendFileMessage(file) + +Sends a file to the meeting. + +**Kind**: instance method of [DyteChat](#module_DyteChat) + +| Param | Description | +| ----- | -------------- | +| file | A File object. | + + + +### meeting.chat.sendMessage(message, participantIds) + +Sends a message to the meeting. This method can be used to send text, image, +or file messages. The message type is determined by the key 'type' in `message` +object. + +**Kind**: instance method of [DyteChat](#module_DyteChat) + +| Param | Description | +| -------------- | -------------------------------------------------------- | +| message | An object including the type and content of the message. | +| participantIds | An array including the userIds of the participants. | + + + +### meeting.chat.getMessagesByUser(userId) + +Returns an array of messages sent by a specific userId. + +**Kind**: instance method of [DyteChat](#module_DyteChat) + +| Param | Description | +| ------ | ---------------------------------------------- | +| userId | The user id of the user that sent the message. | + + + +### meeting.chat.getMessagesByType(type) + +Returns an array of 'text', 'image' or 'file' messages. + +**Kind**: instance method of [DyteChat](#module_DyteChat) + +| Param | Description | +| ----- | --------------------------- | +| type | 'text', 'image', or 'file'. | + + + +### meeting.chat.pin(id) + +Pins a chat message + +**Kind**: instance method of [DyteChat](#module_DyteChat) + +| Param | Description | +| ----- | ------------------------------ | +| id | ID of the message to be pinned | + + + +### meeting.chat.unpin(id) + +Unpins a chat message + +**Kind**: instance method of [DyteChat](#module_DyteChat) + +| Param | Description | +| ----- | -------------------------------- | +| id | ID of the message to be unpinned | + + + +### meeting.chat.getMessages() + +Gets chat messages in a paginated manner + +**Kind**: instance method of [DyteChat](#module_DyteChat) + + +### meeting.chat.createChannel() + +Creates a channel with specified name and userIds as members + +**Kind**: instance method of [DyteChat](#module_DyteChat) + + +### meeting.chat.updateChannel() + +Updates the channel + +**Kind**: instance method of [DyteChat](#module_DyteChat) + + +### meeting.chat.sendMessageToChannel(message, channelId) + +Sends a message to a channel. This method can be used to send text, image, +or file messages. The message type is determined by the key 'type' in `message` +object. + +**Kind**: instance method of [DyteChat](#module_DyteChat) + +| Param | Description | +| --------- | -------------------------------------------------------- | +| message | An object including the type and content of the message. | +| channelId | Id of the channel where you want to send the message. | + + + +### meeting.chat.getChannelMembers() + +returns a list of members added to the channel + +**Kind**: instance method of [DyteChat](#module_DyteChat) + + +### meeting.chat.searchMessages() + +search messages + +**Kind**: instance method of [DyteChat](#module_DyteChat) + + +### meeting.chat.markLastReadMessage() + +marks last read message in a channel + +**Kind**: instance method of [DyteChat](#module_DyteChat) diff --git a/docs/ios-core/reference/DyteClient.md b/docs/ios-core/reference/DyteClient.md new file mode 100644 index 000000000..1d3374729 --- /dev/null +++ b/docs/ios-core/reference/DyteClient.md @@ -0,0 +1,151 @@ +--- +sidebar_position: 1 +web_core_version: 1.20.0 +--- + + + + + +The DyteClient class is the main class of the web core library. +An object of the DyteClient class can be created using +`await DyteClient.init({ ... })`. Typically, an object of `DyteClient` is +named `meeting`. + +- [DyteClient](#module_DyteClient) + - _instance_ + - [.participants](#module_DyteClient+participants) + - [.self](#module_DyteClient+self) + - [.meta](#module_DyteClient+meta) + - [.ai](#module_DyteClient+ai) + - [.plugins](#module_DyteClient+plugins) + - [.chat](#module_DyteClient+chat) + - [.polls](#module_DyteClient+polls) + - [.remote](#module_DyteClient+remote) + - [.connectedMeetings](#module_DyteClient+connectedMeetings) + - ~~[.joinRoom()](#module_DyteClient+joinRoom)~~ + - ~~[.leaveRoom()](#module_DyteClient+leaveRoom)~~ + - [.join()](#module_DyteClient+join) + - [.leave()](#module_DyteClient+leave) + - _static_ + - [.init(options)](#module_DyteClient.init) + - _inner_ + - [~networkCall](#module_DyteClient..networkCall) + + + +### meeting.participants + +The `participants` object consists of 4 maps of participants, +`waitlisted`, `joined`, `active`, `pinned`. The maps are indexed by +`peerId`s, and the values are the corresponding participant objects. + + + +### meeting.self + +The `self` object can be used to manipulate audio and video settings, +and other configurations for the local participant. This exposes methods +to enable and disable media tracks, share the user's screen, etc. + + + +### meeting.meta + +The `room` object stores information about the current meeting, such +as chat messages, polls, room name, etc. + + + +### meeting.ai + +The `ai` object is used to interface with Dyte's AI features. +You can obtain the live meeting transcript and use other meeting AI +features such as summary, and agenda using this object. + + + +### meeting.plugins + +The `plugins` object stores information about the plugins available in +the current meeting. It exposes methods to activate and deactivate them. + + + +### meeting.chat + +The chat object stores the chat messages that were sent in the meeting. +This includes text messages, images, and files. + + + +### meeting.polls + +The polls object stores the polls that were initiated in the meeting. +It exposes methods to create and vote on polls. + + + +### meeting.remote + +The remote object stores the remote control requests for the meeting. +It exposes methods to request, accept and end the remote control. + + + +### meeting.connectedMeetings + +The connectedMeetings object stores the connected meetings states. +It exposes methods to create/read/update/delete methods for connected meetings. + + + +### ~~meeting.joinRoom()~~ + +**_Deprecated_** + +The `joinRoom()` method can be used to join the meeting. A `roomJoined` event +is emitted on `self` when the room is joined successfully. + +**Kind**: instance method of [DyteClient](#module_DyteClient) + + +### ~~meeting.leaveRoom()~~ + +**_Deprecated_** + +The `leaveRoom()` method can be used to leave a meeting. + +**Kind**: instance method of [DyteClient](#module_DyteClient) + + +### meeting.join() + +The `join()` method can be used to join the meeting. A `roomJoined` event +is emitted on `self` when the room is joined successfully. + +**Kind**: instance method of [DyteClient](#module_DyteClient) + + +### meeting.leave() + +The `leave()` method can be used to leave a meeting. + +**Kind**: instance method of [DyteClient](#module_DyteClient) + + +### meeting.init(options) + +The `init` method can be used to instantiate the DyteClient class. +This returns an instance of DyteClient, which can be used to perform +actions on the meeting. + +**Kind**: static method of [DyteClient](#module_DyteClient) + +| Param | Description | +| ----------------- | ----------------------------------------------------------------------------- | +| options | The options object. | +| options.roomName | The name of the room. (If you are using V2 Api's you don't need to send this) | +| options.authToken | The authorization token received using the API. | +| options.apiBase | The base URL of the API. | +| options.defaults | The default audio and video settings. | diff --git a/docs/ios-core/reference/DyteLivestream.md b/docs/ios-core/reference/DyteLivestream.md new file mode 100644 index 000000000..7f21110f2 --- /dev/null +++ b/docs/ios-core/reference/DyteLivestream.md @@ -0,0 +1,30 @@ +--- +sidebar_position: 11 +web_core_version: 1.20.0 +--- + + + + + +The DyteLivestream module represents the state of the current livestream, and allows +to start/stop live streams. + +- [DyteLivestream](#module_DyteLivestream) + - [.start()](#module_DyteLivestream+start) + - [.stop()](#module_DyteLivestream+stop) + + + +### meeting.livestream.start() + +Starts livestreaming the meeting. + +**Kind**: instance method of [DyteLivestream](#module_DyteLivestream) + + +### meeting.livestream.stop() + +Stops livestreaming the meeting. + +**Kind**: instance method of [DyteLivestream](#module_DyteLivestream) diff --git a/docs/ios-core/reference/DyteMediaPermission.md b/docs/ios-core/reference/DyteMediaPermission.md new file mode 100644 index 000000000..a77252341 --- /dev/null +++ b/docs/ios-core/reference/DyteMediaPermission.md @@ -0,0 +1,44 @@ +--- +sidebar_position: 10 +web_core_version: 1.20.0 +--- + + + + + +```swift +enum StageStatus { + case OFF_STAGE + case REQUESTED_TO_JOIN_STAGE + case ACCEPTED_TO_JOIN_STAGE + case REJECTED_TO_JOIN_STAGE + case ON_STAGE +} +``` + +The DyteStageStatus represent an enum to manage the Stage of the meeting +Stage refers to a virtual area, where participants stream are visible to other participants. +When a participant is off-stage, they are not producing media +but only consuming media from participants who are on Stage. Below are the specificed status of the stage. + +### case OFF_STAGE + +when the participant is not on the Stage ie He/She is a viewer and can't produce media + +### case REQUESTED_TO_JOIN_STAGE + +When participant has permission `Need to Request` from the preset `Media` menu and participant requested to join stage from the Host by calling this method `meeting.stage.requestAccess()` + +### case ACCEPTED_TO_JOIN_STAGE + +When host invited a viewer to join stage by calling `meeting.stage.grantAccess(id: participant.id)` Or +When request to join stage raised by the viewer is accepted by the host. + +### case REJECTED_TO_JOIN_STAGE + +When host rejected a viewer request to join stage by calling `meeting.stage.denyAccess(id: participant.id)` + +### case ON_STAGE + +when the participant is on the Stage and can produce media. Participant can move to this stage by calling the `meeting.stage.join()` diff --git a/docs/ios-core/reference/DyteMeetingJoinedParticipant.md b/docs/ios-core/reference/DyteMeetingJoinedParticipant.md new file mode 100644 index 000000000..5e00bb3df --- /dev/null +++ b/docs/ios-core/reference/DyteMeetingJoinedParticipant.md @@ -0,0 +1,112 @@ +--- +sidebar_position: 4 +web_core_version: 1.20.0 +--- + + + + +**Subclass** of [DyteMeetingParticipant](/ios-core-new/reference/DyteMeetingParticipant) +This class represents a single participant in the meeting. +The participant object can be accessed from one of the participant lists +present in the `meeting.participants` object. For example, + +```swift +let participant1 = meeting.participants.active[0]; +let participant2 = meeting.participants.joined[0]; +``` + +- [DyteParticipant](#module_DyteParticipant) + - [.isPinned](#module_DyteParticipant--this.+isPinned) + - [.pin()](#module_DyteParticipant--this.+pin) + - [.unpin()](#module_DyteParticipant--this.+unpin) + - [.kick()](#module_DyteParticipant--this.+kick) + - [.disableAudio()](#module_DyteParticipant--this.+disableAudio) + - [.disableVideo()](#module_DyteParticipant--this.+disableVideo) + - [.getVideoView()](#module_DyteParticipant--this.+getVideoView) + - [.getScreenShareVideoView()](#module_DyteParticipant--this.+getScreenShareVideoView) + + + +#### Check is pinned + +```swift +let isPinned: Bool +``` + +Returns true if the participant is pinned. + + + +#### Pinned participant + +```swift +func pin() +``` + +Returns `participant.id` if user has permission +to pin participants. + + + +#### Unpinned participant + +```swift +func unpin() +``` + +Returns `participant.id` if user has permission +to unpin participants. + + + +#### Kick participant + +```swift +func kick() +``` + +Kicks this participant from the meeting. +Requires the permission to kick a participant. + + + +#### Disable Audio + +```swift +func disableAudio() +``` + +Disables audio for this participant. +Requires the permission to disable participant audio. + + + +#### Disable Video + +```swift +func disableVideo() +``` + +Disables video for this participant. +Requires the permission to disable video for a participant. + + + +#### Get video view + +```swift +fun getVideoView(): VideoView? +``` + +Return a view which is used to render participant camera streams. + + + +#### Get ScreenShare video view + +```swift +fun getScreenShareVideoView(): VideoView +``` + +Return a view which is used to render participant screen streams. diff --git a/docs/ios-core/reference/DyteMeetingParticipant.md b/docs/ios-core/reference/DyteMeetingParticipant.md new file mode 100644 index 000000000..e53d24c06 --- /dev/null +++ b/docs/ios-core/reference/DyteMeetingParticipant.md @@ -0,0 +1,122 @@ +--- +sidebar_position: 4 +web_core_version: 1.20.0 +--- + + + + + +This class is a parent class of [DyteMeetingJoinedParticipant](/ios-core-new/reference/DyteMeetingJoinedParticipant). + +```swift +let participant1 = meeting.participants.active[0]; +let participant2 = meeting.participants.joined[0]; +``` + +open val id: String, +open val userId: String, +open val name: String, +open val picture: String?, +open val isHost: Boolean, +open val clientSpecificId: String?, +open val flags: ParticipantFlags, +open val presetName: String, + +- [DyteParticipant](#module_DyteParticipant) + - [.id](#module_DyteParticipant--this.+id) + - [.userId](#module_DyteParticipant--this.+userId) + - [.name](#module_DyteParticipant--this.+name) + - [.picture](#module_DyteParticipant--this.+picture) + - [.clientSpecificId](#module_DyteParticipant--this.+clientSpecificId) + - [.videoEnabled](#module_DyteParticipant--this.+videoEnabled) + - [.audioEnabled](#module_DyteParticipant--this.+audioEnabled) + - [.presetName](#module_DyteParticipant--this.+presetName) + - [.stageStatus](#module_DyteParticipant--this.+stageStatus) + +### self.id + +```swift +let id: String +``` + +The peer ID of the participant. +The participants are indexed by this ID in the participant class. + + + +### self.userId + +```swift +let userId: String +``` + +The user ID of the participant. + + + +### self.name + +```swift +let name: String +``` + +The name of the participant. + + + +### self.picture + +```swift +let picture: String? +``` + +The picture of the participant and is optional. + + + +### self.clientSpecificId + +```swift +let clientSpecificId: String? +``` + +The clientSpecificId of the participant. Which is optional. + +### self.videoEnabled + +```swift +let videoEnabled: Bool +``` + +This is true if the participant's video is enabled. + + + +### self.audioEnabled + +```swift +let audioEnabled: Bool +``` + +This is true if the participant's audio is enabled. + + + +### self.presetName + +```swift +let presetName: String +``` + +The preset of the participant. + + + +### self.stageStatus + +```swift +let stageStatus: StageStatus? +``` + +Denotes the participant's current stage status. For different states please check [StageStatus](/ios-core-new/reference/StageStatus) diff --git a/docs/ios-core/reference/DyteMeetingType copy 2.md b/docs/ios-core/reference/DyteMeetingType copy 2.md new file mode 100644 index 000000000..a77252341 --- /dev/null +++ b/docs/ios-core/reference/DyteMeetingType copy 2.md @@ -0,0 +1,44 @@ +--- +sidebar_position: 10 +web_core_version: 1.20.0 +--- + + + + + +```swift +enum StageStatus { + case OFF_STAGE + case REQUESTED_TO_JOIN_STAGE + case ACCEPTED_TO_JOIN_STAGE + case REJECTED_TO_JOIN_STAGE + case ON_STAGE +} +``` + +The DyteStageStatus represent an enum to manage the Stage of the meeting +Stage refers to a virtual area, where participants stream are visible to other participants. +When a participant is off-stage, they are not producing media +but only consuming media from participants who are on Stage. Below are the specificed status of the stage. + +### case OFF_STAGE + +when the participant is not on the Stage ie He/She is a viewer and can't produce media + +### case REQUESTED_TO_JOIN_STAGE + +When participant has permission `Need to Request` from the preset `Media` menu and participant requested to join stage from the Host by calling this method `meeting.stage.requestAccess()` + +### case ACCEPTED_TO_JOIN_STAGE + +When host invited a viewer to join stage by calling `meeting.stage.grantAccess(id: participant.id)` Or +When request to join stage raised by the viewer is accepted by the host. + +### case REJECTED_TO_JOIN_STAGE + +When host rejected a viewer request to join stage by calling `meeting.stage.denyAccess(id: participant.id)` + +### case ON_STAGE + +when the participant is on the Stage and can produce media. Participant can move to this stage by calling the `meeting.stage.join()` diff --git a/docs/ios-core/reference/DyteMeetingType.md b/docs/ios-core/reference/DyteMeetingType.md new file mode 100644 index 000000000..a77252341 --- /dev/null +++ b/docs/ios-core/reference/DyteMeetingType.md @@ -0,0 +1,44 @@ +--- +sidebar_position: 10 +web_core_version: 1.20.0 +--- + + + + + +```swift +enum StageStatus { + case OFF_STAGE + case REQUESTED_TO_JOIN_STAGE + case ACCEPTED_TO_JOIN_STAGE + case REJECTED_TO_JOIN_STAGE + case ON_STAGE +} +``` + +The DyteStageStatus represent an enum to manage the Stage of the meeting +Stage refers to a virtual area, where participants stream are visible to other participants. +When a participant is off-stage, they are not producing media +but only consuming media from participants who are on Stage. Below are the specificed status of the stage. + +### case OFF_STAGE + +when the participant is not on the Stage ie He/She is a viewer and can't produce media + +### case REQUESTED_TO_JOIN_STAGE + +When participant has permission `Need to Request` from the preset `Media` menu and participant requested to join stage from the Host by calling this method `meeting.stage.requestAccess()` + +### case ACCEPTED_TO_JOIN_STAGE + +When host invited a viewer to join stage by calling `meeting.stage.grantAccess(id: participant.id)` Or +When request to join stage raised by the viewer is accepted by the host. + +### case REJECTED_TO_JOIN_STAGE + +When host rejected a viewer request to join stage by calling `meeting.stage.denyAccess(id: participant.id)` + +### case ON_STAGE + +when the participant is on the Stage and can produce media. Participant can move to this stage by calling the `meeting.stage.join()` diff --git a/docs/ios-core/reference/DyteMeta.md b/docs/ios-core/reference/DyteMeta.md new file mode 100644 index 000000000..0e1693c29 --- /dev/null +++ b/docs/ios-core/reference/DyteMeta.md @@ -0,0 +1,102 @@ +--- +sidebar_position: 6 +web_core_version: 1.20.0 +--- + + + + + +This consists of the metadata of the meeting, such as the room name and the title. + +- [DyteMeta](#module_DyteMeta) + - [.selfActiveTab](#module_DyteMeta+selfActiveTab) + - [.broadcastTabChanges](#module_DyteMeta+broadcastTabChanges) + - [.viewType](#module_DyteMeta+viewType) + - [.meetingStartedTimestamp](#module_DyteMeta+meetingStartedTimestamp) + - [.meetingTitle](#module_DyteMeta+meetingTitle) + - ~~[.joined](#module_DyteMeta+joined)~~ + - [.roomName](#module_DyteMeta+roomName) + - [.mediaConnected](#module_DyteMeta+mediaConnected) + - [.socketConnected](#module_DyteMeta+socketConnected) + - [.setBroadcastTabChanges(broadcastTabChanges)](#module_DyteMeta+setBroadcastTabChanges) + - [.setSelfActiveTab(spotlightTab)](#module_DyteMeta+setSelfActiveTab) + + + +### meeting.meta.selfActiveTab + +Represents the current active tab + + + +### meeting.meta.broadcastTabChanges + +Represents whether current user is spotlighted + + + +### meeting.meta.viewType + +The `viewType` tells the type of the meeting +possible values are WEBINAR, GROUP_CALL + + + +### meeting.meta.meetingStartedTimestamp + +The timestamp of the time when the meeting started. + + + +### meeting.meta.meetingTitle + +The title of the meeting. + + + +### ~~meeting.meta.joined~~ + +**_Deprecated_** + + + +### meeting.meta.roomName + +The room name of the meeting. + + + +### meeting.meta.mediaConnected + +Has room-node connection been made. + + + +### meeting.meta.socketConnected + +This is set to true if user has successfully connected to the socket. + + + +### meeting.meta.setBroadcastTabChanges(broadcastTabChanges) + +Sets current user as broadcasting tab changes + +**Kind**: instance method of [DyteMeta](#module_DyteMeta) + +| Param | +| ------------------- | +| broadcastTabChanges | + + + +### meeting.meta.setSelfActiveTab(spotlightTab) + +Sets current active tab for user + +**Kind**: instance method of [DyteMeta](#module_DyteMeta) + +| Param | +| ------------ | +| spotlightTab | diff --git a/docs/ios-core/reference/DyteParticipant.md b/docs/ios-core/reference/DyteParticipant.md new file mode 100644 index 000000000..e2e12b645 --- /dev/null +++ b/docs/ios-core/reference/DyteParticipant.md @@ -0,0 +1,14 @@ +--- +sidebar_position: 4 +web_core_version: 1.20.0 +--- + + + + + +This is a map of participants, indexed by `participant.id` (a participant's peer ID). +This map emits an event whenever a participant present in the map emits an event. +For example, when a participant is added to this map, a `participantJoined` event is +emitted from the map. When a participant object emits an event `videoUpdate`, the map +re-emits that event (provided the participant is present in the map). diff --git a/docs/ios-core/reference/DytePermissionsPreset.md b/docs/ios-core/reference/DytePermissionsPreset.md new file mode 100644 index 000000000..d27fcff3d --- /dev/null +++ b/docs/ios-core/reference/DytePermissionsPreset.md @@ -0,0 +1,291 @@ +--- +sidebar_position: 5 +web_core_version: 1.20.0 +--- + + + + + +The DytePermissionsPreset class represents the meeting permissions for the current participant + +- [DytePermissionsPreset](#module_DytePermissionsPreset) + - [.stageEnabled](#module_DytePermissionsPreset+stageEnabled) + - [.stageAccess](#module_DytePermissionsPreset+stageAccess) + - [.acceptWaitingRequests](#module_DytePermissionsPreset+acceptWaitingRequests) + - [.requestProduceVideo](#module_DytePermissionsPreset+requestProduceVideo) + - [.requestProduceAudio](#module_DytePermissionsPreset+requestProduceAudio) + - [.requestProduceScreenshare](#module_DytePermissionsPreset+requestProduceScreenshare) + - [.canAllowParticipantAudio](#module_DytePermissionsPreset+canAllowParticipantAudio) + - [.canAllowParticipantScreensharing](#module_DytePermissionsPreset+canAllowParticipantScreensharing) + - [.canAllowParticipantVideo](#module_DytePermissionsPreset+canAllowParticipantVideo) + - [.canDisableParticipantAudio](#module_DytePermissionsPreset+canDisableParticipantAudio) + - [.canDisableParticipantVideo](#module_DytePermissionsPreset+canDisableParticipantVideo) + - [.kickParticipant](#module_DytePermissionsPreset+kickParticipant) + - [.pinParticipant](#module_DytePermissionsPreset+pinParticipant) + - [.canRecord](#module_DytePermissionsPreset+canRecord) + - ~~[.waitingRoomType](#module_DytePermissionsPreset+waitingRoomType)~~ + - [.waitingRoomBehaviour](#module_DytePermissionsPreset+waitingRoomBehaviour) + - [.plugins](#module_DytePermissionsPreset+plugins) + - [.polls](#module_DytePermissionsPreset+polls) + - ~~[.produceVideo](#module_DytePermissionsPreset+produceVideo)~~ + - ~~[.requestProduce](#module_DytePermissionsPreset+requestProduce)~~ + - [.canProduceVideo](#module_DytePermissionsPreset+canProduceVideo) + - ~~[.produceScreenshare](#module_DytePermissionsPreset+produceScreenshare)~~ + - [.canProduceScreenshare](#module_DytePermissionsPreset+canProduceScreenshare) + - ~~[.produceAudio](#module_DytePermissionsPreset+produceAudio)~~ + - [.canProduceAudio](#module_DytePermissionsPreset+canProduceAudio) + - [.chatPublic](#module_DytePermissionsPreset+chatPublic) + - [.chatPrivate](#module_DytePermissionsPreset+chatPrivate) + - [.hiddenParticipant](#module_DytePermissionsPreset+hiddenParticipant) + - [.showParticipantList](#module_DytePermissionsPreset+showParticipantList) + - ~~[.canChangeParticipantRole](#module_DytePermissionsPreset+canChangeParticipantRole)~~ + - [.canChangeParticipantPermissions](#module_DytePermissionsPreset+canChangeParticipantPermissions) + - ~~[.canChangeTheme](#module_DytePermissionsPreset+canChangeTheme)~~ + - ~~[.canPresent](#module_DytePermissionsPreset+canPresent)~~ + - ~~[.maxScreenShareCount](#module_DytePermissionsPreset+maxScreenShareCount)~~ + - [.canLivestream](#module_DytePermissionsPreset+canLivestream) + + + +### meeting.self.permissions.stageEnabled + +The `stageEnabled` property returns a boolean value. +If `true`, stage management is available for the participant. + + + +### meeting.self.permissions.stageAccess + +The `stageAccess` property dictactes how a user interacts with the stage. +There possible values are `ALLOWED`, `NOT_ALLOWED`, `CAN_REQUEST`; + + + +### meeting.self.permissions.acceptWaitingRequests + +The `acceptWaitingRequests` returns boolean value. +If `true`, participant can accept the request of waiting participant. + + + +### meeting.self.permissions.requestProduceVideo + +The `requestProduceVideo` returns boolean value. +If `true`, participant can send request to participants +about producing video. + + + +### meeting.self.permissions.requestProduceAudio + +The `requestProduceAudio` returns boolean value. +If `true`, participant can send request to participants +about producing audio. + + + +### meeting.self.permissions.requestProduceScreenshare + +The `requestProduceScreenshare` returns boolean value. +If `true`, participant can send request to participants +about sharing screen. + + + +### meeting.self.permissions.canAllowParticipantAudio + +The `canAllowParticipantAudio` returns boolean value. +If `true`, participant can enable other participants` audio. + + + +### meeting.self.permissions.canAllowParticipantScreensharing + +The `canAllowParticipantScreensharing` returns boolean value. +If `true`, participant can enable other participants` screen share. + + + +### meeting.self.permissions.canAllowParticipantVideo + +The `canAllowParticipantVideo` returns boolean value. +If `true`, participant can enable other participants` video. + + + +### meeting.self.permissions.canDisableParticipantAudio + +If `true`, a participant can disable other participants` audio. + + + +### meeting.self.permissions.canDisableParticipantVideo + +If `true`, a participant can disable other participants` video. + + + +### meeting.self.permissions.kickParticipant + +The `kickParticipant` returns boolean value. +If `true`, participant can remove other participants from the meeting. + + + +### meeting.self.permissions.pinParticipant + +The `pinParticipant` returns boolean value. +If `true`, participant can pin a participant in the meeting. + + + +### meeting.self.permissions.canRecord + +The `canRecord` returns boolean value. +If `true`, participant can record the meeting. + + + +### ~~meeting.self.permissions.waitingRoomType~~ + +**_Deprecated_** + + + +### meeting.self.permissions.waitingRoomBehaviour + +The `waitingRoomType` returns string value. +type of waiting room behavior +possible values are `SKIP`, `ON_PRIVILEGED_USER_ENTRY`, `SKIP_ON_ACCEPT` + + + +### meeting.self.permissions.plugins + +The `plugins` tells if the participant can act on plugins +there are 2 permissions with boolean values, `canStart` and `canClose`. + + + +### meeting.self.permissions.polls + +The `polls` tells if the participant can use polls. +There are 3 permissions with boolean values, `canCreate`, `canVote`, `canViewResults` + + + +### ~~meeting.self.permissions.produceVideo~~ + +**_Deprecated_** + + + +### ~~meeting.self.permissions.requestProduce~~ + +**_Deprecated_** + + + +### meeting.self.permissions.canProduceVideo + +The `canProduceVideo` shows permissions for enabling video. +There possible values are `ALLOWED`, `NOT_ALLOWED`, `CAN_REQUEST` + + + +### ~~meeting.self.permissions.produceScreenshare~~ + +**_Deprecated_** + + + +### meeting.self.permissions.canProduceScreenshare + +The `canProduceScreenshare` shows permissions for sharing screen. +There possible values are `ALLOWED`, `NOT_ALLOWED`, `CAN_REQUEST` + + + +### ~~meeting.self.permissions.produceAudio~~ + +**_Deprecated_** + + + +### meeting.self.permissions.canProduceAudio + +The `canProduceAudio` shows permissions for enabling audio. +There possible values are `ALLOWED`, `NOT_ALLOWED`, `CAN_REQUEST` + + + +### meeting.self.permissions.chatPublic + +The `chatPublic` shows permissions for public chat +there are 4 permissions +`canSend` - if true, the participant can send chat +`text` - if true, the participant can send text +`files` - if true, the participant can send files + + + +### meeting.self.permissions.chatPrivate + +The `chatPrivate` shows permissions for public chat +there are 4 permissions +`canSend` - if true, the participant can send private chat +`text` - if true, the participant can send text as private chat +`files` - if true, the participant can send files as private chat +`canReceive` - (optional) if true, the participant can receive private chat + + + +### meeting.self.permissions.hiddenParticipant + +The `hiddenParticipant` returns boolean value. +If `true`, participant is hidden. + + + +### meeting.self.permissions.showParticipantList + +The `showParticipantList` returns boolean value. +If `true`, participant list can be shown to the participant. + + + +### ~~meeting.self.permissions.canChangeParticipantRole~~ + +**_Deprecated_** + + + +### meeting.self.permissions.canChangeParticipantPermissions + +The `canChangeParticipantPermissions` returns boolean value. +If `true`, allow changing the participants' permissions. + + + +### ~~meeting.self.permissions.canChangeTheme~~ + +**_Deprecated_** + + + +### ~~meeting.self.permissions.canPresent~~ + +**_Deprecated_** + + + +### ~~meeting.self.permissions.maxScreenShareCount~~ + +**_Deprecated_** + + + +### meeting.self.permissions.canLivestream + +Livestream diff --git a/docs/ios-core/reference/DytePlugin.md b/docs/ios-core/reference/DytePlugin.md new file mode 100644 index 000000000..038351615 --- /dev/null +++ b/docs/ios-core/reference/DytePlugin.md @@ -0,0 +1,95 @@ +--- +sidebar_position: 14 +web_core_version: 1.20.0 +--- + + + + + +The DytePlugin class represents a single plugin in the meeting. +A plugin can be obtained from one of the plugin arrays in `meeting.plugins`. +For example, + +```swift +let plugin1 = meeting.plugins.active[0]; +let plugin2 = meeting.plugins.all[0]]; +``` + +- [DytePlugin](#module_DytePlugin) + - [.name](#module_DytePlugin+getName) + - [.picture](#module_DytePlugin+getthumbnail) + - [.isActive](#module_DytePlugin+isActive) + - [.getPluginView()](#module_DytePlugin+getPluginView) + - [.activate()](#module_DytePlugin+activate) + - [.deactivate()](#module_DytePlugin+deactivate) + - [.sendData(eventName: String, data: Any?)()](#module_DytePlugin+sendData) + + + +### get Plugin Name + +```swift +let name: String +``` + +This property tells the name of plugin. + + +### get plugin thumbnail + +```swift +let picture: String +``` + +This property stores the string url of the thumbnail of the plugin. + + + +### check plugin is active or not + +```swift +let isActive: Bool +``` + +This property tells that this plugin is active or not. All active plugins would be part of active array of [DytePlugins](/ios-core-new/reference/DytePlugins). + + + +### get plugin view + +```swift +func getPluginView(): WKWebView +``` + +Returns instance of WKWebView. Which is used to show plugin current state and behavior + + + +### activate + +```swift + func activate() +``` + +Activate this plugin for all participants. + + + +### deactivate + +```swift + func deactivate() +``` + +Deactivate this plugin for all participants. + + + +### plugin.sendData(payload) + +```siwft +func sendData(eventName: String, data: Any?) +``` + +This method is used to send arbitrary data to the plugin corresponding to eventName. diff --git a/docs/ios-core/reference/DytePlugins.md b/docs/ios-core/reference/DytePlugins.md new file mode 100644 index 000000000..75012bed8 --- /dev/null +++ b/docs/ios-core/reference/DytePlugins.md @@ -0,0 +1,37 @@ +--- +sidebar_position: 9 +web_core_version: 1.20.0 +--- + + + + + +The DytePlugins class consists of all the plugins in the meeting. It uses instances of [DytePlugin](/ios-core-new/reference/DytePlugin) class to represent plugins + +- `all`: Consists of all the plugins in the meeting. +- `active`: Consists of the plugins that are currently in use. + +* [DytePlugins](#module_DytePlugins) + - [.all](#module_DytePlugins+all) + - [.active](#module_DytePlugins+active) + + + +### Get all plugins + +```swift +let all: [DytePlugin] +``` + +All plugins of type [DytePlugin](/ios/components/dyte-active-tab-selector-view) accessible by the current user. + + + +### Get all active plugins + +```swift +let active: [DytePlugin] +``` + +All plugins of type [DytePlugin](/ios/components/dyte-active-tab-selector-view) that are currently enabled in the room. diff --git a/docs/ios-core/reference/DytePolls.md b/docs/ios-core/reference/DytePolls.md new file mode 100644 index 000000000..cc9be6d17 --- /dev/null +++ b/docs/ios-core/reference/DytePolls.md @@ -0,0 +1,56 @@ +--- +sidebar_position: 8 +web_core_version: 1.20.0 +--- + + + + + +The DytePolls module consists of the polls that have been created in the meeting. + +- [DytePolls](#module_DytePolls) + - [.items](#module_DytePolls+items) + - [.roomJoined](#module_DytePolls+roomJoined) + - [.create(question, options, anonymous, hideVotes)](#module_DytePolls+create) + - [.vote(pollId, index)](#module_DytePolls+vote) + + + +### meeting.polls.items + +An array of poll items. + + + +### meeting.polls.roomJoined + +Returns true if the local participant has joined the meeting. + + + +### meeting.polls.create(question, options, anonymous, hideVotes) + +Creates a poll in the meeting. + +**Kind**: instance method of [DytePolls](#module_DytePolls) + +| Param | Default | Description | +| --------- | ------------------ | ------------------------------------------ | +| question | | The question that is to be voted for. | +| options | | The options of the poll. | +| anonymous | false | If true, the poll votes are anonymous. | +| hideVotes | false | If true, the votes on the poll are hidden. | + + + +### meeting.polls.vote(pollId, index) + +Casts a vote on an existing poll. + +**Kind**: instance method of [DytePolls](#module_DytePolls) + +| Param | Description | +| ------ | ------------------------------------------ | +| pollId | The ID of the poll that is to be voted on. | +| index | The index of the option. | diff --git a/docs/ios-core/reference/DyteRecording.md b/docs/ios-core/reference/DyteRecording.md new file mode 100644 index 000000000..1d658c026 --- /dev/null +++ b/docs/ios-core/reference/DyteRecording.md @@ -0,0 +1,44 @@ +--- +sidebar_position: 17 +web_core_version: 1.20.0 +--- + + + + + +The DyteRecording module represents the state of the current recording, and allows +to start/stop recordings and check if there's a recording in progress. + +- [DyteRecording](#module_DyteRecording) + - [.recordingId](#module_DyteRecording+recordingId) + - [.start()](#module_DyteRecording+start) + - [.stop()](#module_DyteRecording+stop) + - [.getRecordingId()](#module_DyteRecording+getRecordingId) + + + +### meeting.recording.recordingId + + + +### meeting.recording.start() + +Starts recording the meeting. + +**Kind**: instance method of [DyteRecording](#module_DyteRecording) + + +### meeting.recording.stop() + +Stops recording the meeting assuming there +is a recording in progress. + +**Kind**: instance method of [DyteRecording](#module_DyteRecording) + + +### meeting.recording.getRecordingId() + +Refreshes current recording state. + +**Kind**: instance method of [DyteRecording](#module_DyteRecording) diff --git a/docs/ios-core/reference/DyteRemote.md b/docs/ios-core/reference/DyteRemote.md new file mode 100644 index 000000000..2e2b5f3ba --- /dev/null +++ b/docs/ios-core/reference/DyteRemote.md @@ -0,0 +1,49 @@ +--- +sidebar_position: 16 +web_core_version: 1.20.0 +--- + + + + + +This module provides the ability to control a remotely shared screen using mouse and keyboard. +Methods are available to request, accept and end control of shared screen. + +- [DyteRemote](#module_DyteRemote) + - [.requestControl(peerId)](#module_DyteRemote+requestControl) ⇒ + - [.acceptControl(requestId)](#module_DyteRemote+acceptControl) + - [.endControl()](#module_DyteRemote+endControl) + + + +### meeting.remote.requestControl(peerId) ⇒ + +Sends a request to a peer for remote control. + +**Kind**: instance method of [DyteRemote](#module_DyteRemote) +**Returns**: request identifier for the control request. + +| Param | Description | +| ------ | --------------------------------------------------------- | +| peerId | The peer that needs to receive the remote control request | + + + +### meeting.remote.acceptControl(requestId) + +Accepts a remote control request from a peer. + +**Kind**: instance method of [DyteRemote](#module_DyteRemote) + +| Param | Description | +| --------- | ------------------------------------------------ | +| requestId | The request identifier that needs to be accepted | + + + +### meeting.remote.endControl() + +End an active remote control. + +**Kind**: instance method of [DyteRemote](#module_DyteRemote) diff --git a/docs/ios-core/reference/DyteRoomParticipants.md b/docs/ios-core/reference/DyteRoomParticipants.md new file mode 100644 index 000000000..463a85e0e --- /dev/null +++ b/docs/ios-core/reference/DyteRoomParticipants.md @@ -0,0 +1,673 @@ +--- +sidebar_position: 3 +web_core_version: 1.20.0 +--- + + + + + +This class represents all the participants in the meeting (except the local user). +It consists of 4 arrays: + +- `joined`: An of all participants that have joined the meeting. +- `waitlisted`: An array of all participants that have been added to the waitlist. +- `active`: An array of active participants who should be displayed in the meeting grid. +- `screenShares`: An array of participants. + +```swift +let maxNumberOnScreen: Int + +``` + +```swift +let pageCount: Int32 + +``` + +### check whether previous page can be loaded + +```swift +let canGoPreviousPage: Bool +``` + +### check whether next page can be loaded + +```swift +let canGoNextPage: Bool + +``` + +### get current page number + +```swift +let currentPageNumber: Int + +``` + +### get pinned participant + +```swift +let pinned: DyteJoinedMeetingParticipant? + +``` + +### load page number + +```swift +func setPage(pageNumber: Int) + +``` + +### kick out all participants + +```swift +func kickAll() + +``` + +### mute videos for all participants + +```swift +func disableAllVideo() +``` + +### mute audio for all participants + +```swift +func disableAllAudio() +``` + +### enable participant video view cache + +```swift +func enableCache() +``` + +### disable participant video view cache + +```swift +func disableCache() + +``` + +### accept all waiting requests + +```swift +func acceptAllWaitingRequests() + +``` + +### send message to all participants + +```swift +func broadcastMessage(type: String, payload: [String : Any]) + +``` + + + +### module.exports ⏏ + +**Kind**: Exported class + + +#### new module.exports(self) + +This constructs a new DyteParticipant object and maintains +the maps of active/joined/waitlisted/pinned/selectedPeers maps. + +| Param | Description | +| ----- | ----------- | +| self | : DyteSelf | + + + +#### module.exports.waitlisted + +Returns a list of participants waiting to join the meeting. + + + +#### module.exports.joined + +Returns a list of all participants in the meeting. + + + +#### module.exports.active + +Returns a list of participants whose streams are currently consumed. + + + +#### module.exports.pinned + +Returns a list of participants who have been pinned. + + + +#### module.exports.all + +Returns all added participants irrespective of whether they are currently +in the meeting or not + + + +#### module.exports.pip + +Return the controls for Picture-in-Picture + + + +#### module.exports.roomJoined + +Returns true if the local participant has joined the meeting. + + + +#### module.exports.viewMode + +Indicates whether the meeting is in 'ACTIVE_GRID' mode or 'PAGINATED' mode. + +In 'ACTIVE_GRID' mode, participants are populated in the participants.active map +dynamically. The participants present in the map will keep changing when other +participants unmute their audio or turn on their videos. + +In 'PAGINATED' mode, participants are populated in the participants.active map +just once, and the participants in the map will only change if the page number is +changed by the user using setPage(page). + + + +#### module.exports.currentPage + +This indicates the current page that has been set by the user in PAGINATED mode. +If the meeting is in ACTIVE_GRID mode, this value will be 0. + + + +#### module.exports.lastActiveSpeaker + +This stores the `participantId` of the last participant who spoke in the meeting. + + + +#### module.exports.selectedPeers + +Keeps a list of all participants who have been present in the selected peers list. + + + +#### module.exports.count + +Returns the number of participants who are joined in the meeting. + + + +#### module.exports.maxActiveParticipantsCount + +Returns the maximum number of participants that can be present in +the active map. + + + +#### module.exports.pageCount + +Returns the number of pages that are available in the meeting in PAGINATED mode. +If the meeting is in ACTIVE_GRID mode, this value will be 0. + + + +#### module.exports.acceptWaitingRoomRequest(id) + +Accepts requests from waitlisted participants if user +has appropriate permissions. + +**Kind**: instance method of [module.exports](#exp_module_DyteParticipants--module.exports) + +| Param | Description | +| ----- | ----------------------------------------------- | +| id | peerId or userId of the waitlisted participant. | + + + +#### module.exports.acceptAllWaitingRoomRequest() + +We need a new event for socket service events +since if we send them all together, sequence of events +can be unreliable + +**Kind**: instance method of [module.exports](#exp_module_DyteParticipants--module.exports) + + +#### module.exports.rejectWaitingRoomRequest(id) + +Rejects requests from waitlisted participants if user +has appropriate permissions. + +**Kind**: instance method of [module.exports](#exp_module_DyteParticipants--module.exports) + +| Param | Description | +| ----- | -------------------------------------------- | +| id | participantId of the waitlisted participant. | + + + +#### module.exports.setViewMode(viewMode) + +Sets the view mode of the meeting to either ACTIVE_GRID or PAGINATED. + +**Kind**: instance method of [module.exports](#exp_module_DyteParticipants--module.exports) + +| Param | Description | +| -------- | ---------------------------------------------------- | +| viewMode | The mode in which the active map should be populated | + + + +#### module.exports.setPage(page) + +Populates the active map with participants present in the page number +indicated by the parameter `page` in PAGINATED mode. +Does not do anything in ACTIVE_GRID mode. + +**Kind**: instance method of [module.exports](#exp_module_DyteParticipants--module.exports) + +| Param | Description | +| ----- | -------------------------- | +| page | The page number to be set. | + + + +#### module.exports.disableAllAudio(allowUnmute) + +Disables audio for all participants in the meeting. + +**Kind**: instance method of [module.exports](#exp_module_DyteParticipants--module.exports) + +| Param | Description | +| ----------- | -------------------------------------------------- | +| allowUnmute | Allow participants to unmute after they are muted. | + + + +#### module.exports.disableAllVideo() + +Disables video for all participants in the meeting. + +**Kind**: instance method of [module.exports](#exp_module_DyteParticipants--module.exports) + + +#### ~~module.exports.disableAudio(participantId)~~ + +**_Deprecated_** + +**Kind**: instance method of [module.exports](#exp_module_DyteParticipants--module.exports) + +| Param | Description | +| ------------- | ------------------------------ | +| participantId | ID of participant to be muted. | + + + +#### ~~module.exports.disableVideo(participantId)~~ + +**_Deprecated_** + +**Kind**: instance method of [module.exports](#exp_module_DyteParticipants--module.exports) + +| Param | Description | +| ------------- | ------------------------------ | +| participantId | ID of participant to be muted. | + + + +#### ~~module.exports.kick(participantId)~~ + +**_Deprecated_** + +**Kind**: instance method of [module.exports](#exp_module_DyteParticipants--module.exports) + +| Param | Description | +| ------------- | ------------------------------- | +| participantId | ID of participant to be kicked. | + + + +#### module.exports.kickAll() + +Kicks all participants from the meeting. + +**Kind**: instance method of [module.exports](#exp_module_DyteParticipants--module.exports) + + +#### module.exports.broadcastMessage() + +Broadcasts the message to all participants including `self`. + +**Kind**: instance method of [module.exports](#exp_module_DyteParticipants--module.exports) + + +#### ~~module.exports.acceptAllRequestToJoinStageRequests()~~ + +**_Deprecated_** + +**Kind**: instance method of [module.exports](#exp_module_DyteParticipants--module.exports) + + +#### module.exports.getAllJoinedPeers() + +Returns all peers currently present in the room +If you are in a group call or webinar use `meeting.participants.joined` +instead + +## **Kind**: instance method of [module.exports](#exp_module_DyteParticipants--module.exports) + +sidebar_position: ((sidebar_position)) +web_core_version: ((web_core_version)) + +--- + + + + + +This module represents all the participants in the meeting (except the local user). +It consists of 4 maps: + +- `joined`: A map of all participants that have joined the meeting. +- `waitlisted`: A map of all participants that have been added to the waitlist. +- `active`: A map of active participants who should be displayed in the meeting grid. +- `pinned`: A map of pinned participants. + +* [DyteParticipants](#module_DyteParticipants) + - [module.exports](#exp_module_DyteParticipants--module.exports) ⏏ + - [new module.exports(self)](#new_module_DyteParticipants--module.exports_new) + - [.waitlisted](#module_DyteParticipants--module.exports+waitlisted) + - [.joined](#module_DyteParticipants--module.exports+joined) + - [.active](#module_DyteParticipants--module.exports+active) + - [.pinned](#module_DyteParticipants--module.exports+pinned) + - [.all](#module_DyteParticipants--module.exports+all) + - [.pip](#module_DyteParticipants--module.exports+pip) + - [.roomJoined](#module_DyteParticipants--module.exports+roomJoined) + - [.viewMode](#module_DyteParticipants--module.exports+viewMode) + - [.currentPage](#module_DyteParticipants--module.exports+currentPage) + - [.lastActiveSpeaker](#module_DyteParticipants--module.exports+lastActiveSpeaker) + - [.selectedPeers](#module_DyteParticipants--module.exports+selectedPeers) + - [.count](#module_DyteParticipants--module.exports+count) + - [.maxActiveParticipantsCount](#module_DyteParticipants--module.exports+maxActiveParticipantsCount) + - [.pageCount](#module_DyteParticipants--module.exports+pageCount) + - [.acceptWaitingRoomRequest(id)](#module_DyteParticipants--module.exports+acceptWaitingRoomRequest) + - [.acceptAllWaitingRoomRequest()](#module_DyteParticipants--module.exports+acceptAllWaitingRoomRequest) + - [.rejectWaitingRoomRequest(id)](#module_DyteParticipants--module.exports+rejectWaitingRoomRequest) + - [.setViewMode(viewMode)](#module_DyteParticipants--module.exports+setViewMode) + - [.setPage(page)](#module_DyteParticipants--module.exports+setPage) + - [.disableAllAudio(allowUnmute)](#module_DyteParticipants--module.exports+disableAllAudio) + - [.disableAllVideo()](#module_DyteParticipants--module.exports+disableAllVideo) + - ~~[.disableAudio(participantId)](#module_DyteParticipants--module.exports+disableAudio)~~ + - ~~[.disableVideo(participantId)](#module_DyteParticipants--module.exports+disableVideo)~~ + - ~~[.kick(participantId)](#module_DyteParticipants--module.exports+kick)~~ + - [.kickAll()](#module_DyteParticipants--module.exports+kickAll) + - [.broadcastMessage()](#module_DyteParticipants--module.exports+broadcastMessage) + - ~~[.acceptAllRequestToJoinStageRequests()](#module_DyteParticipants--module.exports+acceptAllRequestToJoinStageRequests)~~ + - [.getAllJoinedPeers()](#module_DyteParticipants--module.exports+getAllJoinedPeers) + + + +### module.exports ⏏ + +**Kind**: Exported class + + +#### new module.exports(self) + +This constructs a new DyteParticipant object and maintains +the maps of active/joined/waitlisted/pinned/selectedPeers maps. + +| Param | Description | +| ----- | ----------- | +| self | : DyteSelf | + + + +#### module.exports.waitlisted + +Returns a list of participants waiting to join the meeting. + + + +#### module.exports.joined + +Returns a list of all participants in the meeting. + + + +#### module.exports.active + +Returns a list of participants whose streams are currently consumed. + + + +#### module.exports.pinned + +Returns a list of participants who have been pinned. + + + +#### module.exports.all + +Returns all added participants irrespective of whether they are currently +in the meeting or not + + + +#### module.exports.pip + +Return the controls for Picture-in-Picture + + + +#### module.exports.roomJoined + +Returns true if the local participant has joined the meeting. + + + +#### module.exports.viewMode + +Indicates whether the meeting is in 'ACTIVE_GRID' mode or 'PAGINATED' mode. + +In 'ACTIVE_GRID' mode, participants are populated in the participants.active map +dynamically. The participants present in the map will keep changing when other +participants unmute their audio or turn on their videos. + +In 'PAGINATED' mode, participants are populated in the participants.active map +just once, and the participants in the map will only change if the page number is +changed by the user using setPage(page). + + + +#### module.exports.currentPage + +This indicates the current page that has been set by the user in PAGINATED mode. +If the meeting is in ACTIVE_GRID mode, this value will be 0. + + + +#### module.exports.lastActiveSpeaker + +This stores the `participantId` of the last participant who spoke in the meeting. + + + +#### module.exports.selectedPeers + +Keeps a list of all participants who have been present in the selected peers list. + + + +#### module.exports.count + +Returns the number of participants who are joined in the meeting. + + + +#### module.exports.maxActiveParticipantsCount + +Returns the maximum number of participants that can be present in +the active map. + + + +#### module.exports.pageCount + +Returns the number of pages that are available in the meeting in PAGINATED mode. +If the meeting is in ACTIVE_GRID mode, this value will be 0. + + + +#### module.exports.acceptWaitingRoomRequest(id) + +Accepts requests from waitlisted participants if user +has appropriate permissions. + +**Kind**: instance method of [module.exports](#exp_module_DyteParticipants--module.exports) + +| Param | Description | +| ----- | ----------------------------------------------- | +| id | peerId or userId of the waitlisted participant. | + + + +#### module.exports.acceptAllWaitingRoomRequest() + +We need a new event for socket service events +since if we send them all together, sequence of events +can be unreliable + +**Kind**: instance method of [module.exports](#exp_module_DyteParticipants--module.exports) + + +#### module.exports.rejectWaitingRoomRequest(id) + +Rejects requests from waitlisted participants if user +has appropriate permissions. + +**Kind**: instance method of [module.exports](#exp_module_DyteParticipants--module.exports) + +| Param | Description | +| ----- | -------------------------------------------- | +| id | participantId of the waitlisted participant. | + + + +#### module.exports.setViewMode(viewMode) + +Sets the view mode of the meeting to either ACTIVE_GRID or PAGINATED. + +**Kind**: instance method of [module.exports](#exp_module_DyteParticipants--module.exports) + +| Param | Description | +| -------- | ---------------------------------------------------- | +| viewMode | The mode in which the active map should be populated | + + + +#### module.exports.setPage(page) + +Populates the active map with participants present in the page number +indicated by the parameter `page` in PAGINATED mode. +Does not do anything in ACTIVE_GRID mode. + +**Kind**: instance method of [module.exports](#exp_module_DyteParticipants--module.exports) + +| Param | Description | +| ----- | -------------------------- | +| page | The page number to be set. | + + + +#### module.exports.disableAllAudio(allowUnmute) + +Disables audio for all participants in the meeting. + +**Kind**: instance method of [module.exports](#exp_module_DyteParticipants--module.exports) + +| Param | Description | +| ----------- | -------------------------------------------------- | +| allowUnmute | Allow participants to unmute after they are muted. | + + + +#### module.exports.disableAllVideo() + +Disables video for all participants in the meeting. + +**Kind**: instance method of [module.exports](#exp_module_DyteParticipants--module.exports) + + +#### ~~module.exports.disableAudio(participantId)~~ + +**_Deprecated_** + +**Kind**: instance method of [module.exports](#exp_module_DyteParticipants--module.exports) + +| Param | Description | +| ------------- | ------------------------------ | +| participantId | ID of participant to be muted. | + + + +#### ~~module.exports.disableVideo(participantId)~~ + +**_Deprecated_** + +**Kind**: instance method of [module.exports](#exp_module_DyteParticipants--module.exports) + +| Param | Description | +| ------------- | ------------------------------ | +| participantId | ID of participant to be muted. | + + + +#### ~~module.exports.kick(participantId)~~ + +**_Deprecated_** + +**Kind**: instance method of [module.exports](#exp_module_DyteParticipants--module.exports) + +| Param | Description | +| ------------- | ------------------------------- | +| participantId | ID of participant to be kicked. | + + + +#### module.exports.kickAll() + +Kicks all participants from the meeting. + +**Kind**: instance method of [module.exports](#exp_module_DyteParticipants--module.exports) + + +#### module.exports.broadcastMessage() + +Broadcasts the message to all participants including `self`. + +**Kind**: instance method of [module.exports](#exp_module_DyteParticipants--module.exports) + + +#### ~~module.exports.acceptAllRequestToJoinStageRequests()~~ + +**_Deprecated_** + +**Kind**: instance method of [module.exports](#exp_module_DyteParticipants--module.exports) + + +#### module.exports.getAllJoinedPeers() + +Returns all peers currently present in the room +If you are in a group call or webinar use `meeting.participants.joined` +instead + +**Kind**: instance method of [module.exports](#exp_module_DyteParticipants--module.exports) diff --git a/docs/ios-core/reference/DyteSelf.md b/docs/ios-core/reference/DyteSelf.md new file mode 100644 index 000000000..de0b2fdfa --- /dev/null +++ b/docs/ios-core/reference/DyteSelf.md @@ -0,0 +1,262 @@ +--- +sidebar_position: 2 +web_core_version: 1.20.0 +--- + + + + + +The DyteSelf module represents the current user, and allows to modify the state +of the user in the meeting. The audio and video streams of the user can be retrieved from +this module. + +- [DyteSelf](#module_DyteSelf) + - [.roomState](#module_DyteSelf+roomState) + - [.permissions](#module_DyteSelf+permissions) + - ~~[.suggestedTheme](#module_DyteSelf+suggestedTheme)~~ + - [.config](#module_DyteSelf+config) + - [.roomJoined](#module_DyteSelf+roomJoined) + - [.isPinned](#module_DyteSelf+isPinned) + - ~~[.webinarStageStatus](#module_DyteSelf+webinarStageStatus)~~ + - [.setName(name)](#module_DyteSelf+setName) + - [.setupTracks(options)](#module_DyteSelf+setupTracks) + - [.enableAudio()](#module_DyteSelf+enableAudio) + - [.enableVideo()](#module_DyteSelf+enableVideo) + - [.updateVideoConstraints()](#module_DyteSelf+updateVideoConstraints) + - [.enableScreenShare()](#module_DyteSelf+enableScreenShare) + - [.updateScreenshareConstraints()](#module_DyteSelf+updateScreenshareConstraints) + - [.disableAudio()](#module_DyteSelf+disableAudio) + - [.disableVideo()](#module_DyteSelf+disableVideo) + - [.disableScreenShare()](#module_DyteSelf+disableScreenShare) + - [.getAllDevices()](#module_DyteSelf+getAllDevices) + - [.setIsPinned()](#module_DyteSelf+setIsPinned) + - [.pin()](#module_DyteSelf+pin) + - [.unpin()](#module_DyteSelf+unpin) + - [.setDevice(device)](#module_DyteSelf+setDevice) + - ~~[.requestToJoinStage()](#module_DyteSelf+requestToJoinStage)~~ + - ~~[.withdrawRequestToJoinStage()](#module_DyteSelf+withdrawRequestToJoinStage)~~ + - ~~[.leaveStage()](#module_DyteSelf+leaveStage)~~ + - ~~[.joinStage()](#module_DyteSelf+joinStage)~~ + - ~~[.setWebinarStageStatus()](#module_DyteSelf+setWebinarStageStatus)~~ + - ~~[.disablePreview()](#module_DyteSelf+disablePreview)~~ + + + +### meeting.self.roomState + +Returns the current state of room +init - Inital State +joined - User is in the meeting +waitlisted - User is in the waitlist state +rejected - User's was in the waiting room, but the entry was rejected +kicked - A priveleged user removed the user from the meeting +left - User left the meeting +ended - The meeting was ended + + + +### meeting.self.permissions + +Returns the current permission given to the user for the meeting. + + + +### ~~meeting.self.suggestedTheme~~ + +**_Deprecated_** + + + +### meeting.self.config + +Returns configuration for the meeting. + + + +### meeting.self.roomJoined + +Returns true if the local participant has joined the meeting. + + + +### meeting.self.isPinned + +Returns true if the current user is pinned. + + + +### ~~meeting.self.webinarStageStatus~~ + +**_Deprecated_** + + + +### meeting.self.setName(name) + +The name of the user can be set by calling this method. +This will get reflected to other participants ONLY if +this method is called before the room is joined. + +**Kind**: instance method of [DyteSelf](#module_DyteSelf) + +| Param | Description | +| ----- | ----------------- | +| name | Name of the user. | + + + +### meeting.self.setupTracks(options) + +Sets up the local media tracks. + +**Kind**: instance method of [DyteSelf](#module_DyteSelf) + +| Param | Description | +| ------------- | ------------------------------------- | +| options | The audio and video options. | +| options.video | If true, the video stream is fetched. | +| options.audio | If true, the audio stream is fetched. | + + + +### meeting.self.enableAudio() + +This method is used to unmute the local participant's audio. + +**Kind**: instance method of [DyteSelf](#module_DyteSelf) + + +### meeting.self.enableVideo() + +This method is used to start streaming the local participant's video +to the meeting. + +**Kind**: instance method of [DyteSelf](#module_DyteSelf) + + +### meeting.self.updateVideoConstraints() + +This method is used to apply constraints to the current video +stream. + +**Kind**: instance method of [DyteSelf](#module_DyteSelf) + + +### meeting.self.enableScreenShare() + +This method is used to start sharing the local participant's screen +to the meeting. + +**Kind**: instance method of [DyteSelf](#module_DyteSelf) + + +### meeting.self.updateScreenshareConstraints() + +This method is used to apply constraints to the current screenshare +stream. + +**Kind**: instance method of [DyteSelf](#module_DyteSelf) + + +### meeting.self.disableAudio() + +This method is used to mute the local participant's audio. + +**Kind**: instance method of [DyteSelf](#module_DyteSelf) + + +### meeting.self.disableVideo() + +This participant is used to disable the local participant's video. + +**Kind**: instance method of [DyteSelf](#module_DyteSelf) + + +### meeting.self.disableScreenShare() + +This method is used to stop sharing the local participant's screen. + +**Kind**: instance method of [DyteSelf](#module_DyteSelf) + + +### meeting.self.getAllDevices() + +Returns all media devices accessible by the local participant. + +**Kind**: instance method of [DyteSelf](#module_DyteSelf) + + +### meeting.self.setIsPinned() + +**Kind**: instance method of [DyteSelf](#module_DyteSelf) + + +### meeting.self.pin() + +Returns `self.id` if user has permission +to pin participants. + +**Kind**: instance method of [DyteSelf](#module_DyteSelf) + + +### meeting.self.unpin() + +Returns `self.id` if user has permission +to unpin participants. + +**Kind**: instance method of [DyteSelf](#module_DyteSelf) + + +### meeting.self.setDevice(device) + +Change the current media device that is being used by the local participant. + +**Kind**: instance method of [DyteSelf](#module_DyteSelf) + +| Param | Description | +| ------ | ------------------------------------------------------------------------------------------------ | +| device | The device that is to be used. A device of the same `kind` will be replaced. the primary stream. | + + + +### ~~meeting.self.requestToJoinStage()~~ + +**_Deprecated_** + +**Kind**: instance method of [DyteSelf](#module_DyteSelf) + + +### ~~meeting.self.withdrawRequestToJoinStage()~~ + +**_Deprecated_** + +**Kind**: instance method of [DyteSelf](#module_DyteSelf) + + +### ~~meeting.self.leaveStage()~~ + +**_Deprecated_** + +**Kind**: instance method of [DyteSelf](#module_DyteSelf) + + +### ~~meeting.self.joinStage()~~ + +**_Deprecated_** + +**Kind**: instance method of [DyteSelf](#module_DyteSelf) + + +### ~~meeting.self.setWebinarStageStatus()~~ + +**_Deprecated_** + +**Kind**: instance method of [DyteSelf](#module_DyteSelf) + + +### ~~meeting.self.disablePreview()~~ + +**_Deprecated_** + +**Kind**: instance method of [DyteSelf](#module_DyteSelf) diff --git a/docs/ios-core/reference/DyteSelfMedia.md b/docs/ios-core/reference/DyteSelfMedia.md new file mode 100644 index 000000000..4e452529c --- /dev/null +++ b/docs/ios-core/reference/DyteSelfMedia.md @@ -0,0 +1,177 @@ +--- +sidebar_position: 13 +web_core_version: 1.20.0 +--- + + + + + +This module allows users to initialize media before initializing the root DyteClient.init object + +- [DyteSelfMedia](#module_DyteSelfMedia) + - [.audioTrack](#module_DyteSelfMedia+audioTrack) + - [.rawAudioTrack](#module_DyteSelfMedia+rawAudioTrack) + - [.mediaPermissions](#module_DyteSelfMedia+mediaPermissions) + - [.videoTrack](#module_DyteSelfMedia+videoTrack) + - [.rawVideoTrack](#module_DyteSelfMedia+rawVideoTrack) + - [.screenShareTracks](#module_DyteSelfMedia+screenShareTracks) + - [.audioEnabled](#module_DyteSelfMedia+audioEnabled) + - [.videoEnabled](#module_DyteSelfMedia+videoEnabled) + - [.screenShareEnabled](#module_DyteSelfMedia+screenShareEnabled) + - [.addAudioMiddleware()](#module_DyteSelfMedia+addAudioMiddleware) + - [.removeAudioMiddleware()](#module_DyteSelfMedia+removeAudioMiddleware) + - [.addVideoMiddleware()](#module_DyteSelfMedia+addVideoMiddleware) + - [.removeVideoMiddleware()](#module_DyteSelfMedia+removeVideoMiddleware) + - [.getCurrentDevices()](#module_DyteSelfMedia+getCurrentDevices) + - [.getAudioDevices()](#module_DyteSelfMedia+getAudioDevices) + - [.getVideoDevices()](#module_DyteSelfMedia+getVideoDevices) + - [.getSpeakerDevices()](#module_DyteSelfMedia+getSpeakerDevices) + - [.getDeviceById(deviceId, kind)](#module_DyteSelfMedia+getDeviceById) + - [.setDevice(device)](#module_DyteSelfMedia+setDevice) + + + +### dyteSelfMedia.audioTrack + +Returns the `audioTrack`. + + + +### dyteSelfMedia.rawAudioTrack + +Returns the `rawAudioTrack` having no middleware executed on it. + + + +### dyteSelfMedia.mediaPermissions + +Returns the current audio and video permissions given by the user. +'ACCEPTED' if the user has given permission to use the media. +'CANCELED' if the user has canceled the screenshare. +'DENIED' if the user has denied permission to use the media. +'SYS_DENIED' if the user's system has denied permission to use the media. +'UNAVAILABLE' if the media is not available (or being used by a different application). + + + +### dyteSelfMedia.videoTrack + +Returns the `videoTrack`. + + + +### dyteSelfMedia.rawVideoTrack + +Returns the `videoTrack` having no middleware executed on it. + + + +### dyteSelfMedia.screenShareTracks + +Returns the screen share tracks. + + + +### dyteSelfMedia.audioEnabled + +Returns true if audio is enabled. + + + +### dyteSelfMedia.videoEnabled + +Returns true if video is enabled. + + + +### dyteSelfMedia.screenShareEnabled + +Returns true if screen share is enabled. + + + +### dyteSelfMedia.addAudioMiddleware() + +Adds the audio middleware to be executed on the raw audio stream. +If there are more than 1 audio middlewares, +they will be executed in the sequence they were added in. +If you want the sequence to be altered, please remove all previous middlewares and re-add. + +**Kind**: instance method of [DyteSelfMedia](#module_DyteSelfMedia) + + +### dyteSelfMedia.removeAudioMiddleware() + +Removes the audio middleware, if it is there. + +**Kind**: instance method of [DyteSelfMedia](#module_DyteSelfMedia) + + +### dyteSelfMedia.addVideoMiddleware() + +Adds the video middleware to be executed on the raw video stream. +If there are more than 1 video middlewares, +they will be executed in the sequence they were added in. +If you want the sequence to be altered, please remove all previous middlewares and re-add. + +**Kind**: instance method of [DyteSelfMedia](#module_DyteSelfMedia) + + +### dyteSelfMedia.removeVideoMiddleware() + +Removes the video middleware, if it is there. + +**Kind**: instance method of [DyteSelfMedia](#module_DyteSelfMedia) + + +### dyteSelfMedia.getCurrentDevices() + +Returns the media devices currently being used. + +**Kind**: instance method of [DyteSelfMedia](#module_DyteSelfMedia) + + +### dyteSelfMedia.getAudioDevices() + +Returns the local participant's audio devices. + +**Kind**: instance method of [DyteSelfMedia](#module_DyteSelfMedia) + + +### dyteSelfMedia.getVideoDevices() + +Returns the local participant's video devices. + +**Kind**: instance method of [DyteSelfMedia](#module_DyteSelfMedia) + + +### dyteSelfMedia.getSpeakerDevices() + +Returns the local participant's speaker devices. + +**Kind**: instance method of [DyteSelfMedia](#module_DyteSelfMedia) + + +### dyteSelfMedia.getDeviceById(deviceId, kind) + +Returns the local participant's device, indexed by ID and kind. + +**Kind**: instance method of [DyteSelfMedia](#module_DyteSelfMedia) + +| Param | Description | +| -------- | ------------------------------------------------- | +| deviceId | The ID of the device. | +| kind | The kind of the device: audio, video, or speaker. | + + + +### dyteSelfMedia.setDevice(device) + +Change the current media device that is being used by the local participant. + +**Kind**: instance method of [DyteSelfMedia](#module_DyteSelfMedia) + +| Param | Description | +| ------ | ------------------------------------------------------------------------------------------------ | +| device | The device that is to be used. A device of the same `kind` will be replaced. the primary stream. | diff --git a/docs/ios-core/reference/DyteSelfParticipant.md b/docs/ios-core/reference/DyteSelfParticipant.md new file mode 100644 index 000000000..e2e12b645 --- /dev/null +++ b/docs/ios-core/reference/DyteSelfParticipant.md @@ -0,0 +1,14 @@ +--- +sidebar_position: 4 +web_core_version: 1.20.0 +--- + + + + + +This is a map of participants, indexed by `participant.id` (a participant's peer ID). +This map emits an event whenever a participant present in the map emits an event. +For example, when a participant is added to this map, a `participantJoined` event is +emitted from the map. When a participant object emits an event `videoUpdate`, the map +re-emits that event (provided the participant is present in the map). diff --git a/docs/ios-core/reference/DyteStage.md b/docs/ios-core/reference/DyteStage.md new file mode 100644 index 000000000..a0d16da71 --- /dev/null +++ b/docs/ios-core/reference/DyteStage.md @@ -0,0 +1,156 @@ +--- +sidebar_position: 10 +web_core_version: 1.20.0 +--- + + + + + +The DyteStage class represents functionality to manage the Stage of the meeting +Stage refers to a virtual area, where participants stream are visible to other participants. +When a participant is off-stage, they are not producing media +but only consuming media from participants who are on Stage + +- [DyteStage](#module_DyteStage) + - [.stageStatus](#module_DyteStage+StageSatus) + - [.accessRequests](#module_DyteStage+getAccessRequests) + - [.requestAccess()](#module_DyteStage+requestAccess) + - [.cancelRequestAccess()](#module_DyteStage+cancelRequestAccess) + - [.grantAccess()](#module_DyteStage+grantAccess) + - [.denyAccess()](#module_DyteStage+denyAccess) + - [.join()](#module_DyteStage+join) + - [.leave()](#module_DyteStage+leave) + - [.kick()](#module_DyteStage+kick) + + + +### get stage status + +```swift +let stageStatus: StageStatus +``` + +Tell the current status of stage for the local user (`meeting.localUser`). To know about possible values check [StageStatus](/ios-core-new/reference/StageStatus) + + + +### get Access Request + +```swift +let accessRequests: [DyteJoinedMeetingParticipant] +``` + +Property to fetch all the participants who raised request to join stage. + + + +### meeting.stage.requestAccess() + +```swift +func requestAccess() +``` + +Method to send a request to privileged users to join the stage. This request is always raised by you(`meeting.localUser`) +for eg. + +```swift +meeting.stage.requestAccess() +``` + + + +### Cancel request to join stage + +```swift +func cancelRequestAccess() +``` + +Method to cancel a previous Stage join request raised by you(`meeting.localUser`) +for eg. + +```swift +meeting.stage.cancelRequestAccess() +``` + + + +### Grant access request + +```swift +func grantAccess(id: String) +``` + +Method to grant access to Stage for the participant id passed. +This can be in response to a Stage Join request, but it can be called on other users as well +for eg. + +```swift +meeting.stage.grantAccess(id: participant.id) +``` + + + +### Deny access request + +```swift +func denyAccess(id: String) +``` + +Method to deny access to Stage for the participant id passed. +This should be called in response to a Stage Join request. +for eg. + +```swift +meeting.stage.denyAccess(id: participant.id) +``` + + + +### Join stage + +```swift +func join() +``` + +Method to join the stage +Users either need to have the permission in the preset or must be accepted by a privileged +user to call this method +for eg. + +```swift +meeting.stage.join() +``` + + + +### Leave stage + +```swift +func leave() +``` + +Method to leave the stage +Users must either be on the stage already or be accepted to join the stage +to call this method +for eg. + +```swift +meeting.stage.leave() +``` + + + +### Kick participant + +```swift +func kick(id: String) +``` + +Method to kick a participant off the stage for the participant id passed. + +for eg. + +```swift +meeting.stage.kick(id: participant.id) +``` diff --git a/docs/ios-core/reference/DyteThemePreset.md b/docs/ios-core/reference/DyteThemePreset.md new file mode 100644 index 000000000..6cc529818 --- /dev/null +++ b/docs/ios-core/reference/DyteThemePreset.md @@ -0,0 +1,85 @@ +--- +sidebar_position: 15 +web_core_version: 1.20.0 +--- + + + + + +The DyteThemePreset class represents the meeting theme for the current participant + +- [DyteThemePreset](#module_DyteThemePreset) + - ~~[.setupScreen](#module_DyteThemePreset+setupScreen)~~ + - ~~[.waitingRoom](#module_DyteThemePreset+waitingRoom)~~ + - ~~[.controlBar](#module_DyteThemePreset+controlBar)~~ + - ~~[.header](#module_DyteThemePreset+header)~~ + - ~~[.pipMode](#module_DyteThemePreset+pipMode)~~ + - [.viewType](#module_DyteThemePreset+viewType) + - [.maxVideoStreams](#module_DyteThemePreset+maxVideoStreams) + - [.maxScreenShareCount](#module_DyteThemePreset+maxScreenShareCount) + - ~~[.plugins](#module_DyteThemePreset+plugins)~~ + - [.disabledPlugins](#module_DyteThemePreset+disabledPlugins) + + + +### ~~dyteThemePreset.setupScreen~~ + +**_Deprecated_** + + + +### ~~dyteThemePreset.waitingRoom~~ + +**_Deprecated_** + + + +### ~~dyteThemePreset.controlBar~~ + +**_Deprecated_** + + + +### ~~dyteThemePreset.header~~ + +**_Deprecated_** + + + +### ~~dyteThemePreset.pipMode~~ + +**_Deprecated_** + + + +### dyteThemePreset.viewType + +The `viewType` tells the type of the meeting +possible values are WEBINAR, GROUP_CALL + + + +### dyteThemePreset.maxVideoStreams + +The `maxVideoStreams` contains the maximum video +streams for mobile and desktop + + + +### dyteThemePreset.maxScreenShareCount + +The `maxScreenShareCount` contains the maximum +possible concurrent screen shares + + + +### ~~dyteThemePreset.plugins~~ + +**_Deprecated_** + + + +### dyteThemePreset.disabledPlugins + +The `disabledPlugins` property returns id of all disabled plugins diff --git a/docs/ios-core/reference/DyteWaitlistedParticipant.md b/docs/ios-core/reference/DyteWaitlistedParticipant.md new file mode 100644 index 000000000..8a39d2e16 --- /dev/null +++ b/docs/ios-core/reference/DyteWaitlistedParticipant.md @@ -0,0 +1,41 @@ +--- +sidebar_position: 4 +web_core_version: 1.20.0 +--- + + + + +**Subclass** of [DyteMeetingParticipant](/ios-core-new/reference/DyteMeetingParticipant) +This class represents a single participant in the meeting. +The participant object can be accessed from one of the participant lists +present in the `meeting.participants` object. For example, + +```swift +let participant1 = meeting.participants.active[0]; +let participant2 = meeting.participants.joined[0]; +``` + +- [DyteWaitlistedParticipant](#module_DyteParticipant) + - [.acceptWaitListedRequest()](#module_DyteParticipant--this.+acceptWaitListedRequest) + - [.rejectWaitListedRequest()](#module_DyteParticipant--this.+rejectWaitListedRequest) + + + +#### Accept Waiting room request + +```swift +fun acceptWaitListedRequest() +``` + +Return a view which is used to render participant camera streams. + + + +#### Reject Waiting room request + +```swift +fun rejectWaitListedRequest() +``` + +Return a view which is used to render participant screen streams. diff --git a/docs/ios-core/reference/StageStatus.md b/docs/ios-core/reference/StageStatus.md new file mode 100644 index 000000000..a77252341 --- /dev/null +++ b/docs/ios-core/reference/StageStatus.md @@ -0,0 +1,44 @@ +--- +sidebar_position: 10 +web_core_version: 1.20.0 +--- + + + + + +```swift +enum StageStatus { + case OFF_STAGE + case REQUESTED_TO_JOIN_STAGE + case ACCEPTED_TO_JOIN_STAGE + case REJECTED_TO_JOIN_STAGE + case ON_STAGE +} +``` + +The DyteStageStatus represent an enum to manage the Stage of the meeting +Stage refers to a virtual area, where participants stream are visible to other participants. +When a participant is off-stage, they are not producing media +but only consuming media from participants who are on Stage. Below are the specificed status of the stage. + +### case OFF_STAGE + +when the participant is not on the Stage ie He/She is a viewer and can't produce media + +### case REQUESTED_TO_JOIN_STAGE + +When participant has permission `Need to Request` from the preset `Media` menu and participant requested to join stage from the Host by calling this method `meeting.stage.requestAccess()` + +### case ACCEPTED_TO_JOIN_STAGE + +When host invited a viewer to join stage by calling `meeting.stage.grantAccess(id: participant.id)` Or +When request to join stage raised by the viewer is accepted by the host. + +### case REJECTED_TO_JOIN_STAGE + +When host rejected a viewer request to join stage by calling `meeting.stage.denyAccess(id: participant.id)` + +### case ON_STAGE + +when the participant is on the Stage and can produce media. Participant can move to this stage by calling the `meeting.stage.join()` diff --git a/docs/ios-core/reference/WaitListStatus.md b/docs/ios-core/reference/WaitListStatus.md new file mode 100644 index 000000000..a77252341 --- /dev/null +++ b/docs/ios-core/reference/WaitListStatus.md @@ -0,0 +1,44 @@ +--- +sidebar_position: 10 +web_core_version: 1.20.0 +--- + + + + + +```swift +enum StageStatus { + case OFF_STAGE + case REQUESTED_TO_JOIN_STAGE + case ACCEPTED_TO_JOIN_STAGE + case REJECTED_TO_JOIN_STAGE + case ON_STAGE +} +``` + +The DyteStageStatus represent an enum to manage the Stage of the meeting +Stage refers to a virtual area, where participants stream are visible to other participants. +When a participant is off-stage, they are not producing media +but only consuming media from participants who are on Stage. Below are the specificed status of the stage. + +### case OFF_STAGE + +when the participant is not on the Stage ie He/She is a viewer and can't produce media + +### case REQUESTED_TO_JOIN_STAGE + +When participant has permission `Need to Request` from the preset `Media` menu and participant requested to join stage from the Host by calling this method `meeting.stage.requestAccess()` + +### case ACCEPTED_TO_JOIN_STAGE + +When host invited a viewer to join stage by calling `meeting.stage.grantAccess(id: participant.id)` Or +When request to join stage raised by the viewer is accepted by the host. + +### case REJECTED_TO_JOIN_STAGE + +When host rejected a viewer request to join stage by calling `meeting.stage.denyAccess(id: participant.id)` + +### case ON_STAGE + +when the participant is on the Stage and can produce media. Participant can move to this stage by calling the `meeting.stage.join()` diff --git a/docs/ios-core/reference/_category_.json b/docs/ios-core/reference/_category_.json new file mode 100644 index 000000000..e7dd5551b --- /dev/null +++ b/docs/ios-core/reference/_category_.json @@ -0,0 +1,5 @@ +{ + "position": 11, + "label": "Reference", + "collapsible": true +}