src/StWifiDirectManager.cpp

   1 //
   2 // Copyright (c) 2012 Samsung Electronics Co., Ltd.
   3 //
   4 // Licensed under the Flora License, Version 1.1 (the License);
   5 // you may not use this file except in compliance with the License.
   6 // You may obtain a copy of the License at
   7 //
   8 //     http://floralicense.org/license/
   9 //
  10 // Unless required by applicable law or agreed to in writing, software
  11 // distributed under the License is distributed on an AS IS BASIS,
  12 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13 // See the License for the specific language governing permissions and
  14 // limitations under the License.
  15 //
  16
  17 /**
  18  * @file                StWifiDirectManager.cpp
  19  * @brief               This is the implementation file for StWifiDirectManager class.
  20  */
  21
  22 #include <cstdlib>
  23 #include "StWifiDirectManager.h"
  24 #include "StIWifiDirectManagerEventListener.h"
  25
  26 using namespace Tizen::Base;
  27 using namespace Tizen::Base::Collection;
  28 using namespace Tizen::Net::Wifi;
  29
  30 #define WIFI_DIRECT_MANAGER_DEBUG_CODE
  31 #define WIFI_DIRECT_MANAGER_BUG_REPORT
  32
  33 WifiDirectManager* WifiDirectManager::__pWifiDirectManagerInstance = null;
  34
  35 WifiDirectManager::WifiDirectManager(void)
  36         : __pLocalDevice(null)
  37         , __pAllGroupMemberListInfo(null)
  38         , __pScanDeviceInfoList(null)
  39         , __pBusyDeviceInfoList(null)
  40         , __pEventListener(null)
  41         , __lastEventToPerform(WIFI_DIRECT_MANAGER_EVENT_NONE)
  42 {
  43 }
  44
  45 WifiDirectManager::~WifiDirectManager(void)
  46 {
  47         InitAllGroupMemberListInfo();
  48         InitScanDeviceInfoList();
  49         InitBusyDeviceInfoList();
  50
  51         delete __pLocalDevice;
  52         __pLocalDevice = null;
  53
  54         __pEventListener = null;
  55 }
  56
  57 WifiDirectManager*
  58 WifiDirectManager::GetInstance(void)
  59 {
  60         if (__pWifiDirectManagerInstance == null)
  61         {
  62                 CreateInstance();
  63         }
  64
  65         return __pWifiDirectManagerInstance;
  66 }
  67
  68 result
  69 WifiDirectManager::Construct(void)
  70 {
  71         result r = E_FAILURE;
  72
  73         __pLocalDevice = WifiDirectDeviceManager::GetWifiDirectDeviceN();
  74
  75         if ((__pLocalDevice == null)
  76                 || (IsFailed(GetLastResult())))
  77         {
  78                 if (__pLocalDevice == null)
  79                 {
  80                         r = E_FAILURE;
  81                 }
  82
  83                 delete __pLocalDevice;
  84                 __pLocalDevice = null;
  85                 return r;
  86         }
  87
  88         r = AddLinstener();
  89         if (IsFailed(r))
  90         {
  91                 delete __pLocalDevice;
  92                 __pLocalDevice = null;
  93         }
  94
  95         return r;
  96 }
  97
  98 void
  99 WifiDirectManager::CreateInstance(void)
 100 {
 101         __pWifiDirectManagerInstance = new (std::nothrow) WifiDirectManager();
 102         result r = __pWifiDirectManagerInstance->Construct();
 103         if (IsFailed(r))
 104         {
 105                 delete __pWifiDirectManagerInstance;
 106                 __pWifiDirectManagerInstance = null;
 107                 return;
 108         }
 109
 110         std::atexit(DestroyInstance);
 111 }
 112
 113 void
 114 WifiDirectManager::DestroyInstance(void)
 115 {
 116         delete __pWifiDirectManagerInstance;
 117         __pWifiDirectManagerInstance = null;
 118 }
 119
 120 result
 121 WifiDirectManager::AddLinstener(void)
 122 {
 123         if (__pLocalDevice == null)
 124         {
 125                 return E_FAILURE;
 126         }
 127
 128         result r = __pLocalDevice->AddWifiDirectDeviceListener(*this);
 129         if (IsFailed(r))
 130         {
 131                 return r;
 132         }
 133
 134         r = __pLocalDevice->AddWifiDirectGroupClientListener(*this);
 135         if (IsFailed(r))
 136         {
 137                 return r;
 138         }
 139
 140         r = __pLocalDevice->AddWifiDirectGroupOwnerListener(*this);
 141         if (IsFailed(r))
 142         {
 143                 return r;
 144         }
 145
 146         return r;
 147 }
 148
 149 result
 150 WifiDirectManager::RemoveLinstener(void)
 151 {
 152         if (__pLocalDevice == null)
 153         {
 154                 return E_FAILURE;
 155         }
 156
 157         result r = __pLocalDevice->RemoveWifiDirectDeviceListener(*this);
 158         if (IsFailed(r))
 159         {
 160                 return r;
 161         }
 162
 163         r = __pLocalDevice->RemoveWifiDirectGroupClientListener(*this);
 164         if (IsFailed(r))
 165         {
 166                 return r;
 167         }
 168
 169         r = __pLocalDevice->RemoveWifiDirectGroupOwnerListener(*this);
 170         if (IsFailed(r))
 171         {
 172                 return r;
 173         }
 174
 175         return r;
 176 }
 177
 178 Tizen::Base::Collection::IList*
 179 WifiDirectManager::GetAllGroupMemberListInfoN(void)
 180 {
 181         IList* pGroupMemberListInfo = null;
 182
 183         if ((__pLocalDevice == null)
 184                 || (__pAllGroupMemberListInfo == null))
 185         {
 186                 if (__pLocalDevice == null)
 187                 {
 188                         SetLastResult(E_FAILURE);
 189                 }
 190                 else
 191                 {
 192                         SetLastResult(E_INVALID_OPERATION);
 193                 }
 194                 return pGroupMemberListInfo;
 195         }
 196
 197         pGroupMemberListInfo = __pAllGroupMemberListInfo->GetItemsN(0, __pAllGroupMemberListInfo->GetCount());
 198
 199         if (IsFailed(GetLastResult()))
 200         {
 201                 delete pGroupMemberListInfo;
 202                 pGroupMemberListInfo = null;
 203                 return pGroupMemberListInfo;
 204         }
 205
 206         return pGroupMemberListInfo;
 207 }
 208
 209 Tizen::Net::Wifi::WifiDirectDeviceInfo*
 210 WifiDirectManager::GetGroupMemberListInfoAt(int index)
 211 {
 212         WifiDirectDeviceInfo* pGroupMemberListInfo = null;
 213
 214         if ((__pLocalDevice == null)
 215                 || (__pAllGroupMemberListInfo == null))
 216         {
 217                 if (__pLocalDevice == null)
 218                 {
 219                         SetLastResult(E_FAILURE);
 220                 }
 221                 else
 222                 {
 223                         SetLastResult(E_INVALID_OPERATION);
 224                 }
 225                 return pGroupMemberListInfo;
 226         }
 227
 228         int groupMemberListInfoCount = __pAllGroupMemberListInfo->GetCount();
 229         if (groupMemberListInfoCount != 0)
 230         {
 231                 pGroupMemberListInfo = static_cast<WifiDirectDeviceInfo*>(__pAllGroupMemberListInfo->GetAt(index));
 232
 233                 if (IsFailed(GetLastResult()))
 234                 {
 235                         pGroupMemberListInfo = null;
 236                 }
 237         }
 238         else
 239         {
 240                 SetLastResult(E_OBJ_NOT_FOUND);
 241         }
 242
 243         return pGroupMemberListInfo;
 244 }
 245
 246 Tizen::Base::Collection::IList*
 247 WifiDirectManager::GetScanDeviceListInfoN(void)
 248 {
 249         IList* pScanDeviceInfoList = null;
 250
 251         if ((__pLocalDevice == null)
 252                 || (__pScanDeviceInfoList == null))
 253         {
 254                 if (__pLocalDevice == null)
 255                 {
 256                         SetLastResult(E_FAILURE);
 257                 }
 258                 else
 259                 {
 260                         SetLastResult(E_INVALID_OPERATION);
 261                 }
 262                 return pScanDeviceInfoList;
 263         }
 264
 265         pScanDeviceInfoList = __pScanDeviceInfoList->GetItemsN(0, __pScanDeviceInfoList->GetCount());
 266
 267         if (IsFailed(GetLastResult()))
 268         {
 269                 delete pScanDeviceInfoList;
 270                 pScanDeviceInfoList = null;
 271                 return pScanDeviceInfoList;
 272         }
 273
 274         return pScanDeviceInfoList;
 275 }
 276
 277 Tizen::Net::Wifi::WifiDirectDeviceInfo*
 278 WifiDirectManager::GetScanDeviceListInfoAt(int index)
 279 {
 280         WifiDirectDeviceInfo* pScanDeviceInfo = null;
 281
 282         if ((__pLocalDevice == null)
 283                 || (__pScanDeviceInfoList == null))
 284         {
 285                 if (__pLocalDevice == null)
 286                 {
 287                         SetLastResult(E_FAILURE);
 288                 }
 289                 else
 290                 {
 291                         SetLastResult(E_INVALID_OPERATION);
 292                 }
 293                 return pScanDeviceInfo;
 294         }
 295
 296         int scanDeviceListCount = __pScanDeviceInfoList->GetCount();
 297         if (scanDeviceListCount != 0)
 298         {
 299                 pScanDeviceInfo = static_cast<WifiDirectDeviceInfo*>(__pScanDeviceInfoList->GetAt(index));
 300
 301                 if (IsFailed(GetLastResult()))
 302                 {
 303                         pScanDeviceInfo = null;
 304                 }
 305         }
 306         else
 307         {
 308                 SetLastResult(E_OBJ_NOT_FOUND);
 309         }
 310
 311         return pScanDeviceInfo;
 312 }
 313
 314 int
 315 WifiDirectManager::GetScanDeviceListInfoCount(void)
 316 {
 317         int scanDeviceListTotalCount = 0;
 318
 319         if ((__pLocalDevice == null)
 320                 || (__pScanDeviceInfoList == null))
 321         {
 322                 if (__pLocalDevice == null)
 323                 {
 324                         SetLastResult(E_FAILURE);
 325                 }
 326                 else
 327                 {
 328                         SetLastResult(E_INVALID_OPERATION);
 329                 }
 330                 return scanDeviceListTotalCount;
 331         }
 332
 333         scanDeviceListTotalCount = __pScanDeviceInfoList->GetCount();
 334         return scanDeviceListTotalCount;
 335 }
 336
 337 Tizen::Net::Wifi::WifiDirectDeviceInfo*
 338 WifiDirectManager::GetBusyDeviceListInfoAt(int index)
 339 {
 340         WifiDirectDeviceInfo* pBusyDeviceInfo = null;
 341
 342         if ((__pLocalDevice == null)
 343                 || (__pScanDeviceInfoList == null))
 344         {
 345                 if (__pLocalDevice == null)
 346                 {
 347                         SetLastResult(E_FAILURE);
 348                 }
 349                 else
 350                 {
 351                         SetLastResult(E_INVALID_OPERATION);
 352                 }
 353                 return pBusyDeviceInfo;
 354         }
 355
 356         int busyDeviceListCount = __pBusyDeviceInfoList->GetCount();
 357         if (busyDeviceListCount != 0)
 358         {
 359                 pBusyDeviceInfo = static_cast<WifiDirectDeviceInfo*>(__pBusyDeviceInfoList->GetAt(index));
 360
 361                 if (IsFailed(GetLastResult()))
 362                 {
 363                         pBusyDeviceInfo = null;
 364                 }
 365         }
 366         else
 367         {
 368                 SetLastResult(E_OBJ_NOT_FOUND);
 369         }
 370
 371         return pBusyDeviceInfo;
 372 }
 373
 374 int
 375 WifiDirectManager::GetBusyDeviceListInfoCount(void)
 376 {
 377         int busyDeviceListTotalCount = 0;
 378
 379         if ((__pLocalDevice == null)
 380                 || (__pBusyDeviceInfoList == null))
 381         {
 382                 if (__pLocalDevice == null)
 383                 {
 384                         SetLastResult(E_FAILURE);
 385                 }
 386                 else
 387                 {
 388                         SetLastResult(E_INVALID_OPERATION);
 389                 }
 390                 return busyDeviceListTotalCount;
 391         }
 392
 393         busyDeviceListTotalCount = __pBusyDeviceInfoList->GetCount();
 394         return busyDeviceListTotalCount;
 395 }
 396
 397 result
 398 WifiDirectManager::Activate(void)
 399 {
 400         result r = E_INVALID_OPERATION;
 401
 402         if (__pLocalDevice == null)
 403         {
 404                 return E_FAILURE;
 405         }
 406
 407         if (!IsActivated())
 408         {
 409                 r = __pLocalDevice->Activate();
 410                 if (!IsFailed(r))
 411                 {
 412                         SetLastEventToPerform(WIFI_DIRECT_MANAGER_EVENT_DEVICE_ACTIVATING);
 413                 }
 414         }
 415
 416         return r;
 417 }
 418
 419 result
 420 WifiDirectManager::Deactivate(void)
 421 {
 422         result r = E_INVALID_OPERATION;
 423
 424         if (__pLocalDevice == null)
 425         {
 426                 return E_FAILURE;
 427         }
 428
 429         if(IsActivated())
 430         {
 431                 r = __pLocalDevice->Deactivate();
 432                 if (!IsFailed(r))
 433                 {
 434                         SetLastEventToPerform(WIFI_DIRECT_MANAGER_EVENT_DEVICE_DEACTIVATING);
 435                 }
 436         }
 437
 438         return r;
 439 }
 440
 441 bool
 442 WifiDirectManager::IsActivated(void)
 443 {
 444         bool isActivated = false;
 445
 446         if (__pLocalDevice == null)
 447         {
 448                 SetLastResult(E_FAILURE);
 449                 return isActivated;
 450         }
 451
 452         isActivated = __pLocalDevice->IsActivated();
 453         return isActivated;
 454 }
 455
 456 bool
 457 WifiDirectManager::IsScanInProgress(void)
 458 {
 459         if (__lastEventToPerform == WIFI_DIRECT_MANAGER_EVENT_SCANNING)
 460         {
 461                 return true;
 462         }
 463         return false;
 464 }
 465
 466 WifiDirectManagerEvent
 467 WifiDirectManager::GetLastEventToPerform(void)
 468 {
 469         return __lastEventToPerform;
 470 }
 471
 472 void
 473 WifiDirectManager::SetLastEventToPerform(WifiDirectManagerEvent lsatEvent)
 474 {
 475         __lastEventToPerform = lsatEvent;
 476 }
 477
 478 Tizen::Net::Wifi::WifiWpsConfigurationMode
 479 WifiDirectManager::GetRemoteWpsConfigurationMode(Tizen::Net::Wifi::WifiDirectDevice* pRemoteDevice)
 480 {
 481         WifiWpsConfigurationMode getWpsMode = WIFI_WPS_CONFIG_MODE_NONE;
 482
 483         if (pRemoteDevice == null)
 484         {
 485                 SetLastResult(E_FAILURE);
 486                 return WIFI_WPS_CONFIG_MODE_NONE;
 487         }
 488
 489         getWpsMode = pRemoteDevice->GetWpsConfigurationModePreference();
 490
 491         if (IsFailed(GetLastResult()))
 492         {
 493                 return WIFI_WPS_CONFIG_MODE_NONE;
 494         }
 495
 496         return getWpsMode;
 497 }
 498
 499 WifiDirectGroupMemberType
 500 WifiDirectManager::GetLocalDeviceGroupMemberType(void)
 501 {
 502         WifiDirectGroupMemberType groupMemberType = WIFI_DIRECT_GROUP_MEMBER_TYPE_NONE;
 503
 504         if (__pLocalDevice == null)
 505         {
 506                 SetLastResult(E_FAILURE);
 507                 return WIFI_DIRECT_GROUP_MEMBER_TYPE_NONE;
 508         }
 509
 510         WifiDirectDeviceInfo* pLocalDeviceInfo = __pLocalDevice->GetLocalDeviceInfoN();
 511
 512 #ifdef WIFI_DIRECT_MANAGER_DEBUG_CODE
 513         if (pLocalDeviceInfo == null)
 514         {
 515                 return WIFI_DIRECT_GROUP_MEMBER_TYPE_NONE;
 516         }
 517 #else
 518         if ((pLocalDeviceInfo == null)
 519                 || (IsFailed(GetLastResult())))
 520         {
 521                 if (!IsFailed(GetLastResult()))
 522                 {
 523                         SetLastResult(E_SYSTEM);
 524                 }
 525
 526                 delete pLocalDeviceInfo;
 527                 return WIFI_DIRECT_GROUP_MEMBER_TYPE_NONE;
 528         }
 529 #endif
 530         else
 531         {
 532 #ifdef WIFI_DIRECT_MANAGER_BUG_REPORT
 533                 AppLogDebug("WIFI_DIRECT_MANAGER_BUG_REPORT [GetLocalDeviceGroupMemberType : %d][%s]", pLocalDeviceInfo->GetGroupMemberType(), GetErrorMessage(GetLastResult()));
 534 #endif
 535                 groupMemberType = pLocalDeviceInfo->GetGroupMemberType();
 536                 delete pLocalDeviceInfo;
 537         }
 538
 539         return groupMemberType;
 540 }
 541
 542 result
 543 WifiDirectManager::ConnectTo(const Tizen::Net::Wifi::WifiDirectDeviceInfo& pRemoteDeviceInfo)
 544 {
 545         result r = E_FAILURE;
 546
 547         if (__pLocalDevice == null)
 548         {
 549                 return r;
 550         }
 551
 552         if (GetLocalDeviceGroupMemberType() != WIFI_DIRECT_GROUP_MEMBER_TYPE_NONE)
 553         {
 554                 return r = E_INVALID_CONNECTION;
 555         }
 556
 557         if (pRemoteDeviceInfo.GetGroupMemberType() == WIFI_DIRECT_GROUP_MEMBER_TYPE_CLIENT)
 558         {
 559                 return r = E_INVALID_ARG;
 560         }
 561
 562         if (pRemoteDeviceInfo.GetGroupMemberType() == WIFI_DIRECT_GROUP_MEMBER_TYPE_OWNER)
 563         {
 564                 r = __pLocalDevice->Associate(pRemoteDeviceInfo);
 565                 if (!IsFailed(r))
 566                 {
 567                         SetLastEventToPerform(WIFI_DIRECT_MANAGER_EVENT_ASSOCIATING);
 568                 }
 569         }
 570         else
 571         {
 572                 WifiDirectGroupInfo* pSettingGroupInfo = (WifiDirectGroupInfo*)__pLocalDevice->GetGroupSettingInfoN();
 573
 574                 if ((pSettingGroupInfo == null)
 575                         || (IsFailed(GetLastResult())))
 576                 {
 577                         if (!IsFailed(GetLastResult()))
 578                         {
 579                                 SetLastResult(E_FAILURE);
 580                         }
 581
 582                         delete pSettingGroupInfo;
 583                         return GetLastResult();
 584                 }
 585
 586                 if (pSettingGroupInfo->GetAutonomousGroupOwnerMode() == true)
 587                 {
 588                         r = __pLocalDevice->CreateGroup(pSettingGroupInfo);
 589                 }
 590                 else
 591                 {
 592                         r = __pLocalDevice->CreateGroup(pSettingGroupInfo, &pRemoteDeviceInfo);
 593                 }
 594
 595                 delete pSettingGroupInfo;
 596
 597                 if (!IsFailed(r))
 598                 {
 599                         SetLastEventToPerform(WIFI_DIRECT_MANAGER_EVENT_GROUP_CREATING);
 600                 }
 601         }
 602
 603         return r;
 604 }
 605
 606 result
 607 WifiDirectManager::Associate(const Tizen::Net::Wifi::WifiDirectDeviceInfo& pRemoteDeviceInfo)
 608 {
 609         int localDeviceGroupMemberType = GetLocalDeviceGroupMemberType();
 610
 611         if ((localDeviceGroupMemberType != WIFI_DIRECT_GROUP_MEMBER_TYPE_NONE)
 612                 || (!IsActivated())
 613                 || (IsFailed(GetLastResult())))
 614         {
 615                 return E_INVALID_CONNECTION;
 616         }
 617
 618         if (pRemoteDeviceInfo.GetGroupMemberType() == WIFI_DIRECT_GROUP_MEMBER_TYPE_CLIENT)
 619         {
 620                 return E_INVALID_CONNECTION;
 621         }
 622
 623         result r = __pLocalDevice->Associate(pRemoteDeviceInfo);
 624         if (!IsFailed(r))
 625         {
 626                 SetLastEventToPerform(WIFI_DIRECT_MANAGER_EVENT_ASSOCIATING);
 627         }
 628
 629         return r;
 630 }
 631
 632 result
 633 WifiDirectManager::DisconnectAll(void)
 634 {
 635         result r = E_FAILURE;
 636
 637         if (GetLocalDeviceGroupMemberType() == WIFI_DIRECT_GROUP_MEMBER_TYPE_NONE)
 638         {
 639                 return E_INVALID_CONNECTION;
 640         }
 641
 642         WifiDirectGroupMember* pGroupMember = __pLocalDevice->GetWifiDirectMemberN();
 643
 644         if (pGroupMember == null)
 645         {
 646                 SetLastResult(E_FAILURE);
 647                 return E_FAILURE;
 648         }
 649
 650         if (pGroupMember->GetGroupMemberType() == WIFI_DIRECT_GROUP_MEMBER_TYPE_OWNER)
 651         {
 652                 WifiDirectGroupOwner* pGroupOwner = dynamic_cast<WifiDirectGroupOwner*>(pGroupMember);
 653                 if (pGroupOwner != null)
 654                 {
 655                         r = pGroupOwner->DestroyGroup();
 656                 }
 657         }
 658         else if (pGroupMember->GetGroupMemberType() == WIFI_DIRECT_GROUP_MEMBER_TYPE_CLIENT)
 659         {
 660                 WifiDirectGroupClient* pGroupClient = dynamic_cast<WifiDirectGroupClient*>(pGroupMember);
 661                 if (pGroupClient != null)
 662                 {
 663                         r = pGroupClient->Disassociate();
 664                 }
 665         }
 666         else
 667         {
 668                 r = E_INVALID_CONNECTION;
 669         }
 670
 671         delete pGroupMember;
 672         return r;
 673 }
 674
 675 Tizen::Base::String
 676 WifiDirectManager::GetLocalDeviceName(void)
 677 {
 678         String localDeviceName;
 679
 680         if (__pLocalDevice == null)
 681         {
 682                 SetLastResult(E_FAILURE);
 683                 return localDeviceName;
 684         }
 685
 686         WifiDirectDeviceInfo* pLocalDeviceInfo =__pLocalDevice->GetLocalDeviceInfoN();
 687         if (pLocalDeviceInfo == null)
 688         {
 689                 AppLogDebug("__pLocalDevice->GetLocalDeviceInfoN() is null");
 690                 SetLastResult(E_FAILURE);
 691                 return localDeviceName;
 692         }
 693
 694         localDeviceName = pLocalDeviceInfo->GetDeviceName();
 695         delete pLocalDeviceInfo;
 696
 697         return localDeviceName;
 698 }
 699
 700 result
 701 WifiDirectManager::CancelConnect(void)
 702 {
 703         if (__pLocalDevice == null)
 704         {
 705                 return E_FAILURE;
 706         }
 707
 708         result r = __pLocalDevice->CancelGroupCreation();
 709         return r;
 710 }
 711
 712 result
 713 WifiDirectManager::RemoteDeviceScan(void)
 714 {
 715         result r = E_FAILURE;
 716
 717         if (__pLocalDevice == null)
 718         {
 719                 return r;
 720         }
 721
 722         InitScanDeviceInfoList();
 723         InitBusyDeviceInfoList();
 724
 725         r = __pLocalDevice->Scan();
 726         if (!IsFailed(r))
 727         {
 728                 SetLastEventToPerform(WIFI_DIRECT_MANAGER_EVENT_SCANNING);
 729         }
 730
 731         return r;
 732 }
 733
 734 result
 735 WifiDirectManager::CancelRemoteDeviceScan(void)
 736 {
 737         result r = E_FAILURE;
 738
 739         if (__pLocalDevice != null)
 740         {
 741                 r = __pLocalDevice->CancelScan();
 742         }
 743
 744         return r;
 745 }
 746
 747 void
 748 WifiDirectManager::SendToEventListener(WifiDirectManagerEvent requestEvent, result r)
 749 {
 750         if (__pEventListener != null)
 751         {
 752                 SetLastEventToPerform(requestEvent);
 753                 __pEventListener->OnWifiDirectManagerEventCompleted(requestEvent, r);
 754         }
 755         else
 756         {
 757                 SetLastResult(E_FAILURE);
 758         }
 759 }
 760
 761 void
 762 WifiDirectManager::SetIWifiDirectManagerEventListener(const IWifiDirectManagerEventListener& pEventListener)
 763 {
 764         __pEventListener = &const_cast<IWifiDirectManagerEventListener&>(pEventListener);
 765 }
 766
 767 void
 768 WifiDirectManager::RemoveIWifiDirectManagerEventListener(void)
 769 {
 770         __pEventListener = null;
 771 }
 772
 773 result
 774 WifiDirectManager::QueryAllGroupMemberInfoList(void)
 775 {
 776         if (__pLocalDevice == null)
 777         {
 778                 return E_FAILURE;
 779         }
 780
 781         if ((GetLocalDeviceGroupMemberType() == WIFI_DIRECT_GROUP_MEMBER_TYPE_NONE)
 782                 || (IsActivated() == false))
 783         {
 784                 return E_INVALID_CONNECTION;
 785         }
 786
 787         WifiDirectGroupMember* pLocalGroupMember = __pLocalDevice->GetWifiDirectMemberN();
 788
 789         if ((pLocalGroupMember == null)
 790                 || (IsFailed(GetLastResult())))
 791         {
 792                 if (!IsFailed(GetLastResult()))
 793                 {
 794                         SetLastResult(E_FAILURE);
 795                 }
 796
 797                 delete pLocalGroupMember;
 798                 return GetLastResult();
 799         }
 800
 801         result r = E_SUCCESS;
 802         if (pLocalGroupMember->GetGroupMemberType() == WIFI_DIRECT_GROUP_MEMBER_TYPE_OWNER)
 803         {
 804                 r = SetAllGroupMemberListInfoByOwner(pLocalGroupMember);
 805                 SendToEventListener(WIFI_DIRECT_MANAGER_EVENT_REQUESTED_ALL_GROUP_MEMBER_INFO_RECEIVED_N, r);
 806         }
 807         else if (pLocalGroupMember->GetGroupMemberType() == WIFI_DIRECT_GROUP_MEMBER_TYPE_CLIENT)
 808         {
 809                 WifiDirectGroupClient* pGroupClient = static_cast<WifiDirectGroupClient*>(pLocalGroupMember);
 810 #ifdef WIFI_DIRECT_MANAGER_DEBUG_CODE
 811                 r = pGroupClient->RequestAllGroupMemberInfo();
 812
 813                 if (IsFailed(r))
 814                 {
 815                         Deactivate();
 816                 }
 817                 AppLogDebug("groupMemberType : WIFI_DIRECT_GROUP_MEMBER_TYPE_CLIENT, ErrorMessage : %s]", GetErrorMessage(r));
 818 #endif
 819         }
 820
 821         delete pLocalGroupMember;
 822         return r;
 823 }
 824
 825 int
 826 WifiDirectManager::GetGroupMemberInfoListCount(void)
 827 {
 828         int groupMemberTotalCount = 0;
 829
 830         if ((__pLocalDevice == null)
 831                 || (__pAllGroupMemberListInfo == null))
 832         {
 833                 if (__pLocalDevice == null)
 834                 {
 835                         SetLastResult(E_FAILURE);
 836                 }
 837                 else
 838                 {
 839                         SetLastResult(E_INVALID_OPERATION);
 840                 }
 841                 return groupMemberTotalCount;
 842         }
 843
 844         groupMemberTotalCount = __pAllGroupMemberListInfo->GetCount();
 845
 846         return groupMemberTotalCount;
 847 }
 848
 849 void
 850 WifiDirectManager::InitAllGroupMemberListInfo(void)
 851 {
 852         if (__pAllGroupMemberListInfo != null)
 853         {
 854                 __pAllGroupMemberListInfo->RemoveAll();
 855                 delete __pAllGroupMemberListInfo;
 856                 __pAllGroupMemberListInfo = null;
 857         }
 858 }
 859
 860 void
 861 WifiDirectManager::InitScanDeviceInfoList(void)
 862 {
 863         if (__pScanDeviceInfoList != null)
 864         {
 865                 delete __pScanDeviceInfoList;
 866                 __pScanDeviceInfoList = null;
 867         }
 868 }
 869
 870 void
 871 WifiDirectManager::InitBusyDeviceInfoList(void)
 872 {
 873         if (__pBusyDeviceInfoList != null)
 874         {
 875                 delete __pBusyDeviceInfoList;
 876                 __pBusyDeviceInfoList = null;
 877         }
 878 }
 879
 880 result
 881 WifiDirectManager::DivideDeviceInfoListToBusyAndScan(Tizen::Base::Collection::IList* pDeviceInfoList)
 882 {
 883         result r = E_SUCCESS;
 884         WifiDirectDeviceInfo* pDeviceInfo = null;
 885         ArrayList* pScanDeviceInfoList = null;
 886         ArrayList* pBusyDeviceInfoList = null;
 887
 888         InitScanDeviceInfoList();
 889         InitBusyDeviceInfoList();
 890
 891         if (pDeviceInfoList == null)
 892         {
 893                 return E_INVALID_ARG;
 894         }
 895
 896         pScanDeviceInfoList = new (std::nothrow) ArrayList(SingleObjectDeleter);
 897         r = pScanDeviceInfoList->Construct();
 898         if (IsFailed(r))
 899         {
 900                 AppLogDebug("pScanDeviceInfoList->Construct() failed(%s)",GetErrorMessage(r));
 901                 delete pScanDeviceInfoList;
 902                 return r;
 903         }
 904
 905         pBusyDeviceInfoList = new (std::nothrow) ArrayList(SingleObjectDeleter);
 906         r = pBusyDeviceInfoList->Construct();
 907         if (IsFailed(r))
 908         {
 909                 AppLogDebug("pBusyDeviceInfoList->Construct() failed(%s)",GetErrorMessage(r));
 910                 delete pBusyDeviceInfoList;
 911                 delete pScanDeviceInfoList;
 912                 pBusyDeviceInfoList = null;
 913                 pScanDeviceInfoList = null;
 914                 return r;
 915         }
 916
 917         int deviceInfoListCount = pDeviceInfoList->GetCount();
 918         if (deviceInfoListCount == 0)
 919         {
 920                 delete pBusyDeviceInfoList;
 921                 delete pScanDeviceInfoList;
 922                 pBusyDeviceInfoList = null;
 923                 pScanDeviceInfoList = null;
 924                 return r;
 925         }
 926
 927         for (int loopCount = 0; loopCount < deviceInfoListCount; loopCount++)
 928         {
 929                 pDeviceInfo = static_cast<WifiDirectDeviceInfo*>(pDeviceInfoList->GetAt(loopCount));
 930                 if (IsFailed(GetLastResult()))
 931                 {
 932                         AppLogDebug("pDeviceInfoList->GetAt failed(%s)",GetErrorMessage(GetLastResult()));
 933                         break;
 934                 }
 935
 936                 switch (pDeviceInfo->GetGroupMemberType())
 937                 {
 938                 case WIFI_DIRECT_GROUP_MEMBER_TYPE_NONE:
 939                         //fall through
 940                 case WIFI_DIRECT_GROUP_MEMBER_TYPE_OWNER:
 941                         {
 942                                 pScanDeviceInfoList->Add(new (std::nothrow) WifiDirectDeviceInfo(*pDeviceInfo));
 943                                 pDeviceInfo = null;
 944                         }
 945                         break;
 946
 947                 case WIFI_DIRECT_GROUP_MEMBER_TYPE_CLIENT:
 948                         {
 949                                 pBusyDeviceInfoList->Add(new (std::nothrow) WifiDirectDeviceInfo(*pDeviceInfo));
 950                                 pDeviceInfo = null;
 951                         }
 952                         break;
 953
 954                 default:
 955                         {
 956                                 AppLogDebug("unknown GroupMemberType [MemberType : %d , DeviceName : %ls]", pDeviceInfo->GetGroupMemberType(), pDeviceInfo->GetDeviceName().GetPointer());
 957                         }
 958                         break;
 959                 }
 960         }
 961
 962         if (!IsFailed(r))
 963         {
 964                 __pScanDeviceInfoList = pScanDeviceInfoList;
 965                 __pBusyDeviceInfoList = pBusyDeviceInfoList;
 966         }
 967
 968         return r;
 969 }
 970
 971 result
 972 WifiDirectManager::RemoveLocalGroupMemberFromAllGroupMemberListInfo(Tizen::Base::Collection::IList* pAllGroupMemberListInfo)
 973 {
 974         if (pAllGroupMemberListInfo == null)
 975         {
 976                 return E_FAILURE;
 977         }
 978
 979         WifiDirectDeviceInfo* pDeviceInfo = static_cast<WifiDirectDeviceInfo*>(pAllGroupMemberListInfo->GetAt(0));
 980         result r = E_FAILURE;
 981         if ((pDeviceInfo != null)
 982                 || (!IsFailed(GetLastResult())))
 983         {
 984                 if (pDeviceInfo->GetDeviceName().Equals(GetLocalDeviceName(), false))
 985                 {
 986                         pAllGroupMemberListInfo->RemoveAt(0, true);
 987                         r = E_SUCCESS;
 988                 }
 989         }
 990
 991         return r;
 992 }
 993
 994 void
 995 WifiDirectManager::OnWifiDirectAssociationCompleted(WifiDirectDeviceId localDeviceId, const WifiDirectDeviceInfo& wifiDirectGroupOwnerDeviceInfo, result r)
 996 {
 997         if (!IsFailed(r))
 998         {
 999                 InitAllGroupMemberListInfo();
1000                 InitScanDeviceInfoList();
1001                 InitBusyDeviceInfoList();
1002                 r = AddGroupMemberDeviceInfo(wifiDirectGroupOwnerDeviceInfo);
1003         }
1004         SendToEventListener(WIFI_DIRECT_MANAGER_EVENT_ASSOCIATION_COMPLETED, r);
1005 }
1006
1007 void
1008 WifiDirectManager::OnWifiDirectDeviceActivated(WifiDirectDeviceId localDeviceId, result r)
1009 {
1010         if (!IsFailed(r))
1011         {
1012                 InitScanDeviceInfoList();
1013                 InitBusyDeviceInfoList();
1014         }
1015
1016         SendToEventListener(WIFI_DIRECT_MANAGER_EVENT_DEVICE_ACTIVATED, r);
1017 }
1018
1019 void
1020 WifiDirectManager::OnWifiDirectDeviceDeactivated(WifiDirectDeviceId localDeviceId, result r)
1021 {
1022         if (!IsFailed(r))
1023         {
1024                 InitAllGroupMemberListInfo();
1025                 InitScanDeviceInfoList();
1026                 InitBusyDeviceInfoList();
1027         }
1028
1029         SendToEventListener(WIFI_DIRECT_MANAGER_EVENT_DEVICE_DEACTIVATED, r);
1030 }
1031
1032 void
1033 WifiDirectManager::OnWifiDirectGroupCreatedN(WifiDirectDeviceId localDeviceId, const WifiDirectGroupInfo& wifiDirectGroupInfo,
1034                                                                                                 const WifiDirectDeviceInfo& wifiDirectGroupOwnerDeviceInfo, WifiDirectGroupMember* pWifiDirectMember, result r)
1035 {
1036         if (!IsFailed(r))
1037         {
1038                 InitAllGroupMemberListInfo();
1039                 InitScanDeviceInfoList();
1040                 InitBusyDeviceInfoList();
1041
1042                 if (pWifiDirectMember->GetGroupMemberType() == WIFI_DIRECT_GROUP_MEMBER_TYPE_OWNER)
1043                 {
1044                         r = SetAllGroupMemberListInfoByOwner(pWifiDirectMember);
1045                 }
1046                 else
1047                 {
1048                         r = AddGroupMemberDeviceInfo(wifiDirectGroupOwnerDeviceInfo);
1049 #ifdef WIFI_DIRECT_MANAGER_BUG_REPORT
1050                         AppLogDebug("WIFI_DIRECT_MANAGER_BUG_REPORT LocalDeviceGroupMemberType [%d] GroupOwner DeviceName [%ls]", GetLocalDeviceGroupMemberType(), wifiDirectGroupOwnerDeviceInfo.GetDeviceName().GetPointer());
1051 #endif
1052                 }
1053
1054                 delete pWifiDirectMember;
1055         }
1056         SendToEventListener(WIFI_DIRECT_MANAGER_EVENT_GROUP_CREATED_N, r);
1057 }
1058
1059 result
1060 WifiDirectManager::SetAllGroupMemberListInfoByOwner(Tizen::Net::Wifi::WifiDirectGroupMember* groupMember)
1061 {
1062         result r = E_SUCCESS;
1063
1064         if (groupMember->GetGroupMemberType() == WIFI_DIRECT_GROUP_MEMBER_TYPE_OWNER)
1065         {
1066                 if (__pAllGroupMemberListInfo != null)
1067                 {
1068                         InitAllGroupMemberListInfo();
1069                 }
1070
1071                 WifiDirectGroupOwner* pGroupOwner = static_cast<WifiDirectGroupOwner*>(groupMember);
1072
1073                 __pAllGroupMemberListInfo = pGroupOwner->GetAllGroupMemberInfoListN();
1074
1075                 if ((__pAllGroupMemberListInfo == null)
1076                         || (IsFailed(GetLastResult())))
1077                 {
1078                         if (!IsFailed(GetLastResult()))
1079                         {
1080                                 r = E_FAILURE;
1081                         }
1082
1083                         InitAllGroupMemberListInfo();
1084                 }
1085                 else
1086                 {
1087                         RemoveLocalGroupMemberFromAllGroupMemberListInfo(__pAllGroupMemberListInfo);
1088                 }
1089         }
1090         else
1091         {
1092                 AppLogDebug("groupMeberType : %d][%s]", groupMember->GetGroupMemberType());
1093                 r = E_INVALID_ARG;
1094         }
1095
1096         return r;
1097 }
1098
1099 result
1100 WifiDirectManager::AddGroupMemberDeviceInfo(const Tizen::Net::Wifi::WifiDirectDeviceInfo& deviceInfo)
1101 {
1102         result r = E_SUCCESS;
1103         ArrayList* pDeviceListInfo = null;
1104
1105         if (__pAllGroupMemberListInfo != null)
1106         {
1107                 __pAllGroupMemberListInfo->Add(*(new (std::nothrow) WifiDirectDeviceInfo(deviceInfo)));
1108                 return r;
1109         }
1110
1111         pDeviceListInfo = new (std::nothrow) ArrayList();
1112         r = pDeviceListInfo->Construct();
1113
1114         if ((pDeviceListInfo == null)
1115                 ||(IsFailed(r)))
1116         {
1117                 delete pDeviceListInfo;
1118                 r = E_FAILURE;
1119         }
1120
1121         if (!IsFailed(r))
1122         {
1123                 pDeviceListInfo->Add(new (std::nothrow) WifiDirectDeviceInfo(deviceInfo));
1124                 __pAllGroupMemberListInfo = pDeviceListInfo;
1125         }
1126
1127         return r;
1128 }
1129
1130 void
1131 WifiDirectManager::OnWifiDirectScanCompletedN(Tizen::Net::Wifi::WifiDirectDeviceId localDeviceId,
1132                                                                                                 Tizen::Base::Collection::IList* pWifiDirectDeviceInfoList, result r)
1133 {
1134         if (!IsFailed(r)
1135                 || (r == E_OPERATION_CANCELED))
1136         {
1137                 InitScanDeviceInfoList();
1138                 InitBusyDeviceInfoList();
1139                 DivideDeviceInfoListToBusyAndScan(pWifiDirectDeviceInfoList);
1140
1141                 if (pWifiDirectDeviceInfoList != null)
1142                 {
1143                         pWifiDirectDeviceInfoList->RemoveAll();
1144                         delete pWifiDirectDeviceInfoList;
1145                 }
1146                 r = E_SUCCESS;
1147         }
1148         else
1149         {
1150                 InitScanDeviceInfoList();
1151                 InitBusyDeviceInfoList();
1152         }
1153
1154         SendToEventListener(WIFI_DIRECT_MANAGER_EVENT_SCAN_COMPLETED_N, r);
1155 }
1156
1157 void
1158 WifiDirectManager::OnWifiDirectAssociationTerminated(WifiDirectDeviceId localDeviceId, WifiDirectAssociationTerminationReason reason, result r)
1159 {
1160         InitAllGroupMemberListInfo();
1161         InitScanDeviceInfoList();
1162         InitBusyDeviceInfoList();
1163
1164         SendToEventListener(WIFI_DIRECT_MANAGER_EVENT_ASSOCITION_TERMINATED, r);
1165 }
1166
1167 void
1168 WifiDirectManager::OnWifiDirectAllGroupMemberInfoReceivedN(WifiDirectDeviceId localDeviceId,
1169                         Tizen::Base::Collection::IList* pWifiDirectDeviceInfoList, result r)
1170 {
1171         if (!IsFailed(r))
1172         {
1173                 InitAllGroupMemberListInfo();
1174                 __pAllGroupMemberListInfo = pWifiDirectDeviceInfoList;
1175                 RemoveLocalGroupMemberFromAllGroupMemberListInfo(__pAllGroupMemberListInfo);
1176         }
1177
1178         SendToEventListener(WIFI_DIRECT_MANAGER_EVENT_ALL_GROUP_MEMBER_INFO_RECEIVED_N, r);
1179 }
1180
1181 void
1182 WifiDirectManager::OnWifiDirectGroupOwnerInfoReceived(Tizen::Net::Wifi::WifiDirectDeviceId localDeviceId, const WifiDirectDeviceInfo& wifiDirectGroupOwnerDeviceInfo, result r)
1183 {
1184         SendToEventListener(WIFI_DIRECT_MANAGER_EVENT_GROUP_OWNER_INFO_RECEIVED, r);
1185 }
1186
1187 void
1188 WifiDirectManager::OnWifiDirectClientAssociated(WifiDirectDeviceId localDeviceId, const WifiDirectDeviceInfo& wifiDirectClientInfo)
1189 {
1190         result r = AddGroupMemberDeviceInfo(wifiDirectClientInfo);
1191         SendToEventListener(WIFI_DIRECT_MANAGER_EVENT_CLIENT_ASSOCIATED, r);
1192 }
1193
1194 void
1195 WifiDirectManager::OnWifiDirectClientDisassociated(WifiDirectDeviceId localDeviceId, const WifiDirectDeviceInfo& wifiDirectClientInfo, WifiDirectAssociationTerminationReason reason)
1196 {
1197         result r = E_SUCCESS;
1198         if (__pAllGroupMemberListInfo != null)
1199         {
1200                 WifiDirectDeviceInfo* pDeviceInfo = null;
1201                 int pAllGroupMemberListInfoCount = __pAllGroupMemberListInfo->GetCount();
1202                 for (int loopCount = 0; loopCount < pAllGroupMemberListInfoCount; loopCount++)
1203                 {
1204                         pDeviceInfo = static_cast<WifiDirectDeviceInfo*>(__pAllGroupMemberListInfo->GetAt(loopCount));
1205                         if ((pDeviceInfo == null)
1206                                 || (IsFailed(GetLastResult())))
1207                         {
1208                                 r = E_FAILURE;
1209                                 break;
1210                         }
1211
1212                         if (pDeviceInfo->Equals(wifiDirectClientInfo) == true)
1213                         {
1214                                 __pAllGroupMemberListInfo->RemoveAt(loopCount, true);
1215                                 break;
1216                         }
1217                 }
1218         }
1219
1220         SendToEventListener(WIFI_DIRECT_MANAGER_EVENT_CLIENT_DISASSOCIATED, r);
1221 }
1222
1223 void
1224 WifiDirectManager::OnWifiDirectGroupDestroyed(WifiDirectDeviceId localDeviceId, result r)
1225 {
1226         InitAllGroupMemberListInfo();
1227         InitScanDeviceInfoList();
1228         InitBusyDeviceInfoList();
1229
1230         SendToEventListener(WIFI_DIRECT_MAMAGER_EVENT_GROUP_DESTRORYED, r);
1231  }
1232
1233 void
1234 WifiDirectManager::OnWifiDirectGroupMemberInfoServiceStarted(Tizen::Net::Wifi::WifiDirectDeviceId localDeviceId, const Tizen::Net::NetConnection* pNetConnection, result r)
1235 {
1236         SendToEventListener(WIFI_DIRECT_MANAGER_EVENT_GROUP_MEMBER_INFO_SERVICE_STARTED, r);
1237 }
1238
1239 void
1240 WifiDirectManager::OnWifiDirectGroupMemberInfoServiceStopped(Tizen::Net::Wifi::WifiDirectDeviceId localDeviceId, result r)
1241 {
1242         SendToEventListener(WIFI_DIRECT_MANAGER_EVENT_GROUP_MEMBER_INFO_SERVICE_STOPPED, r);
1243 }