src/wifi/FNetWifi_WifiProximityManagerImpl.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_WifiProximityManagerImpl.cpp
  20  * @brief   This is the implementation file for the _WifiProximityManagerImpl Class.
  21  *
  22  * This file contains the implementation of the _WifiProximityManagerImpl Class.
  23  */
  24
  25 #include <pthread.h>
  26 #include <unique_ptr.h>
  27 #include <FBaseDataType.h>
  28 #include <FBaseString.h>
  29 #include <FBaseStringComparer.h>
  30 #include <FBaseStringHashCodeProvider.h>
  31 #include <FBaseSysLog.h>
  32 #include <FBaseColIListT.h>
  33 #include <FBaseColHashMapT.h>
  34 #include <FBaseColMultiHashMapT.h>
  35 #include <FBaseColIEnumeratorT.h>
  36 #include <FNetWifiWifiBssInfo.h>
  37 #include "FNetWifi_IWifiProximityEventListener.h"
  38 #include "FNetWifi_WifiProximityManagerImpl.h"
  39 #include "FNetWifi_WifiIpcProxy.h"
  40
  41 using namespace std;
  42 using namespace Tizen::Base;
  43 using namespace Tizen::Base::Collection;
  44
  45 namespace Tizen { namespace Net { namespace Wifi
  46 {
  47
  48
  49 _WifiProximityManagerImpl* _WifiProximityManagerImpl::__pWifiProximityManagerImpl = null;
  50
  51 _WifiProximityManagerImpl*
  52 _WifiProximityManagerImpl::GetInstance(void)
  53 {
  54     static pthread_once_t onceBlock = PTHREAD_ONCE_INIT;
  55
  56     if (!__pWifiProximityManagerImpl)
  57     {
  58         ClearLastResult();
  59         pthread_once(&onceBlock, InitSingleton);
  60
  61         result r = GetLastResult();
  62
  63         if (IsFailed(r))
  64         {
  65              onceBlock = PTHREAD_ONCE_INIT;
  66         }
  67     }
  68
  69     return __pWifiProximityManagerImpl;
  70 }
  71
  72 void
  73 _WifiProximityManagerImpl::InitSingleton(void)
  74 {
  75     result r = E_SUCCESS;
  76
  77     unique_ptr<_WifiProximityManagerImpl> pInst(new (std::nothrow) _WifiProximityManagerImpl());
  78     SysTryReturnVoidResult(NID_NET_WIFI, pInst != null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
  79
  80     r = pInst->Construct();
  81     SysTryReturnVoidResult(NID_NET_WIFI, r == E_SUCCESS, r, "[%s] Construct() of the singleton has failed.", GetErrorMessage(r));
  82
  83     __pWifiProximityManagerImpl = pInst.release();
  84 }
  85
  86 _WifiProximityManagerImpl::_WifiProximityManagerImpl(void)
  87         : __pListenerStateMap(null)
  88         , __pWifiServiceProxy(null)
  89 {
  90 }
  91
  92 _WifiProximityManagerImpl::~_WifiProximityManagerImpl(void)
  93 {
  94         __pWifiServiceProxy->SetWifiProximityManagerImpl(null);
  95         delete __pListenerStateMap;
  96         delete __pBssListenerMap;
  97 }
  98
  99 result
 100 _WifiProximityManagerImpl::Construct(void)
 101 {
 102         result r = E_SUCCESS;
 103         unique_ptr< HashMapT< _IWifiProximityEventListener*, bool > > pTempMap;
 104         unique_ptr< MultiHashMapT< String, _IWifiProximityEventListener* > > pTempMultiMap;
 105         static StringHashCodeProvider strHashCodeProvider;
 106         static ComparerT<String> strComparer;
 107
 108         pTempMap.reset(new (std::nothrow) HashMapT<_IWifiProximityEventListener*, bool>());
 109         SysTryReturnResult(NID_NET_WIFI, pTempMap != null, E_OUT_OF_MEMORY, "Memory allocation failed.");
 110
 111         r = pTempMap->Construct();
 112     r = TransExceptionsExclusive(r, E_SYSTEM, E_OUT_OF_MEMORY);
 113         SysTryReturnResult(NID_NET_WIFI, r == E_SUCCESS, r, "Construct of the listener hash map has failed.");
 114
 115         pTempMultiMap.reset(new (std::nothrow) MultiHashMapT<String, _IWifiProximityEventListener*>());
 116         SysTryReturnResult(NID_NET_WIFI, pTempMultiMap != null, E_OUT_OF_MEMORY, "Memory allocation failed.");
 117
 118         r = pTempMultiMap->Construct(16, 0.75f, strHashCodeProvider, strComparer);
 119     r = TransExceptionsExclusive(r, E_SYSTEM, E_OUT_OF_MEMORY);
 120         SysTryReturnResult(NID_NET_WIFI, r == E_SUCCESS, r, "Construct of the listener hash map has failed.");
 121
 122     __pWifiServiceProxy = _WifiIpcProxy::GetInstance();
 123     SysTryReturnResult(NID_NET_WIFI, __pWifiServiceProxy != null, E_SYSTEM, "Getting WifiIpcProxy instance has failed.");
 124
 125     __pWifiServiceProxy->SetWifiProximityManagerImpl(this);
 126
 127     __pListenerStateMap = pTempMap.release();
 128     __pBssListenerMap = pTempMultiMap.release();
 129
 130         return r;
 131 }
 132
 133 result
 134 _WifiProximityManagerImpl::AddProximityEventListener(_IWifiProximityEventListener& listener, const Tizen::Base::String& bssId)
 135 {
 136         result r = E_SUCCESS;
 137         bool contains = false;
 138
 139         // register the listener with an empty string as the BSS ID
 140         if (bssId.GetLength() == 0)
 141         {
 142                 contains = __pListenerStateMap->ContainsValue(true);
 143                 // the specified listener is the first listener in this process when it comes to an empty string.
 144                 if (!contains)
 145                 {
 146                         r = __pWifiServiceProxy->RegisterBssId(L"");
 147                         r = TransExceptionsExclusive(r, E_SYSTEM, E_OUT_OF_MEMORY);
 148                         SysTryReturnResult(NID_NET_WIFI, r == E_SUCCESS, r,
 149                                         "Registering the listener regardless of BSS ID to IPC instance has failed.");
 150                 }
 151
 152                 __pListenerStateMap->ContainsKey(&listener, contains);
 153                 if (contains)
 154                 {
 155                         bool isDefault = false;
 156
 157                         __pListenerStateMap->GetValue(&listener, isDefault);
 158                         SysTryReturnResult(NID_NET_WIFI, isDefault == false, E_OBJ_ALREADY_EXIST, "The listener was already registered.");
 159
 160                         __pListenerStateMap->SetValue(&listener, true);
 161                 }
 162                 else
 163                 {
 164                         r = __pListenerStateMap->Add(&listener, true);
 165                         r = TransExceptionsExclusive(r, E_SYSTEM, E_OUT_OF_MEMORY);
 166                         SysTryReturnResult(NID_NET_WIFI, r == E_SUCCESS, r, "Propagating. Internal map error.");
 167                 }
 168         }
 169         // register the listener with the specified BSS ID (not an empty string)
 170         else
 171         {
 172                 __pBssListenerMap->ContainsKey(bssId, contains);
 173                 if (!contains)
 174                 {
 175                         r = __pWifiServiceProxy->RegisterBssId(bssId);
 176                         r = TransExceptionsExclusive(r, E_SYSTEM, E_OUT_OF_MEMORY);
 177                         SysTryReturnResult(NID_NET_WIFI, r == E_SUCCESS, r,
 178                                         "Registering BSS ID and listener to IPC instance has failed.");
 179                 }
 180
 181                 r = __pBssListenerMap->Add(bssId, &listener);
 182                 r = TransExceptionsExclusive(r, E_SYSTEM, E_OBJ_ALREADY_EXIST, E_OUT_OF_MEMORY);
 183                 SysTryReturnResult(NID_NET_WIFI, r == E_SUCCESS, r, "Propagating. Internal map error.");
 184
 185                 __pListenerStateMap->ContainsKey(&listener, contains);
 186                 if (!contains)
 187                 {
 188                         r = __pListenerStateMap->Add(&listener, false);
 189                         r = TransExceptionsExclusive(r, E_SYSTEM, E_OUT_OF_MEMORY);
 190                         SysTryReturnResult(NID_NET_WIFI, r == E_SUCCESS, r, "Propagating. Internal map error.");
 191                 }
 192         }
 193
 194         return E_SUCCESS;
 195 }
 196
 197 result
 198 _WifiProximityManagerImpl::RemoveProximityEventListener(_IWifiProximityEventListener& listener, const Tizen::Base::String& bssId)
 199 {
 200         result r = E_SUCCESS;
 201         bool contains = false;
 202
 203         // unregister the listener with an empty string as the BSS ID
 204         if (bssId.GetLength() == 0)
 205         {
 206                 __pListenerStateMap->ContainsKey(&listener, contains);
 207                 SysTryReturnResult(NID_NET_WIFI, contains == true, E_OBJ_NOT_FOUND, "The listener was not registered.");
 208
 209                 __pListenerStateMap->Remove(&listener);
 210
 211                 unique_ptr< IMapEnumeratorT<String, _IWifiProximityEventListener*> > pMapEnum(__pBssListenerMap->GetMapEnumeratorN());
 212                 SysTryReturnResult(NID_NET_WIFI, pMapEnum != null, E_OUT_OF_MEMORY, "Propagating. Internal map error.");
 213
 214                 while(pMapEnum->MoveNext() == E_SUCCESS)
 215                 {
 216                         String regBssId;
 217                         _IWifiProximityEventListener* pRegListener = null;
 218
 219                         r = pMapEnum->GetKey(regBssId);
 220                         r = TransExceptionsExclusive(r, E_SYSTEM, E_OUT_OF_MEMORY);
 221                         SysTryReturnResult(NID_NET_WIFI, r == E_SUCCESS, r, "Internal map error.");
 222
 223                         r = pMapEnum->GetValue(pRegListener);
 224                         r = TransExceptionsExclusive(r, E_SYSTEM, E_OUT_OF_MEMORY);
 225                         SysTryReturnResult(NID_NET_WIFI, r == E_SUCCESS, r, "Internal map error.");
 226
 227                         if (pRegListener == &listener)
 228                         {
 229                                 __pBssListenerMap->Remove(regBssId, pRegListener);
 230                                 SysLog(NID_NET_WIFI, "BSS(ID:%d) is removed from the internal map.", regBssId.GetPointer());
 231
 232                                 __pBssListenerMap->ContainsKey(regBssId, contains);
 233                                 if (!contains)
 234                                 {
 235                                         r = __pWifiServiceProxy->UnRegisterBssId(regBssId);
 236                                         r = TransExceptionsExclusive(r, E_SYSTEM, E_OUT_OF_MEMORY);
 237                                         SysTryReturnResult(NID_NET_WIFI, r == E_SUCCESS, r,
 238                                                         "Unregistering BSS ID and listener to IPC instance has failed.");
 239                                 }
 240                         }
 241                 }
 242
 243                 contains = __pListenerStateMap->ContainsValue(true);
 244                 // the specified listener is the last listener in this process when it comes to an empty string.
 245                 if (!contains)
 246                 {
 247                         r = __pWifiServiceProxy->UnRegisterBssId(L"");
 248                         r = TransExceptionsExclusive(r, E_SYSTEM, E_OUT_OF_MEMORY);
 249                         SysTryReturnResult(NID_NET_WIFI, r == E_SUCCESS, r,
 250                                         "Unregistering the listener regardless of BSS ID to IPC instance has failed.");
 251                 }
 252         }
 253         // unregister the listener with the specified BSS ID (not an empty string)
 254         else
 255         {
 256                 r = __pBssListenerMap->Remove(bssId, &listener);
 257                 r = TransExceptionsExclusive(r, E_SYSTEM, E_OBJ_NOT_FOUND);
 258                 SysTryReturnResult(NID_NET_WIFI, r == E_SUCCESS, r, "Propagating.");
 259                 SysLog(NID_NET_WIFI, "BSS(ID:%d) is removed from the internal map.", bssId.GetPointer());
 260
 261                 __pBssListenerMap->ContainsKey(bssId, contains);
 262                 if (!contains)
 263                 {
 264                         r = __pWifiServiceProxy->UnRegisterBssId(bssId);
 265                         r = TransExceptionsExclusive(r, E_SYSTEM, E_OUT_OF_MEMORY);
 266                         SysTryReturnResult(NID_NET_WIFI, r == E_SUCCESS, r,
 267                                         "Unregistering BSS ID and listener to IPC instance has failed.");
 268                 }
 269
 270                 __pListenerStateMap->ContainsKey(&listener, contains);
 271                 if (contains)
 272                 {
 273                         bool isDefault = false;
 274
 275                         __pListenerStateMap->GetValue(&listener, isDefault);
 276                         if (!isDefault)
 277                         {
 278                                 __pListenerStateMap->Remove(&listener);
 279                         }
 280                 }
 281         }
 282
 283         return E_SUCCESS;
 284 }
 285
 286 result
 287 _WifiProximityManagerImpl::ActivateProximityCheck(void)
 288 {
 289         result r = E_SUCCESS;
 290
 291     r = __pWifiServiceProxy->ActivateProximityCheck();
 292         SysTryReturnResult(NID_NET_WIFI, r == E_SUCCESS, r, "Propagating.");
 293
 294         return r;
 295 }
 296
 297 result
 298 _WifiProximityManagerImpl::DeactivateProximityCheck(void)
 299 {
 300         result r = E_SUCCESS;
 301
 302     r = __pWifiServiceProxy->DeactivateProximityCheck();
 303         SysTryReturnResult(NID_NET_WIFI, r == E_SUCCESS, r, "Propagating.");
 304
 305         return r;
 306 }
 307
 308 bool
 309 _WifiProximityManagerImpl::IsProximityCheckActivated(void)
 310 {
 311         bool isActivated = false;
 312     result r = E_SUCCESS;
 313
 314     r = __pWifiServiceProxy->IsProximityCheckActivated(isActivated);
 315         SysTryReturn(NID_NET_WIFI, r == E_SUCCESS, false, r, "[%s] Propagating.", GetErrorMessage(r));
 316
 317     return isActivated;
 318 }
 319
 320 void
 321 _WifiProximityManagerImpl::OnWifiBssDetected(const WifiBssInfo& wifiBssInfo)
 322 {
 323         result r = E_SUCCESS;
 324         unique_ptr< IEnumeratorT<_IWifiProximityEventListener*> > pValueEnum(__pBssListenerMap->GetValuesN(wifiBssInfo.GetBssId()));
 325         SysTryReturnVoidResult(NID_NET_WIFI, pValueEnum != null, E_OUT_OF_MEMORY,
 326                         "[E_OUT_OF_MEMORY] Propagating. Internal map error.");
 327
 328         while (pValueEnum->MoveNext() == E_SUCCESS)
 329         {
 330                 _IWifiProximityEventListener* pListener = null;
 331
 332                 r = pValueEnum->GetCurrent(pListener);
 333                 r = TransExceptionsExclusive(r, E_SYSTEM, E_OUT_OF_MEMORY);
 334                 SysTryReturnVoidResult(NID_NET_WIFI, r == E_SUCCESS, r, "[E_SYSTEM] Internal map error.");
 335
 336                 pListener->OnWifiBssDetectedN(new WifiBssInfo(wifiBssInfo));
 337         }
 338 }
 339
 340 void
 341 _WifiProximityManagerImpl::OnWifiBssLost(const Tizen::Base::String& bssId)
 342 {
 343         result r = E_SUCCESS;
 344         unique_ptr< IEnumeratorT<_IWifiProximityEventListener*> > pValueEnum(__pBssListenerMap->GetValuesN(bssId));
 345         SysTryReturnVoidResult(NID_NET_WIFI, pValueEnum != null, E_OUT_OF_MEMORY,
 346                         "[E_OUT_OF_MEMORY] Propagating. Internal map error.");
 347
 348         while (pValueEnum->MoveNext() == E_SUCCESS)
 349         {
 350                 _IWifiProximityEventListener* pListener = null;
 351
 352                 r = pValueEnum->GetCurrent(pListener);
 353                 r = TransExceptionsExclusive(r, E_SYSTEM, E_OUT_OF_MEMORY);
 354                 SysTryReturnVoidResult(NID_NET_WIFI, r == E_SUCCESS, r, "[E_SYSTEM] Internal map error.");
 355
 356                 pListener->OnWifiBssLost(bssId);
 357         }
 358 }
 359
 360 void
 361 _WifiProximityManagerImpl::OnWifiProximityCheckActivated()
 362 {
 363         unique_ptr< IListT<_IWifiProximityEventListener*> > pListenerList;
 364         int count = 0;
 365
 366         pListenerList.reset(__pListenerStateMap->GetKeysN());
 367         SysTryReturnVoidResult(NID_NET_WIFI, pListenerList != null, E_OUT_OF_MEMORY,
 368                         "[E_OUT_OF_MEMORY] Propagating. Internal map error.");
 369         count = pListenerList->GetCount();
 370
 371         for (int i = 0; i < count; i++)
 372         {
 373                 result r = E_SUCCESS;
 374                 _IWifiProximityEventListener* pListener = null;
 375
 376                 r = pListenerList->GetAt(i, pListener);
 377                 r = TransExceptionsExclusive(r, E_SYSTEM, E_OUT_OF_MEMORY);
 378                 SysTryReturnVoidResult(NID_NET_WIFI, r == E_SUCCESS, r, "[E_SYSTEM] Internal map error.");
 379
 380                 pListener->OnWifiProximityCheckActivated();
 381         }
 382 }
 383
 384 void
 385 _WifiProximityManagerImpl::OnWifiProximityCheckDeactivated()
 386 {
 387         unique_ptr< IListT<_IWifiProximityEventListener*> > pListenerList;
 388         int count = 0;
 389
 390         pListenerList.reset(__pListenerStateMap->GetKeysN());
 391         SysTryReturnVoidResult(NID_NET_WIFI, pListenerList != null, E_OUT_OF_MEMORY,
 392                         "[E_OUT_OF_MEMORY] Propagating. Internal map error.");
 393         count = pListenerList->GetCount();
 394
 395         for (int i = 0; i < count; i++)
 396         {
 397                 result r = E_SUCCESS;
 398                 _IWifiProximityEventListener* pListener = null;
 399
 400                 r = pListenerList->GetAt(i, pListener);
 401                 r = TransExceptionsExclusive(r, E_SYSTEM, E_OUT_OF_MEMORY);
 402                 SysTryReturnVoidResult(NID_NET_WIFI, r == E_SUCCESS, r, "[E_SYSTEM] Internal map error.");
 403
 404                 pListener->OnWifiProximityCheckDeactivated();
 405         }
 406 }
 407
 408 } } } // Tizen::Net::Wifi