Flutter

The Signaling SDK API reference is divided into the following sections:

• Setup
• User authentication
• Channels
• Topics
• Messages
• Presence
• Storage
• Lock
• Enumerated types
• Troubleshooting

Setup

The API reference for the Signaling SDK documents interface descriptions, methods, basic usage, and return values of the Signaling APIs.

RtmConfig

Description

Use the RtmConfig to set additional properties for Signaling initialization. These configuration properties will take effect throughout the lifecycle of the Signaling client and affect the behavior of the Signaling client.

Method

You can create RtmConfig instances as follows:

RtmConfig({
    int heartbeatInterval,
    int presenceTimeout,
    bool useStringUserId,
    bool ispPolicyEnabled,
    RtmProtocolType protocolType,
    RtmLogConfig logConfig,
    RtmProxyConfig proxyConfig,
    RtmEncryptionConfig encryptionConfig,
    RtmPrivateConfig privateConfig,
    Set<RtmAreaCode> areaCode
})

RtmLogConfig

RtmLogConfig({
    String filePath,
    int fileSizeInKB,
    RtmLogLevel level
})

Use the RtmLogConfig instance to configure and store local log files named agora.log. During the debugging phase, you can greatly improve efficiency by storing and tracking the running status of the app through logs. If you encounter complex problems and need Agora technical support to assist with the investigation, you need to provide the log information. RtmLogConfig contains the following properties:

RtmProxyConfig

RtmProxyConfig({
    RtmProxyType proxyType,
    String server,
    int port,
    String account,
    String password
})

Use the RtmProxyConfig instance to set properties related to the client Proxy service. In some restricted network environments, you might need to use this feature.

RtmProxyConfig contains the following properties:

RtmEncryptionConfig

RtmEncryptionConfig({
    RtmEncryptionMode encryptionMode,
    String encryptionKey,
    Uint8List encryptionSalt
})

Use the RtmEncryptionConfig instance to set the properties required for the client-side encryption. After successfully setting encryption modes, encryption keys, and other related properties, the SDK automatically encrypts and decrypts all messages sent or all statuses set by the user on the client side.

RtmEncryptionConfig contains the following properties:

RtmPrivateConfig

RtmPrivateConfig({
    Set<RtmServiceType> serviceType,
    List<String> accessPointHosts
})

Use the RtmPrivateConfig instance to set the properties required for the private deployment.

RtmPrivateConfig contains the following properties:

Basic usage

final proxyConfig = RtmProxyConfig(
      protocolType : RtmProxyType.http,
      server : "x.x.x.x",
      port : 8080,
      account : "Tony",
      password : "pwd" );

final logConfig = RtmLogConfig(
      filePath : "xxxx",
      fileSizeInKB : 1024;
      leave : RtmLogLevel.info );

final encryptionConfig = RtmEncryptionConfig(
      encryptionMode : RtmEncryptionMode.aes256Gcm,
      encryptionKey : "XXXXX",
      encryptionSalt : [1,2,3,4,5]);

final rtmConfig = RtmConfig(
      heartbeatInterval : 10,
      presenceTimeout : 5,
      proxyConfig : proxyConfig,
      logConfig : logConfig,
      areaCode : `RtmAreaCode.cn, RtmAreaCode.na`,
      encryptionConfig : encryptionConfig );

Initialization

Description

Call the RTM() method to create and initialize the Signaling Client instance.

Method

You can create and initialize an instance as follows:

Future<(RtmStatus,RtmClient)> RTM(
    String appId,
    String userId,
    {
        RtmConfig rtmConfig
    }
)

Basic usage

final proxyConfig = RtmProxyConfig(
      protocolType : RtmProxyType.http,
      server : "x.x.x.x",
      port : 8080,
      account : "Tony",
      password : "pwd" );

final logConfig = RtmLogConfig(
      filePath : "xxxx",
      fileSizeInKB : 1024,
      leave : RtmLogLevel.info );

final encryptionConfig = RtmEncryptionConfig(
      encryptionMode : RtmEncryptionMode.aes256gcm,
      encryptionKey : "XXXXX",
      encryptionSalt : [1,2,3,4,5]);

final rtmConfig = RtmConfig(
      heartbeatInterval : 10,
      presenceTimeout : 5,
      proxyConfig : proxyConfig,
      logConfig : logConfig,
      areaCode : `RtmAreaCode.cn, RtmAreaCode.na`,
      encryptionConfig : encryptionConfig );

var (status,rtmClient) = await RTM("myAppId", "Tony", rtmConfig:rtmConfig);
if (status.error == true) {
    print(status);
} else {
    print(response);
}

Return value

Calling this method returns a Future<(RtmStatus,RtmClient)> tuple. Regardless of whether the method call succeeds, the first item in the tuple always returns RtmStatus data type, with the fields defined as follows:

class RtmStatus {
    bool error; // Indicates whether there was an error in this operation.
    String errorCode; // The error code for this operation.
    String operation; // The operation.
    String reason; // A brief description of the error reason for this operation.
}

You can understand the error reason and find the corresponding solution by looking up the error codes in the error codes table.

• If the method call succeeds, the second item of the tuple returns a Signaling client instance for subsequent calls to other Signaling APIs.

Event Listeners

Description

Signaling has a total of 7 types of event notifications, as shown in the following table:

Add event listeners

You can add an event listener object as follows:

rtmClient.addListener({
    Function(MessageEvent event)? message = null,
    Function(PresenceEvent event)? presence = null,
    Function(TopicEvent event)? topic = null,
    Function(StorageEvent event)? storage = null,
    Function(LockEvent event)? lock = null,
    Function(LinkStateEvent event)? linkState = null,
    Function(TokenEvent event)? token = null,
})

Remove event listeners

You can remove an event listener object as follows:

rtmClient.removeListener({
    Function(MessageEvent event) message = null,
})

MessageEvent

Message event.

MessageEvent contains the following properties:

PresenceEvent

User presence event.

PresenceEvent contains the following properties:

StateItem data type contains the following properties:

IntervalInfo contains the following properties:

SnapshotInfo contains the following properties:

UserList contains the following properties:

UserState contains the following properties:

TopicEvent

Topic event.

TopicEvent contains the following properties:

TopicInfo data type contains the following properties:

PublisherInfo data type contains the following properties:

StorageEvent

Storage event.

StorageEvent contains the following properties:

LockEvent

Lock event.

LockEvent contains the following properties:

The LockDetail data type contains the following properties:

LinkStateEvent

SDK link state event.

LinkStateEvent data type contains the following properties:

RtmClient Signaling client instance.

login

Description

After creating and initializing the Signaling instance, you need to perform the login operation to log in to the Signaling service. After successful login, the client establishes a long connection with the Signaling server, and then the SDK allows the client to access Signaling resources.

Method

You can log in to the Signaling system as follows:

Future<(RtmStatus, LoginResult?)> login(String token);

Basic usage

var (status,response) = await rtmClient.login('your_token');
if (status.error == true) {
    print(status);
} else {
    print(response);
}

Return value

Calling this method returns a Future<(RtmStatus, LoginResult?)> tuple data. Regardless of whether the method call succeeds, the first item in the tuple always returns RtmStatus data type, with the fields defined as follows:

class RtmStatus {
    bool error; // Indicates whether there was an error in this operation.
    String errorCode; // The error code for this operation.
    String operation; // The operation.
    String reason; // A brief description of the error reason for this operation.
}

You can understand the error reason and find the corresponding solution by looking up the error codes in the error codes table.

• If the method call succeeds, the second item of the tuple returns a LoginResult type data, which currently does not contain any fields.

logout

Description

When you no longer need to operate, you can log out of the system. This operation affects the PCU item in your billing data.

Method

You can log out as follows:

Future<(RtmStatus, LogoutResult?)> logout();

Basic usage

var (status,response) = await rtmClient.logout();
if (status.error == true) {
    print(status);
} else {
    print(response);
}

Return value

Calling this method returns a Future<(RtmStatus, LogoutResult?)> tuple data. Regardless of whether the method call succeeds, the first item in the tuple always returns RtmStatus data type, with the fields defined as follows:

class RtmStatus {
    bool error; // Indicates whether there was an error in this operation.
    String errorCode; // The error code for this operation.
    String operation; // The operation.
    String reason; // A brief description of the error reason for this operation.
}

You can understand the error reason and find the corresponding solution by looking up the error codes in the error codes table.

• If the method call succeeds, the second item of the tuple returns a LogoutResult type data, which currently does not contain any fields.

releaseLock

Description

Once you no longer need the Signaling service, it is best to destroy the RtmClient instance. Doing so protects you from the performance degradation caused by memory leaks, errors, and exceptions.

Method

You can destroy the RtmClient instance as follows:

Future<RtmStatus> release();

Basic usage

var status = await rtmClient.release();

Return value

Regardless of whether you call this method successfully, this method returns an RtmStatus type data, with the following field definitions:

class RtmStatus {
    bool error; // Whether there was an error in this operation.
    String errorCode; // The error code for this operation.
    String operation; // The API for this operation.
    String reason; // A brief description of the error reason for this operation.
}

You can refer to the errorCode field in the Error Codes to understand the cause of the error and find the corresponding solution.

User authentication

Authentication is the process of validating the identity of each user before they access a system. Agora uses digital tokens to authenticate users and their privileges.

Based on different transmission connections, the RTM SDK provides two types of services: MESSAGE service and STREAM service. These two services use different tokens and the methods for updating tokens are also different:

• MESSAGE service: Use the renewToken() method under the rtmClient instance to update the token, providing authentication services for features such as Message Channel, User Channel, Presence, Storage, and Lock.
• STREAM service: Use the renewToken() method under the streamChannel instance to update the token, providing authentication services for features such as Stream Channel and Topic.

Both services will return a token expiration notification in the token event. You can implement the business logic for automatic token renewal by listening to this event. The token is valid for up to 24 hours. Agora recommends that you update the token before it expires. This article describes how to update the token.

For more information on generating and using tokens, see Secure authentication with tokens.

renewToken

Description

To ensure timely token updates, Agora recommends listening for the token callback. See Event listeners for details. Once you successfully add the event listener, when the token is about to expire within 30 seconds, the SDK triggers the token callback to notify the user about the impending token expiration.

• Call rtmClient.renewToken(String token) to renew the token for MESSAGE service.
• Call streamChannel.renewToken(String token) to renew the token for STREAM service.

Method

You can call the renewToken method as follows:

Future<(RtmStatus, RenewTokenResult?)> renewToken(String token);

Basic Usage

class TokenResult {
    final String status;
    final String token;
    TokenResult(this.status, this.token);
}

 // Define the function to fetch token
Future<TokenResult> fetchToken({required String channelName}) async {
 // Request token from the token provider
    ......
    String status = "success";
    String token = "your_token_here";
    return TokenResult(status, token);
}

rtmClient.addListener({
    token:(event) => {
        if(event.channelName == '') { // When the channelName in the event is empty, it means the MESSAGE service token is about to expire
            var result = await fetchToken(); // Fetch the MESSAGE service token
            rtmClient.renewToken(result.token); // Renew the MESSAGE service token
        } else { // When the channelName in the event is not empty, it means the STREAM service token is about to expire
            var result = await fetchToken(channelName: event.channelName); // Fetch the STREAM service token
            streamChannel.renewToken(result.token); // Renew the STREAM service token
        }
    }
});

Return Value

Calling this method returns a tuple of type Future<(RtmStatus, RenewTokenResult?)>. Regardless of whether the method call succeeds, the first item in the tuple always returns RtmStatus data type, with the fields defined as follows:

class RtmStatus {
    bool error; // Indicates whether there was an error in this operation.
    String errorCode; // The error code for this operation.
    String operation; // The operation.
    String reason; // A brief description of the error reason for this operation.
}

You can understand the error reason and find the corresponding solution by looking up the error codes in the error codes table.

• If the method call is successful, the second item in the tuple returns data of type RenewTokenResult, defined as follows:

  class RenewTokenResult {
      final RtmServiceType serverType; // Service type
      final String channelName; // Channel name
  }

Channels

Signaling provides a highly efficient channel management mechanism for data transmission. Any user who subscribes or joins a channel can receive messages and events transmitted within 100 milliseconds. Signaling allows clients to subscribe to hundreds or even thousands of channels. Most Signaling APIs perform actions such as sending, receiving, and encrypting based on channels.

Based on capabilities of Agora, Signaling channels are divided into three types to match different application use-cases:

• Message Channel: Follows the industry-standard Pub/Sub (publish/subscribe) mode. You can send and receive messages within the channel by subscribing to a channel, and do not need to create the channel in advance. There is no limit to the number of publishers and subscribers in a channel.
• User Channel: Based on the Pub/Sub (publish/subscribe) mode for point-to-point messaging. Users can directly send messages to a specified user without subscribing to a channel. To receive messages, users only need to listen to the message event.
• Stream Channel: Follows a concept similar to the observer pattern in the industry, where users need to create and join a channel before sending and receiving messages. You can create different topics in the channel, and messages are organized and managed through topics.

RtmClient Signaling client instance

subscribeTopic

Description

Signaling provides event notification capabilities for messages and states. By listening for callbacks, you can receive messages and events within subscribed channels. For information on how to add and set event listeners, see Event Listeners.

By calling the subscribeTopic method, the client can subscribe to a message channel and start receiving messages and event notifications within the channel. After successfully calling this method, users who subscribe to the channel and enable the presence event listener can receive a remoteJoinChannel type of the presence event. See Event Listeners.

Method

You can call the subscribeTopic method as follows:

Future<(RtmStatus, SubscribeResult?)> subscribe(
    String channelName,
    {
        bool withMessage = true,
        bool withMetadata = false,
        bool withPresence = true,
        bool withLock = false,
        bool beQuiet = false
    }
);

Basic usage

var (status,response) = await rtmClient.subscribe("myChannel", withPresence:true, beQuiet:true);
if (status.error == true) {
    print(status);
} else {
    print(response);
}

Return value

Calling this method returns a Future<(RtmStatus, SubscribeResult?)> tuple data. Regardless of whether the method call succeeds, the first item in the tuple always returns RtmStatus data type, with the fields defined as follows:

class RtmStatus {
    bool error; // Indicates whether there was an error in this operation.
    String errorCode; // The error code for this operation.
    String operation; // The operation.
    String reason; // A brief description of the error reason for this operation.
}

You can understand the error reason and find the corresponding solution by looking up the error codes in the error codes table.

• If the method call succeeds, the second item of the tuple returns a SubscribeResult type data, defined as follows:

  class SubscribeResult {
      final String channelName; // The channel of the current operation
  }

unsubscribeTopic

Description

If you no longer need to subscribe to a channel, you can call the unsubscribeTopic method to unsubscribe from the channel. After successfully calling this method, users who subscribe to the channel and enable event listeners can receive the remoteLeaveChannel type of the presence event notification. See Event Listeners.

Method

You can call the unsubscribeTopic method as follows:

Future<(RtmStatus, UnsubscribeResult?)> unsubscribe(String channelName);

Basic usage

var (status,response) = await rtmClient.unsubscribe("myChannel");
if (status.error == true) {
    print(status);
} else {
    print(response);
}

Return value

Calling this method returns a Future<(RtmStatus, UnsubscribeResult?)> tuple data. Regardless of whether the method call succeeds, the first item in the tuple always returns RtmStatus data type, with the fields defined as follows:

class RtmStatus {
    bool error; // Indicates whether there was an error in this operation.
    String errorCode; // The error code for this operation.
    String operation; // The operation.
    String reason; // A brief description of the error reason for this operation.
}

You can understand the error reason and find the corresponding solution by looking up the error codes in the error codes table.

• If the method call succeeds, the second item of the tuple will return a UnsubscribeResult type data, defined as follows:

  class UnsubscribeResult {
      final String channelName; // The channel of the current operation
  }

createAgoraRtmClient

Description

Before using a stream channel, you need to call the createAgoraRtmClient method to create a StreamChannel instance. After successfully creating the instance, you can call its relevant methods to implement functions, such as joining the channel, leaving the channel, sending messages in a topic, and subscribing to messages in a topic.

Method

You can call the createAgoraRtmClient method as follows:

Future<(RtmStatus, StreamChannel?)> createStreamChannel(String channelName);

Basic usage

var (status, stChannel) = await rtmClient.createStreamChannel("myStChannel");
if (status.error == true) {
    print(status);
} else {
    print("create Stream Channel Success!");
}

Return value

Calling this method returns a Future<(RtmStatus, StreamChannel?)> tuple data. Regardless of whether the method call succeeds, the first item in the tuple always returns RtmStatus data type, with the fields defined as follows:

class RtmStatus {
    bool error; // Indicates whether there was an error in this operation.
    String errorCode; // The error code for this operation.
    String operation; // The operation.
    String reason; // A brief description of the error reason for this operation.
}

You can understand the error reason and find the corresponding solution by looking up the error codes in the error codes table.

• If the method call succeeds, the second item of the tuple will return a StreamChannel instance object, which can be used to call related API of StreamChannel.

StreamChannel Stream channel instance

joinTopic

Description

After successfully creating a stream channel, you can call the joinTopic method to join the stream channel.

Once you join the channel, you can implement channel-related functions. At this point, users who subscribe to the channel and add event listeners can receive the following event notifications:

• For the local user:
  • The snapshot type of the presence event.
  • The snapshot type of the topic event.
• For remote users: The remoteJoinChannel type of the presence event.

Method

You can call the joinTopic method as follows:

Future<(RtmStatus, JoinResult?)> join({
    String? token,
    bool withMetadata = false,
    bool withPresence = true,
    bool withLock = false,
    bool beQuiet = false
    }
);

Basic usage

var (status,response) = await stChannel.join(token:"myToken", withPresence:true);
if (status.error == true) {
    print(status);
} else {
    print(response);
}

Return value

Calling this method returns a Future<(RtmStatus, JoinResult?)> tuple data. Regardless of whether the method call succeeds, the first item in the tuple always returns RtmStatus data type, with the fields defined as follows:

class RtmStatus {
    bool error; // Indicates whether there was an error in this operation.
    String errorCode; // The error code for this operation.
    String operation; // The operation.
    String reason; // A brief description of the error reason for this operation.
}

You can understand the error reason and find the corresponding solution by looking up the error codes in the error codes table.

• If the method call succeeds, the second item of the tuple will return a JoinResult type data, defined as follows:

  class JoinResult {
      final String channelName; // The channel of the current operation
      final String userId; // The user ID of the current operation
  }

leaveTopic

Description

If you no longer need to stay in a channel, you can call the leaveTopic method to leave the channel. After leaving the channel, you can no longer receive any messages, states, or event notifications from this channel. At the same time, you can no loger be the topic publisher or subscriber of all topics. If you want to restore your previous publisher role and subscribing relationship, you need to call joinTopic, joinTopic and subscribeTopic methods in order.

After successfully leaving the channel, remote users in the channel can receive the remoteLeaveChannel type of the presence event notification. For details, see Event Listeners.

Method

You can call the leaveTopic method as follows:

Future<(RtmStatus, LeaveResult?)> leave();

Basic usage

var (status,response) = await stChannel.leave();
if (status.error == true) {
    print(status);
} else {
    print(response);
}

Return value

Calling this method returns a Future<(RtmStatus, LeaveResult?)> tuple data. Regardless of whether the method call succeeds, the first item in the tuple always returns RtmStatus data type, with the fields defined as follows:

class RtmStatus {
    bool error; // Indicates whether there was an error in this operation.
    String errorCode; // The error code for this operation.
    String operation; // The operation.
    String reason; // A brief description of the error reason for this operation.
}

You can understand the error reason and find the corresponding solution by looking up the error codes in the error codes table.

• If the method call succeeds, the second item of the tuple will return a LeaveResult type data, defined as follows:

  class LeaveResult {
      final String channelName; // The channel of the current operation
      final String userId; // The user ID of the current operation
  }

releaseLock

Description

If you no longer need a channel, you can call the releaseLock method to destroy the corresponding stream channel instance and release resources. Calling the releaseLock method does not destroy the stream channel, and it can be re-joined later by calling createAgoraRtmClient and joinTopic again.

Method

You can call the releaseLock method as follows:

Future<RtmStatus> release();

Basic usage

var status = await stChannel.release();
if (status.error == true) {
    print(status);
} else {
    print(response);
}

Return value

Regardless of whether you call this method successfully, this method returns an RtmStatus type data, with the following field definitions:

class RtmStatus {
    bool error; // Whether there is an error in this operation.
    String errorCode; // The error code for this operation.
    String operation; // The API of this operation.
    String reason; // A brief description of the reason for the error in this operation.
}

You can refer to the errorCode field in the Error Codes to understand the cause of the error and find the corresponding solution.

Topics

Topic is a data stream management mechanism in stream channels. Users can use topics to subscribe to and distribute data streams, as well as notify events in data streams in stream channels.

StreamChannel Stream channel instance

joinTopic

Description

The purpose of joining a topic is to register as one of the message publishers for the topic, so that the user can send messages in the topic. This operation does not affect whether or not the user becomes a subscriber to the topic.

After successfully joining a topic, users who subscribe to that topic and add event listeners can receive the remoteJoinTopic type of the topic event notification. For details, see Event Listeners.

Method

You can call the joinTopic method as follows:

Future<(RtmStatus, JoinTopicResult?)> joinTopic(
    String topic,
    {
        RtmMessageQos qos = RtmMessageQos.unordered,
        RtmMessagePriority priority = RtmMessagePriority.normal,
        String? meta = '',
        bool? syncWithMedia = false
    }
);

Basic usage

var (status,response) = await stChannel.joinTopic("myTopic");

if (status.error == true) {
    print(status);
} else {
    print(response);
}

Return value

Calling this method returns a Future<(RtmStatus, JoinTopicResult?)> tuple data. Regardless of whether the method call succeeds, the first item in the tuple always returns RtmStatus data type, with the fields defined as follows:

class RtmStatus {
    bool error; // Indicates whether there was an error in this operation.
    String errorCode; // The error code for this operation.
    String operation; // The operation.
    String reason; // A brief description of the error reason for this operation.
}

You can understand the error reason and find the corresponding solution by looking up the error codes in the error codes table.

• If the method call succeeds, the second item in the tuple returns a JoinTopicResult object, defined as follows:

  class JoinTopicResult {
      final String channelName; // Channel name
      final String userId; // Current userId
      final String topic; // Topic name
      final String meta; // Additional metadata
  }

publishTextMessage

Description

Use the publishTextMessage method to send string messages to a topic. Users who have subscribed to the topic and the message publisher in the channel can receive the message within 100 milliseconds. Before calling the publishTextMessage method, users need to join the stream channel, and then register as a message publisher for that topic by calling the joinTopic method.

The messages sent by users are encrypted with TLS during transmission, and data link encryption is enabled by default and cannot be disabled. To achieve a higher level of data security, users can also enable client encryption during initialization. For details, see Setup.

Method

You can call the publishTextMessage method as follows:

Future<(RtmStatus, PublishTopicMessageResult?)> publishTextMessage(
    String topic,
    String message,
    {
        int sendTs = 0,
        String? customType
    }
);

Basic usage

var message = {
    type: "poll",
    question: "Which option is right?",
    answers: {
        A: "Apple",
        B: "Banana",
        C: "Blackberry"
    },
    sender: "Max"
}

var payload = json.encode(message);
var (status,response) =
    await stChannel.publishTextMessage("myTopic", payload, customType:"poll");
if (status.error == true) {
    print(status);
} else {
    print(response);
}

Return value

Calling this method returns a Future<(RtmStatus, PublishTopicMessageResult?)> tuple data. Regardless of whether the method call succeeds, the first item in the tuple always returns RtmStatus data type, with the fields defined as follows:

class RtmStatus {
    bool error; // Indicates whether there was an error in this operation.
    String errorCode; // The error code for this operation.
    String operation; // The operation.
    String reason; // A brief description of the error reason for this operation.
}

You can understand the error reason and find the corresponding solution by looking up the error codes in the error codes table.

• If the method call succeeds, the second item in the tuple returns a PublishTopicMessageResult object, defined as follows:

  class PublishTopicMessageResult {
      final String channelName; // Channel name
      final String topic; // Topic name
  }

publishBinaryMessage

Description

Use the publishBinaryMessage method to send binary messages to a topic. Users who have subscribed to the topic and the message publisher in the channel can receive the message within 100 milliseconds. Before calling the publishBinaryMessage method, users need to join the stream channel, and then register as a message publisher for that topic by calling the joinTopic method.

The messages sent by users are encrypted with TLS during transmission, and data link encryption is enabled by default and cannot be disabled. To achieve a higher level of data security, users can also enable client encryption during initialization. For details, see Setup.

Method

You can call the publishBinaryMessage method as follows:

Future<(RtmStatus, PublishTopicMessageResult?)> publishBinaryMessage(
    String topic,
    Uint8List message,
    {
        int sendTs = 0,
        String? customType
    }
);

Basic usage

var payload = [1,2,3,4];
var (status,response) = await stChannel.publishBinaryMessage(
      "myTopic",
      payload,
      customType:"UINT8LIST"
    );
if (status.error == true) {
    print(status);
} else {
    print(response);
}

Return value

Calling this method returns a Future<(RtmStatus, PublishTopicMessageResult?)> tuple data. Regardless of whether the method call succeeds, the first item in the tuple always returns RtmStatus data type, with the fields defined as follows:

class RtmStatus {
    bool error; // Indicates whether there was an error in this operation.
    String errorCode; // The error code for this operation.
    String operation; // The operation.
    String reason; // A brief description of the error reason for this operation.
}

You can understand the error reason and find the corresponding solution by looking up the error codes in the error codes table.

• If the method call succeeds, the second item in the tuple returns a PublishTopicMessageResult object, defined as follows:

  class PublishTopicMessageResult {
      final String channelName; // Channel name
      final String topic; // Topic name
  }

leaveTopic

Description

When you no longer need to publish messages to a topic, to release resources, you can call the leaveTopic method to unregister as a message publisher for that topic. This method does not affect whether or not you subscribe to that topic or any other operations performed by other users on that topic.

After successfully calling this method, users who subscribe to the channel and enable event listeners can receive the remoteLeaveTopic type of the topic event notification. See Event Listeners.

Method

You can call the leaveTopic method as follows:

Future<(RtmStatus, LeaveTopicResult?)> leaveTopic(String topic);

Basic usage

var (status,response) = await stChannel.leaveTopic("myTopic");

if (status.error == true) {
    print(status);
} else {
    print(response);
}

Return value

Calling this method returns a Future<(RtmStatus, LeaveTopicResult?)> tuple data. Regardless of whether the method call succeeds, the first item in the tuple always returns RtmStatus data type, with the fields defined as follows:

class RtmStatus {
    bool error; // Indicates whether there was an error in this operation.
    String errorCode; // The error code for this operation.
    String operation; // The operation.
    String reason; // A brief description of the error reason for this operation.
}

You can understand the error reason and find the corresponding solution by looking up the error codes in the error codes table.

• If the method call succeeds, the second item in the tuple returns a LeaveTopicResult object, defined as follows:

  class LeaveTopicResult {
      final String channelName; // Channel name
      final String userId; // User ID
      final String topic; // Topic name
      final String meta; // Additional metadata
  }

subscribeTopic

Description

After joining the channel, you can call the subscribeTopic method to subscribe to the message publisher of the topic in the channel.

subscribeTopic is an incremental method. For example, if you call this method for the first time with a subscribing list of [UserA, UserB], and then call it again with a subscribing list of [UserB, UserC], the final successful subscribing result is [UserA, UserB, UserC].

A user can subscribe to a maximum of 50 topics in each channel, and a maximum of 64 message publishers in each topic. See API usage restrictions.

Method

You can call the subscribeTopic method as follows:

Future<(RtmStatus, SubscribeTopicResult?)> subscribeTopic(
    String topic,
    {
        List<String> users = const []
    }
);

Basic usage

Example 1: Subscribe to the specified message publisher in the topic.

var userList = ["Tony","Lily"];
var (status,response) = await stChannel.subscribeTopic("myTopic", users:userList);
if (status.error == true) {
    print(status);
} else {
    print(response);
}

Example 2: Randomly subscribe to 64 message publishers in the topic.

var (status,response) = await stChannel.subscribeTopic("myTopic");
if (status.error == true) {
    print(status);
} else {
    print(response);
}

Return value

Calling this method returns a Future<(RtmStatus, SubscribeTopicResult?)> tuple data. Regardless of whether the method call succeeds, the first item in the tuple always returns RtmStatus data type, with the fields defined as follows:

class RtmStatus {
    bool error; // Indicates whether there was an error in this operation.
    String errorCode; // The error code for this operation.
    String operation; // The operation.
    String reason; // A brief description of the error reason for this operation.
}

You can understand the error reason and find the corresponding solution by looking up the error codes in the error codes table.

• If the method call succeeds, the second item in the tuple returns a SubscribeTopicResult object, defined as follows:

  class SubscribeTopicResult {
      final String channelName; // Channel name
      required this.userId; // User ID
      final String topic; // Topic name
      final List<String> succeedUsers; // List of successfully subscribed users
      final List<String> failedUsers; // List of users that failed to subscribe
  }

unsubscribeTopic

Description

If you are no longer interested in a specified topic, or no longer need to subscribe to one or more message publishers in the topic, you can call the unsubscribeTopic method to unsubscribe from the topic or the specified message publishers in the topic.

Method

You can call the unsubscribeTopic method as follows:

Future<(RtmStatus, UnsubscribeTopicResult?)> unsubscribeTopic(
    String topic,
    {
        List<String> users = const []
    }
);

Basic usage

Example 1: Unsubscribe the specified message publisher in the topic

var userList = ["Tony","Lily"];
var (status,response) = await stChannel.unsubscribeTopic("myTopic", users:userList);
if (status.error == true) {
    print(status);
} else {
    print(response);
}

Example 2: Unsubscribe from all message publishers in the topic

var (status,response) = await stChannel.unsubscribeTopic("myTopic");
if (status.error == true) {
    print(status);
} else {
    print(response);
}

Return value

Calling this method returns a Future<(RtmStatus, UnsubscribeTopicResult?)> tuple data. Regardless of whether the method call succeeds, the first item in the tuple always returns RtmStatus data type, with the fields defined as follows:

class RtmStatus {
    bool error; // Indicates whether there was an error in this operation.
    String errorCode; // The error code for this operation.
    String operation; // The operation.
    String reason; // A brief description of the error reason for this operation.
}

You can understand the error reason and find the corresponding solution by looking up the error codes in the error codes table.

• If the method call succeeds, the second item in the tuple returns a UnsubscribeTopicResult object, defined as follows:

  class UnsubscribeTopicResult {
      final String channelName; // Channel name
      final String topic; // Topic name
  }

getSubscribedUserList

Description

If you need to get the list of publishers that you subscribe to in a specific topic, you can call the getSubscribedUserList method.

Method

You can call the getSubscribedUserList method as follows:

Future<(RtmStatus, GetSubscribedUserListResult?)> getSubscribedUserList(String topic);

Basic usage

var (status,response) = await stChannel.getSubscribedUserList("myTopic");
if (status.error == true) {
    print(status);
} else {
    print(response);
}

Return value

Calling this method returns a Future<(RtmStatus, GetSubscribedUserListResult?)> tuple data. Regardless of whether the method call succeeds, the first item in the tuple always returns RtmStatus data type, with the fields defined as follows:

class RtmStatus {
    bool error; // Indicates whether there was an error in this operation.
    String errorCode; // The error code for this operation.
    String operation; // The operation.
    String reason; // A brief description of the error reason for this operation.
}

You can understand the error reason and find the corresponding solution by looking up the error codes in the error codes table.

• If the method call succeeds, the second item in the tuple returns a GetSubscribedUserListResult object, defined as follows:

  class GetSubscribedUserListResult {
      final String channelName; // Channel name
      final String topic; // Topic name
      final UserList users; // List of successfully subscribed users
  }

Messages

Sending and receiving messages is the most basic function of the Signaling service. Any message sent by the Signaling server can be delivered to any online subscribing user within 100 ms. Depending on your business requirements, you can send messages to one user only or broadcast messages to multiple users.

Signaling offers 3 types of channels: message channels, user channels, and stream channels. These channel types have the following differences in how messages are transmitted and methods are called:

• Message Channel: The real-time channel. Messages are transmitted through the channel, and the channel is highly scalable. Local users can call the publishTextMessage method, set the channelType parameter to message, and set the channelName parameter to the channel name to send messages in the channel. The remote users can call the subscribeTopic method to subscribe to the channel and receive messages.
• User Channel: The real-time channel. Messages are transmitted to the specified user. Local users can call the publishTextMessage method, set the channelType parameter to user, and set the channelName parameter to the user ID to send messages to the specified user. The specified remote users receive messages through the message event notifications.
• Stream Channel: The streaming transmission channel. Messages are transmitted through the topic. Users need to join a channel first, and then join a topic. Local users can call the publishTextMessage method to send messages in the topic, and remote users can call the subscribeTopic method to subscribe to the topic and receive messages.

This page introduces how to send and receive messages in a message channel or a user channel.

RtmClient Signaling client instance

publishTextMessage

Description

You can directly call the publishTextMessage method to send string messages to all online users subscribed to this channel. Even if you do not subscribe to the channel, you can still send messages in the channel.

After successfully calling this method, the SDK triggers a message event notification. Users who subscribe to the channel and enabled the event listener can receive this event notification. For details, see Event Listeners.

Method

You can call the publishTextMessage method as follows:

Future<(RtmStatus, PublishResult?)> publish(
    String channelName,
    String message,
    {
        RtmChannelType channelType = RtmChannelType.message,
        String? customType
    }
);

Basic usage

Example 1: Send string messages to a specified message channel.

var message = {
    type: "poll",
    question: "Which option is right?",
    answers: {
        A: "Apple",
        B: "Banana",
        C: "Blackberry"
    },
    sender: "Max"
}

var payload = json.encode(message);
var (status,response) =
    await rtmClient.publish("myChannel", payload, channelType:RtmChannelType.message, customType:"poll");
if (status.error == true) {
    print(status);
} else {
    print(response);
}

Example 2: Send string messages to a specified user channel.

var message = {
    type: "chatInvite",
    channel: "this is the channel you are being invited to",
    message: "Hi Tony, welcome to the team!"
}

var payload = json.encode(message);
var (status,response) =
    await rtmClient.publish("userId", payload, channelType:RtmChannelType.user, customType:"chatInvite");
if (status.error == true) {
    print(status);
} else {
    print(response);
}

Return Values

Calling this method returns a Future<(RtmStatus, PublishResult?)> tuple data. Regardless of whether the method call succeeds, the first item in the tuple always returns RtmStatus data type, with the fields defined as follows:

class RtmStatus {
    bool error; // Indicates whether there was an error in this operation.
    String errorCode; // The error code for this operation.
    String operation; // The operation.
    String reason; // A brief description of the error reason for this operation.
}

You can understand the error reason and find the corresponding solution by looking up the error codes in the error codes table.

• If the method call succeeds, the second item in the tuple returns a PublishResult type, which currently does not contain any fields.

publishBinaryMessage

Description

You can directly call the publishBinaryMessage method to send binary messages to all online users subscribed to this channel. Even if you do not subscribe to the channel, you can still send messages in the channel.

After successfully calling this method, the SDK triggers a message event notification. Users who subscribe to the channel and enabled the event listener can receive this event notification. For details, see Event Listeners.

Method

You can call the publishBinaryMessage method as follows:

Future<PublishResult> publishBinaryMessage(
    String channelName,
    Uint8List message,
    {
        RtmChannelType channelType = RtmChannelType.message,
        String? customType
    }
);

Basic usage

Example 1: Send binary messages to a specified message channel.

var payload = [1,2,3,4];
var (status,response) = await rtmClient.publishBinaryMessage(
      "myChannel",
      payload,
      channelType:RtmChannelType.message,
      customType:"UINT8LIST"
    );
if (status.error == true) {
    print(status);
} else {
    print(response);
}

Example 2: Send binary messages to a specified user channel.

var payload = [1,2,3,4];
var (status,response) = await rtmClient.publishBinaryMessage(
      "myChannel",
      payload,
      channelType:RtmChannelType.message,
      customType:"UINT8LIST"
    );
if (status.error == true) {
    print(status);
} else {
    print(response);
}

Return Values

Calling this method returns a Future<(RtmStatus, PublishResult?)> tuple data. Regardless of whether the method call succeeds, the first item in the tuple always returns RtmStatus data type, with the fields defined as follows:

class RtmStatus {
    bool error; // Indicates whether there was an error in this operation.
    String errorCode; // The error code for this operation.
    String operation; // The operation.
    String reason; // A brief description of the error reason for this operation.
}

You can understand the error reason and find the corresponding solution by looking up the error codes in the error codes table.

• If the method call succeeds, the second item in the tuple returns a PublishResult type, which currently does not contain any fields.

Receive

Signaling provides event notifications for messages, states, and event changes. By listening for callbacks, you can receive messages and events within subscribed channels. The example code below shows how to receive messages from the user channel:

rtm.addListener(
    message: (event) {
        print('Received a message from $`event.channelName`');
        print('Message Type is $`event.messageType`');
        print('Message : $`event.message`');
      }
    );

// convert Uint8List to String. ! means forced conversion
String message = utf8.decode(event.message!);

For information on how to add and set event listeners, see Event Listeners.

Presence

The presence feature provides the ability to monitor user online, offline, and user historical state change. With the Presence feature, you can get real-time access to the following information:

• Real-time event notification when a user joins or leaves a specified channel.
• Real-time event notification when the custom temporary user state changes.
• Query which channels a specified user has joined or subscribed to.
• Query which users have joined a specified channel and their temporary user state data.

RtmPresence Presence instance

getOnlineUsers

Description

By calling the getOnlineUsers method, you can query real-time information about the number of online users, the list of online users, and the temporary state of online users in a specified channel.

Method

You can call the getOnlineUsers method as follows:

Future<(RtmStatus, WhoNowResult?) whoNow(
    String channelName,
    RtmChannelType channelType,
    {
        bool includeUserId = true,
        bool includeState = false,
        String? page = ''
    }
);

Basic usage

var (status, response) = await rtmClient.getPresence.getOnlineUsers(
    "myChannel",
    RtmChannelType.message,
    includeUserId: true,
    includeState: true,
    page: "myBookMark"
);

if (status.error == true) {
    print(status);
} else {
    print(response);
}

Return Value

Calling this method returns a Future<(RtmStatus, GetOnlineUsersResult?)> tuple data. Regardless of whether the method call succeeds, the first item in the tuple always returns RtmStatus data type, with the fields defined as follows:

class RtmStatus {
    bool error; // Indicates whether there was an error in this operation.
    String errorCode; // The error code for this operation.
    String operation; // The operation.
    String reason; // A brief description of the error reason for this operation.
}

You can understand the error reason and find the corresponding solution by looking up the error codes in the error codes table.

• If the method call succeeds, the second item in the tuple returns a GetOnlineUsersResult type data, which is defined as follows:

  class GetOnlineUsersResult {
      final List<UserState> userStateList; // List of user temporary states
      final int count; // Length of the user temporary state list
      final String nextPage; // Bookmark for the next page of data
  }

getUserChannels

Description

In use-cases such as statistic analytics and debugging, you may need to know all the channels that a specified user has subscribed to or joined. Call the getUserChannels method to get the list of channels where the specified user is in real time.

Method

You can call the getUserChannels method as follows:

Future<(RtmStatus, GetUserChannelsResult?)> getUserChannels(String userId);

Basic usage

var (status, response) = await rtmClient.getPresence.getUserChannels("Tony");

if (status.error == true) {
    print(status);
} else {
    print(response);
}

Return Value

Calling this method returns a Future<(RtmStatus, GetUserChannelsResult?)> tuple data. Regardless of whether the method call succeeds, the first item in the tuple always returns RtmStatus data type, with the fields defined as follows:

class RtmStatus {
    bool error; // Indicates whether there was an error in this operation.
    String errorCode; // The error code for this operation.
    String operation; // The operation.
    String reason; // A brief description of the error reason for this operation.
}

You can understand the error reason and find the corresponding solution by looking up the error codes in the error codes table.

• If the method call succeeds, the second item in the tuple returns a GetUserChannelsResult type data, which is defined as follows:

  class GetUserChannelsResult {
      final List<ChannelInfo> channels; // List of channel information
      final int count; // Length of the user temporary state list
  }

setState

Description

To meet different requirements in different business use-cases for setting user states, Signaling provides the setState method to customize the temporary user state. Users can add custom states such as scores, game state, location, mood, and hosting state for themselves.

After successful setup, as long as the user keeps subscribing to the channel and stays online, the custom states can persist in the channel. The setState method sets the temporary user state, and the state disappears when the user leaves the channel. If you need to restore user states when rejoining a channel, you need to cache the data locally in real time. If you want to permanently save user states, Agora recommends you use the setUserMetadata method of the storage function instead.

If a user modifies the temporary user state, Signaling triggers the remoteStateChanged type of the presence event in real time. You can receive the event by subscribing to the channel and configuring the corresponding property.

Method

You can call the setState method as follows:

Future<(RtmStatus, SetStateResult?)> setState(
    String channelName,
    RtmChannelType channelType,
    Map<String, String> state
);

Basic usage

var states = {"Name":"Tony","Mode":"Happy"};
var (status, response) = await rtmClient.getPresence.setState(
    "myChannel",
    RtmChannelType.message,
    states
);

if (status.error == true) {
    print(status);
} else {
    print(response);
}

Return Value

Calling this method returns a Future<(RtmStatus, SetStateResult?)> tuple data. Regardless of whether the method call succeeds, the first item in the tuple always returns RtmStatus data type, with the fields defined as follows:

class RtmStatus {
    bool error; // Indicates whether there was an error in this operation.
    String errorCode; // The error code for this operation.
    String operation; // The operation.
    String reason; // A brief description of the error reason for this operation.
}

You can understand the error reason and find the corresponding solution by looking up the error codes in the error codes table.

• If the method call succeeds, the second item in the tuple returns a SetStateResult type data, which currently does not contain any fields.

getState

Description

To get the temporary user state of a specified user in the channel, you can use the getState method.

Method

You can call the getState method as follows:

Future<(RtmStatus, GetStateResult?)> getState(
    String channelName,
    RtmChannelType channelType,
    String userId
);

Basic usage

var (state, response) = await rtmClient.getPresence.getState(
    "myChannel",
    RtmChannelType.message,
    "Tony"
);

if (status.error == true) {
    print(status);
} else {
    print(response);
}

Return Value

Calling this method returns a Future<(RtmStatus, GetStateResult?)> tuple data. Regardless of whether the method call succeeds, the first item in the tuple always returns RtmStatus data type, with the fields defined as follows:

class RtmStatus {
    bool error; // Indicates whether there was an error in this operation.
    String errorCode; // The error code for this operation.
    String operation; // The operation.
    String reason; // A brief description of the error reason for this operation.
}

You can understand the error reason and find the corresponding solution by looking up the error codes in the error codes table.

• If the method call succeeds, the second item in the tuple returns a GetStateResult type data, which is defined as follows:

  class GetStateResult {
      final UserState state; // User temporary state data
  }

removeState

Description

When a temporary user state is no longer needed, you can call the removeState method to remove one or more of your temporary states. When the user state is removed, the user who has subscribed to the channel and enabled the presence event listener receives the remoteStateChanged type of presence event notification. See Event Listeners.

Method

You can call the removeState method as follows:

Future<(RtmStatus, RemoveStateResult?)> removeState(
    String channelName,
    RtmChannelType channelType,
    {
        List<String> states = const []
    }
);

Basic usage

var states = ["Mode", "Position"];
var (status, response) = await rtmClient.getPresence.removeState(
    "channelName",
    RtmChannelType.message,
    states
);

if (status.error == true) {
    print(status);
} else {
    print(response);
}

Return Value

Calling this method returns a Future<(RtmStatus, RemoveStateResult?)> tuple data. Regardless of whether the method call succeeds, the first item in the tuple always returns RtmStatus data type, with the fields defined as follows:

class RtmStatus {
    bool error; // Indicates whether there was an error in this operation.
    String errorCode; // The error code for this operation.
    String operation; // The operation.
    String reason; // A brief description of the error reason for this operation.
}

You can understand the error reason and find the corresponding solution by looking up the error codes in the error codes table.

• If the method call succeeds, the second item in the tuple returns a RemoveStateResult type data, which currently does not contain any fields.

Storage

The storage feature provides a dynamic database mechanism that allows developers to dynamically set, store, update, and delete data such as channel metadata and user metadata.

RtmStorage Storage instance

setChannelMetadata

Description

The setChannelMetadata method sets metadata for a message channel or stream channel. A channel can only have one set of metadata, but each set of metadata can have one or more metadata items. If you call this method multiple times, the SDK retrieves the key of the metadata items in turn and apply settings according to the following rules:

• If you set metadata with different key, the SDK adds each set of metadata in sequence according to the order of the method calls.
• If you set metadata with the same key, the value of the last setting overwrites the previous one.

Channel metadata also introduces the version control logic CAS (Compare And Set). This method provides two independent version control fields, and you can set one or more of them according to your actual business use-case:

• Enable version number verification for the entire set of channel metadata by setting the majorRevision property.
• Enable version number verification for a single metadata item by setting the revision property in the MetadataItem class.

When setting channel metadata or metadata items, you can control whether to enable version number verification by specifying the revision property:

• The default value of the revision property is -1, indicating that this method call does not perform any CAS verification. If the channel metadata or metadata item already exists, the latest value overwrites the previous one. If the channel metadata or metadata item does not exist, the SDK creates it.
• If the revision property is a positive integer, this method call performs the CAS verification. If the channel metadata or metadata item already exists, the SDK updates the corresponding value after the version number verification succeeds. If the channel metadata or metadata item does not exist, the SDK returns the error code.

After successfully setting channel metadata, users who subscribe to the channel and enable event listeners can receive the channel type of the storage event notification. See Event listeners.

Method

You can call the setChannelMetadata method as follows:

Future<(RtmStatus, SetChannelMetadataResult?)> setChannelMetadata(
    String channelName,
    RtmChannelType channelType,
    List<MetadataItem> metadata,
    {
        int majorRevision = -1,
        bool recordTs = false,
        bool recordUserId = false,
        String lockName = ''
    }
);

The MetadataOptions data type contains the following properties:

Basic usage

var item1 = MetadataItem(
  key: 'Apple',
  value: '100',
  revision: 174298200
);

var item2 = MetadataItem(
  key: 'Banana',
  value: '200',
  revision: 174298100
);

var metadata = [item1,item2];

var (status,response) = await rtmClient.getStorage.setChannelMetadata(
    "myChannel",
    RtmChannelType.message,
    metadata,
    majorRevision: 174298222,
    recordTs: true,
    recordUserId: true,
    lockName: "myLock"
)

if (status.error == true) {
    print(status);
} else {
    print(response);
}

Returns

Calling this method returns a Future<(RtmStatus, SetChannelMetadataResult?)> tuple data. Regardless of whether the method call succeeds, the first item in the tuple always returns RtmStatus data type, with the fields defined as follows:

class RtmStatus {
    bool error; // Indicates whether there was an error in this operation.
    String errorCode; // The error code for this operation.
    String operation; // The operation.
    String reason; // A brief description of the error reason for this operation.
}

You can understand the error reason and find the corresponding solution by looking up the error codes in the error codes table.

• If the method call is successful, the second item of the tuple returns a SetChannelMetadataResult type data, defined as follows:

  class SetChannelMetadataResult {
      final String channelName; // The channel being operated on
      final RtmChannelType channelType; // The type of the channel being operated on
  }

getChannelMetadata

Description

The getChannelMetadata method can get the metadata of the specified channel.

Method

You can call the getChannelMetadata method as follows:

Future<(RtmStatus, GetChannelMetadataResult?)> getChannelMetadata(
    String channelName,
    RtmChannelType channelType
);

Basic usage

var (status,response) = await rtmClient.getStorage.getChannelMetadata(
    "myChannel",
    RtmChannelType.message,
)

if (status.error == true) {
    print(status);
} else {
    print(response);
}

Returns

Calling this method returns a Future<(RtmStatus, GetChannelMetadataResult?)> tuple data. Regardless of whether the method call succeeds, the first item in the tuple always returns RtmStatus data type, with the fields defined as follows:

class RtmStatus {
    bool error; // Indicates whether there was an error in this operation.
    String errorCode; // The error code for this operation.
    String operation; // The operation.
    String reason; // A brief description of the error reason for this operation.
}

You can understand the error reason and find the corresponding solution by looking up the error codes in the error codes table.

• If the method call is successful, the second item of the tuple returns a GetChannelMetadataResult type data, defined as follows:

  class GetChannelMetadataResult {
      final String channelName; // The channel being operated on
      final RtmChannelType channelType; // The type of the channel being operated on
      final Metadata data; // Metadata data
  }

removeChannelMetadata

Description

The removeChannelMetadata method can remove channel metadata or metadata items.

When removing channel metadata or metadata items, you can control whether to enable version number verification by specifying the revision property:

• The default value of the revision property is -1, indicating that this method call does not perform any CAS verification. If the channel metadata or metadata item already exists, the SDK removes it. If the channel metadata or metadata item does not exist, the SDK returns an error code.
• If the revision property is a positive integer, this method call performs the CAS verification. If the channel metadata or metadata item already exists, the SDK removes the corresponding value after the version number verification succeeds. If the channel metadata or metadata item does not exist, the SDK returns the error code.

After successfully removing channel metadata or metadata items, users who subscribe to the channel and enable event listeners can receive the channel type of the storage event notification. See Event listeners.

Method

You can call the removeChannelMetadata method as follows:

Future<(RtmStatus, RemoveChannelMetadataResult?)> removeChannelMetadata(
    String channelName,
    RtmChannelType channelType,
    {
        int majorRevision = -1,
        List<MetadataItem> metadata = const [],
        bool recordTs = false,
        bool recordUserId = false,
        String lockName = ''
    }
);

Basic usage

var item1 = MetadataItem(
  key: 'Apple',
  revision: 174298200
);

var item2 = MetadataItem(
  key: 'Banana',
  revision: 174298100
);

var metadata = [item1,item2];

var (status,response) = await rtmClient.getStorage.removeChannelMetadata(
    "myChannel",
    RtmChannelType.message,
    metadata,
    majorRevision: 174298222,
    recordTs: true,
    recordUserId: true,
    lockName: "myLock"
);

if (status.error == true) {
    print(status);
} else {
    print(response);
}

Returns

Calling this method returns a Future<(RtmStatus, RemoveChannelMetadataResult?)> tuple data. Regardless of whether the method call succeeds, the first item in the tuple always returns RtmStatus data type, with the fields defined as follows: