api

type ConnectionState uint

type ConnectionStateDetail struct {
	// contains filtered or unexported fields
}

type HubInterface interface {
	// Start the ConnectionsHub with all its services
	Start()

	// close all connections
	Shutdown()

	// return the service for a SKI
	ServiceForSKI(ski string) *ServiceDetails

	// Provide the current pairing state for a SKI
	PairingDetailForSki(ski string) *ConnectionStateDetail

	// Enables or disables to automatically accept incoming pairing and connection requests
	//
	// Default: false
	SetAutoAccept(bool)

	// Pair with the SKI
	RegisterRemoteSKI(ski string)

	// Unpair the SKI
	UnregisterRemoteSKI(ski string)

	// Disconnect a connection to an SKI
	DisconnectSKI(ski string, reason string)

	// Cancels the pairing process for a SKI
	CancelPairingWithSKI(ski string)
}

type HubReaderInterface interface {
	// report a connection to a SKI
	RemoteSKIConnected(ski string)

	// report a disconnection to a SKI
	RemoteSKIDisconnected(ski string)

	// report an approved handshake by a remote device
	SetupRemoteDevice(ski string, writeI ShipConnectionDataWriterInterface) ShipConnectionDataReaderInterface

	// report all currently visible EEBUS services
	VisibleRemoteServicesUpdated(entries []RemoteService)

	// Provides the SHIP ID the remote service reported during the handshake process
	// This needs to be persisted and passed on for future remote service connections
	// when using `PairRemoteService`
	ServiceShipIDUpdate(ski string, shipdID string)

	// Provides the current pairing state for the remote service
	// This is called whenever the state changes and can be used to
	// provide user information for the pairing/connection process
	ServicePairingDetailUpdate(ski string, detail *ConnectionStateDetail)

	// return if the user is still able to trust the connection
	AllowWaitingForTrust(ski string) bool
}

type MdnsEntry struct {
	Name       string
	Ski        string
	Identifier string   // mandatory
	Path       string   // mandatory
	Register   bool     // mandatory
	Brand      string   // optional
	Type       string   // optional
	Model      string   // optional
	Host       string   // mandatory
	Port       int      // mandatory
	Addresses  []net.IP // mandatory
}

type MdnsInterface interface {
	Start(cb MdnsReportInterface) error
	Shutdown()
	AnnounceMdnsEntry() error
	UnannounceMdnsEntry()
	SetAutoAccept(bool)
	RequestMdnsEntries()
}

type MdnsProviderInterface interface {
	Start(autoReconnect bool, cb MdnsResolveCB) bool
	Shutdown()
	Announce(serviceName string, port int, txt []string) error
	Unannounce()
}

type MdnsReportInterface interface {
	ReportMdnsEntries(entries map[string]*MdnsEntry, newEntries bool)
}

type MdnsResolveCB func(elements map[string]string, name, host string, addresses []net.IP, port int, remove bool)

type RemoteService struct {
	Name       string `json:"name"`
	Ski        string `json:"ski"`
	Identifier string `json:"identifier"`
	Brand      string `json:"brand"`
	Type       string `json:"type"`
	Model      string `json:"model"`
}

type ServiceDetails struct {
	// contains filtered or unexported fields
}

type ShipConnectionDataReaderInterface interface {
	HandleShipPayloadMessage(message []byte)
}

type ShipConnectionDataWriterInterface interface {
	WriteShipMessageWithPayload(message []byte)
}

type ShipConnectionInfoProviderInterface interface {
	// check if the SKI is paired
	IsRemoteServiceForSKIPaired(string) bool

	// check if auto accept is true
	IsAutoAcceptEnabled() bool

	// report closing of a connection and if handshake did complete
	HandleConnectionClosed(ShipConnectionInterface, bool)

	// report the ship ID provided during the handshake
	ReportServiceShipID(string, string)

	// check if the user is still able to trust the connection
	AllowWaitingForTrust(string) bool

	// report the updated SHIP handshake state and optional error message for a SKI
	HandleShipHandshakeStateUpdate(string, model.ShipState)

	// report an approved handshake by a remote device
	SetupRemoteDevice(ski string, writeI ShipConnectionDataWriterInterface) ShipConnectionDataReaderInterface
}

type ShipConnectionInterface interface {
	DataHandler() WebsocketDataWriterInterface
	CloseConnection(safe bool, code int, reason string)
	RemoteSKI() string
	ApprovePendingHandshake()
	AbortPendingHandshake()
	ShipHandshakeState() (model.ShipMessageExchangeState, error)
}

type WebsocketDataReaderInterface interface {
	// called for each incoming message
	HandleIncomingWebsocketMessage([]byte)

	// called if the data connection is closed unsafe
	// e.g. due to connection issues
	ReportConnectionError(error)
}

type WebsocketDataWriterInterface interface {
	// initialize data processing
	InitDataProcessing(WebsocketDataReaderInterface)

	// send data via the connection to the remote device
	WriteMessageToWebsocketConnection([]byte) error

	// close the data connection
	CloseDataConnection(closeCode int, reason string)

	// report if the data connection is closed and the error if availab le
	IsDataConnectionClosed() (bool, error)
}