DataChannels: OpenChannel & OnOpen

- OpenChannel messages are now sent after SCTP is Established.
- The OnOpen handler tells the application when a channel has opened.

Relates to #159

examples/data-channels/main.go

@@ -7,7 +7,6 @@ import (
 	"io"
 	"math/rand"
 	"os"
-	"sync"
 	"time"
 
 	"github.com/pions/webrtc"
@@ -15,61 +14,52 @@ import (
 	"github.com/pions/webrtc/pkg/ice"
 )
 
-func randSeq(n int) string {
-	r := rand.New(rand.NewSource(time.Now().UnixNano()))
-	letters := []rune("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ")
-	b := make([]rune, n)
-	for i := range b {
-		b[i] = letters[r.Intn(len(letters))]
-	}
-	return string(b)
-}
-
 func main() {
-	reader := bufio.NewReader(os.Stdin)
-	rawSd, err := reader.ReadString('\n')
-	if err != nil && err != io.EOF {
-		panic(err)
-	}
-
-	fmt.Println("")
-	sd, err := base64.StdEncoding.DecodeString(rawSd)
-	if err != nil {
-		panic(err)
-	}
+	// Wait for the offer to be pasted
+	sd := mustReadStdin()
 
 	/* Everything below is the pion-WebRTC API, thanks for using it! */
 
-	// Create a new RTCPeerConnection
-	peerConnection, err := webrtc.New(webrtc.RTCConfiguration{
+	// Prepare the configuration
+	config := webrtc.RTCConfiguration{
 		IceServers: []webrtc.RTCIceServer{
 			{
 				URLs: []string{"stun:stun.l.google.com:19302"},
 			},
 		},
-	})
-	if err != nil {
-		panic(err)
 	}
 
+	// Create a new RTCPeerConnection
+	peerConnection, err := webrtc.New(config)
+	check(err)
+
 	// Set the handler for ICE connection state
 	// This will notify you when the peer has connected/disconnected
 	peerConnection.OnICEConnectionStateChange = func(connectionState ice.ConnectionState) {
-		fmt.Printf("Connection State has changed %s \n", connectionState.String())
+		fmt.Printf("ICE Connection State has changed: %s\n", connectionState.String())
 	}
 
-	datachannels := make([]*webrtc.RTCDataChannel, 0)
-	var dataChannelsLock sync.RWMutex
-
+	// Register data channel creation handling
 	peerConnection.OnDataChannel = func(d *webrtc.RTCDataChannel) {
-		dataChannelsLock.Lock()
-		datachannels = append(datachannels, d)
-		dataChannelsLock.Unlock()
-
 		fmt.Printf("New DataChannel %s %d\n", d.Label, d.ID)
 
 		d.Lock()
 		defer d.Unlock()
+
+		// Register channel opening handling
+		d.OnOpen = func() {
+			fmt.Printf("Data channel '%s'-'%d' open. Random messages will now be sent to any connected DataChannels every 5 seconds\n", d.Label, d.ID)
+			for {
+				time.Sleep(5 * time.Second)
+				message := randSeq(15)
+				fmt.Printf("Sending %s \n", message)
+
+				err := d.Send(datachannel.PayloadString{Data: []byte(message)})
+				check(err)
+			}
+		}
+
+		// Register message handling
 		d.Onmessage = func(payload datachannel.Payload) {
 			switch p := payload.(type) {
 			case *datachannel.PayloadString:
@@ -87,31 +77,50 @@ func main() {
 		Type: webrtc.RTCSdpTypeOffer,
 		Sdp:  string(sd),
 	}
-	if err := peerConnection.SetRemoteDescription(offer); err != nil {
-		panic(err)
-	}
+
+	err = peerConnection.SetRemoteDescription(offer)
+	check(err)
 
 	// Sets the LocalDescription, and starts our UDP listeners
 	answer, err := peerConnection.CreateAnswer(nil)
-	if err != nil {
-		panic(err)
-	}
+	check(err)
 
 	// Get the LocalDescription and take it to base64 so we can paste in browser
 	fmt.Println(base64.StdEncoding.EncodeToString([]byte(answer.Sdp)))
-	fmt.Println("Random messages will now be sent to any connected DataChannels every 5 seconds")
-	for {
-		time.Sleep(5 * time.Second)
-		message := randSeq(15)
-		fmt.Printf("Sending %s \n", message)
 
-		dataChannelsLock.RLock()
-		for _, d := range datachannels {
-			err := d.Send(datachannel.PayloadString{Data: []byte(message)})
-			if err != nil {
-				panic(err)
-			}
-		}
-		dataChannelsLock.RUnlock()
+	// Block forever
+	select {}
+}
+
+func randSeq(n int) string {
+	r := rand.New(rand.NewSource(time.Now().UnixNano()))
+	letters := []rune("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ")
+	b := make([]rune, n)
+	for i := range b {
+		b[i] = letters[r.Intn(len(letters))]
+	}
+	return string(b)
+}
+
+// mustReadStdin blocks untill input is received from stdin
+func mustReadStdin() string {
+	reader := bufio.NewReader(os.Stdin)
+	rawSd, err := reader.ReadString('\n')
+	if err != io.EOF {
+		check(err)
+	}
+
+	fmt.Println("")
+
+	sd, err := base64.StdEncoding.DecodeString(rawSd)
+	check(err)
+
+	return string(sd)
+}
+
+// check is used to panic in an error occurs.
+func check(err error) {
+	if err != nil {
+		panic(err)
 	}
 }