src/wifi/FNetWifi_WifiManagerImpl.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    FNetWifi_WifiManagerImpl.cpp
  20  * @brief   This is the implementation file for the _WifiManagerImpl Class.
  21  *
  22  * This file contains the implementation of the _WifiManagerImpl Class.
  23  */
  24 #include <unique_ptr.h>
  25 #include <FBaseSysLog.h>
  26 #include <FNetWifiWifiManager.h>
  27 #include <FNetWifiWifiBssInfo.h>
  28 #include <FNetWifiIWifiManagerEventListener.h>
  29 #include <FNetWifiIWifiSystemMonitoringEventListener.h>
  30 #include "FNetWifi_WifiManagerImpl.h"
  31 #include "FNetWifi_WifiSystemAdapter.h"
  32 #include "FNetWifi_WifiIpcProxy.h"
  33 #include "FNetWifi_WifiManagerEvent.h"
  34 #include "FNetWifi_WifiManagerEventArg.h"
  35 #include "FNetWifi_WifiSystemMonitoringEvent.h"
  36 #include "FNetWifi_WifiSystemMonitoringEventArg.h"
  37 #include "FNetWifi_WifiUtility.h"
  38
  39 using namespace std;
  40 using namespace Tizen::Base;
  41 using namespace Tizen::Base::Runtime;
  42 using namespace Tizen::Base::Collection;
  43
  44 namespace Tizen { namespace Net { namespace Wifi {
  45
  46 _WifiManagerImpl::_WifiManagerImpl(void)
  47     : __pWifiSystemAdapter(null)
  48     , __pMgrEvent(null)
  49     , __pMonitoringEvent(null)
  50     , __pTargetApInfo(null)
  51     , __stateMutex()
  52     , __currentState(WIFI_MANAGER_DEACTIVATED)
  53     , __currentScanState(WIFI_SCAN_IDLE)
  54     , __wasConnected(false)
  55 {
  56 }
  57
  58 _WifiManagerImpl::~_WifiManagerImpl(void)
  59 {
  60     if (__pWifiSystemAdapter != null)
  61     {
  62         __pWifiSystemAdapter->UnregisterManagerEventListener(*this);
  63     }
  64 }
  65
  66 result
  67 _WifiManagerImpl::Construct(IWifiManagerEventListener& listener)
  68 {
  69     result r = E_SUCCESS;
  70     unique_ptr<_WifiSystemMonitoringEvent> pMonitoringEvent;
  71     unique_ptr<_WifiManagerEvent> pMgrEvent;
  72
  73     SysAssertf(__pWifiSystemAdapter == null,
  74                     "Already constructed. Calling Construct() twice or more on a same instance is not allowed for this class.");
  75
  76     r = __stateMutex.Create();
  77     r = TransExceptionsExclusive(r, E_SYSTEM, E_OUT_OF_MEMORY);
  78     SysTryReturnResult(NID_NET_WIFI, r == E_SUCCESS, r, "Failed to create mutex.");
  79
  80     __pWifiSystemAdapter = _WifiSystemAdapter::GetInstance();
  81     SysTryReturnResult(NID_NET_WIFI, __pWifiSystemAdapter != null, E_OUT_OF_MEMORY, "Failed to get Wi-Fi System adapter instance");
  82
  83     pMonitoringEvent.reset(new (std::nothrow) _WifiSystemMonitoringEvent());
  84     SysTryReturnResult(NID_NET_WIFI, pMonitoringEvent != null, E_OUT_OF_MEMORY, "Memory allocation failed.");
  85     r = pMonitoringEvent->Construct();
  86     r = TransExceptionsExclusive(r, E_SYSTEM, E_OUT_OF_MEMORY);
  87     SysTryReturnResult(NID_NET_WIFI, r == E_SUCCESS, r, "Failed to construct the system monitoring event.");
  88
  89     pMgrEvent.reset(new (std::nothrow) _WifiManagerEvent());
  90     SysTryReturnResult(NID_NET_WIFI, pMgrEvent != null, E_OUT_OF_MEMORY, "The memory is insufficient.");
  91     r = pMgrEvent->Construct();
  92     r = TransExceptionsExclusive(r, E_SYSTEM, E_OUT_OF_MEMORY);
  93     SysTryReturnResult(NID_NET_WIFI, r == E_SUCCESS, E_SYSTEM, "Failed to construct the event.");
  94
  95     // add the IWifiManagerEventListener instance to a new created _WifiManagerEvent.
  96     r = pMgrEvent->AddListener(listener, true);
  97     SysTryReturnResult(NID_NET_WIFI, r == E_SUCCESS, E_SYSTEM,
  98                         "Failed to add the application listener for WifiManager event");
  99
 100     __pWifiSystemAdapter->RegisterManagerEventListener(*this);
 101     SysTryReturnResult(NID_NET_WIFI, r == E_SUCCESS, E_SYSTEM,
 102                            "Failed to register the manager event listener to _WifiSystemAdapter.");
 103
 104     __stateMutex.Acquire();
 105
 106     if (__pWifiSystemAdapter->IsActivated())
 107     {
 108         if (__pWifiSystemAdapter->IsConnected())
 109         {
 110             __currentState = WIFI_MANAGER_CONNECTED;
 111             __wasConnected = true;
 112         }
 113         else
 114         {
 115             __currentState = WIFI_MANAGER_ACTIVATED;
 116         }
 117     }
 118
 119     __stateMutex.Release();
 120
 121     __pMgrEvent = move(pMgrEvent);
 122     __pMonitoringEvent = move(pMonitoringEvent);
 123
 124     return r;
 125 }
 126
 127 result
 128 _WifiManagerImpl::Activate(void)
 129 {
 130     result r = E_SUCCESS;
 131
 132     SysLog(NID_NET_WIFI, "Enter, [Current State : %s],[Scan State: %s]",
 133         GetStringOfCurrentState(), GetStringOfCurrentScanState());
 134
 135     __stateMutex.Acquire();
 136
 137     switch (__currentState)
 138     {
 139     case WIFI_MANAGER_DEACTIVATED:
 140         r = __pWifiSystemAdapter->Activate();
 141         if (r == E_SUCCESS)
 142         {
 143                 __currentState = WIFI_MANAGER_ACTIVATING;
 144         }
 145         else if (r == E_IN_PROGRESS)
 146         {
 147                 __currentState = WIFI_MANAGER_ACTIVATING;
 148                 SysLog(NID_NET_WIFI, "SLP returned E_IN_PROGRESS, return E_SUCCESS (Same as 2.0)");
 149                 r = E_SUCCESS;
 150         }
 151         break;
 152     case WIFI_MANAGER_ACTIVATING:
 153         r = E_IN_PROGRESS;
 154         break;
 155     default:
 156         r = E_INVALID_OPERATION;
 157         break;
 158     }
 159
 160     __stateMutex.Release();
 161
 162     if (IsFailed(r))
 163     {
 164         SysLogException(NID_NET_WIFI, r, "[%s] exception occurred on activating Wifi.", GetErrorMessage(r));
 165     }
 166
 167     SysLog(NID_NET_WIFI, "Exit, [Current State : %s], [Scan State: %s], [Result : %s]",
 168                             GetStringOfCurrentState(), GetStringOfCurrentScanState(), GetErrorMessage(r));
 169
 170     return r;
 171 }
 172
 173 result
 174 _WifiManagerImpl::Deactivate(void)
 175 {
 176     result r = E_SUCCESS;
 177
 178     SysLog(NID_NET_WIFI, "Enter, [Current State : %s], [Scan State: %s]",
 179                         GetStringOfCurrentState(), GetStringOfCurrentScanState());
 180
 181     __stateMutex.Acquire();
 182
 183     switch (__currentState)
 184     {
 185     case WIFI_MANAGER_DEACTIVATED:
 186     case WIFI_MANAGER_ACTIVATING:
 187         r = E_INVALID_OPERATION;
 188         break;
 189     case WIFI_MANAGER_DEACTIVATING:
 190         r = E_IN_PROGRESS;
 191         break;
 192     default:
 193         r = __pWifiSystemAdapter->Deactivate();
 194         if (r == E_SUCCESS)
 195         {
 196             __currentState = WIFI_MANAGER_DEACTIVATING;
 197         }
 198          else if (r == E_IN_PROGRESS)
 199         {
 200             __currentState = WIFI_MANAGER_DEACTIVATING;
 201             SysLog(NID_NET_WIFI, "SLP returned E_IN_PROGRESS, return E_SUCCESS (Same as 2.0)");
 202             r = E_SUCCESS;
 203         }
 204         break;
 205     }
 206
 207     __stateMutex.Release();
 208
 209
 210     if (IsFailed(r))
 211     {
 212         SysLogException(NID_NET_WIFI, r, "[%s] Propagating.", GetErrorMessage(r));
 213     }
 214
 215     SysLog(NID_NET_WIFI, "Exit, [Current State : %s], [Scan State: %s], [Result : %s]",
 216                             GetStringOfCurrentState(), GetStringOfCurrentScanState(), GetErrorMessage(r));
 217
 218     return r;
 219 }
 220
 221 WifiPowerStatus
 222 _WifiManagerImpl::GetPowerStatus(void) const
 223 {
 224     WifiPowerStatus wifiPowerStatus = WIFI_POWER_STATUS_OFF;
 225
 226     if (__currentState != WIFI_MANAGER_DEACTIVATED)
 227     {
 228         wifiPowerStatus = WIFI_POWER_STATUS_ON;
 229     }
 230
 231     return wifiPowerStatus;
 232 }
 233
 234 String
 235 _WifiManagerImpl::GetMacAddress(void) const
 236 {
 237     String macAddress(L"");
 238
 239     switch (__currentState)
 240     {
 241     case WIFI_MANAGER_DEACTIVATED:
 242     case WIFI_MANAGER_ACTIVATING:
 243         return macAddress;
 244         break;
 245     default:
 246         macAddress = __pWifiSystemAdapter->GetMacAddress();
 247         break;
 248     }
 249
 250     return macAddress;
 251 }
 252
 253 bool
 254 _WifiManagerImpl::IsActivated(void) const
 255 {
 256     bool isActivated = false;
 257
 258     SysLog(NID_NET_WIFI, "Enter, [Current State : %s], [Scan State: %s]",
 259                             GetStringOfCurrentState(), GetStringOfCurrentScanState());
 260
 261     if ((__currentState != WIFI_MANAGER_DEACTIVATED) && (__currentState != WIFI_MANAGER_ACTIVATING))
 262     {
 263         isActivated = true;
 264     }
 265     else
 266     {
 267         isActivated = false;
 268     }
 269
 270     return isActivated;
 271 }
 272
 273 bool
 274 _WifiManagerImpl::IsConnected(void) const
 275 {
 276     bool isConnected = false;
 277
 278     SysLog(NID_NET_WIFI, "Enter, [Current State : %s], [Scan State: %s]",
 279                             GetStringOfCurrentState(), GetStringOfCurrentScanState());
 280
 281     if (__currentState == WIFI_MANAGER_CONNECTED)
 282     {
 283         isConnected = true;
 284     }
 285     else
 286     {
 287         isConnected = false;
 288     }
 289
 290     return isConnected;
 291 }
 292
 293 result
 294 _WifiManagerImpl::Scan(void)
 295 {
 296     result r = E_SUCCESS;
 297
 298     SysLog(NID_NET_WIFI, "Enter, [Current State : %s], [Scan State: %s]",
 299                             GetStringOfCurrentState(), GetStringOfCurrentScanState());
 300
 301     __stateMutex.Acquire();
 302
 303     switch (__currentState)
 304     {
 305     case WIFI_MANAGER_DEACTIVATED:
 306     case WIFI_MANAGER_ACTIVATING:
 307     case WIFI_MANAGER_DEACTIVATING:
 308         r = E_INVALID_STATE;
 309         break;
 310     default:
 311         if (__currentScanState == WIFI_SCAN_IDLE)
 312         {
 313             r = __pWifiSystemAdapter->Scan();
 314             if (r == E_SUCCESS)
 315             {
 316                 __currentScanState = WIFI_SCAN_SCANNING;
 317             }
 318             else if (r == E_IN_PROGRESS)
 319             {
 320                 SysLog(NID_NET_WIFI, "SLP returned E_IN_PROGRESS, return E_SUCCESS (Same as 2.0)");
 321                 __currentScanState = WIFI_SCAN_SCANNING;
 322                 r = E_SUCCESS;
 323             }
 324         }
 325         else
 326         {
 327             r = E_SUCCESS;
 328             SysLog(NID_NET_WIFI, "Current Scan request is not processed as scan is either in progress or canceling.");
 329         }
 330         break;
 331     }
 332
 333     __stateMutex.Release();
 334
 335     if (IsFailed(r))
 336     {
 337         SysLogException(NID_NET_WIFI, r, "[%s] Propagating.", GetErrorMessage(r));
 338     }
 339
 340     SysLog(NID_NET_WIFI, "Exit, [Current State : %s], [Scan State: %s], [Result : %s]",
 341                             GetStringOfCurrentState(), GetStringOfCurrentScanState(), GetErrorMessage(r));
 342     return r;
 343 }
 344
 345 result
 346 _WifiManagerImpl::Connect(const WifiBssInfo& targetApInfo)
 347 {
 348     result r = E_SUCCESS;
 349
 350     SysLog(NID_NET_WIFI, "Enter, [Current State : %s], [Scan State: %s]",
 351                             GetStringOfCurrentState(), GetStringOfCurrentScanState());
 352
 353     __stateMutex.Acquire();
 354
 355     switch (__currentState)
 356     {
 357     case WIFI_MANAGER_DEACTIVATED:
 358     case WIFI_MANAGER_ACTIVATING:
 359     case WIFI_MANAGER_DEACTIVATING:
 360         r = E_INVALID_STATE;
 361         break;
 362     case WIFI_MANAGER_ACTIVATED:
 363     case WIFI_MANAGER_CONNECTED:
 364         if (targetApInfo.GetBssType() != WIFI_BSS_TYPE_INFRASTRUCTURE)
 365         {
 366             r = E_INVALID_ARG;
 367         }
 368         else
 369         {
 370             r = __pWifiSystemAdapter->Connect(targetApInfo);
 371             if (r == E_SUCCESS)
 372             {
 373                 __currentState = WIFI_MANAGER_CONNECTING;
 374             }
 375         }
 376         break;
 377     case WIFI_MANAGER_CONNECTING:
 378         r = E_IN_PROGRESS;
 379         break;
 380     }
 381
 382     __stateMutex.Release();
 383
 384    if (IsFailed(r))
 385    {
 386        SysLogException(NID_NET_WIFI, r, "[%s] Propagating.", GetErrorMessage(r));
 387    }
 388
 389     SysLog(NID_NET_WIFI, "Exit, [Current State : %s], [Scan State: %s], [Result : %s]",
 390                             GetStringOfCurrentState(), GetStringOfCurrentScanState(), GetErrorMessage(r));
 391
 392     return r;
 393 }
 394
 395 result
 396 _WifiManagerImpl::SetWifiSystemScanMode(WifiSystemScanMode mode)
 397 {
 398         result r = E_SUCCESS;
 399         _WifiIpcProxy* pProxy = null;
 400
 401         pProxy = _WifiIpcProxy::GetInstance();
 402     SysTryReturnResult(NID_NET_WIFI, pProxy != null, E_SYSTEM, "Failed to get _WifiIpcProxy instance.");
 403
 404     r = pProxy->SetWifiSystemScanMode(mode);
 405         SysTryReturnResult(NID_NET_WIFI, r == E_SUCCESS, r, "Propagating.");
 406
 407         return E_SUCCESS;
 408 }
 409
 410 result
 411 _WifiManagerImpl::AddSystemMonitoringEventListener(IWifiSystemMonitoringEventListener& listener)
 412 {
 413         result r = E_SUCCESS;
 414         _WifiIpcProxy* pProxy = null;
 415
 416         pProxy = _WifiIpcProxy::GetInstance();
 417     SysTryReturnResult(NID_NET_WIFI, pProxy != null, E_SYSTEM, "Failed to get _WifiIpcProxy instance.");
 418
 419     r = pProxy->CheckSystemSettingPrivilege();
 420         SysTryReturnResult(NID_NET_WIFI, r == E_SUCCESS, r, "Propagating.");
 421
 422         // add the specified new IWifiSystemMonitoringEventListener instance to the _WifiSystemMonitoringEvent.
 423         r = __pMonitoringEvent->AddListener(listener, true);
 424         r = TransExceptionsExclusive(r, E_SYSTEM, E_OUT_OF_MEMORY, E_OBJ_ALREADY_EXIST);
 425         SysTryReturnResult(NID_NET_WIFI, r == E_SUCCESS, r, "Failed to add the new listener.");
 426
 427         SysLog(NID_NET_WIFI, "Adding the new IWifiSystemMonitoringEventListener is successful.");
 428
 429         return E_SUCCESS;
 430 }
 431
 432 result
 433 _WifiManagerImpl::RemoveSystemMonitoringEventListener(IWifiSystemMonitoringEventListener& listener)
 434 {
 435         result r = E_SUCCESS;
 436         _WifiIpcProxy* pProxy = null;
 437
 438         pProxy = _WifiIpcProxy::GetInstance();
 439     SysTryReturnResult(NID_NET_WIFI, pProxy != null, E_SYSTEM, "Failed to get _WifiIpcProxy instance.");
 440
 441     r = pProxy->CheckSystemSettingPrivilege();
 442         SysTryReturnResult(NID_NET_WIFI, r == E_SUCCESS, r, "Propagating.");
 443
 444         // remove the previous IWifiSystemMonitoringEventListener instance from the _WifiSystemMonitoringEvent.
 445         r = __pMonitoringEvent->RemoveListener(listener);
 446         r = TransExceptionsExclusive(r, E_SYSTEM, E_OUT_OF_MEMORY, E_OBJ_NOT_FOUND);
 447         SysTryReturnResult(NID_NET_WIFI, r == E_SUCCESS, r, "Failed to remove the previous listener.");
 448
 449         SysLog(NID_NET_WIFI, "Removing the previous IWifiSystemMonitoringEventListener is successful.");
 450
 451         return E_SUCCESS;
 452 }
 453
 454 WifiConnectionState
 455 _WifiManagerImpl::GetConnectionState(void) const
 456 {
 457     return __pWifiSystemAdapter->GetConnectionState();
 458 }
 459
 460 WifiBssInfo*
 461 _WifiManagerImpl::GetConnectionTargetInfoN(void) const
 462 {
 463     return __pWifiSystemAdapter->GetConnectionTargetInfoN();
 464 }
 465
 466 result
 467 _WifiManagerImpl::UpdateBssInfo(const WifiBssInfo& bssInfo)
 468 {
 469         result r = E_SUCCESS;
 470         _WifiIpcProxy* pProxy = null;
 471
 472         pProxy = _WifiIpcProxy::GetInstance();
 473         SysTryReturnResult(NID_NET_WIFI, pProxy != null, E_SYSTEM, "Failed to get _WifiIpcProxy instance.");
 474
 475         r = pProxy->UpdateBssInfo(bssInfo);
 476         SysTryReturnResult(NID_NET_WIFI, r == E_SUCCESS, r, "Propagating.");
 477
 478         return E_SUCCESS;
 479 }
 480
 481 Tizen::Base::Collection::IList*
 482 _WifiManagerImpl::GetSystemScanResultN(void) const
 483 {
 484     return __pWifiSystemAdapter->GetSystemScanResultN();
 485 }
 486
 487 void
 488 _WifiManagerImpl::OnWifiActivated(result r)
 489 {
 490     SysLog(NID_NET_WIFI, "Enter, [CurrentState:%s], [Scan State: %s], [result:%s]",
 491                             GetStringOfCurrentState(), GetStringOfCurrentScanState(), GetErrorMessage(r));
 492     bool isFired = false;
 493
 494     __stateMutex.Acquire();
 495
 496     switch (__currentState)
 497     {
 498     case WIFI_MANAGER_DEACTIVATED:
 499         if (r == E_SUCCESS)
 500         {
 501             __currentState = WIFI_MANAGER_ACTIVATED;
 502             isFired = true;
 503         }
 504         break;
 505     case WIFI_MANAGER_ACTIVATING:
 506         if (r == E_SUCCESS)
 507         {
 508             __currentState = WIFI_MANAGER_ACTIVATED;
 509         }
 510         else
 511         {
 512             __currentState = WIFI_MANAGER_DEACTIVATED;
 513         }
 514
 515         isFired = true;
 516         break;
 517     default:
 518         break;
 519     }
 520
 521     __stateMutex.Release();
 522
 523     if (isFired)
 524     {
 525         _WifiManagerEventArg* pArg = new (std::nothrow) _WifiManagerEventArg(_WIFI_EVENT_ACTIVATED, r);
 526         SysTryReturnVoidResult(NID_NET_WIFI, pArg != null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
 527
 528         __pMgrEvent->FireAsync(*pArg);
 529     }
 530
 531     if ((isFired) && (IsFailed(r)))
 532     {
 533         SysLogException(NID_NET_WIFI, r, "[%s] exception occurred on Wifi-activate callback.", GetErrorMessage(r));
 534     }
 535
 536     SysLog(NID_NET_WIFI, "ExitPoint, [CurrentState:%s], [Scan State: %s], [result:%s], [ACTIVATED_Event:%s]",
 537                    GetStringOfCurrentState(), GetStringOfCurrentScanState(), GetErrorMessage(r), isFired ? "Fired" : "NotFired");
 538 }
 539
 540 void
 541 _WifiManagerImpl::OnWifiDeactivated(result r)
 542 {
 543     SysLog(NID_NET_WIFI, "Enter, [CurrentState:%s], [Scan State: %s], [result:%s]",
 544                             GetStringOfCurrentState(), GetStringOfCurrentScanState(), GetErrorMessage(r));
 545     bool isFired = false;
 546
 547     __stateMutex.Acquire();
 548
 549     switch (__currentState)
 550     {
 551     case WIFI_MANAGER_DEACTIVATING:
 552         if (r == E_SUCCESS)
 553         {
 554             __currentState = WIFI_MANAGER_DEACTIVATED;
 555             __currentScanState = WIFI_SCAN_IDLE;
 556         }
 557         else
 558         {
 559             if (__pWifiSystemAdapter->IsConnected())
 560             {
 561                 __currentState = WIFI_MANAGER_CONNECTED;
 562             }
 563             else
 564             {
 565                 __currentState = WIFI_MANAGER_ACTIVATED;
 566             }
 567         }
 568
 569         isFired = true;
 570         break;
 571     case WIFI_MANAGER_ACTIVATED:
 572     case WIFI_MANAGER_CONNECTING:
 573     case WIFI_MANAGER_CONNECTED:
 574     case WIFI_MANAGER_ACTIVATING:
 575         if (r == E_SUCCESS)
 576         {
 577             __currentState = WIFI_MANAGER_DEACTIVATED;
 578             __currentScanState = WIFI_SCAN_IDLE;
 579             isFired = true;
 580         }
 581         break;
 582     default:
 583         break;
 584     }
 585
 586     __stateMutex.Release();
 587
 588     if (r == E_SUCCESS)
 589     {
 590         __wasConnected = false;
 591     }
 592
 593     if (isFired)
 594     {
 595         _WifiManagerEventArg* pArg = new (std::nothrow) _WifiManagerEventArg(_WIFI_EVENT_DEACTIVATED, r);
 596         SysTryReturnVoidResult(NID_NET_WIFI, pArg != null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
 597
 598         __pMgrEvent->FireAsync(*pArg);
 599     }
 600
 601     if ((isFired) && (IsFailed(r)))
 602     {
 603         SysLogException(NID_NET_WIFI, r, "[%s] exception occurred on Wifi-deactive callback.", GetErrorMessage(r));
 604     }
 605
 606     SysLog(NID_NET_WIFI, "ExitPoint, [CurrentState:%s], [Scan State: %s] , [result:%s], [DEACTIVATED_Event:%s]",
 607                     GetStringOfCurrentState(), GetStringOfCurrentScanState(), GetErrorMessage(r), isFired ? "Fired" :"NotFired");
 608 }
 609
 610 void
 611 _WifiManagerImpl::OnWifiConnected(const Tizen::Base::String &ssid, result r)
 612 {
 613     SysLog(NID_NET_WIFI, "Enter, [CurrentState:%s], [Scan State: %s] , [result:%s]",
 614                             GetStringOfCurrentState(), GetStringOfCurrentScanState(), GetErrorMessage(r));
 615     bool isFired = false;
 616
 617     __stateMutex.Acquire();
 618
 619     switch (__currentState)
 620     {
 621     case WIFI_MANAGER_DEACTIVATING:
 622         if (r == E_SUCCESS)
 623         {
 624             __currentState = WIFI_MANAGER_CONNECTED;
 625             __wasConnected = true;
 626             isFired = true;
 627         }
 628         else
 629         {
 630             isFired = true;
 631         }
 632         break;
 633     case WIFI_MANAGER_ACTIVATED:
 634         if (r == E_SUCCESS)
 635         {
 636             __currentState = WIFI_MANAGER_CONNECTED;
 637             __wasConnected = true;
 638             isFired = true;
 639         }
 640         break;
 641     case WIFI_MANAGER_CONNECTING:
 642         if (r == E_SUCCESS)
 643         {
 644             __currentState = WIFI_MANAGER_CONNECTED;
 645             __wasConnected = true;
 646         }
 647         else
 648         {
 649             __currentState = WIFI_MANAGER_ACTIVATED;
 650         }
 651
 652         isFired = true;
 653         break;
 654     default:
 655         break;
 656     }
 657
 658     __stateMutex.Release();
 659
 660
 661     if (isFired)
 662     {
 663         _WifiManagerEventArg* pArg = new (std::nothrow) _WifiManagerEventArg(_WIFI_EVENT_CONNECTED, ssid, r);
 664         SysTryReturnVoidResult(NID_NET_WIFI, pArg != null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
 665
 666         __pMgrEvent->FireAsync(*pArg);
 667     }
 668
 669     if ((isFired) && (IsFailed(r)))
 670     {
 671         SysLogException(NID_NET_WIFI, r, "[%s] exception occurred on Wifi-connect callback.", GetErrorMessage(r));
 672     }
 673
 674     SysLog(NID_NET_WIFI, "ExitPoint, [CurrentState:%s], [Scan State: %s] , [result:%s], [CONNECTED_Event:%s]",
 675     GetStringOfCurrentState(), GetStringOfCurrentScanState(), GetErrorMessage(r), isFired ? "Fired" : "NotFired");
 676 }
 677
 678 void
 679 _WifiManagerImpl::OnWifiDisconnected(void)
 680 {
 681     SysLog(NID_NET_WIFI, "Enter, [CurrentState:%s], [Scan State: %s]", GetStringOfCurrentState(), GetStringOfCurrentScanState());
 682     bool isFired = false;
 683
 684     __stateMutex.Acquire();
 685     switch (__currentState)
 686     {
 687     case WIFI_MANAGER_DEACTIVATING:
 688                 if (__wasConnected == true)
 689                 {
 690                         isFired = true;
 691                 }
 692         break;
 693
 694     case WIFI_MANAGER_CONNECTING:
 695                 __currentState = WIFI_MANAGER_ACTIVATED;
 696                 if (__wasConnected == true)
 697                 {
 698                         isFired = true;
 699                 }
 700         break;
 701
 702     case WIFI_MANAGER_CONNECTED:
 703                 __currentState = WIFI_MANAGER_ACTIVATED;
 704                 isFired = true;
 705         break;
 706     default:
 707         break;
 708     }
 709     __stateMutex.Release();
 710
 711     __wasConnected = false;
 712
 713     if (isFired)
 714     {
 715         _WifiManagerEventArg* pArg = new (std::nothrow) _WifiManagerEventArg(_WIFI_EVENT_DISCONNECTED);
 716         SysTryReturnVoidResult(NID_NET_WIFI, pArg != null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
 717
 718         __pMgrEvent->FireAsync(*pArg);
 719     }
 720
 721     SysLog(NID_NET_WIFI, "ExitPoint, [CurrentState:%s], [Scan State: %s], [DISCONNECTED_Event:%s]",
 722                 GetStringOfCurrentState(), GetStringOfCurrentScanState(), isFired ? "Fired" : "NotFired");
 723 }
 724
 725 void
 726 _WifiManagerImpl::OnWifiRssiChanged(long rssi)
 727 {
 728     SysLog(NID_NET_WIFI, "Enter, [CurrentState:%s], [Scan State: %s]",
 729                             GetStringOfCurrentState(), GetStringOfCurrentScanState());
 730
 731     if (__currentState == WIFI_MANAGER_CONNECTED)
 732     {
 733         _WifiManagerEventArg* pArg = new (std::nothrow) _WifiManagerEventArg(_WIFI_EVENT_RSSI_CHANGED, rssi);
 734         SysTryReturnVoidResult(NID_NET_WIFI, pArg != null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
 735
 736         __pMgrEvent->FireAsync(*pArg);
 737     }
 738 }
 739
 740 void
 741 _WifiManagerImpl::OnWifiScanCompleted(Tizen::Base::Collection::IList* pWifiBssInfoList, result r)
 742 {
 743         IList* pBssInfoList = null;
 744     bool isFired = false;
 745     SysLog(NID_NET_WIFI, "Enter, [CurrentState:%s], [Scan State: %s], [result:%s]",
 746                             GetStringOfCurrentState(), GetStringOfCurrentScanState(), GetErrorMessage(r));
 747
 748     __stateMutex.Acquire();
 749
 750     if (__currentScanState == WIFI_SCAN_SCANNING)
 751     {
 752         isFired = true;
 753         __currentScanState = WIFI_SCAN_IDLE;
 754     }
 755
 756     __stateMutex.Release();
 757
 758     if (isFired == true)
 759     {
 760                 pBssInfoList = _WifiUtility::GetWifiBssInfoListCloneN(pWifiBssInfoList);
 761         _WifiManagerEventArg* pArg = new (std::nothrow) _WifiManagerEventArg(_WIFI_EVENT_SCAN_COMPLETED, pBssInfoList, r);
 762         SysTryReturnVoidResult(NID_NET_WIFI, pArg != null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
 763
 764         __pMgrEvent->FireAsync(*pArg);
 765     }
 766
 767     SysLog(NID_NET_WIFI, "Exit, [CurrentState:%s], [Scan State: %s], [SCAN_COMPLETED_Event:%s]",
 768                     GetStringOfCurrentState(), GetStringOfCurrentScanState(), isFired ? "Fired" : "Not Fired");
 769 }
 770
 771 void
 772 _WifiManagerImpl::OnWifiConnectionStateChanged(WifiConnectionState state)
 773 {
 774         SysLog(NID_NET_WIFI, "Enter, [CurrentState:%s], [Connection State: %s]",
 775                                         GetStringOfCurrentState(), GetStringOfConnectionState(state));
 776
 777         _WifiSystemMonitoringEventArg* pArg = new (std::nothrow) _WifiSystemMonitoringEventArg(state);
 778         SysTryReturnVoidResult(NID_NET_WIFI, pArg != null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
 779
 780         __pMonitoringEvent->FireAsync(*pArg);
 781
 782     SysLog(NID_NET_WIFI, "Exit, [CurrentState:%s], [CONN_STATE_Event:Fired]", GetStringOfCurrentState());
 783 }
 784
 785 void
 786 _WifiManagerImpl::OnWifiSystemScanResultUpdated(void)
 787 {
 788         SysLog(NID_NET_WIFI, "Enter, [CurrentState:%s]", GetStringOfCurrentState());
 789
 790         _WifiSystemMonitoringEventArg* pArg = new (std::nothrow) _WifiSystemMonitoringEventArg();
 791         SysTryReturnVoidResult(NID_NET_WIFI, pArg != null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
 792
 793         __pMonitoringEvent->FireAsync(*pArg);
 794
 795     SysLog(NID_NET_WIFI, "Exit, [CurrentState:%s], [BACKSCAN_RESULT_Event:Fired]", GetStringOfCurrentState());
 796 }
 797
 798 _WifiManagerImpl*
 799 _WifiManagerImpl::GetInstance(WifiManager& wifiManager)
 800 {
 801     return wifiManager.__pWifiManagerImpl;
 802 }
 803
 804 const _WifiManagerImpl*
 805 _WifiManagerImpl::GetInstance(const WifiManager& wifiManager)
 806 {
 807     return wifiManager.__pWifiManagerImpl;
 808 }
 809
 810 const char*
 811 _WifiManagerImpl::GetStringOfCurrentState(void) const
 812 {
 813     const char* pStateString = null;
 814
 815     switch (__currentState)
 816     {
 817     case WIFI_MANAGER_DEACTIVATED:
 818         pStateString = "__WIFI_MANAGER_DEACTIVATED";
 819         break;
 820     case WIFI_MANAGER_ACTIVATING:
 821         pStateString = "__WIFI_MANAGER_ACTIVATING";
 822         break;
 823     case WIFI_MANAGER_DEACTIVATING:
 824         pStateString = "__WIFI_MANAGER_DEACTIVATING";
 825         break;
 826     case WIFI_MANAGER_ACTIVATED:
 827         pStateString = "__WIFI_MANAGER_ACTIVATED";
 828         break;
 829     case WIFI_MANAGER_CONNECTING:
 830         pStateString = "__WIFI_MANAGER_CONNECTING";
 831         break;
 832     case WIFI_MANAGER_CONNECTED:
 833         pStateString = "__WIFI_MANAGER_CONNECTED";
 834         break;
 835     default:
 836         pStateString = "Unknown";
 837         break;
 838     }
 839
 840     return pStateString;
 841 }
 842
 843 const char*
 844 _WifiManagerImpl::GetStringOfCurrentScanState(void) const
 845 {
 846     const char* pStateString = null;
 847
 848     switch (__currentScanState)
 849     {
 850     case WIFI_SCAN_IDLE:
 851         pStateString = "__WIFI_SCAN_IDLE";
 852         break;
 853     case WIFI_SCAN_SCANNING:
 854         pStateString = "__WIFI_SCAN_SCANNING";
 855         break;
 856     case WIFI_SCAN_CANCELLING:
 857         pStateString = "__WIFI_SCAN_CANCELLING";
 858         break;
 859     default:
 860         pStateString = "Unknown";
 861         break;
 862     }
 863
 864     return pStateString;
 865 }
 866
 867 const char*
 868 _WifiManagerImpl::GetStringOfConnectionState(WifiConnectionState state) const
 869 {
 870     const char* pStateString = null;
 871
 872     switch (state)
 873     {
 874     case WIFI_CONN_STATE_NOT_CONNECTED:
 875         pStateString = "IDLE";
 876         break;
 877     case WIFI_CONN_STATE_ASSOCIATING:
 878         pStateString = "ASSOCIATING";
 879         break;
 880     case WIFI_CONN_STATE_CONFIGURING:
 881         pStateString = "CONFIGURING";
 882         break;
 883     case WIFI_CONN_STATE_CONNECTED:
 884         pStateString = "CONNECTED";
 885         break;
 886     default:
 887         pStateString = "Unknown";
 888         break;
 889     }
 890
 891     return pStateString;
 892 }
 893
 894 } } } // Tizen::Net::Wifi
 895
 896
 897 #ifdef __cplusplus
 898 extern "C"
 899 {
 900 #endif
 901
 902 _OSP_EXPORT_ result
 903 _WifiManagerImpl_Activate(void)
 904 {
 905     Tizen::Net::Wifi::_WifiSystemAdapter* __pWifiSystemAdapter = Tizen::Net::Wifi::_WifiSystemAdapter::GetInstance();
 906     SysTryReturnResult(NID_NET_WIFI, __pWifiSystemAdapter != null, E_OUT_OF_MEMORY, "Failed to get Wi-Fi System adapter instance");
 907
 908     return __pWifiSystemAdapter->Activate();
 909 }
 910
 911 _OSP_EXPORT_ result
 912 _WifiManagerImpl_Deactivate(void)
 913 {
 914     Tizen::Net::Wifi::_WifiSystemAdapter* __pWifiSystemAdapter = Tizen::Net::Wifi::_WifiSystemAdapter::GetInstance();
 915     SysTryReturnResult(NID_NET_WIFI, __pWifiSystemAdapter != null, E_OUT_OF_MEMORY, "Failed to get Wi-Fi System adapter instance");
 916
 917     return __pWifiSystemAdapter->Deactivate();
 918 }
 919
 920 #ifdef __cplusplus
 921 }
 922 #endif
 923
 924