src/platform/Tizen/ConnectivityManagerImpl.h

   1 /*
   2  *
   3  *    Copyright (c) 2020-2021 Project CHIP Authors
   4  *    Copyright (c) 2018 Nest Labs, Inc.
   5  *
   6  *    Licensed under the Apache License, Version 2.0 (the "License");
   7  *    you may not use this file except in compliance with the License.
   8  *    You may obtain a copy of the License at
   9  *
  10  *        http://www.apache.org/licenses/LICENSE-2.0
  11  *
  12  *    Unless required by applicable law or agreed to in writing, software
  13  *    distributed under the License is distributed on an "AS IS" BASIS,
  14  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15  *    See the License for the specific language governing permissions and
  16  *    limitations under the License.
  17  */
  18
  19 #pragma once
  20
  21 #include <platform/ConnectivityManager.h>
  22 #include <platform/internal/GenericConnectivityManagerImpl.h>
  23 #if CHIP_DEVICE_CONFIG_ENABLE_CHIPOBLE
  24 #include <platform/internal/GenericConnectivityManagerImpl_BLE.h>
  25 #else
  26 #include <platform/internal/GenericConnectivityManagerImpl_NoBLE.h>
  27 #endif
  28 #if CHIP_DEVICE_CONFIG_ENABLE_THREAD
  29 #include <platform/internal/GenericConnectivityManagerImpl_Thread.h>
  30 #else
  31 #include <platform/internal/GenericConnectivityManagerImpl_NoThread.h>
  32 #endif
  33 #if CHIP_DEVICE_CONFIG_ENABLE_WPA
  34 #include <platform/internal/GenericConnectivityManagerImpl_WiFi.h>
  35 #else
  36 #include <platform/internal/GenericConnectivityManagerImpl_NoWiFi.h>
  37 #endif
  38
  39 #if CHIP_DEVICE_CONFIG_ENABLE_WPA
  40 #include <platform/Linux/dbus/wpa/DBusWpa.h>
  41 #include <platform/Linux/dbus/wpa/DBusWpaInterface.h>
  42 #include <platform/Linux/dbus/wpa/DBusWpaNetwork.h>
  43 #endif
  44
  45 namespace chip {
  46 namespace Inet {
  47 class IPAddress;
  48 } // namespace Inet
  49 } // namespace chip
  50
  51 namespace chip {
  52 namespace DeviceLayer {
  53
  54 #if CHIP_DEVICE_CONFIG_ENABLE_WPA
  55 struct GDBusWpaSupplicant
  56 {
  57     enum
  58     {
  59         INIT,
  60         WPA_CONNECTING,
  61         WPA_CONNECTED,
  62         WPA_NOT_CONNECTED,
  63         WPA_NO_INTERFACE_PATH,
  64         WPA_GOT_INTERFACE_PATH,
  65         WPA_INTERFACE_CONNECTED,
  66     } state;
  67
  68     enum
  69     {
  70         WIFI_SCANNING_IDLE,
  71         WIFI_SCANNING,
  72     } scanState;
  73
  74     WpaFiW1Wpa_supplicant1 * proxy;
  75     WpaFiW1Wpa_supplicant1Interface * iface;
  76     gchar * interfacePath;
  77     gchar * networkPath;
  78 };
  79 #endif
  80
  81 /**
  82  * Concrete implementation of the ConnectivityManager singleton object for Linux platforms.
  83  */
  84 class ConnectivityManagerImpl final : public ConnectivityManager,
  85 #if CHIP_DEVICE_CONFIG_ENABLE_CHIPOBLE
  86                                       public Internal::GenericConnectivityManagerImpl_BLE<ConnectivityManagerImpl>,
  87 #else
  88                                       public Internal::GenericConnectivityManagerImpl_NoBLE<ConnectivityManagerImpl>,
  89 #endif
  90 #if CHIP_DEVICE_CONFIG_ENABLE_THREAD
  91                                       public Internal::GenericConnectivityManagerImpl_Thread<ConnectivityManagerImpl>,
  92 #else
  93                                       public Internal::GenericConnectivityManagerImpl_NoThread<ConnectivityManagerImpl>,
  94 #endif
  95 #if CHIP_DEVICE_CONFIG_ENABLE_WPA
  96                                       public Internal::GenericConnectivityManagerImpl_WiFi<ConnectivityManagerImpl>,
  97 #else
  98                                       public Internal::GenericConnectivityManagerImpl_NoWiFi<ConnectivityManagerImpl>,
  99 #endif
 100                                       public Internal::GenericConnectivityManagerImpl<ConnectivityManagerImpl>
 101 {
 102     // Allow the ConnectivityManager interface class to delegate method calls to
 103     // the implementation methods provided by this class.
 104     friend class ConnectivityManager;
 105
 106 public:
 107     CHIP_ERROR ProvisionWiFiNetwork(const char * ssid, const char * key);
 108
 109 #if CHIP_DEVICE_CONFIG_ENABLE_WPA
 110     void StartWiFiManagement();
 111 #endif
 112
 113 private:
 114     // ===== Members that implement the ConnectivityManager abstract interface.
 115
 116     bool _HaveIPv4InternetConnectivity();
 117     bool _HaveIPv6InternetConnectivity();
 118     bool _HaveServiceConnectivity();
 119     CHIP_ERROR _Init();
 120     void _OnPlatformEvent(const ChipDeviceEvent * event);
 121
 122 #if CHIP_DEVICE_CONFIG_ENABLE_WPA
 123     WiFiStationMode _GetWiFiStationMode();
 124     CHIP_ERROR _SetWiFiStationMode(ConnectivityManager::WiFiStationMode val);
 125     uint32_t _GetWiFiStationReconnectIntervalMS();
 126     CHIP_ERROR _SetWiFiStationReconnectIntervalMS(uint32_t val);
 127     bool _IsWiFiStationEnabled();
 128     bool _IsWiFiStationConnected();
 129     bool _IsWiFiStationApplicationControlled();
 130     bool _IsWiFiStationProvisioned();
 131     void _ClearWiFiStationProvision();
 132     bool _CanStartWiFiScan();
 133
 134     WiFiAPMode _GetWiFiAPMode();
 135     CHIP_ERROR _SetWiFiAPMode(WiFiAPMode val);
 136     bool _IsWiFiAPActive();
 137     bool _IsWiFiAPApplicationControlled();
 138     void _DemandStartWiFiAP();
 139     void _StopOnDemandWiFiAP();
 140     void _MaintainOnDemandWiFiAP();
 141     uint32_t _GetWiFiAPIdleTimeoutMS();
 142     void _SetWiFiAPIdleTimeoutMS(uint32_t val);
 143
 144     static void _OnWpaProxyReady(GObject * source_object, GAsyncResult * res, gpointer user_data);
 145     static void _OnWpaInterfaceRemoved(WpaFiW1Wpa_supplicant1 * proxy, const gchar * path, GVariant * properties,
 146                                        gpointer user_data);
 147     static void _OnWpaInterfaceAdded(WpaFiW1Wpa_supplicant1 * proxy, const gchar * path, GVariant * properties, gpointer user_data);
 148     static void _OnWpaInterfaceReady(GObject * source_object, GAsyncResult * res, gpointer user_data);
 149     static void _OnWpaInterfaceProxyReady(GObject * source_object, GAsyncResult * res, gpointer user_data);
 150
 151     static BitFlags<ConnectivityFlags> mConnectivityFlag;
 152     static struct GDBusWpaSupplicant mWpaSupplicant;
 153 #endif
 154
 155     // ==================== ConnectivityManager Private Methods ====================
 156
 157 #if CHIP_DEVICE_CONFIG_ENABLE_WPA
 158     void DriveAPState();
 159     CHIP_ERROR ConfigureWiFiAP();
 160     void ChangeWiFiAPState(WiFiAPState newState);
 161     static void DriveAPState(::chip::System::Layer * aLayer, void * aAppState, ::chip::System::Error aError);
 162 #endif
 163
 164     // ===== Members for internal use by the following friends.
 165
 166     friend ConnectivityManager & ConnectivityMgr();
 167     friend ConnectivityManagerImpl & ConnectivityMgrImpl();
 168
 169     static ConnectivityManagerImpl sInstance;
 170
 171     // ===== Private members reserved for use by this class only.
 172
 173     ConnectivityManager::WiFiStationMode mWiFiStationMode;
 174     ConnectivityManager::WiFiAPMode mWiFiAPMode;
 175     WiFiAPState mWiFiAPState;
 176     uint64_t mLastAPDemandTime;
 177     uint32_t mWiFiStationReconnectIntervalMS;
 178     uint32_t mWiFiAPIdleTimeoutMS;
 179 };
 180
 181 #if CHIP_DEVICE_CONFIG_ENABLE_WPA
 182 inline ConnectivityManager::WiFiAPMode ConnectivityManagerImpl::_GetWiFiAPMode()
 183 {
 184     return mWiFiAPMode;
 185 }
 186
 187 inline bool ConnectivityManagerImpl::_IsWiFiAPActive()
 188 {
 189     return mWiFiAPState == kWiFiAPState_Active;
 190 }
 191
 192 inline bool ConnectivityManagerImpl::_IsWiFiAPApplicationControlled()
 193 {
 194     return mWiFiAPMode == kWiFiAPMode_ApplicationControlled;
 195 }
 196
 197 inline uint32_t ConnectivityManagerImpl::_GetWiFiAPIdleTimeoutMS()
 198 {
 199     return mWiFiAPIdleTimeoutMS;
 200 }
 201
 202 inline bool ConnectivityManagerImpl::_HaveServiceConnectivity()
 203 {
 204     return _HaveServiceConnectivityViaThread();
 205 }
 206 #endif
 207
 208 /**
 209  * Returns the public interface of the ConnectivityManager singleton object.
 210  *
 211  * chip applications should use this to access features of the ConnectivityManager object
 212  * that are common to all platforms.
 213  */
 214 inline ConnectivityManager & ConnectivityMgr()
 215 {
 216     return ConnectivityManagerImpl::sInstance;
 217 }
 218
 219 /**
 220  * Returns the platform-specific implementation of the ConnectivityManager singleton object.
 221  *
 222  * chip applications can use this to gain access to features of the ConnectivityManager
 223  * that are specific to the ESP32 platform.
 224  */
 225 inline ConnectivityManagerImpl & ConnectivityMgrImpl()
 226 {
 227     return ConnectivityManagerImpl::sInstance;
 228 }
 229
 230 } // namespace DeviceLayer
 231 } // namespace chip