Linux でデスクトップ通知を喋らせるという話

package tts

import (
	"anything-tts/log"
	"context"
	"io/ioutil"
	"os"
	"os/exec"
	"sync"

	texttospeech "cloud.google.com/go/texttospeech/apiv1"
	"github.com/pkg/errors"
	texttospeechpb "google.golang.org/genproto/googleapis/cloud/texttospeech/v1"
)

var mutex sync.Mutex

func Speech(ctx context.Context, text string) error {
	if text == "" {
		return nil
	}
	mutex.Lock()
	defer mutex.Unlock()

	client, err := texttospeech.NewClient(ctx)
	if err != nil {
		return errors.Wrap(err, "failed create client")
	}

	req := texttospeechpb.SynthesizeSpeechRequest{
		Input: &texttospeechpb.SynthesisInput{
			InputSource: &texttospeechpb.SynthesisInput_Text{
				Text: text,
			},
		},

		Voice: &texttospeechpb.VoiceSelectionParams{
			LanguageCode: "ja-JP",
			SsmlGender:   texttospeechpb.SsmlVoiceGender_FEMALE,
		},

		AudioConfig: &texttospeechpb.AudioConfig{
			AudioEncoding:    texttospeechpb.AudioEncoding_MP3,
			SpeakingRate:     1.5,
			Pitch:            1.5,
			EffectsProfileId: []string{"headphone-class-device"},
		},
	}

	log.Debug("say", log.Fields{
		"Text": text,
	})

	resp, err := client.SynthesizeSpeech(ctx, &req)
	if err != nil {
		return errors.Wrap(err, "failed call tts api")
	}

	out, err := ioutil.TempFile("", "tts")
	if err != nil {
		return errors.Wrap(err, "failed create tempfile")
	}

	defer func() {
		out.Close()
		os.Remove(out.Name())
	}()

	if err := ioutil.WriteFile(out.Name(), resp.AudioContent, 0644); err != nil {
		return errors.Wrap(err, "failed write contents")
	}

	if err := exec.Command("mpg123", out.Name()).Run(); err != nil {
		return errors.Wrap(err, "failed play")
	}

	return nil
}

package pb

import (
	"anything-tts/log"
	"anything-tts/service"
	"anything-tts/tts"
	"context"
	"encoding/json"
	"fmt"

	"github.com/gorilla/websocket"
	"github.com/pkg/errors"
	"github.com/spf13/viper"
)

type PbService struct {
	AccessToken string
}

type pushMessage struct {
	Type string          `json:"type"`
	Push json.RawMessage `json:"push"`
}

type mirrorMessage struct {
	Type            string `json:"type"`
	Title           string `json:"title"`
	Body            string `json:"body"`
	ApplicationName string `json:"application_name"`
	PackageName     string `json:"package_name"`
}

func (s *PbService) Start() {
	url := fmt.Sprintf("wss://stream.pushbullet.com/websocket/%s", s.AccessToken)

	ctx := context.Background()
	c, _, err := websocket.DefaultDialer.DialContext(ctx, url, nil)
	if err != nil {
		log.Error(errors.Wrap(err, "failed connect pushbullet"), nil)
		return
	}
	defer c.Close()

	for {
		_, msg, err := c.ReadMessage()
		if err != nil {
			log.Error(errors.Wrap(err, "failed read."), nil)
			return
		}

		var pmsg pushMessage
		if err := json.Unmarshal(msg, &pmsg); err != nil {
			log.Error(errors.Wrap(err, "failed json unmarshal."), nil)
			return
		}

		switch pmsg.Type {
		case "push":

			var mm mirrorMessage
			if err := json.Unmarshal(pmsg.Push, &mm); err != nil {
				log.Error(errors.Wrap(err, "failed json unmarshal."), nil)
				return
			}
			log.Debug("recv push", log.Fields{
				"app":   mm.ApplicationName,
				"type":  mm.Type,
				"title": mm.Title,
				"body":  mm.Body,
			})

			switch mm.Type {
			case "mirror":
				if err := speechMirror(ctx, mm); err != nil {
					log.Error(err, nil)
					return
				}

			}
		}
	}

}

func speechMirror(ctx context.Context, mm mirrorMessage) error {
	if err := tts.Speech(ctx, fmt.Sprintf("%sからの通知", mm.ApplicationName)); err != nil {
		return errors.Wrap(err, "failed speech.")
	}
	if err := tts.Speech(ctx, mm.Title); err != nil {
		return errors.Wrap(err, "failed speech.")
	}
	if err := tts.Speech(ctx, mm.Body); err != nil {
		return errors.Wrap(err, "failed speech.")
	}
	return nil
}

func NewService() service.Service {

	token := viper.GetString("pushbullet.access_token")
	log.Debug("pushbullet service", log.Fields{
		"token": token,
	})

	return &PbService{
		AccessToken: token,
	}

}

package dbus

import (
	"anything-tts/log"
	"anything-tts/service"
	"anything-tts/tts"
	"context"
	"encoding/json"

	"github.com/godbus/dbus/v5"
	"github.com/pkg/errors"
)

type notification struct {
	Type int           `json:"Type"`
	Body []interface{} `json:"Body"`
}

type DbusService struct {
}

func (s *DbusService) Start() {
	ctx := context.Background()

	conn, err := dbus.SessionBus()
	if err != nil {
		log.Error(errors.Wrap(err, "failed connect d-bus"), nil)
		return
	}
	var rules = []string{
		"type='method_call',member='Notify',path='/org/freedesktop/Notifications',interface='org.freedesktop.Notifications'",
	}
	var flag uint = 0

	call := conn.BusObject().Call("org.freedesktop.DBus.Monitoring.BecomeMonitor", 0, rules, flag)
	if call.Err != nil {
		log.Error(errors.Wrap(call.Err, "failed to become monitor"), nil)
		return
	}

	c := make(chan *dbus.Message, 10)
	conn.Eavesdrop(c)
	log.Debug("Monitoring notifications", nil)
	for v := range c {
		data, err := json.Marshal(v)
		if err != nil {
			log.Error(errors.Wrap(err, "failed marshall"), nil)
			return
		}

		var n notification
		if err := json.Unmarshal(data, &n); err != nil {
			log.Error(errors.Wrap(err, "failed unmarshall"), nil)
			return
		}
		if n.Type == 1 {
			app := n.Body[0].(string)
			title := n.Body[3].(string)
			message := n.Body[4].(string)

			log.Debug("dbus", log.Fields{
				"app":     app,
				"title":   title,
				"message": message,
			})
			if err := speech(ctx, app, title, message); err != nil {
				log.Error(err, nil)
				return
			}

		}
	}
}

func speech(ctx context.Context, app, title, msg string) error {
	if err := tts.Speech(ctx, title); err != nil {
		return errors.Wrap(err, "failed speech.")
	}
	if err := tts.Speech(ctx, msg); err != nil {
		return errors.Wrap(err, "failed speech.")
	}
	return nil
}

func NewService() service.Service {

	return &DbusService{}
}