iOS

AgoraRtmClientConfig(
    appId: String,
    userId: String,
    useStringUserId: Bool,
    ispPolicyEnabled: Bool,
    multipath: Bool,
    presenceTimeout: UInt32,
    heartbeatInterval: UInt32,
    reconnectTimeout: UInt32,
    areaCode: AgoraRtmAreaCode,
    proxyConfig: AgoraRtmProxyConfig?,
    protocolType: AgoraRtmProtocolType,
    logConfig: AgoraRtmLogConfig?,
    encryptionConfig: AgoraRtmEncryptionConfig?,
    privateConfig: AgoraRtmPrivateConfig?
)

let config = AgoraRtmClientConfig(appId: "yourAppId", userId: "yourUserId")
config.areaCode = [.CN, .NA]
config.presenceTimeout = 30
config.heartbeatInterval = 10
config.useStringUserId = true

AgoraRtmClientKit(_ config: AgoraRtmClientConfig, delegate: (any AgoraRtmClientDelegate)?) throws

do {
    let config = AgoraRtmClientConfig(appId: "yourAppId", userId: "uniqueUserId")
    config.areaCode = [.CN, .NA]
    config.presenceTimeout = 30
    config.heartbeatInterval = 10
    config.useStringUserId = true
 // Initializing the RTM client
    let rtmClient = try AgoraRtmClientKit(config, delegate: nil)
    if rtmClient != nil {
        print("RTM Client initialized successfully!")
    }
} catch let error {
    print("Failed to initialize RTM client. Error: \(error)")
}

class EventHandler: NSObject, AgoraRtmClientDelegate {
 // message event handler
  func rtmKit(_ rtmKit: AgoraRtmClientKit, didReceiveMessageEvent event: AgoraRtmMessageEvent) {
    print("Message received from \(event.channelName): \(event.message)")
  }
 // presence event handler
  func rtmKit(_ rtmKit: AgoraRtmClientKit, didReceivePresenceEvent event: AgoraRtmPresenceEvent) {
    print("User \(event.publisher) is now \(event.type)")
  }
}
let eventDelegate = EventHandler()
let rtmClient = try AgoraRtmClientKit(config, delegate: eventDelegate)

// message event handler
class MessageHandler: NSObject, AgoraRtmClientDelegate {
  func rtmKit(_ rtmKit: AgoraRtmClientKit, didReceiveMessageEvent event: AgoraRtmMessageEvent) {
    print("Message received from \(event.channelName): \(event.message)")
  }
}
 // presence event handler
class PresenceHandler: NSObject, AgoraRtmClientDelegate {
  func rtmKit(_ rtmKit: AgoraRtmClientKit, didReceivePresenceEvent event: AgoraRtmPresenceEvent) {
    print("User \(event.publisher) is now \(event.type)")
  }
}
let messageDelegate = MessageHandler()
let presenceDelegate = PresenceHandler()
rtmClient.addDelegate(messageDelegate)
rtmClient.addDelegate(presenceDelegate)

rtmClient.removeDelegate(messageDelegate)

login(_ token: String?) async -> (AgoraRtmCommonResponse?, AgoraRtmErrorInfo?)

login(_ token: String?, completion completionBlock: AgoraRtmOperationBlock? = nil)

class AgoraRtmErrorInfo : NSError {
    var errorCode: AgoraRtmErrorCode  // Error code
    var operation: String  // API name
    var reason: String  // Brief description of the error reason
}

// async-await
let (response, error) = await rtmClient.login("your_token_here")
if let error = error {
    print("Login failed with error: \(error.reason)")
} else if let response = response {
    print("Login successful!")
} else {
    print("Unknown error")
}

// callback
rtmClient.login(token) { response, error in
    if let errorInfo = error {
        print("Login failed with error: \(errorInfo.reason)")
    } else let loginResponse = response {
        print("Login successful: \(loginResponse)")
    }
}

logout() async -> (AgoraRtmCommonResponse?, AgoraRtmErrorInfo?)

logout(_ completionBlock: AgoraRtmOperationBlock? = nil)

 // async-await
let (response, error) = await rtmClient.logout()
if let error = error {
  print("Logout failed with error: \(error.reason)")
} else if let response = response {
  print("Logout successful!")
} else {
  print("Unknown error")
}

 // callback
rtmClient.logout { response, error in
  if let errorInfo = error {
    print("Logout failed with error: \(errorInfo.reason)")
  } else let logoutResponse = response {
    print("Logout successful: \(logoutResponse)")
  }
}

destroy() -> AgoraRtmErrorCode

let errorCode = rtmClient.destroy()
if errorCode == .ok {
    print("RTM instance destroyed successfully.")
} else {
    print("Failed to destroy RTM instance: \(errorCode)")
}

renewToken(_ token: String, completion completionBlock: AgoraRtmOperationBlock? = nil)

renewToken(_ token: String) async -> (AgoraRtmCommonResponse?, AgoraRtmErrorInfo?)

// async-await
let (response, error) = await rtmClient.renewToken(token: "your_token_here")
if let error = error {
    print("Login failed with error: \(error.reason)")
} else if let response = response {
    print("renew token successful!")
} else {
    print("Unknown error")
}

// callback
rtmClient.renewToken(token: "your_token_here") { response, error in
    if let errorInfo = error {
        print("renew token failed with error: \(errorInfo.reason)")
    } else let loginResponse = response {
        print("renew token successful: \(loginResponse)")
    }
}

renewToken(_ token: String, completion completionBlock: AgoraRtmOperationBlock? = nil)

renewToken(_ token: String) async -> (AgoraRtmCommonResponse?, AgoraRtmErrorInfo?)

// async-await
let (response, error) = await streamChannel.renewToken(token: "your_token_here")
if let error = error {
    print("Login failed with error: \(error.reason)")
} else if let response = response {
    print("renew token successful!")
} else {
    print("Unknown error")
}

// callback
streamChannel.renewToken(token: "your_token_here") { response, error in
    if let errorInfo = error {
        print("renew token failed with error: \(errorInfo.reason)")
    } else let loginResponse = response {
        print("renew token successful: \(loginResponse)")
    }
}

subscribe(
    channelName: String,
    option subscribeOption: AgoraRtmSubscribeOptions?
)   async -> (AgoraRtmCommonResponse?, AgoraRtmErrorInfo?)

subscribe(
    channelName: String,
    option subscribeOption: AgoraRtmSubscribeOptions?,
    completion completionBlock: AgoraRtmOperationBlock? = nil
)

// async-await
let subscribeOptions = AgoraRtmSubscribeOptions()
subscribeOptions.features = [.presence, .message, .metadata]

let (response, error) = await rtmClient.subscribe(channelName: "exampleChannel", option: subscribeOptions)
if let error = error {
    print("Failed to subscribe with error: \(error.reason)")
} else {
    print("Successfully subscribed to the channel.")
}

// callback
let subscribeOptions = AgoraRtmSubscribeOptions()
subscribeOptions.features = [.presence, .message, .metadata]

rtmClient.subscribe(channelName: "exampleChannel", option: subscribeOptions) { response, error in
    if let errorInfo = error {
        print("Subscription failed with error: \(errorInfo.reason)")
    } else let SubscribeResponse = response {
        print("Subscription to \(SubscribeResponse.channelName) successful!")
    }
}

unsubscribe(_ channelName: String) async -> (AgoraRtmCommonResponse?, AgoraRtmErrorInfo?)

unsubscribe(_ channelName: String, completion completionBlock: AgoraRtmOperationBlock? = nil)

// async-await
let (response, error) = await rtmClient.unsubscribe("exampleChannel")
if let error = error {
    // Handle error
    print("Failed to unsubscribe with error: \(error.reason)")
} else if let response = response {
    // Handle success
    print("Unsubscribed from channel successfully.")
} else {
    // Handle unknown error
    print("Unknown error occurred while unsubscribing.")
}

// callback
rtmClient.unsubscribe("exampleChannel") { response, error in
    if let errorInfo = error {
        print("Unsubscribe failed with error: \(errorInfo.localizedDescription)")
    } else let unsubscribeResponse = response {
        print("Successfully unsubscribed from \(unsubscribeResponse.channelName).")
    }
}

createStreamChannel(_ channelName: String) throws -> AgoraRtmStreamChannel

do {
    let streamChannel = try rtmClient.createStreamChannel("exampleChannel")
    print("Stream channel created successfully: \(streamChannel)")
    // You can now use the streamChannel instance
} catch {
    print("Failed to create stream channel: \(error)")
}

join(_ option: AgoraRtmJoinChannelOption) async -> (AgoraRtmCommonResponse?, AgoraRtmErrorInfo?)

join(_ option: AgoraRtmJoinChannelOption, completion completionBlock: AgoraRtmOperationBlock? = nil)

// async-await
let joinOptions = AgoraRtmJoinChannelOption()
joinOptions.token = 'your_token'
joinOptions.features = [.message, .presence]

let (response, error) = await streamChannel.join(joinOptions)
if let errorInfo = error {
    print("Failed to join the channel with error: \(errorInfo.reason)")
} else if let joinResponse = response {
    print("Successfully joined the channel. Response: \(joinResponse)")
} else {
    print("Join operation completed with no response or error.")
}

// callback
let joinOptions = AgoraRtmJoinChannelOption()
joinOptions.token = "your_token"
joinOptions.features = [.presence, .presence]

streamChannel.join(joinOptions, completion: { (res, error) in
    if error != nil {
        print("\(error?.operation ?? "Operation") failed! Error reason is \(error?.reason ?? "Unknown reason")")
    } else {
        print("Success")
    }
})

leave() async -> (AgoraRtmCommonResponse?, AgoraRtmErrorInfo?)

leave(_ completionBlock: AgoraRtmOperationBlock? = nil)

// async-await
let (response, error) = await streamChannel.leave()
if let errorInfo = error {
    print("Failed to leave the channel with error: \(errorInfo.localizedDescription)")
} else if let commonResponse = response {
    print("Successfully left the channel. Response: \(commonResponse)")
} else {
    print("Leave operation completed with no response or error.")
}

// callback
streamChannel.leave({ res, error in
    if error != nil {
        print("\(error?.operation) failed! error reason is \(error?.reason)")
    } else {
        print("success")
    }
})

destroy() -> AgoraRtmErrorCode

streamChannel.destroy()

joinTopic(
    _ topic: String,
    option: AgoraRtmJoinTopicOption?
)   async -> (AgoraRtmCommonResponse?, AgoraRtmErrorInfo?)

joinTopic(
    _ topic: String,
    option: AgoraRtmJoinTopicOption?,
    completion completionBlock: AgoraRtmOperationBlock? = nil
)

// async-await
let topic = "exampleTopic"
let joinOption = AgoraRtmJoinTopicOption()
joinOption.priority = .high
joinOption.syncWithMedia = false

let (response, error) = await stChannel.joinTopic(topic, option: joinOption)
if let errorInfo = error {
    // Handle error
    print("Failed to join topic with error: \(errorInfo.reason)")
} else if let joinTopicResponse = response {
    // Handle success
    print("Successfully joined topic.")
} else {
    // Handle unknown error
    print("Unknown error occurred while joining the topic.")
}

// callack
let topic = "exampleTopic"
let joinOption = AgoraRtmJoinTopicOption()
joinOption.priority = .high
joinOption.syncWithMedia = false

stChannel.joinTopic(topic, option: joinOption) { (response, error) in
    if let errorInfo = error {
 // Handle error
        print("Failed to join topic with error: \(errorInfo.reason)")
    } else if let joinTopicResponse = response {
 // Handle success
        print("Successfully joined topic.")
    } else {
 // Handle unknown error
        print("Unknown error occurred while joining the topic.")
    }
}

  publishTopicMessage(
      topic: String,
      message: String,
      option options: AgoraRtmTopicMessageOptions?
  )   async -> (AgoraRtmCommonResponse?, AgoraRtmErrorInfo?)

  publishTopicMessage(
      topic: String,
      message: String,
      option options: AgoraRtmTopicMessageOptions?,
      completion completionBlock: AgoraRtmOperationBlock? = nil
  )

  publishTopicMessage(
      topic: String,
      ata: Data,
      option options: AgoraRtmTopicMessageOptions?
  )   async -> (AgoraRtmCommonResponse?, AgoraRtmErrorInfo?)

  publishTopicMessage(
      topic: String,
      data: Data,
      option options: AgoraRtmTopicMessageOptions?,
      completion completionBlock: AgoraRtmOperationBlock? = nil
  )

// async-await
let topic = "exampleTopic"
let message = "Hello, Agora!"
let messageOptions = AgoraRtmTopicMessageOptions()
messageOption.customType = "PlainText"

let (response, error) = await stChannel.publishTopicMessage(
    topic: topic,
    message: message,
    option: messageOptions
)
if let errorInfo = error {
    // Handle error
    print("Failed to publish message with error: \(errorInfo.reason)")
} else if let publishResponse = response {
    // Handle success
    print("Message published successfully.")
} else {
    // Handle unknown error
    print("Unknown error occurred while publishing the message.")
}

// callback
let topic = "exampleTopic"
let message = "Hello, Agora!"
let messageOptions = AgoraRtmTopicMessageOptions()
messageOption.customType = "PlainText"

stChannel.publishTopicMessage(
    topic: topic,
    message: message,
    option: messageOptions
) { (response, error) in
    if let errorInfo = error {
 // Handle error
        print("Failed to publish message with error: \(errorInfo.reason)")
    } else if let publishResponse = response {
 // Handle success
        print("Message published successfully.")
    } else {
 // Handle unknown error
        print("Unknown error occurred while publishing the message.")
    }
}

// async-await
let topic = "exampleTopic"
let messageOptions = AgoraRtmTopicMessageOptions()
messageOption.customType = "BinaryData"
let byteArray: [UInt8] = [0x00, 0x01, 0x02, 0x03]
let binaryData = Data(byteArray)

let (response, error) = await stChannel.publishTopicMessage(
    topic: topic,
    ata: binaryData,
    option: messageOptions
)
if let errorInfo = error {
    // Handle error
    print("Failed to publish binary data with error: \(errorInfo.reason)")
} else if let publishResponse = response {
    // Handle success
    print("Binary data published successfully.")
} else {
    // Handle unknown error
    print("Unknown error occurred while publishing the binary data.")
}

// callback
let topic = "exampleTopic"
let messageOptions = AgoraRtmTopicMessageOptions()
messageOption.customType = "BinaryData"
let byteArray: [UInt8] = [0x00, 0x01, 0x02, 0x03]
let binaryData = Data(byteArray)

stChannel.publishTopicMessage(
    topic: topic,
    ata: binaryData,
    option: messageOptions
) { (response, error) in
    if let errorInfo = error {
    // Handle error
        print("Failed to publish binary data with error: \(errorInfo.reason)")
    } else if let publishResponse = response {
    // Handle success
        print("Binary data published successfully.")
    } else {
    // Handle unknown error
        print("Unknown error occurred while publishing the binary data.")
    }
}

leaveTopic(
    _ topic: String
)   async -> (AgoraRtmCommonResponse?, AgoraRtmErrorInfo?)

leaveTopic(
    _ topic: String,
    completion completionBlock: AgoraRtmOperationBlock? = nil
)

// async-await
let topic = "exampleTopic"

let (response, error) = await stChannel.leaveTopic(topic)
if let errorInfo = error {
 // Handle error
    print("Failed to leave topic with error: \(errorInfo.reason)")
} else if let leaveTopicResponse = response {
 // Handle success
    print("Successfully left topic.")
} else {
 // Handle unknown error
    print("Unknown error occurred while leaving the topic.")
}

// callback
let topic = "exampleTopic"

stChannel.leaveTopic(topic) { (response, error) in
    if let errorInfo = error {
    // Handle error
        print("Failed to leave topic with error: \(errorInfo.reason)")
    } else if let leaveTopicResponse = response {
    // Handle success
        print("Successfully left topic.")
    } else {
    // Handle unknown error
        print("Unknown error occurred while leaving the topic.")
    }
}

subscribeTopic(
    _ topic: String,
    option: AgoraRtmTopicOption?
)   async -> (AgoraRtmTopicSubscriptionResponse?, AgoraRtmErrorInfo?)

subscribeTopic(
    _ topic: String,
    option: AgoraRtmTopicOption?,
    completion completionBlock: AgoraRtmTopicSubscriptionBlock? = nil
)

// async-await
let topic = "exampleTopic"
let topicOption = AgoraRtmTopicOption() // Optional, configure if needed
topicOption.users = ["user1", "user2"] // Specify users to subscribe to

let (response, error) = await stChannel.subscribeTopic(topic, option: topicOption)
if let errorInfo = error {
    // Handle error
    print("Failed to subscribe to topic with error: \(errorInfo.reason)")
} else if let subscriptionResponse = response {
    // Handle success
    print("Successfully subscribed to topic.")
} else {
    // Handle unknown error
    print("Unknown error occurred while subscribing to the topic.")
}

// callback
let topic = "exampleTopic"
let topicOption = AgoraRtmTopicOption() // Optional
topicOption.users = ["user1", "user2"] // Specify users to subscribe to

stChannel.subscribeTopic(topic, option: topicOption) { (response, error) in
    if let errorInfo = error {
    // Handle error
        print("Failed to subscribe to topic with error: \(errorInfo.reason)")
    } else if let subscriptionResponse = response {
    // Handle success
        print("Successfully subscribed to topic.")
    } else {
    // Handle unknown error
        print("Unknown error occurred while subscribing to the topic.")
    }
}

// async-await
let topic = "exampleTopic"

let (response, error) = await stChannel.subscribeTopic(topic, option: nil)
if let errorInfo = error {
    // Handle error
    print("Failed to subscribe to topic with error: \(errorInfo.reason)")
} else if let subscriptionResponse = response {
    // Handle success
    print("Successfully subscribed to topic.")
} else {
    // Handle unknown error
    print("Unknown error occurred while subscribing to the topic.")
}

// callback
let topic = "exampleTopic"

stChannel.subscribeTopic(topic, option: nil) { (response, error) in
    if let errorInfo = error {
    // Handle error
        print("Failed to subscribe to topic with error: \(errorInfo.reason)")
    } else if let subscriptionResponse = response {
    // Handle success
        print("Successfully subscribed to topic.")
    } else {
    // Handle unknown error
        print("Unknown error occurred while subscribing to the topic.")
    }
}

unsubscribeTopic(
    _ topic: String,
    option: AgoraRtmTopicOption?
)   async -> (AgoraRtmCommonResponse?, AgoraRtmErrorInfo?)

unsubscribeTopic(
    _ topic: String,
    option: AgoraRtmTopicOption?,
    completion completionBlock: AgoraRtmOperationBlock? = nil
)

// async-await
let topic = "exampleTopic"
let topicOption = AgoraRtmTopicOption()
// Set specific users to unsubscribe from if needed
topicOption.users = ["user1", "user2"]

let (response, error) = await stChannel.unsubscribeTopic(topic, option: topicOption)
if let errorInfo = error {
    // Handle error
    print("Failed to unsubscribe from topic with error: \(errorInfo.reason)")
} else if let unsubscribeResponse = response {
     // Handle success
    print("Successfully unsubscribed from topic with specified options.")
} else {
    // Handle unknown error
    print("Unknown error occurred while unsubscribing from the topic.")
}

// callback
let topic = "exampleTopic"
let topicOption = AgoraRtmTopicOption()
 // Set specific users to unsubscribe from if needed
topicOption.users = ["user1", "user2"]

stChannel.unsubscribeTopic(topic, option: topicOption) { (response, error) in
    if let errorInfo = error {
    // Handle error
        print("Failed to unsubscribe from topic with error: \(errorInfo.reason)")
    } else if let unsubscribeResponse = response {
    // Handle success
        print("Successfully unsubscribed from topic with specified options.")
    } else {
    // Handle unknown error
        print("Unknown error occurred while unsubscribing from the topic.")
    }
}

// async-await
let topic = "exampleTopic"

 // Unsubscribing without options
let (response, error) = await stChannel.unsubscribeTopic(topic, option: nil)
if let errorInfo = error {
    // Handle error
    print("Failed to unsubscribe from topic with error: \(errorInfo.reason)")
} else if let unsubscribeResponse = response {
    // Handle success
    print("Successfully unsubscribed from topic.")
} else {
    // Handle unknown error
    print("Unknown error occurred while unsubscribing from the topic.")
}

// callback
let topic = "exampleTopic"

// Unsubscribing without options
stChannel.unsubscribeTopic(topic, option: nil) { (response, error) in
    if let errorInfo = error {
    // Handle error
        print("Failed to unsubscribe from topic with error: \(errorInfo.reason)")
    } else if let unsubscribeResponse = response {
    // Handle success
        print("Successfully unsubscribed from topic.")
    } else {
    // Handle unknown error
        print("Unknown error occurred while unsubscribing from the topic.")
    }
}

  publish(
      channelName: String,
      message: String,
      option publishOption: AgoraRtmPublishOptions?
  )   async -> (AgoraRtmCommonResponse?, AgoraRtmErrorInfo?)

  publish(
      channelName: String,
      message: String,
      option publishOption: AgoraRtmPublishOptions?,
      completion completionBlock: AgoraRtmOperationBlock? = nil
  )

  publish(
      channelName: String,
      data: Data,
      option publishOption: AgoraRtmPublishOptions?
  )   async -> (AgoraRtmCommonResponse?, AgoraRtmErrorInfo?)

  publish(
      channelName: String,
      data: Data,
      option publishOption: AgoraRtmPublishOptions?,
      completion completionBlock: AgoraRtmOperationBlock? = nil
  )

// async-await
let publishOptions = AgoraRtmPublishOptions()
publishOptions.channelType = .message // Which channel type, .user or .message
publishOptions.customType = "PlaintText" // Custom type "PlaintText"
let (response, error) = await rtmClient.publish(
    channelName: "exampleChannel",
    message: "Hello, Agora!",
    option: publishOptions)
if let errorInfo = error {
    // handle error
    print("Failed to publish message with error: \(errorInfo.reason)")
} else if let publishResponse = response {
    // handle success
    print("Message published successfully.")
} else {
    // handle unknown error
    print("Unknown error occurred while publishing the message.")
}

// callback
let publishOptions = AgoraRtmPublishOptions()
publishOptions.channelType = .message // Set the channel type to .message
publishOptions.customType = "PlainText" // Set a custom type to "PlainText"

rtmClient.publish(
    channelName: "exampleChannel",
    message: "Hello, Agora!",
    option: publishOptions
) { (response, error) in
    if let errorInfo = error {
    // Handle error
        print("Failed to publish message with error: \(errorInfo.reason)")
    } else if let publishResponse = response {
    // Handle success
        print("Message published successfully.")
    } else {
    // Handle unknown error
        print("Unknown error occurred while publishing the message.")
    }
}

// async-await
let publishOptions = AgoraRtmPublishOptions()
publishOptions.channelType = .message // Set channel type, .user or .message
publishOptions.customType = "BinaryData" // Set custom message type "BinaryData"
let byteArray: [UInt8] = [0x00, 0x01, 0x02, 0x03]
let binaryData = Data(byteArray)

let (response, error) = await rtmClient.publish(
    channelName: "exampleChannel",
    data: binaryData,
    option: publishOptions)
if let errorInfo = error {
    // handle error
    print("Failed to publish message with error: \(errorInfo.reason)")
} else if let publishResponse = response {
    // handle success
    print("Message published successfully.")
} else {
    // handle unknown error
    print("Unknown error occurred while publishing the message.")
}

// callback
let publishOptions = AgoraRtmPublishOptions()
publishOptions.channelType = .message // Set the channel type to .message
publishOptions.customType = "BinaryData" // Set a custom type to "BinaryData"
let byteArray: [UInt8] = [0x00, 0x01, 0x02, 0x03]
let binaryData = Data(byteArray)

rtmClient.publish(
    channelName: "exampleChannel",
    data: binaryData,
    option: publishOptions
) { (response, error) in
    if let errorInfo = error {
        // Handle error
        print("Failed to publish message with error: \(errorInfo.reason)")
    } else if let publishResponse = response {
        // Handle success
        print("Message published successfully.")
    } else {
        // Handle unknown error
        print("Unknown error occurred while publishing the message.")
    }
}

let publishOptions = AgoraRtmPublishOptions()
publishOptions.channelType = .user
publishOptions.customType = "PlaintText"

let (response, error) = await rtmClient.publish(
    channelName: "exampleChannel",
    message: "Hello, Agora!",
    option: publishOptions)
if let errorInfo = error {
    // handle error
    print("Failed to publish message with error: \(errorInfo.reason)")
} else if let publishResponse = response {
    // handle success
    print("Message published successfully.")
} else {
    // handle unknown error
    print("Unknown error occurred while publishing the message.")
}

// callback
let publishOptions = AgoraRtmPublishOptions()
publishOptions.channelType = .user
publishOptions.customType = "PlainText"

rtmClient.publish(
    channelName: "exampleChannel",
    message: "Hello, Agora!",
    option: publishOptions
) { (response, error) in
    if let errorInfo = error {
        // handle error
        print("Failed to publish message with error: \(errorInfo.reason)")
    } else if let publishResponse = response {
        // handle success
        print("Message published successfully.")
    } else {
        // handle unknown error
        print("Unknown error occurred while publishing the message.")
    }
}

// message event handler
class MessageHandler: NSObject, AgoraRtmClientDelegate {
    func rtmKit(_ rtmKit: AgoraRtmClientKit, didReceiveMessageEvent event: AgoraRtmMessageEvent) {
        print("Message received from \(event.channelName): \(event.message)")
    }
}
let messageDelegate = MessageHandler()
rtmClient.addDelegate(messageDelegate)

getOnlineUsers(
    channelName: String,
    channelType: AgoraRtmChannelType,
    options: AgoraRtmGetOnlineUsersOptions?
)   async -> (AgoraRtmGetOnlineUsersResponse?, AgoraRtmErrorInfo?)

getOnlineUsers(
    channelName: String,
    channelType: AgoraRtmChannelType,
    options: AgoraRtmGetOnlineUsersOptions?,
    completion completionBlock: AgoraRtmGetOnlineUsersBlock? = nil
)

// async-await
let presenceOptions = AgoraRtmGetOnlineUsersOptions()
presenceOptions.includeUserId = true
presenceOptions.includeState = true

let (response, error) = await rtmClient.getPresence()!.getOnlineUsers(
    channelName: "exampleChannel",
    channelType: .message,
    options: presenceOptions)

if let errorInfo = error {
    print("Error querying online users: \(errorInfo.reason)")
} else if let getOnlineUsersResponse = response {
    // Handle the response containing user presence information
    print("Users in channel: \(getOnlineUsersResponse)")
}

// callback
let presenceOptions = AgoraRtmGetOnlineUsersOptions()
presenceOptions.includeUserId = true
presenceOptions.includeState = true

rtmClient.getPresence()!.getOnlineUsers(
    channelName: "exampleChannel",
    channelType: .message,
    options: presenceOptions
) { (response, error) in
    if let errorInfo = error {
        print("Error querying online users: \(errorInfo.reason)")
    } else if let getOnlineUsersResponse = response {
        // Handle the response containing user presence information
        print("Users in channel: \(getOnlineUsersResponse)")
    } else {
        print("Online users query completed with no response or error.")
    }
}

getUserChannels(userId: String) async -> (AgoraRtmGetUserChannelsResponse?, AgoraRtmErrorInfo?)

getUserChannels(userId: String, completion completionBlock: AgoraRtmGetUserChannelsBlock? = nil)

// async-await
let (response, error) = await rtmClient.getPresence()!.getUserChannels(userId:"your_userID")
if let errorInfo = error {
    print("Error querying user channels: \(errorInfo.reason)")
} else if let getUserChannelsResponse = response {
 // Handle the response containing user presence information
    print("channels: \(getUserChannelsResponse)")
}

// callback
rtmClient.getPresence()!.getUserChannels(userId: "your_userID") { (response, error) in
    if let errorInfo = error {
        print("Error querying user channels: \(errorInfo.reason)")
    } else if let getUserChannelsResponse = response {
        // Process the list of channels the user is currently in
        print("User is present in channels: \(getUserChannelsResponse.channels)")
    } else {
        print("No response or error.")
    }
}

setState(
    channelName: String,
    channelType: AgoraRtmChannelType,
    items: [String : String]
)   async -> (AgoraRtmCommonResponse?, AgoraRtmErrorInfo?)

setState(
    channelName: String,
    channelType: AgoraRtmChannelType,
    items: [String : String],
    completion completionBlock: AgoraRtmOperationBlock? = nil
)