Open channel

SBDOpenChannel.createChannel(withName: NAME, coverUrl: COVER_URL, data: DATA, operatorUsers: OPERATOR_USERS, completionHandler: { (openChannel, error) in
    guard error == nil else {
        // Handle error.
    }

    // An open channel is successfully created.
    // Through the "openChannel" parameter of the callback method,
    // you can get the open channel's data from the result object that Sendbird server has passed to the callback method.
    let channelUrl = openChannel?.channelUrl

})

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

var params = SBDOpenChannelParams()
params.operatorUserIds = ops        // Or .operators
params.name = NAME
params.channelUrl = UNIQUE_CHANNEL_URL    // In an open channel, you can create a new channel by specifying its unique channel URL.
params.coverImage = FILE            // Or .coverUrl
params.data = DATA
params.customType = CUSTOM_TYPE

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

    // An open channel with detailed configuration is successfully created.
    // By using openChannel.channelUrl, openChannel.data, openChannel.customType, and so on,
    // you can access the result object from Sendbird server to check your SBDOpenChannelParams configuration.
    let channelUrl = openChannel?.channelUrl

})

SBDOpenChannel.createChannel(withName: NAME, coverImage: COVER_IMAGE, coverImageName: "", data: DATA, operatorUsers: OPERATOR_USERS, customType: CUSTOM_TYPE, progressHandler: nil) { (openChannel, error) in
    guard error == nil else {
        // Handle error.
    }

    // An open channel with detailed configuration is successfully created.
    let channelUrl = openChannel?.channelUrl

}

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

    // Call the instance method of the result object in the "openChannel" parameter of the callback method.
    openChannel?.enter(completionHandler: { (error) in
        guard error == nil else {
            // Handle error.
        }

        // The current user successfully enters the open channel,
        // and can chat with other users in the channel by using APIs.

    })
})

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

    // Call the instance method of the result object in the "openChannel" parameter of the callback method.
    openChannel?.exitChannel(completionHandler: { (error) in
        guard error == nil else {
            // Handle error.
        }

        // The current user successfully exits the open channel.

    })
})

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

    // The channel is successfully deleted.
    ...
})

let listQuery = SBDOpenChannel.createOpenChannelListQuery()!

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

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

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

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

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

openChannel.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.
    let messageId = userMessage?.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

openChannel.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.
    let messageId = fileMessage?.messageId

})

// 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
openChannel.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
openChannel.sendFileMessage(with: fileMessageParams!) { (fileMessage, error) in
    if error != nil {
        // Handle error.
    }
}

class OpenChannelChattingViewController: 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.
openChannel?.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 // This specifies the unique ID of a parent message which has a thread of replies. If the message sent through the `sendFileMessageWithParams:completionHandler:` method is a parent message, the value of this property is 0.
...

// Pass the params to the parameter in the `sendFileMessageWithParams:completionHandler:` method.
openChannel?.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
}

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


})

// There should be only one single instance per channel.
let listQuery = openChannel.createPreviousMessageListQuery()
listQuery?.customTypeFilter = "greeting"


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


})

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
...

openChannel.getMessagesByTimestamp(TIMESTAMP, 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 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!
    ...
})

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


openChannel.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 = openChannel!.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

openChannel?.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!
    ...
})

openChannel?.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.
openChannel.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.
openChannel.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 OpenChannelChattingViewController: 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.
openChannel.delete(BASE_MESSAGE, completionHandler: { (error) in
    guard error == nil else {
        // Handle error.
    }

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

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

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

openChannel.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.
    ...
})

openChannel.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.
    ...
})

let listQuery = openChannel.createParticipantListQuery()

listQuery?.loadNextPage(completionHandler: { (participants, error) in
    if error != nil {
        // Handle error.
    }

    ...
})

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

    // Retrieving operators.
    for operator in openChannel.operators {

    }
})

let listQuery = openChannel.createOperatorListQuery()

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

    // Retrieving operators.
    for operator in users! {

    }
})

openChannel.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.
    ...
}

openChannel.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.
    ...
}

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

    ...
}

// Retrieving banned users.
let listQuery = openChannel.createBannedUserListQuery()

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

    ...
})

// Retrieving muted users.
let listQuery = openChannel.createMutedUserListQuery()

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

    ...
})

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

    if openChannel!.isOperator(with: SBDMain.getCurrentUser()!) {
        // Ban a user.
        openChannel?.ban(USER, seconds: SECONDS, 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.
            ...
        })

        // Unban a user.
        openChannel?.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.
            ...
        })
    }
})

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

    if openChannel?.isOperator(with: USER) ?? false {
        // Mute a user.
        openChannel?.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.
            ...
        })

        // Unmute a user.
        openChannel?.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.
openChannel.report(message: MESSAGE_TO_REPORT, reportCategory: REPORT_CATEGORY, reportDescription: DESCRIPTION, completionHandler: { (error) in
    guard error == nil else {
        // Handle error.
    }

    ...
})

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

    ...
})

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

    ...
})