Add Soft Access Point configuration for ESP32 (#91)

Author: AdrianSoundy

source/nanoFramework.System.Net/NetworkInformation/AuthenticationType.cs

@@ -0,0 +1,57 @@
+//
+// Copyright (c) 2019 The nanoFramework project contributors
+// See LICENSE file in the project root for full license information.
+
+namespace System.Net.NetworkInformation
+{
+    /// <summary>
+    /// Specifies the authentication used in a wireless network.
+    /// </summary>
+    public enum AuthenticationType : byte
+    {
+        /// <summary>
+        /// No protocol.
+        /// </summary>
+        None = 0,
+
+        /// <summary>
+        /// Extensible Authentication Protocol.
+        /// </summary>
+        EAP,
+
+        /// <summary>
+        /// Protected Extensible Authentication Protocol.
+        /// </summary>
+        PEAP,
+
+        /// <summary>
+        /// Microsoft Windows Connect Now protocol.
+        /// </summary>
+        WCN,
+
+        /// <summary>
+        /// Open System authentication, for use with WEP encryption type.
+        /// </summary>
+        Open,
+
+        /// <summary>
+        /// Shared Key authentication, for use with WEP encryption type.
+        /// </summary>
+        Shared,
+
+        /// <summary>
+        /// Wired Equivalent Privacy protocol.
+        /// </summary>
+        WEP,
+
+        /// <summary>
+        /// Wi-Fi Protected Access protocol.
+        /// </summary>
+        WPA,
+
+        /// <summary>
+        /// Wi-Fi Protected Access 2 protocol.
+        /// </summary>
+        WPA2,
+    }
+}

source/nanoFramework.System.Net/NetworkInformation/EncryptionType.cs

@@ -0,0 +1,47 @@
+//
+// Copyright (c) 2019 The nanoFramework project contributors
+// See LICENSE file in the project root for full license information.
+
+namespace System.Net.NetworkInformation
+{
+    /// <summary>
+    /// Defines the available types of encryption for wireless networks.
+    /// </summary>
+    public enum EncryptionType : byte
+    {
+        /// <summary>
+        /// No encryption.
+        /// </summary>
+        None = 0,
+
+        /// <summary>
+        /// Wired Equivalent Privacy encryption.
+        /// </summary>
+        WEP,
+
+        /// <summary>
+        /// Wireless Protected Access encryption.
+        /// </summary>
+        WPA,
+
+        /// <summary>
+        /// Wireless Protected Access 2 encryption.
+        /// </summary>
+        WPA2,
+
+        /// <summary>
+        /// Wireless Protected Access Pre-Shared Key encryption.
+        /// </summary>
+        WPA_PSK,
+
+        /// <summary>
+        /// Wireless Protected Access 2 Pre-Shared Key encryption.
+        /// </summary>
+        WPA2_PSK,
+
+        /// <summary>
+        /// Certificate encryption.
+        /// </summary>
+        Certificate,
+    }
+}

source/nanoFramework.System.Net/NetworkInformation/NetworkChange.cs

@@ -13,7 +13,9 @@ namespace System.Net.NetworkInformation
     /// </summary>
     public class NetworkAvailabilityEventArgs : EventArgs
     {
-        private bool _isAvailable;
+#pragma warning disable IDE0032 // nanoFramework doesn't support auto-properties
+        private readonly bool _isAvailable;
+#pragma warning disable IDE0032 // nanoFramework doesn't support auto-properties
 
         internal NetworkAvailabilityEventArgs(bool isAvailable)
         {
@@ -23,28 +25,55 @@ internal NetworkAvailabilityEventArgs(bool isAvailable)
         /// <summary>
         /// Indicates whether the network is currently available.
         /// </summary>
-        public bool IsAvailable
+        public bool IsAvailable => _isAvailable;
+    }
+
+    /// <summary>
+    /// Contains argument values for network availability events.
+    /// </summary>
+    public class NetworkAPStationEventArgs : EventArgs
+    {
+        private readonly int _stationIndex;
+        private readonly bool _isConnected;
+
+        internal NetworkAPStationEventArgs(bool isConnected, int StationIndex)
         {
-            get
-            {
-                return _isAvailable;
-            }
+            _isConnected = isConnected;
+            _stationIndex = StationIndex;
         }
+
+        /// <summary>
+        /// Indicates whether the client has connected or disconnected.
+        /// </summary>
+        public bool IsConnected { get => _isConnected;  }
+
+        /// <summary>
+        /// Returns the Index of the connected Station.
+        /// </summary>
+        public int StationIndex { get => _stationIndex; }
     }
 
+
     /// <summary>
     /// Provides an event handler that is called when the network address changes.
     /// </summary>
     /// <param name="sender">Specifies the object that sent the network address changed event. </param>
     /// <param name="e">Contains the network address changed event arguments. </param>
-    public delegate void NetworkAvailabilityChangedEventHandler(Object sender, NetworkAvailabilityEventArgs e);
+    public delegate void NetworkAvailabilityChangedEventHandler(object sender, NetworkAvailabilityEventArgs e);
 
     /// <summary>
     /// Indicates a change in the availability of the network.
     /// </summary>
     /// <param name="sender">Specifies the object that sent the network availability changed event. </param>
     /// <param name="e">Contains the network availability changed event arguments. </param>
-    public delegate void NetworkAddressChangedEventHandler(Object sender, EventArgs e);
+    public delegate void NetworkAddressChangedEventHandler(object sender, EventArgs e);
+
+    /// <summary>
+    /// Indicates a change in the connected clients to Access Point.
+    /// </summary>
+    /// <param name="NetworkIndex">Specifies the index of network interface that sent the event. </param>
+    /// <param name="e">Contains the network AP client changed event arguments. </param>
+    public delegate void NetworkAPStationChangedEventHandler(int NetworkIndex, NetworkAPStationEventArgs e);
 
     /// <summary>
     /// Contains information about changes in the availability and address of the network.
@@ -57,10 +86,11 @@ internal enum NetworkEventType : byte
             Invalid = 0,
             AvailabilityChanged = 1,
             AddressChanged = 2,
+            APStationChanged = 3,
         }
 
         [Flags]
-        internal enum NetworkEventFlags : byte
+        internal enum NetworkEvents : byte
         {
             NetworkAvailable = 0x1,
         }
@@ -69,30 +99,38 @@ internal class NetworkEvent : BaseEvent
         {
             public NetworkEventType EventType;
             public byte Flags;
+            public ushort Index;
+            public ushort Data;
             public DateTime Time;
         }
 
         internal class NetworkChangeListener : IEventListener, IEventProcessor
         {
             public void InitializeForEventSource()
             {
+                // Method intentionally left empty.
             }
 
             public BaseEvent ProcessEvent(uint data1, uint data2, DateTime time)
             {
                 NetworkEvent networkEvent = new NetworkEvent();
                 networkEvent.EventType = (NetworkEventType)(data1 & 0xFF);
                 networkEvent.Flags = (byte)((data1 >> 16) & 0xFF);
+
+                // Data2 - Low 8 bits are the Network interface index
+                //         Top 8 bits extra data ( i.e AP station index )
+                networkEvent.Index = (ushort)(data2 & 0xff);
+                networkEvent.Data =  (ushort)(data2 >> 8);
                 networkEvent.Time = time;
 
                 return networkEvent;
             }
 
             public bool OnEvent(BaseEvent ev)
             {
-                if (ev is NetworkEvent)
+                if (ev is NetworkEvent myEvent)
                 {
-                    NetworkChange.OnNetworkChangeCallback((NetworkEvent)ev);
+                    OnNetworkChangeCallback(myEvent);
                 }
 
                 return true;
@@ -123,6 +161,18 @@ public bool OnEvent(BaseEvent ev)
         /// </remarks>
         public static event NetworkAvailabilityChangedEventHandler NetworkAvailabilityChanged;
 
+        /// <summary>
+        /// Event occurs when a station connects or disconnects from Soft Access Point.
+        /// </summary>
+        /// <remarks>
+        /// The NetworkChange class raises the NetworkAPStationChanged events when a client 
+        /// connects or disconnects from the Soft AP. 
+        /// 
+        /// To have a NetworkChange object call an event-handling method when a NetworkAPStationChanged event occurs, 
+        /// you must associate the method with a NetworkAPStationChangedEventHandler delegate, and add this delegate to this event. 
+        /// </remarks>
+        public static event NetworkAPStationChangedEventHandler NetworkAPStationChanged;
+
         static NetworkChange()
         {
             NetworkChangeListener networkChangeListener = new NetworkChangeListener();
@@ -134,33 +184,41 @@ static NetworkChange()
 
         internal static void OnNetworkChangeCallback(NetworkEvent networkEvent)
         {
+     
             switch (networkEvent.EventType)
             {
                 case NetworkEventType.AvailabilityChanged:
+                    if (NetworkAvailabilityChanged != null)
                     {
-                        if (NetworkAvailabilityChanged != null)
-                        {
-                            bool isAvailable = ((networkEvent.Flags & (byte)NetworkEventFlags.NetworkAvailable) != 0);
-                            NetworkAvailabilityEventArgs args = new NetworkAvailabilityEventArgs(isAvailable);
-
-                            NetworkAvailabilityChanged(null, args);
-                        }
-                        break;
+                        bool isAvailable = ((networkEvent.Flags & (byte)NetworkEvents.NetworkAvailable) != 0);
+                        NetworkAvailabilityEventArgs args = new NetworkAvailabilityEventArgs(isAvailable);
+
+                        NetworkAvailabilityChanged(networkEvent.Index, args);
                     }
+                    break;
+
                 case NetworkEventType.AddressChanged:
+                    if (NetworkAddressChanged != null)
                     {
-                        if (NetworkAddressChanged != null)
-                        {
-                            EventArgs args = new EventArgs();
-                            NetworkAddressChanged(null, args);
-                        }
-
-                        break;
+                        EventArgs args = new EventArgs();
+                        NetworkAddressChanged(networkEvent.Index, args);
                     }
-                default:
+
+                    break;
+
+                case NetworkEventType.APStationChanged:
+                    if (NetworkAPStationChanged != null)
                     {
-                        break;
+                        bool isConnected = ((networkEvent.Flags & (byte)NetworkEvents.NetworkAvailable) != 0);
+                            
+                        NetworkAPStationEventArgs args = new NetworkAPStationEventArgs(isConnected, networkEvent.Data);
+                    
+                        NetworkAPStationChanged(networkEvent.Index, args);
                     }
+                    break;
+
+                default:
+                    break;
             }
         }
     }

source/nanoFramework.System.Net/NetworkInformation/NetworkInterfaceType.cs

@@ -32,5 +32,11 @@ public enum NetworkInterfaceType
         /// The network interface uses a wireless LAN connection (IEEE 802.11 standard).
         /// </summary>
         Wireless80211 = 71,
+
+        /// <summary>
+        /// The network interface uses a wireless Soft AP connection (IEEE 802.11 standard).
+        /// </summary>
+        WirelessAP = 72,
+
     }
 }

source/nanoFramework.System.Net/NetworkInformation/RadioType.cs

@@ -0,0 +1,37 @@
+//
+// Copyright (c) 2019 The nanoFramework project contributors
+// See LICENSE file in the project root for full license information.
+
+namespace System.Net.NetworkInformation
+{
+    /// <summary>
+    /// Specifies the type of radio that the wireless network uses.
+    /// </summary>
+    public enum RadioType : byte
+    {
+        /// <summary>
+        /// Not specified.
+        /// </summary>
+        NotSpecified = 0,
+
+        /// <summary>
+        /// 802.11a-compatible radio.
+        /// </summary>
+        _802_11a = 1,
+
+        /// <summary>
+        /// 802.11b-compatible radio.
+        /// </summary>
+        _802_11b = 2,
+
+        /// <summary>
+        /// 802.11g-compatible radio.
+        /// </summary>
+        _802_11g = 4,
+
+        /// <summary>
+        /// 802.11n-compatible radio.
+        /// </summary>
+        _802_11n = 8,
+    }
+}