gopi

type App interface {

	// Run the application and return the return code
	Run() int

	// WaitForSignal stalls the application until a signal is returned,
	// context is cancelled or deadline exceeded
	WaitForSignal(context.Context, ...os.Signal) error // Wait for interrupt signal with context

	// Flags returns the set of key/value configuration parameters
	Flags() Flags

	// Emit events
	Emit(Event)

	// Return unit instances
	UnitInstance(string) Unit // Return singular unit for name
	Log() Logger              // Return logger unit
	Timer() Timer             // Return timer unit
	Bus() Bus                 // Return event bus unit
	Platform() Platform       // Return hardware platform unit
	Display() Display         // Return display
	Surfaces() SurfaceManager // Return surface manager
	Input() InputManager      // Return input manager
	Fonts() FontManager       // Return font manager
	GPIO() GPIO               // Return GPIO interface
	I2C() I2C                 // Return I2C interface
	SPI() SPI                 // Return SPI interface
	LIRC() LIRC               // Return LIRC interface
}

type Bitmap interface {
	Type() SurfaceFlags
	Size() Size

	// Clear bitmap
	ClearToColor(color.Color)

	// Set Pixel
	Pixel(color.Color, Point)

	// Draw line
	Line(color.Color, Point, Point)

	// Outline circle with centre and radius
	CircleOutline(color.Color, Point, float32)

	// Paint a rune
	Rune(color.Color, Point, rune, FontFace, FontSize)

	// Implements image.Image and draw.Image
	draw.Image
}

type Bus interface {
	Unit

	// Emit an event on the bus
	Emit(Event)

	// NewHandler registers an event handler for an event name
	NewHandler(EventHandler) error

	// DefaultHandler registers a default handler for an event namespace
	DefaultHandler(EventNS, EventHandlerFunc) error
}

type Channel uint

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

type Config interface {
	Name() string             // Returns name of the unit
	New(Logger) (Unit, error) // Opens the driver from configuration, or returns error
}

type ConfigFunc func(App) error

type DebugApp interface {

	// Testing
	T() *testing.T

	// Implements App
	App
}

type Display interface {
	// Return display number
	DisplayId() uint

	// Return name of the display
	Name() string

	// Return display size for nominated display number, or (0,0) if display does not exist
	Size() (uint32, uint32)

	// Return the PPI (pixels-per-inch) for the display, or return zero if unknown
	PixelsPerInch() uint32

	// Implements gopi.Unit
	Unit
}

type Error uint

type Event interface {
	Source() Unit       // Source of the event
	Name() string       // Name of the event
	NS() EventNS        // Namespace for the event
	Value() interface{} // Any value associated with the event
}

type EventHandler struct {
	// The name of the event
	Name string

	// The handler function for the event
	Handler EventHandlerFunc

	// The namespace of the event, usually 0
	EventNS EventNS

	// The timeout value for the handler, usually 0
	Timeout time.Duration
}

type EventHandlerFunc func(context.Context, App, Event)

type EventId uint

type EventNS uint

type FSEvent interface {
	// Root path being watched
	Root() string

	// Path the event is concerned with, under the root path
	Path() string

	// Whether the event concerns a folder
	IsFolder() bool

	// The event flags
	Flags() FSEventFlags

	// The unique inode number for the event path, or zero
	Inode() uint64

	// Implements gopi.Event
	Event
}

type FSEventFlags uint

type FSEventFunc func(uint32, FSEvent)

type FSEvents interface {
	// Watch for events and call handler when events are generated
	Watch(string, FSEventFlags, FSEventFunc) (uint32, error)

	// Unwatch stops watching for file events
	Unwatch(uint32) error

	// Implements gopi.Unit
	Unit
}

type FilePoll interface {
	// Watch for events and call handler with file descriptor
	Watch(uintptr, FilePollFlags, FilePollFunc) error

	// Unwatch stops watching for file events
	Unwatch(uintptr) error

	// Implements gopi.Unit
	Unit
}

type FilePollFlags uint

type FilePollFunc func(uintptr, FilePollFlags)

type FlagNS uint

type Flags interface {
	Name() string                                       // Return name of tool
	Parse([]string) error                               // Parse command-line flags
	Parsed() bool                                       // Returns true if Parsed() has been called
	Args() []string                                     // Return command-line arguments
	HasFlag(string, FlagNS) bool                        // HasFlag returns true if a flag exists
	Visit(FlagNS, func(name string, value interface{})) // Visit all flags in a namespace

	Usage(io.Writer)   // Write out usage for the application
	Version(io.Writer) // Write out version for the application

	// Define flags in default namespace
	FlagBool(name string, value bool, usage string) *bool
	FlagString(name, value, usage string) *string
	FlagDuration(name string, value time.Duration, usage string) *time.Duration
	FlagInt(name string, value int, usage string) *int
	FlagUint(name string, value uint, usage string) *uint
	FlagFloat64(name string, value float64, usage string) *float64

	// Get flag values
	GetBool(string, FlagNS) bool
	GetString(string, FlagNS) string
	GetDuration(string, FlagNS) time.Duration
	GetInt(string, FlagNS) int
	GetUint(string, FlagNS) uint
	GetFloat64(string, FlagNS) float64

	// Set flag values
	SetBool(string, FlagNS, bool)
	SetString(string, FlagNS, string)
	SetDuration(string, FlagNS, time.Duration)
	SetInt(string, FlagNS, int)
	SetUint(string, FlagNS, uint)
	SetFloat64(string, FlagNS, float64)
}

type FontFace interface {

	// Get Face Name (from the filename)
	Name() string

	// Get Face Index
	Index() uint

	// Get Number of faces within the file
	NumFaces() uint

	// Number of glyphs for the face
	NumGlyphs() uint

	// Return name of font family
	Family() string

	// Return style name of font face
	Style() string

	// Return properties for face
	Flags() FontFlags
}

type FontFlags uint16

type FontManager interface {

	// Open a font face - first face at index 0 is loaded
	OpenFace(path string) (FontFace, error)

	// Open a font face - indexed within file of several faces
	OpenFaceAtIndex(path string, index uint) (FontFace, error)

	// Open font faces at path, checking to see if individual files should
	// be opened through a callback function
	OpenFacesAtPath(path string, callback func(manager FontManager, path string, info os.FileInfo) bool) error

	// Destroy a font face
	DestroyFace(FontFace) error

	// Return an array of font families which are loaded
	Families() []string

	// Return open face for filepath
	FaceForPath(path string) FontFace

	// Return faces in a family and/or with a particular set of attributes
	Faces(family string, flags FontFlags) []FontFace

	// Implements gopi.Unit
	Unit
}

type FontSize struct {
	Size float32
	Unit FontSizeUnit
}

type FontSizeUnit uint

type GPIO interface {
	// Return number of physical pins, or 0 if if cannot be returned
	// or nothing is known about physical pins
	NumberOfPhysicalPins() uint

	// Return array of available logical pins or nil if nothing is
	// known about pins
	Pins() []GPIOPin

	// Return logical pin for physical pin number. Returns
	// GPIO_PIN_NONE where there is no logical pin at that position
	// or we don't now about the physical pins
	PhysicalPin(uint) GPIOPin

	// Return physical pin number for logical pin. Returns 0 where there
	// is no physical pin for this logical pin, or we don't know anything
	// about the layout
	PhysicalPinForPin(GPIOPin) uint

	// Read pin state
	ReadPin(GPIOPin) GPIOState

	// Write pin state
	WritePin(GPIOPin, GPIOState)

	// Get pin mode
	GetPinMode(GPIOPin) GPIOMode

	// Set pin mode
	SetPinMode(GPIOPin, GPIOMode)

	// Set pull mode to pull down or pull up - will
	// return ErrNotImplemented if not supported
	SetPullMode(GPIOPin, GPIOPull) error

	// Start watching for rising and/or falling edge,
	// or stop watching when GPIO_EDGE_NONE is passed.
	// Will return ErrNotImplemented if not supported
	Watch(GPIOPin, GPIOEdge) error

	// Implements gopi.Unit
	Unit
}

type GPIOEdge uint8

type GPIOMode uint8

type GPIOPin uint8

type GPIOPull uint8

type GPIOState uint8

type I2C interface {

	// Set current slave address
	SetSlave(uint8) error

	// Get current slave address
	GetSlave() uint8

	// Return true if a slave was detected at a particular address
	DetectSlave(uint8) (bool, error)

	// Read Byte (8-bits), Word (16-bits) & Block ([]byte) from registers
	ReadUint8(reg uint8) (uint8, error)
	ReadInt8(reg uint8) (int8, error)
	ReadUint16(reg uint8) (uint16, error)
	ReadInt16(reg uint8) (int16, error)
	ReadBlock(reg, length uint8) ([]byte, error)

	// Write Byte (8-bits) & Word (16-bits) to registers
	WriteUint8(reg, value uint8) error
	WriteInt8(reg uint8, value int8) error
	WriteUint16(reg uint8, value uint16) error
	WriteInt16(reg uint8, value int16) error

	// Implements gopi.Unit
	Unit
}

type InputDevice interface {
	// Name returns the name of the device
	Name() string

	// Id returns a unique ID for the device
	Id() uint

	// Returns the file descriptor for the device, or zero
	Fd() uintptr

	// Type returns the type of input device
	Type() InputDeviceType

	// KeyState indicates keyboard state when a modififer key is pressed or locked
	KeyState() KeyState

	// Position returns the absolute position for the device
	// (if mouse, joystick or touchscreen)
	Position() Point

	// SetPosition sets the absolute position for the device
	SetPosition(Point)

	// Matches returns true if a device has specific capabilities or name
	Matches(name string, flags InputDeviceType) bool
}

type InputDeviceType uint8

type InputEvent interface {
	// Return device which is emitting the event
	Device() InputDevice

	// Type of event
	Type() InputEventType

	// KeyCode returned when a key press event
	KeyCode() KeyCode

	// KeyState returned when a key press event
	KeyState() KeyState

	// ScanCode returned when a key press event
	ScanCode() uint32

	// Abs returns absolute input position
	Abs() Point

	// Rel returns relative input position
	Rel() Point

	// Implements gopi.Event
	Event
}

type InputEventType uint16

type InputManager interface {

	// Open Devices by name and/or type and return a list of opened devices
	OpenDevicesByNameType(name string, flags InputDeviceType, exclusive bool) ([]InputDevice, error)

	// Open an input device, and 'grab' exclusively
	OpenDevice(bus uint, exclusive bool) (InputDevice, error)

	// Close an input device
	CloseDevice(InputDevice) error

	// Implements gopi.Unit
	Unit
}

type KeyAction uint32

type KeyCode uint16

type KeyState uint16

type LIRC interface {
	// Get receive and send modes
	RcvMode() LIRCMode
	SendMode() LIRCMode
	SetRcvMode(mode LIRCMode) error
	SetSendMode(mode LIRCMode) error

	// Receive parameters
	RcvDutyCycle() uint32
	RcvResolutionMicros() uint32

	// Receive parameters
	SetRcvTimeout(micros uint32) error
	SetRcvTimeoutReports(enable bool) error
	SetRcvCarrierHz(value uint32) error
	SetRcvCarrierRangeHz(min uint32, max uint32) error

	// Send parameters
	SendDutyCycle() uint32
	SetSendCarrierHz(value uint32) error
	SetSendDutyCycle(value uint32) error

	// Send Pulse Mode, values are in milliseconds
	PulseSend(values []uint32) error

	// Implements gopi.Unit
	Unit
}

type LIRCEvent interface {
	Type() LIRCType // Type of event
	Mode() LIRCMode // Mode of receiving data

	// Implements gopi.Event methods
	Event
}

type LIRCMode uint32

type LIRCType uint32

type Logger interface {
	Unit

	// Name returns the name of the logger
	Name() string

	// Clone returns a new logger with a different name
	Clone(string) Logger

	// Error logs an error, and returns an error with the name prefixed
	Error(error) error

	// Warn outputs informational message with warning severity
	Warn(args ...interface{})

	// Info outputs informational message
	Info(args ...interface{})

	// Debug will log a debug message when debugging is on
	Debug(args ...interface{})

	// IsDebug returns true if debugging is enabled
	IsDebug() bool
}

type MainCommandFunc func(App, []string) error

type MainTestFunc func(App, *testing.T)

type NewFunc func(App) (Unit, error)

type PWM interface {
	// Return array of pins which are enabled for PWM
	Pins() []GPIOPin

	// Period
	Period(GPIOPin) (time.Duration, error)
	SetPeriod(time.Duration, ...GPIOPin) error

	// Duty Cycle between 0.0 and 1.0 (0.0 is always off, 1.0 is always on)
	DutyCycle(GPIOPin) (float32, error)
	SetDutyCycle(float32, ...GPIOPin) error

	// Implements gopi.Unit
	Unit
}

type Platform interface {

	// Product returns product name
	Product() string

	// Type returns flags identifying platform type
	Type() PlatformType

	// SerialNumber returns unique serial number for host
	SerialNumber() string

	// Uptime returns uptime for host
	Uptime() time.Duration

	// LoadAverages returns 1, 5 and 15 minute load averages
	LoadAverages() (float64, float64, float64)

	// NumberOfDisplays returns the number of possible displays for this host
	NumberOfDisplays() uint

	// AttachedDisplays returns array of displays which are actually attached
	AttachedDisplays() []uint

	// Implements gopi.Unit
	Unit
}

type PlatformType uint32

type Point struct {
	X, Y float32
}

type PubSub interface {
	Unit

	// Emit sends values to be received by handlers
	Emit(value interface{})

	// Subscribe and handle messages which are emitted
	Subscribe() <-chan interface{}

	// Unsubscribe from a channel
	Unsubscribe(<-chan interface{})
}

type Publisher interface {
	// Emit sends values to be received by handlers
	Emit(queue uint, value interface{})

	// Subscribe and handle messages which are emitted
	Subscribe(queue uint, callback func(value interface{})) Channel

	// Unsubscribe from a channel
	Unsubscribe(Channel)
}

type RPCClientConn interface {
	// Return connection information, or nil if not connected
	Addr() string

	// Return service names supported by connection
	Services() ([]string, error)

	// Mutex locking to ensure one request at a time
	Lock()
	Unlock()

	// Implements gopi.Unit
	Unit
}

type RPCClientPool interface {
	// Lookup service records by parameter - returns records
	// which match either a service name up to max number of
	// records (or zero for unlimited). Will wait for new records
	// and block until cancelled
	Lookup(ctx context.Context, addr string, max uint) ([]RPCServiceRecord, error)

	// Connect to service by service record
	Connect(RPCServiceRecord, RPCFlag) (RPCClientConn, error)

	// Connect to service by address and port
	ConnectAddr(net.IP, uint16) (RPCClientConn, error)

	// Connect to service by unix socket
	ConnectFifo(string) (RPCClientConn, error)

	// Disconnect from service
	Disconnect(RPCClientConn) error

	// Create a client stub for a connection given a service name
	CreateStub(string, RPCClientConn) RPCClientStub

	// Implements gopi.Unit
	Unit
}

type RPCClientStub interface {
	// Return the connection associated with the client
	Conn() RPCClientConn

	// Implements gopi.Unit
	Unit
}

type RPCEvent interface {
	// Type of event
	Type() RPCEventType

	// Service record associated with event
	Service() RPCServiceRecord

	// Time-to-live value for event
	TTL() time.Duration

	// Implements gopi.Event
	Event
}

type RPCEventType uint // RPCEventType is an enumeration of event types

type RPCFlag uint // RPCFlag is a set of flags modifying behavior

type RPCServer interface {
	// Start an RPC server in currently running thread.
	// The method will not return until Stop is called
	// which needs to be done in a different thread
	Start() error

	// Stop RPC server. If halt is true then it immediately
	// ends the server without waiting for current requests to
	// be served
	Stop(halt bool) error

	// Return address the server is bound to, or nil if
	// the server is not running
	Addr() net.Addr

	// Implements gopi.Unit
	Unit
}

type RPCService interface {
	// CancelRequests is called by the server to gracefully end any
	// on-going streaming requests, but before the service is shutdown
	CancelRequests() error

	// Implements gopi.Unit
	Unit
}

type RPCServiceDiscovery interface {
	// Lookup service instances by name
	Lookup(ctx context.Context, service string) ([]RPCServiceRecord, error)

	// Return list of service names
	EnumerateServices(ctx context.Context) ([]string, error)

	// Implements gopi.Unit
	Unit
}

type RPCServiceRecord struct {
	Name    string
	Service string
	Host    string
	Port    uint16
	Addrs   []net.IP
	Txt     []string
}

type RPCServiceRegister interface {
	// Register service record, and de-register when deadline is exceeded
	Register(ctx context.Context, record RPCServiceRecord) error

	// Implements gopi.Unit
	Unit
}

type RunFunc func(App, Unit) error

type SPI interface {
	// Get SPI mode
	Mode() SPIMode
	// Get SPI speed
	MaxSpeedHz() uint32
	// Get Bits Per Word
	BitsPerWord() uint8
	// Set SPI mode
	SetMode(SPIMode) error
	// Set SPI speed
	SetMaxSpeedHz(uint32) error
	// Set Bits Per Word
	SetBitsPerWord(uint8) error

	// Read/Write
	Transfer(send []byte) ([]byte, error)

	// Read
	Read(len uint32) ([]byte, error)

	// Write
	Write(send []byte) error

	// Implements gopi.Unit
	Unit
}

type SPIMode uint8

type Size struct {
	W, H float32
}

type StubFunc func(RPCClientConn) (RPCClientStub, error)

type Surface interface {
	Type() SurfaceFlags
	Size() Size
	Origin() Point
	Opacity() float32
	Layer() uint16
	Bitmap() Bitmap
}

type SurfaceCallback func() error

type SurfaceFlags uint16

type SurfaceManager interface {
	// Return the display associated with the surface manager
	Display() Display

	// Return the name of the surface manager
	Name() string

	// Return capabilities for the GPU
	Types() []SurfaceFlags

	// Do CreateSurface, updates and drawing within this method
	Do(SurfaceCallback) error

	// Create and destroy surfaces
	CreateSurfaceWithBitmap(Bitmap, SurfaceFlags, float32, uint16, Point, Size) (Surface, error)
	CreateSurface(SurfaceFlags, float32, uint16, Point, Size) (Surface, error)
	CreateBackground(SurfaceFlags, float32) (Surface, error)
	DestroySurface(Surface) error

	// Create and destroy bitmaps
	CreateBitmap(SurfaceFlags, Size) (Bitmap, error)
	CreateSnapshot(SurfaceFlags) (Bitmap, error)
	DestroyBitmap(Bitmap) error

	// Implements gopi.Unit
	Unit
}

type Timer interface {
	Unit

	NewTicker(time.Duration) EventId // Create periodic event at interval
	NewTimer(time.Duration) EventId  // Create one-shot event after interval
	Cancel(EventId) error            // Cancel events
}

type Unit interface {
	Close() error   // Close closes the driver and frees the underlying resources
	String() string // String returns a string representation of the unit
}

type UnitConfig struct {
	Name     string     // Unique name of the unit
	Type     UnitType   // Unit type
	Requires []string   // Unit dependencies
	Pri      uint       // Priority when more than one unit of the same type
	Config   ConfigFunc // ConfigFunc is called to add configuration to the app
	New      NewFunc    // NewFunc is called to create a unit instance
	Run      RunFunc    // RunFunc is called once all unit instances have been created
	Stub     StubFunc   // StubFunc is called on RPC Clients to create a client stub
	// contains filtered or unexported fields
}

type UnitType uint