can't work in the win service

[jinmao88]

in the win ,normal exe ,is work good but in the win service is not work same code can't read and watch

[changkun]

Can you provide a reproducible code?

[jinmao88]

func WatchClipboard(ctx context.Context) {

err := clipboard.Init()
if err != nil {
    logger.Error(ctx, err)
    return
}
logger.Print(ctx, "新开始监听")

ch := clipboard.Watch(ctx, clipboard.FmtText)
for data := range ch {
    // print out clipboard data whenever it is changed
    //println(string(data))
    s := string(data)
    logger.Print(ctx, s)
    if s != "" {
        checkTxt(s)
        logger.Print(ctx, s)
    }
}

}

build exe ，and run in the win service

[jinmao88]

run in the win service

github.com/kardianos/service

use the demo

[changkun]

I dont' know how to run your code, but it looks to me that your desired case is very similar to this application: https://github.com/changkun/midgard, which was tested on window as a service.

[jinmao88]

package main

import (
    "context"
    "flag"
    "github.com/gogf/gf/v2/container/garray"
    "github.com/gogf/gf/v2/os/gctx"
    "github.com/gogf/gf/v2/os/glog"
    "github.com/takama/daemon"
    "golang.design/x/clipboard"
    "os"
)

var content = garray.New(true)

var (

    logger        = glog.New()
)

type Service struct {
    daemon.Daemon
}

// Manage by daemon commands or run the daemon
func (service *Service) Manage() (string, error) {
    ctx := gctx.New()

    // If received any kind of command, do it
    if len(os.Args) > 1 {
        logger.Print(ctx, "参数", os.Args[1])
        command := os.Args[1]
        switch command {
        case "install":
            return service.Install()
        case "remove":
            return service.Remove()
        case "start":
            return service.Start()
        case "stop":
            // No need to explicitly stop cron since job will be killed
            return service.Stop()
        case "status":
            return service.Status()
        default:
            return "", nil
        }
    }
    // Set up channel on which to send signal notifications.
    // We must use a buffered channel or risk missing the signal
    // if we're not ready to receive when the signal is sent.
    p := &program{}

    return service.Run(p)
}

type program struct{}

func (p *program) Start() {
    // Start should not block. Do the actual work async.
    go p.Run()
}
func (p *program) Run() {
    ctx := gctx.New()
    logger.SetPath(`C:\run\log`)
    logger.Print(ctx, "启动")
    //interrupt := make(chan os.Signal, 1)
    //signal.Notify(interrupt, os.Interrupt, os.Kill, syscall.SIGTERM)

    go func() {
        WatchClipboard(ctx)
    }()

}
func (p *program) Stop() {
    // Stop should not block. Return with a few seconds.

}

func main() {
    flag.Parse()
    //v1, v2, v3 = GetSystemVersion()
    //
    ctx := gctx.New()
    logger.SetPath(`C:\run\log`)

    name := "GoDaemonService1"

    srv, err := daemon.New(name, name, daemon.SystemDaemon)
    if err != nil {
        logger.Error(ctx, err)
        os.Exit(1)
    }

    service := &Service{srv}
    status, err := service.Manage()
    if err != nil {
        logger.Error(ctx, err)
        os.Exit(1)
    }

    logger.Print(ctx, status)

}

func WatchClipboard(ctx context.Context) {

    err := clipboard.Init()
    if err != nil {
        logger.Error(ctx, err)
        return
    }
    logger.Print(ctx, "新开始监听")

    textCh := clipboard.Watch(ctx, clipboard.FmtText)
    for {
        select {
        case <-ctx.Done():
            return
        case text, ok := <-textCh:
            if !ok {
                return
            }

            logger.Print(ctx, string(text), 123)

        }

    }
}

this my code ，run in the service ，the clipboard.watch not work