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         }
 153 }
 154
 155 // Getting sensor information ------------------------------------------------------------------------------------------------- //
 156 bool
 157 _SensorManagerImpl::IsAvailable(SensorType sensorType) const
 158 {
 159         result r = _SensorUtil::CheckSensorTypeValidation(sensorType);
 160         if (IsFailed(r))
 161         {
 162                 return false;
 163         }
 164
 165         return true;
 166 }
 167
 168 result
 169 _SensorManagerImpl::GetDescription(SensorType sensorType, Tizen::Base::String& description) const
 170 {
 171         result r = _SensorUtil::CheckSensorTypeValidation(sensorType);
 172         if (IsFailed(r))
 173         {
 174                 return r;
 175         }
 176
 177         return _ISensorCore::GetDescription(sensorType, description);
 178 }
 179
 180 result
 181 _SensorManagerImpl::GetVendor(SensorType sensorType, Tizen::Base::String& vendor) const
 182 {
 183         result r = _SensorUtil::CheckSensorTypeValidation(sensorType);
 184         if (IsFailed(r))
 185         {
 186                 return r;
 187         }
 188
 189         return _ISensorCore::GetVendor(sensorType, vendor);
 190 }
 191
 192 result
 193 _SensorManagerImpl::GetModelId(SensorType sensorType, Tizen::Base::String& modelId) const
 194 {
 195         result r = _SensorUtil::CheckSensorTypeValidation(sensorType);
 196         if (IsFailed(r))
 197         {
 198                 return r;
 199         }
 200
 201         return _ISensorCore::GetModelId(sensorType, modelId);
 202 }
 203
 204 result
 205 _SensorManagerImpl::GetMeasurementRange(SensorType sensorType, float& min, float& max, float& resolution) const
 206 {
 207         result r = _SensorUtil::CheckSensorTypeValidation(sensorType);
 208         if (IsFailed(r))
 209         {
 210                 return r;
 211         }
 212
 213         return _ISensorCore::GetMeasurementRange(sensorType, min, max, resolution);
 214 }
 215
 216 result
 217 _SensorManagerImpl::GetIntervalRange(SensorType sensorType, long& min, long& max) const
 218 {
 219         result r = _SensorUtil::CheckSensorTypeValidation(sensorType);
 220         if (IsFailed(r))
 221         {
 222                 return r;
 223         }
 224
 225         return _ISensorCore::GetIntervalRange(sensorType, min, max);
 226 }
 227
 228
 229 // Sensor event listener management ------------------------------------------------------------------------------------------- //
 230 result
 231 _SensorManagerImpl::AddSensorEventListener(ISensorEventListener& listener, SensorType sensorType, long interval, bool dataChanged)
 232 {
 233         result r = _SensorUtil::CheckSensorTypeValidation(sensorType);
 234         if (IsFailed(r))
 235         {
 236                 return r;
 237         }
 238
 239         r = _SensorUtil::CheckIntervalValidation(sensorType, interval);
 240         if (IsFailed(r))
 241         {
 242                 return r;
 243         }
 244
 245         if (IsSensorTypeRegistered(sensorType))
 246         {
 247                 _SensorEventDelivererList* pDelivererList = null;
 248                 __pDelivererListHashMap->GetValue(sensorType, pDelivererList);
 249
 250                 int tempIndex = INDEX_NONE;
 251                 SysTryReturn(NID_UIX, !IsListenerRegistered(*pDelivererList, listener, tempIndex), E_USER_ALREADY_REGISTERED, E_USER_ALREADY_REGISTERED, "Invalid ISensorEventListener [sensorType:%d, listener:%p]", sensorType, &listener);
 252
 253                 std::unique_ptr<_SensorEventDeliverer> pDeliverer(CreateSensorDataDelivererN(sensorType));
 254                 SysTryReturn(NID_UIX, pDeliverer != null, E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "Allocating new _SensorEventDeliverer failed.");
 255
 256                 pDeliverer->SetDataEventInfo(listener, sensorType, interval, dataChanged);
 257
 258                 r = pDeliverer->Start();
 259                 SysTryReturn(NID_UIX, !IsFailed(r), r, r, "Starting _SensorEventDeliverer failed."); // E_OUT_OF_MEMORY or E_DEVICE_UNAVAILABLE
 260
 261                 r = pDelivererList->Add(*(pDeliverer.get()));
 262                 if (IsFailed(r))
 263                 {
 264                         // E_OUT_OF_MEMORY
 265                         SysLogException(NID_UIX, r, "Adding _SensorEventDeliverer failed.");
 266                         pDeliverer->Stop();
 267                         return r;
 268                 }
 269
 270                 pDeliverer.release();
 271         }
 272         else
 273         {
 274                 std::unique_ptr<_SensorEventDelivererList> pDelivererList(new (std::nothrow) _SensorEventDelivererList());
 275                 SysTryReturn(NID_UIX, pDelivererList != null, E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "Allocating new _SensorEventDelivererList failed.");
 276
 277                 r = pDelivererList->Construct(sensorType);
 278                 SysTryReturn(NID_UIX, !IsFailed(r), r, r, "Constructing _SensorEventDelivererList failed.");
 279
 280                 std::unique_ptr<_SensorEventDeliverer> pDeliverer(CreateSensorDataDelivererN(sensorType));
 281                 SysTryReturn(NID_UIX, pDeliverer != null, E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "Allocating new _SensorEventDeliverer failed.");
 282
 283                 r = pDelivererList->Add(*(pDeliverer.get()));
 284                 SysTryReturn(NID_UIX, !IsFailed(r), r, r, "Adding _SensorEventDeliverer failed."); // E_OUT_OF_MEMORY
 285
 286                 pDeliverer->SetDataEventInfo(listener, sensorType, interval, dataChanged);
 287
 288                 r = pDeliverer->Start();
 289                 SysTryReturn(NID_UIX, !IsFailed(r), r, r, "Starting _SensorEventDeliverer failed."); // E_OUT_OF_MEMORY or E_DEVICE_UNAVAILABLE
 290
 291                 r = __pDelivererListHashMap->Add(sensorType, pDelivererList.get());
 292                 if (IsFailed(r))
 293                 {
 294                         // E_OUT_OF_MEMORY
 295                         SysLogException(NID_UIX, r, "Adding _SensorEventDelivererList failed.");
 296                         pDeliverer->Stop();
 297                         return r;
 298                 }
 299
 300                 pDeliverer.release();
 301                 pDelivererList.release();
 302         }
 303
 304         return E_SUCCESS;
 305 }
 306
 307 result
 308 _SensorManagerImpl::RemoveSensorEventListener(ISensorEventListener& listener)
 309 {
 310         result r = RemoveSensorEventListenerFromDelivererListHashMap(*__pDelivererListHashMap, listener);
 311         if (IsFailed(r))
 312         {
 313                 return r;
 314         }
 315
 316         return E_SUCCESS;
 317 }
 318
 319 result
 320 _SensorManagerImpl::RemoveSensorEventListener(ISensorEventListener& listener, SensorType sensorType)
 321 {
 322         if (_AppInfo::GetApiVersion() == Tizen::Base::_API_VERSION_2_0 && _AppInfo::IsOspCompat())
 323         {
 324                 SysTryReturn(NID_UIX, _SensorUtil::IsSensorTypeValid(sensorType), E_INVALID_ARG, E_INVALID_ARG, "Invalid SensorType [sensorType:%d]", sensorType);
 325         }
 326         else
 327         {
 328                 result r = _SensorUtil::CheckSensorTypeValidation(sensorType);
 329                 if (IsFailed(r))
 330                 {
 331                         return r;
 332                 }
 333         }
 334
 335         SysTryReturn(NID_UIX, IsSensorTypeRegistered(sensorType), E_INVALID_ARG, E_INVALID_ARG, "Not registered SensorType [sensorType:%d]", sensorType);
 336
 337         _SensorEventDelivererList* pDelivererList = null;
 338         __pDelivererListHashMap->GetValue(sensorType, pDelivererList);
 339         result r = RemoveSensorEventListenerFromDelivererList(*pDelivererList, listener);
 340         if (IsFailed(r))
 341         {
 342                 return r;
 343         }
 344
 345         return E_SUCCESS;
 346 }
 347
 348 result
 349 _SensorManagerImpl::SetInterval(SensorType sensorType, long interval)
 350 {
 351         // NOTE: This API was deprecated.
 352         // It can change sensing interval for registered first listener only.
 353         result r = _SensorUtil::CheckSensorTypeValidation(sensorType);
 354         if (IsFailed(r))
 355         {
 356                 return r;
 357         }
 358
 359         r = _SensorUtil::CheckIntervalValidation(sensorType, interval);
 360         if (IsFailed(r))
 361         {
 362                 return r;
 363         }
 364
 365         if (_AppInfo::GetApiVersion() == Tizen::Base::_API_VERSION_2_0 && _AppInfo::IsOspCompat())
 366         {
 367                 SysTryReturn(NID_UIX, IsSensorTypeRegistered(sensorType), E_DEVICE_UNAVAILABLE, E_DEVICE_UNAVAILABLE, "Not registered SensorType [sensorType:%d]", sensorType);
 368         }
 369         else
 370         {
 371                 SysTryReturn(NID_UIX, IsSensorTypeRegistered(sensorType), E_INVALID_ARG, E_INVALID_ARG, "Not registered SensorType [sensorType:%d]", sensorType);
 372         }
 373
 374         _SensorEventDelivererList* pDelivererList = null;
 375         __pDelivererListHashMap->GetValue(sensorType, pDelivererList);
 376
 377         SysTryReturn(NID_UIX, pDelivererList->GetCount() > 0, E_INVALID_ARG, E_INVALID_ARG, "Listener not registered yet [sensorType:%d]", sensorType);
 378
 379         _SensorEventDeliverer* pDeliverer = static_cast<_SensorEventDeliverer*>(pDelivererList->GetAt(INDEX_FIRST));
 380         r = pDeliverer->ResetInterval(interval);
 381         if (IsFailed(r))
 382         {
 383                 return r;
 384         }
 385
 386         return E_SUCCESS;
 387 }
 388
 389 result
 390 _SensorManagerImpl::SetInterval(ISensorEventListener& listener, SensorType sensorType, long interval)
 391 {
 392         result r = _SensorUtil::CheckSensorTypeValidation(sensorType);
 393         if (IsFailed(r))
 394         {
 395                 return r;
 396         }
 397
 398         r = _SensorUtil::CheckIntervalValidation(sensorType, interval);
 399         if (IsFailed(r))
 400         {
 401                 return r;
 402         }
 403
 404         SysTryReturn(NID_UIX, IsSensorTypeRegistered(sensorType), E_INVALID_ARG, E_INVALID_ARG, "Not registered SensorType [sensorType:%d]", sensorType);
 405
 406         _SensorEventDelivererList* pDelivererList = null;
 407         __pDelivererListHashMap->GetValue(sensorType, pDelivererList);
 408
 409         int index = INDEX_NONE;
 410         SysTryReturn(NID_UIX, IsListenerRegistered(*pDelivererList, listener, index), E_INVALID_ARG, E_INVALID_ARG, "Invalid ISensorEventListener [sensorType:%d, listener:%p]", sensorType, &listener);
 411
 412         _SensorEventDeliverer* pDeliverer = static_cast<_SensorEventDeliverer*>(pDelivererList->GetAt(index));
 413         r = pDeliverer->ResetInterval(interval);
 414         if (IsFailed(r))
 415         {
 416                 return r;
 417         }
 418
 419         return E_SUCCESS;
 420 }
 421
 422 // Sensor wake up management -------------------------------------------------------------------------------------------------- //
 423 bool
 424 _SensorManagerImpl::IsWakeupSupported(SensorType sensorType) const
 425 {
 426
 427         result r = _SensorUtil::CheckSensorTypeValidation(sensorType);
 428         if (IsFailed(r))
 429         {
 430                 return r;
 431         }
 432 #if defined(_OSP_EMUL_)
 433         return true;
 434 #else
 435         return _ISensorCore::IsWakeupSupported(sensorType);
 436 #endif
 437 }
 438
 439 result
 440 _SensorManagerImpl::SetWakeupEnabled(SensorType sensorType, bool enable)
 441 {
 442
 443         bool isWakeupSupported = IsWakeupSupported(sensorType);
 444         result r = GetLastResult();
 445         if (IsFailed(r))
 446         {
 447                 return r;
 448         }
 449 #if defined(_OSP_EMUL_)
 450         return E_SUCCESS;
 451 #else
 452         SysTryReturn(NID_UIX, isWakeupSupported, E_UNSUPPORTED_OPERATION, E_UNSUPPORTED_OPERATION, "Unsupported SensorType for wake up [sensorType:%d]", sensorType);
 453         SysTryReturn(NID_UIX, IsSensorTypeRegistered(sensorType), E_INVALID_STATE, E_INVALID_STATE, "Not registered SensorType [sensorType:%d]", sensorType);
 454
 455         _SensorEventDelivererList* pDelivererList = null;
 456         __pDelivererListHashMap->GetValue(sensorType, pDelivererList);
 457         SysTryReturn(NID_UIX, pDelivererList->GetCount() > 0, E_INVALID_STATE, E_INVALID_STATE, "Listener not registered [sensorType:%d]", sensorType);
 458
 459         int tempIndex = INDEX_NONE;
 460         bool isWakeupEnabled = IsListenerRegistered(*pDelivererList, INVALID_LISTENER, tempIndex);
 461         if ((enable && isWakeupEnabled) || (!enable && !isWakeupEnabled))
 462         {
 463                 return E_SUCCESS;
 464         }
 465
 466         if (enable)
 467         {
 468                 std::unique_ptr<_SensorEventDeliverer> pDeliverer(new (std::nothrow) _SensorEventDeliverer());
 469                 SysTryReturn(NID_UIX, pDeliverer != null, E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "Allocating new Deliverer failed.");
 470
 471                 pDeliverer->SetWakeupEventInfo(INVALID_LISTENER, sensorType);
 472
 473                 r = pDeliverer->Start();
 474                 SysTryReturn(NID_UIX, !IsFailed(r), r, r, "Starting Deliverer failed."); // E_OUT_OF_MEMORY or E_DEVICE_UNAVAILABLE
 475
 476                 r = pDelivererList->Add(*(pDeliverer.get()));
 477                 if (IsFailed(r))
 478                 {
 479                         // E_OUT_OF_MEMORY
 480                         SysLogException(NID_UIX, r, "Adding Deliverer failed.");
 481                         pDeliverer->Stop();
 482                         return r;
 483                 }
 484
 485                 pDeliverer.release();
 486         }
 487         else
 488         {
 489                 _SensorEventDeliverer* pDeliverer = static_cast<_SensorEventDeliverer*>(pDelivererList->GetAt(tempIndex));
 490                 result r = pDeliverer->Stop();
 491                 if (IsFailed(r))
 492                 {
 493                         return r;
 494                 }
 495
 496                 pDelivererList->RemoveAt(tempIndex, true);
 497         }
 498
 499         return E_SUCCESS;
 500 #endif
 501 }
 502
 503 bool
 504 _SensorManagerImpl::IsWakeupEnabled(SensorType sensorType) const
 505 {
 506
 507         bool isWakeupSupported = IsWakeupSupported(sensorType);
 508         result r = GetLastResult();
 509         if (IsFailed(r))
 510         {
 511                 return r;
 512         }
 513 #if defined(_OSP_EMUL_)
 514         return true;
 515 #else
 516         SysTryReturn(NID_UIX, isWakeupSupported, E_UNSUPPORTED_OPERATION, E_UNSUPPORTED_OPERATION, "Unsupported SensorType for wake up [sensorType:%d]", sensorType);
 517
 518         if (!IsSensorTypeRegistered(sensorType))
 519         {
 520                 return false;
 521         }
 522
 523         _SensorEventDelivererList* pDelivererList = null;
 524         __pDelivererListHashMap->GetValue(sensorType, pDelivererList);
 525
 526         int dummyIndex = INDEX_NONE;
 527         return IsListenerRegistered(*pDelivererList, INVALID_LISTENER, dummyIndex);
 528 #endif
 529 }
 530
 531 // Management helpers --------------------------------------------------------------------------------------------------------- //
 532 bool
 533 _SensorManagerImpl::IsSensorTypeRegistered(SensorType sensorType) const
 534 {
 535         bool isContains = false;
 536         __pDelivererListHashMap->ContainsKey(sensorType, isContains);
 537         return isContains;
 538 }
 539
 540 bool
 541 _SensorManagerImpl::IsListenerRegistered(_SensorEventDelivererList& delivererList, ISensorEventListener& listener, int& index) const
 542 {
 543         int delivererCount = delivererList.GetCount();
 544
 545         _SensorEventDeliverer* pDeliverer = null;
 546         for (int i = 0; i < delivererCount; i++)
 547         {
 548                 pDeliverer = static_cast<_SensorEventDeliverer*>(delivererList.GetAt(i));
 549
 550                 if (pDeliverer->IsListenerEquals(listener))
 551                 {
 552                         index = i;
 553                         return true;
 554                 }
 555         }
 556
 557         return false;
 558 }
 559
 560 result
 561 _SensorManagerImpl::RemoveSensorEventListenerFromDelivererListHashMap(_SensorEventDelivererListHashMap& delivererListHashMap, ISensorEventListener& listener)
 562 {
 563         bool isRemoved = false;
 564         std::unique_ptr<_ISensorEventDelivererListHashMapEnumerator> pHashMapEnumeratorN(delivererListHashMap.GetMapEnumeratorN());
 565         if (pHashMapEnumeratorN != null)
 566         {
 567                 _SensorEventDelivererList* pDelivererList = null;
 568                 result r = E_SUCCESS;
 569                 while (pHashMapEnumeratorN->MoveNext() == E_SUCCESS)
 570                 {
 571                         pHashMapEnumeratorN->GetValue(pDelivererList);
 572
 573                         r = RemoveSensorEventListenerFromDelivererList(*pDelivererList, listener);
 574                         if (r == E_INVALID_ARG)
 575                         {
 576                                 continue;
 577                         }
 578                         else if (r == E_DEVICE_UNAVAILABLE)
 579                         {
 580                                 return r;
 581                         }
 582                         else
 583                         {
 584                                 isRemoved = true;
 585                         }
 586                 }
 587         }
 588         else
 589         {
 590                 _SensorEventDelivererList* pDelivererList = null;
 591                 result r = E_SUCCESS;
 592                 for (int i = SENSOR_TYPE_NONE+1; i < SENSOR_TYPE_MAX; i++)
 593                 {
 594                         if (IsFailed(delivererListHashMap.GetValue(static_cast<SensorType>(i), pDelivererList)))
 595                         {
 596                                 continue;
 597                         }
 598
 599                         r = RemoveSensorEventListenerFromDelivererList(*pDelivererList, listener);
 600                         if (r == E_INVALID_ARG)
 601                         {
 602                                 continue;
 603                         }
 604                         else if (r == E_DEVICE_UNAVAILABLE)
 605                         {
 606                                 return r;
 607                         }
 608                         else
 609                         {
 610                                 isRemoved = true;
 611                         }
 612                 }
 613         }
 614
 615         if (!isRemoved)
 616         {
 617                 SetLastResult(E_INVALID_ARG);
 618                 return E_INVALID_ARG;
 619         }
 620
 621         return E_SUCCESS;
 622 }
 623
 624 result
 625 _SensorManagerImpl::RemoveSensorEventListenerFromDelivererList(_SensorEventDelivererList& delivererList, ISensorEventListener& listener)
 626 {
 627         int index = INDEX_NONE;
 628         if (!IsListenerRegistered(delivererList, listener, index))
 629         {
 630                 SetLastResult(E_INVALID_ARG);
 631                 return E_INVALID_ARG;
 632         }
 633
 634         _SensorEventDeliverer* pDeliverer = static_cast<_SensorEventDeliverer*>(delivererList.GetAt(index));
 635         result r = pDeliverer->Stop();
 636         if (IsFailed(r))
 637         {
 638                 return r;
 639         }
 640
 641         r = delivererList.RemoveAt(index, true);
 642         if (IsFailed(r))
 643         {
 644                 return r;
 645         }
 646
 647         if (delivererList.GetCount() == 1 && IsListenerRegistered(delivererList, INVALID_LISTENER, index))
 648         {
 649                 delivererList.RemoveAt(index, true);
 650         }
 651
 652         return E_SUCCESS;
 653 }
 654
 655 // Getting implementation instance -------------------------------------------------------------------------------------------- //
 656 _SensorManagerImpl*
 657 _SensorManagerImpl::GetInstance(SensorManager& sensorManager)
 658 {
 659         return sensorManager.__pSensorManagerImpl;
 660 }
 661
 662 const _SensorManagerImpl*
 663 _SensorManagerImpl::GetInstance(const SensorManager& sensorManager)
 664 {
 665         return sensorManager.__pSensorManagerImpl;
 666 }
 667 } } }// Tizen::Uix::Sensor