Class UpdatesManager

constructor

• new UpdatesManager(
      client: BaseTelegramClient,
      params?: UpdatesManagerParams,
  ): UpdatesManager

• Parameters

  • client: BaseTelegramClient
  • params: UpdatesManagerParams = {}

  Returns UpdatesManager

Optionalauth

catchingUp

catchUpOnStart

channelDiffTimeouts

channelsOpened

Readonlyclient

cpts

cptsMod

Optionaldate

hasTimedoutPostponed

OptionalkeepAliveInterval

lock

log

noDispatchEnabled

noDispatchMsg

noDispatchPts

noDispatchQts

OptionaloldDate

OptionaloldPts

OptionaloldQts

OptionaloldSeq

Readonlyparams

pendingPtsUpdates

pendingPtsUpdatesPostponed

pendingQtsUpdates

pendingQtsUpdatesPostponed

pendingUnorderedUpdates

pendingUpdateContainers

postponedTimer

Optionalpts

Optionalqts

Optionalseq

updatesLoopActive

updatesLoopCv

_addToNoDispatchIndex

• _addToNoDispatchIndex(updates?: TypeUpdates): void

• Parameters

  • Optionalupdates: TypeUpdates

  Returns void

_fetchChannelDifference

• _fetchChannelDifference(
      channelId: number,
      fallbackPts?: number,
  ): Promise<boolean>

• Parameters

  • channelId: number
  • OptionalfallbackPts: number

  Returns Promise<boolean>

_fetchChannelDifferenceLater

• _fetchChannelDifferenceLater(
      requestedDiff: Map<number, Promise<void>>,
      channelId: number,
      fallbackPts?: number,
  ): void

• Parameters

  • requestedDiff: Map<number, Promise<void>>
  • channelId: number
  • OptionalfallbackPts: number

  Returns void

_fetchChannelDifferenceViaUpdate

• _fetchChannelDifferenceViaUpdate(channelId: number, pts?: number): void

• Parameters

  • channelId: number
  • Optionalpts: number

  Returns void

_fetchDifference

• _fetchDifference(requestedDiff: Map<number, Promise<void>>): Promise<void>

• Parameters

  • requestedDiff: Map<number, Promise<void>>

  Returns Promise<void>

_fetchDifferenceLater

• _fetchDifferenceLater(requestedDiff: Map<number, Promise<void>>): void

• Parameters

  • requestedDiff: Map<number, Promise<void>>

  Returns void

_fetchMissingPeers

• _fetchMissingPeers(
      upd: TypeUpdate,
      peers: PeersIndex,
      fromDifference?: boolean,
  ): Promise<Set<number>>

• Parameters

  • upd: TypeUpdate
  • peers: PeersIndex
  • fromDifference: boolean = false

  Returns Promise<Set<number>>

_fetchUpdatesState

• _fetchUpdatesState(): Promise<void>

• Returns Promise<void>

_loadUpdatesStorage

• _loadUpdatesStorage(): Promise<void>

• Returns Promise<void>

_loop

• _loop(): Promise<void>

• Returns Promise<void>

_onUpdate

• _onUpdate(
      pending: PendingUpdate,
      requestedDiff: Map<number, Promise<void>>,
      postponed?: boolean,
      unordered?: boolean,
  ): Promise<void>

• Parameters

  • pending: PendingUpdate
  • requestedDiff: Map<number, Promise<void>>
  • postponed: boolean = false
  • unordered: boolean = false

  Returns Promise<void>

_saveUpdatesStorage

• _saveUpdatesStorage(save?: boolean): Promise<void>

• Parameters

  • save: boolean = false

  Returns Promise<void>

_storeMessageReferences

• _storeMessageReferences(msg: TypeMessage): Promise<void>

• Parameters

  • msg: TypeMessage

  Returns Promise<void>

catchUp

• catchUp(): void

• Catch up with the server by loading missed updates. .

  Note: In case the storage was not properly closed the last time, "catching up" might result in duplicate updates.

  Returns void

destroy

• destroy(): void

• Returns void

handleClientUpdate

• handleClientUpdate(update: TypeUpdates, noDispatch?: boolean): void

• Parameters

  • update: TypeUpdates
  • noDispatch: boolean = true

  Returns void

handleUpdate

• handleUpdate(update: TypeUpdates): void

• Parameters

  • update: TypeUpdates

  Returns void

notifyChannelClosed

• notifyChannelClosed(channelId: number): boolean

• ADVANCED

  Notify the updates manager that some channel was "closed". Basically the opposite of notifyChannelOpened. This is a low-level method, prefer using closeChat instead.

  Parameters

  • channelId: number

    Bare channel ID

  Returns boolean

  true if the chat was closed for the last time, false otherwise

notifyChannelOpened

• notifyChannelOpened(channelId: number, pts?: number): boolean

• ADVANCED

  Notify the updates manager that some channel was "opened". Channel difference for "opened" channels will be fetched on a regular basis. This is a low-level method, prefer using openChat instead.

  Channel must be resolve-able with resolvePeer method (i.e. be in cache); base chat PTS must either be passed (e.g. from Dialog), or cached in storage.

  Parameters

  • channelId: number

    Bare ID of the channel
  • Optionalpts: number

    PTS of the channel, if known (e.g. from Dialog)

  Returns boolean

  true if the channel was opened for the first time, false if it is already opened

notifyLoggedIn

• notifyLoggedIn(self: CurrentUserInfo): void

• Parameters

  • self: CurrentUserInfo

  Returns void

notifyLoggedOut

• notifyLoggedOut(): void

• Returns void

onCatchingUp

• onCatchingUp(handler: (catchingUp: boolean) => void): void

• Parameters

  • handler: (catchingUp: boolean) => void

  Returns void

prepare

• prepare(): Promise<void>

• Returns Promise<void>

startLoop

• startLoop(): Promise<void>

• Start updates loop.

  You must first call enableUpdatesProcessing to use this method.

  It is recommended to use this method in callback to start, or otherwise make sure the user is logged in.

  Note: If you are using UpdatesManagerParams.catchUp option, catching up will be done in background, you can't await it. Instead, listen for the updating and connected connection state events.

  Returns Promise<void>

stopLoop

• stopLoop(): void

• ADVANCED

  Manually stop updates loop. Usually done automatically when stopping the client with close

  Returns void