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

# Core Features

> Essential chat features built into CometChat UI Kit for iOS

<Accordion title="AI Integration Quick Reference">
  ```json theme={null}
  {
    "category": "messaging",
    "features": [
      {"name": "instantMessaging", "description": "Send and receive text messages in real-time", "component": "CometChatMessages", "enabledByDefault": true},
      {"name": "mediaSharing", "description": "Share images, videos, audio files, and documents", "component": "CometChatMessageComposer", "enabledByDefault": true},
      {"name": "readReceipts", "description": "Show when messages are delivered and read", "component": "CometChatMessageList", "enabledByDefault": true},
      {"name": "typingIndicators", "description": "Show when users are typing in real-time", "component": "CometChatMessageHeader", "enabledByDefault": true},
      {"name": "userPresence", "description": "Display online/offline status for users", "component": "CometChatConversations", "enabledByDefault": true},
      {"name": "reactions", "description": "Let users react to messages with emojis", "component": "CometChatMessageList", "enabledByDefault": true},
      {"name": "mentions", "description": "Tag users in messages with @mentions", "component": "CometChatMessageComposer", "enabledByDefault": true},
      {"name": "threadedConversations", "description": "Reply to specific messages in threads", "component": "CometChatThreadedMessageHeader", "enabledByDefault": true},
      {"name": "groupChat", "description": "Create and manage group conversations", "component": "CometChatGroups", "enabledByDefault": true},
      {"name": "search", "description": "Search across conversations and messages", "component": "CometChatSearch", "enabledByDefault": true}
    ],
    "relatedComponents": ["CometChatMessages", "CometChatConversations", "CometChatMessageList", "CometChatMessageComposer"]
  }
  ```
</Accordion>

CometChat UI Kit provides production-ready components that work together to deliver a complete chat experience. This guide shows how to implement each core feature with copy-paste code examples.

## Instant Messaging

Send and receive text messages in real-time.

<Frame>
  <img src="https://mintcdn.com/cometchat-22654f5b-docs-restapi-chatapi-eng-30216/zykkQc0RC-C1q9Oh/images/2075add0-media-sharing-4083495a646205ae456fed02a61ab6f9.png?fit=max&auto=format&n=zykkQc0RC-C1q9Oh&q=85&s=1df9d74cc003ad61cfbef2fe97c91ce6" width="1440" height="833" data-path="images/2075add0-media-sharing-4083495a646205ae456fed02a61ab6f9.png" />
</Frame>

```swift lines theme={null}
import UIKit
import CometChatUIKitSwift
import CometChatSDK

class ChatViewController: UIViewController {
    
    override func viewDidLoad() {
        super.viewDidLoad()
        
        // For one-on-one chat
        let messagesVC = CometChatMessages()
        
        // Set the user to chat with
        CometChat.getUser(UID: "cometchat-uid-1") { user in
            DispatchQueue.main.async {
                messagesVC.set(user: user)
                self.navigationController?.pushViewController(messagesVC, animated: true)
            }
        } onError: { error in
            print("Error: \(error?.errorDescription ?? "")")
        }
    }
}
```

**Components Used:**

* [MessageComposer](/ui-kit/ios/message-composer) - Text input and send button
* [MessageList](/ui-kit/ios/message-list) - Displays sent and received messages
* [Messages](/ui-kit/ios/message-header) - Complete messaging screen (includes both)

## Media Sharing

Share images, videos, audio files, and documents.

```swift lines theme={null}
import UIKit
import CometChatUIKitSwift
import CometChatSDK

class MediaChatViewController: UIViewController {
    
    override func viewDidLoad() {
        super.viewDidLoad()
        
        let messagesVC = CometChatMessages()
        
        // The message composer automatically includes media sharing options
        // Users can tap the attachment button to share:
        // - Photos from library
        // - Camera capture
        // - Documents
        // - Audio files
        
        CometChat.getUser(UID: "cometchat-uid-1") { user in
            DispatchQueue.main.async {
                messagesVC.set(user: user)
                self.navigationController?.pushViewController(messagesVC, animated: true)
            }
        } onError: { error in
            print("Error: \(error?.errorDescription ?? "")")
        }
    }
    
    // Send media programmatically
    func sendImage(to receiverUID: String, imageURL: URL) {
        let mediaMessage = MediaMessage(
            receiverUid: receiverUID,
            fileurl: imageURL.absoluteString,
            messageType: .image,
            receiverType: .user
        )
        
        CometChat.sendMediaMessage(message: mediaMessage) { message in
            print("Image sent successfully")
        } onError: { error in
            print("Error sending image: \(error?.errorDescription ?? "")")
        }
    }
}
```

**Supported Media Types:**

| Type   | Bubble Component                                                |
| ------ | --------------------------------------------------------------- |
| Images | [Image Bubble](/ui-kit/ios/message-bubble-styling#image-bubble) |
| Videos | [Video Bubble](/ui-kit/ios/message-bubble-styling#video-bubble) |
| Audio  | [Audio Bubble](/ui-kit/ios/message-bubble-styling#audio-bubble) |
| Files  | [File Bubble](/ui-kit/ios/message-bubble-styling#file-bubble)   |

## Read Receipts

Show when messages are delivered and read.

<Frame>
  <img src="https://mintcdn.com/cometchat-22654f5b-docs-restapi-chatapi-eng-30216/8YcETMm0YFSRjCU7/images/74738f1e-read-receipts-b8b11e8ca3d07f79f02b187b666aaf74.png?fit=max&auto=format&n=8YcETMm0YFSRjCU7&q=85&s=c69f8202b19c583d920a5aa9c7473c70" width="1440" height="833" data-path="images/74738f1e-read-receipts-b8b11e8ca3d07f79f02b187b666aaf74.png" />
</Frame>

```swift lines theme={null}
import UIKit
import CometChatUIKitSwift
import CometChatSDK

class ReceiptsViewController: UIViewController {
    
    override func viewDidLoad() {
        super.viewDidLoad()
        
        // Read receipts are enabled by default
        let messagesVC = CometChatMessages()
        
        // To hide receipts:
        // messagesVC.hideReceipts = true
        
        CometChat.getUser(UID: "cometchat-uid-1") { user in
            DispatchQueue.main.async {
                messagesVC.set(user: user)
                self.navigationController?.pushViewController(messagesVC, animated: true)
            }
        } onError: { error in
            print("Error: \(error?.errorDescription ?? "")")
        }
    }
    
    // View detailed message information
    func showMessageInfo(for message: BaseMessage) {
        let messageInfo = CometChatMessageInformation()
        messageInfo.set(message: message)
        navigationController?.pushViewController(messageInfo, animated: true)
    }
}
```

**Receipt States:**

* ✓ Sent - Message sent to server
* ✓✓ Delivered - Message delivered to recipient's device
* ✓✓ (blue) Read - Recipient has seen the message

**Components Used:**

* [Conversations](/ui-kit/ios/conversations) - Shows receipt status on last message
* [MessageList](/ui-kit/ios/message-list) - Shows receipts on each message
* [MessageInformation](/ui-kit/ios/message-information) - Detailed delivery/read info

## Mark As Unread

Let users mark messages as unread to revisit later.

<Frame>
  <img src="https://mintcdn.com/cometchat-22654f5b-docs-restapi-chatapi-eng-30216/MyP3UEuDaISnHcFT/images/mark-as-unread.png?fit=max&auto=format&n=MyP3UEuDaISnHcFT&q=85&s=64d1aa882695760ec0124e18efd2167d" width="2560" height="1670" data-path="images/mark-as-unread.png" />
</Frame>

```swift lines theme={null}
import UIKit
import CometChatUIKitSwift
import CometChatSDK

class UnreadMessagesViewController: UIViewController {
    
    override func viewDidLoad() {
        super.viewDidLoad()
        
        let messagesVC = CometChatMessages()
        
        // Enable starting from first unread message
        messagesVC.scrollToUnreadMessages = true
        
        CometChat.getUser(UID: "cometchat-uid-1") { user in
            DispatchQueue.main.async {
                messagesVC.set(user: user)
                self.navigationController?.pushViewController(messagesVC, animated: true)
            }
        } onError: { error in
            print("Error: \(error?.errorDescription ?? "")")
        }
    }
    
    // Mark a message as unread programmatically
    func markAsUnread(message: BaseMessage) {
        CometChat.markAsUnread(
            baseMessage: message
        ) { _ in
            print("Marked as unread")
        } onError: { error in
            print("Error: \(error?.errorDescription ?? "")")
        }
    }
}
```

## Typing Indicators

Show when users are typing in real-time.

<Frame>
  <img src="https://mintcdn.com/cometchat-22654f5b-docs-restapi-chatapi-eng-30216/MIHbrJ9Fdic3aw7O/images/f7e17af9-typing-indicator-04c3387955553dd72919541d2a0c2096.png?fit=max&auto=format&n=MIHbrJ9Fdic3aw7O&q=85&s=42be8a1a77654fa130ed26a6b4088c4d" width="1440" height="833" data-path="images/f7e17af9-typing-indicator-04c3387955553dd72919541d2a0c2096.png" />
</Frame>

```swift lines theme={null}
import UIKit
import CometChatUIKitSwift
import CometChatSDK

class TypingIndicatorViewController: UIViewController {
    
    override func viewDidLoad() {
        super.viewDidLoad()
        
        // Typing indicators are enabled by default in:
        // - CometChatConversations (shows "typing..." in conversation list)
        // - CometChatMessageHeader (shows "typing..." below user name)
        
        let messagesVC = CometChatMessages()
        
        CometChat.getUser(UID: "cometchat-uid-1") { user in
            DispatchQueue.main.async {
                messagesVC.set(user: user)
                self.navigationController?.pushViewController(messagesVC, animated: true)
            }
        } onError: { error in
            print("Error: \(error?.errorDescription ?? "")")
        }
    }
    
    // Send typing indicator manually
    func startTyping(to receiverUID: String) {
        let typingIndicator = TypingIndicator(
            receiverID: receiverUID,
            receiverType: .user
        )
        CometChat.startTyping(indicator: typingIndicator)
    }
    
    func stopTyping(to receiverUID: String) {
        let typingIndicator = TypingIndicator(
            receiverID: receiverUID,
            receiverType: .user
        )
        CometChat.endTyping(indicator: typingIndicator)
    }
}
```

**Components Used:**

* [Conversations](/ui-kit/ios/conversations) - Shows typing in conversation list
* [MessageHeader](/ui-kit/ios/message-header) - Shows typing below user/group name

## User Presence

Display online/offline status for users.

<Frame>
  <img src="https://mintcdn.com/cometchat-22654f5b-docs-restapi-chatapi-eng-30216/9q-vtydqEIaKl827/images/dfcfaa05-user-presence-5566ce6e2cdadc731fcf220bbd59509b.png?fit=max&auto=format&n=9q-vtydqEIaKl827&q=85&s=bcc3351b5575da933e942078d96e67ec" width="1440" height="833" data-path="images/dfcfaa05-user-presence-5566ce6e2cdadc731fcf220bbd59509b.png" />
</Frame>

```swift lines theme={null}
import UIKit
import CometChatUIKitSwift
import CometChatSDK

class PresenceViewController: UIViewController {
    
    override func viewDidLoad() {
        super.viewDidLoad()
        
        // User presence is shown automatically in:
        // - CometChatConversations (green dot for online users)
        // - CometChatMessageHeader (shows "Online" or "Last seen")
        // - CometChatUsers (green dot for online users)
        // - CometChatGroupMembers (green dot for online members)
        
        let conversations = CometChatConversations()
        
        // To hide user status:
        // conversations.hideUserStatus = true
        
        navigationController?.pushViewController(conversations, animated: true)
    }
    
    // Listen for presence changes
    func listenForPresenceChanges() {
        CometChat.addUserListener("presence-listener", self)
    }
}

extension PresenceViewController: CometChatUserDelegate {
    func onUserOnline(user: User) {
        print("\(user.name ?? "") is now online")
    }
    
    func onUserOffline(user: User) {
        print("\(user.name ?? "") went offline")
    }
}
```

## Reactions

Let users react to messages with emojis.

<Frame>
  <img src="https://mintcdn.com/cometchat-22654f5b-docs-restapi-chatapi-eng-30216/8YcETMm0YFSRjCU7/images/79d625bd-reactions-f76123e0e1f84a396be74b88caa2c926.png?fit=max&auto=format&n=8YcETMm0YFSRjCU7&q=85&s=ac7fb6e4f882db8fe01d1097903fe9f2" width="1440" height="833" data-path="images/79d625bd-reactions-f76123e0e1f84a396be74b88caa2c926.png" />
</Frame>

```swift lines theme={null}
import UIKit
import CometChatUIKitSwift
import CometChatSDK

class ReactionsViewController: UIViewController {
    
    override func viewDidLoad() {
        super.viewDidLoad()
        
        // Reactions are enabled by default
        // Users can long-press a message to add reactions
        
        let messagesVC = CometChatMessages()
        
        CometChat.getUser(UID: "cometchat-uid-1") { user in
            DispatchQueue.main.async {
                messagesVC.set(user: user)
                self.navigationController?.pushViewController(messagesVC, animated: true)
            }
        } onError: { error in
            print("Error: \(error?.errorDescription ?? "")")
        }
    }
    
    // Add reaction programmatically
    func addReaction(to message: BaseMessage, emoji: String) {
        CometChat.addReaction(
            messageId: message.id,
            reaction: emoji
        ) { message in
            print("Reaction added")
        } onError: { error in
            print("Error: \(error?.errorDescription ?? "")")
        }
    }
    
    // Remove reaction
    func removeReaction(from message: BaseMessage, emoji: String) {
        CometChat.removeReaction(
            messageId: message.id,
            reaction: emoji
        ) { message in
            print("Reaction removed")
        } onError: { error in
            print("Error: \(error?.errorDescription ?? "")")
        }
    }
}
```

## Mentions

Tag users in messages with @mentions.

<Frame>
  <img src="https://mintcdn.com/cometchat-22654f5b-docs-restapi-chatapi-eng-30216/Z-6uXB0jvTjK4WvV/images/d91c31fc-mentions-27827fc4e5059d5917addbe0f2eab85f.png?fit=max&auto=format&n=Z-6uXB0jvTjK4WvV&q=85&s=22194529b51c66858802dd9210261143" width="1440" height="564" data-path="images/d91c31fc-mentions-27827fc4e5059d5917addbe0f2eab85f.png" />
</Frame>

```swift lines theme={null}
import UIKit
import CometChatUIKitSwift
import CometChatSDK

class MentionsViewController: UIViewController {
    
    override func viewDidLoad() {
        super.viewDidLoad()
        
        // Mentions are enabled by default
        // Type @ in the composer to see mention suggestions
        
        let messagesVC = CometChatMessages()
        
        CometChat.getGroup(GUID: "group-123") { group in
            DispatchQueue.main.async {
                messagesVC.set(group: group)
                self.navigationController?.pushViewController(messagesVC, animated: true)
            }
        } onError: { error in
            print("Error: \(error?.errorDescription ?? "")")
        }
    }
    
    // Send message with mention programmatically
    func sendMessageWithMention(to groupID: String, mentionedUser: User) {
        let textMessage = TextMessage(
            receiverUid: groupID,
            text: "Hey @\(mentionedUser.name ?? ""), check this out!",
            receiverType: .group
        )
        
        // Add mentioned users
        textMessage.mentionedUsers = [mentionedUser]
        
        CometChat.sendTextMessage(message: textMessage) { message in
            print("Message with mention sent")
        } onError: { error in
            print("Error: \(error?.errorDescription ?? "")")
        }
    }
}
```

## Threaded Conversations

Reply to specific messages in threads.

<Frame>
  <img src="https://mintcdn.com/cometchat-22654f5b-docs-restapi-chatapi-eng-30216/AAh1YGKzHGpE3g6R/images/0a425996-threaded-conversation-bb63b71df514c0eec680ffda196473de.png?fit=max&auto=format&n=AAh1YGKzHGpE3g6R&q=85&s=39165c7b8b924a52aa35624c902edee9" width="1440" height="1128" data-path="images/0a425996-threaded-conversation-bb63b71df514c0eec680ffda196473de.png" />
</Frame>

```swift lines theme={null}
import UIKit
import CometChatUIKitSwift
import CometChatSDK

class ThreadedMessagesViewController: UIViewController {
    
    override func viewDidLoad() {
        super.viewDidLoad()
        
        // Threaded messages are enabled by default
        // Users can tap "Reply in thread" on any message
        
        let messagesVC = CometChatMessages()
        
        CometChat.getUser(UID: "cometchat-uid-1") { user in
            DispatchQueue.main.async {
                messagesVC.set(user: user)
                self.navigationController?.pushViewController(messagesVC, animated: true)
            }
        } onError: { error in
            print("Error: \(error?.errorDescription ?? "")")
        }
    }
    
    // Open thread view for a message
    // Note: Thread replies are handled automatically by CometChatMessageList
    // when user taps "Reply in thread". The thread view uses CometChatThreadedMessageHeader
    // combined with CometChatMessageList and CometChatMessageComposer.
    func openThread(for parentMessage: BaseMessage, user: User) {
        // Create a view controller to host the threaded messages
        let threadVC = UIViewController()
        threadVC.view.backgroundColor = .systemBackground
        
        // Create threaded message header
        let threadedHeader = CometChatThreadedMessageHeader()
        threadedHeader.set(parentMessage: parentMessage)
        threadedHeader.set(controller: threadVC)
        threadedHeader.translatesAutoresizingMaskIntoConstraints = false
        
        // Create message list for thread replies
        let messageList = CometChatMessageList()
        messageList.set(user: user)
        messageList.set(parentMessage: parentMessage)
        messageList.set(controller: threadVC)
        messageList.translatesAutoresizingMaskIntoConstraints = false
        
        // Create composer for thread replies
        let composer = CometChatMessageComposer()
        composer.set(user: user)
        composer.set(parentMessage: parentMessage)
        composer.set(controller: threadVC)
        composer.translatesAutoresizingMaskIntoConstraints = false
        
        // Add to view
        threadVC.view.addSubview(threadedHeader)
        threadVC.view.addSubview(messageList)
        threadVC.view.addSubview(composer)
        
        // Layout constraints
        NSLayoutConstraint.activate([
            threadedHeader.topAnchor.constraint(equalTo: threadVC.view.safeAreaLayoutGuide.topAnchor),
            threadedHeader.leadingAnchor.constraint(equalTo: threadVC.view.leadingAnchor),
            threadedHeader.trailingAnchor.constraint(equalTo: threadVC.view.trailingAnchor),
            
            messageList.topAnchor.constraint(equalTo: threadedHeader.bottomAnchor),
            messageList.leadingAnchor.constraint(equalTo: threadVC.view.leadingAnchor),
            messageList.trailingAnchor.constraint(equalTo: threadVC.view.trailingAnchor),
            messageList.bottomAnchor.constraint(equalTo: composer.topAnchor),
            
            composer.leadingAnchor.constraint(equalTo: threadVC.view.leadingAnchor),
            composer.trailingAnchor.constraint(equalTo: threadVC.view.trailingAnchor),
            composer.bottomAnchor.constraint(equalTo: threadVC.view.safeAreaLayoutGuide.bottomAnchor)
        ])
        
        navigationController?.pushViewController(threadVC, animated: true)
    }
    
    // Send reply in thread programmatically
    func sendThreadReply(parentMessage: BaseMessage, text: String) {
        let reply = TextMessage(
            receiverUid: parentMessage.receiverUid,
            text: text,
            receiverType: parentMessage.receiverType
        )
        reply.parentMessageId = parentMessage.id
        
        CometChat.sendTextMessage(message: reply) { message in
            print("Thread reply sent")
        } onError: { error in
            print("Error: \(error?.errorDescription ?? "")")
        }
    }
}
```

**Component Used:**

* [ThreadedMessages](/ui-kit/ios/threaded-messages-header) - Displays thread replies

## Group Chat

Create and manage group conversations.

<Frame>
  <img src="https://mintcdn.com/cometchat-22654f5b-docs-restapi-chatapi-eng-30216/B69IDh3Zv2wn_9pg/images/88d8faa3-group-chat-5ad9841c77fac541fe60b1f1d9c6b536.png?fit=max&auto=format&n=B69IDh3Zv2wn_9pg&q=85&s=df3f96e5ea23eacf4a69f95937dc8361" width="1440" height="833" data-path="images/88d8faa3-group-chat-5ad9841c77fac541fe60b1f1d9c6b536.png" />
</Frame>

```swift lines theme={null}
import UIKit
import CometChatUIKitSwift
import CometChatSDK

class GroupChatViewController: UIViewController {
    
    override func viewDidLoad() {
        super.viewDidLoad()
        showGroupsList()
    }
    
    // Show all groups
    func showGroupsList() {
        let groups = CometChatGroups()
        
        groups.set(onItemClick: { [weak self] group, _ in
            self?.openGroupChat(group: group)
        })
        
        navigationController?.pushViewController(groups, animated: true)
    }
    
    // Open chat for a group
    func openGroupChat(group: Group) {
        let messagesVC = CometChatMessages()
        messagesVC.set(group: group)
        navigationController?.pushViewController(messagesVC, animated: true)
    }
    
    // Create a new group
    func createGroup(name: String, type: CometChat.groupType) {
        let group = Group(
            guid: UUID().uuidString,
            name: name,
            groupType: type,
            password: nil
        )
        
        CometChat.createGroup(group: group) { createdGroup in
            print("Group created: \(createdGroup.name ?? "")")
            DispatchQueue.main.async {
                self.openGroupChat(group: createdGroup)
            }
        } onError: { error in
            print("Error: \(error?.errorDescription ?? "")")
        }
    }
    
    // Join a public group
    func joinGroup(guid: String) {
        CometChat.joinGroup(
            GUID: guid,
            groupType: .public,
            password: nil
        ) { group in
            print("Joined group: \(group.name ?? "")")
            DispatchQueue.main.async {
                self.openGroupChat(group: group)
            }
        } onError: { error in
            print("Error: \(error?.errorDescription ?? "")")
        }
    }
}
```

**Related Guide:** [Groups](/ui-kit/ios/groups)

## Quoted Reply

Reply to specific messages with context.

<Frame>
  <img src="https://mintcdn.com/cometchat-22654f5b-docs-restapi-chatapi-eng-30216/hOiWuy3H5LCSiFAX/images/android-quoted-reply.png?fit=max&auto=format&n=hOiWuy3H5LCSiFAX&q=85&s=029596a1f24006a348f735c000538feb" width="2560" height="1670" data-path="images/android-quoted-reply.png" />
</Frame>

```swift lines theme={null}
import UIKit
import CometChatUIKitSwift
import CometChatSDK

class QuotedReplyViewController: UIViewController {
    
    override func viewDidLoad() {
        super.viewDidLoad()
        
        // Quoted reply is enabled by default
        // Users can swipe right on a message or tap "Reply" in message actions
        
        let messagesVC = CometChatMessages()
        
        CometChat.getUser(UID: "cometchat-uid-1") { user in
            DispatchQueue.main.async {
                messagesVC.set(user: user)
                self.navigationController?.pushViewController(messagesVC, animated: true)
            }
        } onError: { error in
            print("Error: \(error?.errorDescription ?? "")")
        }
    }
}
```

## Search

Search across conversations and messages.

<Frame>
  <img src="https://mintcdn.com/cometchat-22654f5b-docs-restapi-chatapi-eng-30216/hOiWuy3H5LCSiFAX/images/android-search-overview.png?fit=max&auto=format&n=hOiWuy3H5LCSiFAX&q=85&s=f38f91c19a16602e85046e1d86255f9f" width="2560" height="1670" data-path="images/android-search-overview.png" />
</Frame>

```swift lines theme={null}
import UIKit
import CometChatUIKitSwift
import CometChatSDK

class SearchViewController: UIViewController {
    
    override func viewDidLoad() {
        super.viewDidLoad()
        
        // Search is available in:
        // - CometChatConversations (search bar at top)
        // - CometChatMessageHeader (search button)
        
        let conversations = CometChatConversations()
        
        // Search is enabled by default
        // To hide search:
        // conversations.hideSearch = true
        
        navigationController?.pushViewController(conversations, animated: true)
    }
    
    // Open dedicated search screen
    func openSearch() {
        let search = CometChatSearch()
        navigationController?.pushViewController(search, animated: true)
    }
}
```

**Components Used:**

* [Search](/ui-kit/ios/search) - Dedicated search screen
* [MessageHeader](/ui-kit/ios/message-header) - Search within conversation
* [Conversations](/ui-kit/ios/conversations) - Search conversations

## Moderation

Automatically filter inappropriate content.

<Frame>
  <img src="https://mintcdn.com/cometchat-22654f5b-docs-restapi-chatapi-eng-30216/MyP3UEuDaISnHcFT/images/mobile-uikit-moderation-overview.png?fit=max&auto=format&n=MyP3UEuDaISnHcFT&q=85&s=c744b5f5c7d051e97f5362e11dd25c8e" width="1680" height="972" data-path="images/mobile-uikit-moderation-overview.png" />
</Frame>

```swift lines theme={null}
import UIKit
import CometChatUIKitSwift
import CometChatSDK

class ModerationViewController: UIViewController {
    
    override func viewDidLoad() {
        super.viewDidLoad()
        
        // Moderation is handled automatically based on your
        // CometChat dashboard settings
        
        // Blocked messages are displayed appropriately
        // based on your moderation rules
        
        let messagesVC = CometChatMessages()
        
        CometChat.getUser(UID: "cometchat-uid-1") { user in
            DispatchQueue.main.async {
                messagesVC.set(user: user)
                self.navigationController?.pushViewController(messagesVC, animated: true)
            }
        } onError: { error in
            print("Error: \(error?.errorDescription ?? "")")
        }
    }
}
```

<Note>
  Configure moderation rules in your [CometChat Dashboard](/moderation/overview).
</Note>

## Report Message

Allow users to report inappropriate messages.

<Frame>
  <img src="https://mintcdn.com/cometchat-22654f5b-docs-restapi-chatapi-eng-30216/hOiWuy3H5LCSiFAX/images/android-flag-message.png?fit=max&auto=format&n=hOiWuy3H5LCSiFAX&q=85&s=c9613c6809f7763df9f3879b1a16e9ce" width="2518" height="1704" data-path="images/android-flag-message.png" />
</Frame>

```swift lines theme={null}
import UIKit
import CometChatUIKitSwift
import CometChatSDK

class ReportMessageViewController: UIViewController {
    
    override func viewDidLoad() {
        super.viewDidLoad()
        
        // Report message is available in message actions
        // Users can long-press a message and select "Report"
        
        let messagesVC = CometChatMessages()
        
        CometChat.getUser(UID: "cometchat-uid-1") { user in
            DispatchQueue.main.async {
                messagesVC.set(user: user)
                self.navigationController?.pushViewController(messagesVC, animated: true)
            }
        } onError: { error in
            print("Error: \(error?.errorDescription ?? "")")
        }
    }
}
```

<Note>
  View and manage reported messages in [Flagged Messages](/moderation/flagged-messages).
</Note>

{/* ## Feature Summary

| Feature | Component | Enabled by Default |
|---------|-----------|-------------------|
| Text Messaging | [Messages](/ui-kit/ios/message-header) | ✅ |
| Media Sharing | [MessageComposer](/ui-kit/ios/message-composer) | ✅ |
| Read Receipts | [MessageList](/ui-kit/ios/message-list) | ✅ |
| Typing Indicators | [MessageHeader](/ui-kit/ios/message-header) | ✅ |
| User Presence | [Conversations](/ui-kit/ios/conversations) | ✅ |
| Reactions | [MessageList](/ui-kit/ios/message-list) | ✅ |
| Mentions | [MessageComposer](/ui-kit/ios/message-composer) | ✅ |
| Threads | [ThreadedMessages](/ui-kit/ios/threaded-messages-header) | ✅ |
| Search | [Search](/ui-kit/ios/search) | ✅ |
| Moderation | Dashboard Config | Configure in Dashboard | */}