ammeter/drivers/device.go

package drviers

import (
	"reflect"
	"time"

	bus "github.com/ammeter/Bus"
	"github.com/ammeter/protocol"
)

type IDevice interface {
	Name() string
	Probe(name string, drv IDriver) error
	Open(...interface{}) error
	Close() error
	Ctrl(...interface{}) error
	Suspend() error
	Resume() error
	GetDevice(string) interface{}
	ListDevices() interface{}
	SetRoute(evt bus.IBusEvent, prot string, busName string, chn string, param ...interface{}) int
}

type routePath struct {
	iChn   bus.IChannel
	ibus   bus.IBus
	iproto protocol.IProtocol
	router []chan interface{}
}

type baseDevice struct {
	tsUpdate   int64
	tsSample   int64
	DeviceName string
	Status     string
	drv        IDriver
	Id         string
	Route      []routePath
}

func (dev *baseDevice) Name() string {
	return dev.DeviceName
}

func (dev *baseDevice) Probe(name string, driver IDriver) error {
	dev.Route = make([]routePath, 0)
	dev.DeviceName = name
	dev.drv = driver
	return nil
}

//bus.IBusEvent
func (dev *baseDevice) OnAttach(chn bus.IChannel) {
	dev.Status = "Attached"
}

func (dev *baseDevice) OnDetach(chn bus.IChannel) {
	chn.GetBus().ResetChannel(chn)
	dev.Status = "Detached"
}

func (dev *baseDevice) ChannelDispatch(stream []byte, args interface{}) bus.ChnDispResult {
	//log.Info(dev.drv.Name(), "-", dev.DeviceName, " try Dispatch: ", hex.EncodeToString(stream))
	k := reflect.TypeOf(args).Kind()
	if k == reflect.Ptr {
		iprot := args.(protocol.IProtocol)
		return bus.ChnDispResult(iprot.ChannelDispatch(stream))
	}
	return bus.DispatchNone
}

func (dev *baseDevice) Create(model interface{}) interface{} {
	return nil
}

func (dev *baseDevice) Open(...interface{}) error {
	return nil
}

func (dev *baseDevice) Close() error {
	return nil
}

func (dev *baseDevice) Ctrl(...interface{}) error {
	return nil
}

func (dev *baseDevice) GetDevice(string) interface{} {
	return dev
}

func (dev *baseDevice) ListDevices() interface{} {
	dinfo := make(map[string]string)
	dinfo["Name"] = dev.DeviceName
	dinfo["State"] = dev.Status
	if dev.tsSample != 0 {
		dinfo["TsSample"] = time.Unix(dev.tsSample, 0).Format("2006-01-02 15:04:05")
	}
	return dinfo
}

func (dev *baseDevice) Suspend() error {
	return nil
}

func (dev *baseDevice) Resume() error {
	return nil
}

func (dev *baseDevice) SetRoute(evt bus.IBusEvent, prot string, busName string, chn string, param ...interface{}) int {
	r := new(routePath)
	r.router = make([]chan interface{}, 2)
	r.router[0] = make(chan interface{}, 16)

	r.iproto = protocol.LoadProtocol(prot)
	if r.iproto == nil {
		return 0
	}
	r.iproto.Init(prot)

	r.ibus = bus.MountBus(busName, param)
	r.ibus.Init()
	r.iChn = r.ibus.MountChannel(chn, r.router)
	r.iChn.SetEvent(evt, r.iproto)

	dev.Route = append(dev.Route, *r)
	return len(dev.Route)
}