Class UpdatesManager

constructor

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

  Parameters

  • client: BaseTelegramClient
  • params: UpdatesManagerParams = {}

  Returns UpdatesManager

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(): void

  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