src/StWifiPresentationModel.cpp

   1 //
   2 // Copyright (c) 2012 Samsung Electronics Co., Ltd.
   3 //
   4 // Licensed under the Flora License, Version 1.1 (the License);
   5 // you may not use this file except in compliance with the License.
   6 // You may obtain a copy of the License at
   7 //
   8 //     http://floralicense.org/license/
   9 //
  10 // Unless required by applicable law or agreed to in writing, software
  11 // distributed under the License is distributed on an AS IS BASIS,
  12 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13 // See the License for the specific language governing permissions and
  14 // limitations under the License.
  15 //
  16
  17 /**
  18  * @file                StWifiPresentationModel.cpp
  19  * @brief               This is the implementation file for WifiPresentationModel class.
  20  */
  21
  22 #include <cstdlib>
  23 #include "StWifiPresentationModel.h"
  24
  25 using namespace Tizen::Base;
  26 using namespace Tizen::Base::Collection;
  27 using namespace Tizen::Net::Wifi;
  28
  29 WifiPresentationModel* WifiPresentationModel::__pWifiPresentationModelInstance = null;
  30
  31 WifiPresentationModel::WifiPresentationModel(void)
  32         : __pWifiManager(null)
  33         , __pAccessPointList(null)
  34         , __pIWifiPresentationModelEventListener(null)
  35         , __wifiEventInProgress(WIFI_PRESENTATION_MODEL_EVENT_NONE)
  36 {
  37 }
  38
  39 WifiPresentationModel::~WifiPresentationModel(void)
  40 {
  41         RemoveAccessPointList();
  42         __pIWifiPresentationModelEventListener = null;
  43
  44         delete __pWifiManager;
  45         __pWifiManager = null;
  46 }
  47
  48 result
  49 WifiPresentationModel::Construct(void)
  50 {
  51         __pWifiManager = new (std::nothrow) WifiManager();
  52         result r = __pWifiManager->Construct(*this);
  53
  54         if (IsFailed(r))
  55         {
  56                 AppLogDebug("Construct failed(%s)", GetErrorMessage(r));
  57                 delete __pWifiManager;
  58                 __pWifiManager = null;
  59
  60                 return r;
  61         }
  62
  63         r = __pWifiManager->AddSystemMonitoringEventListener(*this);
  64         if (IsFailed(r))
  65         {
  66                 AppLogDebug("Construct failed(%s)", GetErrorMessage(r));
  67                 delete __pWifiManager;
  68                 __pWifiManager = null;
  69         }
  70
  71         return r;
  72 }
  73
  74 WifiPresentationModel*
  75 WifiPresentationModel::GetInstance(void)
  76 {
  77         if (__pWifiPresentationModelInstance == null)
  78         {
  79                 CreateInstance();
  80         }
  81
  82         return __pWifiPresentationModelInstance;
  83 }
  84
  85 void
  86 WifiPresentationModel::CreateInstance(void)
  87 {
  88         __pWifiPresentationModelInstance = new (std::nothrow) WifiPresentationModel();
  89         result r = __pWifiPresentationModelInstance->Construct();
  90         if (IsFailed(r))
  91         {
  92                 delete __pWifiPresentationModelInstance;
  93                 __pWifiPresentationModelInstance = null;
  94                 return;
  95         }
  96
  97         std::atexit(DestroyInstance);
  98 }
  99
 100 void
 101 WifiPresentationModel::DestroyInstance(void)
 102 {
 103         if (__pWifiPresentationModelInstance != null)
 104         {
 105                 delete __pWifiPresentationModelInstance;
 106                 __pWifiPresentationModelInstance = null;
 107         }
 108 }
 109
 110 void
 111 WifiPresentationModel::SetWifiEventListener(const IWifiPresentationModelEventListener* pWifiEventListener)
 112 {
 113         __pIWifiPresentationModelEventListener = pWifiEventListener;
 114 }
 115
 116 void
 117 WifiPresentationModel::OnWifiConnectionStateChanged(Tizen::Net::Wifi::WifiConnectionState state)
 118 {
 119         FireWifiEvnet(WIFI_PRESENTATION_MODEL_EVENT_CONNECTION_STATE_CHANGED);
 120 }
 121
 122 void
 123 WifiPresentationModel::OnWifiSystemScanResultUpdated(void)
 124 {
 125         RemoveAccessPointList();
 126         SetAccessPointList(__pWifiManager->GetSystemScanResultN());
 127
 128         FireWifiEvnet(WIFI_PRESENTATION_MODEL_EVENT_SYSTEM_SCAN_UPDATED);
 129 }
 130
 131 bool
 132 WifiPresentationModel::IsWifiActivated(void)
 133 {
 134         return __pWifiManager->IsActivated();
 135 }
 136
 137 result
 138 WifiPresentationModel::ScanWifi(void)
 139 {
 140         if (IsWifiActivated() == false)
 141         {
 142                 return E_FAILURE;
 143         }
 144
 145         result r = __pWifiManager->Scan();
 146         if (!IsFailed(r))
 147         {
 148                 SetWifiEventInProgress(WIFI_PRESENTATION_MODEL_EVENT_SCANNING);
 149         }
 150
 151         return r;
 152 }
 153
 154 bool
 155 WifiPresentationModel::IsWifiConnected(void)
 156 {
 157         if (IsWifiActivated() == false)
 158         {
 159                 return false;
 160         }
 161
 162         return __pWifiManager->IsConnected();
 163 }
 164
 165 result
 166 WifiPresentationModel::ConnectToAccessPointListAt(int index)
 167 {
 168         if (__pAccessPointList == null)
 169         {
 170                 AppLogDebug("__pAccessPointList is null");
 171                 return E_FAILURE;
 172         }
 173
 174         WifiBssInfo* pWifiBssInfo = static_cast<WifiBssInfo*>(__pAccessPointList->GetAt(index));
 175         if (pWifiBssInfo == null)
 176         {
 177                 AppLogDebug("GetAt is null");
 178                 return E_FAILURE;
 179         }
 180
 181         result r =  __pWifiManager->Connect(*pWifiBssInfo);
 182         if (!IsFailed(r))
 183         {
 184                 SetWifiEventInProgress(WIFI_PRESENTATION_MODEL_EVENT_CONNECTTING);
 185         }
 186
 187         return r;
 188 }
 189
 190 result
 191 WifiPresentationModel::ActivateWifi(void)
 192 {
 193         if (IsWifiActivated() == true)
 194         {
 195                 return E_FAILURE;
 196         }
 197
 198         result r = __pWifiManager->Activate();
 199         if (!IsFailed(r))
 200         {
 201                 SetWifiEventInProgress(WIFI_PRESENTATION_MODEL_EVENT_ACTIVATING);
 202         }
 203
 204         return r;
 205 }
 206
 207 result
 208 WifiPresentationModel::DeactivateWifi(void)
 209 {
 210         if (IsWifiActivated() == false)
 211         {
 212                 return E_FAILURE;
 213         }
 214
 215         result r = __pWifiManager->Deactivate();
 216         if (!IsFailed(r))
 217         {
 218                 SetWifiEventInProgress(WIFI_PRESENTATION_MODEL_EVENT_DEACTIVATING);
 219         }
 220
 221         return r;
 222 }
 223
 224 result
 225 WifiPresentationModel::SetWifiActivateScanMode(Tizen::Net::Wifi::WifiSystemScanMode wifiSystemScanMode)
 226 {
 227         return __pWifiManager->SetWifiSystemScanMode(wifiSystemScanMode);
 228 }
 229
 230 result
 231 WifiPresentationModel::SetWifiBssUnknownAt(int index)
 232 {
 233         if (__pAccessPointList == null)
 234         {
 235                 AppLogDebug("__pAccessPointList is null");
 236                 return E_FAILURE;
 237         }
 238
 239         WifiBssInfo* pWifiAccessPointBssInfo = const_cast<WifiBssInfo*>(__pWifiManager->GetConnectionTargetInfoN());
 240         if (pWifiAccessPointBssInfo == null)
 241         {
 242                 AppLogDebug("pWifiAccessPointBssInfo is null");
 243                 return E_FAILURE;
 244         }
 245
 246         pWifiAccessPointBssInfo->SetUnknown();
 247         delete pWifiAccessPointBssInfo;
 248         pWifiAccessPointBssInfo = null;
 249         return E_SUCCESS;
 250 }
 251
 252 Tizen::Base::String
 253 WifiPresentationModel::GetWifiMacAddress(void)
 254 {
 255         return __pWifiManager->GetMacAddress();
 256 }
 257
 258 void
 259 WifiPresentationModel::OnWifiActivated(result r)
 260 {
 261         if (!IsFailed(r))
 262         {
 263                 RemoveAccessPointList();
 264         }
 265
 266         FireWifiEvnet(WIFI_PRESENTATION_MODEL_EVENT_DEACTIVATED, r);
 267 }
 268
 269 void
 270 WifiPresentationModel::OnWifiDeactivated(result r)
 271 {
 272         if (!IsFailed(r))
 273         {
 274                 RemoveAccessPointList();
 275         }
 276
 277         FireWifiEvnet(WIFI_PRESENTATION_MODEL_EVENT_DEACTIVATED, r);
 278 }
 279
 280 Tizen::Base::String
 281 WifiPresentationModel::GetSsidInAccessPointListAt(int index)
 282 {
 283         if (__pAccessPointList == null)
 284         {
 285                 AppLogDebug("__pAccessPointList is null");
 286                 SetLastResult(E_FAILURE);
 287                 return String(L"");
 288         }
 289
 290         WifiBssInfo* pWifiBssInfo = static_cast<WifiBssInfo*>(__pAccessPointList->GetAt(index));
 291         if (pWifiBssInfo == null)
 292         {
 293                 AppLogDebug("GetAt is null");
 294                 SetLastResult(E_FAILURE);
 295                 return String(L"");
 296         }
 297
 298         return pWifiBssInfo->GetSsid();
 299 }
 300
 301 long
 302 WifiPresentationModel::GetRssiInAccessPointListAt(int index)
 303 {
 304         if (__pAccessPointList == null)
 305         {
 306                 AppLogDebug("__pAccessPointList is null");
 307                 SetLastResult(E_FAILURE);
 308                 return 0;
 309         }
 310
 311         WifiBssInfo* pWifiBssInfo = static_cast<WifiBssInfo*>(__pAccessPointList->GetAt(index));
 312         if (pWifiBssInfo == null)
 313         {
 314                 AppLogDebug("GetAt is null");
 315                 SetLastResult(E_FAILURE);
 316                 return 0;
 317         }
 318
 319         return pWifiBssInfo->GetRssi();
 320 }
 321
 322 int
 323 WifiPresentationModel::GetAccessPointCount(void)
 324 {
 325         if (__pAccessPointList == null)
 326         {
 327                 AppLogDebug("__pAccessPointList is null");
 328                 SetLastResult(E_FAILURE);
 329                 return 0;
 330         }
 331
 332         return __pAccessPointList->GetCount();
 333 }
 334
 335 bool
 336 WifiPresentationModel::IsWifiBssInfoConnect(int index)
 337 {
 338         if (IsWifiConnected() == false)
 339         {
 340                 AppLogDebug("Wifi is disconnect");
 341                 return false;
 342         }
 343
 344         if (__pAccessPointList == null)
 345         {
 346                 AppLogDebug("__pAccessPointList is null");
 347                 return false;
 348         }
 349
 350         WifiBssInfo* pWifiBssInfo = static_cast<WifiBssInfo*>(__pAccessPointList->GetAt(index));
 351         if (pWifiBssInfo == null)
 352         {
 353                 AppLogDebug("GetAt is null");
 354                 return false;
 355         }
 356
 357         WifiBssInfo* pWifiAccessBssInfo = const_cast<WifiBssInfo*>(__pWifiManager->GetConnectionTargetInfoN());
 358         if (pWifiBssInfo == null)
 359         {
 360                 AppLogDebug("GetConnectionTargetInfoN is null");
 361                 return false;
 362         }
 363
 364         if (pWifiBssInfo->GetSsid().Equals(pWifiAccessBssInfo->GetSsid()))
 365         {
 366                 AppLogDebug("pWifiBssInfo == pWifiAccessBssInfo");
 367                 delete pWifiAccessBssInfo;
 368                 pWifiBssInfo = null;
 369                 return true;
 370         }
 371
 372         delete pWifiAccessBssInfo;
 373         pWifiAccessBssInfo = null;
 374         pWifiBssInfo = null;
 375         return false;
 376 }
 377
 378 Tizen::Net::Wifi::WifiBssInfo*
 379 WifiPresentationModel::GetWifiBssInfoInAccessPointListAt(void)
 380 {
 381         if (IsWifiConnected() == false)
 382         {
 383                 AppLogDebug("Wifi is disconnect");
 384                 return null;
 385         }
 386
 387         if (__pAccessPointList == null)
 388         {
 389                 AppLogDebug("__pAccessPointList is null");
 390                 return null;
 391         }
 392
 393         WifiBssInfo* pWifiAccessBssInfo = const_cast<WifiBssInfo*>(__pWifiManager->GetConnectionTargetInfoN());
 394         if (pWifiAccessBssInfo == null)
 395         {
 396                 AppLogDebug("GetConnectionTargetInfoN is null");
 397                 return null;
 398         }
 399
 400         return pWifiAccessBssInfo;
 401 }
 402
 403 Tizen::Net::Wifi::WifiBssInfo*
 404 WifiPresentationModel::GetWifiBssInfoListAt(int index)
 405 {
 406         WifiBssInfo* pWifiBssInfo = null;
 407         if (__pAccessPointList == null)
 408         {
 409                 AppLogDebug("__pAccessPointList is null");
 410                 return pWifiBssInfo;
 411         }
 412
 413         pWifiBssInfo = static_cast<WifiBssInfo*>(__pAccessPointList->GetAt(index));
 414         if (pWifiBssInfo == null)
 415         {
 416                 AppLogDebug("GetAt is null");
 417                 return pWifiBssInfo;
 418         }
 419         return pWifiBssInfo;
 420 }
 421
 422 WifiAuthenticationType
 423 WifiPresentationModel::GetAuthenticationtypeInAccessPointListAt(int index)
 424 {
 425         SetLastResult(E_SUCCESS);
 426         if (__pAccessPointList == null)
 427         {
 428                 AppLogDebug("__pAccessPointList is null");
 429                 SetLastResult(E_FAILURE);
 430                 return WIFI_AUTHENTICATION_OPEN;
 431         }
 432
 433         WifiBssInfo* pWifiBssInfo = static_cast<WifiBssInfo*>(__pAccessPointList->GetAt(index));
 434         if (pWifiBssInfo == null)
 435         {
 436                 AppLogDebug("GetAt is null");
 437                 SetLastResult(E_FAILURE);
 438                 return WIFI_AUTHENTICATION_OPEN;
 439         }
 440
 441         WifiSecurityInfo* pWifiSecurityInfo = const_cast<WifiSecurityInfo*>(pWifiBssInfo->GetSecurityInfo());
 442         if (pWifiSecurityInfo == null)
 443         {
 444                 AppLogDebug("pWifiSecurityInfo is null");
 445                 return WIFI_AUTHENTICATION_OPEN;
 446         }
 447
 448         WifiAuthenticationType tmp = pWifiSecurityInfo->GetAuthenticationType();
 449
 450         return tmp;
 451 }
 452
 453 void
 454 WifiPresentationModel::SetWifiEventInProgress(WifiPresentationModelEvent setEventInProgress)
 455 {
 456         __wifiEventInProgress = setEventInProgress;
 457 }
 458
 459 result
 460 WifiPresentationModel::FireWifiEvnet(WifiPresentationModelEvent wifiEvent, result r)
 461 {
 462         if (__pIWifiPresentationModelEventListener == null)
 463         {
 464                 AppLogDebug("__pBluetoothPresentationModelEventListener is null");
 465                 return E_FAILURE;
 466         }
 467
 468         SetWifiEventInProgress(wifiEvent);
 469         (const_cast <IWifiPresentationModelEventListener*>(__pIWifiPresentationModelEventListener))->OnWifiPresentationModelEventCompleted(wifiEvent, r);
 470
 471         return E_SUCCESS;
 472 }
 473
 474 WifiPresentationModelEvent
 475 WifiPresentationModel::GetWifiEventInProgress(void)
 476 {
 477         return __wifiEventInProgress;
 478 }
 479
 480 void
 481 WifiPresentationModel::SetAccessPointList(Tizen::Base::Collection::IList* pWifiBssInfoList)
 482 {
 483         RemoveAccessPointList();
 484         __pAccessPointList = pWifiBssInfoList;
 485 }
 486
 487 void
 488 WifiPresentationModel::RemoveAccessPointList(void)
 489 {
 490         if (__pAccessPointList != null)
 491         {
 492                 __pAccessPointList->RemoveAll();
 493                 delete __pAccessPointList;
 494                 __pAccessPointList = null;
 495         }
 496 }
 497
 498 void
 499 WifiPresentationModel::OnWifiConnected(const Tizen::Base::String& ssid, result r)
 500 {
 501         FireWifiEvnet(WIFI_PRESENTATION_MODEL_EVENT_RSSI_CHANGED, r);
 502 }
 503
 504 void
 505 WifiPresentationModel::OnWifiDisconnected(void)
 506 {
 507         FireWifiEvnet(WIFI_PRESENTATION_MODEL_EVENT_DISCONNECTED);
 508 }
 509
 510 void
 511 WifiPresentationModel::OnWifiRssiChanged(long rssi)
 512 {
 513         FireWifiEvnet(WIFI_PRESENTATION_MODEL_EVENT_RSSI_CHANGED);
 514 }
 515
 516 void
 517 WifiPresentationModel::OnWifiScanCompletedN(const Tizen::Base::Collection::IList* pWifiBssInfoList, result r)
 518 {
 519         if (!IsFailed(r))
 520         {
 521                 SetAccessPointList(const_cast<IList*>(pWifiBssInfoList));
 522         }
 523
 524         FireWifiEvnet(WIFI_PRESENTATION_MODEL_EVENT_SCAN_COMPLETED_N, r);
 525 }
 526
 527 result
 528 WifiPresentationModel::SetWifiBssInfoList(const Tizen::Base::Collection::IList* pWifiBssInfoList)
 529 {
 530         __pAccessPointList = const_cast<Tizen::Base::Collection::IList*>(pWifiBssInfoList);
 531         return GetLastResult();
 532 }