src/FUixSensor_SensorManagerImpl.cpp

   1 //
   2 // Open Service Platform
   3 // Copyright (c) 2012 Samsung Electronics Co., Ltd.
   4 //
   5 // Licensed under the Flora License, Version 1.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.tizenopensource.org/license
  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     FUixSensor_SensorManagerImpl.cpp
  20  * @brief    This is the implementation file for the %_SensorManagerImpl class.
  21  *
  22  * This files contains implementation of the %_SensorManagerImpl class.
  23  */
  24
  25 #include <new>
  26 #include <unique_ptr.h>
  27
  28 #include <FBaseString.h>
  29 #include <FBaseColHashMapT.h>
  30 #include <FBaseColIMapEnumeratorT.h>
  31 #include <FBaseSysLog.h>
  32
  33 #include <FUixSensorSensorManager.h>
  34 #include <FUixSensorISensorEventListener.h>
  35 #include <FUixSensorAccelerationSensorData.h>
  36 #include <FUixSensorMagneticSensorData.h>
  37 #include <FUixSensorProximitySensorData.h>
  38 #include <FUixSensorTiltSensorData.h>
  39 #include <FUixSensorGyroSensorData.h>
  40 #include <FUixSensorLightSensorData.h>
  41 #include <FUixSensorGravitySensorData.h>
  42 #include <FUixSensorUserAccelerationSensorData.h>
  43 #include <FUixSensorDeviceOrientationSensorData.h>
  44
  45 #include <FApp_AppInfo.h>
  46 #include <FUixSensor_SensorManagerImpl.h>
  47 #include "FUixSensor_SensorUtil.h"
  48 #include "FUixSensor_ISensorCore.h"
  49 #include "FUixSensor_SpecifiedSensorDataEventDelivererT.h"
  50
  51 using Tizen::App::_AppInfo;
  52
  53 namespace Tizen { namespace Uix { namespace Sensor
  54 {
  55 namespace
  56 {
  57 static const int INDEX_NONE = -1;
  58 static const int INDEX_FIRST = 0;
  59 static ISensorEventListener& INVALID_LISTENER = *static_cast<ISensorEventListener*>(0);
  60
  61 _SensorEventDeliverer*
  62 CreateSensorDataDelivererN(SensorType sensorType)
  63 {
  64         switch (sensorType)
  65         {
  66         case SENSOR_TYPE_ACCELERATION:
  67                 return new (std::nothrow) _SpecifiedSensorDataEventDelivererT<AccelerationSensorData>();
  68         case SENSOR_TYPE_MAGNETIC:
  69                 return new (std::nothrow) _SpecifiedSensorDataEventDelivererT<MagneticSensorData>();
  70         case SENSOR_TYPE_PROXIMITY:
  71                 return new (std::nothrow) _SpecifiedSensorDataEventDelivererT<ProximitySensorData>();
  72         case SENSOR_TYPE_TILT:
  73                 return new (std::nothrow) _SpecifiedSensorDataEventDelivererT<TiltSensorData>();
  74         case SENSOR_TYPE_GYRO:
  75                 return new (std::nothrow) _SpecifiedSensorDataEventDelivererT<GyroSensorData>();
  76         case SENSOR_TYPE_LIGHT:
  77                 return new (std::nothrow) _SpecifiedSensorDataEventDelivererT<LightSensorData>();
  78         case SENSOR_TYPE_GRAVITY:
  79                 return new (std::nothrow) _SpecifiedSensorDataEventDelivererT<GravitySensorData>();
  80         case SENSOR_TYPE_USER_ACCELERATION:
  81                 return new (std::nothrow) _SpecifiedSensorDataEventDelivererT<UserAccelerationSensorData>();
  82         case SENSOR_TYPE_DEVICE_ORIENTATION:
  83                 return new (std::nothrow) _SpecifiedSensorDataEventDelivererT<DeviceOrientationSensorData>();
  84         default:
  85                 SysAssertf(false, "CreateSensorDataDelivererN() > Invalid SensorType [sensorType:%d]", sensorType);
  86                 return null;
  87         }
  88 }
  89 } // Anonymous
  90
  91 // _SensorManagerImpl life-cycle ---------------------------------------------------------------------------------------------- //
  92 _SensorManagerImpl::_SensorManagerImpl(void)
  93         : __pDelivererListHashMap(null)
  94 {
  95
  96 }
  97
  98 _SensorManagerImpl::~_SensorManagerImpl(void)
  99 {
 100         Destruct();
 101 }
 102
 103 result
 104 _SensorManagerImpl::Construct(void)
 105 {
 106         std::unique_ptr<_SensorEventDelivererListHashMap> pHashMap(new (std::nothrow) _SensorEventDelivererListHashMap());
 107         SysTryReturn(NID_UIX, pHashMap != null, E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "Allocating new _SensorEventDelivererListHashMap failed.");
 108
 109         result r = pHashMap->Construct();
 110         SysTryReturn(NID_UIX, !IsFailed(r), r, r, "Constructing _SensorEventDelivererListHashMap failed."); // E_OUT_OF_MEMORY
 111
 112         __pDelivererListHashMap = pHashMap.release();
 113
 114         return E_SUCCESS;
 115 }
 116
 117 void
 118 _SensorManagerImpl::Destruct(void)
 119 {
 120         if (__pDelivererListHashMap != null)
 121         {
 122                 std::unique_ptr<_ISensorEventDelivererListHashMapEnumerator> pHashMapEnumeratorN(__pDelivererListHashMap->GetMapEnumeratorN());
 123                 if (pHashMapEnumeratorN != null)
 124                 {
 125                         _SensorEventDelivererList* pDelivererList = null;
 126                         while (pHashMapEnumeratorN->MoveNext() == E_SUCCESS)
 127                         {
 128                                 pHashMapEnumeratorN->GetValue(pDelivererList);
 129
 130                                 pDelivererList->RemoveAll(true);
 131
 132                                 delete pDelivererList;
 133                         }
 134                 }
 135                 else
 136                 {
 137                         _SensorEventDelivererList* pDelivererList = null;
 138                         for (int i = SENSOR_TYPE_NONE+1; i < SENSOR_TYPE_MAX; i++)
 139                         {
 140                                 if (IsFailed(__pDelivererListHashMap->GetValue(static_cast<SensorType>(i), pDelivererList)))
 141                                 {
 142                                         continue;
 143                                 }
 144
 145                                 pDelivererList->RemoveAll(true);
 146
 147                                 delete pDelivererList;
 148                         }
 149                 }
 150
 151                 __pDelivererListHashMap->RemoveAll();
 152                 delete __pDelivererListHashMap;
 153         }
 154 }
 155
 156 // Getting sensor information ------------------------------------------------------------------------------------------------- //
 157 bool
 158 _SensorManagerImpl::IsAvailable(SensorType sensorType) const
 159 {
 160         result r = _SensorUtil::CheckSensorTypeValidation(sensorType);
 161         if (IsFailed(r))
 162         {
 163                 return false;
 164         }
 165
 166         return true;
 167 }
 168
 169 result
 170 _SensorManagerImpl::GetDescription(SensorType sensorType, Tizen::Base::String& description) const
 171 {
 172         result r = _SensorUtil::CheckSensorTypeValidation(sensorType);
 173         if (IsFailed(r))
 174         {
 175                 return r;
 176         }
 177
 178         return _ISensorCore::GetDescription(sensorType, description);
 179 }
 180
 181 result
 182 _SensorManagerImpl::GetVendor(SensorType sensorType, Tizen::Base::String& vendor) const
 183 {
 184         result r = _SensorUtil::CheckSensorTypeValidation(sensorType);
 185         if (IsFailed(r))
 186         {
 187                 return r;
 188         }
 189
 190         return _ISensorCore::GetVendor(sensorType, vendor);
 191 }
 192
 193 result
 194 _SensorManagerImpl::GetModelId(SensorType sensorType, Tizen::Base::String& modelId) const
 195 {
 196         result r = _SensorUtil::CheckSensorTypeValidation(sensorType);
 197         if (IsFailed(r))
 198         {
 199                 return r;
 200         }
 201
 202         return _ISensorCore::GetModelId(sensorType, modelId);
 203 }
 204
 205 result
 206 _SensorManagerImpl::GetMeasurementRange(SensorType sensorType, float& min, float& max, float& resolution) const
 207 {
 208         result r = _SensorUtil::CheckSensorTypeValidation(sensorType);
 209         if (IsFailed(r))
 210         {
 211                 return r;
 212         }
 213
 214         return _ISensorCore::GetMeasurementRange(sensorType, min, max, resolution);
 215 }
 216
 217 result
 218 _SensorManagerImpl::GetIntervalRange(SensorType sensorType, long& min, long& max) const
 219 {
 220         result r = _SensorUtil::CheckSensorTypeValidation(sensorType);
 221         if (IsFailed(r))
 222         {
 223                 return r;
 224         }
 225
 226         return _ISensorCore::GetIntervalRange(sensorType, min, max);
 227 }
 228
 229
 230 // Sensor event listener management ------------------------------------------------------------------------------------------- //
 231 result
 232 _SensorManagerImpl::AddSensorEventListener(ISensorEventListener& listener, SensorType sensorType, long interval, bool dataChanged)
 233 {
 234         result r = _SensorUtil::CheckSensorTypeValidation(sensorType);
 235         if (IsFailed(r))
 236         {
 237                 return r;
 238         }
 239
 240         r = _SensorUtil::CheckIntervalValidation(sensorType, interval);
 241         if (IsFailed(r))
 242         {
 243                 return r;
 244         }
 245
 246         if (IsSensorTypeRegistered(sensorType))
 247         {
 248                 _SensorEventDelivererList* pDelivererList = null;
 249                 __pDelivererListHashMap->GetValue(sensorType, pDelivererList);
 250
 251                 int tempIndex = INDEX_NONE;
 252                 SysTryReturn(NID_UIX, !IsListenerRegistered(*pDelivererList, listener, tempIndex), E_USER_ALREADY_REGISTERED, E_USER_ALREADY_REGISTERED, "Invalid ISensorEventListener [sensorType:%d, listener:%p]", sensorType, &listener);
 253
 254                 std::unique_ptr<_SensorEventDeliverer> pDeliverer(CreateSensorDataDelivererN(sensorType));
 255                 SysTryReturn(NID_UIX, pDeliverer != null, E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "Allocating new _SensorEventDeliverer failed.");
 256
 257                 pDeliverer->SetDataEventInfo(listener, sensorType, interval, dataChanged);
 258
 259                 r = pDeliverer->Start();
 260                 SysTryReturn(NID_UIX, !IsFailed(r), r, r, "Starting _SensorEventDeliverer failed."); // E_OUT_OF_MEMORY or E_DEVICE_UNAVAILABLE
 261
 262                 r = pDelivererList->Add(*(pDeliverer.get()));
 263                 if (IsFailed(r))
 264                 {
 265                         // E_OUT_OF_MEMORY
 266                         SysLogException(NID_UIX, r, "Adding _SensorEventDeliverer failed.");
 267                         pDeliverer->Stop();
 268                         return r;
 269                 }
 270
 271                 pDeliverer.release();
 272         }
 273         else
 274         {
 275                 std::unique_ptr<_SensorEventDelivererList> pDelivererList(new (std::nothrow) _SensorEventDelivererList());
 276                 SysTryReturn(NID_UIX, pDelivererList != null, E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "Allocating new _SensorEventDelivererList failed.");
 277
 278                 r = pDelivererList->Construct(sensorType);
 279                 SysTryReturn(NID_UIX, !IsFailed(r), r, r, "Constructing _SensorEventDelivererList failed.");
 280
 281                 std::unique_ptr<_SensorEventDeliverer> pDeliverer(CreateSensorDataDelivererN(sensorType));
 282                 SysTryReturn(NID_UIX, pDeliverer != null, E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "Allocating new _SensorEventDeliverer failed.");
 283
 284                 r = pDelivererList->Add(*(pDeliverer.get()));
 285                 SysTryReturn(NID_UIX, !IsFailed(r), r, r, "Adding _SensorEventDeliverer failed."); // E_OUT_OF_MEMORY
 286
 287                 pDeliverer->SetDataEventInfo(listener, sensorType, interval, dataChanged);
 288
 289                 r = pDeliverer->Start();
 290                 SysTryReturn(NID_UIX, !IsFailed(r), r, r, "Starting _SensorEventDeliverer failed."); // E_OUT_OF_MEMORY or E_DEVICE_UNAVAILABLE
 291
 292                 r = __pDelivererListHashMap->Add(sensorType, pDelivererList.get());
 293                 if (IsFailed(r))
 294                 {
 295                         // E_OUT_OF_MEMORY
 296                         SysLogException(NID_UIX, r, "Adding _SensorEventDelivererList failed.");
 297                         pDeliverer->Stop();
 298                         return r;
 299                 }
 300
 301                 pDeliverer.release();
 302                 pDelivererList.release();
 303         }
 304
 305         return E_SUCCESS;
 306 }
 307
 308 result
 309 _SensorManagerImpl::RemoveSensorEventListener(ISensorEventListener& listener)
 310 {
 311         result r = RemoveSensorEventListenerFromDelivererListHashMap(*__pDelivererListHashMap, listener);
 312         if (IsFailed(r))
 313         {
 314                 return r;
 315         }
 316
 317         return E_SUCCESS;
 318 }
 319
 320 result
 321 _SensorManagerImpl::RemoveSensorEventListener(ISensorEventListener& listener, SensorType sensorType)
 322 {
 323         if (_AppInfo::GetApiVersion() == Tizen::Base::_API_VERSION_2_0 && _AppInfo::IsOspCompat())
 324         {
 325                 SysTryReturn(NID_UIX, _SensorUtil::IsSensorTypeValid(sensorType), E_INVALID_ARG, E_INVALID_ARG, "Invalid SensorType [sensorType:%d]", sensorType);
 326         }
 327         else
 328         {
 329                 result r = _SensorUtil::CheckSensorTypeValidation(sensorType);
 330                 if (IsFailed(r))
 331                 {
 332                         return r;
 333                 }
 334         }
 335
 336         SysTryReturn(NID_UIX, IsSensorTypeRegistered(sensorType), E_INVALID_ARG, E_INVALID_ARG, "Not registered SensorType [sensorType:%d]", sensorType);
 337
 338         _SensorEventDelivererList* pDelivererList = null;
 339         __pDelivererListHashMap->GetValue(sensorType, pDelivererList);
 340         result r = RemoveSensorEventListenerFromDelivererList(*pDelivererList, listener);
 341         if (IsFailed(r))
 342         {
 343                 return r;
 344         }
 345
 346         return E_SUCCESS;
 347 }
 348
 349 result
 350 _SensorManagerImpl::SetInterval(SensorType sensorType, long interval)
 351 {
 352         // NOTE: This API was deprecated.
 353         // It can change sensing interval for registered first listener only.
 354         result r = _SensorUtil::CheckSensorTypeValidation(sensorType);
 355         if (IsFailed(r))
 356         {
 357                 return r;
 358         }
 359
 360         r = _SensorUtil::CheckIntervalValidation(sensorType, interval);
 361         if (IsFailed(r))
 362         {
 363                 return r;
 364         }
 365
 366         if (_AppInfo::GetApiVersion() == Tizen::Base::_API_VERSION_2_0 && _AppInfo::IsOspCompat())
 367         {
 368                 SysTryReturn(NID_UIX, IsSensorTypeRegistered(sensorType), E_DEVICE_UNAVAILABLE, E_DEVICE_UNAVAILABLE, "Not registered SensorType [sensorType:%d]", sensorType);
 369         }
 370         else
 371         {
 372                 SysTryReturn(NID_UIX, IsSensorTypeRegistered(sensorType), E_INVALID_ARG, E_INVALID_ARG, "Not registered SensorType [sensorType:%d]", sensorType);
 373         }
 374
 375         _SensorEventDelivererList* pDelivererList = null;
 376         __pDelivererListHashMap->GetValue(sensorType, pDelivererList);
 377
 378         SysTryReturn(NID_UIX, pDelivererList->GetCount() > 0, E_INVALID_ARG, E_INVALID_ARG, "Listener not registered yet [sensorType:%d]", sensorType);
 379
 380         _SensorEventDeliverer* pDeliverer = static_cast<_SensorEventDeliverer*>(pDelivererList->GetAt(INDEX_FIRST));
 381         r = pDeliverer->ResetInterval(interval);
 382         if (IsFailed(r))
 383         {
 384                 return r;
 385         }
 386
 387         return E_SUCCESS;
 388 }
 389
 390 result
 391 _SensorManagerImpl::SetInterval(ISensorEventListener& listener, SensorType sensorType, long interval)
 392 {
 393         result r = _SensorUtil::CheckSensorTypeValidation(sensorType);
 394         if (IsFailed(r))
 395         {
 396                 return r;
 397         }
 398
 399         r = _SensorUtil::CheckIntervalValidation(sensorType, interval);
 400         if (IsFailed(r))
 401         {
 402                 return r;
 403         }
 404
 405         SysTryReturn(NID_UIX, IsSensorTypeRegistered(sensorType), E_INVALID_ARG, E_INVALID_ARG, "Not registered SensorType [sensorType:%d]", sensorType);
 406
 407         _SensorEventDelivererList* pDelivererList = null;
 408         __pDelivererListHashMap->GetValue(sensorType, pDelivererList);
 409
 410         int index = INDEX_NONE;
 411         SysTryReturn(NID_UIX, IsListenerRegistered(*pDelivererList, listener, index), E_INVALID_ARG, E_INVALID_ARG, "Invalid ISensorEventListener [sensorType:%d, listener:%p]", sensorType, &listener);
 412
 413         _SensorEventDeliverer* pDeliverer = static_cast<_SensorEventDeliverer*>(pDelivererList->GetAt(index));
 414         r = pDeliverer->ResetInterval(interval);
 415         if (IsFailed(r))
 416         {
 417                 return r;
 418         }
 419
 420         return E_SUCCESS;
 421 }
 422
 423 // Sensor wake up management -------------------------------------------------------------------------------------------------- //
 424 bool
 425 _SensorManagerImpl::IsWakeupSupported(SensorType sensorType) const
 426 {
 427
 428         result r = _SensorUtil::CheckSensorTypeValidation(sensorType);
 429         if (IsFailed(r))
 430         {
 431                 return r;
 432         }
 433 #if defined(_OSP_EMUL_)
 434         return true;
 435 #else
 436         return _ISensorCore::IsWakeupSupported(sensorType);
 437 #endif
 438 }
 439
 440 result
 441 _SensorManagerImpl::SetWakeupEnabled(SensorType sensorType, bool enable)
 442 {
 443
 444         bool isWakeupSupported = IsWakeupSupported(sensorType);
 445         result r = GetLastResult();
 446         if (IsFailed(r))
 447         {
 448                 return r;
 449         }
 450 #if defined(_OSP_EMUL_)
 451         return E_SUCCESS;
 452 #else
 453         SysTryReturn(NID_UIX, isWakeupSupported, E_UNSUPPORTED_OPERATION, E_UNSUPPORTED_OPERATION, "Unsupported SensorType for wake up [sensorType:%d]", sensorType);
 454         SysTryReturn(NID_UIX, IsSensorTypeRegistered(sensorType), E_INVALID_STATE, E_INVALID_STATE, "Not registered SensorType [sensorType:%d]", sensorType);
 455
 456         _SensorEventDelivererList* pDelivererList = null;
 457         __pDelivererListHashMap->GetValue(sensorType, pDelivererList);
 458         SysTryReturn(NID_UIX, pDelivererList->GetCount() > 0, E_INVALID_STATE, E_INVALID_STATE, "Listener not registered [sensorType:%d]", sensorType);
 459
 460         int tempIndex = INDEX_NONE;
 461         bool isWakeupEnabled = IsListenerRegistered(*pDelivererList, INVALID_LISTENER, tempIndex);
 462         if ((enable && isWakeupEnabled) || (!enable && !isWakeupEnabled))
 463         {
 464                 return E_SUCCESS;
 465         }
 466
 467         if (enable)
 468         {
 469                 std::unique_ptr<_SensorEventDeliverer> pDeliverer(new (std::nothrow) _SensorEventDeliverer());
 470                 SysTryReturn(NID_UIX, pDeliverer != null, E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "Allocating new Deliverer failed.");
 471
 472                 pDeliverer->SetWakeupEventInfo(INVALID_LISTENER, sensorType);
 473
 474                 r = pDeliverer->Start();
 475                 SysTryReturn(NID_UIX, !IsFailed(r), r, r, "Starting Deliverer failed."); // E_OUT_OF_MEMORY or E_DEVICE_UNAVAILABLE
 476
 477                 r = pDelivererList->Add(*(pDeliverer.get()));
 478                 if (IsFailed(r))
 479                 {
 480                         // E_OUT_OF_MEMORY
 481                         SysLogException(NID_UIX, r, "Adding Deliverer failed.");
 482                         pDeliverer->Stop();
 483                         return r;
 484                 }
 485
 486                 pDeliverer.release();
 487         }
 488         else
 489         {
 490                 _SensorEventDeliverer* pDeliverer = static_cast<_SensorEventDeliverer*>(pDelivererList->GetAt(tempIndex));
 491                 result r = pDeliverer->Stop();
 492                 if (IsFailed(r))
 493                 {
 494                         return r;
 495                 }
 496
 497                 pDelivererList->RemoveAt(tempIndex, true);
 498         }
 499
 500         return E_SUCCESS;
 501 #endif
 502 }
 503
 504 bool
 505 _SensorManagerImpl::IsWakeupEnabled(SensorType sensorType) const
 506 {
 507
 508         bool isWakeupSupported = IsWakeupSupported(sensorType);
 509         result r = GetLastResult();
 510         if (IsFailed(r))
 511         {
 512                 return r;
 513         }
 514 #if defined(_OSP_EMUL_)
 515         return true;
 516 #else
 517         SysTryReturn(NID_UIX, isWakeupSupported, E_UNSUPPORTED_OPERATION, E_UNSUPPORTED_OPERATION, "Unsupported SensorType for wake up [sensorType:%d]", sensorType);
 518
 519         if (!IsSensorTypeRegistered(sensorType))
 520         {
 521                 return false;
 522         }
 523
 524         _SensorEventDelivererList* pDelivererList = null;
 525         __pDelivererListHashMap->GetValue(sensorType, pDelivererList);
 526
 527         int dummyIndex = INDEX_NONE;
 528         return IsListenerRegistered(*pDelivererList, INVALID_LISTENER, dummyIndex);
 529 #endif
 530 }
 531
 532 // Management helpers --------------------------------------------------------------------------------------------------------- //
 533 bool
 534 _SensorManagerImpl::IsSensorTypeRegistered(SensorType sensorType) const
 535 {
 536         bool isContains = false;
 537         __pDelivererListHashMap->ContainsKey(sensorType, isContains);
 538         return isContains;
 539 }
 540
 541 bool
 542 _SensorManagerImpl::IsListenerRegistered(_SensorEventDelivererList& delivererList, ISensorEventListener& listener, int& index) const
 543 {
 544         int delivererCount = delivererList.GetCount();
 545
 546         _SensorEventDeliverer* pDeliverer = null;
 547         for (int i = 0; i < delivererCount; i++)
 548         {
 549                 pDeliverer = static_cast<_SensorEventDeliverer*>(delivererList.GetAt(i));
 550
 551                 if (pDeliverer->IsListenerEquals(listener))
 552                 {
 553                         index = i;
 554                         return true;
 555                 }
 556         }
 557
 558         return false;
 559 }
 560
 561 result
 562 _SensorManagerImpl::RemoveSensorEventListenerFromDelivererListHashMap(_SensorEventDelivererListHashMap& delivererListHashMap, ISensorEventListener& listener)
 563 {
 564         bool isRemoved = false;
 565         std::unique_ptr<_ISensorEventDelivererListHashMapEnumerator> pHashMapEnumeratorN(delivererListHashMap.GetMapEnumeratorN());
 566         if (pHashMapEnumeratorN != null)
 567         {
 568                 _SensorEventDelivererList* pDelivererList = null;
 569                 result r = E_SUCCESS;
 570                 while (pHashMapEnumeratorN->MoveNext() == E_SUCCESS)
 571                 {
 572                         pHashMapEnumeratorN->GetValue(pDelivererList);
 573
 574                         r = RemoveSensorEventListenerFromDelivererList(*pDelivererList, listener);
 575                         if (r == E_INVALID_ARG)
 576                         {
 577                                 continue;
 578                         }
 579                         else if (r == E_DEVICE_UNAVAILABLE)
 580                         {
 581                                 return r;
 582                         }
 583                         else
 584                         {
 585                                 isRemoved = true;
 586                         }
 587                 }
 588         }
 589         else
 590         {
 591                 _SensorEventDelivererList* pDelivererList = null;
 592                 result r = E_SUCCESS;
 593                 for (int i = SENSOR_TYPE_NONE+1; i < SENSOR_TYPE_MAX; i++)
 594                 {
 595                         if (IsFailed(delivererListHashMap.GetValue(static_cast<SensorType>(i), pDelivererList)))
 596                         {
 597                                 continue;
 598                         }
 599
 600                         r = RemoveSensorEventListenerFromDelivererList(*pDelivererList, listener);
 601                         if (r == E_INVALID_ARG)
 602                         {
 603                                 continue;
 604                         }
 605                         else if (r == E_DEVICE_UNAVAILABLE)
 606                         {
 607                                 return r;
 608                         }
 609                         else
 610                         {
 611                                 isRemoved = true;
 612                         }
 613                 }
 614         }
 615
 616         if (!isRemoved)
 617         {
 618                 SetLastResult(E_INVALID_ARG);
 619                 return E_INVALID_ARG;
 620         }
 621
 622         return E_SUCCESS;
 623 }
 624
 625 result
 626 _SensorManagerImpl::RemoveSensorEventListenerFromDelivererList(_SensorEventDelivererList& delivererList, ISensorEventListener& listener)
 627 {
 628         int index = INDEX_NONE;
 629         if (!IsListenerRegistered(delivererList, listener, index))
 630         {
 631                 SetLastResult(E_INVALID_ARG);
 632                 return E_INVALID_ARG;
 633         }
 634
 635         _SensorEventDeliverer* pDeliverer = static_cast<_SensorEventDeliverer*>(delivererList.GetAt(index));
 636         result r = pDeliverer->Stop();
 637         if (IsFailed(r))
 638         {
 639                 return r;
 640         }
 641
 642         r = delivererList.RemoveAt(index, true);
 643         if (IsFailed(r))
 644         {
 645                 return r;
 646         }
 647
 648         if (delivererList.GetCount() == 1 && IsListenerRegistered(delivererList, INVALID_LISTENER, index))
 649         {
 650                 delivererList.RemoveAt(index, true);
 651         }
 652
 653         return E_SUCCESS;
 654 }
 655
 656 // Getting implementation instance -------------------------------------------------------------------------------------------- //
 657 _SensorManagerImpl*
 658 _SensorManagerImpl::GetInstance(SensorManager& sensorManager)
 659 {
 660         return sensorManager.__pSensorManagerImpl;
 661 }
 662
 663 const _SensorManagerImpl*
 664 _SensorManagerImpl::GetInstance(const SensorManager& sensorManager)
 665 {
 666         return sensorManager.__pSensorManagerImpl;
 667 }
 668 } } }// Tizen::Uix::Sensor