Event listeners

// Handle message event
rtm.addEventListener("message", event => {
    const channelType = event.channelType;      // The channel type, 'STREAM' 'MESSAGE', or 'USER'
    const channelName = event.channelName;      // The name of the channel that this message came from
    const topic = event.topicName;              // (Stream channel only) The name of the topic that this message came from
    const messageType = event.messageType;      // The message type, 'STRING' or 'BINARY'
    const customType = event.customType;        // User defined type
    const publisher = event.publisher;          // The message publisher
    const message = event.message;              // The message payload
    const timestamp = event.timestamp;          // Event timestamp
});
// Handle presence event
rtm.addEventListener("presence", event => {
    const action = event.eventType;             // The event type, should be one of 'SNAPSHOT', 'INTERVAL', 'JOIN', 'LEAVE', 'TIMEOUT、'STATE_CHANGED', 'OUT_OF_SERVICE'.
    const channelType = event.channelType;      // The channel type, should be "STREAM", "MESSAGE" or "USER"
    const channelName = event.channelName;      // The name of the channel this event came from
    const publisher = event.publisher;          // The user who triggered this event
    const states = event.stateChanged;          // User state payload, only for the stateChanged event
    const interval = event.interval;            // Interval payload, only for the interval event
    const snapshot = event.snapshot;            // Snapshot payload, only for the snapshot event
    const timestamp = event.timestamp;          // Event timestamp
});
// Handle topic event
rtm.addEventListener("topic", event => {
    const action = event.evenType;              // The event type, should be one of 'SNAPSHOT', 'JOIN', 'LEAVE'.
    const channelName = event.channelName;      // The name of the channel this event came from
    const publisher = event.userId;             // The user who triggered this event
    const topicInfos = event.topicInfos;        // Topic information payload
    const totalTopics = event.totalTopics;      // The number of topics
    const timestamp = event.timestamp;          // Event timestamp
});
// Handle storage event
rtm.addEventListener("storage", event => {
    const channelType = event.channelType;      // The channel type, should be "STREAM", "MESSAGE" or "USER"
    const channelName = event.channelName;      // The name of the channel this event came from
    const publisher = event.publisher;          // The user who triggered this event
    const storageType = event.storageType;      // The storage type, should be 'USER' or 'CHANNEL'
    const action = event.eventType;             // The event type, should be one of 'SNAPSHOT', 'SET', 'REMOVE', 'UPDATE', or 'NONE'
    const data = event.data;                    // 'USER_METADATA' or 'CHANNEL_METADATA' payload
    const timestamp = event.timestamp;          // Event timestamp
});
// Handle lock event
rtm.addEventListener("lock", event => {
    const channelType = event.channelType;      // The channel type, should be "STREAM", "MESSAGE" or "USER"
    const channelName = event.channelName;      // The name of the channel this event came from
    const publisher = event.publisher;          // The user who triggered this event
    const action = event.evenType;              // The event type, should be one of 'SET', 'REMOVED', 'ACQUIRED', 'RELEASED', 'EXPIRED', 'SNAPSHOT'
    const lockName = event.lockName;            // The name of the lock it affects
    const ttl = event.ttl;                      // The ttl of this lock
    const snapshot = event.snapshot;            // Snapshot payload
    const owner = event.owner;                  // The owner of this lock
    const timestamp = event.timestamp;          // Event timestamp
});
// Handle connection state change event
rtm.addEventListener("status", event => {
    const currentState = event.state;           // Current connection state
    const changeReason = event.reason;          // Why the event was triggered
    const timestamp = event.timestamp;          // Event timestamp
});
// Handle link state change event
rtm.addEventListener('linkState', event => {
    const currentState = event.currentState;
    const previousState = event.previousState;
    const serviceType = event.serviceType;
    const operation = event.operation;
    const reason = event.reason;
    const affectedChannels = event.affectedChannels;
    const timestamp = event.timestamp;
    const isResumed = event.isResumed;
});
// Handle token privilege will expire event
rtm.addEventListener("tokenPrivilegeWillExpire", (channelName) => {
    const channelName = channelName;            // The channel for which the token will expire
});

const messageReceived = (event) => {
    const channelType = event.channelType;      // The channel type, should be 'STREAM' or 'MESSAGE'
    const channelName = event.channelName;      // The name of the channel this event came from
    const topic = event.topicName;              // The message topic, valid when the channelType is "STREAM".
    const messageType = event.messageType;      // The message type, should be "STRING" or "BINARY" .
    const customType = event.customType;        // User defined type
    const publisher = event.publisher;          // Message publisher
    const message = event.message;              // Message payload
    const timestamp = event.timestamp;          // Event timestamp
    // Your business processing logic program
};

// Add Event Listener
rtm.addEventListener("message", messageReceived);

// Remove Event Listener
rtm.removeEventListener("message", messageReceived);

rtmClient.addListener(
    // Handle message event
    message: (MessageEvent event) {
        const channelType = event.channelType;      // The channel type, 'STREAM' 'MESSAGE', or 'USER'
        const channelName = event.channelName;      // The name of the channel that this message came from
        const topicName = event.channelTopic;       // (Stream channel only) The name of the topic that this message came from
        const messageType = event.messageType;      // The message type, 'STRING' or 'BINARY'
        const customType = event.customType;        // User defined type
        const publisher = event.publisher;          // The message publisher
        const message = event.message;              // The message payload
        const timestamp = event.timestamp;          // Event timestamp
    },
    // Handle presence event
    presence: (PresenceEvent event) {
        const action = event.type;                  // The event type, should be one of 'SNAPSHOT', 'INTERVAL', 'JOIN', 'LEAVE', 'TIMEOUT、'STATE_CHANGED', 'OUT_OF_SERVICE'.
        const channelType = event.channelType;      // The channel type, should be "STREAM", "MESSAGE" or "USER"
        const channelName = event.channelName;      // The name of the channel this event came from
        const publisher = event.publisher;          // The user who triggered this even
        const states = event.stateItems;            // User state payload, only for the stateChanged event
        const interval = event.interval;            // Interval payload, only for the interval event
        const snapshot = event.snapshot;            // Snapshot payload, only for the snapshot event
        const timestamp = event.timestamp;          // Event timestamp
    },
   // Handle topic event
    topic: (TopicEvent event) {
        const action = event.type;                  // The event type, should be one of 'SNAPSHOT', 'JOIN', 'LEAVE'
        const channelName = event.channelName;      // The name of the channel this event came from
        const publisher = event.publisher;          // The user who triggered this even
        const topicInfos = event.topicInfos;        // Topic information payload
        const timestamp = event.timestamp;          // Event timestamp
    },
    // Handle storage event
    storage: (StorageEvent event) {
        const channelType = event.channelType;      // The channel type, should be "STREAM", "MESSAGE" or "USER"
        const target = event.target;                // Which channel or user triggered this event
        const storageType = event.storageType;      // The storage type, should be 'USER'、'CHANNEL'
        const action = event.eventType;             // The event type, should be one of "SNAPSHOT"、"SET"、"REMOVE"、"UPDATE" or "NONE"
        const data = event.data;                    // USER_METADATA or CHANNEL_METADATA payload
        const timestamp = event.timestamp;          // Event timestamp
    },
    // Handle lock event
    lock: (LockEvent event) {
        const channelType = event.channelType;      // The channel type, should be "STREAM", "MESSAGE" or "USER"
        const channelName = event.channelName;      // The name of the channel this event came from
        const action = event.evenType;              // The action type, should be one of 'SET'、'REMOVED'、'ACQUIRED'、'RELEASED'、'EXPIRED'、'SNAPSHOT'
        const lockDetailList = event.lockDetailList;    // Lock event payload
    const timestamp = event.timestamp;              // Event timestamp
    },
    // Handle link state event
    linkState: (LinkStateEvent event) {
        const currentState = event.currentState;    // The current link state
        const previousState = event.previousState;  // The previous link state
        const serviceType = event.serviceType;      // The service type, Should be "stream" or "message".
        const operation = event.operation;          // Which operation triggered this state changed
        const reason = event.reason;                // The reason for this state change
        const affectedChannels = event.affectedChannels;  // Which channels are affected
        const unrestoredChannels = event.unrestoredChannels;    // Which channels are unrestored
        const isResumed = event.isResumed;
        const timestamp = event.timestamp;          // Event timestamp
    },
    // Handle token event
    token : (TokenEvent event) {
        const channelName = event.channelName;      // The channel for which the token will expire
    });

// Define a message event handling function
void onMessageReceived(MessageEvent event) {
  print('Received message event: $event');
}

// Register the message event listener
rtmClient.addListener(
  message: onMessageReceived
);

// Remove the message event listener
rtmClient.removeListener(
  message: onMessageReceived
);

// Listen to messages received via Signaling channel
useRtmEvent(engine, 'message', (evt) => {
 const msg = new MessageEvent(evt);
 console.log('[You] received a message:', msg.message, 'from:', msg.publisher);
});

// Listen to Signaling link state changes
useRtmEvent(engine, 'linkState', (eventData) => {
 console.log('Link state changed:', eventData.currentState, 'reason:', eventData.reason);

 if (eventData.currentState === RtmLinkState.connected) {
   console.log('✅ Connected to Signaling');
 } else if (eventData.currentState === RtmLinkState.failed) {
   console.log('❌ Connection failed:', eventData.reason);
 }
});

// Listen to presence events such as user join, leave, or state change
useRtmEvent(engine, 'presence', (presenceData) => {
 console.log('[Signaling] Presence event:', presenceData.eventType);
 console.log('User:', presenceData.publisher, 'Channel:', presenceData.channelName);
});

// Listen to topic-related events such as topic creation, update, or deletion
useRtmEvent(engine, 'topic', (topicEvent) => {
 console.log('[Signaling] Topic event:', topicEvent.eventType);
 console.log('Topic:', topicEvent.topicName, 'Publisher:', topicEvent.publisher);
});

// Listen to updates in shared storage
useRtmEvent(engine, 'storage', (storageData) => {
 console.log('[Signaling] Storage event:', storageData.eventType);
 console.log('Storage type:', storageData.storageType, 'Channel:', storageData.channelName);
});

// Listen to channel lock or unlock events
useRtmEvent(engine, 'lock', (eventData) => {
 console.log('[Signaling] Lock event:', eventData.eventType);
 console.log('Lock:', eventData.lockName, 'Channel:', eventData.channelName);
});

// Listen to token expiration warnings
useRtmEvent(engine, 'tokenPrivilegeWillExpire', (channelName) => {
 console.log('[Signaling] Token privilege will expire for channel:', channelName);
 // Generate and renew token here
});

// Event listeners are automatically managed by the hook
useEffect(() => {
 // useRtmEvent hooks automatically register listeners when component mounts
 console.log('Component mounted - event listeners active');

 return () => {
   // Listeners are automatically removed when component unmounts
   console.log('Component unmounting - listeners automatically cleaned up');
 };
}, []);

class RtmHandler: public IRtmEventHandler {
    void onMessageEvent(const MessageEvent &event) {}
    void onTopicEvent(const TopicEvent &event) {}
    void onLinkStateEvent(const LinkStateEvent &event) {}
    void onLoginResult(RTM_ERROR_CODE errorCode) {
        if (errorCode != RTM_ERROR_OK) {
            printf("login rtm failed error is %d reason is %s\n", errorCode, getErrorReason(errorCode));
        } else {
            printf("login rtm success\n");
        }
    }
    void onStorageEvent(const StorageEvent &event) {}
    void onLockEvent(const LockEvent &event) {}
}

RtmConfig cfg;
cfg.appId = "your_appid";
cfg.userId = "your_name";
// Specify the event listener in the client configuration
cfg.eventHandler = new RtmHandler();

// Create an IRtmClient instance
IRtmClient* rtm_client = createAgoraRtmClient();
int ret = rtm_client->initialize(cfg);

class RtmHandler: public IRtmEventHandler {
    void onMessageEvent(const MessageEvent &event) {}
    void onTopicEvent(const TopicEvent &event) {}
    void onLinkStateEvent(const LinkStateEvent &event) {}
    void onLoginResult(RTM_ERROR_CODE errorCode) {
        if (errorCode != RTM_ERROR_OK) {
            printf("login rtm failed error is %d reason is %s\n", errorCode, getErrorReason(errorCode));
        } else {
            printf("login rtm success\n");
        }
    }
    void onStorageEvent(const StorageEvent &event) {}
    void onLockEvent(const LockEvent &event) {}
}

RtmConfig cfg;
cfg.appId = "your_appid";
cfg.userId = "your_name";
// Specify the event listener in the client configuration
cfg.eventHandler = new RtmHandler();

// Create an IRtmClient instance
IRtmClient* rtm_client = createAgoraRtmClient();
int ret = rtm_client->initialize(cfg);

// Add a message event listener
rtmClient.OnMessageEvent += newMessageEvent =>
{
    var channelName = newMessageEvent.channelName;
    var channelType = newMessageEvent.channelType;
    var topic = newMessageEvent.channelTopic;
    var publisher = newMessageEvent.publisher;
    var messageType = newMessageEvent.messageType;
    var message = newMessageEvent.message;
    var customType = newMessageEvent.customType;
    // your Logic
};

// Add a presence event listener
rtmClient.OnPresenceEvent += newPresenceEvent =>
{
    var channelName = newPresenceEvent.channelName;
    var channelType = newPresenceEvent.channelType;
    var eventType = newPresenceEvent.type;
    var publisher = newPresenceEvent.publisher;
    var stateItems = newPresenceEvent.stateItems;
    var interval = newPresenceEvent.interval;
    var snapshot = newPresenceEvent.snapshot;
    // your Logic
};

// Add a topic event listener
rtmClient.OnTopicEvent += newTopicEvent =>
{
    var channelName = newTopicEvent.channelName;
    var eventType = newTopicEvent.type;
    var publisher = newTopicEvent.publisher;
    var topicInfos = newTopicEvent.topicInfos;
    if (topicInfos != null)
    {
        // your logic
    }
};

// Add a storage event listener
rtmClient.OnStorageEvent += newStorageEvent =>
{
    var channelName = newStorageEvent.channelName;
    var channelType = newStorageEvent.channelType;
    var eventType = newStorageEvent.eventType;
    var category = newStorageEvent.target;
    var data = newStorageEvent.data;
    if (data != null)
    {
        // your logic
    }
};

// Add a lock event listener
rtmClient.OnLockEvent += newLockEvent =>
{
    var channelName = newLockEvent.channelName;
    var channelType = newLockEvent.channelType;
    var eventType = newLockEvent.eventType;
    var LockDetail = newLockEvent.lockDetailList;
    if( LockDetail != null )
    {
        // your logic
    }
};

// Add a OnConnectionStateChange event listener
rtmClient.OnConnectionStateChanged +=(channelName, state, reason ) =>
{
    Debug.Log(string.Format("OnConnectionStateChanged channelName {0}: state:{1} reason:{2}", channelName, state, reason);
    // your logic
};

// Add a OnTokenPrivilegeWillExpire event listener
rtmClient.OnTokenPrivilegeWillExpire += channelName =>
{
    Debug.Log(string.Format("OnTokenPrivilegeWillExpire channelName {0}", channelName));
    // your logic
};

private void AddEventsListener()
{
    rtmClient.OnMessageEvent += OnMessageEvent;
    rtmClient.OnPresenceEvent += OnPresenceEvent;
    rtmClient.OnTopicEvent += OnTopicEvent;
    rtmClient.OnStorageEvent += OnStorageEvent;
    rtmClient.OnLockEvent += OnLockEvent;
    rtmClient.OnConnectionStateChanged += OnConnectionStateChanged;
    rtmClient.OnTokenPrivilegeWillExpire += OnTokenPrivilegeWillExpire;
}

private void RemoveEventsListener()
{
    rtmClient.OnMessageEvent -= OnMessageEvent;
    rtmClient.OnPresenceEvent -= OnPresenceEvent;
    rtmClient.OnTopicEvent -= OnTopicEvent;
    rtmClient.OnStorageEvent -= OnStorageEvent;
    rtmClient.OnLockEvent -= OnLockEvent;
    rtmClient.OnConnectionStateChanged -= OnConnectionStateChanged;
    rtmClient.OnTokenPrivilegeWillExpire -= OnTokenPrivilegeWillExpire;
}

private void OnMessageEvent( MessageEvent Event) { }

private void OnPresenceEvent( PresenceEvent Event) { }

private void OnTopicEvent( TopicEvent Event) { }