mn_wifi_ap.hpp

Go to the documentation of this file.

 
#ifndef __MINILIB_NET_WIFI_AP_H__
#define __MINILIB_NET_WIFI_AP_H__
 
#include "../mn_config.hpp"
 
#include "../net/mn_basic_ip4_address.hpp"
#include "mn_wifi.hpp"
 
namespace mn {
    namespace device {
 
        class basic_wifi_ap : public basic_wifi, public basic_network_device {
            using base_type = basic_wifi;
        public:
 
            using ip4_adress_t = net::basic_ip4_address;
            using auth_mode_t = typename base_type::auth_mode;
            using interface_t = typename base_type::wifi_interface_type;
 
            basic_wifi_ap() : basic_wifi(interface_t::Acesspoint),
                              basic_network_device("wifiap") { }
            ~basic_wifi_ap() { stop(true); }
 
            basic_wifi_ap(const basic_wifi_ap& other) = delete;
            basic_wifi_ap& operator = (const basic_wifi_ap& other) = delete;
 
            int start(const char* ssid, auth_mode_t mode = auth_mode_t::Open, const char* passphrase = "",
                   bool storeCfgToFlash = false,
                   bool ipv6 = false, int channel = 13, bool ssid_hidden = false,
                   int max_connection = 4);
 
            int set_ipinfo(const ip4_adress_t& local_ip, const ip4_adress_t& gateway, const ip4_adress_t& subnet);
 
            int get_ipinfo(ip4_adress_t& local_ip, ip4_adress_t& gateway, ip4_adress_t& subnet) override {
                local_ip = get_ip();        if(local_ip == MNNET_IPV4_ADDRESS_NONE) return -1;
                gateway = get_gateway();    if(gateway  == MNNET_IPV4_ADDRESS_NONE) return -2;
                subnet = get_netmask();     if(subnet   == MNNET_IPV4_ADDRESS_NONE) return -3;
 
                return 0;
            }
            bool stop(bool wifioff) override;
 
            virtual ip4_adress_t      get_ip();
            virtual ip4_adress_t      get_broadcast();
            virtual ip4_adress_t      get_gateway();
            virtual ip4_adress_t      get_netmask();
 
            virtual const char*       get_hostname();
            virtual bool              set_hostname(const char*  hostname);
            virtual uint8_t*          get_mac(uint8_t* mac);
            virtual const char*       get_mac();
            virtual uint32_t          get_connected();
 
            operator uint32_t()     { return get_connected(); }
            operator ip4_adress_t() { return get_ip(); }
            operator const char*()  { return get_hostname(); }
 
            // basic_network_device
        public:
            int     stop() override { return stop(true) ? 0 : 1; }
            int     open() override { if(is_enable()) return 0; else return -1; }
            bool    is_enable() override { return (get_mode() != WIFI_MODE_NULL); }
            bool    is_stream_support() override { return false; }
        protected:
            tcpip_adapter_ip_info_t get_ip_infos();
 
            virtual void on_wifi_event(esp_event_base_t event_base, int32_t event_id, void* event_data) override;
 
            virtual void on_start(esp_event_base_t event_base, void* event_data) { }
            virtual void on_stop(esp_event_base_t event_base, void* event_data) { }
            virtual void on_connected(esp_event_base_t event_base,void* event_data) { }
            virtual void on_disconnected(esp_event_base_t event_base, void* event_data) { }
            virtual void on_probereqrec(esp_event_base_t event_base, void* event_data) { }
 
        };
    }
}
 
 
#endif // __MINILIB_NET_WIFI_AP_H__