Class TimeSynchronizationServer

This is the default server implementation of TimeSynchronizationBehavior.

Hierarchy (view full)

Constructors

constructor

Properties

[reference] agent cluster context endpoint env events features session state cluster defaults dependencies? early Events ExtensionInterface id Interface Internal name schema? State supervisor supports

Methods

[asyncDispose] asAdmin assertAttributeEnabled callback initialize reactTo requireAttributeEnabled setUtcTime toString alter enable for set with

Constructors

constructor

  • new TimeSynchronizationServer(agent, backing): TimeSynchronizationServer

  • Parameters

    • agent: Agent
    • backing: BehaviorBacking

    Returns TimeSynchronizationServer

Properties

[reference]

[reference]: Datasource<StateType>

agent

agent: Agent

cluster

cluster: never

The implemented cluster.

context

context: ActionContext

endpoint

endpoint: Endpoint<Empty>

env

env: Environment

Readonlyevents

events: EventEmitter & Omit<ClusterEvents<Of<{
    attributes: {};
    commands: {};
    events: {};
    id: 0;
    name: "Unknown";
    revision: 0;
}>, typeof ClusterBehavior>, never> & {
    granularity$Changing: ClusterEvents.AttributeObservable<Attribute<TimeSynchronization.Granularity, any>>;
    utcTime$Changing: ClusterEvents.AttributeObservable<Attribute<null | number | bigint, any>>;
} & {
    timeSource$Changing: undefined | ClusterEvents.AttributeObservable<OptionalAttribute<TimeSynchronization.TimeSource, any>>;
} & {
    granularity$Changed: ClusterEvents.AttributeObservable<Attribute<TimeSynchronization.Granularity, any>>;
    utcTime$Changed: ClusterEvents.AttributeObservable<Attribute<null | number | bigint, any>>;
} & {
    timeSource$Changed: undefined | ClusterEvents.AttributeObservable<OptionalAttribute<TimeSynchronization.TimeSource, any>>;
} & {
    timeFailure: ClusterEvents.EventObservable<Event<void, any>>;
} & {}

Access the behavior's events.

Type declaration

  • ReadonlytimeFailure: ClusterEvents.EventObservable<Event<void, any>>

    This event shall be generated if the node has not generated a TimeFailure event in the last hour, and the node is unable to get a time from any source. This event SHOULD NOT be generated more often than once per hour.

    See

    MatterSpecification.v13.Core § 11.17.10.4

features

features: TypeFromBitSchema<{}> & TypeFromBitSchema<{
    ntpClient: BitFlag;
    ntpServer: BitFlag;
    timeSyncClient: BitFlag;
    timeZone: BitFlag;
}>

Supported features as a flag object.

session

session: SecureSession

Readonlystate

state: Omit<ClusterState.Type<Of<{
    attributes: {};
    commands: {};
    events: {};
    id: 0;
    name: "Unknown";
    revision: 0;
}>, typeof ClusterBehavior>, never> & {
    granularity: TimeSynchronization.Granularity;
    utcTime: null | number | bigint;
} & {
    timeSource?: TimeSynchronization.TimeSource;
} & {} & {}

Access the behavior's state.

Type declaration

  • Readonlygranularity: TimeSynchronization.Granularity

    The granularity of the error that the node is willing to guarantee on the time synchronization. It is of type GranularityEnum.

    This value shall be set to NoTimeGranularity if UTCTime is null and shall NOT be set to NoTimeGranularity if UTCTime is non-null.

    See

    MatterSpecification.v13.Core § 11.17.8.2

  • ReadonlyutcTime: null | number | bigint

    If the node has achieved time synchronization, this shall indicate the current time as a UTC epoch-us (Epoch Time in Microseconds).

    If the node has not achieved time synchronization, this shall be null. This attribute may be set when a SetUTCTime is received.

    See

    MatterSpecification.v13.Core § 11.17.8.1

Type declaration

  • Optional ReadonlytimeSource?: TimeSynchronization.TimeSource

    The node’s time source. This attribute indicates what method the node is using to sync, whether the source uses NTS or not and whether the source is internal or external to the Matter network. This attribute may be used by a client to determine its level of trust in the UTCTime. It is of type TimeSourceEnum.

    If a node is unsure if the selected NTP server is within the Matter network, it SHOULD select one of the NonMatter* values.

    This value shall be set to None if UTCTime is null and shall NOT be set to None if UTCTime is non-null.

    See

    MatterSpecification.v13.Core § 11.17.8.3

Static Readonlycluster

cluster: TimeSynchronization.Cluster

Base cluster state include all attribute values but may be extended by subclasses.

Static Readonlydefaults

defaults: ClusterState.Type<TimeSynchronization.Cluster, Type<Of<{
    attributes: {};
    commands: {};
    events: {};
    id: 0;
    name: "Unknown";
    revision: 0;
}>, typeof ClusterBehavior, TimeSynchronizationInterface>>

Static Optional Readonlydependencies

dependencies?: Iterable<Type, any, any>

Static Readonlyearly

early: boolean

Static ReadonlyEvents

Events: ClusterEvents.Type<TimeSynchronization.Cluster, Type<Of<{
    attributes: {};
    commands: {};
    events: {};
    id: 0;
    name: "Unknown";
    revision: 0;
}>, typeof ClusterBehavior, TimeSynchronizationInterface>>

Static ReadonlyExtensionInterface

ExtensionInterface: {}

Static Readonlyid

id

The behavior ID for ClusterBehaviors is the name of the cluster.

Static ReadonlyInterface

Interface: TimeSynchronizationInterface

Static ReadonlyInternal

Internal: (new () => {})

Type declaration

    • new (): {}

    • Implementation of internal state. Subclasses may override to extend.

      Returns {}

    Static Readonlyname

    name: string

    Static Optional Readonlyschema

    schema?: Schema

    Static ReadonlyState

    State: (new () => ClusterState.Type<TimeSynchronization.Cluster, Type<Of<{
        attributes: {};
        commands: {};
        events: {};
        id: 0;
        name: "Unknown";
        revision: 0;
    }>, typeof ClusterBehavior, TimeSynchronizationInterface>>)

    Static Readonlysupervisor

    supervisor: RootSupervisor

    Staticsupports

    supports: ((other: Type) => boolean)

    Type declaration

      • (other): boolean

      • Does this behavior support functionality of a specific implementation?

        Parameters

        Returns boolean

    Methods

    [asyncDispose]

    asAdmin

    • asAdmin(fn): void

    • Execute logic with elevated privileges.

      The provided function executes with privileges escalated to offline mode. This is not commonly necessary.

      Elevated logic effectively ignores ACLs so should be used with care.

      Note that interactions with the behavior will remain elevated until the synchronous completion of this call. You should only elevate privileges for synchronous logic.

      Parameters

      • fn: (() => void)

        the elevated logic

          • (): void

          • Returns void

      Returns void

    assertAttributeEnabled

    Protectedcallback

    • callback<A, R>(reactor, options?): ((...args: A) => undefined | R)

    • Create a generic callback function that has the same properties as a Reactor.

      Like a reactor, the callback's "this" will be bound to an active Behavior instance. Because of this: The reactor MUST be a real JS function - arrow functions will not work!

      Type Parameters

      • A extends any[]
      • R

      Parameters

      Returns ((...args: A) => undefined | R)

        • (...args): undefined | R

        • Parameters

          • Rest...args: A

          Returns undefined | R

    initialize

    • initialize(_options?): MaybePromise

    • Behaviors are ephemeral and should not perform initialization in their constructor. They can override this method instead.

      This method may be synchronous or asyncronous. If asynchronous, the behavior will not be available for external use until initialization completes.

      Parameters

      • Optional_options: {}

        Returns MaybePromise

      ProtectedreactTo

      • reactTo<O>(observable, reactor, options?): void

      • Install a Reactor.

        Important: The reactor MUST be a real JS function - arrow functions will not work!

        Type Parameters

        Parameters

        Returns void

      requireAttributeEnabled

      setUtcTime

      • setUtcTime(request): MaybePromise

      • This command may be issued by Administrator to set the time. If the Commissioner does not have a valid time source, it may send a Granularity of NoTimeGranularity.

        Upon receipt of this command, the node may update its UTCTime attribute to match the time specified in the command, if the stated Granularity and TimeSource are acceptable. The node shall update its UTCTime attribute if its current Granularity is NoTimeGranularity.

        If the time is updated, the node shall also update its Granularity attribute based on the granularity specified in the command and the expected clock drift of the node. This SHOULD normally be one level lower than the stated command Granularity. It shall also update its TimeSource attribute to Admin. It shall also update its Last Known Good UTC Time as defined in Section 3.5.6.1, “Last Known Good UTC Time”.

        If the node updates its UTCTime attribute, it shall accept the command with a status code of SUCCESS. If it opts to not update its time, it shall fail the command with a cluster specific Status Code of TimeNotAccepted.

        Parameters

        Returns MaybePromise

        See

        MatterSpecification.v13.Core § 11.17.9.1

      toString

      • toString(): string

      • Description used in diagnostic messages.

        Returns string

      Staticalter

      Staticenable

      Staticfor

      Staticset

      • set<This>(this, defaults): This

      • Type Parameters

        Parameters

        Returns This

      Staticwith

      Settings

      Member Visibility

      On This Page

      Constructors
      Properties
      Methods