Group channel

SBDGroupChannel.createChannel(withUserIds: USER_IDS, isDistinct: IS_DISTINCT, completionHandler: { (groupChannel, error) in
    guard error == nil else {
        // Handle error.
    }

    // A group channel of the specified users is successfully created.
    // Through the "groupChannel" parameter of the callback method,
    // you can get the group channel's data from the result object that Sendbird server has passed to the callback method.
    let channelUrl = groupChannel?.channelUrl
    ...
})

SBDGroupChannel.createChannel(withName: NAME, isDistinct: IS_DISTINCT, userIds: USER_IDS, coverUrl: COVER_IMAGE_URL, data: DATA, customType: CUSTOM_TYPE, completionHandler: { (groupChannel, error) in
    guard error == nil else {
        // Handle error.
    }

    // A group channel with additional information is successfully created.
    let channelUrl = groupChannel?.channelUrl
    ...
})

var users: [String] = []
users.append("John")
users.append("Harry")
users.append("Jay")

var ops: [String] = []
ops.append("Jeff")

var params = SBDGroupChannelParams()
params.isPublic = false
params.isEphemeral = false
params.isDistinct = false
params.isSuper = false
params.addUserIds(users)
params.operatorUserIds = ops        // Or .operators
params.name = NAME
params.channelUrl = UNIQUE_CHANNEL_URL  // In a group channel, you can create a new channel by specifying its unique channel URL in a 'GroupChannelParams' object.
params.coverImage = FILE            // Or .coverUrl
params.data = DATA
params.customType = CUSTOM_TYPE

SBDGroupChannel.createChannel(with: params, completionHandler: { (groupChannel, error) in
    guard error == nil else {
        // Handle error.
    }

    // A group channel with detailed configuration is successfully created.
    // By using groupChannel.channelUrl, groupChannel.members, groupChannel.data, groupChannel.customType, and so on,
    // you can access the result object from Sendbird server to check your SBDGroupChannelParams configuration.
    let channelUrl = groupChannel?.channelUrl

})

var userIds: [String] = []
users.append("Tyler")
users.append("Young")

groupChannel.inviteUserIds(userIds, completionHandler: { (error) in
    guard error == nil else {
        // Handle error.
    }


})

// Accepting an invitation
groupChannel.acceptInvitation(completionHandler: { (error) in
    guard error == nil else {
        // Handle error.
    }

    ...
})

// Declining an invitation
groupChannel.declineInvitation(completionHandler: { (error) in
    guard error == nil else {
        // Handle error.
    }

    ...
})

var autoAccept = false  // The value of true (default) means that a user will automatically join a group channel with no choice of accepting and declining an invitation.
SBDMain.setChannelInvitationPreferenceAutoAccept(autoAccept, completionHandler: { (error) in
    guard error == nil else {
        // Handle error.
    }

    ...
})

if groupChannel.isPublic {
    groupChannel.join(completionHandler: { (error) in
        guard error == nil else {
            // Handle error.
        }

        // The current user successfully joins the group channel
        ...
    })
})

channel.leaveChannel(completionHandler: { (error) in
    guard error == nil else {
        // Handle error.
    }

    ...
})

// Freezing a channel
groupChannel.freeze(completionHandler: { (error) in
    guard error == nil else {
        // Handle error.
    }

    // The channel gets frozen.
    // You could display a message telling that chatting in the channel is unavailable, or do something in response to a successful operation.

})

// Unfreezing a channel
groupChannel.unfreeze(completionHandler: { (error) in
    guard error == nil else {
        // Handle error.
    }

    // The channel gets unfrozen.
    // You could display a message telling that chatting in the channel is available again, or do something in response to a successful operation.

})

groupChannel.deleteChannel(completionHandler: { (error) in
    guard error == nil else {
        // Handle error.
    }

    // The channel is successfully deleted.
})

let listQuery = SBDGroupChannel.createMyGroupChannelListQuery()
listQuery?.includeEmptyChannel = true
listQuery?.memberStateFilter = SBDMemberStateFilterJoinedOnly   // SBDMemberStateFilterAll, SBDMemberStateFilterJoinedOnly, SBDMemberStateFilterInvitedOnly
listQuery?.order = SBDGroupChannelListOrderLatestLastMessage    // SBDGroupChannelListOrderChronological, SBDGroupChannelListOrderLatestLastMessage, SBDGroupChannelListOrderChannelNameAlphabetical, and SBDGroupChannelListOrderChannelMetaDataValueAlphabetical
listQuery?.limit = 15

listQuery?.loadNextPage(completionHandler: { (groupChannels, error) in
    guard error == nil else {
        // Handle error.
    }

    // A list of matching group channels is successfully retrieved.
    // Through the "groupChannels" parameter of the callback method,
    // you can access the data of each group channel from the result list that Sendbird server has passed to the callback method.
    self.channels += groupChannels!

})

let listQuery = SBDGroupChannel.createPublicGroupChannelListQuery()
listQuery?.includeEmptyChannel = true
listQuery?.publicMembershipFilter = SBDPublicGroupChannelMembershipFilterJoined // SBDPublicGroupChannelMembershipFilterAll, SBDPublicGroupChannelMembershipFilterJoined
listQuery?.order = SBDPublicGroupChannelListOrderChannelNameAlphabetical    // SBDPublicGroupChannelListOrderChronological, SBDPublicGroupChannelListOrderChannelNameAlphabetical, SBDPublicGroupChannelListOrderChannelMetaDataValueAlphabetical
listQuery?.limit = 15

listQuery?.loadNextPage(completionHandler: { (groupChannels, error) in
    guard error == nil else {
        // Handle error.
    }

    // A list of public group channels matching search criteria is successfully retrieved.
    // Through the "groupChannels" parameter of the callback method,
    // you can access the data of each group channel from the result list that Sendbird server has passed to the callback method.
    self.channels += groupChannels!

})

SBDGroupChannel.getWithUrl(CHANNEL_URL), completionHandler: { (groupChannel, error) in
    guard error == nil else {
        // Handle error.
    }

    // Through the "groupChannel" parameter of the callback method,
    // the group channel object identified with the CHANNEL_URL is returned by Sendbird server,
    // and you can get the group channel's data from the result object.
    let channelName = groupChannel?.name
    ...
}

// Hiding (archiving) a group channel.
groupChannel.hideChannel(withHidePreviousMessages:IS_HIDE_PREVIOUS_MESSAGES, allowAutoUnhide:IS_ALLOW_AUTO_UNHIDE, completionHandler: { (error) in
    guard error == nil else {
        // Handle error.
    }

    // The channel successfully gets hidden from the list.
    // The current user's channel view should be refreshed to reflect the change.
    ...
})

// Unhiding a group channel.
groupChannel.unhideChannel(completionHandler: { (error) in
    guard error == nil else {
        // Handle error.
    }

    // The channel successfully gets unhidden from the list.
    // The current user's channel view should be refreshed to reflect the change.
    ...
})

if channel.hiddenState == SBDChannelHiddenStateFilter.hiddenStateUnhidden {
    // Display the channel in the list.
} else if channel.hiddenState == SBDChannelHiddenStateFilter.hiddenAllowAutoUnhide {
    // Hide the channel from the list, and get it appeared back on condition.
} else if channel.hiddenState == SBDChannelHiddenStateFilter.hiddenPreventAutoUnhide {
    // Archive the channel, and get it appeared back in the list only when the unhideChannel() is called.
}

let listQuery = SBDGroupChannel.createMyGroupChannelListQuery()
// The filter options are limited to 'SBDChannelHiddenStateFilter.unhiddenOnly', 'SBDChannelHiddenStateFilter.hiddenOnly', 'SBDChannelHiddenStateFilter.hiddenAllowAutoUnhide', or 'SBDChannelHiddenStateFilter.hiddenPreventAutoUnhide'.
// If set to 'SBDChannelHiddenStateFilter.hiddenOnly', hidden and archived channels are returned.
listQuery?.channelHiddenStateFilter = SBDChannelHiddenStateFilter.hiddenPreventAutoUnhide

listQuery?.loadNextPage(completionHandler: { (groupChannels, error) in
    guard error == nil else {
        // Handle error.
    }

    // Only archived channels are returned in a result list through the "groupChannels" parameter of the callback method.

})

let listQuery = SBDGroupChannel.createMyGroupChannelListQuery()
listQuery?.userIdsExactFilter = ["John", "Jay"]
listQuery?.loadNextPage(completionHandler: { (groupChannels, error) in
    guard error == nil else {
        // Handle error.
    }

    // Only channelA is returned in a result list through the "list" parameter of the callback method.

})

let listQuery = SBDGroupChannel.createMyGroupChannelListQuery()
listQuery?.setUserIdsIncludeFilter(["John", "Jay", "Jin"], queryType: SBDGroupChannelListQueryType.and)
listQuery?.loadNextPage(completionHandler: { (groupChannels, error) in
    guard error == nil else {
        // Handle error.
    }

    // channelA and channelB including {'John'}, channelA and channelB including {'Jay'}, channelB that including {'Jin'}.
    // Actually, channelA and channelB are returned in a result list.

})

listQuery?.setUserIdsIncludeFilter(["John", "Jay", "Jin"], queryType: SBDGroupChannelListQueryType.or)
listQuery?.loadNextPage(completionHandler: { (groupChannels, error) in
    guard error == nil else {
        // Handle error.
    }

    // channelA and channelB that include {'John'}, plus channelA and channelB that include {'Jay'}, plus channelB that includes {'Jin'}.
    // Actually channelA and channelB are returned.
})

var params = SBDUserMessageParams()
params.message = MESSAGE
params.customType = CUSTOM_TYPE
params.data = DATA
params.mentionType = SBDMentionTypeUsers        // Either SBDMentionTypeUsers or SBDMentionTypeChannel
params.mentionedUserIds = ["Jeff", "Julia"]     // Or .mentionedUsers = LIST_OF_USERS_TO_MENTION
params.metaArrays = ["itemType": ["tablet"], "quality": ["best", "good"]]   // A key-value pair
params.targetLanguages = ["fr", "de"]           // French and German
params.pushNotificationDeliveryOption = .default

groupChannel.sendUserMessage(with: params, completionHandler: { (userMessage, error) in
    guard error == nil else {
        // Handle error.
    }

    // A text message with detailed configuration is successfully sent to the channel.
    // By using userMessage.messageId, userMessage.message, userMessage.customType, and so on,
    // you can access the result object from Sendbird server to check your SBDUserMessageParams configuration.
    // The current user can receive messages from other users through the didReceiveMessage() method of an event delegate.
    long long messageId = fileMessage.messageId;

})

// Sending a file message with a raw file
var thumbnailSizes = [SBDThumbnailSize]()

thumbnailSizes.append(SBDThumbnailSize.make(withMaxCGSize: CGSize(width: 100.0, height: 100.0))!)      // Allowed number of thumbnail images: 3
thumbnailSizes.append(SBDThumbnailSize.make(withMaxWidth: 200.0, maxHeight: 200.0)!)

var params = SBDFileMessageParams()
params.file = FILE                  // Or .fileUrl = FILE_URL (You can also send a file message with a file URL.)
params.fileName = FILE_NAME
params.fileSize = FILE_SIZE
params.mimeType = MIME_TYPE
params.thumbnailSizes = thumbnailSizes
params.customType = CUSTOM_TYPE
params.mentionType = SBDMentionTypeUsers        // Either SBDMentionTypeUsers or SBDMentionTypeChannel
params.mentionedUserIds = ["Jeff", "Julia"]     // Or .mentionedUsers = LIST_OF_USERS_TO_MENTION
params.pushNotificationDeliveryOption = SBDPushNotificationDeliveryOptionDefault

groupChannel.sendFileMessage(with: params, completionHandler: { (fileMessage, error) in
    guard error == nil else {
        // Handle error.
    }

    // A file message with detailed configuration is successfully sent to the channel.
    // By using fileMessage.messageId, fileMessage.fileName, fileMessage.customType, and so on,
    // you can access the result object from Sendbird server to check your SBDFileMessageParams configuration.
    // The current user can receive messages from other users through the didReceiveMessage() method of an event delegate.
    ...
})

// AppDelegate.swift
class AppDelegate: UIResponder, UIApplicationDelegate {
    func application(_ application: UIApplication, handleEventsForBackgroundURLSession identifier: String, completionHandler: @escaping () -> Void) {
        debugPrint("method for handling events for background URL session is waiting to be process. background session id: \(identifier)")
        completionHandler()
    }
}

// Send a critical alert user message.
let userMessageParams = SBDUserMessageParams(message: MESSAGE_TEXT)!
let options = SBDAppleCriticalAlertOptions()
options.name = "name"
options.volume = 0.7    // Acceptable values for `options.volume` range from 0 to 1.0, inclusive.
userMessageParams.appleCriticalAlertOptions = options
groupChannel.sendUserMessage(with: userMessageParams) { (userMessage, error) in
    if error != nil {
        // Handle error.
    }
}

// Send a critical alert file message.
let fileMessageParams = SBDFileMessageParams(file: FILE!)
let options = SBDAppleCriticalAlertOptions()
options.name = "name"
options.volume = 0.7    // Acceptable values for `options.volume` range from 0 to 1.0, inclusive.
fileMessageParams!.appleCriticalAlertOptions = options
groupChannel.sendFileMessage(with: fileMessageParams!) { (fileMessage, error) in
    if error != nil {
        // Handle error.
    }
}

class GroupChannelChattingViewController: UIViewController, SBDChannelDelegate {
    SBDMain.add(self, identifier: self.delegateIdentifier)

    func channel(_ sender: SBDBaseChannel, didReceive message: SBDBaseMessage) {
        // You can customize how to display the different types of messages with the result object in the "message" parameter.
        if message is SBDUserMessage {
            ...
        }
        else if message is SBDFileMessage {
            ...
        }
        else if message is SBDAdminMessage {
            ...
        }
    }
}

SBDMain.removeChannelDelegate(forIdentifier: UNIQUE_DELEGATE_ID)

// Create a `SBDUserMessageParams` object.
let params = SBDUserMessageParams(message: MESSAGE_TEXT)
params?.parentMessageId = PARENT_MESSAGE_ID

// Pass the params to the parameter in the `sendUserMessageWithParams:completionHandler:` method.
groupChannel?.sendUserMessage(with: params!, completionHandler: { (message, error) in
    if error != nil {
        // Handle error.
    }

    // A reply to a specific message in the form of a text message is successfully sent.
    ...
})

// Create a `SBDFileMessageParams` object.
let params = SBDFileMessageParams(file: FILE!)
params?.parentMessageId = PARENT_MESSAGE_ID
...

// Pass the params to the parameter in the `sendFileMessageWithParams:completionHandler:` method.
groupChannel?.sendFileMessage(with: params!, completionHandler: { (message, error) in
    if error != nil {
        // Handle error.
    }

    // A reply to a specific message in the form of a file message is successfully sent.
    ...
})

var userIDsToMention: [String] = []
userIDsToMention.append("Harry")
userIDsToMention.append("Jay")
userIDsToMention.append("Jin")

let params = SBDUserMessageParams(message: MESSAGE)

params?.mentionedUserIds = userIDsToMention

guard let paramsBinded: SBDUserMessageParams = params else {
    return
}

groupChannel.sendUserMessage(with: paramsBinded, completionHandler: { (userMessage, error) in
    guard error == nil else {
        // Handle error.
    }


})

let emojiKey = "smile"
// The BASE_MESSAGE below indicates an SBDBaseMessage object to add a reaction to.
groupChannel.addReaction(with: BASE_MESSAGE, key: emojiKey, completionHandler: { (reactionEvent, error) in
    guard error == nil else {
        // Handle error.
    }

    ...
})

// The BASE_MESSAGE below indicates an SBDBaseMessage object to delete a reaction from.
groupChannel.deleteReaction(with: BASE_MESSAGE, key: emojiKey, completionHandler: { (reactionEvent, error) in
    guard error == nil else {
        // Handle error.
    }

    ...
})

// Note: To add or remove the emoji of which key matches 'smile' below the message on the current user's chat view,
// the apply() method should be called in the channel event delegate's updatedReaction() method.

var params = SBDMessageListParams()
params.includeReactions = INCLUDE_REACTIONS
...

groupChannel.getMessagesByTimestamp(TIMESTAMP, params: params, completionHandler: { (messages, error) in
    guard error == nil else {
        // Handle error.
    }

    for message in messages! {


        for reaction in message.reactions {
            // Check if this emoji has been used when the current user reacted to the message.
            if reaction.userIds.firstIndex(of: SBDMain.getCurrentUser()!.userId) != nil {
                let key = reaction.key
                let updatedAt = reaction.updatedAt

                // Show the emoji however you want on the current user's chat view.
            }
        }
    }
})

func channel(_ sender: SBDBaseChannel, updatedReaction reactionEvent: SBDReactionEvent) {
    ...

    // If there is a message with the reactionEvent.messageId,
    // you can apply the reaction change to the message by calling the apply() method.
    message.apply(reactionEvent)

    // Add or remove an emoji below the message on the current user's chat view.
}

// There should be only one single instance per channel.
let listQuery = groupChannel.createPreviousMessageListQuery()
listQuery?.includeMetaArray = true  // Retrieve a list of messages along with their metaarrays.
listQuery?.includeReactions = true  // Retrieve a list of messages along with their reactions.
...

// Retrieving previous messages.
listQuery?.loadPreviousMessages(withLimit: LIMIT, reverse: REVERSE, completionHandler: { (messages, error) in
    guard error == nil else {
        // Handle error.
    }

    ...
})

SBDMessageListParams *params = [[SBDMessageListParams alloc] init];
[params setIsInclusive:IS_INCLUSIVE];
[params setPreviousResultSize:PREVIOUS_RESULT_SIZE];
[params setNextResultSize:NEXT_RESULT_SIZE];
[params setReverse:REVERSE];
[params setMessageType:MESSAGE_TYPE];
[params setCustomType:CUSTOM_TYPE];


[groupChannel getMessagesByTimestamp:TIMESTAMP params:params completionHandler:^(NSArray<SBDBaseMessage *> * _Nullable messages, SBDError * _Nullable error) {
    if (error != nil) {
        // Handle error.
    }

    // A list of previous and next messages on both sides of a specified timestamp is successfully retrieved.
    // Through the "messages" parameter of the callback method,
    // you can access and display the data of each message from the result list that Sendbird server has passed to the callback method.
    [self.messages addObjectsFromArray:messages];

}];

var params = SBDMessageListParams()
params.isInclusive = IS_INCLUSIVE
params.previousResultSize = PREVIOUS_RESULT_SIZE
params.nextResultSize = NEXT_RESULT_SIZE
params.reverse = REVERSE
params.messageType = MESSAGE_TYPE
params.customType = CUSTOM_TYPE


groupChannel.getMessages(byMessageId: MESSAGE_ID, params: params, completionHandler: { (messages, error) in
    guard error == nil else {
        // Handle error.
    }

    // A list of previous and next messages on both sides of a specified message ID is successfully retrieved.
    // Through the "messages" parameter of the callback method,
    // you can access and display the data of each message from the result list that Sendbird server has passed to the callback method.
    self.messages += messages!

})

let listQuery = groupChannel!.createPreviousMessageListQuery()
listQuery!.replyType = REPLY_TYPE
listQuery!.includeThreadInfo = INCLUDE_THREAD_INFO
listQuery!.includeParentMessageInfo = INCLUDE_PARENT_MESSAGE_INFO
...

// This retrieves previous messages.
listQuery?.loadPreviousMessages(withLimit: LIMIT, reverse: REVERSE, completionHandler: { (messages, error) in
    if error != nil {
        // Handle error.
    }

    ...
})

let params = SBDMessageListParams()
params.previousResultSize = PREV_RESULT_SIZE
params.nextResultSize = NEXT_RESULT_SIZE
params.isInclusive = INCLUSIVE
params.reverse = REVERSE
params.replyType = REPLY_TYPE
params.includeThreadInfo = INCLUDE_THREAD_INFO
params.includeParentMessageInfo = INCLUDE_PARENT_MESSAGE_INFO

groupChannel?.getMessagesByTimestamp(TIMESTAMP, params: params, completionHandler: { (messages, error) in
    if error != nil {
        // Handle error.
    }

    // A list of previous and next messages on both sides of a specified timestamp is successfully retrieved.
    // Through the "messages" parameter of the callback method,
    // you can access and display the data of each message from the result list that Sendbird server has passed to the callback method.
    self.messages += messages!
    ...
})

groupChannel?.getMessagesByMessageId(MESSAGE_ID, params: params, completionHandler: { (messages, error) in
    if error != nil {
        // Handle error.
    }

    // A list of previous and next messages on both sides of a specified message ID is successfully retrieved.
    // Through the "messages" parameter of the callback method,
    // you can access and display the data of each message from the result list that Sendbird server has passed to the callback method.
    self.messages += messages!
    ...
})

// Create a `SBDThreadedMessageListParams` object.
let params = SBDThreadedMessageListParams()
params.previousResultSize = PREV_RESULT_SIZE
params.nextResultSize = NEXT_RESULT_SIZE
params.isInclusive = INCLUSIVE
params.reverse = REVERSE
params.includeParentMessageInfo = INCLUDE_PARENT_MESSAGE_INFO
...

// Pass the params to the parameter in the `getThreadedMessagesByTimestamp:params:completionHandler:` method.
parentMessage.getThreadedMessages(byTimestamp: TIMESTAMP, params: params) { (parentMessage, threadedReplies, error) in
    if error != nil {
        // Handle error.
    }

    // A list of replies of the specified parent message timestamp is successfully retrieved.
    // Through the "threadedReplies" parameter of the callback method,
    // you can access and display the data of each message from the result list that Sendbird server has passed to the callback method.
    ...
}

// Create a `SBDMessageRetrievalParams` object.
let params = SBDMessageRetrievalParams()
params.messageId = MESSAGE_ID
params.channelType = CHANNEL_TYPE
params.channelUrl = CHANNEL_URL
...

// Pass the params to the parameter of the `getMessageWithParams:completionHandler:` method.
SBDBaseMessage.getWith(params) { (message, error) in
    if error != nil {
        // Handle error.
    }

    // The specified message is successfully retrieved.
    ...
}

// For a text Message
var params = SBDUserMessageParams(message: NEW_TEXT_MESSAGE)
params.customType = NEW_CUSTOM_TYPE
params.data = NEW_DATA

// The USER_MESSAGE_ID below indicates the unique message ID of a UserMessage object to update.
groupChannel.updateUserMessage(withMessageId: USER_MESSAGE_ID, userMessageParams: params, completionHandler: { (userMessage, error) in
    guard error == nil else {
        // Handle error.
    }

    // The message is successfully updated.
    // Through the "userMessage" parameter of the callback method,
    // you could check if the update operation has been performed right.
    let text = userMessage?.message
    ...
})

// For a file message
var params = SBDFileMessageParams(fileUrl: NEW_FILE_URL)
params.fileName = NEW_FILE_NAME
params.fileSize = NEW_FILE_SIZE
params.customType = NEW_CUSTOM_TYPE

// The FILE_MESSAGE_ID below indicates the unique message ID of a FileMessage object to update.
groupChannel.updateFileMessage(withMessageId: FILE_MESSAGE_ID, fileMessageParams: params, completionHandler: { (fileMessage, error) in
    guard error == nil else {
        // Handle error.
    }

    // The message is successfully updated.
    // Through the "fileMessage" parameter of the callback method,
    // you could check if the update operation has been performed right.
    let customType = fileMessage?.customType
    ...
})

class GroupChannelChattingViewController: UIViewController, SBDChannelDelegate {
    SBDMain.add(self, identifier: self.delegateIdentifier)

    func channel(_ sender: SBDBaseChannel, didUpdate message: SBDBaseMessage) {
        ...
    }
}

// The BASE_MESSAGE below indicates a BaseMessage object to delete.
groupChannel.delete(BASE_MESSAGE, completionHandler: { (error) in
    guard error == nil else {
        // Handle error.
    }

    // The message is successfully deleted from the channel.
    ...
})

class GroupChannelChattingViewController: UIViewController, SBDChannelDelegate {
    SBDMain.add(self, identifier: UNIQUE_DELEGATE_ID)

    func channel(_ sender: SBDBaseChannel, messageWasDeleted messageId: Int64) {
        ...
    }
}

groupChannel.copyUserMessage(MESSAGE_TO_COPY, toTargetChannel:TARGET_CHANNEL, completionHandler: { (userMessage, error) in
    guard error == nil else {
        // Handle error.
    }

    // The message is successfully copied to the target channel.
    ...
})

groupChannel.copyFileMessage(MESSAGE_TO_COPY, toTargetChannel:TARGET_CHANNEL, completionHandler: { (fileMessage, error) in
    guard error == nil else {
        // Handle error.
    }

    // The message is successfully copied to the target channel.
    ...
})

groupChannel.resetMyHistory(completionHandler: { (error) in
    guard error == nil else {
        // Handle error.
    }

    ...
})

groupChannel.refresh(completionHandler: { (error) in
    guard error == nil else {
        // Handle error.
    }

    ...
})

let members = groupChannel?.members

let listQuery = groupChannel.createOperatorListQuery()
listQuery?.limit = 10   // In an alphabetical order by default
listQuery?.order = SBDMemberListOrderOperatorThenMemberNicknameAlphabetical

listQuery?.loadNextPage(completionHandler: { (users, error) in
    guard error == nil else {
        // Handle error.
    }

    // A list of matching members and operators is successfully retrieved.
    // Through the "users" parameter of the callback method,
    // you can access the data of each item from the result list that Sendbird server has passed to the callback method.
    for user in users! {
        ...
    }
})

let listQuery = groupChannel.createMemberListQuery()
listQuery?.limit = 10
listQuery.operatorFilter = SBDGroupChannelOperatorFilterOperator  // In an alphabetical order by default

listQuery?.loadNextPage(completionHandler: { (users, error) in
    guard error == nil else {
        // Handle error.
    }

    // A list of matching members and operators is successfully retrieved.
    // Through the "users" parameter of the callback method,
    // you can access the data of each item from the result list that Sendbird server has passed to the callback method.
    for user in users! {
        ...
    }
})

let listQuery = groupChannel.createOperatorListQuery()
listQuery?.loadNextPage(completionHandler: { (users, error) in
    guard error == nil else {
        // Handle error.
    }

    // Retrieving operators.
    for operator in users! {
        ...
    }
})

groupChannel.addOperators(withUserIds: [USER_ID_1, USER_ID_2]) { (error) in
    guard error == nil else {
        // Handle error.
    }

    // The participants are successfully registered as operators of the channel.
    ...
}

groupChannel.removeOperators(withUserIds: [USER_ID_1, USER_ID_2]) { (error) in
    guard error == nil else {
        // Handle error.
    }

    // The cancel operation is succeeded,
    // and you could display some message to those who are not operators anymore.
    ...
}

groupChannel.removeAllOperators { (error) in
    guard error == nil else {
        // Handle error.
    }

    // The cancel operation is succeeded,
    // and you could display some message to those who are not operators anymore.
    ...
}

// Retrieving banned users.
let listQuery = groupChannel.createBannedUserListQuery()
listQuery?.loadNextPage(completionHandler: { (users, error) in
    guard error == nil else {
        // Handle error.
    }

    ...
})

// Retrieving muted users.
let listQuery = groupChannel.createMemberListQuery()
listQuery?.mutedMemberFilter = SBDGroupChannelMutedMemberFilter.muted
listQuery?.loadNextPage(completionHandler: { (members, error) in
    guard error == nil else {
        // Handle error.
    }

    ...
})

SBDGroupChannel.getWithUrl(CHANNEL_URL, completionHandler: { (groupChannel, error) in
    guard error == nil else {
        // Handle error.
    }

    if groupChannel?.myRole == SBDRole.operator {
        groupChannel?.ban(USER, seconds: SECONDS, description: DESCRIPTION, completionHandler: { (error) in
            guard error == nil else {
                // Handle error.
            }

            // The user is successfully banned from the channel.
            // You could notify the user of being banned by displaying a prompt.
            ...
        })

        groupChannel?.unbanUser(USER, completionHandler: { (error) in
            guard error == nil else {
                // Handle error.
            }

            // The user is successfully unbanned for the channel.
            // You could notify the user of being unbanned by displaying a prompt.
            ...
        })
    }
})

SBDGroupChannel.getWithUrl(CHANNEL_URL, completionHandler: { (groupChannel, error) in
    if groupChannel?.myRole == SBDRole.operator {
        groupChannel?.muteUser(USER, completionHandler: { (error) in
            guard error == nil else {
                // Handle error.
            }

            // The user is successfully muted in the channel.
            // You could notify the user of being muted by displaying a prompt.
            ...
        })

        groupChannel?.unmuteUser(USER, completionHandler: { (error) in
            guard error == nil else {
                // Handle error.
            }

            // The user is successfully unmuted in the channel.
            // You could notify the user of being unmuted by displaying a prompt.
            ...
        })
    }
})

// Reporting a message.
groupChannel.report(message: MESSAGE_TO_REPORT, reportCategory: REPORT_CATEGORY, reportDescription: DESCRIPTION, completionHandler: { (error) in
    guard error == nil else {
        // Handle error.
    }

    ...
})

// Reporting a user.
groupChannel.report(offendingUser: OFFENDING_USER, reportCategory: REPORT_CATEGORY, reportDescription: DESCRIPTION, completionHandler: { (error) in
    guard error == nil else {
        // Handle error.
    }

    ...
})

// Reporting a channel.
groupChannel.report(withCategory: REPORT_CATEGORY, reportDescription: DESCRIPTION, completionHandler: { (error) in
    guard error == nil else {
        // Handle error.
    }

    ...
})