148 lines
2.7 KiB
Go
148 lines
2.7 KiB
Go
package manager
|
|
|
|
import (
|
|
"encoding/json"
|
|
"fmt"
|
|
"log"
|
|
"reflect"
|
|
"sync"
|
|
)
|
|
|
|
type SyncHandler struct {
|
|
devices map[string]*_device
|
|
mutex *sync.Mutex
|
|
chanForSync map[string]chan map[string]interface{}
|
|
states map[string]map[string]interface{}
|
|
}
|
|
|
|
func compareMap(src map[string]interface{}, dst map[string]interface{}) bool {
|
|
|
|
for key, value := range src {
|
|
if key == "code" {
|
|
continue
|
|
}
|
|
|
|
if reflect.TypeOf(value).String() == "string" {
|
|
dstV, ok := dst[key].(string)
|
|
if !ok || value != dstV {
|
|
return false
|
|
}
|
|
continue
|
|
}
|
|
|
|
srcV, ok := value.(float64)
|
|
if !ok {
|
|
srcV = float64(value.(int))
|
|
}
|
|
|
|
dstV, ok := dst[key].(float64)
|
|
if !ok {
|
|
dstV = float64(dst[key].(int))
|
|
}
|
|
|
|
if srcV != dstV {
|
|
fmt.Println("diff ", key, "] ", srcV, " vs ", dstV)
|
|
return false
|
|
}
|
|
}
|
|
|
|
return true
|
|
}
|
|
|
|
func (sh *SyncHandler) Handle(e Event) {
|
|
device, ok := sh.devices[e.Key().(string)]
|
|
// fmt.Println("sync] ", device.IfaceName)
|
|
// fmt.Println(sh.devices)
|
|
if !ok {
|
|
return
|
|
}
|
|
|
|
params := e.Params()
|
|
if params == nil {
|
|
return
|
|
}
|
|
|
|
go func() {
|
|
encoder := json.NewEncoder(device.Iface)
|
|
origin := map[string]interface{}{}
|
|
origin["code"] = 200
|
|
for key, value := range params {
|
|
origin[key] = value
|
|
}
|
|
|
|
sh.states[device.UUID] = origin
|
|
// props := []string{"fan", "light", "servo"}
|
|
|
|
err := encoder.Encode(origin)
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
_, ok := sh.chanForSync[device.IfaceName]
|
|
if ok {
|
|
sh.mutex.Lock()
|
|
close(sh.chanForSync[device.IfaceName])
|
|
delete(sh.chanForSync, device.IfaceName)
|
|
sh.mutex.Unlock()
|
|
}
|
|
|
|
chanForSync := make(chan map[string]interface{})
|
|
sh.mutex.Lock()
|
|
sh.chanForSync[device.IfaceName] = chanForSync
|
|
sh.mutex.Unlock()
|
|
|
|
for state := range chanForSync {
|
|
if compareMap(sh.states[device.UUID], state) {
|
|
sh.mutex.Lock()
|
|
close(sh.chanForSync[device.IfaceName])
|
|
delete(sh.chanForSync, device.IfaceName)
|
|
sh.mutex.Unlock()
|
|
return
|
|
}
|
|
log.Println("wrong: ", state)
|
|
log.Println("resend: ", sh.states[device.UUID])
|
|
err := encoder.Encode(sh.states[device.UUID])
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
|
|
}()
|
|
}
|
|
|
|
type RecvHandler struct {
|
|
devices map[interface{}]*_device
|
|
chanForSync map[string]chan map[string]interface{}
|
|
next EventHandler
|
|
}
|
|
|
|
func (rh *RecvHandler) Handle(e Event) {
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
fmt.Println("panic recover - ", r)
|
|
}
|
|
}()
|
|
device, ok := rh.devices[e.Key()]
|
|
if !ok {
|
|
return
|
|
}
|
|
|
|
param := e.Params()
|
|
code, _ := param["code"].(float64)
|
|
if int(code) == 100 {
|
|
return
|
|
}
|
|
|
|
device.states = param
|
|
channel, ok := rh.chanForSync[device.IfaceName]
|
|
if ok {
|
|
channel <- device.states
|
|
}
|
|
|
|
if rh.next != nil {
|
|
rh.next.Handle(e)
|
|
}
|
|
|
|
// fmt.Println("recv] ", device.states)
|
|
}
|