src/FUixSensor_ISensorCore.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_ISensorCore.cpp
  20  * @brief    This is the implementation file for the %_ISensorCore interface class.
  21  *
  22  * This files contains implementation of the %_ISensorCore interface class.
  23  */
  24
  25 // Includes
  26 #include <sensors.h>
  27
  28 #include <FBaseString.h>
  29 #include <FBaseSysLog.h>
  30 #include <FApp_AppInfo.h>
  31 #include "FUixSensor_ISensorCore.h"
  32 #include "FUixSensor_ISensorCoreEventReceiver.h"
  33 #include "FUixSensor_SensorUtil.h"
  34
  35 using Tizen::App::_AppInfo;
  36
  37 namespace Tizen { namespace Uix { namespace Sensor
  38 {
  39 namespace
  40 {
  41 // Internal variables -------------------------------------------------------------------------------------------------------- //
  42 static const sensor_type_e SENSOR_UNKNOWN = static_cast<sensor_type_e>(-1);
  43 static const wchar_t W_MSG_EMUL_VENDOR[] = L"Emul_Vendor";
  44 static const wchar_t W_MSG_EMUL_MODEL_ID_TILT[] = L"Emul_ModelId_Tilt";
  45 static const wchar_t W_MSG_NOT_SUPPORTED[] = L"Not supported";
  46 static const long SENSOR_MIN_INTERVALS[] = {
  47         20L,  // SENSOR_TYPE_ACCELERATION
  48         20L,  // SENSOR_TYPE_MAGNETIC
  49         100L, // SENSOR_TYPE_PROXIMITY
  50         20L,  // SENSOR_TYPE_TILT
  51         20L,  // SENSOR_TYPE_GYRO
  52         100L, // SENSOR_TYPE_LIGHT
  53 };
  54 static const long SENSOR_MAX_INTERVALS[] = {
  55         100L,  // SENSOR_TYPE_ACCELERATION
  56         100L,  // SENSOR_TYPE_MAGNETIC
  57         5000L, // SENSOR_TYPE_PROXIMITY
  58         1000L, // SENSOR_TYPE_TILT
  59         100L,  // SENSOR_TYPE_GYRO
  60         5000L, // SENSOR_TYPE_LIGHT
  61 };
  62 static const float MIN_VALUE_TILT = 0.0F;
  63 static const float MAX_VALUE_TILT = 360.0F;
  64 static const float RESOLUTION_VALUE_TILT = 0.0F;
  65
  66 // Internal utility methods -------------------------------------------------------------------------------------------------- //
  67 inline bool
  68 IsSuccess(int sensorResult)
  69 {
  70         return sensorResult == SENSOR_ERROR_NONE;
  71 }
  72
  73 sensor_type_e
  74 ConvertToSensorTypeEFromSensorType(SensorType sensorType)
  75 {
  76         switch (sensorType)
  77         {
  78         case SENSOR_TYPE_ACCELERATION:
  79                 return SENSOR_ACCELEROMETER;
  80         case SENSOR_TYPE_MAGNETIC:
  81                 return SENSOR_MAGNETIC;
  82         case SENSOR_TYPE_PROXIMITY:
  83                 return SENSOR_PROXIMITY;
  84         case SENSOR_TYPE_TILT:
  85                 return SENSOR_ORIENTATION;
  86         case SENSOR_TYPE_GYRO:
  87                 return SENSOR_GYROSCOPE;
  88         case SENSOR_TYPE_LIGHT:
  89                 return SENSOR_LIGHT;
  90         default:
  91                 SysAssertf(false, "ConvertToSensorTypeEFromSensorType() > Invalid SensorType [sensorType:%d]", sensorType);
  92                 SetLastResult(E_INVALID_ARG);
  93                 return SENSOR_UNKNOWN;
  94         }
  95 }
  96
  97 int
  98 GetStaticIntervalRange(SensorType sensorType, int& min, int& max)
  99 {
 100         min = SENSOR_MIN_INTERVALS[sensorType];
 101         max = SENSOR_MAX_INTERVALS[sensorType];
 102
 103         return SENSOR_ERROR_NONE;
 104 }
 105
 106 sensor_type_e
 107 GetSensorTypeEFromSensorCoreEventType(_SensorCoreEventType eventType)
 108 {
 109         switch (eventType)
 110         {
 111         case _SENSOR_CORE_EVENT_TYPE_ACCELERATION_DATA:
 112         // fall through
 113         case _SENSOR_CORE_EVENT_TYPE_ACCELERATION_SENSOR_WAKEUP:
 114                 return SENSOR_ACCELEROMETER;
 115         case _SENSOR_CORE_EVENT_TYPE_MAGNETIC_FIELD_DATA:
 116                 return SENSOR_MAGNETIC;
 117         case _SENSOR_CORE_EVENT_TYPE_TILT_DATA:
 118                 return SENSOR_ORIENTATION;
 119         case _SENSOR_CORE_EVENT_TYPE_PROXIMITY_DISTANCE_DATA:
 120                 return SENSOR_PROXIMITY;
 121         case _SENSOR_CORE_EVENT_TYPE_ROTATION_RATE_DATA:
 122                 return SENSOR_GYROSCOPE;
 123         case _SENSOR_CORE_EVENT_TYPE_LIGHT_LEVEL_DATA:
 124                 return SENSOR_LIGHT;
 125         default:
 126                 SysAssertf(false, "GetSensorTypeEFromSensorCoreEventType() > Invalid _SensorCoreEventType [eventType:%d]", eventType);
 127                 SetLastResult(E_INVALID_ARG);
 128                 return SENSOR_UNKNOWN;
 129         }
 130 }
 131
 132 inline int
 133 IsStaticObjectDetected(float distance, bool& isObjectDetected)
 134 {
 135         isObjectDetected = (distance <= 4.0F);
 136         return SENSOR_ERROR_NONE;
 137 }
 138
 139 inline bool
 140 IsAccuracyValid(sensor_data_accuracy_e accuracy)
 141 {
 142         return accuracy >= SENSOR_DATA_ACCURACY_NORMAL;
 143 }
 144
 145 inline long long
 146 CorrectTimestamp(long long timestamp)
 147 {
 148         return timestamp * MICROSECOND_TO_MILLISECOND;
 149 }
 150
 151 // Internal callback methods ------------------------------------------------------------------------------------------------- //
 152 void
 153 OnAccelerationDataEventReceived(unsigned long long timestamp, sensor_data_accuracy_e accuracy,
 154         float x, float y, float z, void* pUserData)
 155 {
 156         _ISensorCoreEventReceiver& receiver= *static_cast<_ISensorCoreEventReceiver*>(pUserData);
 157         _SensorCoreEvent& eventBuffer = receiver.GetSensorCoreEventBuffer();
 158
 159         eventBuffer.isEventValid = IsAccuracyValid(accuracy);
 160         eventBuffer.eventType = _SENSOR_CORE_EVENT_TYPE_ACCELERATION_DATA;
 161         eventBuffer.eventTimestamp = CorrectTimestamp(timestamp);
 162         eventBuffer.eventKind.accelerationData.x = x * METER_PER_SECOND_SQUARE_TO_G;
 163         eventBuffer.eventKind.accelerationData.y = y * METER_PER_SECOND_SQUARE_TO_G;
 164         eventBuffer.eventKind.accelerationData.z = z * METER_PER_SECOND_SQUARE_TO_G;
 165         receiver.OnSensorCoreEventReceived(eventBuffer);
 166 }
 167
 168 void
 169 OnMagneticFieldDataEventReceived(unsigned long long timestamp, sensor_data_accuracy_e accuracy,
 170         float x, float y, float z, void* pUserData)
 171 {
 172         _ISensorCoreEventReceiver& receiver= *static_cast<_ISensorCoreEventReceiver*>(pUserData);
 173         _SensorCoreEvent& eventBuffer = receiver.GetSensorCoreEventBuffer();
 174         eventBuffer.isEventValid = IsAccuracyValid(accuracy);
 175         eventBuffer.eventType = _SENSOR_CORE_EVENT_TYPE_MAGNETIC_FIELD_DATA;
 176         eventBuffer.eventTimestamp = CorrectTimestamp(timestamp);
 177         eventBuffer.eventKind.magneticFieldData.x = x;
 178         eventBuffer.eventKind.magneticFieldData.y = y;
 179         eventBuffer.eventKind.magneticFieldData.z = z;
 180         receiver.OnSensorCoreEventReceived(eventBuffer);
 181 }
 182
 183 void
 184 OnProximityDistanceDataEventReceived(unsigned long long timestamp, float distance, void* pUserData)
 185 {
 186         _ISensorCoreEventReceiver& receiver= *static_cast<_ISensorCoreEventReceiver*>(pUserData);
 187         _SensorCoreEvent& eventBuffer = receiver.GetSensorCoreEventBuffer();
 188         eventBuffer.isEventValid = true;
 189         eventBuffer.eventType = _SENSOR_CORE_EVENT_TYPE_PROXIMITY_DISTANCE_DATA;
 190         eventBuffer.eventTimestamp = CorrectTimestamp(timestamp);
 191         eventBuffer.eventKind.proximityDistanceData.distance = distance;
 192         receiver.OnSensorCoreEventReceived(eventBuffer);
 193 }
 194
 195 void
 196 OnTiltAccelerationDataEventReceived(unsigned long long timestamp, sensor_data_accuracy_e accuracy,
 197         float x, float y, float z, void* pUserData)
 198 {
 199         _ISensorCoreEventReceiver& receiver= *static_cast<_ISensorCoreEventReceiver*>(pUserData);
 200         _SensorCoreEvent& eventBuffer = receiver.GetSensorCoreEventBuffer();
 201         eventBuffer.isEventValid = !(IsEquals(x, 0.0F) && (IsEquals(y, 0.0F) || IsEquals(z, 0.0F)));
 202         eventBuffer.eventKind.tiltData.roll = _SensorUtil::Atan2(-x, z) * RADIAN_TO_DEGREE;
 203         eventBuffer.eventKind.tiltData.pitch = _SensorUtil::Atan2(-x, y) * RADIAN_TO_DEGREE;
 204 }
 205
 206 void
 207 OnTiltMagneticAzimuthDataEventReceived(unsigned long long timestamp, sensor_data_accuracy_e accuracy,
 208         float azimuth, float pitch, float roll, void* pUserData)
 209 {
 210         _ISensorCoreEventReceiver& receiver= *static_cast<_ISensorCoreEventReceiver*>(pUserData);
 211         _SensorCoreEvent& eventBuffer = receiver.GetSensorCoreEventBuffer();
 212         eventBuffer.isEventValid = eventBuffer.isEventValid && IsAccuracyValid(accuracy);
 213         eventBuffer.eventType = _SENSOR_CORE_EVENT_TYPE_TILT_DATA;
 214         eventBuffer.eventTimestamp = CorrectTimestamp(timestamp);
 215         eventBuffer.eventKind.tiltData.azimuth = azimuth;
 216         receiver.OnSensorCoreEventReceived(eventBuffer);
 217 }
 218
 219 void
 220 OnRotationRateDataEventReceived(unsigned long long timestamp, sensor_data_accuracy_e accuracy,
 221         float x, float y, float z, void* pUserData)
 222 {
 223         _ISensorCoreEventReceiver& receiver= *static_cast<_ISensorCoreEventReceiver*>(pUserData);
 224         _SensorCoreEvent& eventBuffer = receiver.GetSensorCoreEventBuffer();
 225         eventBuffer.isEventValid = IsAccuracyValid(accuracy);
 226         eventBuffer.eventType = _SENSOR_CORE_EVENT_TYPE_ROTATION_RATE_DATA;
 227         eventBuffer.eventTimestamp = CorrectTimestamp(timestamp);
 228         eventBuffer.eventKind.rotationRateData.x = x * DEGREE_TO_RADIAN;
 229         eventBuffer.eventKind.rotationRateData.y = y * DEGREE_TO_RADIAN;
 230         eventBuffer.eventKind.rotationRateData.z = z * DEGREE_TO_RADIAN;
 231         receiver.OnSensorCoreEventReceived(eventBuffer);
 232 }
 233
 234 void
 235 OnLightLevelDataEventReceived(unsigned long long timestamp, float lux, void* pUserData)
 236 {
 237         _ISensorCoreEventReceiver& receiver= *static_cast<_ISensorCoreEventReceiver*>(pUserData);
 238         _SensorCoreEvent& eventBuffer = receiver.GetSensorCoreEventBuffer();
 239         eventBuffer.isEventValid = true;
 240         eventBuffer.eventType = _SENSOR_CORE_EVENT_TYPE_LIGHT_LEVEL_DATA;
 241         eventBuffer.eventTimestamp = CorrectTimestamp(timestamp);
 242         eventBuffer.eventKind.lightLevelData.level = lux;
 243         receiver.OnSensorCoreEventReceived(eventBuffer);
 244 }
 245
 246 void
 247 OnAccelerationSensorWakeupEventReceived(void *pUserData)
 248 {
 249         SysLog(NID_UIX, "Device wake up by Acceleration sensor.");
 250 }
 251
 252 // Internal management methods ----------------------------------------------------------------------------------------------- //
 253 result
 254 ConnectToSensorCore(sensor_h& sensorHandle)
 255 {
 256         sensor_h tempHandle = null;
 257         int sensorResult = sensor_create(&tempHandle);
 258         if (!IsSuccess(sensorResult))
 259         {
 260                 // SENSOR_ERROR_OUT_OF_MEMORY
 261                 SysAssertf(false, "ConnectToSensorCore() > sensor_create() failed. [handle:%p, result:%d]", tempHandle, sensorResult);
 262                 SetLastResult(E_OUT_OF_MEMORY);
 263                 return E_OUT_OF_MEMORY;
 264         }
 265
 266         sensorHandle = tempHandle;
 267
 268         return E_SUCCESS;
 269 }
 270
 271 result
 272 DisconnectFromSensorCore(sensor_h& sensorHandle)
 273 {
 274         int sensorResult = sensor_destroy(sensorHandle);
 275         if (!IsSuccess(sensorResult))
 276         {
 277                 // PARADOX
 278                 if(_AppInfo::GetApiVersion() == Tizen::Base::_API_VERSION_2_0 && _AppInfo::IsOspCompat())
 279                 {
 280                         SysAssertf(false, "DisconnectFromSensorCore() > sensor_destroy() failed. [handle:%p, result:%d]", sensorHandle, sensorResult);
 281                         SetLastResult(E_DEVICE_UNAVAILABLE);
 282                         return E_DEVICE_UNAVAILABLE;
 283                 }
 284                 else
 285                 {
 286                         SysAssertf(false, "DisconnectFromSensorCore() > sensor_destroy() failed. [handle:%p, result:%d]", sensorHandle, sensorResult);
 287                         SetLastResult(E_OPERATION_FAILED);
 288                         return E_OPERATION_FAILED;
 289                 }
 290         }
 291
 292         sensorHandle = null;
 293
 294         return E_SUCCESS;
 295 }
 296
 297 result
 298 PrepareSensorCoreEventSensing(sensor_h sensorHandle, _SensorCoreEventType eventType, long interval, void* pUserData)
 299 {
 300         int sensorResult = SENSOR_ERROR_NONE;
 301         switch (eventType)
 302         {
 303         case _SENSOR_CORE_EVENT_TYPE_ACCELERATION_DATA:
 304                 {
 305                         sensorResult = sensor_accelerometer_set_cb(sensorHandle, interval, OnAccelerationDataEventReceived, pUserData);
 306                         break;
 307                 }
 308         case _SENSOR_CORE_EVENT_TYPE_MAGNETIC_FIELD_DATA:
 309                 {
 310                         sensorResult = sensor_magnetic_set_cb(sensorHandle, interval, OnMagneticFieldDataEventReceived, pUserData);
 311                         break;
 312                 }
 313         case _SENSOR_CORE_EVENT_TYPE_PROXIMITY_DISTANCE_DATA:
 314                 {
 315                         sensorResult = sensor_proximity_set_cb(sensorHandle, interval, OnProximityDistanceDataEventReceived, pUserData);
 316                         break;
 317                 }
 318         case _SENSOR_CORE_EVENT_TYPE_TILT_DATA:
 319                 {
 320                         sensorResult = sensor_accelerometer_set_cb(sensorHandle, interval, OnTiltAccelerationDataEventReceived, pUserData);
 321                         if (!IsSuccess(sensorResult))
 322                         {
 323                                 break;
 324                         }
 325                         sensorResult = sensor_orientation_set_cb(sensorHandle, interval, OnTiltMagneticAzimuthDataEventReceived, pUserData);
 326                         if (!IsSuccess(sensorResult))
 327                         {
 328                                 sensor_accelerometer_unset_cb(sensorHandle);
 329                         }
 330                         break;
 331                 }
 332         case _SENSOR_CORE_EVENT_TYPE_ROTATION_RATE_DATA:
 333                 {
 334                         sensorResult = sensor_gyroscope_set_cb(sensorHandle, interval, OnRotationRateDataEventReceived, pUserData);
 335                         break;
 336                 }
 337         case _SENSOR_CORE_EVENT_TYPE_LIGHT_LEVEL_DATA:
 338                 {
 339                         sensorResult = sensor_light_set_cb(sensorHandle, interval, OnLightLevelDataEventReceived, pUserData);
 340                         break;
 341                 }
 342         case _SENSOR_CORE_EVENT_TYPE_ACCELERATION_SENSOR_WAKEUP:
 343                 {
 344                         sensorResult = sensor_awake_set_cb(sensorHandle, SENSOR_ACCELEROMETER, OnAccelerationSensorWakeupEventReceived, pUserData);
 345                         break;
 346                 }
 347         default:
 348                 {
 349                         // PARADOX
 350                         SysAssertf(false, "PrepareSensorCoreEventSensing() > [%s] PARADOX [eventType:%d]", GetErrorMessage(E_INVALID_ARG), eventType);
 351                         SetLastResult(E_INVALID_ARG);
 352                         return E_INVALID_ARG;
 353                 }
 354         }
 355
 356         if (!IsSuccess(sensorResult))
 357         {
 358                 // SENSOR_ERROR_IO_ERROR or SENSOR_ERROR_OPERATION_FAILED
 359                 if(_AppInfo::GetApiVersion() == Tizen::Base::_API_VERSION_2_0 && _AppInfo::IsOspCompat())
 360                 {
 361                         SysAssertf(false, "PrepareSensorCoreEventSensing() > sensor_xxx_set_cb() failed. [handle:%p, eventType:%d, interval:%ld, result:%d]", sensorHandle, eventType, interval, sensorResult);
 362                         SetLastResult(E_DEVICE_UNAVAILABLE);
 363                         return E_DEVICE_UNAVAILABLE;
 364                 }
 365                 else
 366                 {
 367                         SysAssertf(false, "PrepareSensorCoreEventSensing() > sensor_xxx_set_cb() failed. [handle:%p, eventType:%d, interval:%ld, result:%d]", sensorHandle, eventType, interval, sensorResult);
 368                         SetLastResult(E_OPERATION_FAILED);
 369                         return E_OPERATION_FAILED;
 370                 }
 371
 372         }
 373
 374         return E_SUCCESS;
 375 }
 376
 377 result
 378 UnprepareSensorCoreEventSensing(sensor_h sensorHandle, _SensorCoreEventType eventType)
 379 {
 380         int sensorResult = SENSOR_ERROR_NONE;
 381         switch (eventType)
 382         {
 383         case _SENSOR_CORE_EVENT_TYPE_ACCELERATION_DATA:
 384                 {
 385                         sensorResult = sensor_accelerometer_unset_cb(sensorHandle);
 386                         break;
 387                 }
 388         case _SENSOR_CORE_EVENT_TYPE_MAGNETIC_FIELD_DATA:
 389                 {
 390                         sensorResult = sensor_magnetic_unset_cb(sensorHandle);
 391                         break;
 392                 }
 393         case _SENSOR_CORE_EVENT_TYPE_PROXIMITY_DISTANCE_DATA:
 394                 {
 395                         sensorResult = sensor_proximity_unset_cb(sensorHandle);
 396                         break;
 397                 }
 398         case _SENSOR_CORE_EVENT_TYPE_TILT_DATA:
 399                 {
 400                         sensorResult = sensor_orientation_unset_cb(sensorHandle);
 401                         if (!IsSuccess(sensorResult))
 402                         {
 403                                 break;
 404                         }
 405                         sensorResult = sensor_accelerometer_unset_cb(sensorHandle);
 406                         break;
 407                 }
 408         case _SENSOR_CORE_EVENT_TYPE_ROTATION_RATE_DATA:
 409                 {
 410                         sensorResult = sensor_gyroscope_unset_cb(sensorHandle);
 411                         break;
 412                 }
 413         case _SENSOR_CORE_EVENT_TYPE_LIGHT_LEVEL_DATA:
 414                 {
 415                         sensorResult = sensor_light_unset_cb(sensorHandle);
 416                         break;
 417                 }
 418         case _SENSOR_CORE_EVENT_TYPE_ACCELERATION_SENSOR_WAKEUP:
 419                 {
 420                         sensorResult = sensor_awake_unset_cb(sensorHandle, SENSOR_ACCELEROMETER);
 421                         break;
 422                 }
 423         default:
 424                 {
 425                         // PARADOX
 426                         SysAssertf(false, "UnprepareSensorCoreEventSensing() > [%s] PARADOX [eventType:%d]", GetErrorMessage(E_INVALID_ARG), eventType);
 427                         SetLastResult(E_INVALID_ARG);
 428                         return E_INVALID_ARG;
 429                 }
 430         }
 431
 432         if (!IsSuccess(sensorResult))
 433         {
 434                 // SENSOR_ERROR_IO_ERROR or SENSOR_ERROR_OPERATION_FAILED
 435                 if(_AppInfo::GetApiVersion() == Tizen::Base::_API_VERSION_2_0 && _AppInfo::IsOspCompat())
 436                 {
 437                         SysAssertf(false, "UnprepareSensorCoreEventSensing() > sensor_xxx_unset_cb() failed. [handle:%p, eventType:%d, result:%d]", sensorHandle, eventType, sensorResult);
 438                         SetLastResult(E_DEVICE_UNAVAILABLE);
 439                         return E_DEVICE_UNAVAILABLE;
 440                 }
 441                 else
 442                 {
 443                         SysAssertf(false, "UnprepareSensorCoreEventSensing() > sensor_xxx_unset_cb() failed. [handle:%p, eventType:%d, result:%d]", sensorHandle, eventType, sensorResult);
 444                         SetLastResult(E_OPERATION_FAILED);
 445                         return E_OPERATION_FAILED;
 446                 }
 447
 448
 449         }
 450
 451         return E_SUCCESS;
 452 }
 453
 454 result
 455 StartSensorCoreEventSensing(sensor_h sensorHandle, _SensorCoreEventType eventType)
 456 {
 457         switch (eventType)
 458         {
 459         case _SENSOR_CORE_EVENT_TYPE_TILT_DATA:
 460                 {
 461                         int sensorResult = sensor_start(sensorHandle, SENSOR_ACCELEROMETER);
 462                         if (!IsSuccess(sensorResult))
 463                         {
 464                                 // SENSOR_ERROR_IO_ERROR or SENSOR_ERROR_OPERATION_FAILED
 465                                 if (_AppInfo::GetApiVersion() == Tizen::Base::_API_VERSION_2_0 && _AppInfo::IsOspCompat())
 466                                 {
 467                                         SysAssertf(false, "StartSensorCoreEventSensing() > sensor_start() failed. [handle:%p, sensorTypeE:%d, result:%d]", sensorHandle, SENSOR_ACCELEROMETER, sensorResult);
 468                                         SetLastResult(E_DEVICE_UNAVAILABLE);
 469                                         return E_DEVICE_UNAVAILABLE;
 470                                 }
 471                                 else
 472                                 {
 473                                         SysAssertf(false, "StartSensorCoreEventSensing() > sensor_start() failed. [handle:%p, sensorTypeE:%d, result:%d]", sensorHandle, SENSOR_ACCELEROMETER, sensorResult);
 474                                         SetLastResult(E_OPERATION_FAILED);
 475                                         return E_OPERATION_FAILED;
 476                                 }
 477                         }
 478
 479                         sensorResult = sensor_start(sensorHandle, SENSOR_ORIENTATION);
 480                         if (!IsSuccess(sensorResult))
 481                         {
 482                                 // SENSOR_ERROR_IO_ERROR or SENSOR_ERROR_OPERATION_FAILED
 483                                 sensor_stop(sensorHandle, SENSOR_ACCELEROMETER);
 484
 485                                 if(_AppInfo::GetApiVersion() == Tizen::Base::_API_VERSION_2_0 && _AppInfo::IsOspCompat())
 486                                 {
 487                                         SysAssertf(false, "StartSensorCoreEventSensing() > sensor_start() failed. [handle:%p, sensorTypeE:%d, result:%d]", sensorHandle, SENSOR_ORIENTATION, sensorResult);
 488                                         SetLastResult(E_DEVICE_UNAVAILABLE);
 489                                         return E_DEVICE_UNAVAILABLE;
 490                                 }
 491                                 else
 492                                 {
 493                                         SysAssertf(false, "StartSensorCoreEventSensing() > sensor_start() failed. [handle:%p, sensorTypeE:%d, result:%d]", sensorHandle, SENSOR_ORIENTATION, sensorResult);
 494                                         SetLastResult(E_OPERATION_FAILED);
 495                                         return E_OPERATION_FAILED;
 496                                 }
 497
 498                         }
 499                         sensorResult = sensor_set_always_on(sensorHandle, SENSOR_ACCELEROMETER);
 500                         if (!IsSuccess(sensorResult))
 501                         {
 502                                 // SENSOR_ERROR_IO_ERROR
 503                                 if (_AppInfo::GetApiVersion() == Tizen::Base::_API_VERSION_2_0 && _AppInfo::IsOspCompat())
 504                                 {
 505                                         SysAssertf(false, "StartSensorCoreEventSensing() > sensor_set_always_on() failed. [handle:%p, sensorTypeE:%d, result:%d]", sensorHandle, SENSOR_ACCELEROMETER, sensorResult);
 506                                         SetLastResult(E_DEVICE_UNAVAILABLE);
 507                                         return E_DEVICE_UNAVAILABLE;
 508                                 }
 509                                 else
 510                                 {
 511                                         SysAssertf(false, "StartSensorCoreEventSensing() > sensor_set_always_on() failed. [handle:%p, sensorTypeE:%d, result:%d]", sensorHandle, SENSOR_ACCELEROMETER, sensorResult);
 512                                         SetLastResult(E_OPERATION_FAILED);
 513                                         return E_OPERATION_FAILED;
 514                                 }
 515                         }
 516                         sensorResult = sensor_set_always_on(sensorHandle, SENSOR_ORIENTATION);
 517                         if (!IsSuccess(sensorResult))
 518                         {
 519                                 // SENSOR_ERROR_IO_ERROR
 520                                 if (_AppInfo::GetApiVersion() == Tizen::Base::_API_VERSION_2_0 && _AppInfo::IsOspCompat())
 521                                 {
 522                                         SysAssertf(false, "StartSensorCoreEventSensing() > sensor_set_always_on() failed. [handle:%p, sensorTypeE:%d, result:%d]", sensorHandle, SENSOR_ORIENTATION, sensorResult);
 523                                         SetLastResult(E_DEVICE_UNAVAILABLE);
 524                                         return E_DEVICE_UNAVAILABLE;
 525                                 }
 526                                 else
 527                                 {
 528                                         SysAssertf(false, "StartSensorCoreEventSensing() > sensor_set_always_on() failed. [handle:%p, sensorTypeE:%d, result:%d]", sensorHandle, SENSOR_ORIENTATION, sensorResult);
 529                                         SetLastResult(E_OPERATION_FAILED);
 530                                         return E_OPERATION_FAILED;
 531                                 }
 532
 533                         }
 534                         break;
 535                 }
 536         default:
 537                 {
 538                         sensor_type_e sensorTypeE = GetSensorTypeEFromSensorCoreEventType(eventType);
 539
 540                         int sensorResult = sensor_start(sensorHandle, sensorTypeE);
 541                         if (!IsSuccess(sensorResult))
 542                         {
 543                                 // SENSOR_ERROR_IO_ERROR or SENSOR_ERROR_OPERATION_FAILED
 544                                 if(_AppInfo::GetApiVersion() == Tizen::Base::_API_VERSION_2_0 && _AppInfo::IsOspCompat())
 545                                 {
 546                                         SysAssertf(false, "StartSensorCoreEventSensing() > sensor_start() failed. [handle:%p, sensorTypeE:%d, result:%d]", sensorHandle, sensorTypeE, sensorResult);
 547                                         SetLastResult(E_DEVICE_UNAVAILABLE);
 548                                         return E_DEVICE_UNAVAILABLE;
 549                                 }
 550                                 else
 551                                 {
 552                                         SysAssertf(false, "StartSensorCoreEventSensing() > sensor_start() failed. [handle:%p, sensorTypeE:%d, result:%d]", sensorHandle, sensorTypeE, sensorResult);
 553                                         SetLastResult(E_OPERATION_FAILED);
 554                                         return E_OPERATION_FAILED;
 555                                 }
 556                         }
 557                         sensorResult = sensor_set_always_on(sensorHandle, sensorTypeE);
 558                         if (!IsSuccess(sensorResult))
 559                         {
 560                                 // SENSOR_ERROR_IO_ERROR
 561                                 if (_AppInfo::GetApiVersion() == Tizen::Base::_API_VERSION_2_0 && _AppInfo::IsOspCompat())
 562                                 {
 563                                         SysAssertf(false, "StartSensorCoreEventSensing() > sensor_set_always_on() failed. [handle:%p, sensorTypeE:%d, result:%d]", sensorHandle, sensorTypeE, sensorResult);
 564                                         SetLastResult(E_DEVICE_UNAVAILABLE);
 565                                         return E_DEVICE_UNAVAILABLE;
 566                                 }
 567                                 else
 568                                 {
 569                                         SysAssertf(false, "StartSensorCoreEventSensing() > sensor_set_always_on() failed. [handle:%p, sensorTypeE:%d, result:%d]", sensorHandle, sensorTypeE, sensorResult);
 570                                         SetLastResult(E_OPERATION_FAILED);
 571                                         return E_OPERATION_FAILED;
 572                                 }
 573                         }
 574                         break;
 575                 }
 576         }
 577
 578         return E_SUCCESS;
 579 }
 580
 581 result
 582 StopSensorCoreEventSensing(sensor_h sensorHandle, _SensorCoreEventType eventType)
 583 {
 584         switch (eventType)
 585         {
 586         case _SENSOR_CORE_EVENT_TYPE_TILT_DATA:
 587                 {
 588                         int sensorResult = sensor_stop(sensorHandle, SENSOR_ORIENTATION);
 589                         if (!IsSuccess(sensorResult))
 590                         {
 591                                 // SENSOR_ERROR_IO_ERROR
 592                                 if (_AppInfo::GetApiVersion() == Tizen::Base::_API_VERSION_2_0 && _AppInfo::IsOspCompat())
 593                                 {
 594                                         SysAssertf(false, "StartSensorCoreEventSensing() > sensor_stop() failed. [handle:%p, sensorTypeE:%d, result:%d]", sensorHandle, SENSOR_ORIENTATION, sensorResult);
 595                                         SetLastResult(E_DEVICE_UNAVAILABLE);
 596                                         return E_DEVICE_UNAVAILABLE;
 597                                 }
 598                                 else
 599                                 {
 600                                         SysAssertf(false, "StartSensorCoreEventSensing() > sensor_stop() failed. [handle:%p, sensorTypeE:%d, result:%d]", sensorHandle, SENSOR_ACCELEROMETER, sensorResult);
 601                                         SetLastResult(E_OPERATION_FAILED);
 602                                         return E_OPERATION_FAILED;
 603                                 }
 604
 605                         }
 606
 607                         sensorResult = sensor_stop(sensorHandle, SENSOR_ACCELEROMETER);
 608                         if (!IsSuccess(sensorResult))
 609                         {
 610                                 if (_AppInfo::GetApiVersion() == Tizen::Base::_API_VERSION_2_0 && _AppInfo::IsOspCompat())
 611                                 {
 612                                         // SENSOR_ERROR_IO_ERROR
 613                                         SysAssertf(false, "StartSensorCoreEventSensing() > sensor_stop() failed. [handle:%p, sensorTypeE:%d, result:%d]", sensorHandle, SENSOR_ACCELEROMETER, sensorResult);
 614                                         SetLastResult(E_DEVICE_UNAVAILABLE);
 615                                         return E_DEVICE_UNAVAILABLE;
 616                                 }
 617                                 else
 618                                 {
 619                                         SysAssertf(false, "StartSensorCoreEventSensing() > sensor_stop() failed. [handle:%p, sensorTypeE:%d, result:%d]", sensorHandle, SENSOR_ACCELEROMETER, sensorResult);
 620                                         SetLastResult(E_OPERATION_FAILED);
 621                                         return E_OPERATION_FAILED;
 622                                 }
 623
 624                         }
 625                         break;
 626                 }
 627         default:
 628                 {
 629                         sensor_type_e sensorTypeE = GetSensorTypeEFromSensorCoreEventType(eventType);
 630
 631                         int sensorResult = sensor_stop(sensorHandle, sensorTypeE);
 632                         if (!IsSuccess(sensorResult))
 633                         {
 634                                 if (_AppInfo::GetApiVersion() == Tizen::Base::_API_VERSION_2_0 && _AppInfo::IsOspCompat())
 635                                 {
 636                                         SysAssertf(false, "StopSensorCoreEventSensing() > sensor_stop() failed. [handle:%p, sensorTypeE:%d, result:%d]", sensorHandle, sensorTypeE, sensorResult);
 637                                         SetLastResult(E_DEVICE_UNAVAILABLE);
 638                                         return E_DEVICE_UNAVAILABLE;
 639                                 }
 640                                 else
 641                                 {
 642                                         SysAssertf(false, "StopSensorCoreEventSensing() > sensor_stop() failed. [handle:%p, sensorTypeE:%d, result:%d]", sensorHandle, sensorTypeE, sensorResult);
 643                                         SetLastResult(E_OPERATION_FAILED);
 644                                         return E_OPERATION_FAILED;
 645                                 }
 646                                 // SENSOR_ERROR_IO_ERROR
 647                         }
 648                         break;
 649                 }
 650         }
 651
 652         return E_SUCCESS;
 653 }
 654
 655 result
 656 ResetSensorCoreDataEventSensingInterval(sensor_h sensorHandle, _SensorCoreEventType eventType, long interval)
 657 {
 658         int sensorResult = SENSOR_ERROR_NONE;
 659         switch (eventType)
 660         {
 661         case _SENSOR_CORE_EVENT_TYPE_ACCELERATION_DATA:
 662                 {
 663                         sensorResult = sensor_accelerometer_set_interval(sensorHandle, interval);
 664                         break;
 665                 }
 666         case _SENSOR_CORE_EVENT_TYPE_MAGNETIC_FIELD_DATA:
 667                 {
 668                         sensorResult = sensor_magnetic_set_interval(sensorHandle, interval);
 669                         break;
 670                 }
 671         case _SENSOR_CORE_EVENT_TYPE_PROXIMITY_DISTANCE_DATA:
 672                 {
 673                         sensorResult = sensor_proximity_set_interval(sensorHandle, interval);
 674                         break;
 675                 }
 676         case _SENSOR_CORE_EVENT_TYPE_TILT_DATA:
 677                 {
 678                         sensorResult = sensor_orientation_set_interval(sensorHandle, interval);
 679                         if (!IsSuccess(sensorResult))
 680                         {
 681                                 break;
 682                         }
 683                         sensorResult = sensor_accelerometer_set_interval(sensorHandle, interval);
 684                         break;
 685                 }
 686         case _SENSOR_CORE_EVENT_TYPE_ROTATION_RATE_DATA:
 687                 {
 688                         sensorResult = sensor_gyroscope_set_interval(sensorHandle, interval);
 689                         break;
 690                 }
 691         case _SENSOR_CORE_EVENT_TYPE_LIGHT_LEVEL_DATA:
 692                 {
 693                         sensorResult = sensor_light_set_interval(sensorHandle, interval);
 694                         break;
 695                 }
 696         default:
 697                 {
 698                         // PARADOX
 699                         SysAssertf(false, "ResetSensorCoreDataEventSensingInterval() > [%s] PARADOX [eventType:%d]", GetErrorMessage(E_INVALID_ARG), eventType);
 700                         SetLastResult(E_INVALID_ARG);
 701                         return E_INVALID_ARG;
 702                 }
 703         }
 704
 705         if (!IsSuccess(sensorResult))
 706         {
 707                 if (_AppInfo::GetApiVersion() == Tizen::Base::_API_VERSION_2_0 && _AppInfo::IsOspCompat())
 708                 {
 709                         SysAssertf(false, "ResetSensorCoreDataEventSensingInterval() > sensor_xxx_set_interval() failed. [handle:%p, eventType:%d, result:%d]", sensorHandle, eventType, sensorResult);
 710                         SetLastResult(E_DEVICE_UNAVAILABLE);
 711                         return E_DEVICE_UNAVAILABLE;
 712                 }
 713                 else
 714                 {
 715                         SysAssertf(false, "ResetSensorCoreDataEventSensingInterval() > sensor_xxx_set_interval() failed. [handle:%p, eventType:%d, result:%d]", sensorHandle, eventType, sensorResult);
 716                         SetLastResult(E_OPERATION_FAILED);
 717                         return E_OPERATION_FAILED;
 718                 }
 719                 // SENSOR_ERROR_IO_ERROR or SENSOR_ERROR_OPERATION_FAILED
 720
 721         }
 722
 723         return E_SUCCESS;
 724 }
 725 } // Anonymous
 726
 727 // Getting sensor information ------------------------------------------------------------------------------------------------ //
 728 bool
 729 _ISensorCore::IsSupported(SensorType sensorType)
 730 {
 731         sensor_type_e sensorTypeE = ConvertToSensorTypeEFromSensorType(sensorType);
 732
 733         bool isSupported = false;
 734         int sensorResult = sensor_is_supported(sensorTypeE, &isSupported);
 735         if (!IsSuccess(sensorResult))
 736         {
 737                 if (_AppInfo::GetApiVersion() == Tizen::Base::_API_VERSION_2_0 && _AppInfo::IsOspCompat())
 738                 {
 739                         SysAssertf(false, "IsSupported() > sensor_is_supported() failed. [sensorTypeE:%d, result:%d]", sensorTypeE, sensorResult);
 740                         SetLastResult(E_DEVICE_UNAVAILABLE);
 741                         return false;
 742                 }
 743                 else
 744                 {
 745                         SysAssertf(false, "IsSupported() > sensor_get_spec() failed. [sensorTypeE:%d, result:%d]", sensorTypeE, sensorResult);
 746                         SetLastResult(E_OPERATION_FAILED);
 747                         return false;
 748                 }
 749         }
 750
 751         return isSupported;
 752 }
 753
 754 result
 755 _ISensorCore::GetDescription(SensorType sensorType, Tizen::Base::String& description)
 756 {
 757         description = L"In preparation...";
 758         return E_SUCCESS;
 759 }
 760
 761 result
 762 _ISensorCore::GetVendor(SensorType sensorType, Tizen::Base::String& vendor)
 763 {
 764         switch (sensorType)
 765         {
 766         case SENSOR_TYPE_TILT:
 767                 {
 768 #if _OSP_EMUL_
 769                         vendor = W_MSG_EMUL_VENDOR;
 770 #else
 771                         vendor = W_MSG_NOT_SUPPORTED;
 772 #endif
 773                         break;
 774                 }
 775         default:
 776                 {
 777                         sensor_type_e sensorTypeE = ConvertToSensorTypeEFromSensorType(sensorType);
 778
 779                         char* pTempStrVendor = null;
 780                         char* pDummyStrModelId = null;
 781                         float dummyMax = 0.0F;
 782                         float dummyMin = 0.0F;
 783                         float dummyResolution = 0.0F;
 784                         int sensorResult = sensor_get_spec(sensorTypeE, &pTempStrVendor, &pDummyStrModelId, &dummyMax, &dummyMin, &dummyResolution);
 785                         if (!IsSuccess(sensorResult))
 786                         {
 787                                 // PARADOX
 788                                 if (_AppInfo::GetApiVersion() == Tizen::Base::_API_VERSION_2_0 && _AppInfo::IsOspCompat())
 789                                 {
 790                                         SysAssertf(false, "GetVendor() > sensor_get_spec() failed. [sensorTypeE:%d, result:%d]", sensorTypeE, sensorResult);
 791                                         SetLastResult(E_DEVICE_UNAVAILABLE);
 792                                         return E_DEVICE_UNAVAILABLE;
 793                                 }
 794                                 else
 795                                 {
 796                                         SysAssertf(false, "GetVendor() > sensor_get_spec() failed. [sensorTypeE:%d, result:%d]", sensorTypeE, sensorResult);
 797                                         SetLastResult(E_OPERATION_FAILED);
 798                                         return E_OPERATION_FAILED;
 799                                 }
 800
 801                         }
 802
 803                         vendor = pTempStrVendor;
 804
 805                         free(pTempStrVendor);
 806                         free(pDummyStrModelId);
 807
 808                         break;
 809                 }
 810         }
 811
 812         return E_SUCCESS;
 813 }
 814
 815 result
 816 _ISensorCore::GetModelId(SensorType sensorType, Tizen::Base::String& modelId)
 817 {
 818         switch (sensorType)
 819         {
 820         case SENSOR_TYPE_TILT:
 821                 {
 822 #if _OSP_EMUL_
 823                         modelId = W_MSG_EMUL_MODEL_ID_TILT;
 824 #else
 825                         modelId = W_MSG_NOT_SUPPORTED;
 826 #endif
 827                         break;
 828                 }
 829         default:
 830                 {
 831                         sensor_type_e sensorTypeE = ConvertToSensorTypeEFromSensorType(sensorType);
 832
 833                         char* pDummyStrVendor = null;
 834                         char* pTempStrModelId = null;
 835                         float dummyMax = 0.0F;
 836                         float dummyMin = 0.0F;
 837                         float dummyResolution = 0.0F;
 838                         int sensorResult = sensor_get_spec(sensorTypeE, &pDummyStrVendor, &pTempStrModelId, &dummyMax, &dummyMin, &dummyResolution);
 839                         if (!IsSuccess(sensorResult))
 840                         {
 841                                 // PARADOX
 842                                 if (_AppInfo::GetApiVersion() == Tizen::Base::_API_VERSION_2_0 && _AppInfo::IsOspCompat())
 843                                 {
 844                                         SysAssertf(false, "GetModelId() > sensor_get_spec() failed. [sensorTypeE:%d, result:%d]", sensorTypeE, sensorResult);
 845                                         SetLastResult(E_DEVICE_UNAVAILABLE);
 846                                         return E_DEVICE_UNAVAILABLE;
 847                                 }
 848                                 else
 849                                 {
 850                                         SysAssertf(false, "GetModelId() > sensor_get_spec() failed. [sensorTypeE:%d, result:%d]", sensorTypeE, sensorResult);
 851                                         SetLastResult(E_OPERATION_FAILED);
 852                                         return E_OPERATION_FAILED;
 853                                 }
 854
 855
 856
 857                         }
 858
 859                         modelId = pTempStrModelId;
 860
 861                         free(pDummyStrVendor);
 862                         free(pTempStrModelId);
 863
 864                         break;
 865                 }
 866         }
 867
 868         return E_SUCCESS;
 869 }
 870
 871 result
 872 _ISensorCore::GetMeasurementRange(SensorType sensorType, float& min, float& max, float& resolution)
 873 {
 874         switch (sensorType)
 875         {
 876         case SENSOR_TYPE_TILT:
 877                 {
 878                         min = MIN_VALUE_TILT;
 879                         max = MAX_VALUE_TILT;
 880                         resolution = RESOLUTION_VALUE_TILT;
 881                         break;
 882                 }
 883         default:
 884                 {
 885                         sensor_type_e sensorTypeE = ConvertToSensorTypeEFromSensorType(sensorType);
 886
 887                         char* pDummyStrVendor = null;
 888                         char* pDummyStrModelId = null;
 889                         float tempMax = 0.0F;
 890                         float tempMin = 0.0F;
 891                         float tempResolution = 0.0F;
 892                         int sensorResult = sensor_get_spec(sensorTypeE, &pDummyStrVendor, &pDummyStrModelId, &tempMax, &tempMin, &tempResolution);
 893                         if (!IsSuccess(sensorResult))
 894                         {
 895                                 // PARADOX
 896                                 if (_AppInfo::GetApiVersion() == Tizen::Base::_API_VERSION_2_0 && _AppInfo::IsOspCompat())
 897                                 {
 898                                         SysAssertf(false, "GetMeasurementRange() > sensor_get_spec() failed. [sensorTypeE:%d, result:%d]", sensorTypeE, sensorResult);
 899                                         SetLastResult(E_DEVICE_UNAVAILABLE);
 900                                         return E_DEVICE_UNAVAILABLE;
 901                                 }
 902                                 else
 903                                 {
 904                                         SysAssertf(false, "GetMeasurementRange() > sensor_get_spec() failed. [sensorTypeE:%d, result:%d]", sensorTypeE, sensorResult);
 905                                         SetLastResult(E_OPERATION_FAILED);
 906                                         return E_OPERATION_FAILED;
 907                                 }
 908
 909                         }
 910
 911                         free(pDummyStrVendor);
 912                         free(pDummyStrModelId);
 913
 914                         switch (sensorTypeE)
 915                         {
 916                         case SENSOR_ACCELEROMETER:
 917                                 min = tempMin * METER_PER_SECOND_SQUARE_TO_G;
 918                                 max = tempMax * METER_PER_SECOND_SQUARE_TO_G;
 919                                 resolution = tempResolution * METER_PER_SECOND_SQUARE_TO_G;
 920                                 break;
 921                         case SENSOR_GYROSCOPE:
 922                                 min = tempMin * DEGREE_TO_RADIAN;
 923                                 max = tempMax * DEGREE_TO_RADIAN;
 924                                 resolution = tempResolution * DEGREE_TO_RADIAN;
 925                                 break;
 926                         default:
 927                                 min = tempMin;
 928                                 max = tempMax;
 929                                 resolution = tempResolution;
 930                                 break;
 931                         }
 932                         break;
 933                 }
 934         }
 935
 936         return E_SUCCESS;
 937 }
 938
 939 result
 940 _ISensorCore::GetIntervalRange(SensorType sensorType, long& min, long& max)
 941 {
 942         sensor_type_e sensorTypeE = ConvertToSensorTypeEFromSensorType(sensorType);
 943
 944         int tempMin = 0;
 945         int tempMax = 0;
 946 //      int sensorResult = sensor_get_delay_boundary(sensorTypeE, &tempMin, &tempMax); // not implemented yet
 947         int sensorResult = GetStaticIntervalRange(sensorType, tempMin, tempMax);
 948         if (!IsSuccess(sensorResult))
 949         {
 950                 if (_AppInfo::GetApiVersion() == Tizen::Base::_API_VERSION_2_0 && _AppInfo::IsOspCompat())
 951                 {
 952                         SysAssertf(false, "GetIntervalRange() > sensor_get_delay_boundary() failed. [sensorTypeE:%d, result:%d]", sensorTypeE, sensorResult);
 953                         SetLastResult(E_DEVICE_UNAVAILABLE);
 954                         return E_DEVICE_UNAVAILABLE;
 955                 }
 956                 else
 957                 {
 958                         SysAssertf(false, "GetIntervalRange() > sensor_get_delay_boundary() failed. [sensorTypeE:%d, result:%d]", sensorTypeE, sensorResult);
 959                         SetLastResult(E_OPERATION_FAILED);
 960                         return E_OPERATION_FAILED;
 961                 }
 962                 // SENSOR_ERROR_IO_ERROR
 963
 964         }
 965
 966         min = tempMin;
 967         max = tempMax;
 968
 969         return E_SUCCESS;
 970 }
 971
 972 bool
 973 _ISensorCore::IsWakeupSupported(SensorType sensorType)
 974 {
 975         sensor_type_e sensorTypeE = ConvertToSensorTypeEFromSensorType(sensorType);
 976
 977         bool isWakeupSupported = false;
 978         int sensorResult = sensor_awake_is_supported(sensorTypeE, &isWakeupSupported);
 979         if (!IsSuccess(sensorResult))
 980         {
 981                 // SENSOR_ERROR_IO_ERROR
 982                 if (_AppInfo::GetApiVersion() == Tizen::Base::_API_VERSION_2_0 && _AppInfo::IsOspCompat())
 983                 {
 984                         SysAssertf(false, "IsWakeupSupported() > sensor_get_delay_boundary() failed. [sensorTypeE:%d, result:%d]", sensorTypeE, sensorResult);
 985                         SetLastResult(E_DEVICE_UNAVAILABLE);
 986                         return false;
 987                 }
 988                 else
 989                 {
 990                         SysAssertf(false, "IsWakeupSupported() > sensor_get_delay_boundary() failed. [sensorTypeE:%d, result:%d]", sensorTypeE, sensorResult);
 991                         SetLastResult(E_OPERATION_FAILED);
 992                         return false;
 993                 }
 994         }
 995
 996         return isWakeupSupported;
 997 }
 998
 999 bool
1000 _ISensorCore::IsObjectDetected(float distance)
1001 {
1002         bool isObjectDetected = false;
1003 //      int sensorResult = sensor_util_is_near(distance, &isNear);
1004         int sensorResult = IsStaticObjectDetected(distance, isObjectDetected);
1005         if (!IsSuccess(sensorResult))
1006         {
1007                 // PARADOX
1008                 if (_AppInfo::GetApiVersion() == Tizen::Base::_API_VERSION_2_0 && _AppInfo::IsOspCompat())
1009                 {
1010                         SysAssertf(false, "IsObjectDetected() > sensor_util_is_near() failed. [distance:%f, result:%d]", distance, sensorResult);
1011                         return false;
1012                 }
1013                 else
1014                 {
1015                         SysAssertf(false, "IsObjectDetected() > sensor_util_is_near() failed. [distance:%f, result:%d]", distance, sensorResult);
1016                         return false;
1017                 }
1018         }
1019
1020         return isObjectDetected;
1021 }
1022
1023 // Sensor event listener management ------------------------------------------------------------------------------------------ //
1024 result
1025 _ISensorCore::AddSensorCoreEventReceiver(_ISensorCoreEventReceiver& receiver)
1026 {
1027         // Connect
1028         sensor_h sensorHandle = null;
1029         result r = ConnectToSensorCore(sensorHandle);
1030         if (IsFailed(r))
1031         {
1032                 return r;
1033         }
1034
1035         // Prepare
1036         receiver.SetSensorCoreEventReceiverState(_ISensorCoreEventReceiver::SENSOR_CORE_EVENT_RECEIVER_STATE_CONNECTED);
1037         _SensorCoreEventType eventType = receiver.GetSensorCoreEventType();
1038         long interval = receiver.GetSensorCoreDataEventInterval();
1039         void* pUserData = &receiver;
1040         r = PrepareSensorCoreEventSensing(sensorHandle, eventType, interval, pUserData);
1041         if (IsFailed(r))
1042         {
1043                 DisconnectFromSensorCore(sensorHandle);
1044                 receiver.SetSensorCoreEventReceiverState(_ISensorCoreEventReceiver::SENSOR_CORE_EVENT_RECEIVER_STATE_NONE);
1045                 return r;
1046         }
1047
1048         // Start
1049         receiver.SetSensorCoreEventReceiverState(_ISensorCoreEventReceiver::SENSOR_CORE_EVENT_RECEIVER_STATE_PREPARED);
1050         receiver.SetSensorCoreEventHandle(sensorHandle);
1051         r = StartSensorCoreEventSensing(sensorHandle, eventType);
1052         if (IsFailed(r))
1053         {
1054                 receiver.SetSensorCoreEventHandle(null);
1055                 UnprepareSensorCoreEventSensing(sensorHandle, eventType);
1056                 DisconnectFromSensorCore(sensorHandle);
1057                 receiver.SetSensorCoreEventReceiverState(_ISensorCoreEventReceiver::SENSOR_CORE_EVENT_RECEIVER_STATE_NONE);
1058                 return r;
1059         }
1060
1061         receiver.SetSensorCoreEventReceiverState(_ISensorCoreEventReceiver::SENSOR_CORE_EVENT_RECEIVER_STATE_STARTED);
1062
1063         return E_SUCCESS;
1064 }
1065
1066 result
1067 _ISensorCore::RemoveSensorCoreEventReceiver(_ISensorCoreEventReceiver& receiver)
1068 {
1069         sensor_h sensorHandle = static_cast<sensor_h>(receiver.GetSensorCoreEventHandle());
1070         _SensorCoreEventType eventType = receiver.GetSensorCoreEventType();
1071         result r = E_SUCCESS;
1072
1073         // Stop
1074         if (receiver.GetSensorCoreEventReceiverState() == _ISensorCoreEventReceiver::SENSOR_CORE_EVENT_RECEIVER_STATE_STARTED)
1075         {
1076                 r = StopSensorCoreEventSensing(sensorHandle, eventType);
1077                 if (IsFailed(r))
1078                 {
1079                         return r;
1080                 }
1081
1082                 receiver.SetSensorCoreEventReceiverState(_ISensorCoreEventReceiver::SENSOR_CORE_EVENT_RECEIVER_STATE_PREPARED);
1083         }
1084
1085         // Unprepare
1086         if (receiver.GetSensorCoreEventReceiverState() == _ISensorCoreEventReceiver::SENSOR_CORE_EVENT_RECEIVER_STATE_PREPARED)
1087         {
1088                 r = UnprepareSensorCoreEventSensing(sensorHandle, eventType);
1089                 if (IsFailed(r))
1090                 {
1091                         return r;
1092                 }
1093
1094                 receiver.SetSensorCoreEventReceiverState(_ISensorCoreEventReceiver::SENSOR_CORE_EVENT_RECEIVER_STATE_CONNECTED);
1095         }
1096
1097         // Disconnect
1098         if (receiver.GetSensorCoreEventReceiverState() == _ISensorCoreEventReceiver::SENSOR_CORE_EVENT_RECEIVER_STATE_CONNECTED)
1099         {
1100                 r = DisconnectFromSensorCore(sensorHandle);
1101                 if (IsFailed(r))
1102                 {
1103                         return r;
1104                 }
1105
1106                 receiver.SetSensorCoreEventReceiverState(_ISensorCoreEventReceiver::SENSOR_CORE_EVENT_RECEIVER_STATE_NONE);
1107                 receiver.SetSensorCoreEventHandle(null);
1108         }
1109
1110         return E_SUCCESS;
1111 }
1112
1113 result
1114 _ISensorCore::ResetSensorCoreEventReceivingInterval(_ISensorCoreEventReceiver& receiver)
1115 {
1116         sensor_h sensorHandle = static_cast<sensor_h>(receiver.GetSensorCoreEventHandle());
1117         _SensorCoreEventType eventType = receiver.GetSensorCoreEventType();
1118         long interval = receiver.GetSensorCoreDataEventInterval();
1119
1120         result r = ResetSensorCoreDataEventSensingInterval(sensorHandle, eventType, interval);
1121         if (IsFailed(r))
1122         {
1123                 return r;
1124         }
1125
1126         return E_SUCCESS;
1127 }
1128
1129 // Sensor wake up management ------------------------------------------------------------------------------------------------- //
1130 result
1131 _ISensorCore::SetWakeupEnabled(SensorType sensorType, bool enable)
1132 {
1133
1134 #if _OSP_EMUL_
1135         return E_SUCCESS;
1136 #else
1137         // not implemented yet
1138         return E_DEVICE_UNAVAILABLE;
1139 #endif
1140 }
1141
1142 } } }// Tizen::Uix::Sensor