src/wifi/FNetWifi_WifiDirectSystemAdapter.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_WifiDirectSystemAdapter.cpp
  20  * @brief   This is the implementation file for _WifiDirectSystemAdapter class
  21  */
  22 #include <pthread.h>
  23 #include <vconf.h>
  24 #include <wifi-direct.h>
  25 #include <FBaseColArrayList.h>
  26 #include <FBaseColLinkedList.h>
  27 #include <FTextEncoding.h>
  28 #include <FBaseUtilStringUtil.h>
  29 #include <FNetWifiWifiDirectGroupMember.h>
  30 #include <FNetWifiWifiDirectGroupInfo.h>
  31 #include <FNetWifiWifiDirectDeviceInfo.h>
  32 #include <FNetIp4Address.h>
  33 #include <FBaseSysLog.h>
  34 #include <FBase_StringConverter.h>
  35 #include <FBaseColAllElementsDeleter.h>
  36 #include "FNetWifi_WifiDirectSystemAdapter.h"
  37 #include "FNetWifi_WifiDirectEvent.h"
  38 #include "FNetWifi_WifiDirectEventArg.h"
  39 #include "FNetWifi_WifiDirectUtility.h"
  40 #include "FNetWifi_WifiDirectDeviceImpl.h"
  41 #include "FNetWifi_WifiDirectDeviceInfoImpl.h"
  42 #include "FNetWifi_WifiDirectGroupInfoImpl.h"
  43 #include "FNetWifi_WifiIpcProxy.h"
  44 #include "FNetWifi_WifiDirectUtility.h"
  45
  46 #ifdef _WifiDirectConvertErrorResult
  47 #undef _WifiDirectConvertErrorResult
  48 #endif
  49 #define _WifiDirectConvertErrorResult(condition, r, value) \
  50                 do \
  51                 { \
  52                         if (condition) {   \
  53                                 r = value; \
  54                         } \
  55                 } while (0);
  56
  57 using namespace std;
  58 using namespace Tizen::Base;
  59 using namespace Tizen::Base::Utility;
  60 using namespace Tizen::Base::Collection;
  61 using namespace Tizen::Text;
  62 using namespace Tizen::Net;
  63
  64 namespace Tizen { namespace Net { namespace Wifi {
  65
  66 static const int MAX_DEVICE_INFO_COUNT = 32;
  67 static const int WIFI_DIRECT_DISCOVERY_TIMEOUT = 10;
  68
  69 _WifiDirectSystemAdapter* _WifiDirectSystemAdapter::__pWifiDirectSystemAdapter = null;
  70
  71 void
  72 _WifiDirectSystemAdapter::InitSingleton(void)
  73 {
  74     unique_ptr<_WifiDirectSystemAdapter> pInst(new (std::nothrow) _WifiDirectSystemAdapter());
  75     SysTryReturnVoidResult(NID_NET_WIFI, pInst != null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
  76
  77     bool r = true;
  78     r = pInst->Construct();
  79     SysTryReturnVoidResult(NID_NET_WIFI, r == true, r, "Error occured in construct.");
  80
  81     __pWifiDirectSystemAdapter = pInst.release();
  82     std::atexit(DestroySingleton);
  83 }
  84
  85 void
  86 _WifiDirectSystemAdapter::DestroySingleton(void)
  87 {
  88     delete __pWifiDirectSystemAdapter;
  89 }
  90
  91 _WifiDirectSystemAdapter*
  92 _WifiDirectSystemAdapter::GetInstance(void)
  93 {
  94     static pthread_once_t onceBlock = PTHREAD_ONCE_INIT;
  95
  96     if (!__pWifiDirectSystemAdapter)
  97     {
  98         ClearLastResult();
  99         pthread_once(&onceBlock, InitSingleton);
 100
 101         result r = GetLastResult();
 102         if (IsFailed(r))
 103         {
 104              onceBlock = PTHREAD_ONCE_INIT;
 105         }
 106     }
 107
 108     return __pWifiDirectSystemAdapter;
 109 }
 110
 111 /////////////////////////////////////////////////////
 112 // DeviceManager
 113
 114 Tizen::Base::Collection::IList*
 115 _WifiDirectSystemAdapter::GetAllDeviceInfoN(void)
 116 {
 117     result r = E_SUCCESS;
 118
 119     unique_ptr<ArrayList> pList(new (std::nothrow) ArrayList());
 120     SysTryReturn(NID_NET_WIFI, pList != null, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
 121
 122     r = pList->Construct();
 123     SysTryReturn(NID_NET_WIFI, r == E_SUCCESS, null, r, "[%s] Propagating.", GetErrorMessage(r));
 124
 125     unique_ptr<WifiDirectDeviceInfo> pDeviceInfo(GetLocalDeviceInfoN());
 126     SysTryReturn(NID_NET_WIFI, pDeviceInfo != null, null, GetLastResult(), "[%s] Propagating.", GetErrorMessage(GetLastResult()));
 127
 128     r = pList->Add(*pDeviceInfo);
 129     SysTryReturn(NID_NET_WIFI, r == E_SUCCESS, null, r, "[%s] Propagating.", GetErrorMessage(r));
 130     pDeviceInfo.release();
 131
 132     return pList.release();
 133 }
 134
 135 /////////////////////////////////////////////////////
 136 // Device
 137
 138 result
 139 _WifiDirectSystemAdapter::Activate(void)
 140 {
 141     result r = E_SYSTEM;
 142     int err = WIFI_DIRECT_ERROR_NONE;
 143
 144     err = wifi_direct_activate();
 145     _WifiDirectConvertErrorResult(err == WIFI_DIRECT_ERROR_NOT_PERMITTED, r, E_INVALID_OPERATION);
 146     _WifiDirectConvertErrorResult(err == WIFI_DIRECT_ERROR_NONE, r, E_SUCCESS);
 147     SysTryReturn(NID_NET_WIFI, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
 148
 149     __currentState = WIFI_DIRECT_SYSTEM_ACTIVATING;
 150
 151     return r;
 152 }
 153
 154 result
 155 _WifiDirectSystemAdapter::Deactivate(void)
 156 {
 157     result r = E_SYSTEM;
 158     int err = WIFI_DIRECT_ERROR_NONE;
 159
 160     err = wifi_direct_deactivate();
 161     _WifiDirectConvertErrorResult(err == WIFI_DIRECT_ERROR_NOT_PERMITTED, r, E_INVALID_OPERATION);
 162     _WifiDirectConvertErrorResult(err == WIFI_DIRECT_ERROR_NONE, r, E_SUCCESS);
 163     SysTryReturn(NID_NET_WIFI, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
 164
 165     __currentState = WIFI_DIRECT_SYSTEM_DEACTIVATING;
 166
 167     return r;
 168 }
 169
 170 WifiDirectGroupInfo*
 171 _WifiDirectSystemAdapter::GetGroupSettingInfoN(void) const
 172 {
 173     result r = E_SUCCESS;
 174     int err = WIFI_DIRECT_ERROR_NONE;
 175
 176     unique_ptr<WifiDirectGroupInfo> pGroupInfo(new (std::nothrow) WifiDirectGroupInfo());
 177     SysTryReturn(NID_NET_WIFI, pGroupInfo != null, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
 178
 179     _WifiDirectGroupInfoImpl* pGroupInfoImpl = _WifiDirectGroupInfoImpl::GetInstance(*pGroupInfo);
 180     wifi_direct_state_e status = WIFI_DIRECT_STATE_DEACTIVATED;
 181     err = wifi_direct_get_state(&status);
 182     _WifiDirectConvertErrorResult(err != WIFI_DIRECT_ERROR_NONE, r, E_SYSTEM);
 183     SysTryReturn(NID_NET_WIFI, r == E_SUCCESS, null, r, "[%s] Propagating.", GetErrorMessage(r));
 184
 185     // MAC
 186     char* pMacAddress = null;
 187     err = wifi_direct_get_mac_address(&pMacAddress);
 188     _WifiDirectConvertErrorResult(err != WIFI_DIRECT_ERROR_NONE, r, E_SYSTEM);
 189     _WifiDirectConvertErrorResult(err == WIFI_DIRECT_ERROR_OUT_OF_MEMORY, r, E_OUT_OF_MEMORY);
 190
 191     SysTryReturn(NID_NET_WIFI, pMacAddress != null && r == E_SUCCESS, null, r, "[%s] Propagating.", GetErrorMessage(r));
 192
 193     String mac = _WifiDirectUtility::ConvertMacCharToString(pMacAddress);
 194     free(pMacAddress);
 195     pGroupInfoImpl->SetBssId(mac);
 196
 197     if (status != WIFI_DIRECT_STATE_DEACTIVATED
 198             && status != WIFI_DIRECT_STATE_DEACTIVATING
 199             && status != WIFI_DIRECT_STATE_ACTIVATING)
 200     {
 201                 // SSID
 202         if (status == WIFI_DIRECT_STATE_CONNECTED)
 203         {
 204                         char* pSsid = null;
 205                         err = wifi_direct_get_ssid(&pSsid);
 206
 207                         if (pSsid == null)
 208                         {
 209                                 SysLog(NID_NET_WIFI, "The ssid is null.");
 210                         }
 211                         else
 212                         {
 213                                 pGroupInfoImpl->SetSsid(String(pSsid));
 214                                 free(pSsid);
 215                         }
 216         }
 217
 218         // Autonomous group
 219         bool isAutonomousGroup = false;
 220         err = wifi_direct_is_autonomous_group(&isAutonomousGroup);
 221         _WifiDirectConvertErrorResult(err != WIFI_DIRECT_ERROR_NONE, r, E_SYSTEM);
 222         SysTryReturn(NID_NET_WIFI, r == E_SUCCESS, null, r, "[%s] Propagating.", GetErrorMessage(r));
 223
 224         pGroupInfoImpl->SetAutonomousGroupOwnerMode(isAutonomousGroup);
 225
 226         // Intent
 227         int groupOwnerIntent = 0;
 228         err = wifi_direct_get_group_owner_intent(&groupOwnerIntent);
 229         _WifiDirectConvertErrorResult(err != WIFI_DIRECT_ERROR_NONE, r, E_SYSTEM);
 230         SysTryReturn(NID_NET_WIFI, r == E_SUCCESS, null, r, "[%s] Propagating.", GetErrorMessage(r));
 231
 232         pGroupInfoImpl->SetGroupOwnerIntent(groupOwnerIntent);
 233
 234         // Radio channel
 235         int channel = 0;
 236         err = wifi_direct_get_operating_channel(&channel);
 237         _WifiDirectConvertErrorResult(err != WIFI_DIRECT_ERROR_NONE, r, E_SYSTEM);
 238         SysTryReturn(NID_NET_WIFI, r == E_SUCCESS, null, r, "[%s] Propagating.", GetErrorMessage(r));
 239
 240         WifiRadioChannel operatingChannel = _WifiDirectUtility::ConvertChannel(channel);
 241         pGroupInfoImpl->SetOperatingChannel(operatingChannel);
 242     }
 243
 244     // Max clients
 245     int maxClients= 0;
 246     err = wifi_direct_get_max_clients(&maxClients);
 247     _WifiDirectConvertErrorResult(err != WIFI_DIRECT_ERROR_NONE, r, E_SYSTEM);
 248     SysTryReturn(NID_NET_WIFI, r == E_SUCCESS, null, r, "[%s] Propagating.", GetErrorMessage(r));
 249
 250     pGroupInfoImpl->SetMaxNumberOfClients(maxClients);
 251
 252     return pGroupInfo.release();
 253 }
 254
 255 WifiDirectDeviceInfo*
 256 _WifiDirectSystemAdapter::GetLocalDeviceInfoN(void) const
 257 {
 258     SysTryReturn(NID_NET_WIFI, __pWifiServiceProxy != null, null, E_SYSTEM, "[E_SYSTEM] IPC instance has not been constructed yet.");
 259
 260     ClearLastResult();
 261
 262     result r = E_SUCCESS;
 263     int err = WIFI_DIRECT_ERROR_NONE;
 264
 265     unique_ptr<WifiDirectDeviceInfo> pDeviceInfo(new (std::nothrow) WifiDirectDeviceInfo());
 266     SysTryReturn(NID_NET_WIFI, pDeviceInfo != null, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
 267
 268     _WifiDirectDeviceInfoImpl* pDeviceInfoImpl = _WifiDirectDeviceInfoImpl::GetInstance(*pDeviceInfo);
 269
 270     // device ID
 271     pDeviceInfoImpl->SetDeviceId(DEFAULT_DEVICE_ID);
 272
 273     // device name
 274     String deviceName;
 275     r = __pWifiServiceProxy->GetWifiDirectLocalDeviceName(deviceName);
 276     SysTryReturn(NID_NET_WIFI, r == E_SUCCESS, null, r, "[%s] Propagating.", GetErrorMessage(r));
 277
 278     pDeviceInfoImpl->SetDeviceName(deviceName);
 279     r = GetLastResult();
 280     SysTryReturn(NID_NET_WIFI, r == E_SUCCESS, null, E_SYSTEM, "[%s] The length of device name is invalid.", GetErrorMessage(r));
 281
 282     // device status / group member type
 283     wifi_direct_state_e status = WIFI_DIRECT_STATE_DEACTIVATED;
 284     err = wifi_direct_get_state(&status);
 285     _WifiDirectConvertErrorResult(err != WIFI_DIRECT_ERROR_NONE, r, E_SYSTEM);
 286     SysTryReturn(NID_NET_WIFI, r == E_SUCCESS, null, r, "[%s] Propagating.", GetErrorMessage(r));
 287
 288     if (status == WIFI_DIRECT_STATE_DEACTIVATED)
 289     {
 290         pDeviceInfoImpl->SetDeviceStatus(WIFI_DIRECT_DEVICE_DEACTIVATED);
 291     }
 292     else
 293     {
 294         pDeviceInfoImpl->SetDeviceStatus(WIFI_DIRECT_DEVICE_ACTIVATED);
 295
 296         bool isOwner = false;
 297         err = wifi_direct_is_group_owner(&isOwner);
 298         _WifiDirectConvertErrorResult(err != WIFI_DIRECT_ERROR_NONE, r, E_SYSTEM);
 299         SysTryReturn(NID_NET_WIFI, r == E_SUCCESS, null, r, "[%s] Propagating.", GetErrorMessage(r));
 300
 301         switch (status)
 302         {
 303         case WIFI_DIRECT_STATE_DISCONNECTING:
 304         case WIFI_DIRECT_STATE_CONNECTED:
 305             if (isOwner)
 306             {
 307                 pDeviceInfoImpl->SetGroupMemberType(WIFI_DIRECT_GROUP_MEMBER_TYPE_OWNER);
 308             }
 309             else
 310             {
 311                 pDeviceInfoImpl->SetGroupMemberType(WIFI_DIRECT_GROUP_MEMBER_TYPE_CLIENT);
 312             }
 313             break;
 314         case WIFI_DIRECT_STATE_ACTIVATED:
 315             if (isOwner)
 316             {
 317                 pDeviceInfoImpl->SetGroupMemberType(WIFI_DIRECT_GROUP_MEMBER_TYPE_OWNER);
 318             }
 319             else
 320             {
 321                 pDeviceInfoImpl->SetGroupMemberType(WIFI_DIRECT_GROUP_MEMBER_TYPE_NONE);
 322             }
 323             break;
 324         default:
 325             pDeviceInfoImpl->SetGroupMemberType(WIFI_DIRECT_GROUP_MEMBER_TYPE_NONE);
 326             break;
 327         }
 328
 329         if (status == WIFI_DIRECT_STATE_CONNECTED)
 330         {
 331                 // ssid
 332                 char* pSsid = null;
 333                 err = wifi_direct_get_ssid(&pSsid);
 334
 335                 if (pSsid == null)
 336                 {
 337                         SysLog(NID_NET_WIFI, "The ssid is null.");
 338                 }
 339                 else
 340                 {
 341                         pDeviceInfoImpl->SetSsid(String(pSsid));
 342                         free(pSsid);
 343                 }
 344         }
 345     }
 346
 347     // device type category
 348     wifi_direct_primary_device_type_e typeCategory = WIFI_DIRECT_PRIMARY_DEVICE_TYPE_OTHER;
 349     err = wifi_direct_get_primary_device_type(&typeCategory);
 350     _WifiDirectConvertErrorResult(err != WIFI_DIRECT_ERROR_NONE, r, E_SYSTEM);
 351     SysTryReturn(NID_NET_WIFI, r == E_SUCCESS, null, r, "[%s] Propagating.", GetErrorMessage(r));
 352
 353     WifiDirectDeviceTypeCategory deviceTypeCategory = _WifiDirectUtility::ConvertDeviceTypeCategory(typeCategory);
 354     pDeviceInfoImpl->SetDeviceTypeCategory(deviceTypeCategory);
 355
 356     // mac address
 357     char* pMacAddress = null;
 358     err = wifi_direct_get_mac_address(&pMacAddress);
 359     _WifiDirectConvertErrorResult(err != WIFI_DIRECT_ERROR_NONE, r, E_SYSTEM);
 360     _WifiDirectConvertErrorResult(err == WIFI_DIRECT_ERROR_OUT_OF_MEMORY, r, E_OUT_OF_MEMORY);
 361     SysTryReturn(NID_NET_WIFI, pMacAddress != null && r == E_SUCCESS, null, r, "[%s] Propagating.", GetErrorMessage(r));
 362
 363     String mac = _WifiDirectUtility::ConvertMacCharToString(pMacAddress);
 364     pDeviceInfoImpl->SetMacAddress(mac);
 365     r = GetLastResult();
 366     free(pMacAddress);
 367     SysTryReturn(NID_NET_WIFI, r == E_SUCCESS, null, E_SYSTEM, "[%s] The MAC address is invalid.", GetErrorMessage(r));
 368
 369     // IP address
 370     if (pDeviceInfoImpl->GetGroupMemberType() != WIFI_DIRECT_GROUP_MEMBER_TYPE_NONE)
 371     {
 372         char* pIp = null;
 373         err = wifi_direct_get_ip_address(&pIp);
 374         _WifiDirectConvertErrorResult(err != WIFI_DIRECT_ERROR_NONE, r, E_SYSTEM);
 375         _WifiDirectConvertErrorResult(err == WIFI_DIRECT_ERROR_OUT_OF_MEMORY, r, E_OUT_OF_MEMORY);
 376         SysTryReturn(NID_NET_WIFI, pIp != null && r == E_SUCCESS, null, r, "[%s] Propagating.", GetErrorMessage(r));
 377
 378         r = pDeviceInfoImpl->SetIpAddress(String(pIp));
 379         SysTryReturn(NID_NET_WIFI, r == E_SUCCESS, null, r, "[%s] Propagating.", GetErrorMessage(r));
 380         free(pIp);
 381     }
 382
 383     // supported WPS configuration mode
 384     if (status != WIFI_DIRECT_STATE_DEACTIVATED
 385                 && status != WIFI_DIRECT_STATE_DEACTIVATING
 386                 && status != WIFI_DIRECT_STATE_ACTIVATING)
 387     {
 388         ArrayListT<WifiWpsConfigurationMode> wpsModeList;
 389         r = wpsModeList.Construct();
 390         SysTryReturn(NID_NET_WIFI, r == E_SUCCESS, null, E_SYSTEM, "[%s] Construction of ArrayListT has failed.", GetErrorMessage(r));
 391
 392         err = wifi_direct_foreach_supported_wps_types(OnWifiDirectSupportedWpsMode, &wpsModeList);
 393         _WifiDirectConvertErrorResult(err != WIFI_DIRECT_ERROR_NONE, r, E_SYSTEM);
 394         SysTryReturn(NID_NET_WIFI, r == E_SUCCESS, null, r, "[%s] Propagating.", GetErrorMessage(r));
 395
 396         pDeviceInfoImpl->SetSupportedWpsConfigurationMode(wpsModeList);
 397         r = GetLastResult();
 398         SysTryReturn(NID_NET_WIFI, r == E_SUCCESS, null, E_SYSTEM, "[%s] Setting of wps configuration mode has failed.", GetErrorMessage(r));
 399
 400         wpsModeList.RemoveAll();
 401     }
 402
 403     return pDeviceInfo.release();
 404 }
 405
 406 WifiWpsConfigurationMode
 407 _WifiDirectSystemAdapter::GetWpsConfigurationModePreference(void) const
 408 {
 409     result r = E_SYSTEM;
 410     int err = WIFI_DIRECT_ERROR_NONE;
 411
 412     wifi_direct_wps_type_e wpsType;
 413     WifiWpsConfigurationMode wpsMode = WIFI_WPS_CONFIG_MODE_NONE;
 414
 415     err = wifi_direct_get_wps_type(&wpsType);
 416     _WifiDirectConvertErrorResult(err == WIFI_DIRECT_ERROR_NONE, r, E_SUCCESS);
 417     SysTryReturn(NID_NET_WIFI, r == E_SUCCESS, WIFI_WPS_CONFIG_MODE_NONE, r, "[%s] Propagating.", GetErrorMessage(r));
 418
 419     switch(wpsType)
 420     {
 421     case WIFI_DIRECT_WPS_TYPE_PBC:
 422         wpsMode = WIFI_WPS_CONFIG_MODE_PBC;
 423         break;
 424     case WIFI_DIRECT_WPS_TYPE_PIN_DISPLAY:
 425         wpsMode = WIFI_WPS_CONFIG_MODE_PIN_DISPLAY;
 426         break;
 427     case WIFI_DIRECT_WPS_TYPE_PIN_KEYPAD:
 428         wpsMode = WIFI_WPS_CONFIG_MODE_PIN_KEYPAD;
 429         break;
 430     default:
 431         SysLog(NID_NET_WIFI, "The WPS type is unknown.");
 432         break;
 433     }
 434
 435     return wpsMode;
 436 }
 437
 438 result
 439 _WifiDirectSystemAdapter::SetLocalDeviceName(const String &name)
 440 {
 441     SysTryReturnResult(NID_NET_WIFI, __pWifiServiceProxy != null, E_SYSTEM, "IPC instance has not been constructed yet.");
 442
 443     result r = __pWifiServiceProxy->SetWifiDirectLocalDeviceName(name);
 444     SysTryReturnResult(NID_NET_WIFI, r == E_SUCCESS, r, "Setting the Wi-Fi Direct local device name through OSP Connectivity daemon has failed.", GetErrorMessage(r));
 445
 446     return r;
 447 }
 448
 449 result
 450 _WifiDirectSystemAdapter::SetWpsConfigurationModePreference(WifiWpsConfigurationMode mode)
 451 {
 452     result r = E_SYSTEM;
 453     int err = WIFI_DIRECT_ERROR_NONE;
 454
 455     wifi_direct_wps_type_e wpsType = WIFI_DIRECT_WPS_TYPE_NONE;
 456
 457     switch(mode)
 458     {
 459     case WIFI_WPS_CONFIG_MODE_PBC:
 460         wpsType = WIFI_DIRECT_WPS_TYPE_PBC;
 461         break;
 462     case WIFI_WPS_CONFIG_MODE_PIN_DISPLAY:
 463         wpsType = WIFI_DIRECT_WPS_TYPE_PIN_DISPLAY;
 464         break;
 465     case WIFI_WPS_CONFIG_MODE_PIN_KEYPAD:
 466         wpsType = WIFI_DIRECT_WPS_TYPE_PIN_KEYPAD;
 467         break;
 468     default:
 469         SysLog(NID_NET_WIFI, "The WPS type is unknown.");
 470         return E_SYSTEM;
 471     }
 472
 473     err = wifi_direct_set_wps_type(wpsType);
 474     _WifiDirectConvertErrorResult(err == WIFI_DIRECT_ERROR_NONE, r, E_SUCCESS);
 475     SysTryReturn(NID_NET_WIFI, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
 476
 477     return r;
 478 }
 479
 480 result
 481 _WifiDirectSystemAdapter::CreateGroup(const WifiDirectGroupInfo *pWifiDirectGroupInfo,
 482                                         const WifiDirectDeviceInfo *pWifiDirectRemoteDeviceInfo)
 483 {
 484     result r = E_SUCCESS;
 485     int err = WIFI_DIRECT_ERROR_NONE;
 486
 487     SysTryReturnResult(NID_NET_WIFI, !(pWifiDirectGroupInfo != null
 488                                    && pWifiDirectGroupInfo->GetAutonomousGroupOwnerMode()
 489                                    && pWifiDirectRemoteDeviceInfo), E_INVALID_OPERATION,
 490                                     "The operation don't allow to create an autonomous group with a specified remote device.");
 491     __remoteMacAddress.Clear();
 492     __remoteDeviceName.Clear();
 493
 494     // autonomous group owner mode
 495     if (pWifiDirectGroupInfo != null
 496         && pWifiDirectGroupInfo->GetAutonomousGroupOwnerMode())
 497     {
 498         r = SetGroupSettingInfo(*pWifiDirectGroupInfo);
 499         SysTryReturnResult(NID_NET_WIFI, r == E_SUCCESS, r, "Propagating.");
 500
 501         err = wifi_direct_create_group();
 502         _WifiDirectConvertErrorResult(err != WIFI_DIRECT_ERROR_NONE, r, E_SYSTEM);
 503         SysTryReturn(NID_NET_WIFI, r == E_SUCCESS, r, r, "Propagating.", GetErrorMessage(r));
 504
 505         __currentState = WIFI_DIRECT_SYSTEM_AUTONOMOUS_GROUP_CREATING;
 506     }
 507     else
 508     {
 509         if (pWifiDirectGroupInfo != null)
 510         {
 511                 r = SetGroupSettingInfo(*pWifiDirectGroupInfo);
 512                 SysTryReturnResult(NID_NET_WIFI, r == E_SUCCESS, r, "Propagating.");
 513         }
 514
 515         if (pWifiDirectRemoteDeviceInfo != null)
 516         {
 517             unique_ptr<char []> pMacAddress(_WifiDirectUtility::ConvertMacStringToCharN(pWifiDirectRemoteDeviceInfo->GetMacAddress()));
 518             SysTryReturnResult(NID_NET_WIFI, pMacAddress != null, E_OUT_OF_MEMORY, "Memory allocation failed.");
 519
 520             err = wifi_direct_connect(pMacAddress.get());
 521             _WifiDirectConvertErrorResult(err != WIFI_DIRECT_ERROR_NONE, r, E_SYSTEM);
 522
 523             if (IsFailed(r))
 524             {
 525                 SysLog(NID_NET_WIFI, "[%s] Propagating.", GetErrorMessage(r));
 526                 result ret = StartListenMode();
 527                 SysLogException(NID_NET_WIFI, ret, "[%s] Propagating.", GetErrorMessage(ret));
 528                 return r;
 529             }
 530         }
 531         else
 532         {
 533             if (IsDiscoverable())
 534             {
 535                 r = StopListenModeToScan();
 536                 SysTryReturnResult(NID_NET_WIFI, r == E_SUCCESS, E_SYSTEM, "A system error occurs.");
 537             }
 538             else
 539             {
 540                 r = StartDiscovery();
 541                 SysLogException(NID_NET_WIFI, r, "[%s] Propagating.", GetErrorMessage(r));
 542
 543                 if (IsFailed(r))
 544                 {
 545                     r = StartListenMode();
 546                     SysLogException(NID_NET_WIFI, r, "[%s] Propagating.", GetErrorMessage(r));
 547                     return E_SYSTEM;
 548                 }
 549             }
 550         }
 551         __currentState = WIFI_DIRECT_SYSTEM_GROUP_CREATING;
 552     }
 553
 554     return r;
 555 }
 556
 557 result
 558 _WifiDirectSystemAdapter::CancelGroupCreation(void)
 559 {
 560     result r = E_SYSTEM;
 561     int err = WIFI_DIRECT_ERROR_NONE;
 562
 563     if (__currentState == WIFI_DIRECT_SYSTEM_GROUP_CREATING || __currentState == WIFI_DIRECT_SYSTEM_AUTONOMOUS_GROUP_CREATING)
 564     {
 565         switch(__currentScanState)
 566         {
 567         case WIFI_DIRECT_SYSTEM_SCAN_LISTEN_CANCELING_TO_SCAN:
 568         case WIFI_DIRECT_SYSTEM_SCAN_SCANNING:
 569             __currentState = WIFI_DIRECT_SYSTEM_CONNECT_CANCELLING;
 570             r = CancelDiscovery();
 571             break;
 572         default:
 573             err = wifi_direct_disconnect_all();
 574             _WifiDirectConvertErrorResult(err == WIFI_DIRECT_ERROR_NONE, r, E_SUCCESS);
 575
 576             if (IsFailed(r))
 577             {
 578                 SysLog(NID_NET_WIFI, "[%s] Propagating.", GetErrorMessage(r));
 579
 580                 result ret = StartListenMode();
 581                 SysLogException(NID_NET_WIFI, ret, "[%s] Propagating.", GetErrorMessage(ret));
 582             }
 583             else
 584             {
 585                 __currentState = WIFI_DIRECT_SYSTEM_GROUP_CANCELING;
 586             }
 587         }
 588     }
 589     else
 590     {
 591         r = E_INVALID_OPERATION;
 592     }
 593
 594     return r;
 595 }
 596
 597 result
 598 _WifiDirectSystemAdapter::Scan(void)
 599 {
 600     result r = E_SUCCESS;
 601
 602     switch(__currentScanState)
 603     {
 604     case WIFI_DIRECT_SYSTEM_SCAN_IDLE:
 605         r = StartDiscovery();
 606         SysTryReturn(NID_NET_WIFI, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
 607         break;
 608     case WIFI_DIRECT_SYSTEM_SCAN_LISTEN:
 609         r = StopListenModeToScan();
 610         SysTryReturn(NID_NET_WIFI, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
 611         break;
 612     case WIFI_DIRECT_SYSTEM_SCAN_LISTEN_CANCELING_TO_SCAN:
 613     case WIFI_DIRECT_SYSTEM_SCAN_SCANNING:
 614         r = E_IN_PROGRESS;
 615         break;
 616     case WIFI_DIRECT_SYSTEM_SCAN_CANCELLING:
 617         r = E_INVALID_OPERATION;
 618         break;
 619     }
 620
 621     return r;
 622 }
 623
 624 result
 625 _WifiDirectSystemAdapter::CancelScan(void)
 626 {
 627     result r = E_SUCCESS;
 628
 629     switch(__currentScanState)
 630     {
 631
 632     case WIFI_DIRECT_SYSTEM_SCAN_LISTEN_CANCELING_TO_SCAN:
 633         __currentScanState = WIFI_DIRECT_SYSTEM_SCAN_CANCELLING;
 634         //fall through
 635     case WIFI_DIRECT_SYSTEM_SCAN_CANCELLING:
 636         r = E_SUCCESS;
 637         break;
 638     case WIFI_DIRECT_SYSTEM_SCAN_SCANNING:
 639         r = CancelDiscovery();
 640         break;
 641     default:
 642         r = E_INVALID_OPERATION;
 643         break;
 644     }
 645
 646    return r;
 647 }
 648
 649 result
 650 _WifiDirectSystemAdapter::Associate(const WifiDirectDeviceInfo &wifiDirectGroupOwnerDeviceInfo)
 651 {
 652     result r = E_SYSTEM;
 653     int err = WIFI_DIRECT_ERROR_NONE;
 654
 655     unique_ptr<char[]> pMacAddress(_WifiDirectUtility::ConvertMacStringToCharN(wifiDirectGroupOwnerDeviceInfo.GetMacAddress()));
 656     SysTryReturnResult(NID_NET_WIFI, pMacAddress != null, E_OUT_OF_MEMORY, "Failed to convert MacAddress");
 657
 658     err = wifi_direct_connect(pMacAddress.get());
 659     _WifiDirectConvertErrorResult(err == WIFI_DIRECT_ERROR_NONE, r, E_SUCCESS);
 660     SysTryReturn(NID_NET_WIFI, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
 661
 662     __currentState = WIFI_DIRECT_SYSTEM_ASSOCIATING;
 663
 664     return r;
 665 }
 666
 667 bool
 668 _WifiDirectSystemAdapter::IsDiscoverable(void) const
 669 {
 670     bool isDiscoverable = false;
 671     int err = WIFI_DIRECT_ERROR_NONE;
 672
 673     err = wifi_direct_is_discoverable(&isDiscoverable);
 674
 675     if (err != WIFI_DIRECT_ERROR_NONE)
 676     {
 677         SysLog(NID_NET_WIFI, "Getting discoverable state has failed.");
 678         return false;
 679     }
 680
 681     return isDiscoverable;
 682 }
 683
 684 bool
 685 _WifiDirectSystemAdapter::IsActivated(void) const
 686 {
 687     if (__currentState != WIFI_DIRECT_SYSTEM_DEACTIVATED &&
 688         __currentState != WIFI_DIRECT_SYSTEM_ACTIVATING )
 689     {
 690         return true;
 691     }
 692
 693     return false;
 694 }
 695
 696 result
 697 _WifiDirectSystemAdapter::Connect(const WifiDirectDeviceInfo& peerDeviceInfo)
 698 {
 699     result r = E_SYSTEM;
 700
 701     switch(__currentState)
 702     {
 703     case WIFI_DIRECT_SYSTEM_AUTONOMOUS_GROUP_CREATING:
 704     case WIFI_DIRECT_SYSTEM_GROUP_CREATING:
 705     case WIFI_DIRECT_SYSTEM_CONNECTING:
 706         r = E_IN_PROGRESS;
 707         break;
 708     case WIFI_DIRECT_SYSTEM_ACTIVATED:
 709     case WIFI_DIRECT_SYSTEM_OWNER:
 710     {
 711         unique_ptr<char[]> pMacAddress(_WifiDirectUtility::ConvertMacStringToCharN(peerDeviceInfo.GetMacAddress()));
 712         SysTryReturnResult(NID_NET_WIFI, pMacAddress != null, E_OUT_OF_MEMORY, "Memory allocation failed.");
 713
 714         int err = wifi_direct_connect(pMacAddress.get());
 715         _WifiDirectConvertErrorResult(err == WIFI_DIRECT_ERROR_NONE, r, E_SUCCESS);
 716
 717         if (r == E_SUCCESS)
 718         {
 719             __currentState = WIFI_DIRECT_SYSTEM_CONNECTING;
 720         }
 721     }
 722         break;
 723     default:
 724         r = E_INVALID_OPERATION;
 725         break;
 726     }
 727
 728     if (IsFailed(r))
 729     {
 730         SysLog(NID_NET_WIFI, "[%s] Propagating.", GetErrorMessage(r));
 731         result ret = StartListenMode();
 732         SysLogException(NID_NET_WIFI, ret, "[%s] Propagating.", GetErrorMessage(ret));
 733     }
 734
 735     return r;
 736 }
 737
 738 result
 739 _WifiDirectSystemAdapter::CancelConnect(void)
 740 {
 741     result r = E_SYSTEM;
 742     int err = WIFI_DIRECT_ERROR_NONE;
 743
 744     switch(__currentState)
 745     {
 746     case WIFI_DIRECT_SYSTEM_GROUP_CREATING:
 747     case WIFI_DIRECT_SYSTEM_CONNECTING:
 748         err = wifi_direct_disconnect_all();
 749         _WifiDirectConvertErrorResult(err == WIFI_DIRECT_ERROR_NONE, r, E_SUCCESS);
 750
 751         if (r == E_SUCCESS)
 752         {
 753                 __currentState = WIFI_DIRECT_SYSTEM_CONNECT_CANCELLING;
 754         }
 755         else
 756         {
 757                 SysLog(NID_NET_WIFI, "[%s] Propagating.", GetErrorMessage(r));
 758                 result ret = StartListenMode();
 759                 SysLogException(NID_NET_WIFI, ret, "[%s] Propagating.", GetErrorMessage(ret));
 760         }
 761         break;
 762     case WIFI_DIRECT_SYSTEM_GROUP_CANCELING:
 763     case WIFI_DIRECT_SYSTEM_CONNECT_CANCELLING:
 764         r = E_IN_PROGRESS;
 765         break;
 766     default:
 767         r = E_INVALID_OPERATION;
 768         break;
 769     }
 770
 771     SysLog(NID_NET_WIFI, "[%s] The current state is %ls", GetErrorMessage(r), GetStringOfAllCurrentState().GetPointer());
 772     return r;
 773 }
 774
 775 result
 776 _WifiDirectSystemAdapter::CreateAutonomousGroup(void)
 777 {
 778     result r = E_SYSTEM;
 779
 780     if (__currentState == WIFI_DIRECT_SYSTEM_ACTIVATED)
 781     {
 782         int err = wifi_direct_create_group();
 783         _WifiDirectConvertErrorResult(err == WIFI_DIRECT_ERROR_NONE, r, E_SUCCESS);
 784
 785         if (r == E_SUCCESS)
 786         {
 787                 __currentState = WIFI_DIRECT_SYSTEM_AUTONOMOUS_GROUP_CREATING;
 788         }
 789         else
 790         {
 791                 SysLog(NID_NET_WIFI, "[%s] Propagating.", GetErrorMessage(r));
 792             result ret = StartListenMode();
 793             SysLogException(NID_NET_WIFI, ret, "[%s] Propagating.", GetErrorMessage(ret));
 794         }
 795     }
 796     else
 797     {
 798         r = E_INVALID_OPERATION;
 799         SysLog(NID_NET_WIFI, "[%s] The current state is %ls.", GetErrorMessage(r), GetStringOfAllCurrentState().GetPointer());
 800     }
 801
 802     return r;
 803 }
 804
 805 result
 806 _WifiDirectSystemAdapter::SetGroupSettingInfo(const WifiDirectGroupInfo& groupSettingInfo)
 807 {
 808     result r = E_SUCCESS;
 809     int err = WIFI_DIRECT_ERROR_NONE;
 810
 811     // Sets group owner intent
 812     err = wifi_direct_set_group_owner_intent(groupSettingInfo.GetGroupOwnerIntent());
 813     _WifiDirectConvertErrorResult(err != WIFI_DIRECT_ERROR_NONE, r, E_INVALID_OPERATION);
 814     SysTryReturn(NID_NET_WIFI, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
 815
 816     // Sets max clients
 817     err = wifi_direct_set_max_clients(groupSettingInfo.GetMaxNumberOfClients());
 818     _WifiDirectConvertErrorResult(err != WIFI_DIRECT_ERROR_NONE, r, E_INVALID_OPERATION);
 819     SysTryReturn(NID_NET_WIFI, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
 820
 821     return r;
 822 }
 823
 824 result
 825 _WifiDirectSystemAdapter::LeaveGroup(void)
 826 {
 827     result r = E_SYSTEM;
 828     int err = WIFI_DIRECT_ERROR_NONE;
 829
 830     if (__currentState == WIFI_DIRECT_SYSTEM_OWNER)
 831     {
 832         err = wifi_direct_destroy_group();
 833         _WifiDirectConvertErrorResult(err == WIFI_DIRECT_ERROR_NONE, r, E_SUCCESS);
 834         SysTryReturn(NID_NET_WIFI, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
 835
 836         __currentState = WIFI_DIRECT_SYSTEM_LEAVING;
 837     }
 838     else if ( __currentState == WIFI_DIRECT_SYSTEM_CLIENT)
 839     {
 840         err = wifi_direct_disconnect_all();
 841         _WifiDirectConvertErrorResult(err == WIFI_DIRECT_ERROR_NONE, r, E_SUCCESS);
 842         SysTryReturn(NID_NET_WIFI, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
 843
 844         __currentState = WIFI_DIRECT_SYSTEM_LEAVING;
 845     }
 846     else if (__currentState == WIFI_DIRECT_SYSTEM_LEAVING)
 847     {
 848         r = E_IN_PROGRESS;
 849     }
 850     else
 851     {
 852         r = E_INVALID_OPERATION;
 853     }
 854
 855     return r;
 856 }
 857
 858 WifiDirectDeviceInfo*
 859 _WifiDirectSystemAdapter::GetGroupOwnerInfoN(void) const
 860 {
 861     ClearLastResult();
 862     result r = E_SYSTEM;
 863     WifiDirectDeviceInfo* pGroupOwnerInfo = null;
 864
 865     if (__currentState == WIFI_DIRECT_SYSTEM_OWNER)
 866     {
 867         pGroupOwnerInfo = GetLocalDeviceInfoN();
 868     }
 869     else if (__currentState == WIFI_DIRECT_SYSTEM_CLIENT)
 870     {
 871         pGroupOwnerInfo = GetConnectedPeerDeviceInfoN(WIFI_DIRECT_GROUP_MEMBER_TYPE_OWNER);
 872
 873         char* pSsid = null;
 874         int err = wifi_direct_get_ssid(&pSsid);
 875         _WifiDirectConvertErrorResult(err == WIFI_DIRECT_ERROR_NONE, r, E_SUCCESS);
 876
 877         if (pSsid == null)
 878         {
 879            SetLastResult(r);
 880            SysLog(NID_NET_WIFI, "The ssid is null");
 881         }
 882         else
 883         {
 884             _WifiDirectDeviceInfoImpl::SetSsidOfWifiDirectDeviceInfo(*pGroupOwnerInfo, String(pSsid));
 885             free(pSsid);
 886         }
 887     }
 888     else
 889     {
 890         SetLastResult(E_INVALID_OPERATION);
 891     }
 892
 893     return pGroupOwnerInfo;
 894 }
 895
 896 IList*
 897 _WifiDirectSystemAdapter::GetGroupClientInfoListN(void) const
 898 {
 899     ClearLastResult();
 900     result r = E_SYSTEM;
 901     LinkedList* pClientInfoList = null;
 902
 903     pClientInfoList = new (std::nothrow) LinkedList(SingleObjectDeleter);
 904     SysTryReturn(NID_NET_WIFI, pClientInfoList != null, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
 905
 906     if (__currentState == WIFI_DIRECT_SYSTEM_OWNER)
 907     {
 908         int err = wifi_direct_foreach_connected_peers(OnWifiDirectEachConnectedClient, pClientInfoList);
 909         _WifiDirectConvertErrorResult(err == WIFI_DIRECT_ERROR_NONE, r, E_SUCCESS);
 910         SysTryReturn(NID_NET_WIFI, r == E_SUCCESS, null, r, "[%s] Propagating.", GetErrorMessage(r));
 911     }
 912     else
 913     {
 914         SetLastResult(E_INVALID_OPERATION);
 915     }
 916
 917     return pClientInfoList;
 918 }
 919
 920 WifiRadioChannel
 921 _WifiDirectSystemAdapter::GetOperatingChannel(void) const
 922 {
 923     int channel = 0;
 924     int err = WIFI_DIRECT_ERROR_NONE;
 925
 926     err = wifi_direct_get_operating_channel(&channel);
 927
 928     if (err != WIFI_DIRECT_ERROR_NONE)
 929     {
 930         SysLog(NID_NET_WIFI, "Getting operating channel has failed.");
 931         return WIFI_RADIO_CHANNEL_UNKNOWN;
 932     }
 933
 934     WifiRadioChannel operatingChannel = _WifiDirectUtility::ConvertChannel(channel);
 935
 936     return operatingChannel;
 937 }
 938
 939 result
 940 _WifiDirectSystemAdapter::DestroyGroup(void)
 941 {
 942     result r = E_SYSTEM;
 943     int err = WIFI_DIRECT_ERROR_NONE;
 944
 945     if (__currentState == WIFI_DIRECT_SYSTEM_OWNER)
 946     {
 947         err = wifi_direct_destroy_group();
 948         _WifiDirectConvertErrorResult(err == WIFI_DIRECT_ERROR_NONE, r, E_SUCCESS);
 949         SysTryReturn(NID_NET_WIFI, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
 950
 951         __currentState = WIFI_DIRECT_SYSTEM_DESTROYING;
 952     }
 953     else if (__currentState == WIFI_DIRECT_SYSTEM_DESTROYING)
 954     {
 955         r = E_IN_PROGRESS;
 956     }
 957     else
 958     {
 959         r = E_INVALID_OPERATION;
 960     }
 961
 962     return r;
 963 }
 964
 965 result
 966 _WifiDirectSystemAdapter::Disconnect(const WifiDirectDeviceInfo& remoteDeviceInfo)
 967 {
 968     result r = E_SYSTEM;
 969
 970     switch(__currentState)
 971     {
 972     case WIFI_DIRECT_SYSTEM_DISCONNECTING:
 973        r = E_IN_PROGRESS;
 974        break;
 975     case WIFI_DIRECT_SYSTEM_OWNER:
 976     case WIFI_DIRECT_SYSTEM_CLIENT:
 977     {
 978        unique_ptr<char[]> pMacAddress(_WifiDirectUtility::ConvertMacStringToCharN(remoteDeviceInfo.GetMacAddress()));
 979        SysTryReturnResult(NID_NET_WIFI, pMacAddress != null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Failed to convert mac address.");
 980        int err = WIFI_DIRECT_ERROR_NONE;
 981
 982        err = wifi_direct_disconnect(pMacAddress.get());
 983        _WifiDirectConvertErrorResult(err == WIFI_DIRECT_ERROR_NONE, r, E_SUCCESS);
 984        SysTryReturnResult(NID_NET_WIFI, r == E_SUCCESS, r, "Propagating.");
 985
 986        if (__currentState == WIFI_DIRECT_SYSTEM_OWNER)
 987        {
 988            WifiDirectDeviceInfo* pDeviceInfo = GetPeerInfo(remoteDeviceInfo.GetMacAddress());
 989            SysTryLog(NID_NET_WIFI, pDeviceInfo != null, "The client info was not found.");
 990
 991            if (pDeviceInfo != null)
 992            {
 993                _WifiDirectDeviceInfoImpl::GetInstance(*pDeviceInfo)->SetDisconnect(true);
 994            }
 995        }
 996
 997        __currentState = WIFI_DIRECT_SYSTEM_DISCONNECTING;
 998
 999     }
1000        break;
1001     default:
1002        r = E_INVALID_OPERATION;
1003        break;
1004     }
1005
1006     return r;
1007 }
1008
1009 IList*
1010 _WifiDirectSystemAdapter::GetAllGroupMemberInfoImplListN(void)
1011 {
1012     int err = WIFI_DIRECT_ERROR_NONE;
1013     result r = E_SUCCESS;
1014
1015     unique_ptr<ArrayList, AllElementsDeleter> pDeviceInfoList(new (std::nothrow) ArrayList());
1016     SysTryReturn(NID_NET_WIFI, pDeviceInfoList, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
1017
1018     r = pDeviceInfoList->Construct();
1019     r = TransExceptionsExclusive(r, E_SYSTEM, E_OUT_OF_MEMORY);
1020     SysTryReturn(NID_NET_WIFI, r == E_SUCCESS, null, r, "[%s] Constructing ArrayList has failed.", GetErrorMessage(r));
1021
1022     if(__currentState == WIFI_DIRECT_SYSTEM_OWNER)
1023     {
1024         WifiDirectDeviceInfo* pDeviceInfo = GetLocalDeviceInfoN();
1025         r = GetLastResult();
1026         SysTryReturn(NID_NET_WIFI, pDeviceInfo != null, null, r, "[%s] Getting LocalDeviceInfo has failed.", GetErrorMessage(r));
1027
1028         r = pDeviceInfoList->Add(*pDeviceInfo);
1029         SysTryReturn(NID_NET_WIFI, r == E_SUCCESS, null, E_SYSTEM, "[%s] Adding object in ArrayList has failed.", GetErrorMessage(r));
1030     }
1031
1032     err = wifi_direct_foreach_connected_peers(OnWifiDirectEachConnectedClient, pDeviceInfoList.get());
1033     _WifiDirectConvertErrorResult(err != WIFI_DIRECT_ERROR_NONE, r, E_SYSTEM);
1034     SysTryReturn(NID_NET_WIFI, r == E_SUCCESS, null, r, "[%s] Propagating.", GetErrorMessage(r));
1035
1036     return pDeviceInfoList.release();
1037 }
1038
1039 /////////////////////////////////////////////////////
1040 // Client
1041
1042 result
1043 _WifiDirectSystemAdapter::Disassociate(void)
1044 {
1045     result r = E_SYSTEM;
1046
1047     if(__currentState == WIFI_DIRECT_SYSTEM_CLIENT)
1048     {
1049         int err = wifi_direct_disconnect_all();
1050         _WifiDirectConvertErrorResult(err == WIFI_DIRECT_ERROR_NONE, r, E_SUCCESS);
1051         SysTryReturn(NID_NET_WIFI, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
1052
1053         __currentState = WIFI_DIRECT_SYSTEM_DISCONNECTING;
1054     }
1055     else
1056     {
1057         r = E_INVALID_OPERATION;
1058     }
1059
1060     return E_SUCCESS;
1061 }
1062
1063
1064 ///////////////////////////////////////////////////////////////
1065 // Internal
1066
1067 WifiDirectGroupMemberType
1068 _WifiDirectSystemAdapter::GetCurrentMemberType(void) const
1069 {
1070     WifiDirectGroupMemberType memberType = WIFI_DIRECT_GROUP_MEMBER_TYPE_NONE;
1071
1072     switch(__currentState)
1073     {
1074     case WIFI_DIRECT_SYSTEM_OWNER:
1075         memberType = WIFI_DIRECT_GROUP_MEMBER_TYPE_OWNER;
1076         break;
1077     case WIFI_DIRECT_SYSTEM_CLIENT:
1078         memberType = WIFI_DIRECT_GROUP_MEMBER_TYPE_CLIENT;
1079         break;
1080     case WIFI_DIRECT_SYSTEM_DISCONNECTING:
1081     case WIFI_DIRECT_SYSTEM_DESTROYING:
1082     {
1083         bool isGroupOwner = false;
1084         int err = wifi_direct_is_group_owner(&isGroupOwner);
1085         SysLog(NID_NET_WIFI, "[0x%x] Return value of wifi_direct_is_group_owner()", err);
1086
1087         if (isGroupOwner == true)
1088         {
1089             memberType = WIFI_DIRECT_GROUP_MEMBER_TYPE_OWNER;
1090         }
1091         else
1092         {
1093             memberType = WIFI_DIRECT_GROUP_MEMBER_TYPE_CLIENT;
1094         }
1095     }
1096         break;
1097     default:
1098         memberType = WIFI_DIRECT_GROUP_MEMBER_TYPE_NONE;
1099         break;
1100     }
1101
1102     return memberType;
1103 }
1104
1105 bool
1106 _WifiDirectSystemAdapter::Construct(void)
1107 {
1108     result r = E_SUCCESS;
1109     int err = WIFI_DIRECT_ERROR_NONE;
1110
1111     unique_ptr<_WifiDirectEvent,_WifiDirectEventDeleter> pWifiDirectEvent(new (std::nothrow) _WifiDirectEvent());
1112     SysTryReturn(NID_NET_WIFI, pWifiDirectEvent != null, false, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
1113
1114     r = pWifiDirectEvent->Construct();
1115     SysTryReturn(NID_NET_WIFI, r == E_SUCCESS, false, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
1116
1117     __pWifiServiceProxy = _WifiIpcProxy::GetInstance();
1118     if (__pWifiServiceProxy != null)
1119     {
1120         r = __pWifiServiceProxy->InitializeWifiDirect();
1121         SysLog(NID_NET_WIFI, "Initializing WifiDirect service of osp-connectivity-service %s.",
1122                         (r == E_SUCCESS) ? "is successful" : "fails");
1123     }
1124     else
1125     {
1126         SysLog(NID_NET_WIFI, "Creating an IPC instance to connect with the Connectivity service daemon has failed.");
1127     }
1128
1129     err = wifi_direct_initialize();
1130     _WifiDirectConvertErrorResult(err != WIFI_DIRECT_ERROR_NONE, r, E_SYSTEM);
1131     SysTryReturn(NID_NET_WIFI, r == E_SUCCESS, false, r, "[%s] Propagating.", GetErrorMessage(r));
1132
1133     err = wifi_direct_set_device_state_changed_cb(OnWifiDirectPowerChanged, null);
1134     _WifiDirectConvertErrorResult(err != WIFI_DIRECT_ERROR_NONE, r, E_SYSTEM);
1135     SysTryCatch(NID_NET_WIFI, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
1136
1137     err = wifi_direct_set_discovery_state_changed_cb(OnWifiDirectScanCompleted, null);
1138     _WifiDirectConvertErrorResult(err != WIFI_DIRECT_ERROR_NONE, r, E_SYSTEM);
1139     SysTryCatch(NID_NET_WIFI, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
1140
1141     err = wifi_direct_set_connection_state_changed_cb(OnWifiDirectConnectionChanged, null);
1142     _WifiDirectConvertErrorResult(err != WIFI_DIRECT_ERROR_NONE, r, E_SYSTEM);
1143     SysTryCatch(NID_NET_WIFI, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
1144
1145     err = wifi_direct_set_client_ip_address_assigned_cb(OnWifiDirectClientIpAssigned, null);
1146     _WifiDirectConvertErrorResult(err != WIFI_DIRECT_ERROR_NONE, r, E_SYSTEM);
1147     SysTryCatch(NID_NET_WIFI, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
1148
1149     r = InitializeCurrentState();
1150     SysTryCatch(NID_NET_WIFI, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
1151
1152     r = __connectedPeerList.Construct();
1153     SysTryCatch(NID_NET_WIFI, r == E_SUCCESS, , E_SYSTEM, "[%s] Construction of ArrayList has failed.", GetErrorMessage(r));
1154
1155     __pWifiDirectEvent = move(pWifiDirectEvent);
1156
1157     return true;
1158
1159 CATCH:
1160     err = wifi_direct_deinitialize();
1161     SysLog(NID_NET_WIFI, "[0x%x] Return value of wifi_direct_deinitialize()", err);
1162
1163     return false;
1164 }
1165 void
1166 _WifiDirectSystemAdapter::AddListener(const _WifiDirectDeviceImpl& listner)
1167 {
1168     __pWifiDirectEvent->AddListener(listner, true);
1169 }
1170 void
1171 _WifiDirectSystemAdapter::RemoveListener(const _WifiDirectDeviceImpl& listner)
1172 {
1173     __pWifiDirectEvent->RemoveListener(listner);
1174 }
1175
1176 result
1177 _WifiDirectSystemAdapter::AddPeerInfo(WifiDirectDeviceInfo* pPeerInfo)
1178 {
1179     WifiDirectDeviceInfo* pPeerInfoTemp = new WifiDirectDeviceInfo(*pPeerInfo);
1180     return __connectedPeerList.Add(*pPeerInfoTemp);
1181 }
1182 result
1183 _WifiDirectSystemAdapter::RemovePeerInfo(WifiDirectDeviceInfo* pPeerInfo)
1184 {
1185     return __connectedPeerList.Remove(*pPeerInfo, true);
1186 }
1187 WifiDirectDeviceInfo*
1188 _WifiDirectSystemAdapter::GetPeerInfo(const String& macAddress)
1189 {
1190     WifiDirectDeviceInfo* pDeviceInfo = null;
1191     for(int i = 0; i < __connectedPeerList.GetCount(); i++)
1192     {
1193         pDeviceInfo = dynamic_cast<WifiDirectDeviceInfo*>(__connectedPeerList.GetAt(i));
1194
1195         if (pDeviceInfo != null && pDeviceInfo->GetMacAddress() == macAddress)
1196         {
1197             return pDeviceInfo;
1198         }
1199     }
1200     return null;
1201 }
1202
1203 _WifiDirectSystemAdapter::_WifiDirectSystemAdapter(void)
1204     : __remoteMacAddress()
1205     , __remoteDeviceName()
1206     , __pScanResult(null)
1207     , __currentState(WIFI_DIRECT_SYSTEM_DEACTIVATED)
1208     , __currentScanState(WIFI_DIRECT_SYSTEM_SCAN_IDLE)
1209     , __connectedPeerList(SingleObjectDeleter)
1210     , __discoveredPeerList(SingleObjectDeleter)
1211
1212     , __pWifiServiceProxy(null)
1213 {
1214
1215 }
1216
1217 _WifiDirectSystemAdapter::~_WifiDirectSystemAdapter(void)
1218 {
1219     int err = WIFI_DIRECT_ERROR_NONE;
1220
1221     err = wifi_direct_deinitialize();
1222     SysLog(NID_NET_WIFI, "[0x%x] Return value of wifi_direct_deinitialize()", err);
1223 }
1224
1225 // Callback function
1226 void
1227 _WifiDirectSystemAdapter::OnWifiDirectPowerChanged(int errorCode, wifi_direct_device_state_e deviceState, void* pUserData)
1228 {
1229     SysLog(NID_NET_WIFI, "Enter, [deviceState:0x%x] [ErrorCode:0x%x]", deviceState, errorCode);
1230     SysLog(NID_NET_WIFI, "%ls", __pWifiDirectSystemAdapter->GetStringOfAllCurrentState().GetPointer());
1231
1232     int err = WIFI_DIRECT_ERROR_NONE;
1233     result r = E_SYSTEM;
1234     _WifiDirectEventArg* pEventArg = null;
1235     _WifiDirectConvertErrorResult(errorCode == WIFI_DIRECT_ERROR_NONE, r, E_SUCCESS);
1236
1237     switch(deviceState)
1238     {
1239     case WIFI_DIRECT_DEVICE_STATE_ACTIVATED:
1240         SysLog(NID_NET_WIFI, "deviceState : WIFI_DIRECT_DEVICE_STATE_ACTIVATED");
1241         //Don't fire event here, we will fire event after Listen Mode has started
1242         //pEventArg = new (std::nothrow)_WifiDirectEventArg(WIFI_DIRECT_DEVICE_EVENT_ACTIVATED, DEFAULT_DEVICE_ID, r);
1243         //SysTryReturnVoidResult(NID_NET_WIFI, pEventArg != null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
1244
1245         if (r == E_SUCCESS)
1246         {
1247             if (__pWifiDirectSystemAdapter->__currentState == WIFI_DIRECT_SYSTEM_ACTIVATING)
1248             {
1249                 result res = __pWifiDirectSystemAdapter->StartListenMode();
1250
1251                 if (IsFailed(res))
1252                 {
1253                         SysLogException(NID_NET_WIFI, res, "[%s] Propagating.", GetErrorMessage(res));
1254
1255                     err = wifi_direct_deactivate();
1256                     r = _WifiDirectUtility::ConvertErrorCode(err);
1257                     SysLog(NID_NET_WIFI, "[%s] Propagating.", GetErrorMessage(r));
1258
1259                     return;
1260                }
1261            }
1262            else if(__pWifiDirectSystemAdapter->__currentState == WIFI_DIRECT_SYSTEM_DEACTIVATED)
1263            {
1264                __pWifiDirectSystemAdapter->__currentState = WIFI_DIRECT_SYSTEM_ACTIVATED;
1265                 pEventArg = new (std::nothrow)_WifiDirectEventArg(WIFI_DIRECT_DEVICE_EVENT_ACTIVATED, DEFAULT_DEVICE_ID, r);
1266                 SysTryReturnVoidResult(NID_NET_WIFI, pEventArg != null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
1267            }
1268         }
1269         else
1270         {
1271             __pWifiDirectSystemAdapter->__currentState = WIFI_DIRECT_SYSTEM_DEACTIVATED;
1272         }
1273         break;
1274     case WIFI_DIRECT_DEVICE_STATE_DEACTIVATED:
1275         SysLog(NID_NET_WIFI, "deviceState : WIFI_DIRECT_DEVICE_STATE_DEACTIVATED");
1276         if (__pWifiDirectSystemAdapter->__currentState != WIFI_DIRECT_SYSTEM_ACTIVATING)
1277         {
1278             pEventArg = new (std::nothrow)_WifiDirectEventArg(WIFI_DIRECT_DEVICE_EVENT_DEACTIVATED, DEFAULT_DEVICE_ID, r);
1279             SysTryReturnVoidResult(NID_NET_WIFI, pEventArg != null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
1280
1281             if (r == E_SUCCESS)
1282             {
1283                __pWifiDirectSystemAdapter->__currentState = WIFI_DIRECT_SYSTEM_DEACTIVATED;
1284                __pWifiDirectSystemAdapter->__currentScanState = WIFI_DIRECT_SYSTEM_SCAN_IDLE;
1285             }
1286             else
1287             {
1288                SysLogException(NID_NET_WIFI, r, "[%s] Propagating.", GetErrorMessage(r));
1289
1290                result res = __pWifiDirectSystemAdapter->InitializeCurrentState();
1291                SysLogException(NID_NET_WIFI, res, "[%s] Propagating.", GetErrorMessage(res));
1292             }
1293         }
1294         else
1295         {
1296             if (r == E_SUCCESS)
1297             {
1298                __pWifiDirectSystemAdapter->__currentState = WIFI_DIRECT_SYSTEM_DEACTIVATED;
1299                __pWifiDirectSystemAdapter->__currentScanState = WIFI_DIRECT_SYSTEM_SCAN_IDLE;
1300                 pEventArg = new (std::nothrow)_WifiDirectEventArg(WIFI_DIRECT_DEVICE_EVENT_ACTIVATED, DEFAULT_DEVICE_ID, E_SYSTEM);
1301                 SysTryReturnVoidResult(NID_NET_WIFI, pEventArg != null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
1302             }
1303
1304         }
1305         break;
1306     }
1307
1308     if (pEventArg != null)
1309     {
1310         __pWifiDirectSystemAdapter->__pWifiDirectEvent->FireAsync(*pEventArg);
1311     }
1312 }
1313
1314 void
1315 _WifiDirectSystemAdapter::OnWifiDirectConnectionChanged(int errorCode, wifi_direct_connection_state_e connectionState,
1316         const char* pMacAddress, void* pUserData)
1317 {
1318     SysLog(NID_NET_WIFI, "Enter, [connectionState:0x%x] [ErrorCode:0x%x]", connectionState, errorCode);
1319     SysLog(NID_NET_WIFI, "%ls", __pWifiDirectSystemAdapter->GetStringOfAllCurrentState().GetPointer());
1320
1321     result r = E_SUCCESS;
1322     String peerMacAddress = _WifiDirectUtility::ConvertMacCharToString(pMacAddress);
1323
1324     bool isOwner = false;
1325     wifi_direct_is_group_owner(&isOwner);
1326
1327     switch(connectionState)
1328     {
1329     // OnWifiDirectGroupCreatedN() with autonomous group owner mode
1330     case WIFI_DIRECT_GROUP_CREATED:
1331         SysLog(NID_NET_WIFI, "connectionState : WIFI_DIRECT_GROUP_CREATED");
1332         if (errorCode == WIFI_DIRECT_ERROR_NONE)
1333         {
1334             (void)__pWifiDirectSystemAdapter->InitializeCurrentState();
1335             if (__pWifiDirectSystemAdapter->__currentState == WIFI_DIRECT_SYSTEM_OWNER)
1336             {
1337                 _WifiDirectConvertErrorResult(errorCode != WIFI_DIRECT_ERROR_NONE, r, E_SYSTEM);
1338                 _WifiDirectConvertErrorResult(errorCode == WIFI_DIRECT_ERROR_AUTH_FAILED, r, E_AUTHENTICATION);
1339                 _WifiDirectConvertErrorResult(errorCode == WIFI_DIRECT_ERROR_CONNECTION_FAILED, r, E_NOT_RESPONDING);
1340                 _WifiDirectConvertErrorResult(errorCode == WIFI_DIRECT_ERROR_CONNECTION_TIME_OUT, r, E_REMOTE_DEVICE_NOT_FOUND);
1341                 __pWifiDirectSystemAdapter->OnWifiDirectGroupCreated(L"", r);
1342
1343                 _WifiDirectConvertErrorResult(errorCode != WIFI_DIRECT_ERROR_NONE, r, E_SYSTEM);
1344                 __pWifiDirectSystemAdapter->OnWifiDirectAutonomousGroupCreated(r);
1345             }
1346         }
1347         break;
1348     case WIFI_DIRECT_CONNECTION_RSP:
1349        SysLog(NID_NET_WIFI, "connectionState : WIFI_DIRECT_CONNECTION_RSP");
1350        switch(__pWifiDirectSystemAdapter->__currentState)
1351        {
1352        case WIFI_DIRECT_SYSTEM_GROUP_CREATING:
1353        case WIFI_DIRECT_SYSTEM_CONNECTING:
1354            if (r == E_SUCCESS && isOwner == false)
1355            {
1356                    (void)__pWifiDirectSystemAdapter->InitializeCurrentState();
1357                _WifiDirectConvertErrorResult(errorCode != WIFI_DIRECT_ERROR_NONE, r, E_SYSTEM);
1358                _WifiDirectConvertErrorResult(errorCode == WIFI_DIRECT_ERROR_AUTH_FAILED, r, E_AUTHENTICATION);
1359                _WifiDirectConvertErrorResult(errorCode == WIFI_DIRECT_ERROR_CONNECTION_FAILED, r, E_NOT_RESPONDING);
1360                _WifiDirectConvertErrorResult(errorCode == WIFI_DIRECT_ERROR_CONNECTION_TIME_OUT, r, E_REMOTE_DEVICE_NOT_FOUND);
1361                    __pWifiDirectSystemAdapter->OnWifiDirectGroupCreated(peerMacAddress, r);
1362
1363                _WifiDirectConvertErrorResult(errorCode != WIFI_DIRECT_ERROR_NONE, r, E_SYSTEM);
1364                _WifiDirectConvertErrorResult(errorCode == WIFI_DIRECT_ERROR_AUTH_FAILED, r, E_AUTHENTICATION);
1365                _WifiDirectConvertErrorResult(errorCode == WIFI_DIRECT_ERROR_CONNECTION_FAILED, r, E_NOT_RESPONDING);
1366                    __pWifiDirectSystemAdapter->OnWifiDirectConnected(peerMacAddress, r);
1367            }
1368            else if(r != E_SUCCESS)
1369            {
1370                    (void)__pWifiDirectSystemAdapter->InitializeCurrentState();
1371                _WifiDirectConvertErrorResult(errorCode != WIFI_DIRECT_ERROR_NONE, r, E_SYSTEM);
1372                _WifiDirectConvertErrorResult(errorCode == WIFI_DIRECT_ERROR_AUTH_FAILED, r, E_AUTHENTICATION);
1373                _WifiDirectConvertErrorResult(errorCode == WIFI_DIRECT_ERROR_CONNECTION_FAILED, r, E_NOT_RESPONDING);
1374                _WifiDirectConvertErrorResult(errorCode == WIFI_DIRECT_ERROR_CONNECTION_TIME_OUT, r, E_REMOTE_DEVICE_NOT_FOUND);
1375                    __pWifiDirectSystemAdapter->OnWifiDirectGroupCreated(peerMacAddress, r);
1376
1377                _WifiDirectConvertErrorResult(errorCode != WIFI_DIRECT_ERROR_NONE, r, E_SYSTEM);
1378                _WifiDirectConvertErrorResult(errorCode == WIFI_DIRECT_ERROR_AUTH_FAILED, r, E_AUTHENTICATION);
1379                _WifiDirectConvertErrorResult(errorCode == WIFI_DIRECT_ERROR_CONNECTION_FAILED, r, E_NOT_RESPONDING);
1380                    __pWifiDirectSystemAdapter->OnWifiDirectConnected(peerMacAddress, r);
1381            }
1382            break;
1383        case WIFI_DIRECT_SYSTEM_ASSOCIATING:
1384            (void)__pWifiDirectSystemAdapter->InitializeCurrentState();
1385            _WifiDirectConvertErrorResult(errorCode != WIFI_DIRECT_ERROR_NONE, r, E_SYSTEM);
1386            _WifiDirectConvertErrorResult(errorCode == WIFI_DIRECT_ERROR_AUTH_FAILED, r, E_AUTHENTICATION);
1387            _WifiDirectConvertErrorResult(errorCode == WIFI_DIRECT_ERROR_CONNECTION_FAILED, r, E_NOT_RESPONDING);
1388            _WifiDirectConvertErrorResult(errorCode == WIFI_DIRECT_ERROR_CONNECTION_TIME_OUT, r, E_REMOTE_DEVICE_NOT_FOUND);
1389            __pWifiDirectSystemAdapter->OnWifiDirectAssociationCompleted(peerMacAddress, r);
1390
1391            _WifiDirectConvertErrorResult(errorCode != WIFI_DIRECT_ERROR_NONE, r, E_SYSTEM);
1392            _WifiDirectConvertErrorResult(errorCode == WIFI_DIRECT_ERROR_AUTH_FAILED, r, E_AUTHENTICATION);
1393            _WifiDirectConvertErrorResult(errorCode == WIFI_DIRECT_ERROR_CONNECTION_FAILED, r, E_NOT_RESPONDING);
1394            __pWifiDirectSystemAdapter->OnWifiDirectConnected(peerMacAddress, r);
1395            break;
1396        case WIFI_DIRECT_SYSTEM_ACTIVATED:
1397           (void)__pWifiDirectSystemAdapter->InitializeCurrentState();
1398           if (r == E_SUCCESS && isOwner == false)
1399           {
1400               _WifiDirectConvertErrorResult(errorCode != WIFI_DIRECT_ERROR_NONE, r, E_SYSTEM);
1401               _WifiDirectConvertErrorResult(errorCode == WIFI_DIRECT_ERROR_AUTH_FAILED, r, E_AUTHENTICATION);
1402               _WifiDirectConvertErrorResult(errorCode == WIFI_DIRECT_ERROR_CONNECTION_FAILED, r, E_NOT_RESPONDING);
1403               _WifiDirectConvertErrorResult(errorCode == WIFI_DIRECT_ERROR_CONNECTION_TIME_OUT, r, E_REMOTE_DEVICE_NOT_FOUND);
1404               __pWifiDirectSystemAdapter->OnWifiDirectAssociationCompleted(peerMacAddress, r);
1405
1406               _WifiDirectConvertErrorResult(errorCode != WIFI_DIRECT_ERROR_NONE, r, E_SYSTEM);
1407               _WifiDirectConvertErrorResult(errorCode == WIFI_DIRECT_ERROR_AUTH_FAILED, r, E_AUTHENTICATION);
1408               _WifiDirectConvertErrorResult(errorCode == WIFI_DIRECT_ERROR_CONNECTION_FAILED, r, E_NOT_RESPONDING);
1409               __pWifiDirectSystemAdapter->OnWifiDirectConnected(peerMacAddress, r);
1410           }
1411           break;
1412        default:
1413            SysLog(NID_NET_WIFI, "Unknown case - current state : %s", __pWifiDirectSystemAdapter->GetStringOfDeviceState());
1414            break;
1415        }
1416        break;
1417     case WIFI_DIRECT_DISASSOCIATION_IND:
1418         SysLog(NID_NET_WIFI, "connectionState : WIFI_DIRECT_DISASSOCIATION_IND");
1419         __pWifiDirectSystemAdapter->OnWifiDirectClientDisassociated(peerMacAddress);
1420         __pWifiDirectSystemAdapter->OnWifiDirectDisconnected(peerMacAddress, E_SUCCESS);
1421         break;
1422     case WIFI_DIRECT_DISCONNECTION_RSP:
1423         SysLog(NID_NET_WIFI, "event type : WIFI_DIRECT_DISCONNECTION_RSP");
1424         if (__pWifiDirectSystemAdapter->__currentState == WIFI_DIRECT_SYSTEM_DISCONNECTING)
1425         {
1426             (void)__pWifiDirectSystemAdapter->InitializeCurrentState();
1427             _WifiDirectConvertErrorResult(errorCode != WIFI_DIRECT_ERROR_NONE, r, E_SYSTEM);
1428             _WifiDirectConvertErrorResult(errorCode == WIFI_DIRECT_ERROR_CONNECTION_FAILED, r, E_NOT_RESPONDING);
1429             __pWifiDirectSystemAdapter->OnWifiDirectAssociationTerminated(WIFI_DIRECT_ASSOCIATION_TERMINATION_REASON_SELF_INITIATED, r);
1430
1431             _WifiDirectConvertErrorResult(errorCode != WIFI_DIRECT_ERROR_NONE, r, E_SYSTEM);
1432             __pWifiDirectSystemAdapter->OnWifiDirectDisconnected(peerMacAddress, r);
1433         }
1434         else if(__pWifiDirectSystemAdapter->__currentState == WIFI_DIRECT_SYSTEM_LEAVING)
1435         {
1436             (void)__pWifiDirectSystemAdapter->InitializeCurrentState();
1437             _WifiDirectConvertErrorResult(errorCode != WIFI_DIRECT_ERROR_NONE, r, E_SYSTEM);
1438             __pWifiDirectSystemAdapter->OnWifiDirectGroupLeft(r);
1439         }
1440         else if(__pWifiDirectSystemAdapter->__currentState == WIFI_DIRECT_SYSTEM_CONNECT_CANCELLING)
1441         {
1442             (void)__pWifiDirectSystemAdapter->InitializeCurrentState();
1443             __pWifiDirectSystemAdapter->OnWifiDirectGroupCreated(peerMacAddress, E_OPERATION_CANCELED);
1444             __pWifiDirectSystemAdapter->OnWifiDirectConnected(peerMacAddress, E_OPERATION_CANCELED);
1445         }
1446         break;
1447     case WIFI_DIRECT_DISCONNECTION_IND:
1448         SysLog(NID_NET_WIFI, "connectionState : WIFI_DIRECT_DISCONNECTION_IND");
1449         (void)__pWifiDirectSystemAdapter->InitializeCurrentState();
1450         __pWifiDirectSystemAdapter->OnWifiDirectAssociationTerminated(WIFI_DIRECT_ASSOCIATION_TERMINATION_REASON_DISCONNECTED, E_SUCCESS);
1451
1452         _WifiDirectConvertErrorResult(errorCode != WIFI_DIRECT_ERROR_NONE, r, E_SYSTEM);
1453         __pWifiDirectSystemAdapter->OnWifiDirectDisconnected(peerMacAddress, r);
1454         break;
1455     case WIFI_DIRECT_GROUP_DESTROYED:
1456         SysLog(NID_NET_WIFI, "connectionState : WIFI_DIRECT_GROUP_DESTROYED");
1457         switch(__pWifiDirectSystemAdapter->__currentState)
1458         {
1459             case WIFI_DIRECT_SYSTEM_GROUP_CANCELING:
1460                 (void)__pWifiDirectSystemAdapter->InitializeCurrentState();
1461                 _WifiDirectConvertErrorResult(errorCode != WIFI_DIRECT_ERROR_NONE, r, E_SYSTEM);
1462                 __pWifiDirectSystemAdapter->OnWifiDirectGroupDestroyed(r);
1463                 break;
1464             case WIFI_DIRECT_SYSTEM_OWNER:
1465                 if (r == E_SUCCESS)
1466                 {
1467                     (void)__pWifiDirectSystemAdapter->InitializeCurrentState();
1468                     _WifiDirectConvertErrorResult(errorCode != WIFI_DIRECT_ERROR_NONE, r, E_SYSTEM);
1469                     __pWifiDirectSystemAdapter->OnWifiDirectGroupDestroyed(r);
1470
1471                     _WifiDirectConvertErrorResult(errorCode != WIFI_DIRECT_ERROR_NONE, r, E_SYSTEM);
1472                     _WifiDirectConvertErrorResult(errorCode == WIFI_DIRECT_ERROR_CONNECTION_FAILED, r, E_NOT_RESPONDING);
1473                     __pWifiDirectSystemAdapter->OnWifiDirectGroupLeft(r);
1474                 }
1475                 break;
1476             case WIFI_DIRECT_SYSTEM_DESTROYING:
1477                 (void)__pWifiDirectSystemAdapter->InitializeCurrentState();
1478                 _WifiDirectConvertErrorResult(errorCode != WIFI_DIRECT_ERROR_NONE, r, E_SYSTEM);
1479                 __pWifiDirectSystemAdapter->OnWifiDirectGroupDestroyed(r);
1480                 break;
1481             case WIFI_DIRECT_SYSTEM_CLIENT:
1482                 (void)__pWifiDirectSystemAdapter->InitializeCurrentState();
1483                 _WifiDirectConvertErrorResult(errorCode != WIFI_DIRECT_ERROR_NONE, r, E_SYSTEM);
1484                 _WifiDirectConvertErrorResult(errorCode == WIFI_DIRECT_ERROR_CONNECTION_FAILED, r, E_NOT_RESPONDING);
1485                 __pWifiDirectSystemAdapter->OnWifiDirectAssociationTerminated(WIFI_DIRECT_ASSOCIATION_TERMINATION_REASON_DISCONNECTED, r);
1486
1487                 _WifiDirectConvertErrorResult(errorCode != WIFI_DIRECT_ERROR_NONE, r, E_SYSTEM);
1488                 _WifiDirectConvertErrorResult(errorCode == WIFI_DIRECT_ERROR_CONNECTION_FAILED, r, E_NOT_RESPONDING);
1489                 __pWifiDirectSystemAdapter->OnWifiDirectGroupLeft(r);
1490                 break;
1491             case WIFI_DIRECT_SYSTEM_LEAVING:
1492                 (void)__pWifiDirectSystemAdapter->InitializeCurrentState();
1493                 _WifiDirectConvertErrorResult(errorCode != WIFI_DIRECT_ERROR_NONE, r, E_SYSTEM);
1494                 _WifiDirectConvertErrorResult(errorCode == WIFI_DIRECT_ERROR_CONNECTION_FAILED, r, E_NOT_RESPONDING);
1495                 __pWifiDirectSystemAdapter->OnWifiDirectGroupLeft(r);
1496                 break;
1497             default:
1498                 SysLog(NID_NET_WIFI, "Unknown case - current state : %s", __pWifiDirectSystemAdapter->GetStringOfDeviceState());
1499                 break;
1500         }
1501         break;
1502     default:
1503         SysLog(NID_NET_WIFI, "Unknown case %d", connectionState);
1504         break;
1505     }
1506 }
1507
1508 void
1509 _WifiDirectSystemAdapter::OnWifiDirectClientIpAssigned(const char *mac_address, const char *ip_address,
1510                                                     const char *interface_address, void *user_data)
1511 {
1512     SysLog(NID_NET_WIFI, "%ls", __pWifiDirectSystemAdapter->GetStringOfAllCurrentState().GetPointer());
1513     SysLog(NID_NET_WIFI, "mac address : %s, interface address : %s, ipaddress : %s", mac_address, interface_address, ip_address);
1514
1515     switch(__pWifiDirectSystemAdapter->__currentState)
1516     {
1517     case WIFI_DIRECT_SYSTEM_GROUP_CREATING:
1518     case WIFI_DIRECT_SYSTEM_CONNECTING:
1519            (void)__pWifiDirectSystemAdapter->InitializeCurrentState();
1520            __pWifiDirectSystemAdapter->OnWifiDirectGroupCreated(mac_address, E_SUCCESS);
1521            __pWifiDirectSystemAdapter->OnWifiDirectConnected(mac_address, E_SUCCESS);
1522            break;
1523     case WIFI_DIRECT_SYSTEM_OWNER:
1524         __pWifiDirectSystemAdapter->OnWifiDirectClientAssociated(mac_address);
1525         __pWifiDirectSystemAdapter->OnWifiDirectConnected(mac_address, E_SUCCESS);
1526         break;
1527     default:
1528         SysLog(NID_NET_WIFI, "unnecessary case %d", __pWifiDirectSystemAdapter->__currentState);
1529         break;
1530     }
1531 }
1532
1533 void
1534 _WifiDirectSystemAdapter::OnWifiDirectScanCompleted(int errorCode, wifi_direct_discovery_state_e discoveryState, void* pUserData)
1535 {
1536     SysLog(NID_NET_WIFI, "Enter, [discoveryState:0x%x] [ErrorCode:0x%x]", discoveryState, errorCode);
1537     SysLog(NID_NET_WIFI, "%ls", __pWifiDirectSystemAdapter->GetStringOfAllCurrentState().GetPointer());
1538
1539     _WifiDirectEventArg* pEventArg = null;
1540     result r = E_SYSTEM;
1541     _WifiDirectConvertErrorResult(errorCode == WIFI_DIRECT_ERROR_NONE, r, E_SUCCESS);
1542
1543     ArrayList foundPeerList(SingleObjectDeleter);
1544
1545     switch(discoveryState)
1546     {
1547     case WIFI_DIRECT_ONLY_LISTEN_STARTED:
1548         SysLog(NID_NET_WIFI, "discoveryState : WIFI_DIRECT_ONLY_LISTEN_STARTED");
1549         SysTryCatch(NID_NET_WIFI, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
1550         if(__pWifiDirectSystemAdapter->__currentState == WIFI_DIRECT_SYSTEM_ACTIVATING)
1551         {
1552             __pWifiDirectSystemAdapter->__currentState = WIFI_DIRECT_SYSTEM_ACTIVATED;
1553             pEventArg = new (std::nothrow)_WifiDirectEventArg(WIFI_DIRECT_DEVICE_EVENT_ACTIVATED, DEFAULT_DEVICE_ID, r);
1554             SysTryReturnVoidResult(NID_NET_WIFI, pEventArg != null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
1555         }
1556         break;
1557     case WIFI_DIRECT_DISCOVERY_STARTED:
1558         SysLog(NID_NET_WIFI, "discoveryState : WIFI_DIRECT_DISCOVERY_STARTED");
1559         __pWifiDirectSystemAdapter->__discoveredPeerList.RemoveAll();
1560         break;
1561     case WIFI_DIRECT_DISCOVERY_FOUND:
1562         SysLog(NID_NET_WIFI, "discoveryState : WIFI_DIRECT_DISCOVERY_FOUND");
1563         if (__pWifiDirectSystemAdapter->__currentState == WIFI_DIRECT_SYSTEM_GROUP_CREATING)
1564         {
1565             int err = wifi_direct_foreach_discovered_peers(OnWifiDirectFindSameDeviceName, null);
1566             r = _WifiDirectUtility::ConvertErrorCode(err);
1567             SysTryCatch(NID_NET_WIFI, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
1568         }
1569         else if (__pWifiDirectSystemAdapter->__currentScanState == WIFI_DIRECT_SYSTEM_SCAN_SCANNING)
1570         {
1571             int err = wifi_direct_foreach_discovered_peers(OnWifiDirectPeerFound, &foundPeerList);
1572             SysLog(NID_NET_WIFI, "[0x%x] Return value of wifi_direct_foreach_discovered_peers()", err);
1573             r = _WifiDirectUtility::ConvertErrorCode(err);
1574             SysTryCatch(NID_NET_WIFI, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
1575         }
1576
1577         break;
1578     case WIFI_DIRECT_DISCOVERY_FINISHED:
1579         SysLog(NID_NET_WIFI, "discoveryState: WIFI_DIRECT_DISCOVERY_FINISHED");
1580
1581         switch(__pWifiDirectSystemAdapter->__currentScanState)
1582         {
1583         case WIFI_DIRECT_SYSTEM_SCAN_IDLE:
1584             break;
1585         case WIFI_DIRECT_SYSTEM_SCAN_LISTEN:
1586             break;
1587         case WIFI_DIRECT_SYSTEM_SCAN_CANCELLING:
1588             __pWifiDirectSystemAdapter->__currentScanState = WIFI_DIRECT_SYSTEM_SCAN_IDLE;
1589
1590             r = __pWifiDirectSystemAdapter->StartListenMode();
1591             SysTryCatch(NID_NET_WIFI, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
1592
1593             if (__pWifiDirectSystemAdapter->__currentState == WIFI_DIRECT_SYSTEM_CONNECT_CANCELLING)
1594             {
1595
1596                 pEventArg = new (std::nothrow)_WifiDirectEventArg(WIFI_DIRECT_DEVICE_EVENT_GROUP_CREATED, DEFAULT_DEVICE_ID,
1597                         WifiDirectGroupInfo(), WifiDirectDeviceInfo(), WIFI_DIRECT_GROUP_MEMBER_TYPE_NONE, E_OPERATION_CANCELED);
1598             }
1599             else
1600             {
1601                 pEventArg = new (std::nothrow)_WifiDirectEventArg(WIFI_DIRECT_DEVICE_EVENT_SCAN_COMPLETED, DEFAULT_DEVICE_ID,
1602                         (Tizen::Net::NetConnection*)null, E_OPERATION_CANCELED);
1603             }
1604
1605             break;
1606         case WIFI_DIRECT_SYSTEM_SCAN_LISTEN_CANCELING_TO_SCAN:
1607             if (__pWifiDirectSystemAdapter->__currentState == WIFI_DIRECT_SYSTEM_CONNECT_CANCELLING)
1608             {
1609                 __pWifiDirectSystemAdapter->__currentScanState = WIFI_DIRECT_SYSTEM_SCAN_IDLE;
1610
1611                 r = __pWifiDirectSystemAdapter->StartListenMode();
1612                 SysTryCatch(NID_NET_WIFI, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
1613
1614                 pEventArg = new (std::nothrow)_WifiDirectEventArg(WIFI_DIRECT_DEVICE_EVENT_GROUP_CREATED, DEFAULT_DEVICE_ID,
1615                         WifiDirectGroupInfo(), WifiDirectDeviceInfo(), WIFI_DIRECT_GROUP_MEMBER_TYPE_NONE, E_OPERATION_CANCELED);
1616             }
1617             else
1618             {
1619                 __pWifiDirectSystemAdapter->__currentScanState = WIFI_DIRECT_SYSTEM_SCAN_IDLE;
1620                 r = __pWifiDirectSystemAdapter->StartDiscovery();
1621                 SysTryCatch(NID_NET_WIFI, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
1622             }
1623             break;
1624         case WIFI_DIRECT_SYSTEM_SCAN_SCANNING:
1625             __pWifiDirectSystemAdapter->__currentScanState = WIFI_DIRECT_SYSTEM_SCAN_IDLE;
1626
1627             if (__pWifiDirectSystemAdapter->__currentState == WIFI_DIRECT_SYSTEM_GROUP_CREATING)
1628             {
1629                 bool isFind = false;
1630                 int err = wifi_direct_foreach_discovered_peers(OnWifiDirectFindSameDeviceName, &isFind);
1631                 SysLog(NID_NET_WIFI, "[0x%x] Return value of wifi_direct_foreach_discovered_peers() : %ls", err, isFind ? L"Find" : L"Not Find");
1632
1633                 if (isFind == false)
1634                 {
1635                     pEventArg = new _WifiDirectEventArg(WIFI_DIRECT_DEVICE_EVENT_GROUP_CREATED, DEFAULT_DEVICE_ID,
1636                             WifiDirectGroupInfo(), WifiDirectDeviceInfo(), WIFI_DIRECT_GROUP_MEMBER_TYPE_NONE,
1637                             E_REMOTE_DEVICE_NOT_FOUND);
1638
1639                     __pWifiDirectSystemAdapter->__currentState = WIFI_DIRECT_SYSTEM_ACTIVATED;
1640                 }
1641             }
1642             else
1643             {
1644                 __pWifiDirectSystemAdapter->__currentScanState = WIFI_DIRECT_SYSTEM_SCAN_IDLE;
1645
1646                 result res = E_SUCCESS;
1647
1648                 ArrayList* pDeviceInfoList = new (std::nothrow) ArrayList();
1649                 SysTryReturnVoidResult(NID_NET_WIFI, pDeviceInfoList != null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
1650                 res = pDeviceInfoList->Construct();
1651                 if(res != E_SUCCESS)
1652                 {
1653                     delete pDeviceInfoList;
1654                     SysLog(NID_NET_WIFI, "Failed to construct list");
1655                     return;
1656                 }
1657
1658                 int err = wifi_direct_foreach_discovered_peers(OnWifiDirectEachDiscoveredPeer, pDeviceInfoList);
1659                 SysLog(NID_NET_WIFI, "[0x%x] Return value of wifi_direct_foreach_discovered_peers()", err);
1660                 if( err != WIFI_DIRECT_ERROR_NONE
1661                     && err != WIFI_DIRECT_ERROR_OPERATION_FAILED) // when can't find any remote device.
1662                 {
1663                     pDeviceInfoList->RemoveAll(true);
1664                     delete pDeviceInfoList;
1665                     SysLog(NID_NET_WIFI, "Error on wifi_direct_foreach_discovered_peers");
1666                     return;
1667                 }
1668
1669                 res = __pWifiDirectSystemAdapter->StartListenMode();
1670                 SysTryCatch(NID_NET_WIFI, res == E_SUCCESS, , res, "[%s] Propagating.", GetErrorMessage(res));
1671
1672                 pEventArg = new (std::nothrow)_WifiDirectEventArg(WIFI_DIRECT_DEVICE_EVENT_SCAN_COMPLETED, DEFAULT_DEVICE_ID,
1673                         pDeviceInfoList, r);
1674             }
1675             break;
1676         default:
1677             SysLogException(NID_NET_WIFI, E_SYSTEM, "[E_SYSTEM] Not an allowed type : %d", __pWifiDirectSystemAdapter->__currentScanState);
1678             break;
1679         }
1680         break;
1681     } // end of switch(discoveryState)
1682
1683     if (pEventArg != null)
1684     {
1685         __pWifiDirectSystemAdapter->__pWifiDirectEvent->FireAsync(*pEventArg);
1686     }
1687
1688 CATCH:
1689     SysLog(NID_NET_WIFI, "Exit, %ls",__pWifiDirectSystemAdapter->GetStringOfAllCurrentState().GetPointer());
1690
1691 }
1692
1693 bool
1694 _WifiDirectSystemAdapter::OnWifiDirectEachDiscoveredPeer(wifi_direct_discovered_peer_info_s* peer, void* pUserData)
1695 {
1696     ArrayList* pList = static_cast< ArrayList* >(pUserData);
1697     SysTryReturn(NID_NET_WIFI, pList != null, false, E_SYSTEM, "[E_SYSTEM] Failed to acquire list of peers");
1698
1699     WifiDirectDeviceInfo* pDeviceInfo = _WifiDirectUtility::ConvertDiscoveryEntry2DeviceInfoN(*peer);
1700     SysTryReturn(NID_NET_WIFI, pDeviceInfo != null, false, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
1701
1702     pList->Add(*pDeviceInfo);
1703
1704     return true;
1705 }
1706
1707 bool
1708 _WifiDirectSystemAdapter::OnWifiDirectPeerFound(wifi_direct_discovered_peer_info_s* peer, void* pUserData)
1709 {
1710     unique_ptr<WifiDirectDeviceInfo> pDeviceInfo(_WifiDirectUtility::ConvertDiscoveryEntry2DeviceInfoN(*peer));
1711     SysTryReturn(NID_NET_WIFI, pDeviceInfo != null, false, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
1712
1713     int index = 0;
1714
1715     result r = __pWifiDirectSystemAdapter->__discoveredPeerList.IndexOf(*pDeviceInfo, index);
1716
1717     if (r == E_OBJ_NOT_FOUND || r == E_OUT_OF_RANGE)
1718     {
1719         _WifiDirectEventArg* pEventArg = new (std::nothrow)_WifiDirectEventArg(WIFI_DIRECT_DEVICE_EVENT_SCAN_FOUND, DEFAULT_DEVICE_ID,
1720                         *pDeviceInfo);
1721         SysTryReturn(NID_NET_WIFI, pEventArg != null, false, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
1722
1723         __pWifiDirectSystemAdapter->__pWifiDirectEvent->FireAsync(*pEventArg);
1724
1725         __pWifiDirectSystemAdapter->__discoveredPeerList.Add(pDeviceInfo.release());
1726     }
1727
1728     return true;
1729 }
1730
1731 bool
1732 _WifiDirectSystemAdapter::OnWifiDirectEachConnectedClient(wifi_direct_connected_peer_info_s* pPeer, void* pUserData)
1733 {
1734         IList* pList = static_cast<IList*>(pUserData);
1735     SysTryReturn(NID_NET_WIFI, pList != null, false, E_SYSTEM, "[E_SYSTEM] Failed to acquire list of peers");
1736
1737     WifiDirectDeviceInfo * pDeviceInfo= _WifiDirectUtility::ConvertPeerInfoToDeviceInfoN(WIFI_DIRECT_GROUP_MEMBER_TYPE_CLIENT, *pPeer);
1738     SysTryReturn(NID_NET_WIFI, pDeviceInfo != null, false, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
1739
1740     pList->Add(*pDeviceInfo);
1741
1742     return true;
1743 }
1744
1745 bool
1746 _WifiDirectSystemAdapter::OnWifiDirectConnectedOwner(wifi_direct_connected_peer_info_s* pPeer, void* pUserData)
1747 {
1748     IList* pList = static_cast<IList*>(pUserData);
1749     SysTryReturn(NID_NET_WIFI, pList != null, false, E_SYSTEM, "[E_SYSTEM] Failed to acquire list of peers");
1750
1751     WifiDirectDeviceInfo * pDeviceInfo= _WifiDirectUtility::ConvertPeerInfoToDeviceInfoN(WIFI_DIRECT_GROUP_MEMBER_TYPE_OWNER, *pPeer);
1752    SysTryReturn(NID_NET_WIFI, pDeviceInfo != null, false, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
1753
1754     pList->Add(*pDeviceInfo);
1755
1756     return true;
1757 }
1758
1759 bool
1760 _WifiDirectSystemAdapter::OnWifiDirectFindSameDeviceName(wifi_direct_discovered_peer_info_s* pPeer, void* pUserData)
1761 {
1762     String convertDevicename(pPeer->device_name);
1763     String deviceName;
1764     result r = __pWifiDirectSystemAdapter->__pWifiServiceProxy->GetWifiDirectLocalDeviceName(deviceName);
1765     SysTryReturn(NID_NET_WIFI, r == E_SUCCESS, null, r, "[%s] Propagating.", GetErrorMessage(r));
1766
1767     if (deviceName.CompareTo(convertDevicename) == 0 )
1768     {
1769         if(pUserData != null)
1770         {
1771             *(static_cast< bool* >(pUserData)) = true;
1772         }
1773
1774         int err = wifi_direct_connect(pPeer->mac_address);
1775         result r = _WifiDirectUtility::ConvertErrorCode(err);
1776
1777         if (IsFailed(r))
1778         {
1779             _WifiDirectEventArg* pEventArg = new _WifiDirectEventArg(WIFI_DIRECT_DEVICE_EVENT_GROUP_CREATED,
1780                  DEFAULT_DEVICE_ID, WifiDirectGroupInfo(), WifiDirectDeviceInfo(), WIFI_DIRECT_GROUP_MEMBER_TYPE_NONE, E_SYSTEM);
1781
1782             __pWifiDirectSystemAdapter->__currentState = WIFI_DIRECT_SYSTEM_ACTIVATED;
1783             __pWifiDirectSystemAdapter->__pWifiDirectEvent->FireAsync(*pEventArg);
1784         }
1785
1786         return false;
1787     }
1788
1789     return true;
1790 }
1791
1792 bool
1793 _WifiDirectSystemAdapter::OnWifiDirectSupportedWpsMode(wifi_direct_wps_type_e type, void* pUserData)
1794 {
1795     ArrayListT<WifiWpsConfigurationMode>* pList = static_cast< ArrayListT<WifiWpsConfigurationMode>* >(pUserData);
1796     SysTryReturn(NID_NET_WIFI, pList != null, false, E_SYSTEM, "[E_SYSTEM] Failed to acquire list of peers");
1797
1798     WifiWpsConfigurationMode wpsMode  = _WifiDirectUtility::ConvertSupportedWpsMode(type);
1799
1800     pList->Add(wpsMode);
1801
1802     return true;
1803 }
1804
1805 result
1806 _WifiDirectSystemAdapter::InitializeCurrentState(void)
1807 {
1808     result r = E_SUCCESS;
1809     int err = WIFI_DIRECT_ERROR_NONE;
1810
1811     wifi_direct_state_e status = WIFI_DIRECT_STATE_DEACTIVATED;
1812
1813     err = wifi_direct_get_state(&status);
1814     _WifiDirectConvertErrorResult(err != WIFI_DIRECT_ERROR_NONE, r, E_SYSTEM);
1815     SysTryReturn(NID_NET_WIFI, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
1816
1817     bool isOwner = false;
1818     if (status != WIFI_DIRECT_STATE_DEACTIVATED
1819                     && status != WIFI_DIRECT_STATE_DEACTIVATING
1820                     && status != WIFI_DIRECT_STATE_ACTIVATING)
1821     {
1822        err = wifi_direct_is_group_owner(&isOwner);
1823        SysLog(NID_NET_WIFI, "[0x%x] Return value of wifi_direct_is_group_owner()", err);
1824
1825        _WifiDirectConvertErrorResult(err != WIFI_DIRECT_ERROR_NONE, r, E_SYSTEM);
1826        SysTryReturn(NID_NET_WIFI, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
1827     }
1828
1829     switch(status)
1830     {
1831     case WIFI_DIRECT_STATE_DEACTIVATED:
1832         __currentState = WIFI_DIRECT_SYSTEM_DEACTIVATED;
1833         break;
1834     case WIFI_DIRECT_STATE_DEACTIVATING:
1835         __currentState = WIFI_DIRECT_SYSTEM_DEACTIVATING;
1836         break;
1837     case WIFI_DIRECT_STATE_ACTIVATING:
1838         __currentState = WIFI_DIRECT_SYSTEM_ACTIVATING;
1839         break;
1840     case WIFI_DIRECT_STATE_DISCOVERING:
1841         {
1842             if (isOwner == true)
1843             {
1844                 __currentState = WIFI_DIRECT_SYSTEM_OWNER;
1845             }
1846             else
1847             {
1848                 __currentState = WIFI_DIRECT_SYSTEM_ACTIVATED;
1849             }
1850
1851             bool isListenMode = false;
1852             wifi_direct_is_listening_only(&isListenMode);
1853             if (isListenMode == true)
1854             {
1855                 __currentScanState = WIFI_DIRECT_SYSTEM_SCAN_LISTEN;
1856             }
1857             else
1858             {
1859                 __currentScanState = WIFI_DIRECT_SYSTEM_SCAN_SCANNING;
1860             }
1861         }
1862         break;
1863     case WIFI_DIRECT_STATE_ACTIVATED:
1864         __currentState = WIFI_DIRECT_SYSTEM_ACTIVATED;
1865         r = StartListenMode();
1866         SysLogException(NID_NET_WIFI, r, "[%s] Propagating.", GetErrorMessage(r));
1867         break;
1868     case WIFI_DIRECT_STATE_CONNECTED:
1869         if (isOwner == true)
1870         {
1871             __currentState = WIFI_DIRECT_SYSTEM_OWNER;
1872         }
1873         else
1874         {
1875             __currentState = WIFI_DIRECT_SYSTEM_CLIENT;
1876         }
1877         // ToDo: Getting peer list
1878         break;
1879     case WIFI_DIRECT_STATE_CONNECTING:
1880         __currentState = WIFI_DIRECT_SYSTEM_CONNECTING;
1881         break;
1882     case WIFI_DIRECT_STATE_DISCONNECTING:
1883         if (isOwner == true)
1884         {
1885             __currentState = WIFI_DIRECT_SYSTEM_DESTROYING;
1886         }
1887         else
1888         {
1889             __currentState = WIFI_DIRECT_SYSTEM_DISCONNECTING;
1890         }
1891         break;
1892     default:
1893         SysLog(NID_NET_WIFI, "Unknown case : %d", status);
1894         r = E_SYSTEM;
1895         break;
1896     }
1897
1898     return r;
1899 }
1900
1901 result
1902 _WifiDirectSystemAdapter::StartListenMode(void)
1903 {
1904         result r = E_SYSTEM;
1905     int err = wifi_direct_start_discovery(true, 0);
1906     _WifiDirectConvertErrorResult(err == WIFI_DIRECT_ERROR_NONE, r, E_SUCCESS);
1907     SysTryReturnResult(NID_NET_WIFI, err == WIFI_DIRECT_ERROR_NONE, E_SYSTEM, "Staring discovery has failed.", GetErrorMessage(r));
1908
1909     if (r == E_SUCCESS)
1910     {
1911         __currentScanState = WIFI_DIRECT_SYSTEM_SCAN_LISTEN;
1912     }
1913
1914     return r;
1915 }
1916
1917 result
1918 _WifiDirectSystemAdapter::StopListenModeToScan(void)
1919 {
1920         result r = E_SYSTEM;
1921     int err = wifi_direct_cancel_discovery();
1922     _WifiDirectConvertErrorResult(err == WIFI_DIRECT_ERROR_NONE, r, E_SUCCESS);
1923     SysTryReturnResult(NID_NET_WIFI, err == WIFI_DIRECT_ERROR_NONE, E_SYSTEM, "Cancelling discovery has failed.", GetErrorMessage(r));
1924
1925     if (r == E_SUCCESS)
1926     {
1927         __currentScanState = WIFI_DIRECT_SYSTEM_SCAN_LISTEN_CANCELING_TO_SCAN;
1928     }
1929
1930     return r;
1931 }
1932
1933 result
1934 _WifiDirectSystemAdapter::StartDiscovery(void)
1935 {
1936         result r = E_SYSTEM;
1937     int err = wifi_direct_start_discovery(false, WIFI_DIRECT_DISCOVERY_TIMEOUT);
1938     _WifiDirectConvertErrorResult(err == WIFI_DIRECT_ERROR_NONE, r, E_SUCCESS);
1939     SysTryReturnResult(NID_NET_WIFI, err == WIFI_DIRECT_ERROR_NONE, E_SYSTEM, "Staring discovery has failed.", GetErrorMessage(r));
1940
1941     if (r == E_SUCCESS)
1942     {
1943         __currentScanState = WIFI_DIRECT_SYSTEM_SCAN_SCANNING;
1944     }
1945
1946     return r;
1947 }
1948
1949 result
1950 _WifiDirectSystemAdapter::CancelDiscovery(void)
1951 {
1952         result r = E_SYSTEM;
1953     int err = wifi_direct_cancel_discovery();
1954     _WifiDirectConvertErrorResult(err == WIFI_DIRECT_ERROR_NONE, r, E_SUCCESS);
1955     SysTryReturnResult(NID_NET_WIFI, err == WIFI_DIRECT_ERROR_NONE, E_SYSTEM, "Cancelling discovery has failed.", GetErrorMessage(r));
1956
1957     if (r == E_SUCCESS)
1958     {
1959         __currentScanState = WIFI_DIRECT_SYSTEM_SCAN_CANCELLING;
1960     }
1961
1962     return r;
1963 }
1964
1965 const char*
1966 _WifiDirectSystemAdapter::GetStringOfDeviceState(void) const
1967 {
1968     const char* pStateStr[] = { "DEACTIVATED",
1969                                 "ACTIVATING",
1970                                 "DEACTIVATING",
1971                                 "ACTIVATED",
1972                                 "AUTONOMOUS_GROUP_CREATING",
1973                                 "GROUP_CREATING",
1974                                 "GROUP_CANCELING",
1975                                 "CONNECTING",
1976                                 "CONNECT_CANCELLING",
1977                                 "ASSOCIATING",
1978                                 "OWNER",
1979                                 "DESTROYING",
1980                                 "LEAVING",
1981                                 "CLIENT",
1982                                 "DISCONNECTING"};
1983
1984     return pStateStr[__currentState];
1985 }
1986
1987 const char*
1988 _WifiDirectSystemAdapter::GetStringOfScanState(void) const
1989 {
1990     const char* pStateStr[] = { "SCAN_IDLE",
1991                                 "SCAN_LISTEN",
1992                                 "SCAN_LISTEN_CANCELING_TO_SCAN",
1993                                 "SCAN_SCANNING",
1994                                 "SCAN_CANCELLING" };
1995
1996     return pStateStr[__currentScanState];
1997 }
1998
1999 String
2000 _WifiDirectSystemAdapter::GetStringOfAllCurrentState(void) const
2001 {
2002         String currentState;
2003
2004         (void)currentState.Append("DeviceState : ");
2005         (void)currentState.Append(GetStringOfDeviceState());
2006         (void)currentState.Append(" | ");
2007         (void)currentState.Append("ScanState : ");
2008         (void)currentState.Append(GetStringOfScanState());
2009
2010         return currentState;
2011 }
2012
2013 WifiDirectDeviceInfo*
2014 _WifiDirectSystemAdapter::GetConnectedPeerDeviceInfoN(WifiDirectGroupMemberType peerMemberType, const Tizen::Base::String* pPeerMacAddress /* = null */) const
2015 {
2016     unique_ptr<ArrayList,AllElementsDeleter> pDeviceInfoList(new (std::nothrow) ArrayList());
2017     SysTryReturn(NID_NET_WIFI, pDeviceInfoList != null, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
2018
2019     WifiDirectDeviceInfo* pDeviceInfo = null;
2020     int err = WIFI_DIRECT_ERROR_NONE;
2021
2022     if (peerMemberType == WIFI_DIRECT_GROUP_MEMBER_TYPE_OWNER)
2023     {
2024         err = wifi_direct_foreach_connected_peers(OnWifiDirectConnectedOwner, pDeviceInfoList.get());
2025         SysTryReturn(NID_NET_WIFI, err == WIFI_DIRECT_ERROR_NONE, null, E_SYSTEM, "Getting the information of connected device has failed.");
2026
2027         if (pDeviceInfoList->GetCount() != 0)
2028         {
2029             pDeviceInfo = dynamic_cast<WifiDirectDeviceInfo*>(pDeviceInfoList->GetAt(0));
2030             SysTryReturn(NID_NET_WIFI, pDeviceInfo != null, null, E_SYSTEM, "Failed to get a owner owner information.");
2031         }
2032     }
2033     else
2034     {
2035         err = wifi_direct_foreach_connected_peers(OnWifiDirectEachConnectedClient, pDeviceInfoList.get());
2036         SysTryReturn(NID_NET_WIFI, err == WIFI_DIRECT_ERROR_NONE, null, E_SYSTEM, "Getting the information of connected device has failed.");
2037
2038         for (int i = 0; i < pDeviceInfoList->GetCount(); i++)
2039         {
2040             pDeviceInfo = dynamic_cast<WifiDirectDeviceInfo*>(pDeviceInfoList->GetAt(i));
2041             SysTryReturn(NID_NET_WIFI, pDeviceInfo != null, null, E_SYSTEM, "Failed to get a group client information.");
2042
2043             if(pDeviceInfo->GetMacAddress() == *pPeerMacAddress)
2044             {
2045                 break;
2046             }
2047         }
2048     }
2049
2050     return new (std::nothrow) WifiDirectDeviceInfo(*pDeviceInfo);
2051 }
2052
2053 void
2054 _WifiDirectSystemAdapter::OnWifiDirectGroupCreated(const String& peerMacAddress, result r)
2055 {
2056     _WifiDirectEventArg* pEventArg = null;
2057
2058     unique_ptr<WifiDirectGroupInfo> pGroupInfo;
2059     unique_ptr<WifiDirectDeviceInfo> pDeviceInfo;
2060
2061     if (IsFailed(r))
2062     {
2063       pEventArg = new _WifiDirectEventArg(WIFI_DIRECT_DEVICE_EVENT_GROUP_CREATED, DEFAULT_DEVICE_ID,
2064               WifiDirectGroupInfo(), WifiDirectDeviceInfo(), WIFI_DIRECT_GROUP_MEMBER_TYPE_NONE, r);
2065     }
2066     else
2067     {
2068         bool isGroupOwner = false;
2069         (void)wifi_direct_is_group_owner(&isGroupOwner);
2070
2071         if (isGroupOwner == true)
2072         {
2073             pGroupInfo.reset(GetGroupSettingInfoN());
2074             pDeviceInfo.reset(GetLocalDeviceInfoN());
2075         }
2076         else
2077         {
2078                 char* pSsid = null;
2079             (void)wifi_direct_get_ssid(&pSsid);
2080             String ssid(pSsid);
2081             free(pSsid);
2082
2083             int channel = -1;
2084             (void)wifi_direct_get_operating_channel(&channel);
2085             WifiRadioChannel operatingChannel = _WifiDirectUtility::ConvertChannel(channel);
2086
2087             _WifiDirectGroupInfoImpl groupInfoImpl;
2088             groupInfoImpl.SetAutonomousGroupOwnerMode(false);
2089             groupInfoImpl.SetBssId(peerMacAddress);
2090             groupInfoImpl.SetSsid(ssid);
2091             groupInfoImpl.SetOperatingChannel(operatingChannel);
2092
2093             pGroupInfo.reset(_WifiDirectGroupInfoImpl::CreateWifiDirectGroupInfoInstanceN(groupInfoImpl));
2094             pDeviceInfo.reset(GetConnectedPeerDeviceInfoN(WIFI_DIRECT_GROUP_MEMBER_TYPE_OWNER));
2095         }
2096
2097         if(pGroupInfo != null && pDeviceInfo != null)
2098         {
2099            pEventArg = new (std::nothrow) _WifiDirectEventArg(WIFI_DIRECT_DEVICE_EVENT_GROUP_CREATED, DEFAULT_DEVICE_ID, *pGroupInfo,
2100                    *pDeviceInfo, isGroupOwner ? WIFI_DIRECT_GROUP_MEMBER_TYPE_OWNER : WIFI_DIRECT_GROUP_MEMBER_TYPE_CLIENT, r);
2101         }
2102         else
2103         {
2104            SysLogException(NID_NET_WIFI, E_SYSTEM, "[E_SYSTEM] Failed to get group info or device info.");
2105            pEventArg = new (std::nothrow) _WifiDirectEventArg(WIFI_DIRECT_DEVICE_EVENT_GROUP_CREATED, DEFAULT_DEVICE_ID, WifiDirectGroupInfo(),
2106                    WifiDirectDeviceInfo(), WIFI_DIRECT_GROUP_MEMBER_TYPE_NONE, E_SYSTEM);
2107         }
2108     }
2109
2110     if (pEventArg != null)
2111     {
2112        __pWifiDirectEvent->FireAsync(*pEventArg);
2113     }
2114 }
2115
2116 void
2117 _WifiDirectSystemAdapter::OnWifiDirectAssociationCompleted(const Tizen::Base::String& peerMacAddress, result r)
2118 {
2119     _WifiDirectEventArg* pEventArg = null;
2120     unique_ptr<WifiDirectDeviceInfo> pDeviceInfo;
2121
2122     if (IsFailed(r))
2123     {
2124       pEventArg = new (std::nothrow) _WifiDirectEventArg(WIFI_DIRECT_DEVICE_EVENT_ASSOCIATED, DEFAULT_DEVICE_ID, r);
2125     }
2126     else
2127     {
2128         // Get the peer device information
2129         pDeviceInfo.reset(GetConnectedPeerDeviceInfoN(WIFI_DIRECT_GROUP_MEMBER_TYPE_OWNER));
2130
2131         if (pDeviceInfo != null)
2132         {
2133             pEventArg = new (std::nothrow) _WifiDirectEventArg(WIFI_DIRECT_DEVICE_EVENT_ASSOCIATED, DEFAULT_DEVICE_ID, *pDeviceInfo, r);
2134         }
2135         else
2136         {
2137             pEventArg = new (std::nothrow) _WifiDirectEventArg(WIFI_DIRECT_DEVICE_EVENT_ASSOCIATED, DEFAULT_DEVICE_ID, E_SYSTEM);
2138         }
2139     }
2140
2141     if (pEventArg != null)
2142     {
2143       __pWifiDirectEvent->FireAsync(*pEventArg);
2144     }
2145 }
2146
2147 void
2148 _WifiDirectSystemAdapter::OnWifiDirectClientAssociated(const Tizen::Base::String& peerMacAddress)
2149 {
2150     _WifiDirectEventArg* pEventArg = null;
2151     unique_ptr<WifiDirectDeviceInfo> pDeviceInfo(GetConnectedPeerDeviceInfoN(WIFI_DIRECT_GROUP_MEMBER_TYPE_CLIENT, &peerMacAddress));
2152
2153     if (pDeviceInfo != null)
2154     {
2155         pEventArg = new (std::nothrow) _WifiDirectEventArg(WIFI_DIRECT_GO_EVENT_CLIENT_ASSOCIATED, DEFAULT_DEVICE_ID, *pDeviceInfo);
2156
2157         __pWifiDirectEvent->FireAsync(*pEventArg);
2158     }
2159 }
2160
2161 void
2162 _WifiDirectSystemAdapter::OnWifiDirectClientDisassociated(const Tizen::Base::String& peerMacAddress)
2163 {
2164     _WifiDirectEventArg* pEventArg = null;
2165
2166     WifiDirectDeviceInfo* pDeviceInfo = GetPeerInfo(peerMacAddress);
2167     WifiDirectAssociationTerminationReason reason = WIFI_DIRECT_ASSOCIATION_TERMINATION_REASON_SELF_INITIATED;
2168
2169     if (pDeviceInfo != null)
2170     {
2171         if (_WifiDirectDeviceInfoImpl::GetInstance(*pDeviceInfo)->IsDisconnecting() != true)
2172         {
2173             reason = WIFI_DIRECT_ASSOCIATION_TERMINATION_REASON_DISCONNECTED;
2174         }
2175
2176         pEventArg = new (std::nothrow)_WifiDirectEventArg( WIFI_DIRECT_GO_EVENT_CLIENT_DISASSOCIATED,
2177               DEFAULT_DEVICE_ID, *pDeviceInfo, WIFI_DIRECT_ASSOCIATION_TERMINATION_REASON_DISCONNECTED);
2178     }
2179
2180    if (pEventArg != null)
2181    {
2182      __pWifiDirectEvent->FireAsync(*pEventArg);
2183    }
2184 }
2185
2186 void
2187 _WifiDirectSystemAdapter::OnWifiDirectAssociationTerminated(WifiDirectAssociationTerminationReason reason, result r)
2188 {
2189     _WifiDirectEventArg* pEventArg = null;
2190
2191     pEventArg = new (std::nothrow)_WifiDirectEventArg(WIFI_DIRECT_GC_EVENT_DISASSOCIATED, DEFAULT_DEVICE_ID, reason, r);
2192     SysTryReturnVoidResult(NID_NET_WIFI, pEventArg != null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
2193
2194     __pWifiDirectEvent->FireAsync(*pEventArg);
2195 }
2196
2197 void
2198 _WifiDirectSystemAdapter::OnWifiDirectGroupDestroyed(result r)
2199 {
2200     _WifiDirectEventArg* pEventArg = null;
2201
2202     pEventArg = new (std::nothrow)_WifiDirectEventArg(WIFI_DIRECT_GO_EVENT_GROUP_DESTROYED, DEFAULT_DEVICE_ID, r);
2203     SysTryReturnVoidResult(NID_NET_WIFI, pEventArg != null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
2204
2205     __pWifiDirectEvent->FireAsync(*pEventArg);
2206 }
2207
2208 void
2209 _WifiDirectSystemAdapter::OnWifiDirectConnected(const Tizen::Base::String& peerMacAddress, result r)
2210 {
2211     _WifiDirectEventArg* pEventArg = null;
2212     unique_ptr<WifiDirectDeviceInfo> pDeviceInfo;
2213
2214     if (!IsFailed(r))
2215     {
2216         bool isGroupOwner = false;
2217         int err = wifi_direct_is_group_owner(&isGroupOwner);
2218         SysLog(NID_NET_WIFI, "[0x%x] Return value of wifi_direct_is_group_owner()", err);
2219
2220         if (isGroupOwner == true)
2221         {
2222             pDeviceInfo.reset(GetConnectedPeerDeviceInfoN(WIFI_DIRECT_GROUP_MEMBER_TYPE_CLIENT, &peerMacAddress));
2223         }
2224         else
2225         {
2226             pDeviceInfo.reset(GetConnectedPeerDeviceInfoN(WIFI_DIRECT_GROUP_MEMBER_TYPE_OWNER, &peerMacAddress));
2227         }
2228
2229         if (pDeviceInfo != null)
2230         {
2231             AddPeerInfo(pDeviceInfo.get());
2232             pEventArg = new (std::nothrow) _WifiDirectEventArg(WIFI_DIRECT_DEVICE_EVENT_CONNECTED, DEFAULT_DEVICE_ID, *pDeviceInfo, r);
2233
2234             SysTryReturnVoidResult(NID_NET_WIFI, pEventArg != null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
2235         }
2236     }
2237     else
2238     {
2239         pEventArg = new (std::nothrow) _WifiDirectEventArg(WIFI_DIRECT_DEVICE_EVENT_CONNECTED, DEFAULT_DEVICE_ID, WifiDirectDeviceInfo(), r);
2240         SysTryReturnVoidResult(NID_NET_WIFI, pEventArg != null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
2241     }
2242
2243     __pWifiDirectEvent->FireAsync(*pEventArg);
2244 }
2245
2246 void
2247 _WifiDirectSystemAdapter::OnWifiDirectDisconnected(const Tizen::Base::String& peerMacAddress, result r)
2248 {
2249     _WifiDirectEventArg* pEventArg = null;
2250
2251     pEventArg = new (std::nothrow)_WifiDirectEventArg(WIFI_DIRECT_DEVICE_EVENT_DISCONNECTED, DEFAULT_DEVICE_ID, peerMacAddress);
2252     SysTryReturnVoidResult(NID_NET_WIFI, pEventArg != null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
2253
2254     WifiDirectDeviceInfo* pDeviceInfoTemp = GetPeerInfo(peerMacAddress);
2255     if (pDeviceInfoTemp != null)
2256     {
2257         RemovePeerInfo(pDeviceInfoTemp);
2258     }
2259
2260     __pWifiDirectEvent->FireAsync(*pEventArg);
2261 }
2262
2263 void
2264 _WifiDirectSystemAdapter::OnWifiDirectAutonomousGroupCreated(result r)
2265 {
2266     _WifiDirectEventArg* pEventArg = new _WifiDirectEventArg(WIFI_DIRECT_DEVICE_EVENT_AUTONOMOS_GROUP_CREATED, DEFAULT_DEVICE_ID, r);
2267     SysTryReturnVoidResult(NID_NET_WIFI, pEventArg != null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
2268
2269     __pWifiDirectEvent->FireAsync(*pEventArg);
2270 }
2271
2272 void
2273 _WifiDirectSystemAdapter::OnWifiDirectGroupLeft(result r)
2274 {
2275     _WifiDirectEventArg* pEventArg = null;
2276
2277     pEventArg = new (std::nothrow)_WifiDirectEventArg(WIFI_DIRECT_DEVICE_EVENT_GROUP_LEFT, DEFAULT_DEVICE_ID);
2278     SysTryReturnVoidResult(NID_NET_WIFI, pEventArg != null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
2279
2280     __pWifiDirectEvent->FireAsync(*pEventArg);
2281 }
2282
2283 } } } // Tizen::Net::Wifi
2284