Type Alias ClientEventHandlerMap

Type declaration

• accountData: (event: MatrixEvent, lastEvent?: MatrixEvent) => void

  Fires whenever new user-scoped account_data is added.

  Example

  matrixClient.on("accountData", function(event, oldEvent){
    myAccountData[event.type] = event.content;
  });
  Copy

• deleteRoom: (roomId: string) => void

  Fires whenever a Room is removed. This will fire when you forget a room. This event is experimental and may change.

  Example

  matrixClient.on("deleteRoom", function(roomId){
    // update UI from getRooms()
  });
  Copy

• event: (event: MatrixEvent) => void

  Fires whenever the SDK receives a new event.

  This is only fired for live events received via /sync - it is not fired for events received over context, search, or pagination APIs.

  Example

  matrixClient.on("event", function(event){
    var sender = event.getSender();
  });
  Copy

• received_voip_event: (event: MatrixEvent) => void

• Room: (room: Room) => void

  Fires whenever a new Room is added. This will fire when you are invited to a room, as well as when you join a room. This event is experimental and may change.

  Example

  matrixClient.on("Room", function(room){
    var roomId = room.roomId;
  });
  Copy

• sync: (state: SyncState, prevState: SyncState | null, data?: SyncStateData) => void

  Fires whenever the SDK's syncing state is updated. The state can be one of:

  • PREPARED: The client has synced with the server at least once and is ready for methods to be called on it. This will be immediately followed by a state of SYNCING. This is the equivalent of "syncComplete" in the previous API.
  • CATCHUP: The client has detected the connection to the server might be available again and will now try to do a sync again. As this sync might take a long time (depending how long ago was last synced, and general server performance) the client is put in this mode so the UI can reflect trying to catch up with the server after losing connection.
  • SYNCING : The client is currently polling for new events from the server. This will be called after processing latest events from a sync.
  • ERROR : The client has had a problem syncing with the server. If this is called before PREPARED then there was a problem performing the initial sync. If this is called after PREPARED then there was a problem polling the server for updates. This may be called multiple times even if the state is already ERROR. This is the equivalent of "syncError" in the previous API.
  • RECONNECTING: The sync connection has dropped, but not (yet) in a way that should be considered erroneous.
  • STOPPED: The client has stopped syncing with server due to stopClient being called.

  State transition diagram: ``` +---->STOPPED | +----->PREPARED -------> SYNCING <--+ | ^ | ^ | | CATCHUP ----------+ | | | | ^ V | | null ------+ | +------- RECONNECTING | | V V | +------->ERROR ---------------------+

  NB: 'null' will never be emitted by this event.

  Transitions:
  <ul>
  
  <li>`null -> PREPARED` : Occurs when the initial sync is completed
  first time. This involves setting up filters and obtaining push rules.
  
  <li>`null -> ERROR` : Occurs when the initial sync failed first time.
  
  <li>`ERROR -> PREPARED` : Occurs when the initial sync succeeds
  after previously failing.
  
  <li>`PREPARED -> SYNCING` : Occurs immediately after transitioning
  to PREPARED. Starts listening for live updates rather than catching up.
  
  <li>`SYNCING -> RECONNECTING` : Occurs when the live update fails.
  
  <li>`RECONNECTING -> RECONNECTING` : Can occur if the update calls
  continue to fail, but the keepalive calls (to /versions) succeed.
  
  <li>`RECONNECTING -> ERROR` : Occurs when the keepalive call also fails
  
  <li>`ERROR -> SYNCING` : Occurs when the client has performed a
  live update after having previously failed.
  
  <li>`ERROR -> ERROR` : Occurs when the client has failed to keepalive
  for a second time or more.</li>
  
  <li>`SYNCING -> SYNCING` : Occurs when the client has performed a live
  update. This is called <i>after</i> processing.</li>
  
  <li>`* -> STOPPED` : Occurs once the client has stopped syncing or
  trying to sync after stopClient has been called.</li>
  </ul
  Copy

  Example

  matrixClient.on("sync", function(state, prevState, data) {
    switch (state) {
      case "ERROR":
        // update UI to say "Connection Lost"
        break;
      case "SYNCING":
        // update UI to remove any "Connection Lost" message
        break;
      case "PREPARED":
        // the client instance is ready to be queried.
        var rooms = matrixClient.getRooms();
        break;
    }
  });
  Copy

• sync.unexpectedError: (error: Error) => void

• toDeviceEvent: (event: MatrixEvent) => void

  Fires whenever the SDK receives a new to-device event.

  Example

  matrixClient.on("toDeviceEvent", function(event){
    var sender = event.getSender();
  });
  Copy

• toDeviceEvent.undecryptable: (event: MatrixEvent) => void

  Fires if a to-device event is received that cannot be decrypted. Encrypted to-device events will (generally) use plain Olm encryption, in which case decryption failures are fatal: the event will never be decryptable, unlike Megolm encrypted events where the key may simply arrive later.

  An undecryptable to-device event is therefore likley to indicate problems.

• turnServers: (servers: ITurnServer[]) => void

• turnServers.error: (error: Error, fatal: boolean) => void

• WellKnown.client: (data: IClientWellKnown) => void

  Fires when the client .well-known info is fetched.