Methods
Overview
The UI Kit's core function is to extend the CometChat SDK, essentially translating the raw data and functionality provided by the underlying methods into visually appealing and easy-to-use UI components.
To effectively manage and synchronize the UI elements and data across all components in the UI Kit, we utilize internal events. These internal events enable us to keep track of changes in real-time and ensure that the UI reflects the most current state of data.
The CometChat UI Kit has thoughtfully encapsulated the critical CometChat SDK methods within its wrapper to efficiently manage internal eventing. This layer of abstraction simplifies interaction with the underlying CometChat SDK, making it more user-friendly for developers.
Methods
You can access the methods using the CometChatUIKit
class. This class provides access to all the public methods exposed by the CometChat UI Kit.
Init
As a developer, you need to invoke this method every time before you use any other methods provided by the UI Kit.
This initialization is a critical step that ensures the UI Kit and ChatSDK function correctly and as intended in your application. Typical practice is to make this one of the first lines of code executed in your application's lifecycle when it comes to implementing CometChat.
Make sure you replace the APP_ID, REGION and AUTH_KEY with your CometChat App ID, Region and Auth Key in the below code. The Auth Key
is an optional property of the UIKitSettings
Class. It is intended for use primarily during proof-of-concept (POC) development or in the early stages of application development. You can use the Auth Token to log in securely.
Here's the table format for the properties available in UIKitSettings
:
Method | Type | Description |
---|---|---|
set(appID:) | String | Sets the unique ID for the app, available on dashboard |
set(region:) | String | Sets the region for the app ('us' or 'eu') |
set(authKey:) | String | Sets the auth key for the app, available on dashboard |
subscribePresenceForAllUsers | String | Sets subscription type for tracking the presence of all users |
subscribePresenceForFriends | String | Sets subscription type for tracking the presence of friends |
subscribePresenceForRoles | String | Sets subscription type for tracking the presence of users with specified roles |
setAutoEstablishSocketConnection | Boolean | Configures if web socket connections will established automatically on app initialization or be done manually, set to true by default |
setAIFeatures | List<AIExtensionDataSource> | Sets the AI Features that need to be added in UI Kit |
setExtensions | List<ExtensionsDataSource> | Sets the list of extension that need to be added in UI Kit |
The concluding code block:
- Swift
let uiKitSettings = UIKitSettings()
.set(region: "your_region")
.set(appID: "your_appId")
.set(authKey: "your_authKey")
.subscribePresenceForAllUsers()
.autoEstablishSocketConnection(bool: true)
CometChatUIKit.init(uiKitSettings: uikitSettings) { result in
switch result{
case .success(let bool):
print( "Initialization success")
case .failure(let error):
print("CometChat exception: \(error)")
}
}
Login using Auth Key
Only the UID
of a user is needed to log in. This simple authentication procedure is useful when you are creating a POC or if you are in the development phase. For production apps, we suggest you use AuthToken instead of Auth Key.
The concluding code block:
- Swift
CometChatUIKit.login(uid: "uid") { (result) in
switch result {
case .success(let user):
print("CometChat user logged in: \(user)")
case .onError(let error):
print("CometChat exception: \(error)")
}
}
Login using Auth Token
This advanced authentication procedure does not use the Auth Key directly in your client code thus ensuring safety.
- Create a User via the CometChat API when the user signs up in your app.
- Create an Auth Token via the CometChat API for the new user and save the token in your database.
- Load the Auth Token in your client and pass it to the
login(authToken:)
method.
The concluding code block:
- Swift
CometChatUIKit.login(authToken: "your_authToken") { (result) in
switch result {
case .success(let user):
print("CometChat user logged in: \(user)")
case .onError(let error):
print("CometChat exception: \(error)")
}
}
Logout
The CometChat UI Kit and Chat SDK effectively handle the session of the logged-in user within the framework. Before a new user logs in, it is crucial to clean this data to avoid potential conflicts or unexpected behavior. This can be achieved by invoking the .logout(user:)
function.
The concluding code block:
- Swift
let user = User(uid: "uid", name: "user_name")
CometChatUIKit.logout(user: user) { (result) in
switch result {
case .success(let user):
print("CometChat user logged out: \(user)")
case .onError(let error):
print("CometChat exception: \(error)")
}
}
Create User
As a developer, you can dynamically create users on CometChat using the .create(user:)
function. This can be extremely useful for situations where users are registered or authenticated by your system and then need to be created on CometChat.
The concluding code block:
- Swift
let user = User(uid: "uid", name: "user_name")
CometChatUIKit.create(user: user) { result in
switch result {
case .success(let user):
print("CometChat user logged out: \(user)")
case .onError(let error):
print("CometChat exception: \(error)")
}
}
Base Message
Text Message
As a developer, if you need to send a text message to a single user or a group, you'll need to utilize the sendTextMessage()
function. This function requires a TextMessage
object as its argument, which contains the necessary information for delivering the message.
The concluding code block:
- Swift
let textMessage = TextMessage(receiverUid: "uid", text: message, receiverType: .user)
textMessage.muid = "\(NSDate().timeIntervalSince1970)"
textMessage.sentAt = Int(Date().timeIntervalSince1970)
textMessage.senderUid = CometChat.getLoggedInUser()?.uid ?? ""
textMessage.sender = CometChat.getLoggedInUser()
textMessage.parentMessageId = parentMessageId
CometChatUIKit.sendTextMessage(message: textMessage)
It's essential to understand the difference between
CometChatUIKit.sendTextMessage()
andCometChat.sendTextMessage()
. When you useCometChatUIKit.sendTextMessage()
, it automatically adds the message to the MessagesComponent and ConversationsComponent, taking care of all related cases for you. On the other hand,CometChat.sendTextMessage()
only sends the message and doesn't automatically update these components in the UI Kit.
Media Message
As a developer, if you need to send a media message to a single user or a group, you'll need to utilize the sendMediaMessage()
function. This function requires a MediaMessage
object as its argument, which contains the necessary information for delivering the message.
The concluding code block:
- Swift
let mediaMessage = MediaMessage(receiverUid: "uid", fileurl: url, messageType: type, receiverType: .user)
mediaMessage.muid = "\(NSDate().timeIntervalSince1970)"
mediaMessage.sentAt = Int(Date().timeIntervalSince1970)
mediaMessage.sender = CometChat.getLoggedInUser()
mediaMessage.metaData = ["fileURL": url]
mediaMessage.senderUid = CometChat.getLoggedInUser()?.uid ?? ""
mediaMessage.parentMessageId = parentMessageId
CometChatUIKit.sendMediaMessage(message: MediaMessage)
It's essential to understand the difference between
CometChatUIKit.sendMediaMessage()
andCometChat.sendMediaMessage()
. When you useCometChatUIKit.sendMediaMessage()
, it automatically adds the message to the MessagesComponent and ConversationsComponent, taking care of all related cases for you. On the other hand,CometChat.sendMediaMessage()
only sends the message and doesn't automatically update these components in the UI Kit.
Custom Message
As a developer, if you need to send a custom message to a single user or a group, you'll need to utilize the sendCustomMessage()
function. This function requires a CustomMessage
object as its argument, which contains the necessary information for delivering the message.
The concluding code block:
- Swift
var customData = [String: Any]()
customData["key"] = "value"
let customMessage = CustomMessage(receiverUid: "uid or guid", receiverType: .user, customData: customData, type: "custom message type")
customMessage.muid = "\(Int(Date().timeIntervalSince1970))"
customMessage.senderUid = CometChat.getLoggedInUser()?.uid
customMessage.sender = CometChat.getLoggedInUser()
CometChatUIKit.sendCustomMessage(message: CustomMessage)
It's essential to understand the difference between
CometChatUIKit.sendCustomMessage()
andCometChat.sendCustomMessage()
. When you useCometChatUIKit.sendCustomMessage()
, it automatically adds the message to the MessagesComponent and ConversationsComponent, taking care of all related cases for you. On the other hand,CometChat.sendCustomMessage()
only sends the message and doesn't automatically update these components in the UI Kit.
Interactive Message
Form Message
As a developer, if you need to send a Form message to a single user or a group, you'll need to utilize the sendFormMessage()
function. This function requires a FormMessage
object as its argument, which contains the necessary information to create a form bubble for that messages
The concluding code block:
- Swift
let apiAction = APIAction()
apiAction.url = "https://example.com/api"
apiAction.method = .POST
let submitButton = ButtonElement()
submitButton.elementId = "1"
submitButton.action = apiAction
submitButton.buttonText = "Submit"
let nameInput = TextInput()
nameInput.elementId = "1"
nameInput.placeHolder = "Please enter your name"
let formMessage = FormMessage(title: "Title",receiverUid: receiverId,receiverType: .user, formFields: [nameInput],submitElement: submitButton)
CometChatUIKit.sendFormMessage(formMessage) { form in
print("Form message sent: \(form)")
} onError: { error in
print("CometChat exception: \(error)")
}
Card Message
As a developer, if you need to send a Card message to a single user or a group, you'll need to utilize the sendCardMessage()
function. This function requires a CardMessage
object as its argument, which contains the necessary information to create a card bubble for the messages.
The concluding code block:
- Swift
let apiAction = APIAction()
apiAction.url = "https://example.com/api"
apiAction.method = .POST
let cardAction = ButtonElement()
cardAction.elementId = "1"
cardAction.action = apiAction
cardAction.buttonText = "Click Me"
let cardMessage = CardMessage(url:"ImageURL", receiverUid:"receiverId", receiverType:.user, cardActions:[cardAction],text: "This is a card")
CometChatUIKit.sendCardMessage(cardMessage) { success in
print("Card message sent: \(success)")
} onError: { error in
print("CometChat exception: \(error)")
}
Scheduler Message
As a developer, if you need to send a Scheduler message to a single user or a group, you'll need to utilize the sendSchedulerMessage()
function. This function requires a SchedulerMessage
object as its argument, which contains the necessary information to create a SchedulerMessage bubble for the messages.
The concluding code block:
- Swift
var interactiveData = [String: Any]()
interactiveData["key"] = "value"
let schedulerMessage = SchedulerMessage(receiverUid: "receiver_uid", type: "scheduler message type", receiverType: .user, interactiveData: interactiveData)
CometChatUIKit.sendSchedulerMessage(schedulerMessage: schedulerMessage) { scheduler in
print("Scheduler message sent: \(scheduler)")
} onError: { error in
print("CometChat exception: \(error)")
}