播放游戏时，停止待机任务

internal/common/pause.go

@@ -0,0 +1,29 @@
+package common
+
+type CtrlWait struct {
+	// 用于暂停的chan
+	P chan struct{}
+	// 用于恢复的chan
+	R chan struct{}
+}
+
+// Pause 暂停
+func (c *CtrlWait) Pause() {
+	c.P <- struct{}{}
+}
+
+// Resume 恢复
+func (c *CtrlWait) Resume() {
+	c.R <- struct{}{}
+}
+
+// NewCtrlWait 创建一个控制等待
+func NewCtrlWait() *CtrlWait {
+	return &CtrlWait{
+		P: make(chan struct{}),
+		R: make(chan struct{}),
+	}
+}
+
+// PassCtrl 全局控制等待
+var PassCtrl = NewCtrlWait()

internal/middleware/pause.go

@@ -0,0 +1,70 @@
+package middleware
+
+import (
+	"context"
+	"game-driver/internal/common"
+	"game-driver/leaf"
+	"go.uber.org/zap"
+	"sync"
+)
+
+func Pause(ctrl *common.CtrlWait) leaf.HandlerFunc {
+	return func(c *leaf.Context) {
+		var cancel context.CancelFunc
+
+		// 获取锚点
+		holdPoint := c.Hold()
+
+		// 等待组
+		var wait sync.WaitGroup
+		defer wait.Wait()
+
+		// 结束信号通道
+		a := make(chan struct{})
+		// 发送结束信号
+		defer close(a)
+
+		run := true
+
+		// 保存原始的 Context
+		originalCtx := c.Context
+
+		wait.Add(1)
+		go func() {
+			defer wait.Done()
+			zap.S().Infoln("待机控制器")
+
+			for {
+				select {
+				case <-originalCtx.Done():
+					zap.S().Infoln("待机控制器监听结束")
+					return
+				case <-ctrl.R:
+					{
+						zap.S().Infoln("待机控制器 Resume 触发")
+						c.Context = originalCtx
+						run = true
+					}
+				case <-ctrl.P:
+					{
+						zap.S().Infoln("待机控制器 Pause 触发")
+						run = false
+						cancel()
+					}
+				}
+			}
+		}()
+
+		for {
+			select {
+			case <-originalCtx.Done():
+				return
+			default:
+				if run {
+					cancel = leaf.WithCancel(c)
+					c.Resume(holdPoint)
+				}
+			}
+		}
+	}
+}

internal/middleware/pause_wait.go

@@ -0,0 +1,15 @@
+package middleware
+
+import (
+	"game-driver/internal/common"
+	"game-driver/leaf"
+)
+
+func PauseWait(ctrl *common.CtrlWait) leaf.HandlerFunc {
+	return func(c *leaf.Context) {
+		ctrl.Pause()
+		defer ctrl.Resume()
+
+		c.Next()
+	}
+}

internal/middleware/sound_start.go

@@ -14,8 +14,10 @@ func SoundStart() leaf.HandlerFunc {
 
 		defer func() {
 			switch leaf.Value[leaf.EndType](c, leaf.EndKey) {
-			case leaf.EndTimer:
+			case leaf.End:
 				tts.DefaultTTS.Sound(pm.TTS.End)
+			case leaf.EndTimeout:
+				tts.DefaultTTS.Sound(pm.TTS.Timeout)
 			case leaf.EndStop:
 				tts.DefaultTTS.Sound(pm.TTS.Stop)
 			}

internal/middleware/timer.go

@@ -46,7 +46,7 @@ func TimeoutOver(maxTimeout int) leaf.HandlerFunc {
 				{
 					zap.S().Infoln("超时 Timer 触发")
 					cancel()
-					leaf.WithValue[leaf.EndType](c, leaf.EndKey, leaf.EndTimer)
+					leaf.WithValue[leaf.EndType](c, leaf.EndKey, leaf.EndTimeout)
 				}
 			}
 		}()

internal/routes/wait.go

@@ -1,6 +1,7 @@
 package routes
 
 import (
+	"context"
 	"game-driver/internal/middleware"
 	"game-driver/internal/schema"
 	"game-driver/leaf"
@@ -10,180 +11,165 @@ import (
 	"game-driver/pkg/tts"
 	"game-driver/pkg/utils"
 	"game-driver/pkg/video"
+	"github.com/go-pkgz/cronrange"
 	"github.com/gopxl/beep/v2/speaker"
 	"go.uber.org/zap"
 	"sync"
 	"time"
 )
 
-func timerAction(timestamp int64) <-chan struct{} {
-	a := make(chan struct{})
-
-	go func() {
-		if timestamp == 0 {
-			close(a)
-		} else {
-			<-time.After(time.Until(time.Unix(timestamp, 0)))
-			close(a)
-		}
-	}()
-
-	return a
-}
-
-func WaitAction(c *leaf.Context) {
-	payload := leaf.Value[*schema.WaitModel](c, middleware.PayloadJSONKey)
-
-	if payload.Start != 0 && payload.End != 0 && time.Unix(payload.Start, 0).After(time.Unix(payload.End, 0)) {
-		zap.S().Infoln("开始时间大于结束时间")
+func runAction(c *leaf.Context, item schema.WaitItemModel, rootRules []cronrange.Rule, play func(c context.Context, item schema.WaitItemModel)) {
+	if item.Cron == "" {
+		item.Cron = "* * * *"
+	}
+	rules, err := cronrange.Parse(item.Cron)
+	if err != nil {
+		zap.S().Errorln("解析时间规则异常: ", err)
 		return
 	}
 
-	if payload.End != 0 {
-		cancel := leaf.WithDeadline(c, time.Unix(payload.End, 0))
-		defer cancel()
-	}
+	// 等待组
+	var wait sync.WaitGroup
+	defer wait.Wait()
 
-	select {
-	case <-c.Done():
-	case <-timerAction(payload.Start):
-		// 等待组
-		var wait sync.WaitGroup
-		defer wait.Wait()
-		for _, item := range payload.Items {
-			switch item.Type {
-			case schema.WaitAudio:
-				// 执行音乐播放
-				wait.Add(1)
-				go func() {
-					defer wait.Done()
-					audioAction(c, item, payload.TimeModel)
-				}()
-			case schema.WaitTTS:
-				// 执行TTS播放
-				wait.Add(1)
-				go func() {
-					defer wait.Done()
-					ttsAction(c, item, payload.TimeModel)
-				}()
-			case schema.WaitRelay:
-				// 执行继电器供电
-				wait.Add(1)
-				go func() {
-					defer wait.Done()
-					relayAction(c, item, payload.TimeModel)
-				}()
-			case schema.WaitVideo:
-				// 执行视频播放
-				wait.Add(1)
-				go func() {
-					defer wait.Done()
-					videoAction(c, item, payload.TimeModel)
-				}()
-			case schema.WaitWeb:
-				// 执行网页打开
-				wait.Add(1)
-				go func() {
-					defer wait.Done()
-					webAction(c, item, payload.TimeModel)
-				}()
-			default:
-				zap.S().Infof("不支持的类型: %d\n", item.Type)
+	ticker := time.NewTicker(time.Second)
+	defer ticker.Stop()
+
+	ctx, cancel := context.WithCancel(context.TODO())
+
+	var run bool
+
+	wait.Add(1)
+	go func() {
+		defer wait.Done()
+		for {
+			select {
+			case <-c.Done():
+				cancel()
+				return
+			case <-ticker.C:
+				if cronrange.Match(rules, time.Now()) && cronrange.Match(rootRules, time.Now()) {
+					run = true
+				} else {
+					run = false
+					cancel()
+				}
+			}
+		}
+	}()
+
+	for {
+		select {
+		case <-c.Done():
+			return
+		default:
+			if run {
+				play(ctx, item)
 			}
 		}
 	}
 }
 
-func audioAction(c *leaf.Context, item schema.WaitItemModel, root schema.TimeModel) {
-	if item.Start != 0 && time.Unix(item.Start, 0).Before(time.Unix(root.Start, 0)) {
-		zap.S().Infoln("开始时间小于根任务开始时间")
+func WaitAction(c *leaf.Context) {
+	payload := leaf.Value[*schema.WaitModel](c, middleware.PayloadJSONKey)
+
+	rules, err := cronrange.Parse(payload.Cron)
+	if err != nil {
+		zap.S().Errorln("解析时间规则异常: ", err)
 		return
 	}
 
-	if item.End != 0 {
-		cancel := leaf.WithDeadline(c, time.Unix(item.End, 0))
-		defer cancel()
+	// 等待组
+	var wait sync.WaitGroup
+	defer wait.Wait()
+	for _, item := range payload.Items {
+		switch item.Type {
+		case schema.WaitAudio:
+			// 执行音乐播放
+			wait.Add(1)
+			go func() {
+				defer wait.Done()
+				runAction(c, item, rules, audioAction)
+			}()
+		case schema.WaitTTS:
+			// 执行TTS播放
+			wait.Add(1)
+			go func() {
+				defer wait.Done()
+				runAction(c, item, rules, ttsAction)
+			}()
+		case schema.WaitRelay:
+			// 执行继电器供电
+			wait.Add(1)
+			go func() {
+				defer wait.Done()
+				runAction(c, item, rules, relayAction)
+			}()
+		case schema.WaitVideo:
+			// 执行视频播放
+			wait.Add(1)
+			go func() {
+				defer wait.Done()
+				runAction(c, item, rules, videoAction)
+			}()
+		case schema.WaitWeb:
+			// 执行网页打开
+			wait.Add(1)
+			go func() {
+				defer wait.Done()
+				runAction(c, item, rules, webAction)
+			}()
+		default:
+			zap.S().Infof("不支持的类型: %d\n", item.Type)
+		}
 	}
+}
 
+func audioAction(c context.Context, item schema.WaitItemModel) {
 	data, err := utils.LinkAudio(item.Data)
 	if err != nil {
 		zap.S().Errorln("音频数据获取异常: ", err)
 		return
 	}
 
-	select {
-	case <-c.Done():
-	case <-timerAction(item.Start):
-		{
-			zap.S().Infoln("播放待机音乐")
-			defer zap.S().Infoln("结束待机音乐")
+	zap.S().Infoln("播放待机音乐")
+	defer zap.S().Infoln("结束待机音乐")
 
-			ctrl, closer, e := audio.PlayBgmMP3(data)
-			defer closer()
-			if e != nil {
-				zap.S().Errorln("播放待机音乐异常", e)
-				return
-			}
-
-			select {
-			case <-c.Done():
-				{
-					speaker.Lock()
-					ctrl.Streamer = nil
-					speaker.Unlock()
-				}
-			}
-		}
-	}
-}
-
-func ttsAction(c *leaf.Context, item schema.WaitItemModel, root schema.TimeModel) {
-	if item.Start != 0 && time.Unix(item.Start, 0).Before(time.Unix(root.Start, 0)) {
-		zap.S().Infoln("开始时间小于根任务开始时间")
+	ctrl, closer, e := audio.PlayBgmMP3(data)
+	defer closer()
+	if e != nil {
+		zap.S().Errorln("播放待机音乐异常", e)
 		return
 	}
 
-	if item.End != 0 {
-		cancel := leaf.WithDeadline(c, time.Unix(item.End, 0))
-		defer cancel()
-	}
+	<-c.Done()
 
+	speaker.Lock()
+	ctrl.Streamer = nil
+	speaker.Unlock()
+}
+
+func ttsAction(c context.Context, item schema.WaitItemModel) {
 	reader, err := tts.DefaultTTS.Get(item.Data)
 	if err != nil {
 		zap.S().Errorln("语音合成异常: ", err)
 		return
 	}
 
-	select {
-	case <-c.Done():
-	case <-timerAction(item.Start):
-		{
-			zap.S().Infoln("循环播放待机 TTS 语音")
-			defer zap.S().Infoln("结束待机 TTS 语音")
+	zap.S().Infoln("循环播放待机 TTS 语音")
+	defer zap.S().Infoln("结束待机 TTS 语音")
 
-			for {
-				audio.PlayWav(c, reader)
-				select {
-				case <-c.Done():
-					return
-				case <-time.After(time.Duration(item.Interval) * time.Second):
-				}
-			}
+	for {
+		audio.PlayWav(c, reader)
+		select {
+		case <-c.Done():
+			return
+		case <-time.After(time.Duration(item.Interval) * time.Second):
 		}
 	}
 }
 
-func relayAction(c *leaf.Context, item schema.WaitItemModel, root schema.TimeModel) {
-	if item.Start != 0 && time.Unix(item.Start, 0).Before(time.Unix(root.Start, 0)) {
-		zap.S().Infoln("开始时间小于根任务开始时间")
-		return
-	}
-
-	if item.End != 0 {
-		cancel := leaf.WithDeadline(c, time.Unix(item.End, 0))
-		defer cancel()
-	}
-
+func relayAction(c context.Context, item schema.WaitItemModel) {
 	r, err := relay.New(item.Data)
 	if err != nil {
 		zap.S().Errorln("继电器初始化异常: ", err)
@@ -191,85 +177,47 @@ func relayAction(c *leaf.Context, item schema.WaitItemModel, root schema.TimeMod
 	}
 	defer r.Close()
 
-	select {
-	case <-c.Done():
-	case <-timerAction(item.Start):
-		{
-			zap.S().Infoln("待机继电器供电")
-			defer zap.S().Infoln("待机继电器断电")
+	zap.S().Infoln("待机继电器供电")
+	defer zap.S().Infoln("待机继电器断电")
 
-			r.On(0)
-			<-c.Done()
-			r.Off(0)
-		}
-	}
+	_ = r.On(0)
+	<-c.Done()
+	_ = r.Off(0)
 }
 
-func videoAction(c *leaf.Context, item schema.WaitItemModel, root schema.TimeModel) {
-	if item.Start != 0 && time.Unix(item.Start, 0).Before(time.Unix(root.Start, 0)) {
-		zap.S().Infoln("开始时间小于根任务开始时间")
-		return
-	}
-
-	if item.End != 0 {
-		cancel := leaf.WithDeadline(c, time.Unix(item.End, 0))
-		defer cancel()
-	}
-
+func videoAction(c context.Context, item schema.WaitItemModel) {
 	local, err := utils.LinkVideo(item.Data)
 	if err != nil {
 		zap.S().Errorln("视频文件获取异常: ", err)
 		return
 	}
 
-	select {
-	case <-c.Done():
-	case <-timerAction(item.Start):
-		{
-			zap.S().Infoln("循环播放待机视频")
-			defer zap.S().Infoln("结束待机视频")
+	zap.S().Infoln("循环播放待机视频")
+	defer zap.S().Infoln("结束待机视频")
 
-			utils.BlankOpen()
-			defer utils.BlankClose()
+	utils.BlankOpen()
+	defer utils.BlankClose()
 
-			for {
-				err := video.Play(c, local)
-				if err != nil {
-					zap.S().Infof("视频播放异常: %s", err)
-					return
-				}
-				select {
-				case <-c.Done():
-					return
-				case <-time.After(time.Duration(item.Interval) * time.Second):
-				}
-			}
+	for {
+		err := video.Play(c, local)
+		if err != nil {
+			zap.S().Infof("视频播放异常: %s", err)
+			return
+		}
+		select {
+		case <-c.Done():
+			return
+		case <-time.After(time.Duration(item.Interval) * time.Second):
 		}
 	}
 }
 
-func webAction(c *leaf.Context, item schema.WaitItemModel, root schema.TimeModel) {
-	if item.Start != 0 && time.Unix(item.Start, 0).Before(time.Unix(root.Start, 0)) {
-		zap.S().Infoln("开始时间小于根任务开始时间")
-		return
-	}
+func webAction(c context.Context, item schema.WaitItemModel) {
+	zap.S().Infoln("打开待机网页")
 
-	if item.End != 0 {
-		cancel := leaf.WithDeadline(c, time.Unix(item.End, 0))
-		defer cancel()
-	}
+	// 控制背光
+	utils.BlankOpen()
+	defer utils.BlankClose()
 
-	select {
-	case <-c.Done():
-	case <-timerAction(item.Start):
-		{
-			zap.S().Infoln("打开待机网页")
-
-			// 控制背光
-			utils.BlankOpen()
-			defer utils.BlankClose()
-
-			browser.OpenApp(c, item.Data)
-		}
-	}
+	browser.OpenApp(c, item.Data)
 }

internal/schema/play.go

@@ -6,10 +6,11 @@ type TTSTimer struct {
 }
 
 type TTSModal struct {
-	Start string     `json:"start"`
-	End   string     `json:"end"`
-	Stop  string     `json:"stop"`
-	Timer []TTSTimer `json:"timer"`
+	Start   string     `json:"start"`
+	End     string     `json:"end"`
+	Stop    string     `json:"stop"`
+	Timeout string     `json:"timeout"`
+	Timer   []TTSTimer `json:"timer"`
 }
 
 type PrintModal struct {

internal/schema/wait.go

@@ -10,13 +10,8 @@ const (
 	WaitWeb
 )
 
-type TimeModel struct {
-	Start int64 `json:"start"`
-	End   int64 `json:"end"`
-}
-
 type WaitItemModel struct {
-	TimeModel
+	Cron     string   `json:"cron"`
 	Type     WaitType `json:"type"`
 	Data     string   `json:"data"`
 	Interval int64    `json:"interval"`
@@ -24,6 +19,6 @@ type WaitItemModel struct {
 
 type WaitModel struct {
 	JsonModel
-	TimeModel
+	Cron  string          `json:"cron"`
 	Items []WaitItemModel `json:"items"`
 }

internal/server.go

@@ -54,7 +54,7 @@ func buildMqtt(c config.MqttConfig, r *leaf.Engine, subTopics ...string) autopah
 			zap.S().Infof("MQTT 连接异常: %s\n", err)
 		},
 		ClientConfig: paho.ClientConfig{
-			ClientID: "TestSubscriber",
+			ClientID: fmt.Sprintf("game-driver-%s-%v", config.C.Location, config.C.Point),
 			OnPublishReceived: []func(paho.PublishReceived) (bool, error){
 				func(pr paho.PublishReceived) (bool, error) {
 					r.Route(pr.Packet.Packet())
@@ -131,6 +131,7 @@ func Run() {
 		middleware.RunLog(),
 		middleware.PayloadJSON[schema.PlayModal](),
 		middleware.DeviceLock(device),
+		middleware.PauseWait(common.PassCtrl),
 		middleware.EmergencyStop(common.GlobalStopper),
 		middleware.SoundStart(),
 		middleware.RelayMaster(r),
@@ -145,6 +146,7 @@ func Run() {
 		middleware.PayloadJSON[schema.WaitModel](),
 		middleware.Unique(common.GlobalBgStopper),
 		middleware.EmergencyStop(common.GlobalBgStopper),
+		middleware.Pause(common.PassCtrl),
 		routes.WaitAction,
 	)
 	// 处理指令