> ## 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 [Chat SDK](/sdk/android/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 [Chat SDK](/sdk/android/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>

<Tabs>
  <Tab title="Java">
    ```java theme={null}
    CometChatUIKit.init(Context context, UIKitSettings authSettings, CometChat.CallbackListener<String> callbackListener)
    ```
  </Tab>

  <Tab title="Kotlin">
    ```kotlin theme={null}
    CometChatUIKit.init(context: Context, authSettings: UIKitSettings, callbackListener: CometChat.CallbackListener<String>)
    ```
  </Tab>
</Tabs>

As a developer, the `UIKitSettings` is an important parameter of the `init()` function. It functions as a base settings object, housing properties such as `appId`, `region`, and `authKey`, contained within `UIKitSettings`.

Here's the table format for the properties available in `UIKitSettings`:

| Method                               | Type                          | Description                                                                                                                           |
| ------------------------------------ | ----------------------------- | ------------------------------------------------------------------------------------------------------------------------------------- |
| **setAppId**                         | `String`                      | Sets the unique ID for the app, available on dashboard                                                                                |
| **setRegion**                        | `String`                      | Sets the region for the app ('us' or 'eu')                                                                                            |
| **setAuthKey**                       | `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="Java">
    ```java theme={null}
    UIKitSettings uiKitSettings = new UIKitSettings.UIKitSettingsBuilder()
        .setRegion(your_region)
        .setAppId(your_appID)
        .setAuthKey(your_authKey)
        .subscribePresenceForAllUsers().build();


    CometChatUIKit.init(context, uiKitSettings, new CometChat.CallbackListener<String>() {
        @Override
        public void onSuccess(String response) {
            Log.i(TAG, "CometChat init onSuccess: "+response);

        @Override
        public void onError(CometChatException e) {
            Log.e(TAG, "CometChat init exception: "+e);
        }
    });
    ```
  </Tab>

  <Tab title="Kotlin">
    ```kotlin theme={null}
    val uiKitSettings: UIKitSettings = UIKitSettingsBuilder()
        .setRegion(your_region)
        .setAppId(your_appID)
        .setAuthKey(your_authKey)
        .subscribePresenceForAllUsers()
        .build()

    CometChatUIKit.init(context, uiKitSettings, object : CometChat.CallbackListener<String>() {
        override fun onSuccess(response: String) {
            Log.i(TAG, "CometChat init onSuccess: $response")
        }

        override fun onError(e: CometChatException) {
            Log.e(TAG, "CometChat init exception: $e")
        }
    })
    ```
  </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.

<Tabs>
  <Tab title="Java">
    ```java theme={null}
    CometChatUIKit.login(String uid, CometChat.CallbackListener <User> callbackListener)
    ```
  </Tab>

  <Tab title="Kotlin">
    ```kotlin theme={null}
    CometChatUIKit.login(uid: String, callbackListener: CometChat.CallbackListener<User>)
    ```
  </Tab>
</Tabs>

The concluding code block:

<Tabs>
  <Tab title="Java">
    ```java theme={null}
    CometChatUIKit.login(UID, new CometChat.CallbackListener<User>() {
         @Override
         public void onSuccess(User user) {
             Log.i(TAG, "CometChat Login Successful : " + user.toString());
         }
         @Override
         public void onError(CometChatException e) {
             Log.e(TAG, "CometChat Login Failed : " + e.getMessage());
         }
    });
    ```
  </Tab>

  <Tab title="Kotlin">
    ```kotlin theme={null}
    CometChatUIKit.login(UID, object : CometChat.CallbackListener<User>() {
     override fun onSuccess(user: User) {
         Log.i(TAG, "CometChat Login Successful : $user")
     }

     override fun onError(e: CometChatException) {
         Log.e(TAG, "CometChat Login Failed : ${e.message}")
     }
    })
    ```
  </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 `loginWithAuthToken()` method.

   <Tabs>
     <Tab title="Java">
       ```java theme={null}
       CometChatUIKit.loginWithAuthToken(String authToken, CometChat.CallbackListener <User> callbackListener)
       ```
     </Tab>

     <Tab title="Kotlin">
       ```kotlin theme={null}
       CometChatUIKit.loginWithAuthToken(authToken: String, callbackListener: CometChat.CallbackListener<User>)
       ```
     </Tab>
   </Tabs>

   The concluding code block:

   <Tabs>
     <Tab title="Java">
       ```java theme={null}
       CometChatUIKit.loginWithAuthToken(AuthToken, new CometChat.CallbackListener<User>() {
            @Override
            public void onSuccess(User user) {
                Log.i(TAG, "CometChat Login Successful : " + user.toString());
            }
            @Override
            public void onError(CometChatException e) {
                Log.e(TAG, "CometChat Login Failed : " + e.getMessage());
            }
       });
       ```
     </Tab>

     <Tab title="Kotlin">
       ```kotlin theme={null}
       CometChatUIKit.loginWithAuthToken(AuthToken, object : CometChat.CallbackListener<User>() {
        override fun onSuccess(user: User) {
            Log.i(TAG, "CometChat Login Successful : $user")
        }

        override fun onError(e: CometChatException) {
            Log.e(TAG, "CometChat Login Failed : ${e.message}")
        }
       })
       ```
     </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()` function

<Tabs>
  <Tab title="Java">
    ```java theme={null}
        CometChatUIKit.logout(CometChat.CallbackListener <String> callbackListener)
    ```
  </Tab>

  <Tab title="Kotlin">
    ```kotlin theme={null}
        CometChatUIKit.logout(callbackListener: CometChat.CallbackListener<String>)
    ```
  </Tab>
</Tabs>

The concluding code block:

<Tabs>
  <Tab title="Java">
    ```java theme={null}
    CometChatUIKit.logout(new CometChat.CallbackListener<String>() {
        @Override
        public void onSuccess(String s) {
            // your action on logout
        }
        @Override
        public void onError(CometChatException e) {
        }
    });
    ```
  </Tab>

  <Tab title="Kotlin">
    ```kotlin theme={null}
    CometChatUIKit.logout(object: CometChat.CallbackListener<String>() {
        override fun onSuccess(s: String) {
            // your action on logout
        }

        override fun onError(e: CometChatException) {
            // Error handling
        }
    })
    ```
  </Tab>
</Tabs>

***

### Create User

As a developer, you can dynamically create users on CometChat using the `.createUser()` 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.

<Tabs>
  <Tab title="Java">
    ```java theme={null}
    CometChatUIKit.createUser(User user, CometChat.CallbackListener <User> callbackListener);
    ```
  </Tab>

  <Tab title="Kotlin">
    ```kotlin theme={null}
    CometChatUIKit.createUser(user: User, callbackListener: CometChat.CallbackListener<User>)
    ```
  </Tab>
</Tabs>

The concluding code block:

<Tabs>
  <Tab title="Java">
    ```java theme={null}
    User user = new User("user_uid","user_name");
    user.setAvatar("user_avatar_url");

    CometChatUIKit.createUser(user, new CometChat.CallbackListener<User>() {
        @Override
        public void onSuccess(User user) {
        }
        @Override
        public void onError(CometChatException e) {
        }
    });
    ```
  </Tab>

  <Tab title="Kotlin">
    ```kotlin theme={null}
    val user = User("user_uid", "user_name")
    user.setAvatar("user_avatar_url")

    CometChatUIKit.createUser(user, object : CometChat.CallbackListener<User>() {
        override fun onSuccess(user: User) {
            // Action on success
        }

        override fun onError(e: CometChatException) {
            // Action on 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 `sendMessage()` function. This function requires a `TextMessage` object as its argument, which contains the necessary information for delivering the message.

<Tabs>
  <Tab title="Java">
    ```java theme={null}
    CometChatUIKit.sendTextMessage(TextMessage textMessage, CometChat.CallbackListener <TextMessage> messageCallbackListener)
    ```
  </Tab>

  <Tab title="Kotlin">
    ```kotlin theme={null}
    CometChatUIKit.sendTextMessage(textMessage: TextMessage, messageCallbackListener: CometChat.CallbackListener<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/v4/messages) and [ConversationsComponent](/ui-kit/android/v4/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.

The concluding code block:

<Tabs>
  <Tab title="Java">
    ```java theme={null}
    TextMessage textMessage = new TextMessage("receiver_uid", "your_text_message", CometChatConstants.RECEIVER_TYPE_USER);
    CometChatUIKit.sendTextMessage(textMessage, new CometChat.CallbackListener<TextMessage>() {
        @Override
        public void onSuccess(TextMessage message) {
        }
        @Override
        public void onError(CometChatException e) {
        }
    });
    ```
  </Tab>

  <Tab title="Kotlin">
    ```kotlin theme={null}
    val textMessage = TextMessage("receiver_uid", "your_text_message", CometChatConstants.RECEIVER_TYPE_USER)
    CometChatUIKit.sendTextMessage(textMessage, object : CometChat.CallbackListener<TextMessage>() {
        override fun onSuccess(message: TextMessage) {
            // Action on success
        }

        override fun onError(e: CometChatException) {
            // Action on error
        }
    })
    ```
  </Tab>
</Tabs>

***

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

<Tabs>
  <Tab title="Java">
    ```java theme={null}
    CometChatUIKit.sendMediaMessage(MediaMessage mediaMessage, CometChat.CallbackListener <MediaMessage> messageCallbackListener)
    ```
  </Tab>

  <Tab title="Kotlin">
    ```kotlin theme={null}
    CometChatUIKit.sendMediaMessage(mediaMessage: MediaMessage, messageCallbackListener: CometChat.CallbackListener<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/android/v4/messages) and [ConversationsComponent](/ui-kit/android/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.

The concluding code block:

<Tabs>
  <Tab title="Java">
    ```java theme={null}
    MediaMessage mediaMessage = new MediaMessage("receiver_uid", new File("your_filePath"), CometChatConstants.MESSAGE_TYPE_FILE, CometChatConstants.RECEIVER_TYPE_USER);

    CometChatUIKit.sendMediaMessage(mediaMessage, new CometChat.CallbackListener<MediaMessage>() {
        @Override
        public void onSuccess(MediaMessage mediaMessage) {
        }
        @Override
        public void onError(CometChatException e) {
        }
    });
    ```
  </Tab>

  <Tab title="Kotlin">
    ```kotlin theme={null}
    val mediaMessage = MediaMessage("receiver_uid", File("your_filePath"), CometChatConstants.MESSAGE_TYPE_FILE, CometChatConstants.RECEIVER_TYPE_USER)

    CometChatUIKit.sendMediaMessage(mediaMessage, object : CometChat.CallbackListener<MediaMessage>() {
        override fun onSuccess(mediaMessage: MediaMessage) {
            // Action on success
        }

        override fun onError(e: CometChatException) {
            // Action on error
        }
    })
    ```
  </Tab>
</Tabs>

***

#### Custom 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 `sendCustomMessage()` function. This function requires a `CustomMessage` object as its argument, which contains the necessary information for delivering the message.

<Tabs>
  <Tab title="Java">
    ```java theme={null}
    CometChatUIKit.sendCustomMessage(CustomMessage customMessage, CometChat.CallbackListener <CustomMessage> messageCallbackListener)
    ```
  </Tab>

  <Tab title="Kotlin">
    ```kotlin theme={null}
    CometChatUIKit.sendCustomMessage(customMessage: CustomMessage, messageCallbackListener: CometChat.CallbackListener<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/android/v4/messages) and [ConversationsComponent](/ui-kit/android/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.

The concluding code block:

<Tabs>
  <Tab title="Java">
    ```java theme={null}
    String customType = "your_message_type";
    JSONObject customData = new JSONObject();

    customData.put("key1","value1");
    customData.put("key2","value2");
    customData.put("key3","value3");
    customData.put("key4","value4");

    CustomMessage customMessage = new CustomMessage("receiver_uid", CometChatConstantsRECEIVER_TYPE_USER,customType, customData);

    CometChatUIKit.sendCustomMessage(customMessage, new CometChat.CallbackListener<CustomMessage>() {
        @Override
        public void onSuccess(CustomMessage mediaMessage) {
        }
        @Override
        public void onError(CometChatException e) {
        }
    });
    ```
  </Tab>

  <Tab title="Kotlin">
    ```kotlin theme={null}
    val customType = "your_message_type"
    val customData = JSONObject()

    customData.put("key1", "value1")
    customData.put("key2", "value2")
    customData.put("key3", "value3")
    customData.put("key4", "value4")

    val customMessage = CustomMessage("receiver_uid", CometChatConstants.RECEIVER_TYPE_USER, customType, customData)

    CometChatUIKit.sendCustomMessage(customMessage, object : CometChat.CallbackListener<CustomMessage>() {
        override fun onSuccess(customMessage: CustomMessage) {
            // Action on success
        }

        override fun onError(e: CometChatException) {
            // Action on error
        }
    })
    ```
  </Tab>
</Tabs>

> Note: To display custom messages in the [MessageList](/ui-kit/android/v4/message-list), you must create and register a new [MessageTemplate](/ui-kit/android/v4/message-template#new-templates) that defines how to render your custom message type.

***

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

<Tabs>
  <Tab title="Java">
    ```java theme={null}
    CometChatUIKit.sendFormMessage(FormMessage formmessage, CometChat.CallbackListener <FormMessage> messageCallbackListener)
    ```
  </Tab>

  <Tab title="Kotlin">
    ```kotlin theme={null}
    CometChatUIKit.sendFormMessage(formmessage: FormMessage, messageCallbackListener: CometChat.CallbackListener<FormMessage>)
    ```
  </Tab>
</Tabs>

The concluding code block:

<Tabs>
  <Tab title="Java">
    ```java theme={null}
    CometChatMessages cometChatMessages = findViewById(R.id.messages);
           cometChatMessages.setUser(user);

            List<ElementEntity> elementEntities = new ArrayList<>();
    //here we have created the object to display the TextInput into the form
            TextInputElement textInputElement1 = new TextInputElement("element1", "Name");
            TextInputElement textInputElement2 = new TextInputElement("element2", "Last Name");
            TextInputElement textInputElement3 = new TextInputElement("element3", "Address");
            textInputElement3.setMaxLines(5);
            elementEntities.add(textInputElement1);
            elementEntities.add(textInputElement2);
            elementEntities.add(textInputElement3);


    //here we have created the navigation action which will executated on a click of button
            URLNavigationAction urlNavigationAction = new URLNavigationAction("https://www.cometchat.com/");

            ButtonElement submitElement = new ButtonElement("idSubmit", "submit", urlNavigationAction);
            submitElement.setDisableAfterInteracted(true);
            FormMessage formMessage = new FormMessage("uid-1001", UIKitConstants.ReceiverType.USER, elementEntities, submitElement);
            formMessage.setTitle("Socity Survey");
            formMessage.setAllowSenderInteraction(true); // this will confirm if sender can interact with that form or not
            formMessage.setSender(CometChatUIKit.getLoggedInUser());
            formMessage.setSentAt(System.currentTimeMillis() / 1000);
            formMessage.setReceiver(user); // set Receiver user/group object

            CometChatUIKit.sendFormMessage(formMessage, false, new CometChat.CallbackListener<FormMessage>() {
                @Override
                public void onSuccess(FormMessage formMessage) {

                }

                @Override
                public void onError(CometChatException e) {
                    e.printStackTrace();
                }
            });
    ```
  </Tab>

  <Tab title="Kotlin">
    ```kotlin theme={null}
    val cometChatMessages = findViewById<CometChatMessages>(R.id.messages)
    cometChatMessages.setUser(user)

    val elementEntities = mutableListOf<ElementEntity>()
    val textInputElement1 = TextInputElement("element1", "Name")
    val textInputElement2 = TextInputElement("element2", "Last Name")
    val textInputElement3 = TextInputElement("element3", "Address").apply {
        maxLines = 5
    }
    elementEntities.add(textInputElement1)
    elementEntities.add(textInputElement2)
    elementEntities.add(textInputElement3)

    val urlNavigationAction = URLNavigationAction("https://www.cometchat.com/")

    val submitElement = ButtonElement("idSubmit", "submit", urlNavigationAction).apply {
        disableAfterInteracted = true
    }
    val formMessage = FormMessage("uid-1001", UIKitConstants.ReceiverType.USER, elementEntities, submitElement).apply {
        title = "Socity Survey"
        allowSenderInteraction = true
        sender = CometChatUIKit.loggedInUser
        sentAt = System.currentTimeMillis() / 1000
        receiver = user
    }

    CometChatUIKit.sendFormMessage(formMessage, false, object : CometChat.CallbackListener<FormMessage>() {
        override fun onSuccess(formMessage: FormMessage) {
            // Handle success
        }

        override fun onError(e: CometChatException) {
            e.printStackTrace()
        }
    })
    ```
  </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

<Tabs>
  <Tab title="Java">
    ```java theme={null}
    CometChatUIKit.sendCardMessage(CardMessage cardMessage, CometChat.CallbackListener <CardMessage> messageCallbackListener)
    ```
  </Tab>

  <Tab title="Kotlin">
    ```kotlin theme={null}
    CometChatUIKit.sendCardMessage(cardMessage: CardMessage, messageCallbackListener: CometChat.CallbackListener<CardMessage>)
    ```
  </Tab>
</Tabs>

The concluding code block:

<Tabs>
  <Tab title="Java">
    ```java theme={null}
    List<BaseInteractiveElement> elementEntities = new ArrayList<>();

    URLNavigationAction urlNavigationAction = new URLNavigationAction("https://www.cometchat.com/");

    ButtonElement buttonElement = new ButtonElement("idbtn", "submit", urlNavigationAction);
    buttonElement.setDisableAfterInteracted(true); // button will be disable after interacted
    buttonElement.setText("Learn more");

    elementEntities.add(buttonElement);
    // Create a new instance of CardMessage
    CardMessage cardMessage = new CardMessage(receiverId, receivertype, "Decorative Text to show on Card", elementEntities);

    cardMessage.setImageUrl("https://anyImageUrl.com"); // here you can set the Image url to the Card Message
    cardMessage.setSender(CometChatUIKit.getLoggedInUser());
    cardMessage.setSentAt(System.currentTimeMillis() / 1000);
    cardMessage.setReceiver(user); //here receiver user or group object need to be set
    CometChatUIKit.sendCardMessage(cardMessage, false, new CometChat.CallbackListener<CardMessage>() {
     @Override
       public void onSuccess(CardMessage cardMessage) {

       }

      @Override
        public void onError(CometChatException e) {
               e.printStackTrace();
         }
     });
    ```
  </Tab>

  <Tab title="Kotlin">
    ```kotlin theme={null}
    val elementEntities = mutableListOf<BaseInteractiveElement>()

    val urlNavigationAction = URLNavigationAction("https://www.cometchat.com/")

    val buttonElement = ButtonElement("idbtn", "submit", urlNavigationAction).apply {
        disableAfterInteracted = true
        text = "Learn more"
    }
    elementEntities.add(buttonElement)

    val cardMessage = CardMessage(receiverId, receivertype, "Decorative Text to show on Card", elementEntities).apply {
        imageUrl = "https://anyImageUrl.com"
        sender = CometChatUIKit.loggedInUser
        sentAt = System.currentTimeMillis() / 1000
        receiver = user
    }

    CometChatUIKit.sendCardMessage(cardMessage, false, object : CometChat.CallbackListener<CardMessage>() {
        override fun onSuccess(cardMessage: CardMessage) {
            // Handle success
        }

        override fun onError(e: CometChatException) {
            e.printStackTrace()
        }
    })
    ```
  </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 `sendCardMessage()` function. This function requires a `SchedulerMessage` object as its argument, which contains the necessary information to create a SchedulerMessage bubble for the messages

<Tabs>
  <Tab title="Java">
    ```java theme={null}
    CometChatUIKit.sendSchedulerMessage(SchedulerMessage schedulerMessage, CometChat.CallbackListener <SchedulerMessage> messageCallbackListener)
    ```
  </Tab>

  <Tab title="Kotlin">
    ```kotlin theme={null}
    CometChatUIKit.sendSchedulerMessage(schedulerMessage: SchedulerMessage, messageCallbackListener: CometChat.CallbackListener<SchedulerMessage>)
    ```
  </Tab>
</Tabs>

The concluding code block:

<Tabs>
  <Tab title="Java">
    ```java theme={null}
    SchedulerMessage schedulerMessage = new SchedulerMessage();
            schedulerMessage.setDuration(60);
            schedulerMessage.setAllowSenderInteraction(true); // true to set the sender as the scheduler
            schedulerMessage.setTitle("Meet Dr. Jackob");
            schedulerMessage.setBufferTime(15);
            schedulerMessage.setAvatarUrl("https://encrypted-tbn0.gstatic.com/images?q=tbn:ANd9GcRdRz0HEBl1wvncmX6rU8wFrRDxt2cvn2Dq9w&usqp=CAU");
            schedulerMessage.setGoalCompletionText("Meeting Scheduled Successfully!!");

            TimeZone timeZone = TimeZone.getDefault();
            schedulerMessage.setTimezoneCode(timeZone.getID());
            schedulerMessage.setDateRangeStart("2024-01-01");
            schedulerMessage.setDateRangeEnd("2024-12-31");
            schedulerMessage.setReceiverUid("cometchat-uid-1");

            HashMap<String, List<TimeRange>> availability = new HashMap<>();
            availability.put("monday", Arrays.asList(new TimeRange("0000", "1359")));
            availability.put("tuesday", Arrays.asList(new TimeRange("0000", "1559")));
            availability.put("wednesday", Arrays.asList(new TimeRange("0000", "0659")));
            availability.put("thursday", Arrays.asList(new TimeRange("0000", "0959")));
            availability.put("friday", Arrays.asList(new TimeRange("0000", "1059")));
            schedulerMessage.setAvailability(availability);
            APIAction clickAction = new APIAction("https://www.example.com", "POST", "data");

            ButtonElement scheduleElement = new ButtonElement("21", "Submit", clickAction);
            schedulerMessage.setScheduleElement(scheduleElement);

    				schedulerMessage.setReceiverType(CometChatConstants.RECEIVER_TYPE_USER);
            schedulerMessage.setSender(CometChatUIKit.getLoggedInUser());
            schedulerMessage.setSentAt(System.currentTimeMillis() / 1000);
            schedulerMessage.setReceiver(user);

    				CometChatUIKit.sendSchedulerMessage(schedulerMessage,false, new 	CometChat.CallbackListener<SchedulerMessage>() {
                @Override
                public void onSuccess(SchedulerMessage schedulerMessage) {
                    // SchedulerMessage sent successfully
                }

                @Override
                public void onError(CometChatException e) {
                    // Error occurred while sending SchedulerMessage
                }
            });
    ```
  </Tab>

  <Tab title="Kotlin">
    ```kotlin theme={null}
    val schedulerMessage = SchedulerMessage().apply {
        duration = 60
        allowSenderInteraction = true
        title = "Meet Dr. Jackob"
        bufferTime = 15
        avatarUrl = "https://encrypted-tbn0.gstatic.com/images?q=tbn:ANd9GcRdRz0HEBl1wvncmX6rU8wFrRDxt2cvn2Dq9w&usqp=CAU"
        goalCompletionText = "Meeting Scheduled Successfully!!"
        timezoneCode = TimeZone.getDefault().id
        dateRangeStart = "2024-01-01"
        dateRangeEnd = "2024-12-31"
        receiverUid = "cometchat-uid-1"
        availability = hashMapOf(
            "monday" to listOf(TimeRange("0000", "1359")),
            "tuesday" to listOf(TimeRange("0000", "1559")),
            "wednesday" to listOf(TimeRange("0000", "0659")),
            "thursday" to listOf(TimeRange("0000", "0959")),
            "friday" to listOf(TimeRange("0000", "1059"))
        )
        scheduleElement = ButtonElement("21", "Submit",
            APIAction("https://www.example.com", "POST", "data")
        )
        receiverType = CometChatConstants.RECEIVER_TYPE_USER
        sender = CometChatUIKit.loggedInUser
        sentAt = System.currentTimeMillis() / 1000
        receiver = user
    }

    CometChatUIKit.sendSchedulerMessage(schedulerMessage, false, object : CometChat.CallbackListener<SchedulerMessage>() {
        override fun onSuccess(schedulerMessage: SchedulerMessage) {
            // SchedulerMessage sent successfully
        }

        override fun onError(e: CometChatException) {
            // Error occurred while sending SchedulerMessage
        }
    })
    ```
  </Tab>
</Tabs>

***

#### Custom InteractiveMessage

As a developer, if you need to send a Custom Interactive message to a single user or a group, you'll need to utilize the `sendCustomInteractiveMessage()` function. This function requires a `CustomInteractiveMessage` object as its argument.

<Tabs>
  <Tab title="Java">
    ```java theme={null}
    CometChatUIKit.sendCustomInteractiveMessage(CustomInteractiveMessage customInteractiveMessage, CometChat.CallbackListener <CustomInteractiveMessage> messageCallbackListener)
    ```
  </Tab>

  <Tab title="Kotlin">
    ```kotlin theme={null}
    CometChatUIKit.sendCustomInteractiveMessage(customInteractiveMessage: CustomInteractiveMessage, messageCallbackListener: CometChat.CallbackListener<CustomInteractiveMessage>)
    ```
  </Tab>
</Tabs>

The concluding code block:

<Tabs>
  <Tab title="Java">
    ```java theme={null}
    JSONObject jsonObject = new JSONObject();
     try {
       jsonObject.put("text", "custom Interactive message");
     } catch (JSONException e) {
       throw new RuntimeException(e);
     }

    CustomInteractiveMessage customInteractiveMessage = new CustomInteractiveMessage(receiverId,receiverType, jsonObject); //receiverType could be user/group
    customInteractiveMessage.setSender(CometChatUIKit.getLoggedInUser());
    customInteractiveMessage.setReceiver(user); // set Receiver user/group object

    CometChatUIKit.sendCustomInteractiveMessage(customInteractiveMessage, false, new CometChat.CallbackListener<CustomInteractiveMessage>() {
              @Override
              public void onSuccess(CustomInteractiveMessage customInteractiveMessage) {

               }
              @Override
              public void onError(CometChatException e) {
                    e.printStackTrace();
              }
        });
    ```
  </Tab>

  <Tab title="Kotlin">
    ```kotlin theme={null}
    val jsonObject = JSONObject()
    try {
        jsonObject.put("text", "custom Interactive message")
    } catch (e: JSONException) {
        throw RuntimeException(e)
    }

    val customInteractiveMessage = CustomInteractiveMessage(receiverId, receiverType, jsonObject) // receiverType could be user/group
    customInteractiveMessage.sender = CometChatUIKit.getLoggedInUser()
    customInteractiveMessage.receiver = user // set Receiver user/group object

    CometChatUIKit.sendCustomInteractiveMessage(customInteractiveMessage, false, object : CometChat.CallbackListener<CustomInteractiveMessage>() {
        override fun onSuccess(customInteractiveMessage: CustomInteractiveMessage) {

        }

        override fun onError(e: CometChatException) {
            e.printStackTrace()
        }
    })
    ```
  </Tab>
</Tabs>

> Note: To display custom messages in the [MessageList](/ui-kit/android/v4/message-list), you must create and register a new [MessageTemplate](/ui-kit/android/v4/message-template#new-templates) that defines how to render your custom message type.s

***