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