Upgrading from V5 to V6

dependencies {
    implementation 'com.cometchat:chatuikit-kotlin-android:5.x.x'
}

dependencies {
    implementation 'com.cometchat:chatuikit-kotlin-android:6.x.x'
    // chatuikit-core is pulled in transitively
}

dependencies {
    implementation 'com.cometchat:chatuikit-compose-android:6.x.x'
    // chatuikit-core is pulled in transitively
}

import com.cometchat.chatuikit.shared.cometchatuikit.CometChatUIKit;
import com.cometchat.chatuikit.shared.cometchatuikit.UIKitSettings;

import com.cometchat.uikit.core.CometChatUIKit
import com.cometchat.uikit.core.UIKitSettings

import com.cometchat.chatuikit.conversations.CometChatConversations;
import com.cometchat.chatuikit.users.CometChatUsers;
import com.cometchat.chatuikit.groups.CometChatGroups;
import com.cometchat.chatuikit.messageheader.CometChatMessageHeader;
import com.cometchat.chatuikit.messagelist.CometChatMessageList;
import com.cometchat.chatuikit.messagecomposer.CometChatMessageComposer;

import com.cometchat.uikit.kotlin.presentation.conversations.ui.CometChatConversations
import com.cometchat.uikit.kotlin.presentation.users.ui.CometChatUsers
import com.cometchat.uikit.kotlin.presentation.groups.ui.CometChatGroups
import com.cometchat.uikit.kotlin.presentation.messageheader.ui.CometChatMessageHeader
import com.cometchat.uikit.kotlin.presentation.messagelist.ui.CometChatMessageList
import com.cometchat.uikit.kotlin.presentation.messagecomposer.ui.CometChatMessageComposer

import com.cometchat.uikit.compose.presentation.conversations.ui.CometChatConversations
import com.cometchat.uikit.compose.presentation.users.ui.CometChatUsers
import com.cometchat.uikit.compose.presentation.groups.ui.CometChatGroups
import com.cometchat.uikit.compose.presentation.messageheader.ui.CometChatMessageHeader
import com.cometchat.uikit.compose.presentation.messagelist.ui.CometChatMessageList
import com.cometchat.uikit.compose.presentation.messagecomposer.ui.CometChatMessageComposer

CometChatMessageEvents.addListener("unique-id", new CometChatMessageEvents() {
    @Override
    public void onMessageSent(BaseMessage message) {
        // Handle message sent
    }
});
// Cleanup
CometChatMessageEvents.removeListener("unique-id");

lifecycleScope.launch {
    CometChatEvents.messageEvents.collect { event ->
        when (event) {
            is MessageEvent.Sent -> { /* Handle message sent */ }
            is MessageEvent.Edited -> { /* Handle message edited */ }
            is MessageEvent.Deleted -> { /* Handle message deleted */ }
        }
    }
}
// No manual cleanup needed — lifecycleScope auto-cancels

conversationsViewModel.getConversationList().observe(this, new Observer<List<Conversation>>() {
    @Override
    public void onChanged(List<Conversation> conversations) {
        // Update UI with conversations
    }
});

lifecycleScope.launch {
    conversationsViewModel.uiState.collect { state ->
        when (state) {
            is UIState.Loading -> { /* Show loading */ }
            is UIState.Success -> { /* Update UI with state.data */ }
            is UIState.Error -> { /* Show error */ }
        }
    }
}

ConversationsStyle style = new ConversationsStyle();
style.setBackground(Color.WHITE);
style.setTitleColor(Color.BLACK);
style.setBorderWidth(1);
style.setBorderColor(Color.GRAY);
cometChatConversations.setStyle(style);

<resources>
    <style name="AppTheme" parent="CometChatTheme.DayNight">
        <item name="cometchatPrimaryColor">#F76808</item>
        <item name="cometchatBackgroundColor">#FFFFFF</item>
        <item name="cometchatTextPrimaryColor">#141414</item>
        <item name="android:fontFamily">@font/your_custom_font</item>
    </style>

    <!-- Override a specific component style -->
    <style name="CustomConversationsStyle" parent="CometChatConversations">
        <item name="cometchatSeparatorColor">#E0E0E0</item>
        <item name="cometchatItemBackgroundColor">#FAFAFA</item>
    </style>
</resources>

CometChatConversations(
    style = CometChatConversationsStyle.default().copy(
        backgroundColor = Color.White,
        titleColor = Color.Black,
        separatorColor = Color.LightGray
    )
)

CometChatConversations conversations = findViewById(R.id.conversations);
conversations.setOnItemClick(new OnItemClick<Conversation>() {
    @Override
    public void onItemClick(Conversation conversation, int position) {
        // Handle click
    }
});

val conversations = findViewById<CometChatConversations>(R.id.conversations)
conversations.setOnItemClick { conversation ->
    // Handle click
}

CometChatUsers users = findViewById(R.id.users);
users.setOnItemClick(new OnItemClick<User>() {
    @Override
    public void onItemClick(User user, int position) {
        // Handle click
    }
});

val users = findViewById<CometChatUsers>(R.id.users)
users.setOnItemClick { user ->
    // Handle click
}

CometChatGroups groups = findViewById(R.id.groups);
groups.setOnItemClick(new OnItemClick<Group>() {
    @Override
    public void onItemClick(Group group, int position) {
        // Handle click
    }
});

val groups = findViewById<CometChatGroups>(R.id.groups)
groups.setOnItemClick { group ->
    // Handle click
}

CometChatMessageHeader header = findViewById(R.id.messageHeader);
header.setOnBackButtonPressed(new OnBackPress() {
    @Override
    public void onBack() {
        // Handle back
    }
});

val header = findViewById<CometChatMessageHeader>(R.id.messageHeader)
header.setOnBackPress {
    // Handle back
}

CometChatMessageList messageList = findViewById(R.id.messageList);
messageList.setOnThreadRepliesClick(new OnThreadRepliesClick() {
    @Override
    public void onThreadRepliesClick(Context context, BaseMessage message, CometChatMessageTemplate template) {
        // Handle thread click
    }
});

val messageList = findViewById<CometChatMessageList>(R.id.messageList)
messageList.setOnThreadRepliesClick { context, message, template ->
    // Handle thread click
}

CometChatMessageComposer composer = findViewById(R.id.messageComposer);
composer.setOnSendButtonClick(new OnSendButtonClick() {
    @Override
    public void onSendButtonClick(Context context, BaseMessage message) {
        // Handle send
    }
});

val composer = findViewById<CometChatMessageComposer>(R.id.messageComposer)
composer.setOnSendButtonClick { context, message ->
    // Handle send
}

import com.cometchat.chatuikit.calls.incoming.CometChatIncomingCall;
import com.cometchat.chatuikit.calls.outgoing.CometChatOutgoingCall;
import com.cometchat.chatuikit.calls.callbuttons.CometChatCallButtons;
import com.cometchat.chatuikit.calls.calllogs.CometChatCallLogs;

import com.cometchat.uikit.kotlin.presentation.incomingcall.CometChatIncomingCall
import com.cometchat.uikit.kotlin.presentation.outgoingcall.CometChatOutgoingCall
import com.cometchat.uikit.kotlin.presentation.callbuttons.CometChatCallButtons
import com.cometchat.uikit.kotlin.presentation.calllogs.ui.CometChatCallLogs

// V5 — Java ViewModel with LiveData
ConversationsViewModel viewModel = cometChatConversations.getViewModel();
viewModel.getConversationList().observe(this, conversations -> {
    // React to data
});

// V6 — Kotlin ViewModel with StateFlow
val viewModel = conversations.getViewModel()
lifecycleScope.launch {
    viewModel.uiState.collect { state ->
        // React to data
    }
}

// You can also inject a custom ViewModel
conversations.setViewModel(myCustomViewModel)

val viewModel = conversations.getViewModel()

// Single operations
viewModel.addItem(conversation)
viewModel.removeItem(conversation)
viewModel.updateItem(conversation)
viewModel.moveItemToTop(conversation)

// Batch operations
viewModel.batch {
    addItem(conversation1)
    updateItem(conversation2)
    removeItem(conversation3)
}

// Implement the repository interface
class MyConversationRepository : ConversationsRepository {
    override suspend fun fetchConversations(): List<Conversation> {
        // Your custom data source
    }
}

// Inject via ViewModelFactory
val factory = CometChatConversationsViewModelFactory(
    repository = MyConversationRepository()
)
conversations.setViewModelFactory(factory)