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