remoteApp.go

package tsremote

import (
	"encoding/json"
	"fmt"
	"log"
	"os"
	"os/signal"

	"github.com/jkoenig134/ts-remote-app/event"
	"github.com/jkoenig134/ts-remote-app/publisher"

	"github.com/gorilla/websocket"
)

type RemoteApp struct {
	apiKeyProvider ApiKeyProvider
	c              *websocket.Conn
	authorized     bool
	eventPublisher publisher.AppClientEventPublisher
	wsUrl          string
}

type NewTsAppParams struct {
	Host string
	Port int
}

func NewTsApp(provider ApiKeyProvider, p NewTsAppParams) RemoteApp {
	if p.Host == "" {
		p.Host = "localhost"
	}

	if p.Port == 0 {
		p.Port = 5899
	}

	wsUrl := fmt.Sprintf("ws://%s:%d", p.Host, p.Port)
	return RemoteApp{
		apiKeyProvider: provider,
		authorized:     false,
		eventPublisher: publisher.NewParser(),
		wsUrl:          wsUrl,
	}
}

func (app *RemoteApp) Disconnect() {
	if app.c != nil {
		_ = app.c.WriteMessage(websocket.CloseMessage, websocket.FormatCloseMessage(websocket.CloseNormalClosure, ""))
		_ = app.c.Close()
		app.c = nil
	}

	app.authorized = false
	app.eventPublisher.PublishEvent(event.DisconnectEvent)
}

func (app *RemoteApp) Connect() error {
	interrupt := make(chan os.Signal, 1)
	signal.Notify(interrupt, os.Interrupt)

	c, _, err := websocket.DefaultDialer.Dial(app.wsUrl, nil)
	if err != nil {
		return err
	}

	app.c = c

	go app.receive()

	return nil
}

func (app *RemoteApp) SubscribeEvent(event event.AppEvent, fn interface{}) error {
	return app.eventPublisher.SubscribeEvent(event, fn)
}

func (app *RemoteApp) UnsubscribeEvent(event event.AppEvent, handler interface{}) error {
	return app.eventPublisher.UnsubscribeEvent(event, handler)
}

type TypeScan struct {
	Type string `json:"type"`
}

func (app *RemoteApp) receive() {
	defer app.Disconnect()
	for {
		_, message, err := app.c.ReadMessage()
		if err != nil {
			return
		}

		resp := TypeScan{}
		if err = json.Unmarshal(message, &resp); err != nil {

			app.eventPublisher.PublishEvent(event.ErrorEvent, fmt.Errorf("deserialize: %s", message))
			continue
		}

		switch resp.Type {
		case "auth":
			if key := app.eventPublisher.HandleAuthResponse(message); key != nil {
				app.authorized = true
				app.apiKeyProvider.SetApiKey(*key)
			}
		case "clientSelfPropertyUpdated":
			app.eventPublisher.HandleClientSelfPropertyUpdated(message)
		case "clientPropertiesUpdated":
			app.eventPublisher.HandleClientPropertyUpdated(message)
		case "connectStatusChanged":
			app.eventPublisher.HandleConnectStatusChanged(message)
		case "channelsSubscribed":
			app.eventPublisher.HandleChannelsSubscribed(message)
		case "clientMoved":
			app.eventPublisher.HandleClientMoved(message)
		case "channelPropertiesUpdated":
			app.eventPublisher.HandleChannelPropertiesUpdated(message)
		case "clientChannelGroupChanged":
			app.eventPublisher.HandleClientChannelGroupChanged(message)
		case "channels":
			app.eventPublisher.HandleChannels(message)
		case "groupInfo":
			app.eventPublisher.HandleGroupInfo(message)
		case "permissionList":
			app.eventPublisher.HandlePermissionList(message)
		case "serverPropertiesUpdated":
			app.eventPublisher.HandleServerPropertiesUpdated(message)
		case "neededPermissions":
			app.eventPublisher.HandleNeededPermissions(message)
		case "buttonPress":
			app.eventPublisher.HandleButtonPress(message)

		default:
			log.Printf("not recognized event %s: %s\n", resp.Type, string(message))
		}
	}
}