Mobile (#735)

Initial modification to support mobile client

Export necessary interfaces for Android framework

client/internal/peer/conn.go

@@ -9,6 +9,7 @@ import (
 	"time"
 
 	"github.com/pion/ice/v2"
+	"github.com/pion/transport/v2/stdnet"
 	log "github.com/sirupsen/logrus"
 	"golang.zx2c4.com/wireguard/wgctrl"
 
@@ -161,7 +162,10 @@ func (conn *Conn) reCreateAgent() error {
 	defer conn.mu.Unlock()
 
 	failedTimeout := 6 * time.Second
-	var err error
+	transportNet, err := stdnet.NewNet()
+	if err != nil {
+		log.Warnf("failed to create pion's stdnet: %s", err)
+	}
 	agentConfig := &ice.AgentConfig{
 		MulticastDNSMode: ice.MulticastDNSModeDisabled,
 		NetworkTypes:     []ice.NetworkType{ice.NetworkTypeUDP4, ice.NetworkTypeUDP6},
@@ -172,6 +176,7 @@ func (conn *Conn) reCreateAgent() error {
 		UDPMux:           conn.config.UDPMux,
 		UDPMuxSrflx:      conn.config.UDPMuxSrflx,
 		NAT1To1IPs:       conn.config.NATExternalIPs,
+		Net:              transportNet,
 	}
 
 	if conn.config.DisableIPv6Discovery {

client/internal/peer/listener.go

@@ -0,0 +1,9 @@
+package peer
+
+// Listener is a callback type about the NetBird network connection state
+type Listener interface {
+	OnConnected()
+	OnDisconnected()
+	OnConnecting()
+	OnPeersListChanged(int)
+}

client/internal/peer/notifier.go

@@ -0,0 +1,124 @@
+package peer
+
+import (
+	"sync"
+)
+
+const (
+	stateDisconnected = iota
+	stateConnected
+	stateConnecting
+)
+
+type notifier struct {
+	serverStateLock    sync.Mutex
+	listenersLock      sync.Mutex
+	listeners          map[Listener]struct{}
+	currentServerState bool
+	currentClientState bool
+	lastNotification   int
+}
+
+func newNotifier() *notifier {
+	return &notifier{
+		listeners: make(map[Listener]struct{}),
+	}
+}
+
+func (n *notifier) addListener(listener Listener) {
+	n.listenersLock.Lock()
+	defer n.listenersLock.Unlock()
+
+	n.serverStateLock.Lock()
+	go n.notifyListener(listener, n.lastNotification)
+	n.serverStateLock.Unlock()
+	n.listeners[listener] = struct{}{}
+}
+
+func (n *notifier) removeListener(listener Listener) {
+	n.listenersLock.Lock()
+	defer n.listenersLock.Unlock()
+	delete(n.listeners, listener)
+}
+
+func (n *notifier) updateServerStates(mgmState bool, signalState bool) {
+	n.serverStateLock.Lock()
+	defer n.serverStateLock.Unlock()
+
+	var newState bool
+	if mgmState && signalState {
+		newState = true
+	} else {
+		newState = false
+	}
+
+	if !n.isServerStateChanged(newState) {
+		return
+	}
+
+	n.currentServerState = newState
+	n.lastNotification = n.calculateState(newState, n.currentClientState)
+
+	go n.notifyAll(n.lastNotification)
+}
+
+func (n *notifier) clientStart() {
+	n.serverStateLock.Lock()
+	defer n.serverStateLock.Unlock()
+	n.currentClientState = true
+	n.lastNotification = n.calculateState(n.currentServerState, true)
+	go n.notifyAll(n.lastNotification)
+}
+
+func (n *notifier) clientStop() {
+	n.serverStateLock.Lock()
+	defer n.serverStateLock.Unlock()
+	n.currentClientState = false
+	n.lastNotification = n.calculateState(n.currentServerState, false)
+	go n.notifyAll(n.lastNotification)
+}
+
+func (n *notifier) isServerStateChanged(newState bool) bool {
+	return n.currentServerState != newState
+}
+
+func (n *notifier) notifyAll(state int) {
+	n.listenersLock.Lock()
+	defer n.listenersLock.Unlock()
+
+	for l := range n.listeners {
+		n.notifyListener(l, state)
+	}
+}
+
+func (n *notifier) notifyListener(l Listener, state int) {
+	switch state {
+	case stateDisconnected:
+		l.OnDisconnected()
+	case stateConnected:
+		l.OnConnected()
+	case stateConnecting:
+		l.OnConnecting()
+	}
+}
+
+func (n *notifier) calculateState(serverState bool, clientState bool) int {
+	if serverState && clientState {
+		return stateConnected
+	}
+
+	if !clientState {
+		return stateDisconnected
+	}
+
+	return stateConnecting
+}
+
+func (n *notifier) peerListChanged(numOfPeers int) {
+	n.listenersLock.Lock()
+	defer n.listenersLock.Unlock()
+
+	for l := range n.listeners {
+		l.OnPeersListChanged(numOfPeers)
+	}
+}

client/internal/peer/notifier_test.go

@@ -0,0 +1,32 @@
+package peer
+
+import (
+	"testing"
+)
+
+func Test_notifier_serverState(t *testing.T) {
+
+	type scenario struct {
+		name        string
+		expected    bool
+		mgmState    bool
+		signalState bool
+	}
+	scenarios := []scenario{
+		{"connected", true, true, true},
+		{"mgm down", false, false, true},
+		{"signal down", false, true, false},
+		{"disconnected", false, false, false},
+	}
+
+	for _, tt := range scenarios {
+		t.Run(tt.name, func(t *testing.T) {
+			n := newNotifier()
+			n.updateServerStates(tt.mgmState, tt.signalState)
+			if n.currentServerState != tt.expected {
+				t.Errorf("invalid serverstate: %t, expected: %t", n.currentServerState, tt.expected)
+			}
+
+		})
+	}
+}

client/internal/peer/status.go

@@ -58,6 +58,7 @@ type Status struct {
 	offlinePeers    []State
 	mgmAddress      string
 	signalAddress   string
+	notifier        *notifier
 }
 
 // NewRecorder returns a new Status instance
@@ -66,6 +67,7 @@ func NewRecorder(mgmAddress string) *Status {
 		peers:        make(map[string]State),
 		changeNotify: make(map[string]chan struct{}),
 		offlinePeers: make([]State, 0),
+		notifier:     newNotifier(),
 		mgmAddress:   mgmAddress,
 	}
 }
@@ -114,6 +116,7 @@ func (d *Status) RemovePeer(peerPubKey string) error {
 		return nil
 	}
 
+	d.notifyPeerListChanged()
 	return errors.New("no peer with to remove")
 }
 
@@ -148,6 +151,7 @@ func (d *Status) UpdatePeerState(receivedState State) error {
 		d.changeNotify[receivedState.PubKey] = nil
 	}
 
+	d.notifyPeerListChanged()
 	return nil
 }
 
@@ -164,6 +168,7 @@ func (d *Status) UpdatePeerFQDN(peerPubKey, fqdn string) error {
 	peerState.FQDN = fqdn
 	d.peers[peerPubKey] = peerState
 
+	d.notifyPeerListChanged()
 	return nil
 }
 
@@ -199,6 +204,8 @@ func (d *Status) CleanLocalPeerState() {
 func (d *Status) MarkManagementDisconnected() {
 	d.mux.Lock()
 	defer d.mux.Unlock()
+	defer d.onConnectionChanged()
+
 	d.managementState = false
 }
 
@@ -206,7 +213,9 @@ func (d *Status) MarkManagementDisconnected() {
 func (d *Status) MarkManagementConnected() {
 	d.mux.Lock()
 	defer d.mux.Unlock()
-	d.managementState = true
+	defer d.onConnectionChanged()
+
+    d.managementState = true
 }
 
 // UpdateSignalAddress update the address of the signal server
@@ -227,13 +236,17 @@ func (d *Status) UpdateManagementAddress(mgmAddress string) {
 func (d *Status) MarkSignalDisconnected() {
 	d.mux.Lock()
 	defer d.mux.Unlock()
-	d.signalState = false
+	defer d.onConnectionChanged()
+
+    d.signalState = false
 }
 
 // MarkSignalConnected sets SignalState to connected
 func (d *Status) MarkSignalConnected() {
 	d.mux.Lock()
 	defer d.mux.Unlock()
+	defer d.onConnectionChanged()
+
 	d.signalState = true
 }
 
@@ -262,3 +275,31 @@ func (d *Status) GetFullStatus() FullStatus {
 
 	return fullStatus
 }
+
+// ClientStart will notify all listeners about the new service state
+func (d *Status) ClientStart() {
+	d.notifier.clientStart()
+}
+
+// ClientStop will notify all listeners about the new service state
+func (d *Status) ClientStop() {
+	d.notifier.clientStop()
+}
+
+// AddConnectionListener add a listener to the notifier
+func (d *Status) AddConnectionListener(listener Listener) {
+	d.notifier.addListener(listener)
+}
+
+// RemoveConnectionListener remove a listener from the notifier
+func (d *Status) RemoveConnectionListener(listener Listener) {
+	d.notifier.removeListener(listener)
+}
+
+func (d *Status) onConnectionChanged() {
+	d.notifier.updateServerStates(d.managementState, d.signalState)
+}
+
+func (d *Status) notifyPeerListChanged() {
+	d.notifier.peerListChanged(len(d.peers))
+}