hap-nodejs

constructor

constructor(password?: boolean);

• Instantiates a new AccessControlManagement.

  Parameter password

  if set to true the service will listen for password settings

constructor

constructor(password?: boolean, service?: AccessControl);

• Instantiates a new AccessControlManagement.

  Parameter password

  if set to true the service will listen for password settings

  Parameter service

  supply your own instance to sideload the AccessControl service

method destroy

destroy: () => void;

• This destroys the AccessControlManagement. It unregisters all GET or SET handler it has associated with the given AccessControl service. It removes all event handlers which were registered to this object.

method getAccessLevel

getAccessLevel: () => AccessLevel;

• Returns

  the current AccessLevel configured for the Home

method getPassword

getPassword: () => string | undefined;

• Returns

  the current password configured for the Home or undefined if no password is required.

method getService

getService: () => AccessControl;

• Returns

  the AccessControl service

constructor

constructor(displayName: string, UUID: string);

property aid

aid: number;

property bridge

bridge?: Accessory;

property bridged

bridged: boolean;

property bridgedAccessories

bridgedAccessories: Accessory[];

property category

category: Categories;

property controllerStorage

controllerStorage: ControllerStorage;

• Private API.

property displayName

displayName: string;

property getPrimaryAccessory

getPrimaryAccessory: () => Accessory;

• Returns the bridging accessory if this accessory is bridged. Otherwise, returns itself.

  Returns

  the primary accessory

property lastKnownUsername

lastKnownUsername?: string;

property reachable

reachable: boolean;

property services

services: Service[];

property shouldPurgeUnusedIDs

shouldPurgeUnusedIDs: boolean;

property UUID

UUID: string;

method addBridgedAccessories

addBridgedAccessories: (accessories: Accessory[]) => void;

method addBridgedAccessory

addBridgedAccessory: (accessory: Accessory, deferUpdate?: boolean) => Accessory;

method addService

addService: {
    (service: Service): Service;
    <S extends typeof Service>(
        serviceConstructor: S,
        ...constructorArgs: ConstructorArgs<S>
    ): Service;
};

• Add the given service instance to the Accessory.

  Parameter service

  A Service instance.

  Returns

  Returns the service instance passed to the method call.

• Adds a given service by calling the provided Service constructor with the provided constructor arguments.

  Parameter serviceConstructor

  A Service service constructor (e.g. Service.Switch).

  Parameter constructorArgs

  The arguments passed to the given constructor.

  Returns

  Returns the constructed service instance.

method cleanupAccessoryData

static cleanupAccessoryData: (username: MacAddress) => void;

method configureController

configureController: (
    controllerConstructor: Controller | ControllerConstructor
) => void;

• This method is used to set up a new Controller for this accessory. See Controller for a more detailed explanation what a Controller is and what it is capable of.

  The controller can be passed as an instance of the class or as a constructor (without any necessary parameters) for a new Controller. Only one Controller of a given ControllerIdentifier can be configured for a given Accessory.

  When called, it will be checked if there are any services and persistent data the Controller (for the given ControllerIdentifier) can be restored from. Otherwise, the Controller will be created with new services.

  Parameter controllerConstructor

  The Controller instance or constructor to the Controller with no required arguments.

method deserialize

static deserialize: (json: SerializedAccessory) => Accessory;

method destroy

destroy: () => Promise<void>;

• Removes this Accessory from the local network Accessory object will no longer valid after invoking this method Trying to invoke publish() on the object will result undefined behavior

method disableUnusedIDPurge

disableUnusedIDPurge: () => void;

method enableUnusedIDPurge

enableUnusedIDPurge: () => void;

method findCharacteristic

protected findCharacteristic: (
    aid: number,
    iid: number
) => Characteristic | undefined;

method getAccessoryByAID

protected getAccessoryByAID: (aid: number) => Accessory | undefined;

method getService

getService: <T extends WithUUID<typeof Service>>(
    name: string | T
) => Service | undefined;

method getServiceById

getServiceById: <T extends WithUUID<typeof Service>>(
    uuid: string | T,
    subType: string
) => Service | undefined;

method publish

publish: (info: PublishInfo, allowInsecureRequest?: boolean) => Promise<void>;

• Publishes this accessory on the local network for iOS clients to communicate with. - info.username - formatted as a MAC address, like CC:22:3D:E3:CE:F6, of this accessory. Must be globally unique from all Accessories on your local network. - info.pincode - the 8-digit pin code for clients to use when pairing this Accessory. Must be formatted as a string like 031-45-154. - info.category - one of the values of the Accessory.Category enum, like Accessory.Category.SWITCH. This is a hint to iOS clients about what "type" of Accessory this represents, so that for instance an appropriate icon can be drawn for the user while adding a new Accessory.

  Parameter info

  Required info for publishing.

  Parameter allowInsecureRequest

  Will allow unencrypted and unauthenticated access to the http server

method purgeUnusedIDs

purgeUnusedIDs: () => void;

• Manually purge the unused ids if you like, comes handy when you have disabled auto purge, so you can do it manually

method removeAllBridgedAccessories

removeAllBridgedAccessories: () => void;

method removeBridgedAccessories

removeBridgedAccessories: (accessories: Accessory[]) => void;

method removeBridgedAccessory

removeBridgedAccessory: (accessory: Accessory, deferUpdate?: boolean) => void;

method removeController

removeController: (controller: Controller) => void;

• This method will remove a given Controller from this accessory. The controller object will be restored to its initial state. This also means that any event handlers setup for the controller will be removed.

  Parameter controller

  The controller which should be removed from the accessory.

method removeService

removeService: (service: Service) => void;

method serialize

static serialize: (accessory: Accessory) => SerializedAccessory;

method setupURI

setupURI: () => string;

method unpublish

unpublish: () => Promise<void>;

property category

category: Categories;

property deviceIdPattern

static readonly deviceIdPattern: RegExp;

property displayName

displayName: string;

property model

model: string;

property paired

paired: () => boolean;

property pairedAdminClients

pairedAdminClients: number;

property pairedClients

pairedClients: Record<string, PairingInformation>;

property pincode

pincode: string;

property setupID

setupID: string;

property signPk

signPk: Buffer;

property signSk

signSk: Buffer;

property username

username: string;

method addPairedClient

addPairedClient: (
    username: HAPUsername,
    publicKey: Buffer,
    permission: PermissionTypes
) => void;

• Add a paired client to memory.

  Parameter username

  Parameter publicKey

  Parameter permission

method assertValidUsername

static assertValidUsername: (username: MacAddress) => void;

method checkForCurrentConfigurationNumberIncrement

checkForCurrentConfigurationNumberIncrement: (
    configuration: AccessoryJsonObject[],
    checkFirmwareIncrement?: boolean
) => boolean;

• Checks based on the current accessory configuration if the current configuration number needs to be incremented. Additionally, if desired, it checks if the firmware version was incremented (aka the HAP-NodeJS) version did grow.

  Parameter configuration

  The current accessory configuration.

  Parameter checkFirmwareIncrement

  Returns

  True if the current configuration number was incremented and thus a new TXT must be advertised.

method create

static create: (username: MacAddress) => AccessoryInfo;

method getClientPublicKey

getClientPublicKey: (username: HAPUsername) => Buffer | undefined;

method getConfigVersion

getConfigVersion: () => number;

method hasAdminPermissions

hasAdminPermissions: (username: HAPUsername) => boolean;

method isPaired

isPaired: (username: HAPUsername) => boolean;

• Check if username is paired

  Parameter username

method listPairings

listPairings: () => PairingInformation[];

method load

static load: (username: MacAddress) => AccessoryInfo | null;

method persistKey

static persistKey: (username: MacAddress) => string;

method remove

static remove: (username: MacAddress) => void;

method removePairedClient

removePairedClient: (connection: HAPConnection, username: HAPUsername) => void;

• Remove a paired client from memory.

  Parameter connection

  the session of the connection initiated the removal of the pairing

  Parameter username

method save

save: () => void;

method updatePermission

updatePermission: (username: HAPUsername, permission: PermissionTypes) => void;

constructor

constructor(service: Lightbulb, options?: AdaptiveLightingOptions);

• Creates a new instance of the AdaptiveLightingController. Refer to the AdaptiveLightingController documentation on how to use it.

  Parameter service

  The lightbulb to which Adaptive Lighting support should be added.

  Parameter options

  Optional options to define the operating mode (automatic vs manual).

method configureServices

configureServices: () => void;

method constructServices

constructServices: () => ControllerServiceMap;

method controllerId

controllerId: () => ControllerIdentifier;

method deserialize

deserialize: (serialized: SerializedAdaptiveLightingControllerState) => void;

method disableAdaptiveLighting

disableAdaptiveLighting: () => void;

• This method can be called to manually disable the current active Adaptive Lighting transition. When using AdaptiveLightingControllerMode.AUTOMATIC you won't need to call this method. In AdaptiveLightingControllerMode.MANUAL you must call this method when Adaptive Lighting should be disabled. This is the case when the user manually changes the value of Hue, Saturation or ColorTemperature characteristics (or if any of those values is changed by physical interaction with the lightbulb).

method getAdaptiveLightingBrightnessMultiplierRange

getAdaptiveLightingBrightnessMultiplierRange: () => BrightnessAdjustmentMultiplierRange;

method getAdaptiveLightingNotifyIntervalThreshold

getAdaptiveLightingNotifyIntervalThreshold: () => number;

• Returns the minimum interval threshold (in milliseconds) a accessory may notify HomeKit controllers about a new color temperature value via event notifications (what happens when you call Characteristic.updateValue). Meaning the accessory should only send event notifications to subscribed HomeKit controllers at the specified interval.

  Typically this evaluates to 600000 milliseconds (10 minutes).

method getAdaptiveLightingStartTimeOfTransition

getAdaptiveLightingStartTimeOfTransition: () => number;

• Returns the time where the current transition curve was started in epoch time millis. A transition curves is active for 24 hours typically and is renewed every 24 hours by a HomeHub. Additionally see getAdaptiveLightingTimeOffset.

method getAdaptiveLightingTimeOffset

getAdaptiveLightingTimeOffset: () => number;

• It is not necessarily given, that we have the same time (or rather the correct time) as the HomeKit controller who set up the transition schedule. Thus we record the delta between our current time and the the time send with the setup request. timeOffset is defined as Date.now() - getAdaptiveLightingStartTimeOfTransition();. So in the case were we actually have a correct local time, it most likely will be positive (due to network latency). But of course it can also be negative.

method getAdaptiveLightingTransitionCurve

getAdaptiveLightingTransitionCurve: () => AdaptiveLightingTransitionCurveEntry[];

method getAdaptiveLightingUpdateInterval

getAdaptiveLightingUpdateInterval: () => number;

• This method returns the interval (in milliseconds) in which the light should update its internal color temperature (aka changes it physical color). A lightbulb should ideally change this also when turned of in oder to have a smooth transition when turning the light on.

  Typically this evaluates to 60000 milliseconds (60 seconds).

method getCurrentAdaptiveLightingTransitionPoint

getCurrentAdaptiveLightingTransitionPoint: () =>
    | AdaptiveLightingTransitionPoint
    | undefined;

• Retrieve the AdaptiveLightingTransitionPoint for the current timestamp. Returns undefined if the current transition schedule reached its end.

method handleControllerRemoved

handleControllerRemoved: () => void;

method handleFactoryReset

handleFactoryReset: () => void;

method initWithServices

initWithServices: (
    serviceMap: ControllerServiceMap
) => void | ControllerServiceMap;

method isAdaptiveLightingActive

isAdaptiveLightingActive: () => boolean;

• Returns if a Adaptive Lighting transition is currently active.

method serialize

serialize: () => SerializedAdaptiveLightingControllerState | undefined;

method setupStateChangeDelegate

setupStateChangeDelegate: (delegate?: StateChangeDelegate) => void;

constructor

constructor(displayName: string, UUID: string);

constructor

constructor(options: CameraControllerOptions, legacyMode?: boolean);

property motionService

motionService?: MotionSensor;

property occupancyService

occupancyService?: OccupancySensor;

property recordingManagement

recordingManagement?: RecordingManagement;

• The RecordingManagement which is responsible for handling HomeKit Secure Video. This property is only present if recording was configured.

property streamManagements

streamManagements: RTPStreamManagement[];

method configureServices

configureServices: () => void;

method constructServices

constructServices: () => CameraControllerServiceMap;

method controllerId

controllerId: () => ControllerIdentifier;

method deserialize

deserialize: (serialized: CameraControllerState) => void;

method forceStopStreamingSession

forceStopStreamingSession: (sessionId: SessionIdentifier) => void;

• Call this method if you want to forcefully suspend an ongoing streaming session. This would be adequate if the rtp server or media encoding encountered an unexpected error.

  Parameter sessionId

  id of the current ongoing streaming session

method generateSynchronisationSource

static generateSynchronisationSource: () => number;

method handleControllerRemoved

handleControllerRemoved: () => void;

method handleFactoryReset

handleFactoryReset: () => void;

method handleSnapshotRequest

handleSnapshotRequest: (
    height: number,
    width: number,
    accessoryName?: string,
    reason?: ResourceRequestReason
) => Promise<Buffer>;

method initWithServices

initWithServices: (
    serviceMap: CameraControllerServiceMap
) => void | CameraControllerServiceMap;

method migrateFromDoorbell

protected migrateFromDoorbell: (serviceMap: ControllerServiceMap) => boolean;

method retrieveEventTriggerOptions

protected retrieveEventTriggerOptions: () => Set<EventTriggerOption>;

method serialize

serialize: () => CameraControllerState | undefined;