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