> ## Documentation Index
> Fetch the complete documentation index at: https://cometchat-22654f5b-docs-rn-guide-message-privately.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.

# Methods

> Methods — CometChat documentation.

## Overview

The UI Kit's core function is to extend the [CometChat SDK](/sdk/ios/overview), 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](/sdk/ios/overview) 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.

<Note>
  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](#login-using-auth-token) to log in securely.
</Note>

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:

<Tabs>
  <Tab title="Swift">
    ```swift theme={null}
    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)")
      }
    }
    ```
  </Tab>
</Tabs>

***

### 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](#login-using-auth-token) instead of Auth Key.

The concluding code block:

<Tabs>
  <Tab title="Swift">
    ```swift theme={null}
    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)")
      }
    }
    ```
  </Tab>
</Tabs>

***

### 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](/rest-api/chat-apis) via the CometChat API when the user signs up in your app.
2. [Create an Auth Token](/rest-api/chat-apis) 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:

<Tabs>
  <Tab title="Swift">
    ```swift theme={null}
    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)")
      }
    }
    ```
  </Tab>
</Tabs>

***

### 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:

<Tabs>
  <Tab title="Swift">
    ```swift theme={null}
    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)")
      }
    }
    ```
  </Tab>
</Tabs>

***

### 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:

<Tabs>
  <Tab title="Swift">
    ```swift theme={null}
    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)")
      }
    }
    ```
  </Tab>
</Tabs>

***

### 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:

<Tabs>
  <Tab title="Swift">
    ```swift theme={null}
    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)
    ```
  </Tab>
</Tabs>

> 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](/ui-kit/android/message-header) and [ConversationsComponent](/ui-kit/android/conversations), 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:

<Tabs>
  <Tab title="Swift">
    ```swift theme={null}
    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)
    ```
  </Tab>
</Tabs>

> 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](/ui-kit/ios/v4/messages) and [ConversationsComponent](/ui-kit/ios/v4/conversations), 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:

<Tabs>
  <Tab title="Swift">
    ```swift theme={null}
    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)
    ```
  </Tab>
</Tabs>

> 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](/ui-kit/ios/v4/messages) and [ConversationsComponent](/ui-kit/ios/v4/conversations), 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:

<Tabs>
  <Tab title="Swift">
    ```swift theme={null}
    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)")
    }
    ```
  </Tab>
</Tabs>

***

#### 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:

<Tabs>
  <Tab title="Swift">
    ```swift theme={null}
    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)")
    }
    ```
  </Tab>
</Tabs>

***

#### 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:

<Tabs>
  <Tab title="Swift">
    ```swift theme={null}
    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)")
    }
    ```
  </Tab>
</Tabs>

***