​
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 Chat SDK 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:
MethodTypeDescription
set(appID:)StringSets the unique ID for the app, available on dashboard
set(region:)StringSets the region for the app (‘us’ or ‘eu’)
set(authKey:)StringSets the auth key for the app, available on dashboard
subscribePresenceForAllUsersStringSets subscription type for tracking the presence of all users
subscribePresenceForFriendsStringSets subscription type for tracking the presence of friends
subscribePresenceForRolesStringSets subscription type for tracking the presence of users with specified roles
setAutoEstablishSocketConnectionBooleanConfigures if web socket connections will established automatically on app initialization or be done manually, set to true by default
setAIFeaturesList<AIExtensionDataSource>Sets the AI Features that need to be added in UI Kit
setExtensionsList<ExtensionsDataSource>Sets the list of extension that need to be added in UI Kit
The concluding code block: 
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: 
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.
  1. Create a User via the CometChat API when the user signs up in your app.
  2. Create an Auth Token via the CometChat API for the new user and save the token in your database.
  3. Load the Auth Token in your client and pass it to the login(authToken:) method.
The concluding code block: 
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: 
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: 
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: 
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() and CometChat.sendTextMessage(). When you use CometChatUIKit.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: 
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() and CometChat.sendMediaMessage(). When you use CometChatUIKit.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: 
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() and CometChat.sendCustomMessage(). When you use CometChatUIKit.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: 
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: 
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: 
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)")
}