src/WifiService.cpp

   1 //
   2 // Open Service Platform
   3 // Copyright (c) 2012-2013 Samsung Electronics Co., Ltd.
   4 //
   5 // Licensed under the Apache License, Version 2.0 (the License);
   6 // you may not use this file except in compliance with the License.
   7 // You may obtain a copy of the License at
   8 //
   9 //     http://www.apache.org/licenses/LICENSE-2.0
  10 //
  11 // Unless required by applicable law or agreed to in writing, software
  12 // distributed under the License is distributed on an "AS IS" BASIS,
  13 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14 // See the License for the specific language governing permissions and
  15 // limitations under the License.
  16 //
  17
  18 /**
  19  * @file    WifiService.cpp
  20  * @brief   This is the implementation file for the %WifiService class.
  21  */
  22
  23 #include <glib.h>
  24 #include <vconf.h>
  25 #include <vconf-keys.h>
  26 #include <wifi.h>
  27 #include <unique_ptr.h>
  28 #include <FBaseUtilStringUtil.h>
  29 #include <FBaseRtMutexGuard.h>
  30 #include <FBaseSysLog.h>
  31 #include <FNetIp4Address.h>
  32 #include <FNetWifiWifiTypes.h>
  33 #include <FNetWifiWifiBssInfo.h>
  34 #include <FNetNetAccountInfo.h>
  35 #include <FSys_SystemInfoImpl.h>
  36 #include <FBase_StringConverter.h>
  37 #include <FNetWifi_WifiBssInfoImpl.h>
  38 #include <FNetWifi_WifiUtility.h>
  39 #include <FNetWifi_WifiNetAccountInfoImpl.h>
  40 #include "WifiService.h"
  41 #include "WifiProximityService.h"
  42 #include "WifiConnectivityIpcStub.h"
  43 #include "WifiSystemAdapter.h"
  44
  45 #ifdef _WifiConvertErrorResult
  46 #undef _WifiConvertErrorResult
  47 #endif
  48 #define _WifiConvertErrorResult(condition, r, value) \
  49                 do \
  50                 { \
  51                         if (condition) {   \
  52                                 r = value; \
  53                         } \
  54                 } while (0);
  55
  56 using namespace std;
  57 using namespace Tizen::Base;
  58 using namespace Tizen::Base::Utility;
  59 using namespace Tizen::Base::Runtime;
  60 using namespace Tizen::Base::Collection;
  61 using namespace Tizen::App;
  62 using namespace Tizen::System;
  63 using namespace Tizen::Net;
  64 using namespace Tizen::Net::Wifi;
  65
  66 WifiService::WifiService(void)
  67         : __listMutex()
  68         , __managerClientIdList()
  69         , __monitorClientIdList()
  70         , __pStub(null)
  71         , __pWifiSystemAdapter(null)
  72 {
  73 }
  74
  75 WifiService::~WifiService(void)
  76 {
  77 }
  78
  79 result
  80 WifiService::Construct(WifiConnectivityIpcStub& stub)
  81 {
  82         result r = E_SUCCESS;
  83         bool isWifiSupported = false;
  84         String key(L"http://tizen.org/feature/network.wifi");
  85
  86         r = Tizen::System::_SystemInfoImpl::GetSysInfo(key, isWifiSupported);
  87         SysTryReturnResult(NID_NET_WIFI, (r == E_SUCCESS) && (isWifiSupported == true), E_UNSUPPORTED_OPERATION,
  88                         "Wi-Fi is not supported.");
  89
  90         r = __listMutex.Create();
  91         SysTryReturnResult(NID_NET_WIFI, r == E_SUCCESS, E_SYSTEM, "Failed to create a mutex.");
  92
  93         SysAssertf(__pWifiSystemAdapter == null,
  94                             "Already constructed. Calling Construct() twice or more on a same instance is not allowed for this class.");
  95
  96         __pWifiSystemAdapter = WifiSystemAdapter::GetInstance();
  97         SysTryReturnResult(NID_NET_WIFI, __pWifiSystemAdapter != null, GetLastResult(), "Failed to get Wi-Fi System adapter instance");
  98
  99         __pStub = &stub;
 100         return E_SUCCESS;
 101 }
 102
 103 result
 104 WifiService::RegisterManagerClientId(int clientId)
 105 {
 106         result r = E_SUCCESS;
 107         bool isContain = true;
 108
 109         isContain = __managerClientIdList.Contains(clientId);
 110         SysTryReturnResult(NID_NET_WIFI, isContain == false, E_OBJ_ALREADY_EXIST, "The client was already registered.");
 111
 112         r = __managerClientIdList.Add(clientId);
 113         r = TransExceptionsExclusive(r, E_SYSTEM, E_OUT_OF_MEMORY);
 114         SysTryReturnResult(NID_NET_WIFI, r == E_SUCCESS, r, "Propagating. Internal map error.");
 115
 116         if (__managerClientIdList.GetCount() == 1)
 117         {
 118                 __pWifiSystemAdapter->SetWifiService(this);
 119         }
 120
 121         return r;
 122 }
 123
 124 result
 125 WifiService::UnregisterManagerClientId(int clientId)
 126 {
 127         result r = E_SUCCESS;
 128
 129         if (__managerClientIdList.GetCount() == 0)
 130                 return r;
 131
 132         r = __managerClientIdList.Remove(clientId);
 133         r = TransExceptionsExclusive(r, E_SYSTEM, E_OUT_OF_MEMORY);
 134         SysTryReturnResult(NID_NET_WIFI, r == E_SUCCESS, r, "Propagating. Internal map error.");
 135
 136         if (__managerClientIdList.GetCount() == 0
 137                 && __monitorClientIdList.GetCount() == 0)
 138         {
 139                 __pWifiSystemAdapter->SetWifiService(null);
 140         }
 141
 142         return r;
 143 }
 144
 145
 146 result
 147 WifiService::RegisterMonitoringClientId(int clientId)
 148 {
 149         result r = E_SUCCESS;
 150         bool isContain = true;
 151
 152         isContain = __monitorClientIdList.Contains(clientId);
 153         SysTryReturnResult(NID_NET_WIFI, isContain == false, E_OBJ_ALREADY_EXIST, "The client was already registered.");
 154
 155         r = __monitorClientIdList.Add(clientId);
 156         r = TransExceptionsExclusive(r, E_SYSTEM, E_OUT_OF_MEMORY);
 157         SysTryReturnResult(NID_NET_WIFI, r == E_SUCCESS, r, "Propagating. Internal map error.");
 158
 159         if (__monitorClientIdList.GetCount() == 1)
 160         {
 161                 __pWifiSystemAdapter->SetWifiService(this);
 162         }
 163
 164         return r;
 165 }
 166
 167
 168 result
 169 WifiService::UnregisterMonitoringClientId(int clientId)
 170 {
 171         result r = E_SUCCESS;
 172         if (__monitorClientIdList.GetCount() == 0)
 173                         return r;
 174
 175         r = __monitorClientIdList.Remove(clientId);
 176         r = TransExceptionsExclusive(r, E_SYSTEM, E_OUT_OF_MEMORY);
 177         SysTryReturnResult(NID_NET_WIFI, r == E_SUCCESS, r, "Propagating. Internal map error.");
 178
 179         if (__managerClientIdList.GetCount() == 0
 180                 && __monitorClientIdList.GetCount() == 0)
 181         {
 182                 __pWifiSystemAdapter->SetWifiService(null);
 183         }
 184
 185         return r;
 186 }
 187
 188 result
 189 WifiService::SetWifiSystemScanMode(int mode)
 190 {
 191         return __pWifiSystemAdapter->SetWifiSystemScanMode(mode);
 192 }
 193
 194 result
 195 WifiService::UpdateWifiBssInfo(const WifiBssInfo& bssInfo)
 196 {
 197         return __pWifiSystemAdapter->UpdateWifiBssInfo(bssInfo);
 198 }
 199
 200 result
 201 WifiService::GetWifiMacAddress(String* pMacAddress)
 202 {
 203         *pMacAddress = __pWifiSystemAdapter->GetMacAddress();
 204         return GetLastResult();
 205 }
 206 result
 207 WifiService::IsWifiActivated(bool& isActivated)
 208 {
 209         isActivated = __pWifiSystemAdapter->IsActivated();
 210
 211         return GetLastResult();
 212 }
 213
 214 result
 215 WifiService::IsWifiConnected(bool& isConnected)
 216 {
 217         isConnected = __pWifiSystemAdapter->IsConnected();
 218
 219         return GetLastResult();
 220 }
 221
 222 result
 223 WifiService::GetWifiConnectionState(int& connectionState)
 224 {
 225         connectionState = __pWifiSystemAdapter->GetConnectionState();
 226
 227         return GetLastResult();
 228 }
 229
 230 result
 231 WifiService::WifiActivate(int clientId)
 232 {
 233         return __pWifiSystemAdapter->Activate(clientId);
 234 }
 235
 236 result
 237 WifiService::WifiDeactivate(int clientId)
 238 {
 239         return __pWifiSystemAdapter->Deactivate(clientId);
 240 }
 241
 242 result
 243 WifiService::WifiScan(int clientId)
 244 {
 245         return __pWifiSystemAdapter->Scan(clientId);
 246 }
 247
 248 result
 249 WifiService::WifiConnect(int clientId, const Tizen::Net::Wifi::WifiBssInfo& bssInfo)
 250 {
 251         return __pWifiSystemAdapter->Connect(clientId, bssInfo);
 252 }
 253
 254 result
 255 WifiService::GetWifiConnectionTargetInfo(Tizen::Net::Wifi::WifiBssInfo* pBssInfo) const
 256 {
 257         return __pWifiSystemAdapter->GetConnectionTargetInfo(pBssInfo);
 258 }
 259
 260 result
 261 WifiService::GetWifiNetAccountInfo(NetAccountInfo* pNetAccountInfo, _WifiNetAccountInfoImpl* pWifiNetAccountInfoImpl) const
 262 {
 263         return __pWifiSystemAdapter->GetWifiNetAccountInfo(pNetAccountInfo, pWifiNetAccountInfoImpl);
 264 }
 265
 266 result
 267 WifiService::GetWifiSystemScanResultN(ArrayListT<Tizen::Net::Wifi::WifiBssInfo*>* pBssInfoList) const
 268 {
 269         IList* pList = __pWifiSystemAdapter->GetSystemScanResult();
 270         result r = GetLastResult();
 271         SysTryReturnResult(NID_NET_WIFI, pList != null, r, "Failed to get scan results.");
 272
 273         for (int i = 0; i < pList->GetCount() ; i++)
 274         {
 275                 r = pBssInfoList->Add(static_cast<Tizen::Net::Wifi::WifiBssInfo*>(pList->GetAt(i)));
 276         }
 277
 278         SysTryReturnResult(NID_NET_WIFI, r == E_SUCCESS, r, "Failed to get scan results.");
 279
 280         return E_SUCCESS;
 281 }
 282
 283 // Wifi callback functions
 284
 285 void
 286 WifiService::OnWifiActivated(int clientId, result r)
 287 {
 288         int id = 0;
 289         if (r == E_SUCCESS)
 290         {
 291                 // broadcast to all clients
 292                 for (int i = 0 ; i < __managerClientIdList.GetCount() ; i++)
 293                 {
 294                         __managerClientIdList.GetAt(i, id);
 295                         __pStub->SendWifiActivated(id, r);
 296                 }
 297         }
 298         else
 299         {
 300                 __pStub->SendWifiActivated(clientId, r);
 301         }
 302 }
 303
 304 void
 305 WifiService::OnWifiDeactivated(int clientId, result r)
 306 {
 307         int id = 0;
 308         if (r == E_SUCCESS)
 309         {
 310                 // broadcast to all clients
 311                 for (int i = 0 ; i < __managerClientIdList.GetCount() ; i++)
 312                 {
 313                         __managerClientIdList.GetAt(i, id);
 314                         __pStub->SendWifiDeactivated(id, r);
 315                 }
 316
 317         }
 318         else
 319         {
 320                 __pStub->SendWifiDeactivated(clientId, r);
 321         }
 322 }
 323
 324 void
 325 WifiService::OnWifiConnected(int clientId, const String ssid, result r)
 326 {
 327         int id = 0;
 328         if (r == E_SUCCESS)
 329         {
 330                 // broadcast to all clients
 331                 for (int i = 0 ; i < __managerClientIdList.GetCount() ; i++)
 332                 {
 333                         __managerClientIdList.GetAt(i, id);
 334                         __pStub->SendWifiConnected(id, ssid, r);
 335                 }
 336         }
 337         else
 338         {
 339                 __pStub->SendWifiConnected(clientId, ssid, r);
 340         }
 341 }
 342
 343 void
 344 WifiService::OnWifiScanCompleted(int clientId, Tizen::Base::Collection::IList* pWifiBssInfoList, result r)
 345 {
 346         if (r == E_SUCCESS && pWifiBssInfoList != null)
 347         {
 348                 ArrayListT<Tizen::Net::Wifi::WifiBssInfo*>* pBssInfoList = new ArrayListT<Tizen::Net::Wifi::WifiBssInfo*>();
 349                 SysTryCatch(NID_NET_WIFI, pBssInfoList != null, r = E_OUT_OF_MEMORY, r, "Memory allocation failed.");
 350
 351
 352                 for (int i = 0; i < pWifiBssInfoList->GetCount(); i++)
 353                 {
 354                         result res = pBssInfoList->Add(static_cast<Tizen::Net::Wifi::WifiBssInfo*>(pWifiBssInfoList->GetAt(i)));
 355                         SysTryCatch(NID_NET_WIFI, res == E_SUCCESS, ,E_SYSTEM, "Failed to get scan results.");
 356                 }
 357
 358                 __pStub->SendWifiScanCompleted(clientId, pBssInfoList, r);
 359                 delete pBssInfoList;
 360         }
 361         else
 362         {
 363                 goto CATCH;
 364         }
 365
 366         return;
 367
 368 CATCH:
 369         unique_ptr< ArrayListT<Tizen::Net::Wifi::WifiBssInfo*> > pBssInfoList(new ArrayListT<Tizen::Net::Wifi::WifiBssInfo*>());
 370         __pStub->SendWifiScanCompleted(clientId, pBssInfoList.get(), r);
 371
 372 }
 373
 374 void
 375 WifiService::OnWifiDisconnected()
 376 {
 377         int id = 0;
 378         // broadcast to all clients
 379         for (int i = 0 ; i < __managerClientIdList.GetCount() ; i++)
 380         {
 381                 __managerClientIdList.GetAt(i, id);
 382                 __pStub->SendWifiDisconnected(id);
 383         }
 384 }
 385
 386 void
 387 WifiService::OnWifiRssiLevelChanged(long rssi)
 388 {
 389         // broadcast to all clients
 390         int id = 0;
 391         for (int i = 0 ; i < __managerClientIdList.GetCount() ; i++)
 392         {
 393                 __managerClientIdList.GetAt(i, id);
 394                 __pStub->SendWifiRssiChanged(id, rssi);
 395         }
 396 }
 397
 398 // __monitorClientIdList
 399 void
 400 WifiService::OnWifiConnectionStateChanged(Tizen::Net::Wifi::WifiConnectionState state)
 401 {
 402         int id = 0;
 403         // broadcast to all clients
 404         for (int i = 0 ; i < __monitorClientIdList.GetCount() ; i++)
 405         {
 406                 __monitorClientIdList.GetAt(i, id);
 407                 __pStub->SendWifiConnectionStateChanged(id, state);
 408         }
 409 }
 410
 411 void
 412 WifiService::OnWifiBackgroundScanResultUpdated()
 413 {
 414         // broadcast to all clients
 415         int id = 0;
 416         for (int i = 0 ; i < __monitorClientIdList.GetCount() ; i++)
 417         {
 418                 __monitorClientIdList.GetAt(i, id);
 419                 __pStub->SendWifiSystemScanResultUpdated(id);
 420         }
 421 }