Concept from here.

Should be as simple as posting with a file payload then processing the response(s).

Then building a connect web-page which will list the device currently connected and a list of devices we can connect to (possibly include if they are tvs or the roku stick)

TODO:

• Perform a successful post to the magic ip they provide to query for roku:ecp
• Build a web-page which is shown at /connect, provide a button for connect if we get a error/invalid response (the button should simply redirect to /connect from /)
• Add to the web-page currently connected to and support a "refresh" button which performs the query for roku ecp controllable devices
• Add to the web-page a list of a button and text showing all roku devices found by "refresh". (If one of the buttons is clicked support setting the device we are "connected")
• Test this feature (The more we use this, the more I will know where to improve it)

Current issues:

• We fail to process inbound UDP responses from our query for roku devices

Our current code as of [1c9271817e] is in a failing state

Pressing 'Connect' then 'Reload' will cause a Internal Server Error (500) code to be sent to the user, even before any possible responses have been received.

Top issues:

• I don't quite understand concurrency in general much less in Go.
• I think I need to have extra eyes to know how to improve the current code or even a rewrite of the code.
• I think the solution is to make a go channel for storing ips as strings then as I receive responses stuff the ip I got a response from into that channel. (Then I'd have something read that go channel and form a list of strings to be shown and selected)
• I'm fairly sure I have the code where a list of strings will be listed (each being buttons) then making it so we can connect to the new selected ip. (But since I'm failing to properly receive the UDP responses I don't know if it works)

@stevet Ping?

Ok, I think we need ListenMulticastUDP.

I did see some weird go code:

GetDevices():

There's no way to know when GetFind updates &str.

GetFind():
  for {
  }

Then after the infinite loop, you assign *data = list.

^ Ok, it isn't infinite -- it COULD break, if there's an error from ReadFromUDP. But the probability of that is 0.

There's lots of "Strings that end with\r\n". ? What?

You're not sending out strings to a dumb BBS terminal. "\n"

I found https://github.com/dmichael/go-multicast which appears to be a broken go package so we'd have to fiddle with it to get it to work. (:S)

The infinite loop where afterwards I assign *data = list will fail once it hits the 3 seconds as per ln.SetReadDeadline(time.Now().Add(3 * time.Second)) (SetReadDeadline, if we fail to read anything in 3 seconds it will exit the loop)

RequestUDP.png is M-SEARCH.

ResponseUDP.png is the reply the TV did.

package main

import (
    "fmt"
    "log"
    "net"
    "os"
    "time"
)

func PostFind() {
    file, err := os.ReadFile("finder.txt")
    if err != nil {
        log.Print(err)
    }
    addr, err := net.ResolveUDPAddr("udp", "239.255.255.250:1900")
    if err != nil {
        log.Print(err)
    }
    laddr, err := net.ResolveUDPAddr("udp", ":0") // "192.168.254.13:9000")
    if err != nil {
        log.Print(err)
    }
    // "192.168.254.13:9000")

    // conn, err := net.DialUDP("udp", laddr, addr)
    /*
        ListenUDP -- to SEND?  WAT?
        https://github.com/golang/go/issues/13391
        Ok, maybe you don't want to read it -- the developers are cranky when
        asked why Listen would be able to SEND.
    */
    conn, err := net.ListenUDP("udp", laddr)
    if err != nil {
        log.Print(err)
    }
    defer conn.Close()

    conn.WriteTo(file, addr)
    // conn.Write(file)
    log.Println("Posted Request for devices")

    conn.SetReadDeadline(time.Now().Add(time.Second * time.Duration(5)))
    buffer := make([]byte, 512)
    n, fromaddr, err := conn.ReadFrom(buffer) //  Read(buffer)
    fmt.Printf("%d, %#v, %#v\n", n, fromaddr, err)

    var output string = string(buffer[0:n])
    fmt.Printf("GOT: [%s]\n", output)
    // log.Printf("Read: %#v\n", buffer)

}

func main() {
    fmt.Println("Start:")
    PostFind()
    fmt.Println("Done!")
}

In the future I will probably want to rework the code to support multiple Roku device responses.

Since we only have 1 device to test with we don't need the multi-device support (Not that it would be too difficult to support multiple responses and adding them to a list)